All Symbols¶

A¶

variable biquad_section<T>::a0 Denominator coefficient z^0
variable biquad_section<T>::a1 Denominator coefficient z^-1
variable iir_params<T, filters>::a1 Denominator coefficient z^-1 per section.
variable biquad_section<T>::a2 Denominator coefficient z^-2
variable iir_params<T, filters>::a2 Denominator coefficient z^-2 per section.
enum constant audiofile_error::abort Operation aborted
function histogram_data<Bins, TCount>::above() Returns the count of values that fell above the histogram range.
function abs(const T1 &) Returns the absolute value of x.
function abs(E1 &&) Creates an expression that returns the absolute value of x.
function absmax(const T1 &, const T2 &) Returns the greater in magnitude of two values.
function absmax(E1 &&, E2 &&) Creates an expression that returns the greater in magnitude of x and y.
function absmaxof(const E1 &) Returns the greatest in magnitude of all the elements in x.
function absmin(const T1 &, const T2 &) Returns the smaller in magnitude of two values.
function absmin(E1 &&, E2 &&) Creates an expression that returns the smaller in magnitude of x and y.
function absminof(const E1 &) Returns the smallest in magnitude of all the elements in x.
function compiletime::abs(T) Compile-time absolute value.
class abstract_reader<T> Base class for all typed readers
class abstract_stream<T> Base class for all typed readers and writer
destructor abstract_stream<T>::~abstract_stream<T>()
class abstract_vector<T, Tag> Generic 2D/3D container of univector rows, parameterized by the row storage tag.
class abstract_vector<T, tag_array_ref> Specialization of abstract_vector that only holds a non-owning reference to external data.
class abstract_vector<T, tag_dynamic_vector> Specialization of abstract_vector backed by a dynamically sized std::vector using KFR's data_allocator .
class abstract_writer<T> Base class for all typed writers
enum constant audiofile_error::access_denied Access to the file was denied
function tensor<T, NDims>::access(const shape_type &) Returns a reference to the element at indices.
function acos(const T1 &) Returns the arc cosine of x. The returned angle is in the range 0 through \(\pi\) .
function acos(E1 &&) Creates an expression that returns the arc cosine of x.
function shape<Dims>::adapt(const shape<indims> &, cbool_t<stop>) Adapt a higher-rank shape to the current rank for indexing.
function shape<0>::adapt(const shape<odims> &, cbool_t<stop>) Adapt any shape to a scalar; always returns the empty shape.
function shape<Dims>::add_at(index_t, cval_t<index_t, Axis>) Add value to the axis selected by the template parameter.
function shape<Dims>::add_shape_undef(const shape<dims> &, const shape<dims> &) Variant of add_shape that also propagates undefined_size .
function shape<Dims>::add_shape(const shape<dims> &, const shape<dims> &) Combine two shapes using the broadcasting rule max(max(x, y), x + y).
function shape<Dims>::add(const shape<dims> &) Element-wise addition of two shapes.
function add(const T &) Identity add (single argument).
function add(const T1 &, const T2 &, const Ts &...) Returns sum of all the arguments passed to a function.
function add(E &&...) Creates an expression that returns the sum of all the arguments passed to a function.
function shape<Dims>::add(index_t) Add value to the last axis.
function add(initialvalue<T>) Identity element for add (returns zero).
function addsub(const vec<T, N> &, const vec<T, N> &) Returns a vector with a+b in the low half and a-b in the high half.
function adjacent(Fn &&, E1 &&) Creates an expression that returns the result of calling \(fn(x_i, x_{i-1})\) .
function advance(T *, ptrdiff_t)
function advance(void *, ptrdiff_t)
enum constant audiofile_container::aiff
struct aiff_decoding_options Options for decoding AIFF audio files.
struct aiff_encoding_options Represents options for AIFF audio encoding.
enum constant audiofile_codec::alac
function align_down(T *, size_t)
function align_down(T, std::type_identity_t<T>)
function align_up(T *, size_t)
function align_up(T, std::type_identity_t<T>)
function aligned_allocate(size_t) Allocates aligned memory
function aligned_allocate(size_t, size_t) Allocates aligned memory
function aligned_deallocate(T *) Deallocates aligned memory
struct aligned_new
variable dft_plan<T>::all_stages Internal data.
function all(const mask<T, N> &) Returns true if all elements are true.
function tensor<T, NDims>::allocate(size_t) Allocates aligned memory for size elements.
function data_allocator<T>::allocate(size_type)
function special_scalar_constants<T>::allones() Returns a value with all bits set.
function special_scalar_constants<float>::allones() Returns a floating-point value with all bits set.
function special_scalar_constants<double>::allones() Returns a floating-point value with all bits set.
function special_scalar_constants<bit<T>>::allones() All bits set (true).
function allonesvector() Return a vector of the given type and size with all bits set to 1.
function allonesvector(vec_shape<T, N>) Return a vector matching the given shape with all bits set to 1.
function allonesvector(vec<T, N>) Return a vector matching the type of the given vector with all bits set to 1.
function special_scalar_constants<T>::allzeros() Returns a value with all bits cleared.
function special_scalar_constants<float>::allzeros() Returns positive zero, whose bits are all cleared.
function special_scalar_constants<double>::allzeros() Returns positive zero, whose bits are all cleared.
function special_scalar_constants<bit<T>>::allzeros() All bits cleared (false).
variable generator_expj<T, VecWidth>::alpha
variable generator_cossin<T, VecWidth>::alpha
variable generator_sin<T, VecWidth>::alpha
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).
union vec<T, N>::(Anonymous union at simd/vec.hpp:831:5)
function any(const mask<T, N> &) Returns true if any element is true.
enum constant open_file_mode::append_existing
function audio_data<IsInterleaved>::append(const audio_data<IsInterleaved> &) Appends samples from a buffer with the opposite layout.
function filter<T>::apply_zeros(T (&)[Size]) Feeds zero-valued samples to the filter and writes its tail to a fixed-size C array.
function filter<T>::apply_zeros(T *, size_t) Feeds size zero-valued samples to the filter and writes the resulting tail.
function filter<T>::apply_zeros(univector<T, Tag> &) Feeds zero-valued samples to the filter and writes its tail to a univector.
function apply(Fn &&) Generate a vector by calling a nullary function N times.
function apply(Fn &&, const T &, Args &&...) Apply a function to a scalar (pass-through overload).
function apply(Fn &&, const vec<T, N> &, Args &&...) Apply a scalar function element-wise to a vector.
function filter<T>::apply(T *, const expression_handle<T, 1> &, size_t) Evaluates src into a raw destination buffer through the filter.
function filter<T>::apply(T *, const Expr &, size_t) Evaluates the 1-dimensional expression src into a raw destination buffer through the filter.
function filter<T>::apply(T *, const T *, size_t) Applies the filter to a raw buffer and writes the result to another buffer.
function filter<T>::apply(T (&)[Size]) Applies the filter in-place to a fixed-size C array.
function filter<T>::apply(T *, size_t) Applies the filter in-place to a raw buffer.
function filter<T>::apply(T (&)[Size], T (&)[Size]) Applies the filter to a fixed-size C array and writes the result to another array.
function filter<T>::apply(univector<T, Tag> &) Applies the filter in-place to a univector.
function filter<T>::apply(univector<T, Tag1> &, const univector<T, Tag2> &) Applies the filter to a univector and writes the result to another univector.
function filter<T>::apply(univector<T, Tag> &, const Expr &) Evaluates the 1-dimensional expression src into dest through the filter.
function filter<T>::apply(univector<T, Tag> &, const expression_handle<T, 1> &) Evaluates src into dest through the filter.
function arange(T, cbool_t<truncated>) Creates an expression that returns integer values spanning [0, stop) with step 1.
function arange(T, T, T, cbool_t<truncated>) Creates an expression that returns values spanning [start, stop) with the given step.
variable dft_plan<T>::arblen True if Bluestein's FFT algorithm is selected.
typedef arg Alias that decays numeric/boolean argument types while preserving expression types unchanged.
variable expression_window_with_metrics<T, metrics>::arg
variable expression_with_arguments<Args>::args Tuple holding all arguments.
variable expression_with_arguments<Arg>::args Tuple holding the single argument.
typedef expression_traits<expression_slice<Arg>>::ArgTraits
typedef expression_traits<expression_cast<T, Arg>>::ArgTraits
typedef expression_padded<Arg>::ArgTraits
typedef expression_traits<expression_padded<Arg>>::ArgTraits
typedef expression_reverse<Arg>::ArgTraits
typedef expression_traits<expression_reverse<Arg>>::ArgTraits
typedef expression_fixshape<Arg, Shape>::ArgTraits
typedef expression_traits<expression_fixshape<Arg, fixed_shape_t<ShapeValues...>>>::ArgTraits
typedef expression_reshape<Arg, OutDims>::ArgTraits
typedef expression_traits<expression_reshape<Arg, OutDims>>::ArgTraits
typedef expression_delay<delay, E, stateless, STag>::ArgTraits
typedef expression_delay<1, E, stateless, STag>::ArgTraits
typedef expression_traits<expression_concatenate<Arg1, Arg2, ConcatAxis>>::ArgTraits1
typedef expression_traits<expression_concatenate<Arg1, Arg2, ConcatAxis>>::ArgTraits2
enum constant speaker_arrangement::Arr102 L, R, C, Lfe, Ls, Rs, Lc, Rc, Tfl, Tfr, Trl, Trr (10.2).
enum constant speaker_arrangement::Arr50 L, R, C, Ls, Rs (5.0).
enum constant speaker_arrangement::Arr51 L, R, C, Lfe, Ls, Rs (5.1).
function arrangement_for_channels(size_t) Returns a predefined speaker arrangement for a given number of channels.
function arrangement_speakers(speaker_arrangement) Returns the canonical channel list for a speaker arrangement.
function cvals_t<T, values>::array() Pointer to a static array holding all values
function cvals_t<T>::array() Pointer to the (empty) array (always nullptr)
class array_ref<T> Reference to array
constructor array_ref<T>::array_ref<T>()
constructor array_ref<T>::array_ref<T>(array_ref<T> &&)
constructor array_ref<T>::array_ref<T>(const array_ref<T> &)
function array_ref<T>::array_ref<T>(Container &&)
constructor array_ref<T>::array_ref<T>(std::initializer_list<T>)
constructor array_ref<T>::array_ref<T>(T *, size_type)
function array_to_string(const std::array<size_t, Dims> &, Getter &&, int, int, std::string_view, std::string_view, std::string_view) Render a multi-dimensional array as a nested, brace-delimited string.
function array_to_string(size_t, Getter &&, int, int, std::string_view, std::string_view, std::string_view) Convenience overload of array_to_string for a one-dimensional array accessed through a getter callable.
function array_to_string(size_t, T *, int, int, std::string_view, std::string_view, std::string_view) Convenience overload of array_to_string for a raw pointer buffer.
function i24::as_int() Reconstructs the signed 32-bit value, sign-extending from bit 23.
function as_string(const Args &...) Convert arbitrary values to a std::string using KFR's built-in formatting.
function asin(const T1 &) Returns the arc sine of x. The returned angle is in the range \(-\pi/2\) through \(\pi/2\) .
function asin(E1 &&) Creates an expression that returns the arc sine of x.
function vec<T, N>::asmask() Reinterpret the bits as a mask of the same shape.
macro ASSERT
function assertion_failed(const std::string &, const char *, int) Prints a failed assertion to stderr.
function univector_base<T, Class, true>::assign_expr(Input &&) Evaluates input and writes the result into the derived vector.
function small_buffer<T, Capacity>::assign(const small_buffer<T, Capacity> &) Replaces the contents with a copy of other.
function tensor<T, NDims>::assign(const T &) Fills the tensor with a scalar value.
function tensor<T, NDims>::assign(const tensor<T, NDims> &) Copies the contents of src into this tensor. Both tensors must have the same shape.
function tensor<T, NDims>::astype() Returns a tensor with elements converted to type U.
function vec<T, N>::asvec() Reinterpret a mask vector as a value vector (drops the bit wrapper).
function atan2(const T1 &, const T2 &) Returns the arc tangent of y/x using the signs of both arguments to determine the correct quadrant. The result is in the range \([-\pi, \pi]\) .
function atan2deg(const T1 &, const T2 &) Returns the arc tangent of y/x (expressed in degrees) using the signs of both arguments to determine the correct quadrant. The result is in the range [-180, 180].
function atan2deg(E1 &&, E2 &&) Creates an expression that returns the arc tangent of y/x (expressed in degrees).
function atan2(E1 &&, E2 &&) Creates an expression that returns the arc tangent of y/x.
function atan(const T1 &) Returns the arc tangent of x. The returned angle is in the range \(-\pi/2\) through \(\pi/2\) .
function atandeg(const T1 &) Returns the arc tangent of x, expressed in degrees. The returned angle is in the range -90 through 90.
function atandeg(E1 &&) Creates an expression that returns the arc tangent of x, expressed in degrees.
function atan(E1 &&) Creates an expression that returns the arc tangent of x.
function compound_type_traits<kfr::vec<T, N>>::at(const kfr::vec<T, N> &, size_t)
function compound_type_traits<std::complex<T>>::at(const std::complex<T> &, size_t) Returns the real ( index == 0) or imaginary ( index == 1) part of value.
function compound_type_traits<std::pair<T, T>>::at(const std::pair<subtype, subtype> &, size_t)
function compound_type_traits<T>::at(const T &, size_t)
function inline_vector<T, N>::at(size_type) Returns a const reference to the element at index with bounds checking.
function inline_vector<T, N>::at(size_type) Returns a reference to the element at index with bounds checking.
typedef audio_data_interleaved Alias for audio_data with interleaved storage.
typedef audio_data_planar Alias for audio_data with planar (non-interleaved) storage format.
class audio_data<IsInterleaved> Contiguous audio buffer with optional interleaving.
constructor audio_data<IsInterleaved>::audio_data<IsInterleaved>()
constructor audio_data<IsInterleaved>::audio_data<IsInterleaved>(audio_data<IsInterleaved> &&)
constructor audio_data<IsInterleaved>::audio_data<IsInterleaved>(const audio_data<!IsInterleaved> &) Converts between planar and interleaved layouts.
constructor audio_data<IsInterleaved>::audio_data<IsInterleaved>(fbase *, size_t, size_t) Constructs an interleaved audio_data view from an external buffer.
function audio_data<IsInterleaved>::audio_data<IsInterleaved>(fbase *, size_t, size_t, Fn &&) Constructs an interleaved audio_data view from an external buffer with a custom deallocator.
constructor audio_data<IsInterleaved>::audio_data<IsInterleaved>(size_t, size_t) Constructs an audio_data buffer with the specified channel count and optional initial size.
constructor audio_data<IsInterleaved>::audio_data<IsInterleaved>(size_t, size_t, fbase) Constructs an audio buffer and initializes all samples to a constant value.
constructor audio_data<IsInterleaved>::audio_data<IsInterleaved>(std::span<fbase *const>, size_t) Constructs a planar audio_data view from external channel pointers.
function audio_data<IsInterleaved>::audio_data<IsInterleaved>(std::span<fbase *const>, size_t, Fn &&) Constructs a planar audio_data view from external channel pointers with a custom deallocator.
struct audio_decoder Abstract base class for audio decoders providing methods for opening and reading audio files.
destructor audio_decoder::~audio_decoder()
constructor audio_decoder::audio_decoder()
struct audio_decoding_options Options for generic audio decoding.
enum audio_dithering Supported audio dithering methods.
struct audio_dithering_state Represents the state of audio dithering.
struct audio_encoder Abstract base class for audio encoders, providing methods for opening, writing, and closing audio files.
destructor audio_encoder::~audio_encoder() Destructor to close and finalize file encoding.
struct audio_encoding_options Represents options for audio encoding, including dithering settings.
struct audio_format
struct audio_format_and_length
constructor audio_format_and_length::audio_format_and_length()
constructor audio_format_and_length::audio_format_and_length(const audio_format &)
struct audio_quantization Represents audio quantization parameters.
constructor audio_quantization::audio_quantization(int, audio_dithering) Constructs quantization parameters for the given bit depth and dithering method.
struct audio_reader_flac<f32>
struct audio_reader_flac<f64>
struct audio_reader_flac<i16>
struct audio_reader_flac<i24>
struct audio_reader_flac<i32>
class audio_reader_flac<T> FLAC format reader
destructor audio_reader_flac<T>::~audio_reader_flac<T>()
constructor audio_reader_flac<T>::audio_reader_flac<T>(std::shared_ptr<abstract_reader<>> &&) Constructs FLAC reader
struct audio_reader_mp3<f32>
struct audio_reader_mp3<f64>
struct audio_reader_mp3<i16>
struct audio_reader_mp3<i24>
struct audio_reader_mp3<i32>
class audio_reader_mp3<T> MP3 format reader
destructor audio_reader_mp3<T>::~audio_reader_mp3<T>()
constructor audio_reader_mp3<T>::audio_reader_mp3<T>(std::shared_ptr<abstract_reader<>> &&) Constructs MP3 reader
struct audio_reader_wav<f32>
struct audio_reader_wav<f64>
struct audio_reader_wav<i16>
struct audio_reader_wav<i24>
struct audio_reader_wav<i32>
class audio_reader_wav<T> WAV format reader
destructor audio_reader_wav<T>::~audio_reader_wav<T>()
constructor audio_reader_wav<T>::audio_reader_wav<T>(std::shared_ptr<abstract_reader<>> &&) Constructs WAV reader
class audio_reader<T>
concept audio_sample Concept matching the C++ types accepted as audio samples.
function audio_sample_bit_depth(audio_sample_type) Returns the bit depth of the given audio sample type.
struct audio_sample_get_type<audio_sample_type::f32>
struct audio_sample_get_type<audio_sample_type::f64>
struct audio_sample_get_type<audio_sample_type::i16>
struct audio_sample_get_type<audio_sample_type::i24>
struct audio_sample_get_type<audio_sample_type::i32>
class audio_sample_get_type<type> Maps an audio_sample_type enumerator to its native C++ type.
function audio_sample_is_float(audio_sample_type) Reports whether the given sample type is floating point.
function audio_sample_sizeof(audio_sample_type) Returns the storage size in bytes of a sample of the given type.
struct audio_sample_traits<f32>
struct audio_sample_traits<f64>
struct audio_sample_traits<i16>
struct audio_sample_traits<i24>
struct audio_sample_traits<i32>
class audio_sample_traits<T> Compile-time properties of an audio sample C++ type.
enum audio_sample_type Identifies the numeric format of an audio sample.
typedef audio_sample_type_clist List of all supported audio sample types.
struct audio_stat Represents audio statistics such as peak and RMS values.
struct audio_writer_wav<f32>
struct audio_writer_wav<f64>
struct audio_writer_wav<i16>
struct audio_writer_wav<i24>
struct audio_writer_wav<i32>
class audio_writer_wav<T> WAV format writer
destructor audio_writer_wav<T>::~audio_writer_wav<T>()
constructor audio_writer_wav<T>::audio_writer_wav<T>(std::shared_ptr<abstract_writer<>> &&, const audio_format &) Constructs WAV writer using target writer and format
class audio_writer<T>
variable audio_writing_software Software string to write into metadata, if supported by format
enum audiofile_codec Supported audio file codecs.
enum audiofile_container Supported audio file container formats.
function audiofile_container_from_extension(std::string_view) Determines the audio container type from a file extension.
enum audiofile_endianness Endianness of audio data.
enum audiofile_error Enumerates possible error codes for audio file operations.
struct audiofile_format Represents the format of an audio file.
typedef audiofile_header Represents a fixed-size audio file header.
class autocast_impl<Tfrom> Helper returned by autocast that converts to any type via static_cast .
function autocast(const Tfrom &)
function autocorrelate(const univector<T, Tag1> &) Computes the auto-correlation of a real or complex signal.
class autofree<T> Smart pointer for aligned memory with automatic deallocation.
constructor autofree<T>::autofree<T>() Default constructor.
constructor autofree<T>::autofree<T>(autofree<T> &&)
constructor autofree<T>::autofree<T>(const autofree<T> &)
constructor autofree<T>::autofree<T>(size_t) Allocates aligned memory for given size.
enum constant cpu_t::avx
enum constant cpu_t::avx1
enum constant cpu_t::avx2
enum constant cpu_t::avx512
function aweighting(const T1 &) A-weighting filter response for a scalar frequency.
function aweighting(E1 &&) A-weighting filter response as an expression.
variable axis_params<Axis, N>::axis The axis index.
variable axis_params_v Inline variable form of axis_params for use in expressions.
class axis_params<Axis, N> Compile-time axis descriptor used by SIMD tensor accessors.
constructor axis_params<Axis, N>::axis_params<Axis, N>() Default-construct an axis parameter object.

B¶

enum constant datatype::b
variable biquad_section<T>::b0 Numerator coefficient z^0
variable iir_params<T, filters>::b0 Numerator coefficient z^0 per section.
variable biquad_section<T>::b1 Numerator coefficient z^-1
variable iir_params<T, filters>::b1 Numerator coefficient z^-1 per section.
variable biquad_section<T>::b2 Numerator coefficient z^-2
variable iir_params<T, filters>::b2 Numerator coefficient z^-2 per section.
typedef b8 Short names for common types
enum constant datatype::b8
function cvals_t<T, values>::back() Returns the last value
function portable_vec<T, N>::back()
function portable_vec<T, N>::back()
function vec<T, N>::back() Read the last element from a const lvalue vector.
function vec<T, N>::back() Read the last element from an rvalue vector.
function vec<T, N>::back() Access the last element of a non-const lvalue vector.
function expression_counter<T, Dims>::back()
function array_ref<T>::back()
function inline_vector<T, N>::back() Returns a reference to the last element.
function inline_vector<T, N>::back() Returns a const reference to the last element.
function small_buffer<T, Capacity>::back()
function small_buffer<T, Capacity>::back()
enum constant biquad_type::bandpass Passes frequencies inside a band.
enum constant biquad_type::bandstop Rejects frequencies inside a band.
enum constant window_type::bartlett
enum constant window_type::bartlett_hann
typedef shape<Dims>::base Underlying static array storing one index_t per axis.
typedef iir_params<T, tag_dynamic_vector>::base
typedef stride_pointer<T, groupsize>::base_type
function cvals_t<T, values>::begin() Iterator to the first value
function array_ref<T>::begin()
function inline_vector<T, N>::begin() Returns an iterator to the first element.
function inline_vector<T, N>::begin() Returns a const iterator to the first element.
function tensor<T, NDims>::begin() Returns an iterator to the first element.
function small_buffer<T, Capacity>::begin()
function small_buffer<T, Capacity>::begin()
function range<T>::begin()
enum constant seek_origin::begin From the beginning
function begin_pass(const expression_handle<T, NDims> &, shape<NDims>, shape<NDims>) Internal ADL-provided implementation for expression_handle expressions.
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 begin_pass(const expression_with_arguments<Args...> &, shape<Dims>, shape<Dims>) Notifies all arguments of an expression_with_arguments that a pass is beginning.
function begin_pass(const internal_generic::anything &, shape<Dims>, shape<Dims>) No-op pass begin/end hooks for the anything placeholder type.
function histogram_data<Bins, TCount>::below() Returns the count of values that fell below the histogram range.
function bessel(int) Analog Bessel/Thomson lowpass filter prototype (normalized cutoff = 1 rad/s).
variable generator_expj<T, VecWidth>::beta
variable generator_cossin<T, VecWidth>::beta
variable generator_sin<T, VecWidth>::beta
enum constant audiofile_endianness::big
function tensor<T, NDims>::binary_inplace(const tensor<U, dims> &, Fn &&) Applies a binary function element-wise with rhs in place.
typedef binary_reader Binary reader
typedef binary_writer Binary writer
function tensor<T, NDims>::binary(const tensor<U, dims> &, Fn &&) Applies a binary function element-wise with rhs and returns the resulting tensor.
function bind_expression(Fn &&, Args &&...) Constructs an expression_function from a callable and arguments.
function bind_func(Fn &&, Args &&...)
function biquad_allpass(std::type_identity_t<T>, std::type_identity_t<T>) Calculates coefficients for the all-pass biquad filter
function biquad_bandpass(std::type_identity_t<T>, std::type_identity_t<T>) Calculates coefficients for the band-pass biquad filter
function biquad_highpass(std::type_identity_t<T>, std::type_identity_t<T>) Calculates coefficients for the high-pass biquad filter
function biquad_highshelf(std::type_identity_t<T>, std::type_identity_t<T>) Calculates coefficients for the high-shelf biquad filter
function biquad_lowpass(std::type_identity_t<T>, std::type_identity_t<T>) Calculates coefficients for the low-pass biquad filter
function biquad_lowshelf(std::type_identity_t<T>, std::type_identity_t<T>) Calculates coefficients for the low-shelf biquad filter
function biquad_notch(std::type_identity_t<T>, std::type_identity_t<T>) Calculates coefficients for the notch biquad filter
function biquad_peak(std::type_identity_t<T>, std::type_identity_t<T>, std::type_identity_t<T>) Calculates coefficients for the peak biquad filter
class biquad_section<T> Structure for holding biquad filter coefficients.
constructor biquad_section<T>::biquad_section<T>() Default constructor: produces a pass-through section (a0=b0=1, rest 0).
function biquad_section<T>::biquad_section<T>(const biquad_section &) Converting copy constructor.
constructor biquad_section<T>::biquad_section<T>(T, T, T, T, T, T) Construct from explicit coefficient values.
class biquad_state<T, filters> Per-section delay-line state for a cascade of filters biquad sections.
constructor biquad_state<T, filters>::biquad_state<T, filters>() Default constructor: zero-initializes all registers.
enum biquad_type Type of biquad filter response used by coefficient design helpers.
variable audiofile_format::bit_depth Bits per sample.
function bitcast_anything(const Tin &)
function bitcast(const From &) Reinterpret the bits of value as type To .
function bitcast(const vec<From, N> &) Reinterpret the bits of a vector as a vector of a different element type.
class bitmask<bits> Holds an unsigned integer wide enough to store bits bits.
constructor bitmask<bits>::bitmask<bits>(type) Construct from a value of the underlying type.
function bitness_const(const char *, const char *) Selects between 32-bit and 64-bit compile-time constants.
function bitness_const(const T &, const T &) Selects between 32-bit and 64-bit compile-time constants.
function bitpermute(const vec<T, N> &) Permute the elements of a vector according to a bit permutation.
function bitreverse(const vec<T, N> &) Reorders the elements of a vector by reversing the bits of their indices.
function bitreverse(u32) Reverses the lowest bits bits of the given unsigned integer.
function bitreverse(u32, size_t) Reverses the lowest bits bits of the given unsigned integer at runtime.
variable typebits<T>::bits
typedef dft_plan<T>::bitset
class bit<T> Boolean value stored as a mask of type T (all-ones for true, all-zeros for false).
constructor bit<T>::bit<T>() Default constructor leaving the value uninitialized.
constructor bit<T>::bit<T>(bool) Construct from a bool, storing all-ones or all-zeros.
function bit<T>::bit<T>(const bit &) Convert a bit of another element type to this one.
constructor bit<T>::bit<T>(T)
function bitwiseand(const T1 &, const T2 &) Bitwise AND of x and y .
function bitwiseand(double, double)
function bitwiseand(float, float)
function bitwiseand(initialvalue<T>) Identity element for bitwiseand (returns all ones).
function bitwiseandnot(const T1 &, const T2 &) Bitwise AND-NOT of x and y .
function bitwiseandnot(double, double)
function bitwiseandnot(float, float)
function bitwiseandnot(initialvalue<T>) Identity element for bitwiseandnot (returns all ones).
function bitwisenot(const T1 &) Bitwise NOT of x .
function bitwisenot(double)
function bitwisenot(float)
function bitwiseor(const T1 &, const T2 &) Bitwise OR of x and y .
function bitwiseor(double, double)
function bitwiseor(float, float)
function bitwiseor(initialvalue<T>) Identity element for bitwiseor (returns zero).
function bitwisexor(const T1 &, const T2 &) Bitwise XOR (exclusive OR) of x and y .
function bitwisexor(double, double)
function bitwisexor(float, float)
function bitwisexor(initialvalue<T>) Identity element for bitwisexor (returns zero).
enum constant window_type::blackman
enum constant window_type::blackman_harris
function blend(const vec<T, N> &, const vec<T, N> &, elements_t<Indices...>) Blends lanes from x and y according to a repeating selector pattern.
variable iir_state<T, filters>::block_end End index of the current processing block.
function block_process(size_t, csizes_t<widths...>, Fn &&) Processes a range using a sequence of decreasing block widths.
variable convolve_filter<T>::block_size
variable dft_stage<T>::blocks Number of independent blocks processed by the stage.
enum constant window_type::bohman
enum constant dft_type::both Both direct and inverse transforms.
function broadcast(const Ts &...) Broadcasts a pack of scalar values into a vector of length Nout.
function broadcast(T) Broadcast a scalar to all N elements of a vector.
function broadcastto(const From &) Broadcast-cast a scalar to To (deep rebind).
function broadcastto(const vec<Tin, N> &) Broadcast-cast a vector to a different element type.
function broadcastto(const vec<Tin, N> &) Identity broadcast-cast for a vector (same element type).
function broadcastto(const vec<vec<Tin, N1>, N2> &) Broadcast-cast a nested vector to a different element type.
function broadcastto(const vec<vec<Tin, N1>, N2> &) Identity broadcast-cast for a nested vector (same element type).
function build_fmt_str(cchars_t<'@', chars...>, ctypes_t<Arg, Args...>) Build a compile-time format string: replace the leading '@' with the specifier for Arg and recurse on the remaining arguments.
function build_fmt_str(cchars_t<ch, chars...>, ctypes_t<Args...>) Build a compile-time format string: copy a literal character and recurse.
function build_fmt_str(cchars_t<>, ctypes_t<>) Build a compile-time printf format string from a literal template and argument types.
function butterworth(int) Analog Butterworth lowpass filter prototype (normalized cutoff = 1 rad/s).
enum constant audiofile_container::bw64 BW64 as per EBU Tech 3285 v2 (no metadata support yet)
function bweighting(const T1 &) B-weighting filter response for a scalar frequency.
function bweighting(E1 &&) B-weighting filter response as an expression.
typedef byte_reader Byte reader
typedef byte_writer Byte writer
function audiofile_format::bytes_per_pcm_frame()

C¶

variable special_value::c Active variant tag
enum constant datatype::c
enum constant speaker_type::C Alias for Center.
enum constant datatype::c32
typedef c32 Alias for complex<f32>
enum constant datatype::c64
typedef c64 Alias for complex<f64>
variable c_degtorad Degrees to radians conversion factor (π / 180).
variable c_e The mathematical constant e (Euler's number), scaled by m/d.
variable c_epsilon The machine epsilon — the smallest value such that 1 + epsilon ≠ 1.
variable c_infinity Positive infinity representation.
variable c_log_10 The natural logarithm of 10 (ln(10)).
variable c_log_2 The natural logarithm of 2 (ln(2)).
variable c_mantissa_bits The number of mantissa bits for the given floating-point type.
variable c_mantissa_mask The bitmask for the mantissa of the floating-point representation.
variable c_neginfinity Negative infinity representation.
variable c_pi The mathematical constant π (pi), scaled by m/d.
variable c_qnan A quiet NaN (Not-a-Number) value.
variable c_radtodeg Radians to degrees conversion factor (180 / π).
variable c_recip_log_10 The reciprocal of the natural logarithm of 10 (1 / ln(10)).
variable c_recip_log_2 The reciprocal of the natural logarithm of 2 (1 / ln(2)).
variable c_recip_pi The reciprocal of π (1/π), scaled by m/d.
variable c_sqr_pi The square of π (pi²), scaled by m/d.
variable c_sqrt_2 The square root of 2 (√2), scaled by m/d.
function cstring<N>::c_str()
function cabs(const T1 &) Returns the absolute value (magnitude) of the complex number x
function cabs(E1 &&) Creates an expression that returns the absolute value (magnitude) of the complex number x.
function cabssqr(const T1 &) Returns the squared absolute value (magnitude squared) of the complex number x
function cabssqr(E1 &&) Creates an expression that returns the squared absolute value (magnitude squared) of the complex number x.
enum constant audiofile_container::caf Apple CAF
struct caff_decoding_options Options for decoding CAFF audio files.
struct caff_encoding_options Represents options for CAFF audio encoding.
function dft_plan<T>::calc_disposition() Internal function
function tensor<T, NDims>::calc_index(const shape_type &) Computes the linear offset of the element at indices using the tensor's strides.
function window_linspace<T>::calc_p2(size_t, bool)
function window_linspace<T>::calc_p(size_t, bool)
variable caligned Instance of caligned_t.
typedef caligned_t Compile-time boolean tag selecting aligned access.
function call_with_temp(size_t, Fn &&) Calls a function with a temporary buffer, allocated on the stack if small enough, otherwise on the heap.
variable dft_stage<T>::can_inplace Whether the stage can operate in-place.
enum constant npy_decode_result::cannot_read Failed to read data or header
variable audio_data<IsInterleaved>::capacity Allocated capacity per channel.
function carg(const T1 &) Returns the phase angle (argument) of the complex number x
function carg(E1 &&) Creates an expression that returns the phase angle (argument) of the complex number x.
function cartesian(const T1 &) Converts a complex number from polar to cartesian representation
function cartesian(E1 &&) Creates an expression that converts a complex number to cartesian form.
function cast(Arg &&) Creates an expression that converts the values of arg to type T.
function cast(Arg &&, ctype_t<T>) Creates an expression that converts the values of arg to type T.
function cast(const From &) Cast a scalar value to To (deep rebind).
function cast(const vec<Tin, N> &) Cast a vector to a different element type.
function cast(const vec<Tin, N> &) Identity cast for a vector (same element type).
function cast(const vec<vec<Tin, N1>, N2> &) Cast a nested vector to a different element type.
function cast(const vec<vec<Tin, N1>, N2> &) Identity cast for a nested vector (same element type).
function catmullrom(M, T, T, T, T) Catmull-Rom spline interpolation.
typedef cbase Alias for complex<fbase>
function array_ref<T>::cbegin()
function inline_vector<T, N>::cbegin() Returns a const iterator to the first element.
function small_buffer<T, Capacity>::cbegin()
variable cbool
typedef cbool_t Compile-time boolean constant
variable cbools Constant instance of cbools_t<vals...>
typedef cbools_t Compile-time list of boolean values
function cbrt(const T1 &) Returns the cube root of x.
function cbrt(E1 &&) Creates an expression that returns the cube root of x.
variable cchars Constant instance of cchars_t<vals...>
typedef cchars_t Compile-time list of char values
function ccomp(const vec<T, N> &) Composes a vector of N/2 complex values from a flattened N-element real vector.
function cconcat(T1, Ts...) Returns a value of the concatenated list type
function cconj(const T1 &) Returns the complex conjugate of the complex number x
function cconj(E1 &&) Creates an expression that returns the complex conjugate of the complex number x.
function ccos(const T1 &) Returns the cosine of the complex number x
function ccos(E1 &&) Creates an expression that returns the cosine of the complex value x.
function ccosh(const T1 &) Returns the hyperbolic cosine of the complex number x
function ccosh(E1 &&) Creates an expression that returns the hyperbolic cosine of the complex value x.
variable ccpu Compile-time constant instance of ccpu_t .
typedef ccpu_t Compile-time wrapper around a cpu_t value.
enum constant dft_pack_format::CCs Conjugate-symmetric format: {DC, 0}, X[1], X[2], ..., X[N/2-1], {Nyquist, 0} The number of complex samples is
enum constant ::KFR_DFT_PACK_FORMAT::CCs Conjugate-complex symmetric format (N/2 + 1 complex values).
function cdecom(const vec<complex<T>, N> &) Decomposes a vector of N complex values into a flattened 2N-element real vector.
typedef cdirect_t Tag type selecting the direct (forward) DFT direction.
function cdupimag(const vec<complex<T>, N> &) Returns vector of complex values with imaginary part duplicated
function cdupreal(const vec<complex<T>, N> &) Returns vector of complex values with real part duplicated
function ceil(const T1 &) Returns the smallest integer value not less than x.
function ceil(E1 &&) Creates an expression that returns the smallest integer value not less than x.
function array_ref<T>::cend()
function inline_vector<T, N>::cend() Returns a const iterator to one past the last element.
function small_buffer<T, Capacity>::cend()
enum constant speaker_type::Center Front center.
function cexp10(const T1 &) Returns 10 raised to the complex number x
function cexp10(E1 &&) Creates an expression that returns 10 raised to the complex number x.
function cexp2(const T1 &) Returns 2 raised to the complex number x
function cexp2(E1 &&) Creates an expression that returns 2 raised to the complex number x.
function cexp(const T1 &) Returns e raised to the complex number x
function cexp(E1 &&) Creates an expression that returns \(e\) raised to the complex number x.
variable cfalse Constant instance of cfalse_t
typedef cfalse_t Compile-time false value type
variable cfalse_true Constant instance of
typedef cfilter_t Filters a cvals_t list, keeping only elements whose corresponding flag is
function cfilter(cvals_t<T, vals...>, cvals_t<bool, flags...>)
function cfind(cvals_t<T, values...>, std::type_identity_t<T>)
class cfor_t<stop, start, conditional> Compile-time for loop helper that unrolls iteration over [start, stop) .
variable cfor_v Constant instance of cfor_t<stop, start, conditional> used as the left-hand side of KFR_FOR / KFR_FORC .
function cfor(cval_t<T, start>, cval_t<T, stop>, BodyFn &&)
function cforeach(A0 &&, A1 &&, A2 &&, A3 &&, Fn &&) Invokes
function cforeach(A0 &&, A1 &&, A2 &&, Fn &&) Invokes
function cforeach(A0 &&, A1 &&, Fn &&)
function cforeach(const std::tuple<Ts...> &, Fn &&)
function cforeach(ctypes_t<Ts...>, Fn &&)
function cforeach(cvals_t<T, values...>, Fn &&)
function cforeach(T &&, Fn &&)
typedef chan Determines the channel type based on interleaving.
function audio_data<IsInterleaved>::channel_count() Retrieves the number of audio channels.
variable audio_format::channels
variable audiofile_format::channels Number of channels.
variable audio_data<IsInterleaved>::channels Number of channels.
function audio_data<IsInterleaved>::channel(size_t) Retrieves a reference to the audio data of a specific channel.
typedef opencl_names::char16
typedef opencl_names::char2
typedef opencl_names::char3
typedef opencl_names::char4
typedef opencl_names::char8
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 check_assertion(...) SFINAE fallback for non-comparison arguments.
function check_assertion(const comparison<Op, L, R> &, const char *, const char *, int) Evaluates a full comparison and reports it on failure.
function check_assertion(const half_comparison<L> &, const char *, const char *, int) Evaluates a half comparison (a bare boolean operand) and reports it on failure.
function choose_const() Selects the constant of the specific type from a list of candidates. Returns the candidate whose type matches T ; triggers a static_assert if T is not present.
function choose_const_fallback(C1) Single-argument fallback: converts
function choose_const_fallback(C1, Cs...)
function choose_const(C1, Cs...) Recursively skips candidates whose type does not match
function cif(cbool_t<false>, TrueFn &&, FalseFn &&) Compile-time conditional: invokes
function cif(cbool_t<true>, TrueFn &&, FalseFn &&)
variable cindex Variable template form of cindex_t .
typedef cindex_t Compile-time constant of type index_t .
enum constant speaker_arrangement::Cine30 L, R, C (cinema 3.0).
enum constant speaker_arrangement::Cine31 L, R, C, Lfe (cinema 3.1).
enum constant speaker_arrangement::Cine40 L, R, C, Cs (cinema 4.0).
enum constant speaker_arrangement::Cine41 L, R, C, Cs, Lfe (cinema 4.1).
enum constant speaker_arrangement::Cine60 L, R, C, Ls, Rs, Cs (cinema 6.0).
enum constant speaker_arrangement::Cine61 L, R, C, Lfe, Ls, Rs, Cs (cinema 6.1).
enum constant speaker_arrangement::Cine70 L, R, C, Ls, Rs, Lc, Rc (cinema 7.0).
enum constant speaker_arrangement::Cine71 L, R, C, Lfe, Ls, Rs, Lc, Rc (cinema 7.1).
enum constant speaker_arrangement::Cine80 L, R, C, Ls, Rs, Lc, Rc, Cs (cinema 8.0).
enum constant speaker_arrangement::Cine81 L, R, C, Lfe, Ls, Rs, Lc, Rc, Cs (cinema 8.1).
variable cint Constant instance of cint_t<val>
typedef cint_t Compile-time int constant
variable cintrange Constant instance of the int range
variable cints Constant instance of cints_t<vals...>
typedef cints_t Compile-time list of int values
variable cintseq Constant instance of an int sequence with
typedef cinvert_t Tag type selecting the inverse DFT direction.
function clamp(const T1 &, const T2 &) Returns the first argument clamped to a range [0, hi]
function clamp(const T1 &, const T2 &, const T3 &) Returns the first argument clamped to a range [lo, hi]
function clamp(E1 &&, E2 &&) Creates an expression that returns the first argument clamped to a range [0, hi]
function clamp(E1 &&, E2 &&, E3 &&) Creates an expression that returns the first argument clamped to a range [lo, hi]
function small_buffer<T, Capacity>::clear() Resets the buffer to zero elements, releasing any heap allocation.
function dft_cache_impl<int>::clear()
function audio_data<IsInterleaved>::clear() Clears all audio data, leaving the container empty (size == 0).
function clock_elapsed(uint64_t) Returns the elapsed time in seconds since start_time, based on clock_now .
function clock_frequency() Returns the number of ticks per second for the clock used in clock_now().
function clock_now() Returns the current value of the OS's highest-resolution monotonic clock. On modern hardware, these typically map to hardware instructions (RDTSC/CNTVCT_EL0) via user-mode shared pages, avoiding a heavy syscall context switch.
function clog10(const T1 &) Returns the common (base-10) logarithm of the complex number x
function clog10(E1 &&) Creates an expression that returns the common (base-10) logarithm of the complex number x.
function clog2(const T1 &) Returns the binary (base-2) logarithm of the complex number x
function clog2(E1 &&) Creates an expression that returns the binary (base-2) logarithm of the complex number x.
function clog(const T1 &) Returns the natural logarithm of the complex number x
function clog(E1 &&) Creates an expression that returns the natural logarithm of the complex number x.
function audio_writer<T>::close() Finishes writing and closes underlying writer
function audio_writer_wav<T>::close()
function audio_decoder::close() Closes the audio file and releases resources.
function audio_encoder::close() Closes the encoder and finalizes the file.
enum constant audiofile_error::closed The audio file is closed
function cmatch(T &&, Fn &&, Args...)
function cmaxof(cvals_t<T>) Returns the maximum value in the list (min of
function cmaxof(cvals_t<T, val, vals...>) Returns the maximum value in the list
function cminof(cvals_t<T>) Returns the minimum value in the list (max of
function cminof(cvals_t<T, val, vals...>) Returns the minimum value in the list
variable comparison<Fn, L, R>::cmp
struct cmp_eq
struct cmp_ge
struct cmp_gt
struct cmp_le
struct cmp_lt
struct cmp_ne
function cnegimag(const vec<complex<T>, N> &) Returns vector of complex values with imaginary part negated
function cnegreal(const vec<complex<T>, N> &) Returns vector of complex values with real part negated
variable audiofile_format::codec Audio codec.
variable expression_goertzel<T>::coeff Precomputed resonator coefficient
variable expression_parallel_goertzel<T, width>::coeff Precomputed coefficients
function column(const vec<vec<T, N1>, N2> &) Extracts a single column from a vector-of-vectors.
function combine(const vec<T, N1> &, const vec<T, N2> &) Combines two vectors by selecting lanes from x or y based on index.
enum constant cpu_t::common
variable platform<cpu_t::common>::common_float_vector_size
variable platform<cpu_t::common>::common_int_vector_size
class common_type_helper<T1, T2, N1, N2> Helper for std::common_type deduction between vectors and scalars.
class common_type_helper<T1, T2, N, N> Same-width vectors share a vec<common, N> common type.
class common_type_helper<T1, vec<T2, N2>, N1, N2> Scalar vs. vector of differing widths form a nested vec<vec<...>> .
class common_type_helper<vec<T1, N2>, T2, N1, N2> Vector vs. scalar of differing widths form a nested vec<vec<...>> .
class ::std::common_type<kfr::complex<T1>, kfr::complex<T2>> common_type of two kfr::complex values.
class ::std::common_type<kfr::complex<T1>, kfr::vec<T2, N>> common_type of a kfr::complex and a kfr::vec.
class ::std::common_type<kfr::complex<T1>, T2> common_type of a kfr::complex and a scalar.
class ::std::common_type<kfr::vec<T1, N1>, kfr::vec<T2, N2>>
class ::std::common_type<kfr::vec<T1, N>, kfr::complex<T2>> common_type of a kfr::vec and a kfr::complex.
class ::std::common_type<kfr::vec<T1, N>, T2>
class ::std::common_type<T1, kfr::complex<T2>> common_type of a scalar and a kfr::complex.
class ::std::common_type<T1, kfr::vec<T2, N>>
class comparison<Fn, L, R>
constructor comparison<Fn, L, R>::comparison<Fn, L, R>(L &&, R &&)
namespace compiletime
typedef complex Complex number type alias.
function dft_plan_real<T>::complex_size() Returns the number of complex samples produced/consumed.
function dft_plan_md_real<T, Dims>::complex_size() Returns the shape of the complex (packed) spectrum.
function dft_plan_md_real<T, Dims>::complex_size_for(shape<Dims>) Returns the complex spectrum shape for a given real shape.
function dft_plan_real<T>::complex_size_for(size_t, dft_pack_format) Returns the number of complex samples for a given real size and format.
class compound_type_traits<kfr::vec_shape<T, N>> compound_type_traits specialization for vec_shape<T, N> .
class compound_type_traits<kfr::vec<T, N>> compound_type_traits specialization for vec<T, N> .
class compound_type_traits<std::complex<T>> Traits specialization for std::complex<T> enabling KFR's compound-type machinery.
class compound_type_traits<std::pair<T, T>> Specialization of compound_type_traits for std::pair<T, T>
class compound_type_traits<T> Traits describing how a type composes scalar elements. Specialized for compound types (e.g. std::pair ) to expose width, subtype and accessors.
function dft_resampler<T>::compute_block_size(size_t, T, T) Computes the minimal power-of-two block size required for the given filter parameters (Kaiser formula).
function timestamps<max_count, fence>::compute_rdtsc_overhead() Measure and return the RDTSC read overhead in cycles.
function concat2(const vec<T, N1> &, const vec<T, N2> &) Concatenates two vectors into a single vector.
function concat4(const vec<T, N> &, const vec<T, N> &, const vec<T, N> &, const vec<T, N> &) Concatenates four equal-length vectors into a single vector.
function concat_and_slice(const vec<T, N1> &, const vec<T, N2> &) Concatenates two vectors of unequal length (first shorter) and extracts a slice.
function concat_and_slice(const vec<T, N> &, const vec<T, N> &) Concatenates two equal-length vectors and extracts a slice of length count.
function concat_args()
function concat_args(const std::string &, const Ts &...)
function concat_cstring()
function concat_cstring(const cstring<N1> &)
function concat_cstring(const cstring<N1> &, const cstring<N2> &, const Args &...)
typedef concat_lists Concatenates two or more cvals_t or ctypes_t lists into a single list
function expression_traits<expression_concatenate<Arg1, Arg2, ConcatAxis>>::concat_shape(const shape<dims> &, const shape<dims> &)
function concat(const vec<T, Ns> &...) Concatenates any number of vectors into a single vector.
function concatenate(Arg1 &&, Arg2 &&) Creates an expression that concatenates two input expressions along the given axis.
function concatenate(Arg1 &&, Arg2 &&, Arg3 &&) Creates an expression that concatenates three input expressions along the given axis.
variable cones Instance of cones_t.
struct cones_t Tag type selecting all-ones initialization.
variable audio_reader_mp3<T>::config
typedef tensor<T, NDims>::const_contiguous_iterator
typedef array_ref<T>::const_iterator
typedef inline_vector<T, N>::const_iterator
typedef tensor<T, NDims>::const_iterator
typedef struct_with_alignment<T, A>::const_pointer Const pointer to this wrapper type.
typedef struct_with_alignment<T, false>::const_pointer Const pointer to this wrapper type.
typedef array_ref<T>::const_pointer
typedef data_allocator<T>::const_pointer
typedef inline_vector<T, N>::const_pointer
typedef tensor<T, NDims>::const_pointer
typedef range<T>::const_pointer
typedef array_ref<T>::const_reference
typedef data_allocator<T>::const_reference
typedef inline_vector<T, N>::const_reference
typedef tensor_subscript<T, Derived, std::integer_sequence<index_t, Dims...>>::const_reference
typedef tensor<T, NDims>::const_reference
typedef range<T>::const_reference
typedef array_ref<T>::const_reverse_iterator
class constants<T> Constants for the SIMD type T , inheriting from the scalar constants of its element type.
class construct_common_type<CT, Tpl> Helper that maps a common-type result onto a single-argument template.
class construct_common_type<CT, Tpl>
variable audiofile_format::container Container format.
typedef container_value_type
function tensor<T, NDims>::contiguous_begin() Returns a contiguous iterator to the first element. The tensor must be contiguous.
function tensor<T, NDims>::contiguous_begin_unsafe() Returns a contiguous iterator to the first element without checking contiguity.
function tensor<T, NDims>::contiguous_end() Returns a contiguous iterator past the last element. The tensor must be contiguous.
function tensor<T, NDims>::contiguous_end_unsafe() Returns a contiguous iterator past the last element without checking contiguity.
typedef tensor<T, NDims>::contiguous_iterator
function convert_endianness(T *, size_t) Reverses the byte order (endianness) of a contiguous array of values in place.
function convert_sample(const Tin &) Converts a single audio sample between two different native types.
function convert(Tout *, const Tin *, size_t) Converts audio samples between two compile-time-known formats.
function convert(Tout *, const void *, audio_sample_type, size_t) Converts audio samples whose input format is selected at runtime.
function convert(void *, audio_sample_type, const Tin *, size_t) Converts audio samples whose output format is selected at runtime.
class convolve_filter<T> Streaming convolution filter using the overlap-add (block convolution) method.
constructor convolve_filter<T>::convolve_filter<T>(const univector_ref<const T> &, size_t) Constructs a filter and initializes its kernel from data .
constructor convolve_filter<T>::convolve_filter<T>(size_t, size_t) Constructs a filter with a kernel of the given length (initially zero).
function convolve(const univector<T1, Tag1> &, const univector<T2, Tag2> &) Computes the linear convolution of two real or complex signals.
function tensor<T, NDims>::copy() Returns a deep copy of the tensor.
function tensor<T, NDims>::copy_from(const tensor<T, NDims> &) Copies the contents of other into this tensor.
function dft_stage<T>::copy_input(bool, complex<T> *, const complex<T> *, size_t) Copies the input into the stage's working buffer.
function copysign(const vec<T, N> &, const vec<T, N> &) Compose x with the magnitude of x and the sign of y .
function correlate(const univector<T1, Tag1> &, const univector<T2, Tag2> &) Computes the linear correlation of two real or complex signals.
function cos2x(const T &, const T &) Returns cos(2x) from already computed sin(x) and cos(x).
function cos3x(const T &, const T &) Returns cos(3x) from already computed sin(x) and cos(x).
function cos(const T1 &) Returns the trigonometric cosine of x, evaluated in radians.
function cosdeg(const T1 &) Returns the trigonometric cosine of the angle expressed in degrees.
function cosdeg(E1 &&) Creates an expression that returns the trigonometric cosine of x (expressed in degrees).
function cos(E1 &&) Creates an expression that returns the trigonometric cosine of x.
function cosh(const T1 &) Returns the hyperbolic cosine of x.
function cosh(E1 &&) Creates an expression that returns the hyperbolic cosine of x.
function coshsinh(const T1 &) Computes cosh and sinh of x in a single pass and interleaves the results.
function coshsinh(E1 &&) Creates an expression that returns the hyperbolic cosine of the even elements of x and the hyperbolic sine of the odd elements of x.
enum constant window_type::cosine
enum constant window_type::cosine_np
function cosine(M, T, T) Cosine interpolation.
function cossin(const T1 &) Returns the trigonometric cosine of the even elements of x and sine of the odd elements.
function cossindeg(const T1 &) Returns the trigonometric cosine of the even elements and sine of the odd elements of x, where x is a vector of angles expressed in degrees.
function cossindeg(E1 &&) Creates an expression that returns the trigonometric cosine of the even elements of x and sine of the odd elements. x must be expressed in degrees.
function cossin(E1 &&) Creates an expression that returns the trigonometric cosine of the even elements of x and sine of the odd elements. x must be a vector.
function compiletime::cos(T) Compile-time cosine, derived from sin .
function coth(const T1 &) Returns the hyperbolic cotangent of x.
function coth(E1 &&) Creates an expression that returns the hyperbolic cotangent of x.
variable expression_with_arguments<Args>::count Number of arguments held by the expression.
variable expression_with_arguments<Arg>::count Number of arguments held by the expression (always 1).
variable expression_unpack<E>::count
function ebu_r128<T>::count() Return the number of channels.
variable timestamps<max_count, fence>::count Number of checkpoints currently stored in dur / msg .
variable expression_reduce<Tout, Dims, Twork, Tin, ReduceFn, TransformFn, FinalFn>::counter
function counter(T) Creates a 1-D expression_counter with step 1.
function counter(T, Arg, Args...) Creates an N-dimensional expression_counter with one step per dimension.
function cprod(cvals_t<T>) Returns the product of all values in the list (1 for an empty list)
function cprod(cvals_t<T, first, rest...>) Returns the product of all values in the list
variable cpu_all Compile-time list of all CPU instruction sets supported by the current architecture that are not newer than cpu_t::native .
struct cpu_features Detected x86 CPU capabilities and identifying strings.
function cpu_name(cpu_t) Returns the name of the given CPU instruction set.
function cpu_runtime() Returns the current CPU name at runtime.
enum cpu_t Enumeration representing a CPU instruction set.
variable cpuval Compile-time constant instance of cpuval_t .
typedef cpuval_t Compile-time wrapper around a cpu_t value (alias).
function create_aiff_decoder(const aiff_decoding_options &) Creates a decoder for AIFF audio files.
function create_aiff_encoder(const aiff_encoding_options &) Creates an AIFF audio encoder with optional encoding options.
function create_caff_decoder(const caff_decoding_options &) Creates a decoder for CAFF audio files.
function create_caff_encoder(const caff_encoding_options &) Creates a CAFF audio encoder with optional encoding options.
function create_decoder_for_container(audiofile_container, const audio_decoding_options &) Creates an audio decoder for a specific container type.
function create_decoder_for_file(const file_path &, const audio_decoding_options &) Creates an audio decoder for a file.
function create_decoder_from_header(const audiofile_header &, const audio_decoding_options &) Creates an audio decoder from a file header.
function create_encoder_for_container(audiofile_container, const audio_encoding_options &) Creates an audio encoder for the specified container format with optional encoding options.
function create_flac_decoder(const flac_decoding_options &) Creates a decoder for FLAC audio files.
function create_flac_encoder(const flac_encoding_options &) Creates a FLAC audio encoder with optional encoding options.
function create_mp3_decoder(const mp3_decoding_options &) Creates an MP3 audio decoder with the specified decoding options.
function create_raw_decoder(const raw_decoding_options &) Creates a decoder for raw audio streams.
function create_raw_encoder(const raw_encoding_options &) Creates a raw audio encoder with optional encoding options.
function create_w64_decoder(const w64_decoding_options &) Creates a decoder for W64 audio files.
function create_w64_encoder(const w64_encoding_options &) Creates a W64 audio encoder with optional encoding options.
function create_wave_decoder(const wave_decoding_options &) Creates a decoder for WAVE audio files.
function create_wave_encoder(const wave_encoding_options &) Creates a WAVE audio encoder with optional encoding options.
function univector_base<T, Class, true>::cref() Returns a const reference to the underlying data.
function univector_base<T, Class, false>::cref() Returns a const reference to the underlying data.
enum constant speaker_type::Cs Alias for S (center surround).
variable convolve_filter<T>::cscratch
function csin(const T1 &) Returns the sine of the complex number x
function csin(E1 &&) Creates an expression that returns the sine of the complex value x.
function csinh(const T1 &) Returns the hyperbolic sine of the complex number x
function csinh(E1 &&) Creates an expression that returns the hyperbolic sine of the complex number x.
variable csize Constant instance of csize_t<val>
typedef csize_t Compile-time size_t constant
variable csizerange Constant instance of the size_t range
variable csizes Constant instance of csizes_t<vals...>
typedef csizes_t Compile-time list of size_t values
variable csizeseq Constant instance of csizeseq_t with
typedef csizeseq_t Compile-time sequence of size_t values
function csqr(const T1 &) Returns square of the complex number x
function csqr(E1 &&) Creates an expression that returns the square of the complex number x.
function csqrt(const T1 &) Returns square root of the complex number x
function csqrt(E1 &&) Creates an expression that returns the square root of the complex number x.
class cstring<N>
function csum(cvals_t<T>) Returns the sum of all values in the list (0 for an empty list)
function csum(cvals_t<T, first, rest...>) Returns the sum of all values in the list
function cswapreim(const vec<complex<T>, N> &) Returns vector of complex values with real and imaginary parts swapped
function cswitch(cvals_t<T>, std::type_identity_t<T>, Fn &&, DefFn &&, CmpFn &&) Switch over an empty list: always invokes the default handler
function cswitch(cvals_t<T, v0, values...>, std::type_identity_t<T>, Fn &&, DefFn &&, CmpFn &&)
function cswitch(cvals_t<T, vs...>, const U &, Function &&, Fallback &&)
function ctranspose(const vec<T, N> &) Complex transpose: transposes pairs of adjacent lanes viewed as complex (real, imag).
function ctransposeinverse(const vec<T, N> &) Inverse complex transpose.
variable ctrue Constant instance of ctrue_t
typedef ctrue_t Compile-time true value type
variable ctype Constant instance of ctype_t<T>
function ctype_name()
class ctype_t<T> Compile-time wrapper for a single type. Used to pass types as values in metaprogramming contexts.
function ctypeid() Gets unique value associated with the type
function ctypeid(T) Gets unique value associated with the type
variable ctypes Constant instance of ctypes_t<Ts...>
class ctypes_t<Ts> Compile-time list of types.
function cub(const T1 &) Returns cube of x.
function cub(E1 &&) Creates an expression that returns the cube of x.
function cubic(M, T, T, T, T) Cubic interpolation.
variable cuint Constant instance of cuint_t<val>
typedef cuint_t Compile-time unsigned constant
variable cuintrange Constant instance of the unsigned range
variable cuints Constant instance of cuints_t<vals...>
typedef cuints_t Compile-time list of unsigned values
variable cuintseq Constant instance of an unsigned sequence with
variable cunaligned Instance of cunaligned_t.
typedef cunaligned_t Compile-time boolean tag selecting unaligned access.
variable cursor<Dims>::current Current multi-dimensional index.
enum constant seek_origin::current From the current position
function current_epsilon()
variable delay_state<T, samples, Tag>::cursor
class cursor<Dims> Multi-dimensional iteration cursor.
variable dft_resampler_params::cutoff Normalised cutoff frequency (0..1], where 1.0 = Nyquist of the output rate.
variable cval Constant instance of cval_t<T, val>
class cval_t<T, val> Compile-time constant wrapper carrying a value of type T . Usable as a non-type template parameter and convertible to its underlying value.
constructor cval_t<T, val>::cval_t<T, val>()
constructor cval_t<T, val>::cval_t<T, val>(const cval_t<T, val> &)
constructor cval_t<T, val>::cval_t<T, val>(cval_t<T, val> &&)
variable cvalrange Constant instance of the value range
variable cvals Constant instance of cvals_t<T, values...>
class cvals_t<T> Empty specialization of cvals_t.
class cvals_t<T, values> Compile-time list of constant values of type T . Supports indexing, slicing, mapping and equality comparison at compile time.
constructor cvals_t<T, values>::cvals_t<T, values...>()
variable cvalseq Constant instance of cvalseq_t with
typedef cvalseq_t Compile-time arithmetic sequence of size values starting at start with step step .
function cweighting(const T1 &) C-weighting filter response for a scalar frequency.
function cweighting(E1 &&) C-weighting filter response as an expression.
variable cwindow_type Compile-time window type value
typedef cwindow_type_t Compile-time window type tag
variable czeros Instance of czeros_t.
struct czeros_t Tag type selecting zero-initialization.

D¶

variable special_value::d Stored floating-point literal
variable epsilon_scope<void>::d
function cstring<N>::data()
variable expression_adjacent<Fn, E>::data
function array_ref<T>::data()
function autofree<T>::data() Returns pointer to underlying data.
function autofree<T>::data() Returns const pointer to underlying data.
function inline_vector<T, N>::data() Returns a pointer to the underlying element storage.
function inline_vector<T, N>::data() Returns a const pointer to the underlying element storage.
function tensor<T, NDims>::data() Returns a pointer to the underlying data.
variable expression_histogram<Bins, E, TCount>::data
function small_buffer<T, Capacity>::data()
function small_buffer<T, Capacity>::data()
variable dft_stage<T>::data Pointer to the stage's internal data buffer.
variable dft_plan<T>::data Internal data.
variable delay_state<T, samples, Tag>::data
variable delay_state<T, 1, 1>::data
variable strided_channel<T>::data Pointer to the first sample of the channel.
variable audio_data<IsInterleaved>::data Pointers to channel data.
class data_allocator<T> Aligned allocator
constructor data_allocator<T>::data_allocator<T>()
constructor data_allocator<T>::data_allocator<T>(const data_allocator<T> &)
function data_allocator<T>::data_allocator<T>(const data_allocator &)
variable dft_stage<T>::data_size Size in bytes of the stage's internal data (e.g. twiddles).
variable dft_plan<T>::data_size Internal data size.
variable convolve_filter<T>::data_size
enum datatype An enumeration representing data type
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 dB_to_string(const T &, double) Converts dB value to string (uses oo for infinity symbol)
function dB_to_utf8string(const T &, double) Converts dB value to string (uses infinity symbol in utf-8 encoding)
function dcremove(E1 &&, double)
function dcremove(E1 &&, double, double) Applies a DC removal filter to the given input expression.
class dct_plan<T> Plan for computing the Discrete Cosine Transform (DCT type 2, unscaled).
constructor dct_plan<T>::dct_plan<T>(size_t) Constructs a DCT plan for the given size.
function data_allocator<T>::deallocate(pointer, size_type)
function tensor<T, NDims>::deallocate(T *) Deallocates memory previously returned by allocate().
variable audio_data<IsInterleaved>::deallocator Deallocator for the data.
typedef decay_common Decays to the common type of the supplied arguments after decay.
variable samplerate_converter<T>::decimation_factor Decimation factor.
function 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 deep_is_equal(const T1 &, const T2 &)
typedef compound_type_traits<T>::deep_rebind
typedef compound_type_traits<std::pair<T, T>>::deep_rebind
typedef compound_type_traits<kfr::vec_shape<T, N>>::deep_rebind
typedef compound_type_traits<kfr::vec<T, N>>::deep_rebind
typedef compound_type_traits<std::complex<T>>::deep_rebind Rebinds the complex to hold values of the deep-rebound subtype of
typedef compound_type_traits<T>::deep_subtype
typedef deep_subtype The deepest scalar subtype of a (possibly nested) compound type
typedef compound_type_traits<std::pair<T, T>>::deep_subtype
typedef compound_type_traits<kfr::vec_shape<T, N>>::deep_subtype
typedef compound_type_traits<kfr::vec<T, N>>::deep_subtype
typedef compound_type_traits<std::complex<T>>::deep_subtype Deepest scalar component type after full recursion.
variable compound_type_traits<T>::deep_width
variable compound_type_traits<std::pair<T, T>>::deep_width
variable compound_type_traits<kfr::vec_shape<T, N>>::deep_width
variable compound_type_traits<kfr::vec<T, N>>::deep_width
variable compound_type_traits<std::complex<T>>::deep_width Width after fully recursing into the subtype.
variable default_audio_frames_to_read The default number of audio frames to read in one operation.
enum constant special_constant::default_constructed value-initialized
variable default_dft_algorithm
variable default_memory_alignment
variable scalar_constants<T>::degtorad Degrees to radians conversion factor (π / 180).
function deinterleave(Tout **, const Tin *, size_t, size_t) Deinterleaves and converts audio samples from a single buffer.
function deinterleave(univector2d<Tout, Tag1, Tag2> &, const univector<Tin, Tag3> &) Deinterleaves and converts audio samples into a 2D univector.
variable samplerate_converter<T>::delay Delay line buffer.
class delay_state<T, 1, 1>
class delay_state<T, samples, Tag>
constructor delay_state<T, samples, Tag>::delay_state<T, samples, Tag>()
function delay(delay_state<T, samples, STag> &, E1 &&) Returns template expression that applies delay to the input (uses ring buffer in state)
function delay(E1 &&) Returns template expression that applies delay to the input (uses ring buffer internally)
function delay(E1 &&, std::reference_wrapper<delay_state<T, samples, STag>>) Returns template expression that applies delay to the input (uses ring buffer in state)
variable short_fir_state<tapcount, T, U>::delayline Delay line holding the last
variable fir_state<T, U>::delayline Ring-buffer delay line of length
variable moving_sum_state<U, Tag>::delayline Ring buffer holding the window contents.
variable moving_sum_state<U, tag_dynamic_vector>::delayline Ring buffer holding the window contents.
variable fir_state<T, U>::delayline_cursor Current write cursor into
variable fraction::denominator Denominator of the fraction (always positive after normalization).
variable compound_type_traits<T>::depth
variable compound_type_traits<std::pair<T, T>>::depth
variable compound_type_traits<kfr::vec_shape<T, N>>::depth
variable compound_type_traits<kfr::vec<T, N>>::depth
variable compound_type_traits<std::complex<T>>::depth Recursion depth of the compound type.
variable samplerate_converter<T>::depth Processing depth.
function derived_cast(const U *) Down-casts a const pointer from
function derived_cast(U *)
namespace details
enum dft_algorithm Concrete DFT/FFT algorithm selection.
typedef dft_cache
class dft_cache_impl<int>
enum dft_decomp Decomposition direction for a butterfly pass.
enum dft_family Family of DFT algorithms (groups related algorithms).
macro DFT_MAX_STAGES
enum dft_order Specifies the desired order for DFT output (and IDFT input).
enum dft_pack_format Specifies the packing format for real DFT output data. See https://www.kfr.dev/docs/latest/dft_format/ for details
class dft_plan_md_real<T, Dims> Multidimensional real-to-complex / complex-to-real DFT plan.
constructor dft_plan_md_real<T, Dims>::dft_plan_md_real<T, Dims>(const dft_plan_md_real<T, Dims> &)
constructor dft_plan_md_real<T, Dims>::dft_plan_md_real<T, Dims>(dft_plan_md_real<T, Dims> &&)
constructor dft_plan_md_real<T, Dims>::dft_plan_md_real<T, Dims>(shape<Dims>, bool) Constructs a multidimensional real DFT plan.
class dft_plan_md<T, Dims> Multidimensional complex DFT plan.
constructor dft_plan_md<T, Dims>::dft_plan_md<T, Dims>(const dft_plan_md<T, Dims> &)
constructor dft_plan_md<T, Dims>::dft_plan_md<T, Dims>(dft_plan_md<T, Dims> &&)
constructor dft_plan_md<T, Dims>::dft_plan_md<T, Dims>(shape<Dims>) Constructs a multidimensional DFT plan for the given shape.
typedef dft_plan_ptr
typedef dft_plan_real_ptr
class dft_plan_real<T> Real-to-complex and complex-to-real 1D DFT plan.
constructor dft_plan_real<T>::dft_plan_real<T>() Constructs an empty (uninitialized) real DFT plan.
constructor dft_plan_real<T>::dft_plan_real<T>(const dft_plan_real<T> &)
constructor dft_plan_real<T>::dft_plan_real<T>(dft_plan_real<T> &&)
constructor dft_plan_real<T>::dft_plan_real<T>(size_t, dft_pack_format, bool) Constructs a real DFT plan.
class dft_plan<T> Class for performing 1D DFT/FFT.
constructor dft_plan<T>::dft_plan<T>() Constructs an empty DFT plan.
destructor dft_plan<T>::~dft_plan<T>() Destructor.
constructor dft_plan<T>::dft_plan<T>(const dft_plan<T> &) Copy constructor (deleted).
constructor dft_plan<T>::dft_plan<T>(dft_plan<T> &&) Move constructor.
constructor dft_plan<T>::dft_plan<T>(noinit, size_t, dft_order, bool)
constructor dft_plan<T>::dft_plan<T>(size_t, dft_order, bool) Constructs a DFT plan with the specified size and order.
struct dft_resampler_params Parameters for constructing a dft_resampler .
constructor dft_resampler_params::dft_resampler_params(int, fbase, fbase, fbase) Constructs resampler parameters.
class dft_resampler<T> FFT-based sample-rate converter and FIR filter using overlap-save.
constructor dft_resampler<T>::dft_resampler<T>(const dft_resampler_params &) Constructs the resampler from the given parameters.
typedef dft_stage_ptr
class dft_stage<T> Base structure representing a single DFT stage.
destructor dft_stage<T>::~dft_stage<T>() Destructor.
enum dft_type Direction(s) of DFT computation requested for a plan.
function dft(const univector<complex<T>, Tag> &) Performs the direct (forward) complex DFT using a cached plan.
enum constant dft_decomp::dif Decimation-in-frequency
typedef range<T>::diff_type
typedef array_ref<T>::difference_type
typedef data_allocator<T>::difference_type
typedef tensor<T, NDims>::tensor_iterator::difference_type
typedef tensor<T, NDims>::nested_iterator_t::difference_type
function digitreverse4(const vec<T, N> &) Reorders the elements of a vector by reversing base-4 (quaternary) digits of their indices.
function digitreverse4(u32) Reverses the digits of the given unsigned integer in base-4 (quaternary), using the lowest bits digits.
function digitreverse(const vec<T, N> &) Reorders the elements of a vector by reversing the digits of their indices in the specified radix.
function dimensions(E1 &&) Creates an expression that adjusts the dimensionality of another expression.
function shape<Dims>::dims() Returns the number of dimensions (compile-time constant).
function shape<0>::dims() Returns the number of dimensions (always 0).
function shape<dynamic_shape>::dims() Returns the number of dimensions at run time.
variable expression_traits<T>::dims
variable expression_with_traits<Arg>::dims
variable expression_function<Fn, Args>::dims Number of dimensions of the expression.
variable expression_discard<Tin, Dims>::dims
variable expression_traits<expression_scalar<T>>::dims
variable expression_traits<expression_counter<T, Dims>>::dims
variable expression_slice<Arg>::dims
variable expression_traits<expression_slice<Arg>>::dims
variable expression_traits<expression_cast<T, Arg>>::dims
variable expression_traits<expression_lambda<T, Dims, Fn, Rnd>>::dims
variable expression_traits<expression_padded<Arg>>::dims
variable expression_traits<expression_reverse<Arg>>::dims
variable expression_traits<expression_fixshape<Arg, fixed_shape_t<ShapeValues...>>>::dims
variable expression_traits<expression_reshape<Arg, OutDims>>::dims
variable expression_traits<expression_linspace<T, truncated>>::dims
variable expression_concatenate<Arg1, Arg2, ConcatAxis>::dims
variable expression_traits<expression_concatenate<Arg1, Arg2, ConcatAxis>>::dims
variable expression_unpack<E>::dims
variable expression_adjacent<Fn, E>::dims
variable expression_trace<E>::dims
variable expression_dimensions<Dims, E>::dims
variable expression_traits<univector<T, Tag>>::dims
variable expression_traits<expression_handle<T, Dims>>::dims Number of dimensions.
variable expression_traits<expression_placeholder<T, Dims, Key>>::dims Number of dimensions.
variable generator<T, VecWidth, Class, Twork>::dims
variable tensor_subscript<T, Derived, std::integer_sequence<index_t, Dims...>>::dims
variable tensor<T, NDims>::dims Number of dimensions.
variable expression_traits<tensor<T, Dims>>::dims
variable expression_random_uniform<T, Dims, Reference>::dims
variable expression_random_range<T, Dims, Reference>::dims
variable expression_random_normal<T, Dims, Reference>::dims
variable expression_reduce<Tout, Dims, Twork, Tin, ReduceFn, TransformFn, FinalFn>::dims
variable expression_window<T>::dims
variable expression_delay<delay, E, stateless, STag>::dims
variable expression_delay<1, E, stateless, STag>::dims
variable expression_goertzel<T>::dims
variable expression_parallel_goertzel<T, width>::dims
variable expression_traits<strided_channel<T>>::dims
typedef dimset Fixed-size bitmask indexed by tensor axis.
enum constant dft_type::direct Only the direct (forward) transform.
variable dft_plan<T>::disposition_inplace Internal data.
variable dft_plan<T>::disposition_outofplace Internal data.
variable audio_dithering_state::dist
function range<T>::distance()
function distance(const void *, const void *)
enum constant dft_decomp::dit Decimation-in-time
variable audio_quantization::dither Dithering state used during quantization.
variable audio_dithering_state::dithering Active dithering method.
variable audio_encoding_options::dithering
function div(const T1 &, const T2 &) Division of x by y .
function dft_stage<T>::do_execute(cdirect_t, complex<T> *, const complex<T> *, u8 *) Performs the direct stage execution (implemented by derived stages).
function dft_stage<T>::do_execute(cinvert_t, complex<T> *, const complex<T> *, u8 *) Performs the inverse stage execution (implemented by derived stages).
function dft_stage<T>::do_initialize(size_t) Initializes the stage's internal data for the given DFT size.
function dont_deduce(T)
function shape<0>::dot(const shape<0> &) Dot product with another scalar shape; the empty product is 0.
function shape<Dims>::dot(const shape<dims> &) Dot product of the two shapes (element-wise multiply and sum).
function dotproduct(E1 &&, E2 &&) Returns the dot product of two vectors.
typedef opencl_names::double16
typedef opencl_names::double2
typedef opencl_names::double3
typedef opencl_names::double4
typedef opencl_names::double8
function downsample2(E1 &&, csize_t<offset>) Downsamples a signal by a factor of 2 by selecting every other sample.
function downsample4(E1 &&, csize_t<offset>) Downsamples a signal by a factor of 4 by selecting every fourth sample.
enum constant sample_rate_conversion_quality::draft Draft quality (lowest, fastest).
function dft_stage<T>::dump() Prints the stage parameters to stdout for debugging.
function dft_plan<T>::dump() Dumps details of the DFT plan to stdout for inspection.
function dft_plan_md<T, Dims>::dump() Dumps details of the underlying per-axis plans to stdout.
function dft_plan_md_real<T, Dims>::dump() Dumps details of the underlying per-axis plans to stdout.
function dup(const vec<T, N> &) Duplicates each element of x into a pair of adjacent lanes.
function dupeven(const vec<T, N> &) Duplicates each even-indexed element into the following odd-indexed lane.
function duphalves(const vec<T, N> &) Duplicates the contents of x to form a vector twice as long.
function duphigh(const vec<T, N> &) Duplicates the upper half of x to fill the whole vector.
function duplow(const vec<T, N> &) Duplicates the lower half of x to fill the whole vector.
function dupodd(const vec<T, N> &) Duplicates each odd-indexed element into the preceding even-indexed lane.
variable timestamps<max_count, fence>::dur Per-checkpoint elapsed cycle counts (overhead-subtracted), indexed by record order.
typedef glsl_names::dvec2
typedef glsl_names::dvec3
typedef glsl_names::dvec4
variable dynamic_shape Sentinel rank value indicating a run-time-determined rank.

E¶

variable scalar_constants<T>::e The mathematical constant e (Euler's number).
class ebu_channel<T> Single-channel loudness measurement front-end.
constructor ebu_channel<T>::ebu_channel<T>(int, speaker_type, int, T) Construct a channel front-end.
class ebu_r128<T> EBU R128 loudness meter.
constructor ebu_r128<T>::ebu_r128<T>(int, std::span<const speaker_type>, int) Construct the meter.
function stopwatch::elapsed() Return the elapsed time since construction cast to the requested Duration type.
function stopwatch::elapsed_ms() Convenience wrapper for elapsed returning milliseconds.
function stopwatch::elapsed_ns() Convenience wrapper for elapsed returning nanoseconds.
function stopwatch::elapsed_s() Return the elapsed wall-clock time in seconds since construction.
function stopwatch::elapsed_us() Convenience wrapper for elapsed returning microseconds.
variable portable_vec<T, N>::elem
struct vec<T, N>::element Proxy reference to a single vector element enabling read/write access.
function element_size()
function element_size<>()
variable elements Constant instance of elements_t<vals...>
typedef elements_t Compile-time list of element indices (size_t values)
function elliptic(int, double, double) Analog elliptic (Cauer) lowpass filter prototype (normalized cutoff = 1 rad/s).
function array_ref<T>::empty()
function inline_vector<T, N>::empty() Returns true if the vector holds no elements.
function tensor<T, NDims>::empty() Returns true if the tensor has no elements.
function small_buffer<T, Capacity>::empty()
function audio_data<IsInterleaved>::empty() Check whether this audio data container is empty.
enum constant audiofile_error::empty_file The file is empty or does not contain any audio data
class empty_struct<tag> Empty type tagged with a unique integer tag .
function 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 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 cvals_t<T, values>::end() Iterator past the last value
function array_ref<T>::end()
function inline_vector<T, N>::end() Returns an iterator to one past the last element.
function inline_vector<T, N>::end() Returns a const iterator to one past the last element.
function tensor<T, NDims>::end() Returns the end sentinel iterator.
function small_buffer<T, Capacity>::end()
function small_buffer<T, Capacity>::end()
function range<T>::end()
enum constant seek_origin::end From the end
enum constant audiofile_error::end_of_file End of file reached
function end_pass(const expression_handle<T, NDims> &, shape<NDims>, shape<NDims>) Internal ADL-provided implementation for expression_handle expressions.
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 end_pass(const expression_with_arguments<Args...> &, shape<Dims>, shape<Dims>) Notifies all arguments of an expression_with_arguments that a pass has ended.
function end_pass(const internal_generic::anything &, shape<Dims>, shape<Dims>)
variable audiofile_format::endianness Endianness of the audio data.
variable expression_linspace<T, truncated>::endpoint
function energy_to_loudness(T) Convert mean-square energy to loudness in LUFS.
function enumerate() Generates a vector with an arithmetic sequence of values.
function enumerate(vec_shape<T, N>) Shape-driven overload of enumerate() for type deduction.
function enumerate(vec_shape<T, N>, std::type_identity_t<T>) Generates a vector with an arithmetic sequence using a runtime step.
enum constant special_constant::epsilon machine epsilon
variable scalar_constants<T>::epsilon The machine epsilon — the smallest value such that 1 + epsilon ≠ 1.
constructor epsilon_scope<void>::epsilon_scope(float)
class epsilon_scope<T>
destructor epsilon_scope<T>::~epsilon_scope<T>()
constructor epsilon_scope<T>::epsilon_scope<T>(T)
struct epsilon_scope<void>
function eq(E1 &&, E2 &&) Creates an expression that returns whether e1 is equal to e2.
function equal(const T1 &, const T2 &) Element-wise equality comparison.
function cvals_t<T, values>::equal(cvals_t<T, values...>) Returns
function cvals_t<T, values>::equal(cvals_t<T, values2...>) Returns
class equality_comparer<L, R>
function error(const Args &...) Print values to stderr, each formatted with its default conversion specifier.
function errorln(const Args &...) Print values to stderr followed by a newline, then flush stderr.
function even(const vec<T, N> &) Extracts the even-indexed elements of x (with optional grouping).
class exception
constructor exception::exception(std::string)
function dft_plan<T>::execute_dft(cbool_t<inverse>, complex<T> *, const complex<T> *, u8 *)
function dft_stage<T>::execute(bool, complex<T> *, const complex<T> *, u8 *) Executes the stage in the requested direction.
function dft_stage<T>::execute(cdirect_t, complex<T> *, const complex<T> *, u8 *) Executes the direct (forward) stage.
function dft_stage<T>::execute(cinvert_t, complex<T> *, const complex<T> *, u8 *) Executes the inverse stage.
function dft_plan<T>::execute(complex<T> *, const complex<T> *, u8 *, bool) Execute the complex DFT on in and write the result to out .
function dft_plan_real<T>::execute(complex<T> *, const complex<T> *, u8 *, bool)
function dft_plan_md<T, Dims>::execute(complex<T> *, const complex<T> *, u8 *, bool) Executes the multidimensional DFT on raw pointers.
function dft_plan<T>::execute(complex<T> *, const complex<T> *, u8 *, cbool_t<inverse>) Execute the complex DFT on in and write the result to out .
function dft_plan_real<T>::execute(complex<T> *, const complex<T> *, u8 *, cbool_t<inverse>)
function dft_plan_md<T, Dims>::execute(complex<T> *, const complex<T> *, u8 *, cbool_t<inverse>) Executes the multidimensional DFT with a compile-time direction.
function dft_plan_md_real<T, Dims>::execute(complex<T> *, const T *, u8 *, bool) Forward transform selected by a runtime flag (raw pointers).
function dft_plan_real<T>::execute(complex<T> *, const T *, u8 *, cdirect_t) Executes the forward real-to-complex DFT.
function dft_plan_md_real<T, Dims>::execute(complex<T> *, const T *, u8 *, cdirect_t) Forward transform: real input to packed complex output (raw pointers).
function dft_plan_md<T, Dims>::execute(const tensor<complex<T>, Dims> &, const tensor<complex<T>, Dims> &, u8 *, bool) Executes the multidimensional DFT on tensors.
function dft_plan_md_real<T, Dims>::execute(const tensor<complex<T>, Dims> &, const tensor<T, Dims> &, u8 *, cdirect_t) Forward transform on tensors.
function dft_plan_md_real<T, Dims>::execute(const tensor<T, Dims> &, const tensor<complex<T>, Dims> &, u8 *, cinvert_t) Inverse transform on tensors.
function dft_plan_md_real<T, Dims>::execute(T *, const complex<T> *, u8 *, bool) Inverse transform selected by a runtime flag (raw pointers).
function dft_plan_real<T>::execute(T *, const complex<T> *, u8 *, cinvert_t) Executes the inverse complex-to-real DFT.
function dft_plan_md_real<T, Dims>::execute(T *, const complex<T> *, u8 *, cinvert_t) Inverse transform: packed complex input to real output (raw pointers).
function dct_plan<T>::execute(T *, const T *, u8 *, bool) Executes the DCT.
function dft_plan<T>::execute(univector<complex<T>, Tag1> &, const univector<complex<T>, Tag2> &, u8 *, bool) Execute the complex DFT on in and write the result to out .
function dft_plan_real<T>::execute(univector<complex<T>, Tag1> &, const univector<complex<T>, Tag2> &, u8 *, bool)
function dft_plan<T>::execute(univector<complex<T>, Tag1> &, const univector<complex<T>, Tag2> &, u8 *, cbool_t<inverse>) Execute the complex DFT on in and write the result to out .
function dft_plan_real<T>::execute(univector<complex<T>, Tag1> &, const univector<complex<T>, Tag2> &, u8 *, cbool_t<inverse>)
function dft_plan<T>::execute(univector<complex<T>, Tag1> &, const univector<complex<T>, Tag2> &, univector<u8, Tag3> &, bool) Execute the complex DFT on in and write the result to out .
function dft_plan_real<T>::execute(univector<complex<T>, Tag1> &, const univector<complex<T>, Tag2> &, univector<u8, Tag3> &, bool)
function dft_plan<T>::execute(univector<complex<T>, Tag1> &, const univector<complex<T>, Tag2> &, univector<u8, Tag3> &, cbool_t<inverse>) Execute the complex DFT on in and write the result to out .
function dft_plan_real<T>::execute(univector<complex<T>, Tag1> &, const univector<complex<T>, Tag2> &, univector<u8, Tag3> &, cbool_t<inverse>)
function dft_plan_real<T>::execute(univector<complex<T>, Tag1> &, const univector<T, Tag2> &, u8 *, cdirect_t) Forward real-to-complex DFT using univector buffers with a raw scratch pointer.
function dft_plan_real<T>::execute(univector<complex<T>, Tag1> &, const univector<T, Tag2> &, univector<u8, Tag3> &, cdirect_t) Forward real-to-complex DFT using univector buffers with a scratch univector.
function dft_plan_real<T>::execute(univector<T, Tag1> &, const univector<complex<T>, Tag2> &, u8 *, cinvert_t) Inverse complex-to-real DFT using univector buffers with a raw scratch pointer.
function dft_plan_real<T>::execute(univector<T, Tag1> &, const univector<complex<T>, Tag2> &, univector<u8, Tag3> &, cinvert_t) Inverse complex-to-real DFT using univector buffers with a scratch univector.
function dct_plan<T>::execute(univector<T, Tag1> &, const univector<T, Tag2> &, univector<u8, Tag3> &, bool) Executes the DCT using univector buffers.
variable cpu_features::exmax Highest supported extended CPUID leaf (leaf 0x80000000 EAX).
function exp10(const T1 &) Returns 10 raised to the given power x.
function exp10(E1 &&) Creates an expression that returns 10 raised to the given power x.
function exp2(const T1 &) Returns 2 raised to the given power x.
function exp2(E1 &&) Creates an expression that returns 2 raised to the given power x.
function exp_fmadd(const T1 &, const T2 &, const T3 &) Returns exp(x * m + a).
function exp_fmadd(E1 &&, E2 &&, E3 &&) Creates an expression that returns exp(x * m + a).
class expand_cvals<T, Tpl, cvals_t<T, vals...>> Specialization of expand_cvals that instantiates Tpl with the pack values.
class expand_cvals<T, Tpl, Pack> Expands a cvals_t pack into a template expecting non-type parameters.
function exp(const T1 &) Returns e raised to the given power x.
function exp(E1 &&) Creates an expression that returns \(e\) raised to the given power x.
variable expression_traits<T>::explicit_operand
variable expression_traits_defaults::explicit_operand
variable expression_with_traits<Arg>::explicit_operand
concept expr_element Concept satisfied by scalar vector element types.
class expression_adjacent<Fn, E> Expression that applies a binary function to each value and its previous value.
constructor expression_adjacent<Fn, E>::expression_adjacent<Fn, E>(Fn &&, E &&)
concept expression_argument Concept satisfied by input expressions that must appear as an explicit operand (i.e. not implicitly convertible from a scalar argument).
concept expression_arguments Concept satisfied when all E are input expressions and at least one of them is an explicit operand.
class expression_bartlett_hann<T> Bartlett-Hann window expression
class expression_bartlett<T> Bartlett window expression (triangular reaching zero at the edges)
typedef expression_biquads Alias for expression_iir (sample-by-sample biquad cascade expression).
typedef expression_biquads_l Alias for expression_iir_l (look-ahead biquad cascade expression).
class expression_blackman_harris<T> Blackman-Harris window expression (4-term minimum sidelobe window)
class expression_blackman<T> Blackman window expression (parameterized by alpha)
constructor expression_blackman<T>::expression_blackman<T>(size_t, T, window_symmetry)
class expression_bohman<T> Bohman window expression (product of cosine and linear taper)
class expression_cast<T, Arg> Expression that converts the values of the wrapped expression to type T.
class expression_concatenate<Arg1, Arg2, ConcatAxis> Expression that joins two expressions along a single axis.
constructor expression_concatenate<Arg1, Arg2, ConcatAxis>::expression_concatenate<Arg1, Arg2, ConcatAxis>(Arg1 &&, Arg2 &&)
class expression_cosine_np<T> Cosine window expression (numpy-compatible)
class expression_cosine<T> Cosine window expression (sin(pi*x))
class expression_counter<T, Dims> Expression that produces a sequence of values start, start + step, start + 2*step, ... for one or more dimensions.
class expression_delay<1, E, stateless, STag>
constructor expression_delay<1, E, stateless, STag>::expression_delay<1, E, stateless, STag>(E &&, state_holder<delay_state<T, 1, STag>, stateless>)
class expression_delay<delay, E, stateless, STag>
constructor expression_delay<delay, E, stateless, STag>::expression_delay<delay, E, stateless, STag>(E &&, state_holder<delay_state<T, delay, STag>, stateless>)
class expression_dimensions<Dims, E> Expression that adjusts the dimensionality of another expression.
variable expression_dims Inline variable holding the number of dimensions of an expression.
class expression_discard<Tin, Dims> Output expression that discards all written values.
class expression_filter<T> Filter adapter that wraps an expression containing a placeholder.
constructor expression_filter<T>::expression_filter<T>() Default-constructing constructor for subclasses.
constructor expression_filter<T>::expression_filter<T>(expression_handle<T, 1>) Constructs the filter from a placeholder expression handle.
class expression_fir<T, U, E1, stateless> Template expression applying a generic FIR filter of arbitrary length.
constructor expression_fir<T, U, E1, stateless>::expression_fir<T, U, E1, stateless>(E1 &&, state_holder<fir_state<T, U>, stateless>)
class expression_fixshape<Arg, Shape> Expression that overrides the shape of another expression with a compile-time shape.
constructor expression_fixshape<Arg, Shape>::expression_fixshape<Arg, Shape>(Arg &&)
class expression_flattop<T> Flat-top window expression (5-term window for accurate amplitude estimation)
deduction guide expression_function Deduction guide for constructing an expression_function from an argument holder and a callable.
deduction guide expression_function Deduction guide for constructing an expression_function from an rvalue argument holder and a callable.
deduction guide expression_function Deduction guide for constructing an expression_function from an lvalue argument holder and a callable.
class expression_function<Fn, Args> Expression that applies a callable to its arguments.
constructor expression_function<Fn, Args>::expression_function<Fn, Args...>(arg<Args &&>...) Constructs the expression from a pack of arguments with a default-constructed callable.
constructor expression_function<Fn, Args>::expression_function<Fn, Args...>(expression_with_arguments<Args...>, Fn &&) Constructs the expression from an argument holder and a callable.
constructor expression_function<Fn, Args>::expression_function<Fn, Args...>(Fn &&, arg<Args &&>...) Constructs the expression from a callable and a pack of arguments.
class expression_gaussian<T> Gaussian window expression
constructor expression_gaussian<T>::expression_gaussian<T>(size_t, T, window_symmetry) alpha = std / 2N
class expression_goertzel<T> Single-bin Goertzel algorithm expression.
destructor expression_goertzel<T>::~expression_goertzel<T>() Destructor: rotates the final filter state into the complex DFT bin value and stores it in result .
constructor expression_goertzel<T>::expression_goertzel<T>(complex<T> &, T) Construct a Goertzel resonator for frequency omega .
class expression_hamming<T> Hamming window expression
constructor expression_hamming<T>::expression_hamming<T>(size_t, T, window_symmetry)
class expression_handle<T, Dims> Opaque type-erased handle to an expression (forward declaration).
constructor expression_handle<T, Dims>::expression_handle<T, Dims>() Construct an empty (invalid) handle.
constructor expression_handle<T, Dims>::expression_handle<T, Dims>(const void *, const expression_vtable<T, Dims> *, std::shared_ptr<expression_resource>) Construct a handle referencing instance with vtable vtable.
class expression_hann<T> Hann window expression (0.5*(1-cos(2*pi*x)))
class expression_histogram<Bins, E, TCount> Expression that computes a histogram as data flows through it.
constructor expression_histogram<Bins, E, TCount>::expression_histogram<Bins, E, TCount>(E &&, size_t) Constructs a runtime-sized histogram expression.
class expression_iir_l<filters, T, E1, Stateless> Template expression applying a cascade of biquad sections (look-ahead variant, no latency compensation).
constructor expression_iir_l<filters, T, E1, Stateless>::expression_iir_l<filters, T, E1, Stateless>(E1 &&, state_holder<iir_state<T, filters>, Stateless>) Construct from an input expression and a state holder.
class expression_iir<filters, T, E1, Stateless> Template expression applying a cascade of biquad sections (look-ahead variant, with latency compensation).
constructor expression_iir<filters, T, E1, Stateless>::expression_iir<filters, T, E1, Stateless>(E1 &&, state_holder<iir_state<T, filters>, Stateless>) Construct from an input expression and a state holder.
class expression_kaiser<T> Kaiser window expression (shaped by the zeroth-order modified Bessel function)
constructor expression_kaiser<T>::expression_kaiser<T>(size_t, T, window_symmetry)
class expression_lambda<T, Dims, Fn, Rnd> Expression backed by a user-provided callable.
class expression_lanczos<T> Lanczos window expression (sinc based)
class expression_linspace<T, truncated> Expression that produces evenly spaced values from start to stop.
constructor expression_linspace<T, truncated>::expression_linspace<T, truncated>(symmetric_linspace_t, T, size_t, bool)
constructor expression_linspace<T, truncated>::expression_linspace<T, truncated>(T, T, size_t, bool)
typedef expression_make_function Alias that produces an expression_function with decayed argument types.
class expression_moving_sum<U, E1, STag, stateless> Template expression performing a moving sum (rectangular window) over the input.
constructor expression_moving_sum<U, E1, STag, stateless>::expression_moving_sum<U, E1, STag, stateless>(E1 &&, state_holder<moving_sum_state<U, STag>, stateless>)
typedef expression_pack Type alias for the expression that packs several expressions into a single vector-valued expression.
class expression_padded<Arg> Expression that extends another expression with a constant fill value.
constructor expression_padded<Arg>::expression_padded<Arg>(Arg &&, typename ArgTraits::value_type)
class expression_parallel_goertzel<T, width> Parallel (multi-bin) Goertzel algorithm expression.
destructor expression_parallel_goertzel<T, width>::~expression_parallel_goertzel<T, width>() Destructor: rotates the final filter states into the width complex DFT bin values and stores them in result .
constructor expression_parallel_goertzel<T, width>::expression_parallel_goertzel<T, width>(complex<T> *, vec<T, width>) Construct width parallel Goertzel resonators.
class expression_placeholder<T, Dims, Key> A placeholder expression that can be bound to a concrete expression at runtime.
constructor expression_placeholder<T, Dims, Key>::expression_placeholder<T, Dims, Key>()
class expression_planck_taper<T> Planck-taper window expression (smooth flat-top taper controlled by epsilon)
constructor expression_planck_taper<T>::expression_planck_taper<T>(size_t, T, window_symmetry)
variable expression_random_access Inline variable indicating whether an expression supports random access.
class expression_random_normal<T, Dims, Reference> Expression that produces normally distributed (Gaussian) random values.
class expression_random_range<T, Dims, Reference> Expression that produces uniformly distributed random values in [min, max).
class expression_random_uniform<T, Dims, Reference> Expression that produces uniformly distributed random values in [0, 1).
class expression_rectangular<T> Rectangular window expression (all ones within the window)
constructor expression_rectangular<T>::expression_rectangular<T>(size_t, T, window_symmetry)
class expression_reduce<Tout, Dims, Twork, Tin, ReduceFn, TransformFn, FinalFn> Expression that reduces an input expression to a single value.
constructor expression_reduce<Tout, Dims, Twork, Tin, ReduceFn, TransformFn, FinalFn>::expression_reduce<Tout, Dims, Twork, Tin, ReduceFn, TransformFn, FinalFn>(ReduceFn, TransformFn, FinalFn) Constructs the reducer.
class expression_reshape<Arg, OutDims> Expression that exposes the same data as another expression with a different shape.
constructor expression_reshape<Arg, OutDims>::expression_reshape<Arg, OutDims>(Arg &&, const shape<OutDims> &)
struct expression_resource Base class for owning the storage of a type-erased expression.
destructor expression_resource::~expression_resource() Returns a pointer to the owned expression instance, or nullptr.
class expression_resource_impl<E> expression_resource that owns an expression of type E by value.
destructor expression_resource_impl<E>::~expression_resource_impl<E>()
constructor expression_resource_impl<E>::expression_resource_impl<E>(E &&) Take ownership of e by move.
class expression_reverse<Arg> Expression that exposes another expression with its trailing dimension reversed.
constructor expression_reverse<Arg>::expression_reverse<Arg>(Arg &&)
class expression_scalar<T> Expression that wraps a single scalar value of type T.
class expression_short_fir<tapcount, T, U, E1, stateless> Template expression applying a short FIR filter (2..33 taps).
constructor expression_short_fir<tapcount, T, U, E1, stateless>::expression_short_fir<tapcount, T, U, E1, stateless>(E1 &&, state_holder<short_fir_state<tapcount, T, U>, stateless>)
class expression_slice<Arg> Expression that exposes a sub-region of another expression.
constructor expression_slice<Arg>::expression_slice<Arg>(Arg &&, shape<dims>, shape<dims>)
class expression_trace<E> Expression that prints the requested values to the console for debugging purposes.
struct expression_traits_defaults Base struct providing default values for expression traits.
class expression_traits<const T> Pass-through specialization that forwards traits for const-qualified expression types.
class expression_traits<const T &> Pass-through specialization that forwards traits for const lvalue reference expression types.
class expression_traits<const T &&> Pass-through specialization that forwards traits for const rvalue reference expression types.
class expression_traits<expression_cast<T, Arg>>
class expression_traits<expression_concatenate<Arg1, Arg2, ConcatAxis>>
class expression_traits<expression_counter<T, Dims>>
class expression_traits<expression_fixshape<Arg, fixed_shape_t<ShapeValues...>>>
class expression_traits<expression_handle<T, Dims>> expression_traits specialization for expression_handle .
class expression_traits<expression_lambda<T, Dims, Fn, Rnd>>
class expression_traits<expression_linspace<T, truncated>>
class expression_traits<expression_padded<Arg>>
class expression_traits<expression_placeholder<T, Dims, Key>> expression_traits specialization for expression_placeholder .
class expression_traits<expression_reshape<Arg, OutDims>>
class expression_traits<expression_reverse<Arg>>
class expression_traits<expression_scalar<T>>
class expression_traits<expression_slice<Arg>>
class expression_traits<strided_channel<T>>
class expression_traits<T> Primary traits template for expressions.
class expression_traits<T &> Pass-through specialization that forwards traits for lvalue reference expression types.
class expression_traits<T &&> Pass-through specialization that forwards traits for rvalue reference expression types.
class expression_traits<T> Specialization of expression_traits for scalar vector element types.
class expression_traits<tensor<T, Dims>> Expression traits for tensor, enabling its use as an expression argument.
class expression_traits<univector<T, Tag>> Expression traits for univector , allowing it to participate in KFR expression evaluation.
class expression_triangular<T> Triangular window expression
class expression_tukey<T> Tukey window expression (tapered cosine, numpy-compatible)
constructor expression_tukey<T>::expression_tukey<T>(size_t, T, window_symmetry)
class expression_unpack<E> Expression that writes a single vector-valued input into several output expressions.
constructor expression_unpack<E>::expression_unpack<E...>(E &&...)
typedef expression_value_type Helper alias that extracts the value type of an expression.
class expression_vtable<T, Dims> Virtual table providing type-erased access to an expression of value type T and dimensionality Dims.
function expression_vtable<T, Dims>::expression_vtable<T, Dims>(ctype_t<Expression>) Build the vtable for concrete expression type Expression.
class expression_window_with_metrics<T, metrics> Base class for windows parameterized by a linspace and a scalar argument
constructor expression_window_with_metrics<T, metrics>::expression_window_with_metrics<T, metrics>(size_t, T, window_symmetry)
class expression_window<T> Base class for all window expressions
constructor expression_window<T>::expression_window<T>(size_t)
deduction guide expression_with_arguments Deduction guide for expression_with_arguments .
class expression_with_arguments<Arg> Single-argument specialization of expression_with_arguments .
constructor expression_with_arguments<Arg>::expression_with_arguments<Arg>(Arg &&) Constructs the expression from a single argument.
class expression_with_arguments<Args> Holds the arguments of an expression along with their dimension masks.
constructor expression_with_arguments<Args>::expression_with_arguments<Args...>(arg<Args &&>...) Constructs the expression from a pack of arguments.
class expression_with_traits<Arg> Wraps a single-argument expression and forwards its traits.
function extend(const vec<T, 1> &) Extends a single-element vector to length Nout by repeating its value.
function extend(const vec<T, N> &) Resizes a multi-element vector to length Nout by cyclic repetition or truncation.
function extend(const vec<T, N> &) Identity overload of extend() for the Nout == N case.
function shape<Dims>::extend(index_t) Promote the shape to a higher rank by prepending axes.
function shape<0>::extend(index_t) Promote the scalar shape to a higher rank by prepending axes of size value.

F¶

enum constant datatype::f
variable epsilon_scope<void>::f
enum constant datatype::f16
struct f16 16-bit half-precision floating-point value stored as raw bits.
constructor f16::f16() Default constructor leaving the value uninitialized.
constructor f16::f16(f32) Converts a single-precision value to IEEE 754 binary16.
typedef f32
enum constant datatype::f32
enum constant audio_sample_type::f32
typedef f32_reader float reader
typedef f32_writer float writer
typedef f32x1 Short alias for vec<T, N> .
typedef f32x16
typedef f32x2
typedef f32x2x2
typedef f32x3
typedef f32x32
typedef f32x4
typedef f32x4x4
typedef f32x64
typedef f32x8
typedef f64
enum constant datatype::f64
enum constant audio_sample_type::f64
typedef f64x1
typedef f64x16
typedef f64x2
typedef f64x2x2
typedef f64x3
typedef f64x32
typedef f64x4
typedef f64x4x4
typedef f64x64
typedef f64x8
typedef f80
enum constant datatype::f80
concept f_class
function dft_resampler_params::factor() Returns the absolute resampling factor (2^|shift|).
function dft_resampler<T>::factor() Returns the resampling factor (a power of two, >= 1).
function factorial_approx(const T1 &) Returns the approximate factorial of an argument.
function factorial_approx(E1 &&) Creates an expression that returns the approximate factorial of x.
variable factorial_table Lookup table of exact factorial values for 0 <= n <= 20.
function factorial(int) Returns the exact factorial of an argument.
variable platform<cpu_t::common>::fast_unaligned
variable platform<cpu_t::avx>::fast_unaligned
function fastcos(const T1 &) Returns a fast (lower-precision) approximation of the trigonometric cosine of x.
function fastcosdeg(const T1 &) Returns a fast (lower-precision) approximation of the trigonometric cosine of the angle expressed in degrees.
function fastcosdeg(E1 &&) Creates an expression that returns an approximation of the trigonometric cosine of x (expressed in degrees).
function fastcos(E1 &&) Creates an expression that returns an approximation of the trigonometric cosine of x.
function fastsin(const T1 &) Returns a fast (lower-precision) approximation of the trigonometric sine of x.
function fastsindeg(const T1 &) Returns a fast (lower-precision) approximation of the trigonometric sine of the angle expressed in degrees.
function fastsindeg(E1 &&) Creates an expression that returns an approximation of the trigonometric sine of x (expressed in degrees).
function fastsin(E1 &&) Creates an expression that returns an approximation of the trigonometric sine of x.
typedef fbase
function fbitcast(const From &) Reinterpret the bits of a scalar value as its floating-point counterpart type.
function fbitcast(const vec<From, N> &) Reinterpret the bits of a vector as a vector of its floating-point counterpart type.
variable convolve_filter<T>::fft
function 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) Multiply-accumulate of two spectra with an addend into a destination.
function fft_multiply_accumulate(univector<complex<T>, Tag1> &, const univector<complex<T>, Tag2> &, const univector<complex<T>, Tag3> &, dft_pack_format) Multiply-accumulate of two spectra into a destination.
function fft_multiply(univector<complex<T>, Tag1> &, const univector<complex<T>, Tag2> &, const univector<complex<T>, Tag3> &, dft_pack_format) Element-wise multiplication of two spectra (convolution in time domain).
variable file_handle::file
function file_extension(const file_path &)
struct file_handle
constructor file_handle::file_handle()
destructor file_handle::~file_handle()
constructor file_handle::file_handle(const file_handle &)
constructor file_handle::file_handle(FILE *)
constructor file_handle::file_handle(file_handle &&)
typedef file_path
class file_reader<T> Typed file reader
destructor file_reader<T>::~file_reader<T>()
constructor file_reader<T>::file_reader<T>(file_handle &&)
class file_writer<T> Typed file writer
destructor file_writer<T>::~file_writer<T>()
constructor file_writer<T>::file_writer<T>(file_handle &&)
typedef filepath
variable expression_padded<Arg>::fill_value
function audio_data<IsInterleaved>::fill(fbase) Fills the audio data with the specified value.
variable samplerate_converter<T>::filter Filter coefficients.
variable expression_filter<T>::filter_expr The wrapped placeholder expression.
typedef filter_fir Alias for
function dft_resampler<T>::filter_length() Returns the designed filter length (in filter-rate samples).
function samplerate_converter<T>::filter_order(sample_rate_conversion_quality) Computes the filter order for a given quality level.
class filter<T> Abstract base class for single-argument filters, mainly intended for DSP processing.
destructor filter<T>::~filter<T>() Destructor.
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 final_mean(T, size_t) Finalizer for mean .
function final_rootmean(T, size_t) Finalizer for rms .
variable expression_reduce<Tout, Dims, Twork, Tin, ReduceFn, TransformFn, FinalFn>::finalfn
function tensor<T, NDims>::finalizer() Returns the memory finalizer holding the data alive.
function audio_data<IsInterleaved>::find_peak()
typedef findinttype
function fir_bandpass(const univector_ref<T> &, std::type_identity_t<T>, std::type_identity_t<T>, const expression_handle<T> &, bool)
function fir_bandpass(univector<T, Tag> &, std::type_identity_t<T>, std::type_identity_t<T>, const expression_handle<T> &, bool) Calculates coefficients for the band-pass FIR filter using the windowed-sinc method.
function fir_bandstop(const univector_ref<T> &, std::type_identity_t<T>, std::type_identity_t<T>, const expression_handle<T> &, bool)
function fir_bandstop(univector<T, Tag> &, std::type_identity_t<T>, std::type_identity_t<T>, const expression_handle<T> &, bool) Calculates coefficients for the band-stop (notch) FIR filter using the windowed-sinc method.
class fir_filter<T, U> Runtime FIR filter implementing the filter interface.
constructor fir_filter<T, U>::fir_filter<T, U>(fir_state<T, U>) Construct from a fir_state .
function fir_highpass(const univector_ref<T> &, std::type_identity_t<T>, const expression_handle<T> &, bool)
function fir_highpass(univector<T, Tag> &, std::type_identity_t<T>, const expression_handle<T> &, bool) Calculates coefficients for the high-pass FIR filter using the windowed-sinc method.
function fir_lowpass(const univector_ref<T> &, std::type_identity_t<T>, const expression_handle<T> &, bool)
function fir_lowpass(univector<T, Tag> &, std::type_identity_t<T>, const expression_handle<T> &, bool) Calculates coefficients for the low-pass FIR filter using the windowed-sinc method.
deduction guide fir_params Deduction guide for fir_params from an arbitrary container.
class fir_params<T> Parameters of a generic FIR filter: the tap vector.
constructor fir_params<T>::fir_params<T>(const fir_params<T> &)
constructor fir_params<T>::fir_params<T>(const T *, size_t) Construct from a raw pointer and size (taps are reversed internally).
function fir_params<T>::fir_params<T>(Cont &&) Construct from any container satisfying has_data_size .
constructor fir_params<T>::fir_params<T>(fir_params<T> &&)
constructor fir_params<T>::fir_params<T>(univector<T> &&) Construct by moving a tap vector (taps are reversed internally).
deduction guide fir_state Deduction guide for fir_state from an arbitrary container.
class fir_state<T, U> State of a generic FIR filter: parameters plus a ring-buffer delay line.
constructor fir_state<T, U>::fir_state<T, U>(const fir_state<T, U> &)
function fir_state<T, U>::fir_state<T, U>(Cont &&) Construct from a tap container (taps are reversed by fir_params ).
constructor fir_state<T, U>::fir_state<T, U>(fir_params<T>) Construct from fir_params (taps are taken as-is, already reversed).
constructor fir_state<T, U>::fir_state<T, U>(fir_state<T, U> &&)
typedef fir_taps Alias for a fixed-size vector of FIR filter coefficients.
function fir(E1 &&, fir_params<T>) Returns template expression that applies FIR filter to the input.
function fir(E1 &&, std::reference_wrapper<fir_state<T, U>>) Returns template expression that applies FIR filter to the input.
function fir(E1 &&, Taps &&) Returns template expression that applies FIR filter to the input.
function fir(fir_state<T, U> &, E1 &&) Returns template expression that applies FIR filter to the input.
function expression_with_arguments<Args>::first() Returns a reference to the first argument.
function expression_with_arguments<Args>::first() Returns a const reference to the first argument.
function expression_with_arguments<Arg>::first() Returns a reference to the stored argument.
function expression_with_arguments<Arg>::first() Returns a const reference to the stored argument.
typedef expression_with_arguments<Args>::first_arg Alias for the type of the first argument.
typedef expression_with_arguments<Arg>::first_arg Alias for the argument type.
typedef expression_with_arguments<Args>::first_arg_traits Traits of the first argument.
typedef expression_with_arguments<Arg>::first_arg_traits Traits of the argument.
typedef expression_with_traits<Arg>::first_arg_traits
typedef expression_unpack<E>::first_arg_traits
typedef expression_dimensions<Dims, E>::first_arg_traits
typedef expression_unpack<E>::first_value_type
typedef fix_type
variable fixed_shape Convenience variable template for instantiating a fixed_shape_t .
class fixed_shape_t<Values> Type-level storage for a fixed shape built from a list of constants.
constructor fixed_shape_t<Values>::fixed_shape_t<Values...>()
function fixshape(Arg &&, const fixed_shape_t<ShapeValues...> &) Creates an expression that overrides the shape of arg with a compile-time shape.
enum constant audiofile_container::flac FLAC
enum constant audiofile_codec::flac
struct flac_decoding_options Options for decoding FLAC audio files.
struct flac_encoding_options Represents options for FLAC audio encoding.
function tensor<T, NDims>::tensor_iterator::flat_index() Returns the flat (linear) index of the current element.
function vec<T, N>::flatten()
function tensor<T, NDims>::flatten() Returns a 1D tensor view of the data.
function tensor<T, NDims>::flatten_may_copy(bool) Returns a 1D tensor view of the data, copying if necessary.
function flatten(const vec<From, N> &)
enum constant window_type::flattop
typedef opencl_names::float16
typedef opencl_names::float2
typedef opencl_names::float3
typedef opencl_names::float4
typedef opencl_names::float8
typedef float_type Maps a bit width to the corresponding floating-point type (32 -> float, 64 -> double)
variable float_types
variable float_vector_types Instance of float_vector_types_t for use as a value parameter pack.
typedef float_vector_types_t Type list of floating-point vector instantiations for the test sizes.
enum constant special_constant::floating_point floating-point literal carried by
function floor_div(long long, long long)
function floor(const T1 &) Returns the largest integer value not greater than x.
function floor(E1 &&) Creates an expression that returns the largest integer value not greater than x.
typedef flt_type
function fmadd(const T1 &, const T2 &, const T3 &) Fused multiply-add.
typedef fmax
function fmod(const T &, const T &) Returns the floating-point remainder of dividing x by y.
function fmsub(const T1 &, const T2 &, const T3 &) Fused multiply-subtract.
variable dft_plan_real<T>::fmt Packing format of the complex spectrum.
class fmt_t<T, t, width, prec> Wrapper that carries a value together with printf-style format options.
function fmt(const T &) Wrap value with a custom conversion specifier.
function fmtwidth(const T &) Wrap value with only width/precision, keeping the default conversion specifier.
namespace fn
variable expression_function<Fn, Args>::fn Callable applied to the arguments.
variable expression_lambda<T, Dims, Fn, Rnd>::fn
variable expression_adjacent<Fn, E>::fn
variable expression_vtable<T, Dims>::fn_begin_pass begin_pass callback.
variable expression_vtable<T, Dims>::fn_end_pass end_pass callback.
namespace fn_generic
variable expression_vtable<T, Dims>::fn_get_elements get_elements callbacks per axis/size.
struct fn_get_first
struct fn_get_second
struct fn_get_third
struct fn_is_between
struct fn_is_equal
struct fn_is_greater
struct fn_is_greaterorequal
struct fn_is_less
struct fn_is_lessorequal
struct fn_is_notequal
class fn_noinline<Fn> Functor wrapper that invokes Fn through noinline .
struct fn_noop
struct fn_pass_through
variable expression_vtable<T, Dims>::fn_reset reset callback.
class fn_return_constant<T, value> Functor returning a fixed constant of type T , ignoring all arguments.
class fn_returns<T>
variable expression_vtable<T, Dims>::fn_set_elements set_elements callbacks per axis/size.
variable expression_vtable<T, Dims>::fn_shapeof Shape query callback.
variable expression_vtable<T, Dims>::fn_substitute Placeholder substitution callback.
variable scalar_constants<T>::fold_constant_div Constant π/2 used as the folding divisor in trigonometric argument reduction.
variable scalar_constants<T>::fold_constant_hi High part of the π/2 folding constant (Cody-Waite reduction).
variable scalar_constants<T>::fold_constant_rem1 First remainder term of the π/2 folding constant (Cody-Waite reduction).
variable scalar_constants<T>::fold_constant_rem2 Second remainder term of the π/2 folding constant (Cody-Waite reduction).
function expression_with_arguments<Args>::fold_idx(Fn &&) Folds a callable over compile-time indices of the arguments.
function expression_with_arguments<Arg>::fold_idx(Fn &&) Folds a callable over the compile-time index of the argument.
function expression_with_arguments<Args>::fold(Fn &&) Folds a callable over the stored arguments, passing them by value.
function expression_with_arguments<Arg>::fold(Fn &&) Folds a callable over the stored argument.
function fopen_path(const file_path &, open_file_mode)
function audio_data<IsInterleaved>::for_channel(Fn &&) Applies a given function to the audio data for each channel.
variable force_compiletime_size_t Forces a compile-time evaluation of the given size_t value.
function audio_reader<T>::format() Returns audio format description
function audio_writer<T>::format() Returns audio format description
function audio_writer_wav<T>::format()
function audio_reader_wav<T>::format() Returns audio format description
function audio_reader_flac<T>::format() Returns audio format description
function audio_reader_mp3<T>::format() Returns audio format description
function audio_decoder::format() Retrieves the format of the currently opened audio file.
variable raw_decoding_options::format
function audio_encoder::format() Retrieves the current audio file format.
enum constant audiofile_error::format_error The audio file format is invalid or unsupported.
class format_t<chars> Callable object holding a compile-time format literal (built by operator""_format).
function format(const std::string &, const Args &...) Format values into a std::string using a {}"-based format string.
enum constant dft_family::fourstep Four-step FFT family.
enum constant dft_algorithm::fourstep Four-step FFT algorithm.
function fprintfmt(FILE *, const std::string &, const Args &...) Print to a file f using a {}"-based format string.
function fracdelay(E1 &&, T) Returns template expression that applies a fractional delay to the input
function fract(const T1 &) Returns the fractional part of x.
function fract(E1 &&) Creates an expression that returns the fractional part of x.
struct fraction Exact rational number represented as a numerator/denominator pair.
constructor fraction::fraction(i64, i64) Construct a fraction from a numerator and denominator.
variable stopwatch::frequency Tick frequency of the underlying clock, captured at construction.
function from_error_code(std::error_code) Converts a standard error code to an audiofile_error.
function shape<Dims>::from_flat(size_t) Convert a flat offset to multi-dimensional indices.
function shape<0>::from_flat(size_t) Inverse of to_flat : returns the empty shape.
function vec<T, N>::from_flatten(const vec<ST, SN> &) Reconstruct a (possibly compound) vector from a flat scalar vector.
struct from_lambda Tag type used to select the vec constructor that initializes elements from an index-based generator function.
function from_maskbits(T) Interprets value as a signed integer and tests the sign bit.
function f16::from_raw(u16)
function shape<Dims>::from_std_array(const std::array<TI, Dims> &) Build a shape from a std::array.
function vec<T, N>::frombits(const vec<U, M> &) Reinterpret the bits of v as a vector of this type.
function cvals_t<T, values>::front() Returns the first value
function portable_vec<T, N>::front()
function portable_vec<T, N>::front()
function vec<T, N>::front() Read the first element from a const lvalue vector.
function vec<T, N>::front() Read the first element from an rvalue vector.
function vec<T, N>::front() Access the first element of a non-const lvalue vector.
function expression_counter<T, Dims>::front()
function array_ref<T>::front()
function inline_vector<T, N>::front() Returns a reference to the first element.
function inline_vector<T, N>::front() Returns a const reference to the first element.
function small_buffer<T, Capacity>::front()
function small_buffer<T, Capacity>::front()
typedef fsubtype
typedef ftype
typedef samplerate_converter<T>::ftype
typedef expression_vtable<T, Dims>::func_get Signature of a get_elements callback: read N samples into dest.
typedef expression_vtable<T, Dims>::func_pass Signature of the begin_pass/end_pass callbacks.
typedef expression_vtable<T, Dims>::func_reset Signature of the reset callback.
typedef expression_vtable<T, Dims>::func_set Signature of a set_elements callback: write N samples from src.
typedef expression_vtable<T, Dims>::func_shapeof Signature of the shape query callback.
typedef expression_vtable<T, Dims>::func_substitute Signature of the placeholder substitution callback.
typedef function_arguments Extracts the argument types of a functor's
typedef function_result Extracts the return type of a functor's

G¶

function gamma(const T1 &) Returns the approximate gamma function of an argument.
function gamma(E1 &&) Creates an expression that returns the approximate gamma function of x.
function gather_stride(const T *) Gathers Nout elements from base at compile-time stride Stride.
function gather_stride(const T *, size_t) Gathers Nout groups of groupsize contiguous elements from base separated by stride.
function gather(const T *) Gathers elements from base at the given compile-time indices.
function gather(const T *, const vec<IT, N> &) Gathers N groups of groupsize contiguous elements from base using a vector of offsets.
function gather(const T *, const vec<u32, N> &) Gathers elements from base using a vector of indices.
function gather(const T *, size_t, Indices...) Gathers elements from base at the given runtime indices.
enum constant window_type::gaussian
function shape<Dims>::ge(const shape<dims> &) Element-wise greater-than-or-equal comparison.
function ge(E1 &&, E2 &&) Creates an expression that returns whether e1 is greater than or equal to e2.
function gen_cossin(T1, T2) Creates an 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 gen_exp2(T1, T2) Creates an expression that generates values using the following formula:
\\[ x_i = 2^{ start + i \cdot step } \\]
function gen_expj(T1, T2) Creates an expression that generates values using the following formula:
\\[ x_i = e^{ j ( start + i \cdot step ) } \\]
function gen_exp(T1, T2) Creates an expression that generates values using the following formula:
\\[ x_i = e^{ start + i \cdot step } \\]
function gen_linear(T1, T2) Creates an expression that generates values starting from start and using step as the increment between successive numbers.
function gen_random_normal(const random_state &, T, T) Creates an expression that produces normally distributed values using a copied state.
function gen_random_normal(std::reference_wrapper<random_state>, T, T) Creates an expression that produces normally distributed values using a referenced state.
function gen_random_normal(T, T) Creates an expression that produces normally distributed values seeded from the cycle counter.
function gen_random_range(const random_state &, T, T) Creates an expression that produces random values in [min, max) using a copied state.
function gen_random_range(std::reference_wrapper<random_state>, T, T) Creates an expression that produces random values in [min, max) using a referenced state.
function gen_random_range(T, T) Creates an expression that produces random values in [min, max) seeded from the cycle counter.
function gen_random_uniform() Creates an expression that produces uniform pseudorandom values in [0, 1) seeded from the cycle counter.
function gen_random_uniform(const random_state &) Creates an expression that produces uniform pseudorandom values in [0, 1) using a copied state.
function gen_random_uniform(std::reference_wrapper<random_state>) Creates an expression that produces uniform pseudorandom values in [0, 1) using a referenced state.
function gen_sin(T1, T2) Creates an expression that generates values using the following formula:
\\[ x_i = \sin( start + i \cdot step ) \\]
function generator<T, VecWidth, Class, Twork>::generate() Produces a vector of N values from the generator and advances its internal state.
function generate_vector() Generates a vector of length Nout by invoking Fn at each compile-time index.
class generator_cossin<T, VecWidth> Generator that produces interleaved cosine and sine values
\\[ x_i = \begin{cases} \cos(start + i \cdot step), & \text{if } i \text{ is even}\\ \sin(start + i \cdot step), & \text{otherwise} \end{cases} \\]
constructor generator_cossin<T, VecWidth>::generator_cossin<T, VecWidth>(T, T) Constructs an interleaved cosine/sine generator.
class generator_exp2<T, VecWidth> Generator that produces a base-2 exponential sequence \(x_i = 2^{ start + i \cdot step }\) .
constructor generator_exp2<T, VecWidth>::generator_exp2<T, VecWidth>(T, T) Constructs a base-2 exponential generator.
class generator_expj<T, VecWidth> Generator that produces a complex exponential \(x_i = e^{ j ( start + i \cdot step ) }\) .
constructor generator_expj<T, VecWidth>::generator_expj<T, VecWidth>(ST, ST) Constructs a complex exponential generator.
class generator_exp<T, VecWidth> Generator that produces an exponential sequence \(x_i = e^{ start + i \cdot step }\) .
constructor generator_exp<T, VecWidth>::generator_exp<T, VecWidth>(T, T) Constructs an exponential generator.
class generator_linear<T, VecWidth> Generator that produces an arithmetic progression \(x_i = start + i \cdot step\) .
constructor generator_linear<T, VecWidth>::generator_linear<T, VecWidth>(T, T) Constructs a linear generator.
class generator_sin<T, VecWidth> Generator that produces sine values \(x_i = \sin( start + i \cdot step )\) .
constructor generator_sin<T, VecWidth>::generator_sin<T, VecWidth>(T, T) Constructs a sine generator.
class generator<T, VecWidth, Class, Twork> CRTP base for stateful streaming generators that produce fixed-width vectors of values on demand.
enum constant cpu_t::generic
namespace generic
function special_value::get() Returns the value converted to type
function vec<T, N>::get() Get element at compile-time index (template parameter form).
function fixed_shape_t<Values>::get()
function expression_reduce<Tout, Dims, Twork, Tin, ReduceFn, TransformFn, FinalFn>::get() Returns the reduced value.
function integrated_vec<T>::get() Return the integrated loudness in LUFS, recomputing if needed.
function get_cpu() Returns the CPU instruction set selected for use at runtime.
function samplerate_converter<T>::get_delay() Gets the integer delay introduced by the resampler.
function get_element(E &&, shape<Dims>) Reads a single element from an expression at the given index.
function expression_adjacent<Fn, E>::get_elements(const expression_adjacent<Fn, E> &, shape<dims>, axis_params<VecAxis, N>)
function expression_bartlett_hann<T>::get_elements(const expression_bartlett_hann<T> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for
function expression_bartlett<T>::get_elements(const expression_bartlett<T> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for
function expression_blackman_harris<T>::get_elements(const expression_blackman_harris<T> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for
function expression_blackman<T>::get_elements(const expression_blackman<T> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for
function expression_bohman<T>::get_elements(const expression_bohman<T> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for
function get_elements(const expression_cast<T, Arg> &, const shape<NDims> &, const axis_params<Axis, N> &) Internal ADL-provided implementation for
function get_elements(const expression_concatenate<Arg1, Arg2, ConcatAxis> &, const shape<NDims> &, const axis_params<Axis, N> &) Internal ADL-provided implementation for
function expression_cosine_np<T>::get_elements(const expression_cosine_np<T> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for
function expression_cosine<T>::get_elements(const expression_cosine<T> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for
function get_elements(const expression_counter<T, 1> &, const shape<1> &, const axis_params<Axis, N> &) Internal ADL-provided implementation for
function get_elements(const expression_counter<T, dims> &, const shape<dims> &, const axis_params<Axis, N> &) Internal ADL-provided implementation for
function expression_delay<1, E, stateless, STag>::get_elements(const expression_delay<1, E, stateless, STag> &, shape<1>, axis_params<0, N>)
function expression_delay<delay, E, stateless, STag>::get_elements(const expression_delay<delay, E, stateless, STag> &, shape<1>, axis_params<0, 1>)
function expression_delay<delay, E, stateless, STag>::get_elements(const expression_delay<delay, E, stateless, STag> &, shape<1>, axis_params<0, N>)
function expression_dimensions<Dims, E>::get_elements(const expression_dimensions<Dims, E> &, shape<dims>, axis_params<VecAxis, N>)
function expression_fir<T, U, E1, stateless>::get_elements(const expression_fir<T, U, E1, stateless> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for expression_fir expressions.
function get_elements(const expression_fixshape<Arg, Shape> &, const shape<Traits::dims> &, const axis_params<Axis, N> &) Internal ADL-provided implementation for
function expression_flattop<T>::get_elements(const expression_flattop<T> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for
function get_elements(const expression_function<Fn, Args...> &, const shape<Dims> &, const axis_params<Axis, N> &) Reads a vector of elements from an expression_function .
function expression_gaussian<T>::get_elements(const expression_gaussian<T> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for
function expression_hamming<T>::get_elements(const expression_hamming<T> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for
function get_elements(const expression_handle<T, NDims> &, const shape<NDims> &, const axis_params<Axis, N> &) Internal ADL-provided implementation for expression_handle expressions.
function expression_hann<T>::get_elements(const expression_hann<T> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for
function expression_histogram<Bins, E, TCount>::get_elements(const expression_histogram<Bins, E, TCount> &, const shape<expression_with_traits<E>::dims> &, const axis_params<Axis, N> &)
function get_elements(const expression_iir<1, T, E1, Stateless> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for
function get_elements(const expression_iir_l<filters, T, E1, Stateless> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for
function get_elements(const expression_iir<filters, T, E1, Stateless> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for
function expression_kaiser<T>::get_elements(const expression_kaiser<T> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for
function get_elements(const expression_lambda<T, Dims, Fn, Rnd> &, const shape<Dims> &, const axis_params<Axis, N> &) Internal ADL-provided implementation for
function expression_lanczos<T>::get_elements(const expression_lanczos<T> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for
function get_elements(const expression_linspace<T, truncated> &, const shape<1> &, const axis_params<0, N> &) Internal ADL-provided implementation for
function expression_moving_sum<U, E1, STag, stateless>::get_elements(const expression_moving_sum<U, E1, STag, stateless> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for expression_moving_sum expressions.
function get_elements(const expression_padded<Arg> &, const shape<Traits::dims> &, const axis_params<Axis, N> &) Internal ADL-provided implementation for
function get_elements(const expression_placeholder<T, Dims, Key> &, shape<Dims>, axis_params<VecAxis, N>) Internal ADL-provided implementation for expression_placeholder expressions.
function expression_planck_taper<T>::get_elements(const expression_planck_taper<T> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for
function expression_random_normal<T, Dims, Reference>::get_elements(const expression_random_normal<T, Dims, Reference> &, shape<Dims>, axis_params<VecAxis, N>) Internal ADL-provided implementation for
function expression_random_range<T, Dims, Reference>::get_elements(const expression_random_range<T, Dims, Reference> &, shape<Dims>, axis_params<VecAxis, N>) Internal ADL-provided implementation for
function expression_random_uniform<T, Dims, Reference>::get_elements(const expression_random_uniform<T, Dims, Reference> &, shape<Dims>, axis_params<VecAxis, N>) Internal ADL-provided implementation for
function expression_rectangular<T>::get_elements(const expression_rectangular<T> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for
function get_elements(const expression_reshape<Arg, outdims> &, const shape<Traits::dims> &, const axis_params<Axis, N> &) Internal ADL-provided implementation for
function get_elements(const expression_reverse<Arg> &, const shape<Traits::dims> &, const axis_params<Axis, N> &) Internal ADL-provided implementation for
function get_elements(const expression_scalar<T> &, const shape<0> &, const axis_params<Axis, N> &) Internal ADL-provided implementation for
function expression_short_fir<tapcount, T, U, E1, stateless>::get_elements(const expression_short_fir<tapcount, T, U, E1, stateless> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for expression_short_fir expressions.
function get_elements(const expression_slice<Arg> &, const shape<NDims> &, const axis_params<Axis, N> &) Internal ADL-provided implementation for
function expression_trace<E>::get_elements(const expression_trace<E> &, shape<dims>, axis_params<VecAxis, N>)
function expression_triangular<T>::get_elements(const expression_triangular<T> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for
function expression_tukey<T>::get_elements(const expression_tukey<T> &, shape<1>, axis_params<0, N>) Internal ADL-provided implementation for
function generator<T, VecWidth, Class, Twork>::get_elements(const generator<T, VecWidth, Class, Twork> &, const shape<1> &, const axis_params<0, N> &) Internal ADL-provided implementation for generator expressions. Returns a vector of N generated values at the given index.
function get_elements(const strided_channel<T> &, const shape<1> &, const axis_params<0, N> &)
function get_elements(const tensor<T, NDims> &, const shape<NDims> &, const axis_params<Axis, N> &) Internal ADL-provided implementation for tensor expressions. Reads N elements along Axis starting at index from self.
function get_elements(const univector<T, Tag> &, const shape<1> &, const axis_params<0, N> &) Internal ADL-provided implementation for get_elements expressions.
function get_elements(T &&, const shape<0> &, const axis_params<Axis, N> &) Returns a scalar element broadcast to a vector.
typedef fn_generic::get_first
function get_first(T1 &&, Ts &&...) Function that returns its first argument and ignores all other arguments
function samplerate_converter<T>::get_fractional_delay() Gets the fractional delay introduced by the resampler.
function tensor<T, NDims>::get_range(index_t &, index_t &, index_t &, signed_index_t, const tensor_range &) Computes the range for a tensor_range specifier. Handles optional start/stop/step, negative indices, and clamping to the axis size.
function tensor<T, NDims>::get_range(index_t &, index_t &, index_t &, signed_index_t, index_t) Computes the range for a single integer index.
function tensor<T, NDims>::get_ranges(shape_type &, shape_type &, shape_type &, cvals_t<index_t, Num...>, const std::tuple<Index...> &) Computes the start, shape, and step for each axis given a set of indices and ranges. Axes without a corresponding index cover the full extent of the axis.
typedef fn_generic::get_second
function get_second(T1, T2 &&, Ts &&...) Function that returns its second argument and ignores all other arguments
function get_shape() Returns the static shape of an expression type.
function expression_traits<T>::get_shape()
function expression_with_traits<Arg>::get_shape()
function expression_function<Fn, Args>::get_shape() Returns the static shape of the expression type.
function expression_discard<Tin, Dims>::get_shape()
function expression_traits<expression_scalar<T>>::get_shape()
function expression_traits<expression_counter<T, Dims>>::get_shape()
function expression_traits<expression_slice<Arg>>::get_shape()
function expression_traits<expression_cast<T, Arg>>::get_shape()
function expression_traits<expression_lambda<T, Dims, Fn, Rnd>>::get_shape()
function expression_traits<expression_padded<Arg>>::get_shape()
function expression_traits<expression_reverse<Arg>>::get_shape()
function expression_traits<expression_fixshape<Arg, fixed_shape_t<ShapeValues...>>>::get_shape()
function expression_traits<expression_reshape<Arg, OutDims>>::get_shape()
function expression_traits<expression_linspace<T, truncated>>::get_shape()
function expression_traits<expression_concatenate<Arg1, Arg2, ConcatAxis>>::get_shape()
function expression_unpack<E>::get_shape()
function expression_dimensions<Dims, E>::get_shape()
function expression_traits<univector<T, Tag>>::get_shape() Returns the static shape of the univector type. For fixed-size vectors this is the compile-time size; otherwise it is undefined_size .
function expression_traits<expression_handle<T, Dims>>::get_shape() Static shape query: undefined for an unbound handle.
function expression_traits<expression_placeholder<T, Dims, Key>>::get_shape() Static shape query: undefined for an unbound placeholder.
function generator<T, VecWidth, Class, Twork>::get_shape()
function expression_traits<tensor<T, Dims>>::get_shape() Returns the static shape of the expression, with undefined extents.
function expression_random_uniform<T, Dims, Reference>::get_shape()
function expression_random_range<T, Dims, Reference>::get_shape()
function expression_random_normal<T, Dims, Reference>::get_shape()
function expression_reduce<Tout, Dims, Twork, Tin, ReduceFn, TransformFn, FinalFn>::get_shape()
function expression_window<T>::get_shape()
function expression_delay<delay, E, stateless, STag>::get_shape()
function expression_delay<1, E, stateless, STag>::get_shape()
function expression_goertzel<T>::get_shape()
function expression_parallel_goertzel<T, width>::get_shape()
function expression_traits<strided_channel<T>>::get_shape()
function generator<T, VecWidth, Class, Twork>::get_shape(const Class &)
function expression_traits<expression_cast<T, Arg>>::get_shape(const expression_cast<T, Arg> &)
function expression_traits<expression_concatenate<Arg1, Arg2, ConcatAxis>>::get_shape(const expression_concatenate<Arg1, Arg2, ConcatAxis> &)
function expression_traits<expression_counter<T, Dims>>::get_shape(const expression_counter<T, Dims> &)
function expression_delay<1, E, stateless, STag>::get_shape(const expression_delay<1, E, stateless, STag> &)
function expression_delay<delay, E, stateless, STag>::get_shape(const expression_delay<delay, E, stateless, STag> &)
function expression_dimensions<Dims, E>::get_shape(const expression_dimensions<Dims, E> &)
function expression_discard<Tin, Dims>::get_shape(const expression_discard<Tin, Dims> &)
function expression_traits<expression_fixshape<Arg, fixed_shape_t<ShapeValues...>>>::get_shape(const expression_fixshape<Arg, fixed_shape_t<ShapeValues...>> &)
function expression_function<Fn, Args>::get_shape(const expression_function<Fn, Args...> &) Returns the shape of the expression instance.
function expression_goertzel<T>::get_shape(const expression_goertzel<T> &)
function expression_traits<expression_handle<T, Dims>>::get_shape(const expression_handle<T, Dims> &) Query the shape of the referenced expression via its vtable.
function expression_traits<expression_lambda<T, Dims, Fn, Rnd>>::get_shape(const expression_lambda<T, Dims, Fn, Rnd> &)
function expression_traits<expression_linspace<T, truncated>>::get_shape(const expression_linspace<T, truncated> &)
function expression_traits<expression_padded<Arg>>::get_shape(const expression_padded<Arg> &)
function expression_parallel_goertzel<T, width>::get_shape(const expression_parallel_goertzel<T, width> &)
function expression_traits<expression_placeholder<T, Dims, Key>>::get_shape(const expression_placeholder<T, Dims, Key> &) Shape of the bound expression, or infinite_size when unbound.
function expression_random_normal<T, Dims, Reference>::get_shape(const expression_random_normal<T, Dims, Reference> &)
function expression_random_range<T, Dims, Reference>::get_shape(const expression_random_range<T, Dims, Reference> &)
function expression_random_uniform<T, Dims, Reference>::get_shape(const expression_random_uniform<T, Dims, Reference> &)
function expression_reduce<Tout, Dims, Twork, Tin, ReduceFn, TransformFn, FinalFn>::get_shape(const expression_reduce<Tout, Dims, Twork, Tin, ReduceFn, TransformFn, FinalFn> &)
function expression_traits<expression_reshape<Arg, OutDims>>::get_shape(const expression_reshape<Arg, OutDims> &)
function expression_traits<expression_reverse<Arg>>::get_shape(const expression_reverse<Arg> &)
function expression_traits<expression_scalar<T>>::get_shape(const expression_scalar<T> &)
function expression_traits<expression_slice<Arg>>::get_shape(const expression_slice<Arg> &)
function expression_unpack<E>::get_shape(const expression_unpack<E...> &)
function expression_window<T>::get_shape(const expression_window<T> &)
function expression_with_traits<Arg>::get_shape(const expression_with_traits<Arg> &)
function expression_traits<strided_channel<T>>::get_shape(const strided_channel<T> &)
function expression_traits<T>::get_shape(const T &)
function expression_traits<tensor<T, Dims>>::get_shape(const tensor<T, Dims> &) Returns the shape of self.
function expression_traits<univector<T, Tag>>::get_shape(const univector<T, Tag> &) Returns the runtime shape of u.
function get_shape(T &&) Returns the shape of an expression instance.
function ebu_channel<T>::get_speaker() Return the speaker role assigned to this channel.
typedef fn_generic::get_third
function get_third(T1 &&, T2 &&, T3 &&, Ts &&...) Function that returns its third argument and ignores all other arguments
function generator_sin<T, VecWidth>::get_value() Returns the sine components of the current interleaved cos/sin state.
function ebu_r128<T>::get_values(T &, T &, T &, T &, T &) Read all measured loudness values.
function representation<fmt_t<kfr::complex<T>, t, width, prec>>::get(const fmt_t<kfr::complex<T>, t, width, prec> &) Converts a formatted complex value to its string form.
function representation<fmt_t<kfr::generic::vec<T, N>, t, width, prec>>::get(const fmt_t<kfr::generic::vec<T, N>, t, width, prec> &)
function representation<fmt_t<kfr::tensor<T, dims>, t, width, prec>>::get(const fmt_t<kfr::tensor<T, dims>, t, width, prec> &) Returns the formatted string representation of value.
function representation<fmt_t<kfr::univector<T, Tag>, t, width, prec>>::get(const fmt_t<kfr::univector<T, Tag>, t, width, prec> &) Returns a string representation of value with per-element formatting.
function representation<kfr::complex<T>>::get(const kfr::complex<T> &) Converts a complex value to its string form.
function representation<kfr::fraction>::get(const kfr::fraction &)
function representation<kfr::generic::mask<T, N>>::get(const kfr::generic::mask<T, N> &)
function representation<kfr::generic::vec<T, N>>::get(const kfr::generic::vec<T, N> &)
function representation<kfr::shape<dims>>::get(const kfr::shape<dims> &) Returns the string representation of value.
function representation<kfr::special_value>::get(const kfr::special_value &)
function representation<kfr::tensor<T, dims>>::get(const kfr::tensor<T, dims> &) Returns the string representation of value.
function representation<kfr::univector<T, Tag>>::get(const kfr::univector<T, Tag> &) Returns a string representation of value.
function representation<named_arg<T>>::get(const named_arg<T> &)
function representation<std::array<T, Size>>::get(const std::array<T, Size> &)
function representation<std::pair<T1, T2>>::get(const std::pair<T1, T2> &)
function representation<std::shared_ptr<T1>>::get(const std::shared_ptr<T1> &)
function representation<std::shared_ptr<void>>::get(const std::shared_ptr<void> &)
function representation<std::string_view>::get(const std::string_view &)
function representation<std::unique_ptr<T1>>::get(const std::unique_ptr<T1> &)
function representation<std::vector<T, Allocator>>::get(const std::vector<T, Allocator> &)
function representation<std::weak_ptr<T1>>::get(const std::weak_ptr<T1> &)
function representation<T>::get(const T &)
function cvals_t<T, values>::get(csize_t<index>) Returns the value at
function ctypes_t<Ts>::get(csize_t<index>) Returns a ctype_t wrapping the type at position
function vec<T, N>::get(csize_t<index>) Get element at compile-time index (compound element type).
function dft_cache_impl<int>::get(ctype_t<f32>, size_t)
function dft_cache_impl<int>::get(ctype_t<f64>, size_t)
function representation<kfr::cpu_t>::get(kfr::cpu_t)
function representation<kfr::npy_decode_result>::get(kfr::npy_decode_result)
function expression_with_arguments<Args>::getmask(csize_t<idx>) Returns the dimension mask for the argument at position idx.
function expression_with_arguments<Arg>::getmask(csize_t<idx>) Returns the sentinel dimension mask for the single argument.
function dft_cache_impl<int>::getreal(ctype_t<f32>, size_t)
function dft_cache_impl<int>::getreal(ctype_t<f64>, size_t)
function vec<T, N>::get(size_t) Get element at runtime index (compound element type).
function univector<T, Size>::get(size_t, value_type) Returns the element at index, or fallback_value if index is out of range.
function univector<T, tag_array_ref>::get(size_t, value_type) Returns the element at index, or fallback_value if index is out of range.
function univector<T, tag_dynamic_vector>::get(size_t, value_type) Returns the element at index, or fallback_value if index is out of range.
function lra_vec<T>::get(T &, T &) Return the LRA percentile loudness bounds.
namespace glsl_names
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.
function greater(const T1 &, const T2 &) Element-wise greater-than comparison.
function greaterorequal(const T1 &, const T2 &) Element-wise greater-or-equal comparison.
function gt(E1 &&, E2 &&) Creates an expression that returns whether e1 is greater than e2.

H¶

variable vec<T, N>::(Anonymous union at simd/vec.hpp:831:5)::h
function hadd(const vec<T, N> &) Computes the sum of all elements in the vector.
class half_comparison<L>
constructor half_comparison<L>::half_comparison<L>(L &&)
enum constant window_type::hamming
variable expression_placeholder<T, Dims, Key>::handle Handle to the bound expression, or empty if unbound.
variable file_reader<T>::handle
variable file_writer<T>::handle
enum constant window_type::hann
variable cpu_features::has3DNOW AMD 3DNow! instructions.
variable cpu_features::has3DNOWEXT AMD 3DNow! extension instructions.
concept has_begin_end Concept satisfied by types that support
function audio_decoder::has_chunk(std::span<const std::byte>) Checks if the file contains a chunk with the specified ID.
function tensor<T, NDims>::has_contiguous_strides(const shape_type &, const shape_type &) Returns true if strides describe a packed layout in some axis order.
concept has_data_size Concept satisfied by types that support
concept has_expression_traits Concept that is satisfied when expression_traits<T> is well-formed.
function shape<Dims>::has_infinity() Detect the infinite_size sentinel among the axes.
function shape<0>::has_infinity() A scalar shape has no axes, so it can never contain infinite_size .
variable tensor<T, NDims>::has_tensor_range Returns true if any of Index... is a tensor_range.
variable cpu_features::hasABM AMD Advanced Bit Manipulation (LZCNT + POPCNT on AMD).
variable cpu_features::hasADX ADX instruction set (arbitrary-precision add with carry).
variable cpu_features::hasAES AES instruction set.
variable cpu_features::hasAVX AVX instruction set (CPUID-reported, see hasAVXOSSUPPORT).
variable cpu_features::hasAVX2 AVX2 instruction set.
variable cpu_features::hasAVX512BW AVX-512 Byte and Word.
variable cpu_features::hasAVX512CD AVX-512 Conflict Detection.
variable cpu_features::hasAVX512DQ AVX-512 Doubleword and Quadword.
variable cpu_features::hasAVX512ER AVX-512 Exponential and Reciprocal instructions.
variable cpu_features::hasAVX512F AVX-512 Foundation.
variable cpu_features::hasAVX512OSSUPPORT AVX-512 state enabled by the OS (XCR0[7:5] == 0b111).
variable cpu_features::hasAVX512PF AVX-512 Prefetch.
variable cpu_features::hasAVX512VL AVX-512 Vector Length extensions.
variable cpu_features::hasAVXOSSUPPORT AVX state enabled by the OS (XCR0[2:1] == 0b11).
variable cpu_features::hasBMI1 Bit Manipulation Instructions 1.
variable cpu_features::hasBMI2 Bit Manipulation Instructions 2.
variable cpu_features::hasCLFSH CLFLUSH instruction.
variable cpu_features::hasCMOV CMOVcc conditional move.
variable cpu_features::hasCMPXCHG16B CMPXCHG16B (128-bit compare-exchange).
variable cpu_features::hasCX8 CMPXCHG8B (64-bit compare-exchange).
variable cpu_features::hasERMS Enhanced REP MOVSB/STOSB.
variable cpu_features::hasF16C F16C half-precision conversion.
variable cpu_features::hasFMA Fused Multiply-Add (FMA3).
variable cpu_features::hasFSGSBASE RDFSBASE/WRFSBASE instructions.
variable cpu_features::hasFXSR FXSAVE/FXRSTOR.
variable cpu_features::hasHLE Hardware Lock Elision (Intel only).
variable cpu_features::hasINVPCID INVPCID instruction.
variable cpu_features::hasLAHF LAHF/SAHF in 64-bit mode.
variable cpu_features::hasLZCNT LZCNT instruction (Intel only).
variable cpu_features::hasMMX MMX.
variable cpu_features::hasMMXEXT AMD MMX extensions.
variable cpu_features::hasMONITOR MONITOR/MWAIT.
variable cpu_features::hasMOVBE MOVBE (move byte-swap).
variable cpu_features::hasMSR Model-Specific Registers (RDMSR/WRMSR).
variable cpu_features::hasOSXSAVE OS enables XSAVE/XRSTOR (CPUID.1:ECX[27]).
variable cpu_features::hasPCLMULQDQ PCLMULQDQ carry-less multiplication.
variable cpu_features::hasPOPCNT POPCNT instruction.
variable cpu_features::hasPREFETCHWT1 PREFETCHWT1 (Intel Xeon Phi).
variable cpu_features::hasRDRAND RDRAND random number.
variable cpu_features::hasRDSEED RDSEED random seed.
variable cpu_features::hasRDTSCP RDTSCP instruction (Intel only).
variable cpu_features::hasRTM Restricted Transactional Memory (Intel only).
variable cpu_features::hasSEP SYSENTER/SYSEXIT.
variable cpu_features::hasSHA SHA instruction set.
variable cpu_features::hasSSE SSE.
variable cpu_features::hasSSE2 SSE2.
variable cpu_features::hasSSE3 SSE3.
variable cpu_features::hasSSE41 SSE4.1.
variable cpu_features::hasSSE42 SSE4.2.
variable cpu_features::hasSSE4a AMD SSE4a.
variable cpu_features::hasSSSE3 SSSE3.
variable cpu_features::hasSYSCALL SYSCALL/SYSRET (Intel only).
variable cpu_features::hasTBM AMD Trailing Bit Manipulation.
variable cpu_features::hasXOP AMD XOP.
variable cpu_features::hasXSAVE XSAVE/XRSTOR.
function havg(const vec<T, N> &) Computes the arithmetic mean (average) of all elements in the vector.
function hbitwiseand(const vec<T, N> &) Computes the bitwise AND of all elements in the vector.
function hbitwiseor(const vec<T, N> &) Computes the bitwise OR of all elements in the vector.
function hbitwisexor(const vec<T, N> &) Computes the bitwise XOR of all elements in the vector.
function hdot(const vec<T, N> &, const vec<T, N> &) Computes the dot product of two vectors.
variable moving_sum_state<U, Tag>::head_cursor Write cursor (newest sample).
variable moving_sum_state<U, tag_dynamic_vector>::head_cursor Write cursor (newest sample).
function map_indices_impl<size, Fn>::helper(csizes_t<I...>)
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.
variable vec_halves<T, N>::high Upper (remainder) half.
enum constant sample_rate_conversion_quality::high High quality.
function special_scalar_constants<T>::highbitmask() Returns a value with only the most significant bit set.
function special_scalar_constants<float>::highbitmask() Returns negative zero, whose sign bit is set.
function special_scalar_constants<double>::highbitmask() Returns negative zero, whose sign bit is set.
function special_scalar_constants<bit<T>>::highbitmask() Mask with only the most significant bit set, expressed as a bit.
function high(const vec<T, N> &) Extracts the high subvector of x with non-power-of-two-aware sizing.
enum constant cpu_t::highest
function highhalf(const vec<T, N> &) Extracts the upper half of x.
function highhalf(vec_shape<T, N>) Shape-only overload of highhalf() for type deduction.
enum constant biquad_type::highpass Passes frequencies above the cutoff.
enum constant biquad_type::highshelf High-shelf equalizer filter.
function high(vec_shape<T, N>) Shape-only overload of high() for type deduction.
class histogram_data<Bins, TCount> Holds the bin counts for a histogram.
constructor histogram_data<Bins, TCount>::histogram_data<Bins, TCount>(size_t) Constructs a runtime-sized histogram.
function histogram_expression(E &&) Creates an expression that computes a histogram as data flows through it.
function histogram_expression(E &&, size_t) Creates an expression that computes a histogram as data flows through it.
function histogram(E &&) Returns the histogram of the expression data.
function histogram(E &&, size_t) Returns the histogram of the expression data.
function hmax(const vec<T, N> &) Computes the maximum element in the vector.
function hmin(const vec<T, N> &) Computes the minimum element in the vector.
function hmul(const vec<T, N> &) Computes the product of all elements in the vector.
function horizontal(const vec<T, N> &, ReduceFn &&) Applies a reduction function horizontally across all elements of the vector.
function horner_even(const T1 &, const Ts &...) Calculate polynomial using Horner's method (even powers)
function horner_even(E &&...) Creates an expression that evaluates a polynomial with even powers using Horner's method.
function horner_odd(const T1 &, const Ts &...) Calculate polynomial using Horner's method (odd powers)
function horner_odd(E &&...) Creates an expression that evaluates a polynomial with odd powers using Horner's method.
function horner(const T1 &, const Ts &...) Calculate polynomial using Horner's method
function horner(E &&...) Creates an expression that evaluates a polynomial using Horner's method.
function hproduct(const vec<T, N> &) Computes the product of all elements in the vector.
function hrms(const vec<T, N> &) Computes the root-mean-square (RMS) of the vector elements.
function hsum(const vec<T, N> &) Computes the sum of all elements in the vector.

I¶

enum constant datatype::i
typedef i16
enum constant datatype::i16
enum constant audio_sample_type::i16
typedef i16x1
typedef i16x16
typedef i16x2
typedef i16x2x2
typedef i16x3
typedef i16x32
typedef i16x4
typedef i16x4x4
typedef i16x64
typedef i16x8
enum constant datatype::i24
struct i24 Signed 24-bit integer stored in three bytes (little-endian).
constructor i24::i24() Default constructor leaving the value uninitialized.
enum constant audio_sample_type::i24
constructor i24::i24(i32) Construct from a 32-bit signed integer, truncating to 24 bits.
typedef i32
enum constant datatype::i32
enum constant audio_sample_type::i32
typedef i32x1
typedef i32x16
typedef i32x2
typedef i32x2x2
typedef i32x3
typedef i32x32
typedef i32x4
typedef i32x4x4
typedef i32x64
typedef i32x8
typedef i64
enum constant datatype::i64
typedef i64x1
typedef i64x16
typedef i64x2
typedef i64x2x2
typedef i64x3
typedef i64x32
typedef i64x4
typedef i64x4x4
typedef i64x64
typedef i64x8
typedef i8
enum constant datatype::i8
typedef i8x1
typedef i8x16
typedef i8x2
typedef i8x2x2
typedef i8x3
typedef i8x32
typedef i8x4
typedef i8x4x4
typedef i8x64
typedef i8x8
concept i_class
function ibitcast(const From &) Reinterpret the bits of a scalar value as its signed counterpart type.
function ibitcast(const vec<From, N> &) Reinterpret the bits of a vector as a vector of its signed counterpart type.
function iceil(const T1 &) Returns the smallest integer value not less than x, as an integer type.
function iceil(E1 &&) Creates an expression that returns the integer equivalent of ceil( x).
variable type_id_t::id
function idft(const univector<complex<T>, Tag> &) Performs the inverse complex DFT using a cached plan.
enum constant audiofile_codec::ieee_float
function ifloor(const T1 &) Returns the largest integer value not greater than x, as an integer type.
function ifloor(E1 &&) Creates an expression that returns the integer equivalent of floor( x).
function iir_bandpass(const zpk &, double, double, double) Designs a digital bandpass IIR filter and returns ZPK coefficients.
function iir_bandstop(const zpk &, double, double, double) Designs a digital bandstop (notch) IIR filter and returns ZPK coefficients.
class iir_filter<T> Runtime IIR filter object usable as a streaming filter.
constructor iir_filter<T>::iir_filter<T>(const iir_params<T> &) Construct the filter from biquad parameters.
function iir_highpass(const zpk &, double, double) Designs a digital highpass IIR filter and returns ZPK coefficients.
function iir_lowpass(const zpk &, double, double) Designs a digital lowpass IIR filter and returns ZPK coefficients.
deduction guide iir_params
deduction guide iir_params
deduction guide iir_params
deduction guide iir_params
deduction guide iir_params
deduction guide iir_params
class iir_params<T, filters> Fixed-size container of biquad coefficients stored as SoA vectors.
constructor iir_params<T, filters>::iir_params<T, filters>() Default constructor: pass-through (b0=1, rest 0).
constructor iir_params<T, filters>::iir_params<T, filters>(const biquad_section<T> &) Construct from a single biquad_section.
constructor iir_params<T, filters>::iir_params<T, filters>(const biquad_section<T> *, size_t) Build from an array of biquad_section.
function iir_params<T, filters>::iir_params<T, filters>(Container &&) Construct from any container with data()/size().
class iir_params<T, tag_dynamic_vector> Dynamic-size specialization of iir_params.
constructor iir_params<T, tag_dynamic_vector>::iir_params<T, tag_dynamic_vector>()
constructor iir_params<T, tag_dynamic_vector>::iir_params<T, tag_dynamic_vector>(const biquad_section<T> &) Construct from a single biquad_section.
constructor iir_params<T, tag_dynamic_vector>::iir_params<T, tag_dynamic_vector>(const biquad_section<T> *, size_t) Build from a C array of
function iir_params<T, tag_dynamic_vector>::iir_params<T, tag_dynamic_vector>(const iir_params<T, filters> &) Convert a fixed-size iir_params to the dynamic-size form.
constructor iir_params<T, tag_dynamic_vector>::iir_params<T, tag_dynamic_vector>(const iir_params<T, tag_dynamic_vector> &)
function iir_params<T, tag_dynamic_vector>::iir_params<T, tag_dynamic_vector>(Container &&) Construct from any container with data()/size().
constructor iir_params<T, tag_dynamic_vector>::iir_params<T, tag_dynamic_vector>(iir_params<T, tag_dynamic_vector> &&)
constructor iir_params<T, tag_dynamic_vector>::iir_params<T, tag_dynamic_vector>(size_t) Allocate storage for
constructor iir_params<T, tag_dynamic_vector>::iir_params<T, tag_dynamic_vector>(std::vector<biquad_section<T>> &&) Move-construct from a vector of sections.
deduction guide iir_state
deduction guide iir_state
class iir_state<T, filters> Combined IIR filter parameters and runtime state.
function iir_state<T, filters>::iir_state<T, filters>(Args &&...) Forwarding constructor for the embedded iir_params.
function iir(E1 &&, const iir_params<T, tag_dynamic_vector> &) Returns a template expression that applies a runtime-sized biquad cascade to the input.
function iir(E1 &&, const zpk &) Applies an IIR filter (in ZPK form) to an input signal expression.
function iir(E1 &&, iir_params<T, filters>) Returns a template expression that applies a biquad filter cascade to the input.
function iir(E1 &&, std::reference_wrapper<iir_state<T, filters>>) Returns a template expression that applies a biquad cascade using externally-owned state.
function ilog2(T) Returns the base-2 logarithm of
function imag(const complex<T> &) Returns the imaginary part of the complex value
function imag(const vec<complex<T>, N> &) Returns the imaginary parts of a vector of complex values.
function imag(E1 &&) Creates an expression that returns the imaginary part of the complex value x.
typedef imax
function implicit_cast(U &&)
variable expression_dimensions<Dims, E>::in_dims
variable expression_reshape<Arg, OutDims>::in_shape
variable vec<T, N>::element::index Element index within
variable tensor<T, NDims>::nested_iterator_t::index
typedef index_t Unsigned integer type used for tensor indices and axis sizes.
variable index_undefined Sentinel index value meaning "no index".
variable tensor<T, NDims>::tensor_iterator::indices
function indices(const shape<Dims> &, axis_params<VecAxis, N>) Computes the vector of indices along an axis for a vectorized read.
variable indicesfor Constant instance of indicesfor_t for the given type list
typedef indicesfor_t Returns a sequence of indices
variable infinite_size Sentinel value denoting a dimension of unbounded/unknown size.
enum constant special_constant::infinity positive infinity
variable infinity Positive infinity as a double .
variable scalar_constants<T>::infinity The representation of positive infinity for the type T.
function timestamps<max_count, fence>::init() Reset the profiler, capturing the current cycle count as time zero.
function generator_expj<T, VecWidth>::init_cossin(ST, ST) Initializes a vector of complex exponentials with angular frequency w and starting phase phase.
function generator_cossin<T, VecWidth>::init_cossin(T, T) Initializes a vector of interleaved cosine/sine pairs with angular frequency w and starting phase phase.
function dft_stage<T>::initialize(size_t)
class initialvalue<T> Used to determine the initial value for reduce functions.
class inline_vector<T, N> A sequence container with fixed-capacity inline storage.
constructor inline_vector<T, N>::inline_vector<T, N>() Creates an empty vector.
constructor inline_vector<T, N>::inline_vector<T, N>(const inline_vector<T, N> &)
constructor inline_vector<T, N>::inline_vector<T, N>(inline_vector<T, N> &&)
function inline_vector<T, N>::inline_vector<T, N>(Iter, Iter) Creates a vector from the range [first, last) .
constructor inline_vector<T, N>::inline_vector<T, N>(size_type) Creates a vector holding initial_size value-initialized elements.
constructor inline_vector<T, N>::inline_vector<T, N>(size_type, T) Creates a vector holding initial_size copies of initial_value .
constructor inline_vector<T, N>::inline_vector<T, N>(std::initializer_list<T>) Creates a vector from a brace-enclosed initializer list.
function convolve_filter<T>::input_block_size() Returns the processing block size.
variable dft_resampler_params::input_block_size Computed FFT block size (power of two) satisfying the overlap-save constraint.
function dft_resampler<T>::input_block_size() Returns the input FFT block size \(N\) .
concept input_expression Concept satisfied by expressions that can be read from.
function dft_resampler<T>::input_hop() Returns the number of new input samples consumed per frame.
concept input_output_expression Concept satisfied by expressions that are both readable and writable.
variable convolve_filter<T>::input_position
variable samplerate_converter<T>::input_position Current input position.
function samplerate_converter<T>::input_position_to_intermediate(itype) Converts an input position to an intermediate (interpolated) position.
function samplerate_converter<T>::input_position_to_output(itype) Converts an input position to the corresponding output position.
variable expression_padded<Arg>::input_shape
variable expression_reverse<Arg>::input_shape
function samplerate_converter<T>::input_size_for_output(itype) Calculates the input size required to produce a given output size (pull method).
typedef map_indices_impl<size, Fn>::input_type
function inrange(const T1 &, const T2 &, const T3 &) Test whether each element lies within a closed range.
function inserthigh(T, const vec<T, N> &) Inserts a scalar x at the high (right) end of y, shifting y one lane to the low (left) side.
function insertleft(T, const vec<T, N> &) Legacy alias for insertlow().
function insertlow(T, const vec<T, N> &) Inserts a scalar x at the low (left) end of y, shifting y one lane to the high (right) side.
function insertright(T, const vec<T, N> &) Legacy alias for inserthigh().
function expression_resource::instance()
function expression_resource_impl<E>::instance()
variable expression_handle<T, Dims>::instance Pointer to the concrete expression instance.
function dft_cache_impl<int>::instance()
typedef opencl_names::int16
typedef opencl_names::int2
typedef opencl_names::int3
typedef opencl_names::int4
typedef opencl_names::int8
typedef int_type Maps a bit width to the corresponding signed integer type
enum constant special_constant::integer integer literal carried by
variable integer_types Type list of all integer element types (signed and unsigned).
variable integer_vector_types Instance of integer_vector_types_t for use as a value parameter pack.
typedef integer_vector_types_t Type list of all integer vector instantiations for the test sizes.
class integrated_vec<T> Buffer of momentary mean-square energies used to compute the integrated (program) loudness per EBU R128 §3560.
constructor integrated_vec<T>::integrated_vec<T>()
function audio_data<IsInterleaved>::interlaved() Returns a reference to the interleaved audio data.
function interleave(const univector2d<Tin, Tag1, Tag2> &) Interleaves audio samples of a 2D univector into a new buffer.
function interleave(const vec<T, N> &, const vec<T, N> &) Interleaves the lanes of two equal-length vectors x and y.
function interleave(E1 &&, E2 &&) Creates an expression that interleaves the lanes of x and y.
function interleavehalves(const vec<T, N> &) Interleaves the two halves of x.
function interleave(Tout *, const Tin **, size_t, size_t) Interleaves and converts audio samples into a single buffer.
function interleave(univector<Tout, Tag1> &, const univector2d<Tin, Tag2, Tag3> &) Interleaves and converts audio samples from a 2D univector.
namespace internal
enum constant dft_order::internal Possibly bit/digit-reversed, implementation-defined, may be faster to compute
enum constant audiofile_error::internal_error An internal error occurred.
namespace internal_generic
variable samplerate_converter<T>::interpolation_factor Interpolation factor.
namespace intr
enum constant audiofile_error::invalid_argument Invalid argument passed
enum constant npy_decode_result::invalid_header Malformed header
enum constant npy_decode_result::invalid_shape Shape mismatch
enum constant npy_decode_result::invalid_type Type mismatch
enum constant dft_type::inverse Only the inverse transform.
function special_scalar_constants<T>::invhighbitmask() Returns a value with every bit except the most significant bit set.
function special_scalar_constants<float>::invhighbitmask() Returns a floating-point value with every bit except the sign bit set.
function special_scalar_constants<double>::invhighbitmask() Returns a floating-point value with every bit except the sign bit set.
function special_scalar_constants<bit<T>>::invhighbitmask() Inverse of highbitmask, i.e. all bits except the high bit set.
variable expression_linspace<T, truncated>::invsize
enum constant audiofile_error::io_error An input/output error occurred.
function ipow(const T &, int) Integer power.
function ipow(E1 &&, E2 &&) Creates an expression that returns x raised to the integer power b.
variable convolve_filter<T>::ir_segments
function irealdft(const univector<complex<T>, Tag> &) Performs the inverse complex-to-real DFT using a cached plan.
function iround(const T1 &) Returns the nearest integer value to x, as an integer type.
function iround(E1 &&) Creates an expression that returns the integer equivalent of round( x).
variable univector<T, Size>::is_aligned True: aligned to the maximum vector alignment.
variable univector<T, tag_array_ref>::is_aligned False: alignment of the referenced data is unknown.
variable univector<T, tag_dynamic_vector>::is_aligned True: aligned to the maximum vector alignment.
variable is_arg Inline variable that is true when T (after decay) is a numeric or boolean type and can therefore be passed by value as an argument.
variable univector<T, Size>::is_array True: backed by std::array.
variable univector<T, tag_array_ref>::is_array False: not backed by std::array.
variable univector<T, tag_dynamic_vector>::is_array False: not backed by std::array.
variable univector<T, Size>::is_array_ref False: owns its data.
variable univector<T, tag_array_ref>::is_array_ref True: holds a reference to external data.
variable univector<T, tag_dynamic_vector>::is_array_ref False: owns its data.
function is_between(T, std::type_identity_t<T>, std::type_identity_t<T>)
variable is_bit True when T is a bit specialization.
variable is_complex Variable template: true if T is a complex specialization.
variable is_compound_type if
function is_constant_val(cval_t<T, value>) Returns
function is_constant_val(T) Returns
function tensor<T, NDims>::is_contiguous() Returns true if the tensor data is stored contiguously.
function is_divisible(T, T)
function dft_resampler_params::is_downsampling() Returns true if this is a downsampling configuration.
function dft_resampler<T>::is_downsampling() Returns true if this resampler downsamples by factor() .
function tensor<T, NDims>::tensor_iterator::is_end() Returns true if this iterator is the end sentinel.
function is_equal(const T1 &, const T2 &) Returns
function is_even(T) Returns
variable is_expr_element Inline variable that is true when T is a non-cv-qualified scalar vector element type.
variable is_f_class
function is_greater(const T1 &, const T2 &) Returns
function is_greaterorequal(const T1 &, const T2 &) Returns
variable is_i_class
variable is_infinite Inline variable that is true when the shape of E is infinite.
function dft_plan<T>::is_initialized() Checks whether the plan is non-empty.
function dft_plan_real<T>::is_initialized() Checks whether the plan is non-empty.
function dft_plan_md<T, Dims>::is_initialized() Checks whether the plan is non-empty.
function dft_plan_md_real<T, Dims>::is_initialized() Checks whether the plan is non-empty.
variable is_input_expression Inline variable that is true when E satisfies input_expression .
variable is_input_output_expression Inline variable that is true when E satisfies input_output_expression .
function tensor<T, NDims>::is_last_contiguous() Returns true if the last axis has stride 1.
function is_less(const T1 &, const T2 &) Returns
function is_lessorequal(const T1 &, const T2 &) Returns
function is_notequal(const T1 &, const T2 &) Returns
variable is_number if
variable is_number_or_bool if
variable is_numbers
variable is_numeric Check if the type argument is a number or a compound type of numbers
variable is_numeric_args Check if the type arguments are numbers or compound types of numbers
variable is_numeric_or_bool Check if the type argument is a number, bool or a compound type of numbers or bool
function is_odd(T) Returns
variable is_output_expression Inline variable that is true when E satisfies output_expression .
function is_poweroftwo(T) Returns
variable compound_type_traits<T>::is_scalar
variable compound_type_traits<std::pair<T, T>>::is_scalar
variable compound_type_traits<kfr::vec_shape<T, N>>::is_scalar
variable compound_type_traits<kfr::vec<T, N>>::is_scalar
variable compound_type_traits<std::complex<T>>::is_scalar because a complex value is not a scalar.
function is_sequence(csizes_t<number, numbers...>)
function audio_data<IsInterleaved>::is_silent(fbase) Checks whether all samples in the buffer are effectively silent within a given amplitude threshold.
variable is_simd_float_type True when T is a floating-point SIMD element type.
variable is_simd_int_type True when T is an integer SIMD element type.
function is_simd_size(size_t) Checks whether size is a valid SIMD vector size for type T.
variable is_simd_type True when T is one of the scalar types usable as a SIMD element.
function is_single_codec(audiofile_container) Checks if a container supports a single codec.
variable is_u_class
typedef is_val_t
variable is_vec True if T is a vec instantiation.
variable is_vec_element True if T (after stripping cv) is usable as a vec element type.
variable univector<T, Size>::is_vector False: not dynamically sized.
variable univector<T, tag_array_ref>::is_vector False: not dynamically sized.
variable univector<T, tag_dynamic_vector>::is_vector True: dynamically sized.
variable cpu_features::isAMD Vendor string is "AuthenticAMD".
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.
function isfinite(const vec<T, N> &) Detect finite values element-wise.
function isinf(const vec<T, N> &) Detect infinite values element-wise.
variable cpu_features::isIntel Vendor string is "GenuineIntel".
function isnan(const vec<T, N> &) Detect NaN (Not-a-Number) values element-wise.
function isnegative(const vec<T, N> &) Detect negative values element-wise by inspecting the sign bit.
function ispositive(const vec<T, N> &) Detect non-negative values element-wise.
function isreal(const complex<T> &) Returns mask with true for real elements
typedef isubtype
function iszero(const vec<T, N> &) Detect zero values element-wise.
function tensor<T, NDims>::iterate(Fn &&) Calls fn for each element together with its multi-dimensional index.
typedef array_ref<T>::iterator
typedef inline_vector<T, N>::iterator
typedef tensor<T, NDims>::iterator
struct range<T>::iterator
typedef tensor<T, NDims>::tensor_iterator::iterator_category
typedef tensor<T, NDims>::nested_iterator_t::iterator_category
function itrunc(const T1 &) Returns the truncated integer part of x, as an integer type.
function itrunc(E1 &&) Creates an expression that returns the integer equivalent of trunc( x).
typedef itype
typedef samplerate_converter<T>::itype
typedef vec<T, N>::iuscalar_type
typedef vec<T, N>::iusimd_type
typedef vec<T, N>::iuvalue_type
typedef glsl_names::ivec2
typedef glsl_names::ivec3
typedef glsl_names::ivec4

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.
function join(T) Convert a single value to a string (terminator of join ).
function join(T, U, Ts...) Join values into a comma-separated string of the form {x}, {y}, {rest...}".
function just_value(T)

K¶

variable zpk::k System gain
enum constant window_type::kaiser
variable samplerate_converter<T>::kaiser_beta Kaiser window beta parameter.
function dft_resampler<T>::kaiser_beta_from_attenuation(T) Computes the Kaiser window beta from a desired stopband attenuation.
namespace kfr
function ::kfr_allocate_aligned(size_t, size_t)
function ::kfr_allocate(size_t)
macro KFR_ALWAYS_INLINE
macro KFR_API_SPEC
enum constant (Unnamed enum at capi.h:119:1)::KFR_ARCH_AVX AVX.
enum constant (Unnamed enum at capi.h:119:1)::KFR_ARCH_AVX2 AVX2.
enum constant (Unnamed enum at capi.h:119:1)::KFR_ARCH_AVX512 AVX-512.
macro KFR_ARCH_BITNESS_NAME
macro KFR_ARCH_ID_AVX
macro KFR_ARCH_ID_AVX2
macro KFR_ARCH_ID_AVX512
macro KFR_ARCH_ID_GENERIC
macro KFR_ARCH_ID_NEON
macro KFR_ARCH_ID_NEON64
macro KFR_ARCH_ID_RVV
macro KFR_ARCH_ID_SSE2
macro KFR_ARCH_ID_SSE3
macro KFR_ARCH_ID_SSE41
macro KFR_ARCH_ID_SSE42
macro KFR_ARCH_ID_SSSE3
macro KFR_ARCH_IS_GENERIC
macro KFR_ARCH_IS_X86
macro KFR_ARCH_NAME
enum constant (Unnamed enum at capi.h:119:1)::KFR_ARCH_SSE2 SSE2.
enum constant (Unnamed enum at capi.h:119:1)::KFR_ARCH_SSE3 SSE3.
enum constant (Unnamed enum at capi.h:119:1)::KFR_ARCH_SSE41 SSE4.1.
enum constant (Unnamed enum at capi.h:119:1)::KFR_ARCH_SSE42 SSE4.2.
enum constant (Unnamed enum at capi.h:119:1)::KFR_ARCH_SSSE3 SSSE3.
macro KFR_ARCH_X64
macro KFR_ARCH_X86
enum constant (Unnamed enum at capi.h:119:1)::KFR_ARCH_X86 Baseline x86 (no SIMD).
macro KFR_ASSERT
macro KFR_ASSERT_ACTIVE
macro KFR_ASSERT_INACTIVE
macro KFR_ASSUME
macro KFR_ASSUME_ALIGNED
macro KFR_BIN_OP
typedef ::kfr_bool Boolean type used throughout the CAPI. Maps to
macro KFR_BREAKPOINT
macro KFR_BUILD_DETAILS_1
macro KFR_BUILD_DETAILS_2
macro KFR_builtin_readcyclecounter
typedef ::kfr_c32 Single-precision complex type.
typedef ::kfr_c64 Double-precision complex type.
macro KFR_C_API
macro KFR_CACHE_LINE_SIZE
macro KFR_CALL_CONV_SPEC
macro KFR_CDECL
macro KFR_CDECL
macro KFR_CHECK_IMPL
macro KFR_CLASS_REFCOUNT
macro KFR_COMPILER_CLANG
macro KFR_COMPILER_FULL_NAME
macro KFR_COMPILER_GNU
macro KFR_COMPILER_NAME
macro KFR_COMPLEX_SIZE_MULTIPLIER
macro KFR_CONCAT
function ::kfr_current_arch() Returns the current architecture in use.
macro KFR_CVAL
function ::kfr_dct_create_plan_f32(size_t) Creates a DCT-II plan (single precision).
function ::kfr_dct_create_plan_f64(size_t) Creates a DCT-II plan (double precision).
function ::kfr_dct_delete_plan_f32(KFR_DCT_PLAN_F32 *) Deletes a DCT plan.
function ::kfr_dct_delete_plan_f64(KFR_DCT_PLAN_F64 *) Deletes a DCT plan.
function ::kfr_dct_dump_f32(KFR_DCT_PLAN_F32 *) Dumps details of the DCT plan to stdout for inspection.
function ::kfr_dct_dump_f64(KFR_DCT_PLAN_F64 *) Dumps 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 *)
function ::kfr_dct_execute_f64(KFR_DCT_PLAN_F64 *, kfr_f64 *, const kfr_f64 *, uint8_t *)
function ::kfr_dct_execute_inverse_f32(KFR_DCT_PLAN_F32 *, kfr_f32 *, const kfr_f32 *, uint8_t *)
function ::kfr_dct_execute_inverse_f64(KFR_DCT_PLAN_F64 *, kfr_f64 *, const kfr_f64 *, uint8_t *)
function ::kfr_dct_get_size_f32(KFR_DCT_PLAN_F32 *) Returns the size of a DCT plan.
function ::kfr_dct_get_size_f64(KFR_DCT_PLAN_F64 *) Returns the size of a DCT plan.
function ::kfr_dct_get_temp_size_f32(KFR_DCT_PLAN_F32 *) Returns the temporary (scratch) buffer size required by the DCT plan.
function ::kfr_dct_get_temp_size_f64(KFR_DCT_PLAN_F64 *) Returns the temporary (scratch) buffer size required by the DCT plan.
struct ::KFR_DCT_PLAN_F32
typedef ::KFR_DCT_PLAN_F32
struct ::KFR_DCT_PLAN_F64
typedef ::KFR_DCT_PLAN_F64
function ::kfr_deallocate(void *)
macro KFR_DEBUG_STR
macro KFR_DEFAULT_ALIGNMENT
macro KFR_DFT_ALGO_SWITCH
function ::kfr_dft_create_2d_plan_f32(size_t, size_t) Creates a 2D complex DFT plan (single precision).
function ::kfr_dft_create_2d_plan_f64(size_t, size_t) Creates a 2D complex DFT plan (double precision).
function ::kfr_dft_create_3d_plan_f32(size_t, size_t, size_t) Creates a 3D complex DFT plan (single precision).
function ::kfr_dft_create_3d_plan_f64(size_t, size_t, size_t) Creates a 3D complex DFT plan (double precision).
function ::kfr_dft_create_md_plan_f32(size_t, const unsigned int *) Creates an N-dimensional complex DFT plan (single precision).
function ::kfr_dft_create_md_plan_f64(size_t, const unsigned int *) Creates an N-dimensional complex DFT plan (double precision).
function ::kfr_dft_create_plan_f32(size_t) Creates a complex DFT plan (single precision).
function ::kfr_dft_create_plan_f64(size_t) Creates a complex DFT plan (double precision).
function ::kfr_dft_delete_plan_f32(KFR_DFT_PLAN_F32 *) Deletes a complex DFT plan.
function ::kfr_dft_delete_plan_f64(KFR_DFT_PLAN_F64 *) Deletes a complex DFT plan.
function ::kfr_dft_dump_f32(KFR_DFT_PLAN_F32 *) Dumps details of the DFT plan to stdout for inspection.
function ::kfr_dft_dump_f64(KFR_DFT_PLAN_F64 *) Dumps 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 *)
function ::kfr_dft_execute_f64(KFR_DFT_PLAN_F64 *, kfr_c64 *, const kfr_c64 *, uint8_t *)
function ::kfr_dft_execute_inverse_f32(KFR_DFT_PLAN_F32 *, kfr_c32 *, const kfr_c32 *, uint8_t *)
function ::kfr_dft_execute_inverse_f64(KFR_DFT_PLAN_F64 *, kfr_c64 *, const kfr_c64 *, uint8_t *)
function ::kfr_dft_get_size_f32(KFR_DFT_PLAN_F32 *) Returns the size of the DFT plan, in complex numbers.
function ::kfr_dft_get_size_f64(KFR_DFT_PLAN_F64 *) Returns the size of the DFT plan, in complex numbers.
function ::kfr_dft_get_temp_size_f32(KFR_DFT_PLAN_F32 *) Returns the temporary (scratch) buffer size required by the DFT plan.
function ::kfr_dft_get_temp_size_f64(KFR_DFT_PLAN_F64 *) Returns the temporary (scratch) buffer size required by the DFT plan.
enum ::KFR_DFT_PACK_FORMAT DFT packing format for real DFTs. See https://www.kfr.dev/docs/latest/dft_format/ for details.
typedef ::KFR_DFT_PACK_FORMAT DFT packing format for real DFTs. See https://www.kfr.dev/docs/latest/dft_format/ for details.
struct ::KFR_DFT_PLAN_F32
typedef ::KFR_DFT_PLAN_F32
struct ::KFR_DFT_PLAN_F64
typedef ::KFR_DFT_PLAN_F64
function ::kfr_dft_real_create_2d_plan_f32(size_t, size_t, kfr_bool) Creates a 2D real DFT plan (single precision).
function ::kfr_dft_real_create_2d_plan_f64(size_t, size_t, kfr_bool) Creates a 2D real DFT plan (double precision).
function ::kfr_dft_real_create_3d_plan_f32(size_t, size_t, size_t, kfr_bool) Creates a 3D real DFT plan (single precision).
function ::kfr_dft_real_create_3d_plan_f64(size_t, size_t, size_t, kfr_bool) Creates a 3D real DFT plan (double precision).
function ::kfr_dft_real_create_md_plan_f32(size_t, const unsigned int *, kfr_bool) Creates an N-dimensional real DFT plan (single precision).
function ::kfr_dft_real_create_md_plan_f64(size_t, const unsigned int *, kfr_bool) Creates an N-dimensional real DFT plan (double precision).
function ::kfr_dft_real_create_plan_f32(size_t, KFR_DFT_PACK_FORMAT) Creates a real DFT plan (single precision).
function ::kfr_dft_real_create_plan_f64(size_t, KFR_DFT_PACK_FORMAT) Creates a real DFT plan (double precision).
function ::kfr_dft_real_delete_plan_f32(KFR_DFT_REAL_PLAN_F32 *) Deletes a real DFT plan.
function ::kfr_dft_real_delete_plan_f64(KFR_DFT_REAL_PLAN_F64 *) Deletes a real DFT plan.
function ::kfr_dft_real_dump_f32(KFR_DFT_REAL_PLAN_F32 *) Dumps details of the real DFT plan to stdout for inspection.
function ::kfr_dft_real_dump_f64(KFR_DFT_REAL_PLAN_F64 *) Dumps 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 *)
function ::kfr_dft_real_execute_f64(KFR_DFT_REAL_PLAN_F64 *, kfr_c64 *, const kfr_f64 *, uint8_t *)
function ::kfr_dft_real_execute_inverse_f32(KFR_DFT_REAL_PLAN_F32 *, kfr_f32 *, const kfr_c32 *, uint8_t *)
function ::kfr_dft_real_execute_inverse_f64(KFR_DFT_REAL_PLAN_F64 *, kfr_f64 *, const kfr_c64 *, uint8_t *)
function ::kfr_dft_real_get_size_f32(KFR_DFT_REAL_PLAN_F32 *) Returns the size of a real DFT plan.
function ::kfr_dft_real_get_size_f64(KFR_DFT_REAL_PLAN_F64 *) Returns the size of a real DFT plan.
function ::kfr_dft_real_get_temp_size_f32(KFR_DFT_REAL_PLAN_F32 *) Returns the temporary (scratch) buffer size required by the real DFT plan (single precision).
function ::kfr_dft_real_get_temp_size_f64(KFR_DFT_REAL_PLAN_F64 *) Returns the temporary (scratch) buffer size required by the real DFT plan (double precision).
struct ::KFR_DFT_REAL_PLAN_F32
typedef ::KFR_DFT_REAL_PLAN_F32
struct ::KFR_DFT_REAL_PLAN_F64
typedef ::KFR_DFT_REAL_PLAN_F64
macro KFR_DFT_SUPPORTS_ODD_REAL
macro KFR_DLL_EXPORT
macro KFR_DLL_IMPORT
macro KFR_EMPTY_BASES
macro KFR_ENABLE_IF
macro KFR_ENABLE_IF_IMPL
function ::kfr_enabled_archs() Returns the list of enabled architectures as a string.
macro KFR_ENABLED_ARCHS_LIST
macro KFR_ESC
macro KFR_EXPAND_IF_ARCH_avx
macro KFR_EXPAND_IF_ARCH_avx2
macro KFR_EXPAND_IF_ARCH_avx512
macro KFR_EXPAND_IF_ARCH_sse2
macro KFR_EXPAND_IF_ARCH_sse3
macro KFR_EXPAND_IF_ARCH_sse41
macro KFR_EXPAND_IF_ARCH_sse42
macro KFR_EXPAND_IF_ARCH_ssse3
macro KFR_EXPOSE_VALUE
macro KFR_EXTERN_C
typedef ::kfr_f32 Single-precision floating-point type.
typedef ::kfr_f64 Double-precision floating-point type.
macro KFR_FALSE
macro KFR_FAST_CC
macro KFR_FILEPATH
struct ::KFR_FILTER_C32
typedef ::KFR_FILTER_C32
struct ::KFR_FILTER_C64
typedef ::KFR_FILTER_C64
function ::kfr_filter_create_convolution_plan_f32(const kfr_f32 *, size_t, size_t) Creates a convolution filter plan (single precision).
function ::kfr_filter_create_convolution_plan_f64(const kfr_f64 *, size_t, size_t) Creates a convolution filter plan (double precision).
function ::kfr_filter_create_fir_plan_f32(const kfr_f32 *, size_t) Creates a FIR filter plan (single precision).
function ::kfr_filter_create_fir_plan_f64(const kfr_f64 *, size_t) Creates a FIR filter plan (double precision).
function ::kfr_filter_create_iir_plan_f32(const kfr_f32 *, size_t) Creates an IIR filter plan (single precision) from a cascade of second-order sections.
function ::kfr_filter_create_iir_plan_f64(const kfr_f64 *, size_t) Creates an IIR filter plan (double precision) from a cascade of second-order sections.
function ::kfr_filter_delete_plan_f32(KFR_FILTER_F32 *) Deletes a filter plan.
function ::kfr_filter_delete_plan_f64(KFR_FILTER_F64 *) Deletes a filter plan.
struct ::KFR_FILTER_F32
typedef ::KFR_FILTER_F32
struct ::KFR_FILTER_F64
typedef ::KFR_FILTER_F64
function ::kfr_filter_process_f32(KFR_FILTER_F32 *, kfr_f32 *, const kfr_f32 *, size_t) Processes input data with a filter.
function ::kfr_filter_process_f64(KFR_FILTER_F64 *, kfr_f64 *, const kfr_f64 *, size_t) Processes input data with a filter.
function ::kfr_filter_reset_f32(KFR_FILTER_F32 *) Resets the internal state of a filter plan, including its delay line.
function ::kfr_filter_reset_f64(KFR_FILTER_F64 *) Resets the internal state of a filter plan, including its delay line.
macro KFR_FLATTEN
macro KFR_FN
macro KFR_FOR
macro KFR_FORC
macro KFR_FP
macro KFR_FUNC_SIGNATURE
macro KFR_FUNCTION
macro KFR_GCC_VERSION
macro KFR_GNU_ATTRIBUTES
macro KFR_GNU_PACKED
macro KFR_HAS_ASSERT_H
macro KFR_HAS_ATTRIBUTE
macro KFR_HAS_BUILTIN
macro KFR_HAS_EXCEPTIONS
macro KFR_HAS_EXTENSION
macro KFR_HAS_FEATURE
macro KFR_HAS_GXX_CXX11
macro KFR_HAS_WARNING
macro KFR_HEADERS_VERSION
macro KFR_I_FN
macro KFR_I_FN_FULL
macro KFR_ICC_VERSION
macro KFR_IF_IS_AVX
macro KFR_IF_IS_AVX2
macro KFR_IF_IS_AVX512
macro KFR_IF_IS_SSE2
macro KFR_IF_IS_SSE3
macro KFR_IF_IS_SSE41
macro KFR_IF_IS_SSE42
macro KFR_IF_IS_SSSE3
macro KFR_INLINE
macro KFR_INLINE_IN_RELEASE
macro KFR_INLINE_LAMBDA
macro KFR_INLINE_MEMBER
macro KFR_INTRINSIC
macro KFR_IO_SEEK_64
macro KFR_IO_TELL_64
function ::kfr_last_error() Returns the last error message.
macro KFR_LIKELY
macro KFR_LOGIC_CHECK
macro KFR_LOOP_NOUNROLL
macro KFR_LOOP_UNROLL
macro KFR_MEM_INTRINSIC
macro KFR_META_FN
macro KFR_META_FN_TPL
macro KFR_MSC_VER
macro KFR_NARGS
macro KFR_NARGS2
macro KFR_NATIVE_F64
macro KFR_NATIVE_I64
macro KFR_NATIVE_INTRINSICS
macro KFR_NO_UNIQUE_ADDRESS
macro KFR_NODEBUG
macro KFR_NOINLINE
macro KFR_NOOP
macro KFR_OPAQUE_STRUCT
macro KFR_OS_LINUX
macro KFR_OS_NAME
macro KFR_OS_POSIX
macro KFR_PRAGMA
macro KFR_PRAGMA_CLANG
macro KFR_PRAGMA_GCC
macro KFR_PRAGMA_GNU
macro KFR_PRAGMA_MSVC
macro KFR_PRAGMA_PACK_POP
macro KFR_PRAGMA_PACK_PUSH_1
macro KFR_PRINT_AND_ABORT
macro KFR_PUBLIC_C
macro KFR_REPORT_ERROR
macro KFR_REPORT_LOGIC_ERROR
macro KFR_REPORT_RUNTIME_ERROR
macro KFR_RESTRICT
macro KFR_RUNTIME_CHECK
macro KFR_SHUFFLE_SPECIALIZATIONS
macro KFR_STANDARD_PACK
macro KFR_STRINGIFY
macro KFR_STRINGIFY2
macro KFR_THROW
macro KFR_THROW_EXCEPTION
macro KFR_TRUE
macro KFR_UN_OP
macro KFR_UNLIKELY
macro KFR_UNREACHABLE
macro KFR_UNUSED
macro KFR_VEC_CC
macro KFR_VEC_CMP_OPERATOR
macro KFR_VEC_EXT
struct ::kfr_vec_hpp
macro KFR_VEC_OPERATOR1
macro KFR_VEC_OPERATOR2
macro KFR_VEC_SHIFT_OPERATOR
macro KFR_VERSION
function ::kfr_version() Returns the library version as an integer.
macro KFR_VERSION_FULL
macro KFR_VERSION_LABEL
macro KFR_VERSION_MAJOR
macro KFR_VERSION_MINOR
macro KFR_VERSION_PATCH
macro KFR_VERSION_STRING
function ::kfr_version_string() Returns the library version as a string.
macro KFR_WINDOW_BY_TYPE

L¶

enum constant speaker_type::L Alias for Left.
variable ngfft_plan<T>::l2fftsize Log2 of the FFT size (e.g. 16 means a 65536-point FFT).
function lambda_generator(Fn &&) Creates an expression backed by a non-random-access callable.
function lambda(Fn &&, cbool_t<RandomAccess>) Creates an expression backed by a callable.
enum constant window_type::lanczos
variable timestamps<max_count, fence>::last Cycle count captured by init or the most recent record ; used as the reference point for the next duration measurement.
enum constant speaker_type::Lc Left center (front, between L and C).
variable epsilon_scope<void>::ld
function shape<Dims>::le(const shape<dims> &) Element-wise less-than-or-equal comparison.
function le(E1 &&, E2 &&) Creates an expression that returns whether e1 is less than or equal to e2.
variable comparison<Fn, L, R>::left
variable half_comparison<L>::left
enum constant speaker_type::Left Front left.
enum constant speaker_type::LeftSurround Alias for Ls.
function cstring<N>::length()
variable audio_format_and_length::length
function less(const T1 &, const T2 &) Element-wise less-than comparison.
function lessorequal(const T1 &, const T2 &) Element-wise less-or-equal comparison.
enum constant speaker_type::Lfe Low-frequency effects (subwoofer).
enum constant speaker_type::Lfe2 Second low-frequency effects channel.
function library_version() Returns the string representation of the KFR library version, including target architecture.
function library_version_audio() Returns the full version string of the KFR audio module.
function library_version_codecs() Returns a comma-separated list of enabled audio codecs.
function library_version_dft() Returns the full version string of the KFR DFT module.
function library_version_dsp() Returns the full version string of the KFR DSP module.
function library_version_io() Returns the full version string of the KFR IO module.
function linear(M, T, T) Linear interpolation.
variable expression_window_with_metrics<T, metrics>::linspace
function linspace(T1, T2, size_t, bool, cbool_t<truncated>) Creates an expression that returns evenly spaced numbers over a specified interval.
enum constant audiofile_endianness::little
variable special_value::ll Stored integer literal
function load_from_npy(tensor<T, Dims> &, Fn &&) Loads a tensor from .npy format using a custom read callback.
typedef lockfree_ring_buffer Backward-compatible alias for spsc_ring_buffer .
function log10(const T1 &) Returns the common (base-10) logarithm of x.
function log10(E1 &&) Creates an expression that returns the common (base-10) logarithm of x.
function log2(const T1 &) Returns the binary (base-2) logarithm of x.
function log2(E1 &&) Creates an expression that returns the binary (base-2) logarithm of x.
variable scalar_constants<T>::log_10 The natural logarithm of 10 (ln(10)).
variable scalar_constants<T>::log_2 The natural logarithm of 2 (ln(2)).
function log_fmadd(const T1 &, const T2 &, const T3 &) Returns log(x) * m + a.
function log_fmadd(E1 &&, E2 &&, E3 &&) Creates an expression that returns log(x) * m + a.
function logb(const T1 &) Returns the unbiased exponent of x as a floating-point value (equivalent to std::logb).
function logb(E1 &&) Creates an expression that returns the rounded binary (base-2) logarithm of x.
function log(const T1 &) Returns the natural logarithm of x.
function log(E1 &&) Creates an expression that returns the natural logarithm of x.
class logic_error
function logm(const T1 &, const T2 &) Returns log(x) * m.
function logm(E1 &&, E2 &&) Creates an expression that returns log(x) * y.
function logn(const T1 &, const T2 &) Returns the logarithm of x with base y.
function logn(E1 &&, E2 &&) Creates an expression that returns the logarithm of x with base y.
typedef opencl_names::long16
typedef opencl_names::long2
typedef opencl_names::long3
typedef opencl_names::long4
typedef opencl_names::long8
function loudness_to_energy(T) Inverse of energy_to_loudness : convert LUFS back to linear energy.
variable vec_halves<T, N>::low Lower (power-of-two) half.
enum constant sample_rate_conversion_quality::low Low quality.
function low(const vec<T, N> &) Extracts the largest power-of-two-sized low subvector of x.
enum constant special_constant::lowest most negative representable value
enum constant cpu_t::lowest
function lowhalf(const vec<T, N> &) Extracts the lower half of x.
function lowhalf(vec_shape<T, N>) Shape-only overload of lowhalf() for type deduction.
enum constant biquad_type::lowpass Passes frequencies below the cutoff.
enum constant biquad_type::lowshelf Low-shelf equalizer filter.
function low(vec_shape<T, N>) Shape-only overload of low() for type deduction.
enum constant audiofile_codec::lpcm
class lra_vec<T> Sorted buffer of short-term mean-square energies used to compute the Loudness Range (LRA) per EBU R128 / ITU-R BS.1770.
constructor lra_vec<T>::lra_vec<T>()
enum constant speaker_type::Ls Left surround.
function lt(E1 &&, E2 &&) Creates an expression that returns whether e1 is less than e2.

M¶

enum constant speaker_type::M Alias for Mono.
variable small_buffer<T, Capacity>::m_data Pointer to the active storage (inline or heap).
variable audio_decoder::m_format
variable audio_encoder::m_format
variable small_buffer<T, Capacity>::m_preallocated Inline storage for up to
variable audio_decoder::m_reader
variable inline_vector<T, N>::m_size Current number of elements stored.
variable small_buffer<T, Capacity>::m_size Number of elements currently stored.
variable expression_window<T>::m_size
variable inline_vector<T, N>::m_values Inline storage for the elements.
variable audio_encoder::m_writer
function make_array_ref(Container &&)
function make_array_ref(T *, std::size_t)
struct make_comparison
function make_complex(const vec<T1, N> &, const vec<T2, N> &) Constructs a vector of complex values from real and imaginary vectors.
function make_complex(E1 &&, E2 &&) Creates an expression that constructs a complex value from the real part re and the imaginary part im.
function make_complex(T1, T2) Constructs a complex value from real and imaginary scalars.
function make_cstring(cchars_t<chars...>)
function make_cstring(const char (&)[N])
function make_kfilter(int) Build the EBU R128 K-weighting pre-filter as an IIR expression handle.
function make_mask(bool, Args...) Constructs a SIMD mask vector from boolean values.
function make_memory_finalizer(Fn &&) Creates a memory finalizer that invokes fn when the handle is destroyed.
function make_nonmember(const Fn &)
function make_range(T, T) Make iterable range object
function make_range(T, T, D) Make iterable range object with step
function make_resource(E &&) Create an expression_resource owning e (moved in), allocated with proper alignment.
function make_univector(const Container &) Creates univector from a container (must have data() and size() methods)
function make_univector(const T (&)[N]) Creates univector from a sized array
function make_univector(const T *, size_t) Creates univector from data and size
function make_univector(Container &) Creates univector from a container (must have data() and size() methods)
function make_univector(T (&)[N]) Creates univector from a sized array
function make_univector(T *, size_t) Creates univector from data and size
function make_vector(const Arg &, const Args &...) Create a vector from scalar values.
function make_vector(const vec<T, N> &) Identity overload: returns the passed vector unchanged.
function make_vector(cvals_t<T, Values...>) Create a vector from a compile-time constant list.
function map_indices() Returns a value of map_indices_t<size, Fn...> for use in non-type contexts.
class map_indices_impl<size, Fn> Compile-time index transformer used to build shuffle/permutation tables.
typedef map_indices_t Alias for the csizes_t produced by map_indices_impl<size, Fn...> .
function cvals_t<T, values>::map(Fn &&) Returns a new list with
function tensor<T, NDims>::map(Fn &&) Applies fn to each element and returns the resulting tensor.
typedef mask SIMD mask type of T elements with default width vector_width .
variable platform<cpu_t::common>::mask_registers
variable platform<cpu_t::avx512>::mask_registers
typedef vec<T, N>::mask_t
function maskbits(bool) Returns all-ones or all-zeros of type T depending on value.
typedef maskfor Obtains the mask type associated with a SIMD type.
variable expression_with_arguments<Args>::masks Per-argument dimension masks computed from each argument's shape.
typedef mat Matrix alias: a vector of vectors, N2 rows of N1 columns.
variable stereo_matrix::matrix 2x2 mixing matrix (rows are output coefficients).
function matrix_halfsum_halfdiff() Returns a 2x2 matrix that computes half-sum/half-difference of stereo channels.
function matrix_sum_diff() Returns a 2x2 matrix that computes sum/difference of stereo channels.
function matrix_transpose(T *, const T *, shape<Dims>) Transposes a matrix (supports scalar and compound types).
enum constant special_constant::max maximum representable value
variable cpu_features::max Highest supported standard CPUID leaf (leaf 0 EAX).
variable expression_random_range<T, Dims, Reference>::max
variable range<T>::max
variable max_audio_channels Maximum number of channels in audio data.
variable max_index_t Maximum representable value of index_t .
variable max_sindex_t Maximum representable value of signed_index_t .
variable max_size_t Maximum value representable by size_t
variable max_test_size Maximum vector size (in elements) exercised by the test suite for the current architecture.
function max(const T1 &, const T2 &) Returns the greater of two values.
function max(E1 &&, E2 &&) Creates an expression that returns the greater of x and y.
variable cursor<Dims>::maximum Upper bound (exclusive) for each axis.
variable maximum_biquad_count Maximum number of cascaded biquad sections (maximum_iir_order / 2).
variable maximum_dims Upper bound on the number of dimensions supported by shape .
variable maximum_expression_width Maximum vector width (in elements) supported by an expression handle for type T.
variable maximum_iir_order Maximum supported IIR filter order.
variable platform<cpu_t::common>::maximum_vector_alignment
variable platform<cpu_t::common>::maximum_vector_alignment_mask
variable maximum_vector_size
function maxof(const E1 &) Returns the greatest of all the elements in x.
function mean(const E1 &) Returns the arithmetic mean of all the elements in x.
function measure_rdtsc_cycle_time() Measures and returns the estimated cycle time in nanoseconds per tick for rdtsc.
typedef memory_finalizer Shared ownership handle for a memory finalizer.
class memory_reader<T>
constructor memory_reader<T>::memory_reader<T>(std::span<const T>)
class memory_writer<T>
constructor memory_writer<T>::memory_writer<T>(std::span<T>)
variable audiofile_format::metadata Key-value metadata pairs.
typedef metadata_map Metadata map for storing key-value pairs.
enum constant window_metrics::metrics_0_1
enum constant window_metrics::metrics_m1_1
enum constant window_metrics::metrics_m1_1_trunc
enum constant window_metrics::metrics_m1_1_trunc2
enum constant window_metrics::metrics_mpi_pi
enum constant special_constant::min minimum positive normalized value
variable expression_random_range<T, Dims, Reference>::min
variable range<T>::min
function shape<Dims>::min(const shape<dims> &, const shape<dims> &) Element-wise minimum of two shapes.
function min(const T1 &, const T2 &) Returns the smaller of two values.
function timestamps<max_count, fence>::min(const timestamps<max_count, fence> &) Return a new timestamps object containing the per-slot minimum durations.
function min(E1 &&, E2 &&) Creates an expression that returns the smaller of x and y.
variable cursor<Dims>::minimum Lower bound (inclusive) for each axis.
variable platform<cpu_t::common>::minimum_float_vector_size
variable platform<cpu_t::common>::minimum_int_vector_size
variable minimum_vector_width Minimum SIMD vector width (in elements) for type T on the native platform.
function minof(const E1 &) Returns the smallest of all the elements in x.
function mix(const T1 &, const T2 &, const T3 &) Linear blend of x and y .
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 mix(E1 &&, E2 &&, E3 &&) Creates an expression that returns the linear blend of x and y.
function mixs(const T1 &, const T2 &, const T3 &) Signed linear blend of x and y .
function mixs(E1 &&, E2 &&, E3 &&) Creates an expression that returns the signed linear blend of x and y.
function mod(const T1 &, const T2 &) Modulo of x by y .
variable cpu_features::model NUL-terminated CPUID model/brand string (leaves 0x80000002–4).
function 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 modzerobessel(E1 &&) Creates an expression that returns the modified Bessel function of the first kind of order 0 of x.
enum constant speaker_type::Mono Mono (front center, single channel).
enum constant speaker_arrangement::Mono Single mono channel (M).
class moving_sum_state<U, Tag> State for a moving-sum (rectangular window) filter with a compile-time-sized delay line.
constructor moving_sum_state<U, Tag>::moving_sum_state<U, Tag>()
class moving_sum_state<U, tag_dynamic_vector> Specialization of moving_sum_state for a runtime-sized window.
constructor moving_sum_state<U, tag_dynamic_vector>::moving_sum_state<U, tag_dynamic_vector>(size_t) Construct a moving-sum state with the given window length.
function moving_sum(E1 &&) Returns template expression that performs moving sum on the input.
function moving_sum(E1 &&, size_t) Returns template expression that performs moving sum on the input.
function moving_sum(E1 &&, std::reference_wrapper<moving_sum_state<U, Tag>>) Returns template expression that performs moving sum on the input.
function moving_sum(moving_sum_state<U, STag> &, E1 &&) Returns template expression that performs moving sum on the input.
enum constant audiofile_container::mp3 MPEG audio
enum constant audiofile_codec::mp3
struct mp3_config
struct mp3_decoding_options Options for decoding MP3 audio files.
variable timestamps<max_count, fence>::msg Per-checkpoint labels, parallel to dur .
variable expression_random_normal<T, Dims, Reference>::mu
function mul(const T1 &) Identity mul (single argument).
function mul(const T1 &, const T2 &, const Ts &...) Returns product of all the arguments passed to a function.
function mul(E &&...) Creates an expression that returns the product of all the arguments passed to a function.
function mul(initialvalue<T>) Identity element for mul (returns one).
function mulsign(const T1 &, const T2 &) Multiply x by the sign of y without a conditional branch.
function compiletime::mulsign(T, T) Compile-time multiplication by sign of a second value.
function audio_data<IsInterleaved>::multiply(fbase) Multiplies the audio data by a specified scalar value.
enum constant speaker_arrangement::Music30 L, R, S (music 3.0).
enum constant speaker_arrangement::Music31 L, R, S, Lfe (music 3.1).
enum constant speaker_arrangement::Music40 L, R, Ls, Rs (music 4.0).
enum constant speaker_arrangement::Music41 L, R, Ls, Rs, Lfe (music 4.1).
enum constant speaker_arrangement::Music60 L, R, Ls, Rs, Sl, Sr (music 6.0).
enum constant speaker_arrangement::Music61 L, R, Lfe, Ls, Rs, Sl, Sr (music 6.1).
enum constant speaker_arrangement::Music70 L, R, C, Ls, Rs, Sl, Sr (music 7.0).
enum constant speaker_arrangement::Music71 L, R, C, Lfe, Ls, Rs, Sl, Sr (music 7.1).
enum constant speaker_arrangement::Music80 L, R, C, Ls, Rs, Sl, Sr, Cs (music 8.0).
enum constant speaker_arrangement::Music81 L, R, C, Lfe, Ls, Rs, Sl, Sr, Cs (music 8.1).

N¶

variable named_arg<T>::name
variable named::name
variable dft_stage<T>::name Human-readable name of the stage (for
struct named
class named_arg<T>
constructor named::named(const char *)
function narrow(const vec<T, N> &) Narrows x to length Nout by truncation.
enum constant cpu_t::native
variable platform<cpu_t::common>::native_cache_alignment
variable platform<cpu_t::common>::native_cache_alignment_mask
variable platform<cpu_t::common>::native_float_vector_size
variable platform<cpu_t::avx>::native_float_vector_size
variable platform<cpu_t::avx512>::native_float_vector_size
variable platform<cpu_t::common>::native_int_vector_size
variable platform<cpu_t::avx2>::native_int_vector_size
variable platform<cpu_t::avx512>::native_int_vector_size
variable platform<cpu_t::common>::native_vector_alignment
variable platform<cpu_t::avx>::native_vector_alignment
variable platform<cpu_t::avx512>::native_vector_alignment
variable platform<cpu_t::common>::native_vector_alignment_mask
variable platform<cpu_t::avx>::native_vector_alignment_mask
variable platform<cpu_t::avx512>::native_vector_alignment_mask
class native_vector_type<T>
function nearest(M, T, T) Nearest-neighbor interpolation.
function ne(E1 &&, E2 &&) Creates an expression that returns whether e1 is not equal to e2.
variable dft_stage<T>::need_reorder Whether the stage output requires bit-reversal reordering.
enum constant special_constant::neg_infinity negative infinity
enum constant special_constant::neg_max negated maximum representable value
function neg(const T1 &) Arithmetic negation of x .
function negeven(const vec<T, N> &) Negates the even-indexed lanes of x .
variable scalar_constants<T>::neginfinity The representation of negative infinity for the type T.
function negodd(const vec<T, N> &) Negates the odd-indexed lanes of x .
function tensor<T, NDims>::nested_begin() Returns a nested iterator to the first sub-tensor along the first axis.
function tensor<T, NDims>::nested_end() Returns the nested iterator sentinel past the last sub-tensor.
typedef tensor<T, NDims>::nested_iterator
struct tensor<T, NDims>::nested_iterator_t Iterator over the first axis yielding sub-tensors of one fewer dimension.
function generator_linear<T, VecWidth>::next() Advances the generator state by one native vector width.
function generator_exp<T, VecWidth>::next() Advances the generator state by one native vector width using the precomputed multiplicative growth factor.
function generator_expj<T, VecWidth>::next() Advances the complex rotation by one native vector width using the recurrence relation.
function generator_exp2<T, VecWidth>::next() Advances the generator state by one native vector width using the precomputed multiplicative growth factor.
function generator_cossin<T, VecWidth>::next() Advances the rotation by one native vector width using the recurrence relation.
function generator_sin<T, VecWidth>::next() Advances the rotation by one native vector width using the recurrence relation.
function next_poweroftwo(T) Returns a nearest power of two that is greater or equal than n
function ngfft_execute(const ngfft_plan<T> &, bool, complex<T> *, const complex<T> *, dft_algorithm) Executes the FFT with separate input and output buffers, runtime direction and algorithm.
function ngfft_execute(const ngfft_plan<T> &, bool, complex<T> *, dft_algorithm) Executes the FFT in-place with runtime direction and algorithm.
function ngfft_execute(const ngfft_plan<T> &, cbool_t<inverse>, complex<T> *, const complex<T> *, dft_algorithm) Executes the FFT with separate input and output buffers, a compile-time direction and runtime algorithm.
function ngfft_execute(const ngfft_plan<T> &, cbool_t<inverse>, complex<T> *, dft_algorithm) Executes the FFT in-place with a compile-time direction and runtime algorithm.
function ngfft_initialize(ngfft_plan<T> &, dft_algorithm) Initializes the plan's twiddles for a runtime algorithm value.
class ngfft_plan_real<T>
constructor ngfft_plan_real<T>::ngfft_plan_real<T>()
constructor ngfft_plan_real<T>::ngfft_plan_real<T>(uint8_t)
class ngfft_plan<T> Plan structure for the ng FFT algorithms (new in KFR 7.1).
function ngfft_real_execute(const ngfft_plan<T> &, complex<T> *, const T *, dft_algorithm) Executes the forward real-to-complex FFT with a runtime algorithm.
function ngfft_real_execute(const ngfft_plan<T> &, T *, const complex<T> *, dft_algorithm) Executes the inverse complex-to-real FFT with a runtime algorithm.
function ngfft_twiddle_count(ngfft_plan<T> &, dft_algorithm) Returns the twiddle-factor count for a runtime algorithm value.
variable expression_vtable<T, Dims>::Nmax Largest supported block size.
struct dft_plan<T>::noinit
function noinline(Fn &&, Args &&...)
enum constant speaker_type::None No speaker / unspecified.
enum constant speaker_arrangement::None No arrangement / unspecified.
enum constant audio_dithering::none
typedef fn_generic::noop
function noop(Ts &&...) Function that returns void and ignores all its arguments
enum constant dft_order::normal Normal order
enum constant sample_rate_conversion_quality::normal Normal quality (balanced).
function fraction::normalize() Reduce the fraction to lowest terms and enforce a positive denominator.
function biquad_section<T>::normalized_a0() Returns a section scaled so that a0 == 1.
function biquad_section<T>::normalized_all() Returns a section scaled so that both a0 == 1 and b0 == 1.
function biquad_section<T>::normalized_b0() Returns a section scaled so that b0 == 1.
concept not_f_class
enum constant audiofile_error::not_found The file was not found
concept not_i_class
enum constant audiofile_error::not_implemented Not implemented
concept not_u_class
enum constant biquad_type::notch Notch (band-reject) filter.
function note_to_hertz(const T1 &) Convert a MIDI note number to frequency in Hertz.
function note_to_hertz(E1 &&) Convert a MIDI note number expression to frequency in Hertz.
function notequal(const T1 &, const T2 &) Element-wise inequality comparison.
function cvals_t<T, values>::notequal(cvals_t<T, values...>) Returns
enum npy_decode_result Status returned by the .npy loading function.
variable expression_vtable<T, Dims>::Nsizes Number of supported power-of-two block sizes (1 .. maximum_expression_width<T>).
typedef ctypes_t<Ts>::nth The type at position
typedef expression_with_arguments<Args>::nth Alias for the type of the argument at position
typedef expression_with_arguments<Arg>::nth Alias for the argument type (any index).
typedef expression_with_arguments<Args>::nth_trait Alias for the traits of the argument at position
typedef expression_with_arguments<Arg>::nth_trait Alias for the traits of the argument.
variable fraction::numerator Numerator of the fraction.
concept numeric Concept satisfied by numeric types (numbers or compound types of numbers)
variable numeric_types
variable numeric_vector_types Instance combining integer and floating-point vector types for use as a value parameter pack.

O¶

function odd(const vec<T, N> &) Extracts the odd-indexed elements of x (with optional grouping).
enum constant npy_decode_result::ok Successfully loaded
variable expression_goertzel<T>::omega Target angular frequency [rad/sample].
variable expression_parallel_goertzel<T, width>::omega SIMD vector of target angular frequencies.
function ones() Creates an expression that always evaluates to one.
function onoff(cint_t<on>, cint_t<off>) Generates a vector with an on/off pattern over a contiguous range.
function onoff(vec_shape<T, N>, cint_t<on>, cint_t<off>) Shape-driven overload of onoff() for type deduction.
function cmp_eq::op()
function cmp_ne::op()
function cmp_lt::op()
function cmp_gt::op()
function cmp_le::op()
function cmp_ge::op()
variable ::KFR_DFT_PLAN_F32::opaque
variable ::KFR_DFT_PLAN_F64::opaque
variable ::KFR_DFT_REAL_PLAN_F32::opaque
variable ::KFR_DFT_REAL_PLAN_F64::opaque
variable ::KFR_DCT_PLAN_F32::opaque
variable ::KFR_DCT_PLAN_F64::opaque
variable ::KFR_FILTER_F32::opaque
variable ::KFR_FILTER_F64::opaque
variable ::KFR_FILTER_C32::opaque
variable ::KFR_FILTER_C64::opaque
function open_file_for_appending(const filepath &) Opens typed file for appending
function open_file_for_reading(const filepath &) Opens typed file for reading
function open_file_for_writing(const filepath &) Opens typed file for writing
enum open_file_mode
namespace opencl_names
function audio_decoder::open(const file_path &) Opens an audio file from a file path and retrieves its format.
function audio_encoder::open(const file_path &, const audiofile_format &, audio_decoder *) Opens the encoder with a file path and format.
function audio_decoder::open(std::shared_ptr<binary_reader>) Opens an audio file using a binary reader and retrieves its format.
function audio_encoder::open(std::shared_ptr<binary_writer>, const audiofile_format &, audio_decoder *) Opens the encoder with a binary writer and format.
function cval_t<T, val>::operator()() Returns the wrapped value
function vec<T, N>::element::operator+() Unary plus (returns the value).
function vec<T, N>::element::operator-() Unary negation.
function vec<T, N>::element::operator++() Pre-increment.
function vec<T, N>::element::operator--() Pre-decrement.
function shape<Dims>::operator*() Access the underlying static array.
function shape<Dims>::operator->() Pointer-like access to the underlying static array.
function fraction::operator+() Unary plus (returns a copy of the fraction).
function fraction::operator-() Unary minus (negates the numerator).
function tensor<T, NDims>::tensor_iterator::operator*() Dereferences the iterator to the referenced element.
function tensor<T, NDims>::tensor_iterator::operator->() Accesses the referenced element by pointer.
function tensor<T, NDims>::tensor_iterator::operator++() Prefix increment, advancing to the next element in row-major order.
function tensor<T, NDims>::nested_iterator_t::operator*() Dereferences the iterator to the sub-tensor at the current index.
function tensor<T, NDims>::nested_iterator_t::operator++() Prefix increment, advancing to the next sub-tensor.
function state_holder<T, false>::operator->() Returns a pointer to the state (const overload).
function state_holder<T, false>::operator->() Returns a pointer to the state (non-const overload).
function state_holder<T, false>::operator*() Returns a reference to the state (const overload).
function state_holder<T, false>::operator*() Returns a reference to the state (non-const overload).
function state_holder<T, true>::operator->() Returns a pointer to the state (const overload).
function state_holder<T, true>::operator->() Returns a pointer to the state (non-const overload).
function state_holder<T, true>::operator*() Returns a reference to the state (const overload).
function state_holder<T, true>::operator*() Returns a reference to the state (non-const overload).
function range<T>::iterator::operator*()
function range<T>::iterator::operator->()
function range<T>::iterator::operator++()
function comparison<Fn, L, R>::operator()()
function audio_dithering_state::operator()() Generates one dither sample according to the configured method.
function operator
function operator User-defined literal returning a format_t for the given string literal.
function operator User-defined literal returning a print_t for the given string literal.
function fn_pass_through::operator()(Args &&...)
function fn_noop::operator()(Args &&...)
function fn_get_first::operator()(Args &&...)
function fn_get_second::operator()(Args &&...)
function fn_get_third::operator()(Args &&...)
function fn_returns<T>::operator()(Args &&...)
function fn_return_constant<T, value>::operator()(Args &&...) Returns the wrapped constant
function fn_is_equal::operator()(Args &&...)
function fn_is_notequal::operator()(Args &&...)
function fn_is_less::operator()(Args &&...)
function fn_is_greater::operator()(Args &&...)
function fn_is_lessorequal::operator()(Args &&...)
function fn_is_greaterorequal::operator()(Args &&...)
function fn_is_between::operator()(Args &&...)
function fn_noinline<Fn>::operator()(Args &&...) Invokes the wrapped callable non-inlined
function array_ref<T>::operator=(array_ref<T> &&)
function audio_data<IsInterleaved>::operator=(audio_data<IsInterleaved> &&)
function autofree<T>::operator=(autofree<T> &&)
operator bit<T>::operator Converts to bool by testing the sign bit of the stored mask.
function bit<T>::operator==(bool) Equality comparison against a plain bool.
function bit<T>::operator!=(bool) Inequality comparison against a plain bool.
operator expression_handle<T, Dims>::operator true if the handle references a valid instance.
operator fraction::operator True if the fraction is non-zero.
function format_t<chars>::operator()(const Args &...) Format the given arguments using the stored literal.
function print_t<chars>::operator()(const Args &...) Print the given arguments to stdout using the stored literal.
function array_ref<T>::operator=(const array_ref<T> &)
function audio_data<IsInterleaved>::operator==(const audio_data<IsInterleaved> &)
function audio_data<IsInterleaved>::operator=(const audio_data<IsInterleaved> &)
function audiofile_format::operator==(const audiofile_format &)
function autofree<T>::operator=(const autofree<T> &)
function bit<T>::operator==(const bit<T> &) Equality comparison between two bit values.
function bit<T>::operator!=(const bit<T> &) Inequality comparison between two bit values.
function cstring<N>::operator==(const cstring<N> &, const cstring<N> &)
function cstring<N>::operator!=(const cstring<N> &, const cstring<N> &)
function cstring<N>::operator==(const cstring<NN> &)
function cstring<N>::operator!=(const cstring<NN> &)
function operator==(const data_allocator<T1> &, const data_allocator<T2> &)
function operator!=(const data_allocator<T1> &, const data_allocator<T2> &)
function dft_plan_md_real<T, Dims>::operator=(const dft_plan_md_real<T, Dims> &)
function dft_plan_md<T, Dims>::operator=(const dft_plan_md<T, Dims> &)
function dft_plan_real<T>::operator=(const dft_plan_real<T> &)
function dft_plan<T>::operator=(const dft_plan<T> &) Copy assignment operator (deleted).
function vec<T, N>::element::operator=(const element &) Copy-assign from another element proxy.
function fir_params<T>::operator=(const fir_params<T> &)
function fir_state<T, U>::operator=(const fir_state<T, U> &)
function fraction::operator+=(const fraction &) Add-assign.
function fraction::operator-=(const fraction &) Subtract-assign.
function fraction::operator*=(const fraction &) Multiply-assign.
function fraction::operator/=(const fraction &) Divide-assign.
function fraction::operator+(const fraction &, const fraction &) Add two fractions.
function fraction::operator-(const fraction &, const fraction &) Subtract two fractions.
function fraction::operator*(const fraction &, const fraction &) Multiply two fractions.
function fraction::operator/(const fraction &, const fraction &) Divide two fractions.
function fraction::operator==(const fraction &, const fraction &) Equality comparison.
function fraction::operator!=(const fraction &, const fraction &) Inequality comparison.
function fraction::operator<(const fraction &, const fraction &) Less-than comparison.
function fraction::operator<=(const fraction &, const fraction &) Less-than-or-equal comparison.
function fraction::operator>(const fraction &, const fraction &) Greater-than comparison.
function fraction::operator>=(const fraction &, const fraction &) Greater-than-or-equal comparison.
function tensor<T, NDims>::operator()(const Index &...) Returns a sub-tensor (slice) selected by a mix of integer indices and tensor_range specifiers. Axes indexed by integers are removed from the result; axes indexed by tensor_range are kept.
function inline_vector<T, N>::operator=(const inline_vector<T, N> &)
function inline_vector<T, N>::operator==(const inline_vector<T, N> &) Returns true if both vectors contain the same elements in the same order.
function inline_vector<T, N>::operator!=(const inline_vector<T, N> &) Returns true if the vectors differ in size or contents.
function range<T>::iterator::operator!=(const iterator &)
function equality_comparer<L, R>::operator()(const L &, const R &)
function operator&(const mask<T1, N> &, const mask<T2, N> &) Bitwise AND of two masks (bit-level, size must match).
function operator|(const mask<T1, N> &, const mask<T2, N> &) Bitwise OR of two masks (bit-level, size must match).
function operator&&(const mask<T1, N> &, const mask<T2, N> &) Logical AND of two masks (bit-level conjunction, size must match).
function operator||(const mask<T1, N> &, const mask<T2, N> &) Logical OR of two masks (bit-level disjunction, size must match).
function operator^(const mask<T1, N> &, const mask<T2, N> &) Bitwise XOR of two masks (bit-level, size must match).
function operator~(const mask<T, N> &) Bitwise NOT of a mask.
function operator!(const mask<T, N> &) Logical NOT of a mask (equivalent to bitwise NOT).
function tensor<T, NDims>::nested_iterator_t::operator==(const nested_iterator_t &) Returns true if two iterators refer to the same position.
function tensor<T, NDims>::nested_iterator_t::operator!=(const nested_iterator_t &) Returns true if two iterators refer to different positions.
function portable_vec<T, N>::operator==(const portable_vec<T, N> &)
function random_state::operator=(const random_state &)
function shape<0>::operator==(const shape<0> &) Two scalar shapes are always equal.
function shape<0>::operator!=(const shape<0> &) Two scalar shapes are never unequal.
function tensor<T, NDims>::operator()(const shape_type &, const shape_type &) Returns a sub-tensor (slice) spanning from start to stop.
function tensor<T, NDims>::operator=(const T &) Fills the tensor with a scalar value (const overload).
function tensor<T, NDims>::operator=(const T &) Fills the tensor with a scalar value (rvalue overload).
function operator+(const T1 &, const vec<T2, N> &)
function operator-(const T1 &, const vec<T2, N> &)
function operator*(const T1 &, const vec<T2, N> &)
function operator/(const T1 &, const vec<T2, N> &)
function operator%(const T1 &, const vec<T2, N> &)
function operator&(const T1 &, const vec<T2, N> &)
function operator|(const T1 &, const vec<T2, N> &)
function operator^(const T1 &, const vec<T2, N> &)
function operator<<(const T1 &, const vec<T2, N> &)
function operator>>(const T1 &, const vec<T2, N> &)
function operator==(const T1 &, const vec<T2, N> &)
function operator!=(const T1 &, const vec<T2, N> &)
function operator>=(const T1 &, const vec<T2, N> &)
function operator<=(const T1 &, const vec<T2, N> &)
function operator>(const T1 &, const vec<T2, N> &)
function operator<(const T1 &, const vec<T2, N> &)
function tensor<T, NDims>::tensor_iterator::operator==(const tensor_iterator &) Returns true if two iterators refer to the same position.
function tensor<T, NDims>::tensor_iterator::operator!=(const tensor_iterator &) Returns true if two iterators refer to different positions.
function tensor<T, NDims>::operator=(const tensor<T, NDims> &) Copy-assigns the tensor, sharing the data of src.
function tensor<T, NDims>::operator=(const tensor<T, NDims> &) Copy-assigns the tensor from src (const overload).
function tensor<T, NDims>::operator=(const tensor<T, NDims> &) Copy-assigns the tensor from src (rvalue overload).
function tensor<T, NDims>::operator==(const tensor<T, NDims> &, const tensor<T, NDims> &) Returns true if both tensors have the same shape and equal elements.
function tensor<T, NDims>::operator==(const tensor<T, NDims> &, tensor<T, NDims> &&) Returns true if both tensors have the same shape and equal elements.
function tensor<T, NDims>::operator==(const tensor<T, NDims> &, tensor<T, NDims> &) Returns true if both tensors have the same shape and equal elements.
function vec<T, N>::element::operator=(const typename vec<U, M>::element &) Assign from an element proxy of a different vector type.
function operator==(const univector<T, T1> &, const univector<T, T2> &) Returns true if the two univectors have equal size and element-wise equal contents.
function operator!=(const univector<T, T1> &, const univector<T, T2> &) Returns true if the two univectors differ in size or in any element.
function univector<T, tag_dynamic_vector>::operator=(const univector<T, tag_dynamic_vector> &)
function vec<T, N>::element::operator=(const value_type &) Assign a scalar to the referenced element.
function vec<T, N>::element::operator+=(const value_type &) Add-assign a scalar.
function vec<T, N>::element::operator-=(const value_type &) Subtract-assign a scalar.
function vec<T, N>::element::operator*=(const value_type &) Multiply-assign a scalar.
function vec<T, N>::element::operator/=(const value_type &) Divide-assign a scalar.
function operator+(const vec<T1, N> &, const T2 &)
function operator-(const vec<T1, N> &, const T2 &)
function operator*(const vec<T1, N> &, const T2 &)
function operator/(const vec<T1, N> &, const T2 &)
function operator%(const vec<T1, N> &, const T2 &)
function operator&(const vec<T1, N> &, const T2 &)
function operator|(const vec<T1, N> &, const T2 &)
function operator^(const vec<T1, N> &, const T2 &)
function operator==(const vec<T1, N> &, const T2 &)
function operator!=(const vec<T1, N> &, const T2 &)
function operator>=(const vec<T1, N> &, const T2 &)
function operator<=(const vec<T1, N> &, const T2 &)
function operator>(const vec<T1, N> &, const T2 &)
function operator<(const vec<T1, N> &, const T2 &)
function operator+(const vec<T1, N> &, const vec<T2, N> &)
function operator-(const vec<T1, N> &, const vec<T2, N> &)
function operator*(const vec<T1, N> &, const vec<T2, N> &)
function operator/(const vec<T1, N> &, const vec<T2, N> &)
function operator%(const vec<T1, N> &, const vec<T2, N> &)
function operator&(const vec<T1, N> &, const vec<T2, N> &)
function operator|(const vec<T1, N> &, const vec<T2, N> &)
function operator^(const vec<T1, N> &, const vec<T2, N> &)
function operator<<(const vec<T1, N> &, const vec<T2, N> &)
function operator>>(const vec<T1, N> &, const vec<T2, N> &)
function operator==(const vec<T1, N> &, const vec<T2, N> &)
function operator!=(const vec<T1, N> &, const vec<T2, N> &)
function operator>=(const vec<T1, N> &, const vec<T2, N> &)
function operator<=(const vec<T1, N> &, const vec<T2, N> &)
function operator>(const vec<T1, N> &, const vec<T2, N> &)
function operator<(const vec<T1, N> &, const vec<T2, N> &)
function operator<<(const vec<T1, N> &, unsigned int)
function operator>>(const vec<T1, N> &, unsigned int)
function vec<T, N>::operator=(const vec<T, N> &) Copy assignment operator.
function operator-(const vec<T, N> &)
function operator~(const vec<T, N> &)
function stereo_matrix::operator()(const vec<vec<T, 2>, N> &) Apply the matrix to a vector of stereo samples.
function cvals_t<T, values>::operator[](csize_t<index>) Returns the value at
function operator-(cval_t<T1, val1>)
function operator+(cval_t<T1, val1>)
function operator~(cval_t<T1, val1>)
function operator!(cval_t<T1, val1>)
function operator&&(cval_t<T1, val1>, cvals_t<T2, vals2...>)
function operator||(cval_t<T1, val1>, cvals_t<T2, vals2...>)
function operator==(cval_t<T1, val1>, cvals_t<T2, vals2...>)
function operator!=(cval_t<T1, val1>, cvals_t<T2, vals2...>)
function operator<(cval_t<T1, val1>, cvals_t<T2, vals2...>)
function operator>(cval_t<T1, val1>, cvals_t<T2, vals2...>)
function operator<=(cval_t<T1, val1>, cvals_t<T2, vals2...>)
function operator>=(cval_t<T1, val1>, cvals_t<T2, vals2...>)
function operator+(cval_t<T1, val1>, cvals_t<T2, vals2...>)
function operator-(cval_t<T1, val1>, cvals_t<T2, vals2...>)
function operator*(cval_t<T1, val1>, cvals_t<T2, vals2...>)
function operator/(cval_t<T1, val1>, cvals_t<T2, vals2...>)
function operator%(cval_t<T1, val1>, cvals_t<T2, vals2...>)
function operator<<(cval_t<T1, val1>, cvals_t<T2, vals2...>)
function operator>>(cval_t<T1, val1>, cvals_t<T2, vals2...>)
function operator&(cval_t<T1, val1>, cvals_t<T2, vals2...>)
function operator|(cval_t<T1, val1>, cvals_t<T2, vals2...>)
function operator^(cval_t<T1, val1>, cvals_t<T2, vals2...>)
function cvals_t<T, values>::operator[](cvals_t<size_t, indices...>) Returns a sub-list containing the values at
function operator-(cvals_t<T1, vals1...>)
function operator+(cvals_t<T1, vals1...>)
function operator~(cvals_t<T1, vals1...>)
function operator!(cvals_t<T1, vals1...>)
function operator&&(cvals_t<T1, vals1...>, cval_t<T2, val2>)
function operator||(cvals_t<T1, vals1...>, cval_t<T2, val2>)
function operator==(cvals_t<T1, vals1...>, cval_t<T2, val2>)
function operator!=(cvals_t<T1, vals1...>, cval_t<T2, val2>)
function operator<(cvals_t<T1, vals1...>, cval_t<T2, val2>)
function operator>(cvals_t<T1, vals1...>, cval_t<T2, val2>)
function operator<=(cvals_t<T1, vals1...>, cval_t<T2, val2>)
function operator>=(cvals_t<T1, vals1...>, cval_t<T2, val2>)
function operator+(cvals_t<T1, vals1...>, cval_t<T2, val2>)
function operator-(cvals_t<T1, vals1...>, cval_t<T2, val2>)
function operator*(cvals_t<T1, vals1...>, cval_t<T2, val2>)
function operator/(cvals_t<T1, vals1...>, cval_t<T2, val2>)
function operator%(cvals_t<T1, vals1...>, cval_t<T2, val2>)
function operator<<(cvals_t<T1, vals1...>, cval_t<T2, val2>)
function operator>>(cvals_t<T1, vals1...>, cval_t<T2, val2>)
function operator&(cvals_t<T1, vals1...>, cval_t<T2, val2>)
function operator|(cvals_t<T1, vals1...>, cval_t<T2, val2>)
function operator^(cvals_t<T1, vals1...>, cval_t<T2, val2>)
function operator&&(cvals_t<T1, vals1...>, cvals_t<T2, vals2...>)
function operator||(cvals_t<T1, vals1...>, cvals_t<T2, vals2...>)
function operator==(cvals_t<T1, vals1...>, cvals_t<T2, vals2...>)
function operator!=(cvals_t<T1, vals1...>, cvals_t<T2, vals2...>)
function operator<(cvals_t<T1, vals1...>, cvals_t<T2, vals2...>)
function operator>(cvals_t<T1, vals1...>, cvals_t<T2, vals2...>)
function operator<=(cvals_t<T1, vals1...>, cvals_t<T2, vals2...>)
function operator>=(cvals_t<T1, vals1...>, cvals_t<T2, vals2...>)
function operator+(cvals_t<T1, vals1...>, cvals_t<T2, vals2...>)
function operator-(cvals_t<T1, vals1...>, cvals_t<T2, vals2...>)
function operator*(cvals_t<T1, vals1...>, cvals_t<T2, vals2...>)
function operator/(cvals_t<T1, vals1...>, cvals_t<T2, vals2...>)
function operator%(cvals_t<T1, vals1...>, cvals_t<T2, vals2...>)
function operator<<(cvals_t<T1, vals1...>, cvals_t<T2, vals2...>)
function operator>>(cvals_t<T1, vals1...>, cvals_t<T2, vals2...>)
function operator&(cvals_t<T1, vals1...>, cvals_t<T2, vals2...>)
function operator|(cvals_t<T1, vals1...>, cvals_t<T2, vals2...>)
function operator^(cvals_t<T1, vals1...>, cvals_t<T2, vals2...>)
function operator|(datatype, datatype)
function operator&(datatype, datatype)
function aligned_new::operator
function dft_stage<T>::operator
function aligned_new::operator
function expression_resource_impl<E>::operator Aligned delete overload matching the aligned allocation in make_resource .
function dft_stage<T>::operator
function dft_plan_md_real<T, Dims>::operator=(dft_plan_md_real<T, Dims> &&)
function dft_plan_md<T, Dims>::operator=(dft_plan_md<T, Dims> &&)
function dft_plan_real<T>::operator=(dft_plan_real<T> &&)
function dft_plan<T>::operator=(dft_plan<T> &&) Move assignment operator.
operator fraction::operator Convert to double (exact value).
function operator-(E1 &&) Creates an expression that returns the arithmetic negation of e1.
function operator~(E1 &&) Creates an expression that returns the bitwise NOT of e1.
function operator+(E1 &&, E2 &&) Creates an expression that returns the sum of e1 and e2.
function operator-(E1 &&, E2 &&) Creates an expression that returns the difference between e1 and e2.
function operator*(E1 &&, E2 &&) Creates an expression that returns the product of e1 and e2.
function operator/(E1 &&, E2 &&) Creates an expression that returns the quotient of e1 divided by e2.
function operator%(E1 &&, E2 &&) Creates an expression that returns the remainder of e1 divided by e2.
function operator&(E1 &&, E2 &&) Creates an expression that returns the bitwise AND of e1 and e2.
function operator|(E1 &&, E2 &&) Creates an expression that returns the bitwise OR of e1 and e2.
function operator^(E1 &&, E2 &&) Creates an expression that returns the bitwise XOR of e1 and e2.
function operator<<(E1 &&, E2 &&) Creates an expression that returns e1 shifted left by e2 bits.
function operator>>(E1 &&, E2 &&) Creates an expression that returns e1 shifted right by e2 bits.
function operator+=(E1 &&, E2 &&) Adds e2 to e1 in place and returns a reference to e1.
function operator-=(E1 &&, E2 &&) Subtracts e2 from e1 in place and returns a reference to e1.
function operator*=(E1 &&, E2 &&) Multiplies e1 by e2 in place and returns a reference to e1.
function operator/=(E1 &&, E2 &&) Divides e1 by e2 in place and returns a reference to e1.
function operator%=(E1 &&, E2 &&) Assigns the remainder of e1 divided by e2 to e1 and returns a reference to e1.
function operator|=(E1 &&, E2 &&) Assigns the bitwise OR of e1 and e2 to e1 and returns a reference to e1.
function operator&=(E1 &&, E2 &&) Assigns the bitwise AND of e1 and e2 to e1 and returns a reference to e1.
function operator^=(E1 &&, E2 &&) Assigns the bitwise XOR of e1 and e2 to e1 and returns a reference to e1.
function operator<<=(E1 &&, E2 &&) Shifts e1 left by e2 bits in place and returns a reference to e1.
function operator>>=(E1 &&, E2 &&) Shifts e1 right by e2 bits in place and returns a reference to e1.
function fir_params<T>::operator=(fir_params<T> &&)
function fir_state<T, U>::operator=(fir_state<T, U> &&)
operator f16::operator Converts this IEEE 754 binary16 value to single precision.
operator fraction::operator Convert to float (exact value).
function cfor_t<stop, start, conditional>::operator=(Fn &&) Invokes fn for each index in [start, stop) , passing i as template argument.
function expression_function<Fn, Args>::operator=(In &&) Processes an input expression into this output expression.
function tensor<T, NDims>::operator[](index_t) Returns a reference to the element at the given flat index.
function inline_vector<T, N>::operator=(inline_vector<T, N> &&)
function expression_unpack<E>::operator=(Input &&) Assigns the values of input to all wrapped output expressions.
function univector_base<T, Class, true>::operator=(Input &&) Assigns an expression to the vector. The expression must have at most one dimension; its elements are written to the vector starting at index 0.
function univector_base<T, Class, false>::operator=(Input &&) Assignment from an expression is disabled for non-expression vectors. Always triggers a static assertion failure.
function univector<T, tag_dynamic_vector>::operator=(Input &&) Assigns an expression to the vector, resizing it when the expression has a finite size.
function tensor<T, NDims>::operator=(Input &&) Evaluates input and assigns the result to this tensor (const overload).
function tensor<T, NDims>::operator=(Input &&) Evaluates input and assigns the result to this tensor (rvalue overload).
function tensor<T, NDims>::operator=(Input &&) Evaluates input and assigns the result to this tensor (lvalue overload).
operator i24::operator Implicit conversion to int via as_int().
function vec<T, N>::element::operator++(int) Post-increment.
function vec<T, N>::element::operator--(int) Post-decrement.
function tensor<T, NDims>::tensor_iterator::operator++(int) Postfix increment.
function tensor<T, NDims>::nested_iterator_t::operator++(int) Postfix increment.
function range<T>::iterator::operator++(int)
function make_comparison::operator<=(L &&)
operator fraction::operator Convert to integer (truncates toward zero).
function cmp_eq::operator()(L &&, R &&)
function cmp_ne::operator()(L &&, R &&)
function cmp_lt::operator()(L &&, R &&)
function cmp_gt::operator()(L &&, R &&)
function cmp_le::operator()(L &&, R &&)
function cmp_ge::operator()(L &&, R &&)
function aligned_new::operator
function dft_stage<T>::operator
function aligned_new::operator
function dft_stage<T>::operator
operator vec<T, N>::operator Convert to a layout-compatible portable_vec .
function half_comparison<L>::operator==(R &&)
function half_comparison<L>::operator!=(R &&)
function half_comparison<L>::operator<(R &&)
function half_comparison<L>::operator>(R &&)
function half_comparison<L>::operator<=(R &&)
function half_comparison<L>::operator>=(R &&)
function random_state::operator=(random_state &&)
function samplerate_converter<T>::operator=(samplerate_converter<T> &&) Move assignment operator.
function cstring<N>::operator[](size_t)
function portable_vec<T, N>::operator[](size_t)
function portable_vec<T, N>::operator[](size_t)
function vec<T, N>::operator[](size_t) Read element at index from a const lvalue vector.
function vec<T, N>::operator[](size_t) Read element at index from an rvalue vector.
function vec<T, N>::operator[](size_t) Access element at index from a non-const lvalue vector.
function vec<T, N>::element::operator[](size_t) Index into a compound element (nested vector).
function autofree<T>::operator[](size_t) Access element at index.
function autofree<T>::operator[](size_t) Const access to element at index.
function histogram_data<Bins, TCount>::operator[](size_t) Returns the count in bin n.
function ebu_r128<T>::operator[](size_t) Access channel index (read-only).
function inline_vector<T, N>::operator[](size_type) Returns a const reference to the element at index (no bounds checking).
function inline_vector<T, N>::operator[](size_type) Returns a reference to the element at index (no bounds checking).
function small_buffer<T, Capacity>::operator=(small_buffer<T, Capacity>) Copy- and move-assigns from other using copy-and-swap.
function array_ref<T>::operator[](std::size_t)
function small_buffer<T, Capacity>::operator[](std::size_t)
function small_buffer<T, Capacity>::operator[](std::size_t)
function struct_with_alignment<T, A>::operator=(T) Assigns a new value to the wrapped member.
function struct_with_alignment<T, false>::operator=(T) Assigns a new value to the wrapped member.
function named::operator=(T &&)
function tensor<T, NDims>::operator=(tensor<T, NDims> &&) Move-assigns the tensor from src.
function tensor<T, NDims>::operator==(tensor<T, NDims> &&, const tensor<T, NDims> &) Returns true if both tensors have the same shape and equal elements.
function tensor<T, NDims>::operator==(tensor<T, NDims> &, const tensor<T, NDims> &) Returns true if both tensors have the same shape and equal elements.
function tensor<T, NDims>::operator==(tensor<T, NDims> &&, tensor<T, NDims> &&) Returns true if both tensors have the same shape and equal elements.
function tensor<T, NDims>::operator==(tensor<T, NDims> &&, tensor<T, NDims> &) Returns true if both tensors have the same shape and equal elements.
function tensor<T, NDims>::operator==(tensor<T, NDims> &, tensor<T, NDims> &&) Returns true if both tensors have the same shape and equal elements.
function tensor<T, NDims>::operator==(tensor<T, NDims> &, tensor<T, NDims> &) Returns true if both tensors have the same shape and equal elements.
function tensor_subscript<T, Derived, std::integer_sequence<index_t, Dims...>>::operator()(type_for<index_t, Dims>...) Accesses the element at the given multi-dimensional index.
function type_id_t::operator==(type_id_t)
function type_id_t::operator!=(type_id_t)
operator cval_t<T, val>::operator Implicit conversion to the underlying value
function special_value::operator Converts to type
operator bit<T>::operator
operator vec<T, N>::element::operator Read the referenced element.
function autocast_impl<Tfrom>::operator Converts the stored value to
function univector<T, tag_dynamic_vector>::operator=(univector<T, tag_dynamic_vector> &&)
function univector<T, tag_dynamic_vector>::operator=(univector<T, tag_dynamic_vector> &) Copy assignment from a mutable univector (forwards to the const overload).
function shape<Dims>::operator Implicit conversion to index_t for 1D shapes.
function operator+=(vec<T1, N> &, const T2 &)
function operator-=(vec<T1, N> &, const T2 &)
function operator*=(vec<T1, N> &, const T2 &)
function operator/=(vec<T1, N> &, const T2 &)
function operator%=(vec<T1, N> &, const T2 &)
function operator&=(vec<T1, N> &, const T2 &)
function operator|=(vec<T1, N> &, const T2 &)
function operator^=(vec<T1, N> &, const T2 &)
function operator+=(vec<T1, N> &, const vec<T2, N> &)
function operator-=(vec<T1, N> &, const vec<T2, N> &)
function operator*=(vec<T1, N> &, const vec<T2, N> &)
function operator/=(vec<T1, N> &, const vec<T2, N> &)
function operator%=(vec<T1, N> &, const vec<T2, N> &)
function operator&=(vec<T1, N> &, const vec<T2, N> &)
function operator|=(vec<T1, N> &, const vec<T2, N> &)
function operator^=(vec<T1, N> &, const vec<T2, N> &)
function operator<<=(vec<T1, N> &, const vec<T2, N> &)
function operator>>=(vec<T1, N> &, const vec<T2, N> &)
function operator<<=(vec<T1, N> &, unsigned int)
function operator>>=(vec<T1, N> &, unsigned int)
function vec<T, N>::operator=(vec<T, N> &&) Move assignment operator.
typedef opt_index_t Optional signed index used by tensor_range .
function optimized_bitshuffle(const vec<T, N> &) Internal ADL-provided implementation for bit-shuffle expressions.
typedef or_type If
variable samplerate_converter<T>::order Filter order.
typedef data_allocator<T>::rebind::other
variable biquad_state<T, filters>::out Last output vector, used as inter-section delay line.
variable dft_stage<T>::out_offset Offset (in complex elements) between successive recursive outputs.
variable expression_reshape<Arg, OutDims>::out_shape
function dft_resampler<T>::output_block_size() Returns the output FFT block size \(M\) .
concept output_expression Concept satisfied by expressions that can be written to.
function dft_resampler<T>::output_hop() Returns the number of valid output samples produced per frame.
variable samplerate_converter<T>::output_position Current output position.
function samplerate_converter<T>::output_position_to_input(itype) Converts an output position to the corresponding input position.
function samplerate_converter<T>::output_position_to_intermediate(itype) Converts an output position to an intermediate (pre-decimation) position.
function samplerate_converter<T>::output_size_for_input(itype) Calculates the output size produced for a given input size (push method).
variable mp3_config::outputChannels
variable mp3_config::outputSampleRate
variable convolve_filter<T>::overlap
variable overload_auto Convenience instance of the highest-priority tag for use in overload resolution
typedef overload_generic Alias for the lowest-priority tag, used as a fallback overload
struct overload_priority<0> Lowest priority tag, base of the overload_priority chain
class overload_priority<n> Tag type forming a linear inheritance chain used to rank overload candidates. overload_priority<n> derives from overload_priority<n-1> , so larger n is a better match.
function override_cpu(cpu_t) Overrides the CPU instruction set used by KFR at runtime.

P¶

variable zpk::p Poles of the transfer function
function pack_elements() Returns the identity value (0) for an empty pack
function pack_elements(Arg, Args...)
function pack(Args &&...) Creates an expression that packs several input expressions into a single vector-valued expression.
function pack(const Arg &, const Args &...) Pack scalar values into a vector of numeric type.
function ebu_channel<T>::packet_size() Return the number of samples per packet.
function ebu_r128<T>::packet_size() Return the number of samples per packet (= sample_rate / refresh_rate).
function packtranspose(const vec<T, N1> &, const vec<T, Ns> &...) Transposes and packs sizeof...(Ns)+1 vectors of length N1 into a vector of vectors of length N1 .
function padcenter(size_t, const std::string &, char) Center text within a field of size characters using character.
function padded(Arg &&, T) Creates an expression that extends arg with a constant fill value.
variable cpu_features::padding1
variable cpu_features::padding2
function padhigh(const vec<T, N> &) Pads x with Ncount zero-initialized lanes on the high side.
function padhigh(const vec<T, N> &, std::type_identity_t<T>) Pads x with Ncount copies of newvalue on the high side.
function padleft(size_t, const std::string &, char) Left-align text within a field of size characters by appending character.
function padlow(const vec<T, N> &) Pads x with Ncount zero-initialized lanes on the low side.
function padlow(const vec<T, N> &, std::type_identity_t<T>) Pads x with Ncount copies of newvalue on the low side.
function padright(size_t, const std::string &, char) Right-align text within a field of size characters by prepending character.
variable iir_state<T, filters>::params
variable fir_state<T, U>::params Filter parameters (reversed taps).
function part(const vec<T, N> &) Extracts the number-th of total equal-sized parts of x.
variable partial_masks Lookup table used by partial_mask to build vectors with a leading run of all-ones elements.
function partial_mask(size_t) Returns a vector of N elements with index leading all-ones elements followed by zeros.
function partial_mask(size_t, vec_shape<T, N>) Returns a vector of N elements with index leading all-ones elements followed by zeros.
function partial_read(const T *, size_t) Reads up to count elements into a vector.
function partial_write(T *, const vec<T, N> &, size_t) Writes up to count leading elements of a vector to memory.
typedef fn_generic::pass_through
function pass_through(T &&) Function that returns its first argument
typedef pconstvoid Pointer to const void
enum constant biquad_type::peak Peaking equalizer filter.
variable audio_stat::peak Peak absolute sample value across all channels.
enum constant sample_rate_conversion_quality::perfect Perfect quality (highest, slowest).
function perfplot_save(const std::string &, T1 &&, T2 &&, const std::string &)
function perfplot_show(const std::string &, T1 &&, T2 &&, const std::string &)
enum constant window_symmetry::periodic
enum constant dft_pack_format::Perm Packed format: {DC, Nyquist}, X[1], X[2], ..., X[N/2-1] For even N, the number of complex samples is
enum constant ::KFR_DFT_PACK_FORMAT::Perm Permuted format (N/2 complex values).
function permute(const vec<T, N> &, elements_t<Indices...>) Permutes the lanes of x using a repeating index pattern.
function permutegroups(const vec<T, N> &, elements_t<Indices...>) Group-wise variant of permute() that operates on blocks of group elements.
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.
variable scalar_constants<T>::pi The mathematical constant π (pi).
function scalar_constants<T>::pi_s(int, int) Returns π scaled by m / d .
class pkd_vec<T, N> Packed storage for a vector with no alignment padding.
constructor pkd_vec<T, N>::pkd_vec<T, N>() Default constructor (uninitialized).
constructor pkd_vec<T, N>::pkd_vec<T, N>(const vec<T, N> &) Store a vec into this packed storage.
function pkd_vec<T, N>::pkd_vec<T, N>(Ts...) Initialize from up to N scalar values.
function placeholder(csize_t<Key>) Create an unbound expression_placeholder with the given key.
typedef convolve_filter<T>::plan_t
enum constant window_type::planck_taper
class platform<c> Trait structure describing the SIMD capabilities of a CPU instruction set.
struct platform<cpu_t::avx> Platform traits for AVX. Doubles the native float vector size and alignment to 32 bytes and enables fast unaligned access.
struct platform<cpu_t::avx2> Platform traits for AVX2. Extends AVX with 256-bit integer vectors.
struct platform<cpu_t::avx512> Platform traits for AVX-512. Provides 512-bit vectors, 64-byte alignment, mask register support and an increased register count.
struct platform<cpu_t::common> Platform traits for the common (baseline) x86 instruction set.
struct platform<cpu_t::sse2> Platform traits for SSE2. Inherits the common baseline and reports the SSE2 register count.
struct platform<cpu_t::sse3> Platform traits for SSE3. Equivalent to SSE2.
struct platform<cpu_t::sse41> Platform traits for SSE4.1. Equivalent to SSSE3.
struct platform<cpu_t::sse42> Platform traits for SSE4.2. Equivalent to SSE4.1.
struct platform<cpu_t::ssse3> Platform traits for SSSE3. Equivalent to SSE3.
function plot_save(const std::string &, const T &, const std::string &) Plot data using python and save to file
function plot_show(const std::string &, const char *, const std::string &)
function plot_show(const std::string &, const std::string &, const std::string &)
function plot_show(const std::string &, const T &, const std::string &) Plot data using python
typedef struct_with_alignment<T, A>::pointer Pointer to this wrapper type.
typedef struct_with_alignment<T, false>::pointer Pointer to this wrapper type.
typedef array_ref<T>::pointer
typedef data_allocator<T>::pointer
typedef inline_vector<T, N>::pointer
typedef tensor<T, NDims>::pointer
typedef tensor<T, NDims>::tensor_iterator::pointer
typedef tensor<T, NDims>::nested_iterator_t::pointer
typedef range<T>::pointer
function audio_data<IsInterleaved>::pointers() Retrieves an array of pointers to the base type of the audio data.
function polar(const T1 &) Converts a complex number to its polar representation (magnitude, phase)
function polar(E1 &&) Creates an expression that converts a complex number to polar form.
function small_buffer<T, Capacity>::pop_back() Removes the last element.
class portable_vec<T, N> A portable vector type with fixed size and layout compatible with vec<T, N> .
constructor portable_vec<T, N>::portable_vec<T, N>()
constructor portable_vec<T, N>::portable_vec<T, N>(T)
function portable_vec<T, N>::portable_vec<T, N>(T, T, Ts...)
variable convolve_filter<T>::position
variable audio_data<IsInterleaved>::position Position of the first sample in the audio data.
function pow2(const T &) Returns \(x^2\) .
function pow2(E1 &&) Creates an expression that returns x raised to the power of 2.
function pow3(const T &) Returns \(x^3\) .
function pow3(E1 &&) Creates an expression that returns x raised to the power of 3.
function pow4(const T &) Returns \(x^4\) .
function pow4(E1 &&) Creates an expression that returns x raised to the power of 4.
function pow5(const T &) Returns \(x^5\) .
function pow5(E1 &&) Creates an expression that returns x raised to the power of 5.
function pow(const T1 &, const T2 &) Returns x raised to the given power y.
function pow(E1 &&, E2 &&) Creates an expression that returns x raised to the given power y.
function power_to_dB(const T1 &) Convert a power value to decibels (10*log10).
function power_to_dB(E1 &&) Convert a power expression to decibels (10*log10).
function dft_plan<T>::precompute_disposition(int, bitset, bool) Internal function
variable convolve_filter<T>::premul
function audio_data<IsInterleaved>::prepend(const audio_data<IsInterleaved> &) Prepends samples from a buffer with the opposite layout.
function prev_poweroftwo(T) Returns a nearest power of two that is less or equal than n
class print_t<chars> Callable object holding a compile-time format literal (built by operator""_print).
function print(const Args &...) Print values to stdout, each formatted with its default conversion specifier.
function printfmt(const std::string &, const Args &...) Print to stdout using a {}"-based format string.
function println(const Args &...) Print values to stdout followed by a newline.
function filter<T>::process_buffer(T *, const T *, size_t) Filters size samples from src into dest.
function expression_filter<T>::process_buffer(T *, const T *, size_t)
function convolve_filter<T>::process_buffer(T *, const T *, size_t)
function fir_filter<T, U>::process_buffer(U *, const U *, size_t)
function filter<T>::process_expression(T *, const expression_handle<T, 1> &, size_t) Evaluates size samples of the expression src into dest.
function expression_filter<T>::process_expression(T *, const expression_handle<T, 1> &, size_t)
function convolve_filter<T>::process_expression(T *, const expression_handle<T> &, size_t)
function fir_filter<T, U>::process_expression(U *, const expression_handle<U, 1> &, size_t)
function dft_resampler<T>::process_frame(const T *) Processes one frame in-place and returns a pointer to the valid output.
function dft_resampler<T>::process_frame(T *, const T *) Processes one frame via overlap-save and writes normalised output.
function samplerate_converter<T>::process_impl(univector_ref<T>, univector_ref<const T>) Internal implementation of the process function.
function ebu_r128<T>::process_packet(const std::initializer_list<univector_dyn<T>> &) Process one packet for every channel.
function ebu_r128<T>::process_packet(const std::initializer_list<univector_ref<T>> &)
function ebu_channel<T>::process_packet(const T *) Process one packet of packet_size() samples.
function ebu_r128<T>::process_packet(std::span<const univector_dyn<T>>)
function ebu_r128<T>::process_packet(std::span<const univector_ref<T>>)
function expression_reduce<Tout, Dims, Twork, Tin, ReduceFn, TransformFn, FinalFn>::process(const vec<Tin, N> &)
function expression_reduce<Tout, Dims, Twork, Tin, ReduceFn, TransformFn, FinalFn>::process(const vec<Tin, width> &)
function stereo_matrix::process(const vec<vec<T, 2>, N> &, csizes_t<indices...>) Internal ADL-provided implementation for stereo_matrix expressions.
function process(Out &&, In &&, shape<0>, shape<0>, csize_t<gw>) Processes a zero-dimensional input expression into a zero-dimensional output expression.
function process(Out &&, In &&, shape<outdims>, shape<outdims>, csize_t<gw>) Processes a multi-dimensional input expression into a multi-dimensional output expression.
function dft_resampler<T>::process(std::span<T>, std::span<const T>) Processes an arbitrary-length input stream and writes the resampled output.
function samplerate_converter<T>::process(univector<T, Tag> &, univector_ref<const T>) Processes input data to produce resampled output (pull or push method).
function shape<Dims>::product() Product of every axis size (total number of elements).
function shape<0>::product() Product of all axes; the empty product is 0.
function shape<dynamic_shape>::product() Product of every axis size; 0 for an empty shape.
function product(const E1 &) Returns the product of all the elements in x.
variable dft_plan<T>::progressive_optimized True if the plan is for progressive execution of the DFT.
function promoteto(const Tin &) Promote a scalar to Tout .
function promoteto(const vec<Tin, N> &) Promote a vector to a different element type.
function promoteto(const vec<vec<Tin, N1>, N2> &) Promote a nested vector to a different element type.
variable stride_pointer<const T, groupsize>::ptr Pointer to the first element.
variable autofree<T>::ptr Unique pointer with custom deleter for aligned memory.
function ptr_cast(const U *) Reinterprets a const pointer of type
function ptr_cast(U *)
function ptr_cast(U *, ptrdiff_t)
function small_buffer<T, Capacity>::push_back(const T &) Appends value to the end of the buffer.
function inline_vector<T, N>::push_back(T) Appends value to the end of the vector.
function fir_state<T, U>::push_delayline(Cont &&) Append samples to the delay line ring buffer.
function integrated_vec<T>::push(T) Append a momentary mean-square energy sample.
function lra_vec<T>::push(T) Insert a short-term mean-square energy sample, keeping the buffer sorted.
function histogram_data<Bins, TCount>::put(const vec<T, N> &) Adds a vector of values to the histogram, incrementing the appropriate bins.
function histogram_data<Bins, TCount>::put(T) Adds a single value to the histogram.
typedef pvoid Pointer to void
function python_prologue()

Q¶

variable expression_goertzel<T>::q0 Current filter output (working state).
variable expression_parallel_goertzel<T, width>::q0 Current filter outputs (working state).
variable expression_goertzel<T>::q1 Previous output sample (working state).
variable expression_parallel_goertzel<T, width>::q1 Previous output samples (working state).
variable expression_goertzel<T>::q2 Output sample two steps back (working state).
variable expression_parallel_goertzel<T, width>::q2 Output samples two steps back (working state).
variable qnan Quiet NaN (Not-a-Number) as a double .
variable scalar_constants<T>::qnan A quiet NaN (Not-a-Number) value for the type T. This value does not raise floating-point exceptions.
function q(T) Wrap the string representation of x in double quotes.

R¶

enum constant speaker_type::R Alias for Right.
variable dft_stage<T>::radix Radix of the stage (number of butterfly arms).
variable scalar_constants<T>::radtodeg Radians to degrees conversion factor (π * 180).
variable expression_traits<T>::random_access
variable expression_traits_defaults::random_access
variable expression_with_traits<Arg>::random_access
variable expression_function<Fn, Args>::random_access when all arguments support random access.
variable expression_traits<expression_slice<Arg>>::random_access
variable expression_traits<expression_cast<T, Arg>>::random_access
variable expression_traits<expression_lambda<T, Dims, Fn, Rnd>>::random_access
variable expression_traits<expression_padded<Arg>>::random_access
variable expression_traits<expression_fixshape<Arg, fixed_shape_t<ShapeValues...>>>::random_access
variable expression_traits<expression_reshape<Arg, OutDims>>::random_access
variable expression_traits<expression_concatenate<Arg1, Arg2, ConcatAxis>>::random_access
variable expression_adjacent<Fn, E>::random_access
variable expression_traits<expression_handle<T, Dims>>::random_access Handles are not random-access.
variable generator<T, VecWidth, Class, Twork>::random_access
variable expression_short_fir<tapcount, T, U, E1, stateless>::random_access
variable expression_fir<T, U, E1, stateless>::random_access
variable expression_moving_sum<U, E1, STag, stateless>::random_access
variable expression_delay<delay, E, stateless, STag>::random_access
variable expression_delay<1, E, stateless, STag>::random_access
enum constant special_constant::random_bits value filled with random bits
function special_value::random_bits()
function random_bits(random_state &) Generates more than 16 bytes of random data.
function special_value::random_generator() Returns a reference to the shared mt19937 random generator (seeded with 1)
function random_init() Initializes the random number generator state using the CPU cycle counter.
function random_init(u32, u32, u32, u32) Initializes the random number generator with four 32-bit seed values.
function random_init(u64, u64) Initializes the random number generator with two 64-bit seed values.
function random_next(random_state &) Advances the internal state of the pseudo-random number generator.
function random_normal(random_state &, T, T) Generates N normally distributed (Gaussian) random values using Box-Muller transform.
function random_range(random_state &, T, T) Generates random values uniformly distributed in the range [min, max) for integral types.
struct random_state Internal state of the pseudo-random number generator.
constructor random_state::random_state() Default-constructs the state initialized to all zeros.
constructor random_state::random_state(const random_state &)
constructor random_state::random_state(random_state &&)
function random_uniform(random_state &) Generates a vector of uniformly distributed floating-point numbers in [0.0, 1.0).
function randommantissa(random_state &) Generates a vector of f32 values with mantissas in [1.0, 2.0).
function randommantissa(random_state &) Generates a vector of f64 values with mantissas in [1.0, 2.0).
class range<T> Iterable range
constructor range<T>::range<T>(value_type, value_type, diff_type)
variable u24::raw Raw byte storage.
variable i24::raw Raw byte storage.
variable f16::raw Raw bit representation of the half-precision value.
struct raw_decoding_options Options for decoding raw audio streams.
struct raw_encoding_options Represents options for raw audio encoding.
function rawsawtooth(const T1 &) Sawtooth wave of a phase ramp in [0, 1) cycles.
function rawsawtooth(E1 &&) Expression overload of rawsawtooth ; applies element-wise to an expression.
function rawsine(const T1 &) Sine of a phase ramp in [0, 1) cycles.
function rawsine(E1 &&) Expression overload of rawsine ; applies element-wise to an expression.
function rawsquare(const T1 &) Square wave of a phase ramp in [0, 1) cycles.
function rawsquare(E1 &&) Expression overload of rawsquare ; applies element-wise to an expression.
function rawtriangle(const T1 &) Triangle wave of a phase ramp in [0, 1) cycles.
function rawtriangle(E1 &&) Expression overload of rawtriangle ; applies element-wise to an expression.
enum constant speaker_type::Rc Right center (front, between R and C).
function rdtsc() Reads the processor's cycle counter.
variable timestamps<max_count, fence>::rdtsc_overhead
function audio_decoder::read_all() Reads the entire audio stream into an interleaved buffer.
function audio_decoder::read_all_planar() Reads the entire audio stream into a planar buffer.
function read_audiofile_header(const file_path &) Reads the header of an audio file.
function audio_decoder::read_buffered(const audio_data_interleaved &, const std::function<expected<audio_data_interleaved, audiofile_error> ()> &, audio_data_interleaved &) Reads audio frames into a buffer using a custom read function.
function audio_reader<T>::read_channels()
function audio_reader<T>::read_channels(size_t)
function audio_decoder::read_chunk_bytes(std::span<const std::byte>) Reads a RIFF chunk into a byte vector.
function audio_decoder::read_chunk(std::span<const std::byte>, const std::function<bool (std::span<const std::byte>)> &, size_t) Reads a RIFF chunk by its identifier.
enum constant open_file_mode::read_existing
function read_group(const T *, size_t) Reads count groups of group*N elements separated by stride groups.
variable audio_decoding_options::read_metadata Whether to read metadata tags during decoding.
function audio_decoder::read_to(const audio_data_interleaved &) Reads audio frames into an interleaved buffer.
enum constant open_file_mode::read_write_existing
enum constant open_file_mode::read_write_new
function read(const T *) Reads a vector of N elements of type T from memory.
function stride_pointer<const T, groupsize>::read(csize_t<N>) Gathers N elements from the underlying pointer using the stored stride.
variable reader_adapter<From, To>::reader
function audio_decoder::reader() Retrieves the binary reader associated with the decoder.
class reader_adapter<From, To>
constructor reader_adapter<From, To>::reader_adapter<From, To>(std::shared_ptr<abstract_reader<From>>)
function abstract_reader<T>::read(size_t)
function audio_decoder::read(size_t) Reads up to a maximum number of audio frames into a newly allocated buffer.
function reader_adapter<From, To>::read(To *, size_t)
function abstract_reader<T>::read(T *, size_t)
function memory_reader<T>::read(T *, size_t)
function file_reader<T>::read(T *, size_t)
function audio_reader_wav<T>::read(T *, size_t) Reads and decodes audio data
function audio_reader_flac<T>::read(T *, size_t) Reads and decodes audio data
function audio_reader_mp3<T>::read(T *, size_t) Reads and decodes audio data
function abstract_reader<T>::read(U &)
variable convolve_filter<T>::real_fft
variable dft_plan_md_real<T, Dims>::real_out_is_enough If true, the inverse transform may write directly into the real output buffer without an extra complex working region.
function dft_plan_md_real<T, Dims>::real_out_size() Returns the number of real elements needed to hold the inverse output.
function dft_plan_md_real<T, Dims>::real_out_size_for(shape<Dims>) Returns the real output element count for a given real shape.
function real(const complex<T> &) Returns the real part of the complex value
function real(const T &) Returns the real part of the complex value
function real(const vec<complex<T>, N> &) Returns the real parts of a vector of complex values.
function realdft(const univector<T, Tag> &) Performs the direct (forward) real-to-complex DFT using a cached plan.
function real(E1 &&) Creates an expression that returns the real part of the complex value x.
typedef realftype Alias for ftype<decltype(kfr::real(std::declval<T>()))>
typedef realtype Alias for decltype(kfr::real(std::declval<T>()))
typedef compound_type_traits<T>::rebind
typedef compound_type_traits<std::pair<T, T>>::rebind
typedef compound_type_traits<kfr::vec_shape<T, N>>::rebind
typedef compound_type_traits<kfr::vec<T, N>>::rebind
typedef compound_type_traits<std::complex<T>>::rebind Rebinds the complex to hold values of type
function rebind(const expression_function<Fn, OldArgs...> &, NewArgs &&...) Construct a new expression using the same function as in e and new arguments
function rebind(expression_function<Fn, OldArgs...> &&, NewArgs &&...) Construct a new expression using the same function as in e and new arguments.
class data_allocator<T>::rebind
variable scalar_constants<T>::recip_log_10 The reciprocal of the natural logarithm of 10 (1 / ln(10)).
variable scalar_constants<T>::recip_log_2 The reciprocal of the natural logarithm of 2 (1 / ln(2)).
variable scalar_constants<T>::recip_pi The reciprocal of π (1/π).
function scalar_constants<T>::recip_pi_s(int, int) Returns the reciprocal of π scaled by m / d .
function reciprocal(const T &) Multiplicative inverse of x .
function timestamps<max_count, fence>::record(const char *) Record a timestamp checkpoint with an optional label.
enum constant window_type::rectangular
enum constant audio_dithering::rectangular
variable dft_stage<T>::recursion Whether the stage uses recursive execution.
function reduce(const E1 &, ReduceFn &&, TransformFn &&, FinalFn &&) Reduces a range to a single value.
variable expression_reduce<Tout, Dims, Twork, Tin, ReduceFn, TransformFn, FinalFn>::reducefn
function tensor<T, NDims>::reduce(Fn &&, T) Reduces all elements using fn and an initial value.
function univector_base<T, Class, true>::ref() Returns a mutable reference to the underlying data.
function univector_base<T, Class, true>::ref() Returns a const reference to the underlying data.
function univector_base<T, Class, false>::ref() Returns a mutable reference to the underlying data.
function univector_base<T, Class, false>::ref() Returns a const reference to the underlying data.
function univector<T, tag_array_ref>::ref() Returns *this as a reference. Intended for use on rvalues to forward the contained reference without copying.
function ref_cast(const U &) Reinterprets a const reference of type
function ref_cast(U &)
typedef array_ref<T>::reference
typedef data_allocator<T>::reference
typedef inline_vector<T, N>::reference
typedef tensor_subscript<T, Derived, std::integer_sequence<index_t, Dims...>>::reference
typedef tensor<T, NDims>::reference
typedef tensor<T, NDims>::tensor_iterator::reference
typedef tensor<T, NDims>::nested_iterator_t::reference
typedef range<T>::reference
function 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 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 reference_dft_md(T *, const complex<T> *, shape<dynamic_shape>, bool, size_t, size_t) Performs Multidimensional Inverse Real DFT using reference implementation (slow, used for testing)
function 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 reference_dft(complex<T> *, const T *, size_t, size_t, size_t) Performs Direct Real DFT using reference implementation (slow, used for testing)
function reference_dft(T *, const complex<T> *, size_t, size_t, size_t) Performs Inverse Real DFT using reference implementation (slow, used for testing)
function rem(const T1 &, const T2 &) Remainder of x divided by y .
function rem(const vec<T, N> &, const vec<T, N> &) Returns the element-wise floating-point remainder of vectors x and y.
function shape<Dims>::remove_back() Drop the last axis.
function shape<dynamic_shape>::remove_back() Drop the last axis.
function shape<Dims>::remove_front() Drop the first axis.
function shape<dynamic_shape>::remove_front() Drop the first axis.
function render(Expr &&) Converts an expression to a dynamically sized univector.
function render(Expr &&, csize_t<Size>) Converts an expression to a fixed-size univector.
function render(Expr &&, size_t, size_t) Converts a slice of an expression to a dynamically sized univector of the given size.
function repeat(const vec<T, N> &) Repeats the contents of x count times.
variable dft_stage<T>::repeats Number of recursive repetitions used during execution.
function replace(const vec<T, N> &, const vec<T, N> &) Replaces a contiguous range of x with the corresponding lanes of y.
typedef repr_type Alias for the type used by representation<T> when formatting values of type T.
class representation<fmt_t<kfr::complex<T>, t, width, prec>> String representation specialization for a formatted complex value.
class representation<fmt_t<kfr::generic::vec<T, N>, t, width, prec>>
class representation<fmt_t<kfr::tensor<T, dims>, t, width, prec>> Specialization of representation for a formatted tensor, providing formatted string conversion.
class representation<fmt_t<kfr::univector<T, Tag>, t, width, prec>> representation specialization that formats a fmt_t-wrapped univector as a string, applying the wrapped format options to each element.
class representation<kfr::complex<T>> String representation specialization for kfr::complex<T> .
struct representation<kfr::cpu_t>
struct representation<kfr::fraction> String representation specialization for fraction .
class representation<kfr::generic::mask<T, N>> String representation of a mask for formatting/logging.
class representation<kfr::generic::vec<T, N>> String representation of a vec for formatting/logging.
struct representation<kfr::npy_decode_result>
class representation<kfr::shape<dims>> String representation of a shape , used by as_string and the formatting framework.
struct representation<kfr::special_value>
class representation<kfr::tensor<T, dims>> Specialization of representation for tensor, providing string conversion.
class representation<kfr::univector<T, Tag>> representation specialization that formats a univector as a string using KFR's built-in array formatting.
class representation<named_arg<T>> Representation of named_arg as name = value".
class representation<std::array<T, Size>> Representation of std::array as a brace-delimited list of its elements.
class representation<std::pair<T1, T2>> Representation of std::pair as (first; second)".
class representation<std::shared_ptr<T1>> Representation of std::shared_ptr as Type(value) or Type(nullptr)".
struct representation<std::shared_ptr<void>> Representation of std::shared_ptr<void> as Type(pointer) or Type(nullptr)".
struct representation<std::string_view> Representation of std::string_view as a std::string.
class representation<std::unique_ptr<T1>> Representation of std::unique_ptr as Type(value) or Type(nullptr)".
class representation<std::vector<T, Allocator>> Representation of std::vector as a brace-delimited list of its elements.
class representation<std::weak_ptr<T1>> Representation of std::weak_ptr as Type(value) or Type(nullptr)".
class representation<T> Primary template for converting a value of type T to its string representation.
function tensor<T, NDims>::require_contiguous() Throws if the tensor is not contiguous.
typedef resample_quality Alias for sample_rate_conversion_quality.
function resampler(sample_rate_conversion_quality, size_t, size_t, subtype<T>, subtype<T>) Helper function to create a sample rate converter instance.
function audio_data<IsInterleaved>::reserve(size_t) Increases the allocated capacity, preserving existing samples.
function filter<T>::reset() Resets the internal state (such as a delay line).
function expression_filter<T>::reset() Resets the state of the wrapped expression.
function expression_reduce<Tout, Dims, Twork, Tin, ReduceFn, TransformFn, FinalFn>::reset()
function convolve_filter<T>::reset() Resets the filter state (clears input history and overlap buffers).
function dft_resampler<T>::reset() Resets the resampler to its freshly-constructed state, clearing all buffered input without changing filter parameters.
function fir_filter<T, U>::reset() Reset internal filter state
function integrated_vec<T>::reset() Clear the buffer and invalidate the cached result.
function lra_vec<T>::reset() Clear the buffer and invalidate the cached result.
function ebu_channel<T>::reset() Zero the momentary and short-term sum-of-squares ring buffers.
function ebu_r128<T>::reset() Request a deferred reset of all channels and accumulators.
function samplerate_converter<T>::reset() Resets the converter to its initial state.
function audio_data<IsInterleaved>::reset() Resets the object to its default state.
function reset(const expression_delay<1, E, stateless, STag> &) Clears a one-sample delay expression's stored sample.
function reset(const expression_delay<delay, E, stateless, STag> &) Clears a multi-sample delay expression's ring buffer and cursor.
function reset(const expression_fir<T, U, E1, stateless> &) Clears a generic FIR expression's delay line while preserving its taps.
function reset(const expression_goertzel<T> &) Clears a Goertzel resonator's recursive state.
function reset(const expression_handle<T, NDims> &) Internal ADL-provided implementation for expression_handle expressions.
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.
function reset(const expression_with_arguments<Args...> &) Resets all arguments of an expression_with_arguments .
function reset(const internal_generic::anything &) No-op reset hook for the anything placeholder type.
function tensor<T, NDims>::reshape_may_copy(const kfr::shape<dims> &, bool) Returns a tensor with a different shape, copying if necessary.
function reshape(Arg &&, const shape<OutDims> &) Creates an expression that exposes the same data as arg with a different shape.
function tensor<T, NDims>::reshape(const kfr::shape<dims> &) Returns a tensor with a different shape without copying. The tensor must be contiguous.
function resize(const vec<T, N> &) Resizes a vector to length Nout.
function resize(const vec<T, N> &) Identity overload of resize() for the Nout == N case.
function univector<T, Size>::resize(size_t) No-op for API compatibility with dynamically sized vectors.
function univector<T, tag_array_ref>::resize(size_t) No-op for API compatibility with dynamically sized vectors.
function audio_data<IsInterleaved>::resize(size_t) Resizes the container to hold exactly new_size elements.
function audio_data<IsInterleaved>::resize(size_t, fbase) Resize to the specified length and initialize newly added samples.
function small_buffer<T, Capacity>::resize(std::size_t) Resizes the buffer to newsize elements.
variable expression_handle<T, Dims>::resource Owning resource, or null for a non-owning handle.
variable expression_goertzel<T>::result Output complex bin value (written on destruction).
variable expression_parallel_goertzel<T, width>::result Output array of
function generator<T, VecWidth, Class, Twork>::resync(T) Reinitializes the generator state so that the next produced value corresponds to the given start.
function return_constant(Args &&...) Function that returns constant of type T and ignores all its arguments
typedef fn_generic::returns
function returns(Ts &&...) Function that returns value-initialization of type T and ignores all its arguments
typedef array_ref<T>::reverse_iterator
function reverse(Arg &&) Creates an expression that exposes arg with its trailing dimension reversed.
function reverse(const vec<T, N> &) Reverses the order of lanes in x (with optional grouping).
function reverse(const vec<vec<T, N1>, N2> &) Reverses the order of inner vectors in a vector of vectors.
function shape<Dims>::revindex(size_t) Read an axis by its position from the back.
function shape<0>::revindex(size_t) Read an axis by its position from the back; always returns 1 because there are no axes.
enum constant audiofile_container::rf64 RF64 by EBU
variable comparison<Fn, L, R>::right
enum constant speaker_type::Right Front right.
enum constant speaker_type::RightSurround Alias for Rs.
function univector_base<T, Class, true>::ringbuf_read(size_t &, T &) Reads a single element from the ring buffer at cursor into value and advances the cursor.
function univector_base<T, Class, true>::ringbuf_read(size_t &, T *, size_t) Reads destsize elements from the ring buffer at cursor into dest. The buffer is treated as circular: reads that cross the end wrap around to the beginning. If destsize exceeds the buffer capacity, only the most recent size() elements are produced and the leading portion of dest is skipped. cursor is advanced by the number of elements actually read and wrapped into [0, size()).
function univector_base<T, Class, true>::ringbuf_read(size_t &, vec<T, N> &) Reads N elements from the ring buffer at cursor into the SIMD vector x.
function univector_base<T, Class, true>::ringbuf_step(size_t &, size_t) Advances cursor by step, wrapping it into the [0, size()) range.
function univector_base<T, Class, true>::ringbuf_write(size_t &, const T &) Writes a single value into the ring buffer at cursor and advances the cursor.
function univector_base<T, Class, true>::ringbuf_write(size_t &, const T *, size_t) Writes srcsize elements from src into the ring buffer starting at cursor. The buffer is treated as circular: data that does not fit before the end wraps around to the beginning. If srcsize exceeds the buffer capacity, only the most recent size() elements are kept and the rest is skipped. cursor is advanced by the number of elements actually written and wrapped into [0, size()).
function univector_base<T, Class, true>::ringbuf_write(size_t &, const vec<T, N> &) Writes the N elements of the SIMD vector x into the ring buffer at cursor.
variable audio_stat::rms Root mean square of all samples across all channels.
function rms(const E1 &) Returns the root mean square of all the elements in x.
variable audio_dithering_state::rnd Random number generator.
function rol(const T1 &, const T2 &) Bitwise left rotate.
function root(const T1 &, const T2 &) Returns the real y-th root of x.
function root(E1 &&, E2 &&) Creates an expression that returns the real nth root of x.
function ror(const T1 &, const T2 &) Bitwise right rotate.
function shape<Dims>::rotate_left() Rotate the axes left by one position.
function shape<dynamic_shape>::rotate_left() Rotate the axes left by one position.
function shape<Dims>::rotate_right() Rotate the axes right by one position.
function shape<dynamic_shape>::rotate_right() Rotate the axes right by one position.
function rotateleft(const vec<T, N> &, csize_t<amount>) Rotates the lanes of x to the left by amount positions.
function rotateright(const vec<T, N> &, csize_t<amount>) Rotates the lanes of x to the right by amount positions.
function rotatetwo(const vec<T, N> &, const vec<T, N> &) Combines two vectors lo and hi with a rotation by shift lanes.
function round(const T1 &) Returns the nearest integer value to x.
function round(E1 &&) Creates an expression that returns x rounded to the nearest integer.
enum constant speaker_type::Rs Right surround.
function ebu_r128<T>::running() Return whether the meter is currently running (see start() , stop() ).
enum constant cpu_t::runtime
class runtime_error

S¶

variable state_holder<T, false>::s The owned state value.
variable state_holder<T, true>::s Pointer to the externally owned state. Never null for a valid holder.
enum constant speaker_type::S Rear surround (single).
variable biquad_state<T, filters>::s1 First delay register per section.
variable biquad_state<T, filters>::s2 Second delay register per section.
function safe_cast(const InType &) Casts between integral types after range-checking the source value.
function ebu_r128<T>::sample_rate() Return the configured sample rate in Hz.
variable audiofile_format::sample_rate Sample rate in Hz.
enum sample_rate_conversion_quality Defines the quality levels for sample rate conversion.
function sample_rate_converter(sample_rate_conversion_quality, size_t, size_t, subtype<T>, subtype<T>) Helper function to create a sample rate converter instance.
typedef sample_rate_t Sample rate expressed in Hertz.
function audiofile_format::sample_type()
function audiofile_format::sample_type_lpcm()
variable audio_format::samplerate
class samplerate_converter<T> A template class for performing sample rate conversion on audio signals.
constructor samplerate_converter<T>::samplerate_converter<T>() Default constructor.
constructor samplerate_converter<T>::samplerate_converter<T>(int, itype, itype, fbase, fbase, fbase, fbase) Constructs a sample rate converter from explicit filter parameters.
constructor samplerate_converter<T>::samplerate_converter<T>(sample_rate_conversion_quality, itype, itype, fbase, fbase) Constructs a sample rate converter.
constructor samplerate_converter<T>::samplerate_converter<T>(samplerate_converter<T> &&) Move constructor.
function samples_load(audio_sample_type, fbase *const *, const std::byte *, size_t, size_t, bool) Loads interleaved audio samples based on sample type.
function samples_load(audio_sample_type, fbase *, const std::byte *, size_t, bool) Loads audio samples based on sample type.
function samples_load(fbase *const *, const Tin *, size_t, size_t, bool) Loads interleaved audio samples into a planar floating-point buffer.
function samples_load(fbase *, const Tin *, size_t, bool) Loads audio samples into a floating-point buffer.
function samples_store(audio_sample_type, std::byte *, const fbase *const *, size_t, size_t, bool) Stores interleaved audio samples based on sample type.
function 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 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 samples_store(Tout *, const fbase *const *, size_t, size_t, bool) Stores planar floating-point samples into a interleaved buffer.
function 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 samples_store(Tout *, const fbase *, size_t, const audio_quantization &, bool) Stores floating-point samples into a buffer with quantization.
function satadd(const T1 &, const T2 &) Adds two numeric values using saturation arithmetic.
function satadd(E1 &&, E2 &&) Creates an expression that adds x and y using saturation.
function satsub(const T1 &, const T2 &) Subtracts two numeric values using saturation arithmetic.
function satsub(E1 &&, E2 &&) Creates an expression that subtracts y from x using saturation.
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 save_to_npy(const tensor<T, Dims> &, Fn &&) Saves a tensor to .npy format using a custom write callback.
variable epsilon_scope<T>::saved
variable convolve_filter<T>::saved_input
variable iir_state<T, filters>::saved_state Snapshot used for block-based processing.
function sawtooth(const T1 &) Sawtooth wave of a phase in radians.
function sawtooth(E1 &&) Expression overload of sawtooth ; applies element-wise to an expression.
function sawtoothnorm(const T1 &) Sawtooth wave of a phase ramp in [0, 1) cycles (alias of rawsawtooth ).
function sawtoothnorm(E1 &&) Expression overload of sawtoothnorm ; applies element-wise to an expression.
class scalar_constants<T> Collection of mathematical and machine constants for the scalar type T .
function vec_shape<T, N>::scalar_size() Total number of scalar components, including compound element widths.
function vec<T, N>::scalar_size()
typedef vec_shape<T, N>::scalar_type Scalar component type of the element.
typedef vec<T, N>::scalar_type
function scalar(T) Creates an expression that wraps a single value.
function scale()
variable audio_sample_traits<i16>::scale Maximum representable magnitude used as conversion scale.
variable audio_sample_traits<i24>::scale Maximum representable magnitude used as conversion scale.
variable audio_sample_traits<i32>::scale Maximum representable magnitude used as conversion scale.
variable audio_sample_traits<f32>::scale Scale factor for float samples (always 1).
variable audio_sample_traits<f64>::scale Scale factor for double samples (always 1).
variable reader_adapter<From, To>::scale
variable writer_adapter<From, To>::scale
variable audio_dithering_state::scale Amplitude scale applied to the generated noise.
function scale(csizes_t<indices...>)
function scatter_stride(T *, const vec<T, N> &, size_t) Scatters N/groupsize groups of groupsize contiguous elements of value to base separated by stride.
function scatter(const T *, const vec<T, N> &) Scatters elements of value to base at the given compile-time indices.
function scatter(T *, const vec<IT, N> &, const vec<T, Nout> &) Scatters N groups of groupsize contiguous elements of value to base using a vector of offsets.
variable convolve_filter<T>::scratch1
variable convolve_filter<T>::scratch2
enum constant cpu_t::secondary
variable seed_from_rdtsc Tag value used to seed the random number generator from the CPU cycle counter.
struct seed_from_rdtsc_t Tag type for seeding the random number generator from the CPU cycle counter.
function audio_decoder::seek_is_precise() Determines whether seeking is precise for this decoder.
enum seek_origin Seek origin
function audio_writer_wav<T>::seek(imax, seek_origin)
function audio_reader_wav<T>::seek(imax, seek_origin) Seeks to specific sample
function audio_reader_flac<T>::seek(imax, seek_origin) Seeks to specific sample
function audio_reader_mp3<T>::seek(imax, seek_origin) Seeks to specific sample
function abstract_stream<T>::seek(int64_t, int)
function abstract_stream<T>::seek(int64_t, seek_origin)
function memory_reader<T>::seek(int64_t, seek_origin)
function memory_writer<T>::seek(int64_t, seek_origin)
function reader_adapter<From, To>::seek(int64_t, seek_origin)
function writer_adapter<From, To>::seek(int64_t, seek_origin)
function file_reader<T>::seek(int64_t, seek_origin)
function file_writer<T>::seek(int64_t, seek_origin)
function audio_decoder::seek(uint64_t) Seeks to a specific sample position in the audio stream.
variable convolve_filter<T>::segments
function compiletime::select(bool, T, T) Compile-time conditional select between two values.
function select(const mask<T1, N> &, const T2 &, const T3 &) Returns x if m is true, otherwise return y. Order of the arguments is same as in ternary operator.
function select(cvals_t<bool, flags...>, cvals_t<T, values1...>, cvals_t<T, values2...>) Element-wise selection between two value lists based on a flag list. For each position, returns values1[i] if flags[i] is true , otherwise values2[i] .
function select(E1 &&, E2 &&, E3 &&) Creates an expression that returns x if m is true, otherwise returns y.
function sequence(const Ts &...) Creates an expression that cycles through the provided list of values.
function convolve_filter<T>::set_data(const univector_ref<const T> &) Sets (replaces) the filter kernel.
function set_elements(const expression_cast<T, Arg> &, const shape<NDims> &, const axis_params<Axis, N> &, const std::type_identity_t<vec<T, N>> &) Internal ADL-provided implementation for
function expression_discard<Tin, Dims>::set_elements(const expression_discard<Tin, Dims> &, shape<Dims>, axis_params<VecAxis, N>, const std::type_identity_t<vec<Tin, N>> &) Discards a vector write.
function set_elements(const expression_handle<T, NDims> &, const shape<NDims> &, const axis_params<Axis, N> &, const std::type_identity_t<vec<T, N>> &) Internal ADL-provided implementation for expression_handle expressions.
function set_elements(const expression_slice<Arg> &, const shape<NDims> &, const axis_params<Axis, N> &, const std::type_identity_t<vec<T, N>> &) Internal ADL-provided implementation for
function set_elements(const tensor<T, NDims> &, const shape<NDims> &, const axis_params<Axis, N> &, const std::type_identity_t<vec<T, N>> &) Internal ADL-provided implementation for tensor expressions. Writes value as N elements along Axis starting at index into self.
function set_elements(expression_fixshape<Arg, Shape> &, const shape<Traits::dims> &, const axis_params<Axis, N> &, const std::type_identity_t<vec<T, N>> &) Internal ADL-provided implementation for
function 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>> &) Internal ADL-provided implementation for
function expression_goertzel<T>::set_elements(expression_goertzel<T> &, shape<1>, axis_params<VecAxis, N>, const std::type_identity_t<vec<T, N>> &) Internal ADL-provided implementation for expression_goertzel expressions.
function expression_parallel_goertzel<T, width>::set_elements(expression_parallel_goertzel<T, width> &, shape<1>, axis_params<VecAxis, N>, const std::type_identity_t<vec<T, N>> &) Internal ADL-provided implementation for expression_parallel_goertzel expressions.
function expression_reduce<Tout, Dims, Twork, Tin, ReduceFn, TransformFn, FinalFn>::set_elements(expression_reduce<Tout, Dims, Twork, Tin, ReduceFn, TransformFn, FinalFn> &, shape<Dims>, axis_params<VecAxis, N>, const std::type_identity_t<vec<Tin, N>> &)
function set_elements(expression_reshape<Arg, outdims> &, const shape<Traits::dims> &, const axis_params<Axis, N> &, const std::type_identity_t<vec<T, N>> &) Internal ADL-provided implementation for
function set_elements(expression_reverse<Arg> &, const shape<Traits::dims> &, const axis_params<Axis, N> &, const std::type_identity_t<vec<T, N>> &) Internal ADL-provided implementation for
function expression_unpack<E>::set_elements(expression_unpack<E...> &, shape<dims>, axis_params<Axis, N>, const std::type_identity_t<vec<value_type, N>> &)
function set_elements(strided_channel<T> &, const shape<1> &, const axis_params<0, N> &, const std::type_identity_t<vec<T, N>> &)
function set_elements(T &, const shape<0> &, const axis_params<Axis, N> &, const std::type_identity_t<vec<T, N>> &) Stores a single-element vector into a scalar element.
function set_elements(univector<T, Tag> &, const shape<1> &, const axis_params<0, N> &, const std::type_identity_t<vec<T, N>> &) Internal ADL-provided implementation for set_elements expressions.
function fir_filter<T, U>::set_params(fir_params<T>) Replace the filter parameters (alias of
function shape<Dims>::set_revindex(size_t, index_t) Write an axis by its position from the back.
function shape<0>::set_revindex(size_t, index_t) Set an axis by its position from the back; a no-op.
function fir_filter<T, U>::set_taps(fir_params<T>) Replace the filter taps (resets parameters; delay line is unchanged until next process).
function vec<T, N>::set(csize_t<index>, const value_type &) Set element at compile-time index (compound element type).
function vec<T, N>::set(size_t, const value_type &) Set element at runtime index (compound element type).
function portable_vec<T, N>::shape()
function vec<T, N>::shape()
constructor shape<0>::shape() Default-construct an empty (scalar) shape.
deduction guide shape Deduction guide for shape from a parameter pack.
function tensor<T, NDims>::shape() Returns the shape of the tensor.
struct shape<0> Scalar shape specialization.
typedef tensor<T, NDims>::shape_type
class shape<dims> Fixed-rank multidimensional shape used by tensor .
constructor shape<Dims>::shape<dims>(const base &) Construct a shape from a base static array.
struct shape<dynamic_shape> Run-time-rank shape specialization.
constructor shape<0>::shape(index_t) Construct a scalar shape; the value is ignored.
function shape<dynamic_shape>::shape(shape<Dims>) Construct a dynamic-rank shape from a fixed-rank one.
variable dft_resampler_params::shift Resampling factor as a power of 2 (e.g. 1 for 2x, -1 for 0.5x, 0 for filter-only).
function shl(const T1 &, const T2 &) Bitwise left shift.
typedef opencl_names::short16
typedef opencl_names::short2
typedef opencl_names::short3
typedef opencl_names::short4
typedef opencl_names::short8
class short_fir_state<tapcount, T, U> State for a short FIR filter (tap count in range 2..33).
function short_fir_state<tapcount, T, U>::short_fir_state<tapcount, T, U>(const univector<const T, N> &) Construct from a runtime-sized tap vector (const data variant).
function short_fir_state<tapcount, T, U>::short_fir_state<tapcount, T, U>(const univector<T, N> &) Construct from a runtime-sized tap vector.
function short_fir(E1 &&, const univector<T, TapCount> &) Returns template expression that applies a short FIR filter to the input (tap count must be in range 2..33).
function short_fir(E1 &&, std::reference_wrapper<short_fir_state<TapCount, T, U>>) Returns template expression that applies a short FIR filter to the input (tap count must be in range 2..33).
function short_fir(short_fir_state<InternalTapCount, T, U> &, E1 &&) Returns template expression that applies a short FIR filter to the input (tap count must be in range 2..33).
function shr(const T1 &, const T2 &) Bitwise right shift.
function shuffle(const vec<T, N> &, const vec<T, N> &, elements_t<Indices...>) Shuffles the concatenation of two equal-length vectors using a repeating index pattern.
function vec<T, N>::shuffle(const vec<T, N> &, csizes_t<indices...>) Permute elements from two concatenated vectors (*this, y) .
function vec<T, N>::shuffle(csizes_t<indices...>) Permute elements of this vector according to i .
function shufflegroups(const vec<T, N> &, const vec<T, N> &, elements_t<Indices...>) Group-wise variant of shuffle() that operates on blocks of group elements.
function shuffleindexbits(const vec<T, N> &, elements_t<A...>) Shuffles lanes of x by permuting the bits of each lane index.
function shufflevector(const vec<complex<T>, N> &, csizes_t<indices...>) Shuffles the complex elements of x according to indices.
function shufflevector(const vec<T, N> &, csizes_t<indices...>) Permute elements of a single vector.
function shufflevectors(const vec<complex<T>, N> &, const vec<T, N> &, csizes_t<indices...>) Shuffles complex elements from two vectors x and y according to indices.
function shufflevectors(const vec<T, N> &, const vec<T, N> &, csizes_t<indices...>) Permute elements from two concatenated vectors.
function samplerate_converter<T>::sidelobe_att() Calculates the sidelobe attenuation based on the Kaiser beta parameter.
function samplerate_converter<T>::sidelobe_attenuation(sample_rate_conversion_quality) Returns the sidelobe attenuation for a given quality level.
variable expression_random_normal<T, Dims, Reference>::sigma
typedef signed_index_t Signed integer type used for tensor indices and axis sizes.
variable signed_types Type list of all signed integer element types.
variable signed_vector_types Instance of signed_vector_types_t for use as a value parameter pack.
typedef signed_vector_types_t Type list of signed-integer vector instantiations for the test sizes.
concept simd_compat Concept satisfied by scalar types usable as SIMD elements.
variable vec<T, N>::simd_element_count Number of native lanes.
variable vec<T, N>::simd_element_size
typedef vec<T, N>::simd_element_type
variable platform<cpu_t::common>::simd_register_count
variable platform<cpu_t::sse2>::simd_register_count
variable platform<cpu_t::avx512>::simd_register_count
typedef vec<T, N>::simd_type
function sin2x(const T &, const T &) Returns sin(2x) from already computed sin(x) and cos(x).
function sin3x(const T &, const T &) Returns sin(3x) from already computed sin(x) and cos(x).
function sinc(const T1 &) Returns the (normalized) sinc function of x.
function sinc(E1 &&) Creates an expression that returns the sinc function of x.
function sin(const T1 &) Returns the trigonometric sine of x, evaluated in radians.
function sincos(const T1 &) Returns the trigonometric sine of the even elements of x and cosine of the odd elements.
function sincosdeg(const T1 &) Returns the trigonometric sine of the even elements and cosine of the odd elements of x, where x is a vector of angles expressed in degrees.
function sincosdeg(E1 &&) Creates an expression that returns the trigonometric sine of the even elements of x and cosine of the odd elements. x must be expressed in degrees.
function sincos(E1 &&) Creates an expression that returns the trigonometric sine of the even elements of x and cosine of the odd elements. x must be a vector.
function sindeg(const T1 &) Returns the trigonometric sine of the angle expressed in degrees.
function sindeg(E1 &&) Creates an expression that returns the trigonometric sine of x (expressed in degrees).
function sin(E1 &&) Creates an expression that returns the trigonometric sine of x.
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 sinh(const T1 &) Returns the hyperbolic sine of x.
function sinhcosh(const T1 &) Computes sinh and cosh of x in a single pass and interleaves the results.
function sinhcosh(E1 &&) Creates an expression that returns the hyperbolic sine of the even elements of x and the hyperbolic cosine of the odd elements of x.
function sinh(E1 &&) Creates an expression that returns the hyperbolic sine of x.
function sink(E &&) Reads the expression expr through the whole range.
function compiletime::sin(T) Compile-time sine, accurate to better than 1e-4.
function cvals_t<T, values>::size() Number of values in the list
function cvals_t<T>::size() Number of values (always 0)
function ctypes_t<Ts>::size() Number of types in the list
function vec_shape<T, N>::size() Number of elements in the vector.
function cstring<N>::size()
function portable_vec<T, N>::size()
function vec<T, N>::size()
function shape<0>::size() Returns the number of elements (always 0).
variable expression_slice<Arg>::size
variable expression_linspace<T, truncated>::size
function array_ref<T>::size()
function spsc_ring_buffer<T>::size() Returns an approximate number of elements currently available for dequeue.
function inline_vector<T, N>::size() Returns the number of elements currently stored.
function tensor<T, NDims>::size() Returns the total number of elements in the tensor.
function histogram_data<Bins, TCount>::size() Returns the number of bins.
function small_buffer<T, Capacity>::size()
variable dft_plan<T>::size The size of the DFT as passed to the constructor.
variable dft_plan_real<T>::size Number of real samples in the transform.
variable dft_plan_md<T, Dims>::size Per-dimension sizes of the transform.
variable dft_plan_md_real<T, Dims>::size Per-dimension sizes of the real transform.
function expression_window<T>::size()
function abstract_stream<T>::size()
function memory_reader<T>::size()
function memory_writer<T>::size()
function reader_adapter<From, To>::size()
function writer_adapter<From, To>::size()
variable strided_channel<T>::size Number of samples in the channel.
variable audio_data<IsInterleaved>::size Number of samples per channel.
variable expression_concatenate<Arg1, Arg2, ConcatAxis>::size1
function size_add(size_t, size_t) Saturating addition for shape sizes.
variable univector<T, Size>::size_known True: the size is known at compile time.
variable univector<T, tag_array_ref>::size_known False: the size is not known at compile time.
variable univector<T, tag_dynamic_vector>::size_known False: the size is not known at compile time.
function size_min(size_t) Returns the minimum of a single value.
function size_min(size_t, size_t, Ts...) Returns the minimum of two or more values (recursively).
function size_of() Size of a (possibly compound) type measured in bytes of its deepest scalar.
function size_of_shape(const shape<dims> &) Total number of elements described by a shape.
function size_sub(size_t, size_t) Saturating subtraction for shape sizes.
typedef cstring<N>::size_type
typedef array_ref<T>::size_type
typedef data_allocator<T>::size_type
typedef univector<T, Size>::size_type
typedef univector<T, tag_array_ref>::size_type
typedef univector<T, tag_dynamic_vector>::size_type
typedef inline_vector<T, N>::size_type
typedef tensor<T, NDims>::size_type
function samplerate_converter<T>::skip(size_t, univector_ref<const T>) Skips a specified number of output samples, updating internal state.
enum constant speaker_type::Sl Side left.
function audio_data<IsInterleaved>::slice_past_end(size_t) Creates a new audio_data object representing a slice of audio data starting past the end of the current data.
function slice(Arg &&, std::type_identity_t<shape<Dims>>, std::type_identity_t<shape<Dims>>) Creates an expression that exposes a sub-region of another expression.
function slice(const vec<T, N> &) Extracts a contiguous subvector of count elements starting at start.
function slice(const vec<T, N> &, const vec<T, N> &) Extracts a contiguous subvector spanning the concatenation of x and y.
function cstring<N>::slice(csize_t<start>)
function cstring<N>::slice(csize_t<start>, csize_t<count>)
function univector_base<T, Class, true>::slice(size_t, size_t) Returns subrange of the vector. If start is greater or equal to this->size, returns empty univector If requested size is greater than this->size, returns only available elements
function univector_base<T, Class, true>::slice(size_t, size_t) Returns subrange of the vector. If start is greater or equal to this->size, returns empty univector If requested size is greater than this->size, returns only available elements
function audio_data<IsInterleaved>::slice(size_t, size_t) Creates a slice of the audio data starting at a specified position and with a specified length.
class small_buffer<T, Capacity> A dynamically-sized buffer with a small-size optimization.
constructor small_buffer<T, Capacity>::small_buffer<T, Capacity>() Constructs an empty buffer pointing at the inline storage.
destructor small_buffer<T, Capacity>::~small_buffer<T, Capacity>() Destructor; releases any heap allocation.
constructor small_buffer<T, Capacity>::small_buffer<T, Capacity>(const small_buffer<T, Capacity> &) Copy-constructs from other.
constructor small_buffer<T, Capacity>::small_buffer<T, Capacity>(small_buffer<T, Capacity> &&) Move-constructs from other, leaving other in an empty state.
constructor small_buffer<T, Capacity>::small_buffer<T, Capacity>(std::size_t) Constructs a buffer with size default-initialized elements.
variable vec<T, N>::SN Total scalar count.
function snprintfmt(char *, size_t, const std::string &, const Args &...) Write to a buffer using a {}"-based format string.
function sort(const vec<T, N> &) Sort the elements in the vector in ascending order
function sortdesc(const vec<T, N> &) Sort the elements in the vector in descending order
typedef Speaker
enum speaker_arrangement Predefined speaker arrangements.
enum speaker_type Speaker types (channel positions).
typedef SpeakerArrangement
variable audiofile_format::speakers Speaker arrangement.
enum special_constant Enumeration of special numeric values selectable through special_value .
class special_constants<T> Provides special constants for the scalar subtype of T.
class special_scalar_constants<bit<T>> Special scalar constants for bit<T> .
struct special_scalar_constants<double> Provides special bit-pattern constants for double .
struct special_scalar_constants<float> Provides special bit-pattern constants for float .
class special_scalar_constants<T> Provides special bit-pattern constants for a scalar type.
struct special_value Type-erased constant convertible to any numeric type T . Holds either a special_constant tag, an integer literal, or a floating-point literal, and converts to T according to the active variant.
constructor special_value::special_value(const special_value &)
constructor special_value::special_value(double) Constructs from a double literal
constructor special_value::special_value(int) Constructs from an int literal
constructor special_value::special_value(long long) Constructs from a long long literal
constructor special_value::special_value(special_constant) Constructs from a special_constant tag
function split(const vec<T, N> &) Terminal overload of split() for variadic recursion.
function split(const vec<T, N> &, vec<T, N / 2> &, vec<T, N / 2> &) Splits x into two equal halves.
function split(const vec<T, N> &, vec<T, N / 4> &, vec<T, N / 4> &, vec<T, N / 4> &, vec<T, N / 4> &) Splits x into four equal quarters.
function split(const vec<T, N> &, vec<T, Nout> &, Args &&...) Splits x into consecutive subvectors written into the supplied output references.
function splitpairs(const vec<T, N> &) Deinterleaves adjacent pairs (inverse of interleavehalves with side1 == 2).
class spsc_ring_buffer<T> Single-producer/single-consumer queue backed by an external univector .
constructor spsc_ring_buffer<T>::spsc_ring_buffer<T>() Constructs an empty queue with front and tail set to 0.
variable scalar_constants<T>::sqr_pi The square of π (pi²).
function sqr(const T1 &) Returns square of x.
function sqrdiff(const T1 &, const T2 &) Returns square of the difference of two arguments.
function sqr(E1 &&) Creates an expression that returns the square of x.
function sqrsum(const T1 &, const Ts &...) Square of the sum of all arguments.
variable scalar_constants<T>::sqrt_2 The square root of 2 (√2).
function sqrt(const T1 &) Returns the positive square root of x. \(\sqrt{x}\)
function sqrt(E1 &&) Creates an expression that returns the positive square root of x. \(\sqrt{x}\)
function square(const T1 &) Square wave of a phase in radians.
function square(E1 &&) Expression overload of square ; applies element-wise to an expression.
function squarenorm(const T1 &) Square wave of a phase ramp in [0, 1) cycles (alias of rawsquare ).
function squarenorm(E1 &&) Expression overload of squarenorm ; applies element-wise to an expression.
enum constant speaker_type::Sr Side right.
variable tensor<T, NDims>::tensor_iterator::src
variable tensor<T, NDims>::nested_iterator_t::src
enum constant cpu_t::sse2
enum constant cpu_t::sse3
enum constant cpu_t::sse41
enum constant cpu_t::sse42
enum constant cpu_t::ssse3
typedef vec<T, N>::ST
typedef generator_expj<T, VecWidth>::ST
typedef convolve_filter<T>::ST
function dft_resampler_params::stage_factor() Returns the per-stage conversion ratio (>1 for upsampling, <1 for downsampling).
variable dft_stage<T>::stage_size Number of complex elements processed by this stage.
variable dft_plan<T>::stages Internal data.
variable tensor_range::start Start of the range (inclusive). std::nullopt means "from the beginning" (or "to the end" for negative steps).
variable expression_counter<T, Dims>::start
variable expression_slice<Arg>::start
variable expression_linspace<T, truncated>::start
function ebu_r128<T>::start() (Re)start measurement: subsequent packets update the buffers.
variable stopwatch::start_time Tick count captured at construction.
function audio_data<IsInterleaved>::stat() Retrieves the statistical information of the audio data.
variable expression_random_uniform<T, Dims, Reference>::state
variable expression_random_range<T, Dims, Reference>::state
variable expression_random_normal<T, Dims, Reference>::state
variable iir_state<T, filters>::state Active delay-line state.
variable expression_iir_l<filters, T, E1, Stateless>::state
variable expression_iir<filters, T, E1, Stateless>::state
variable expression_short_fir<tapcount, T, U, E1, stateless>::state
variable expression_fir<T, U, E1, stateless>::state
variable expression_moving_sum<U, E1, STag, stateless>::state
variable fir_filter<T, U>::state
variable expression_delay<delay, E, stateless, STag>::state
variable expression_delay<1, E, stateless, STag>::state
class state_holder<T, false> Owning specialization of state_holder .
constructor state_holder<T, false>::state_holder<T, false>()
constructor state_holder<T, false>::state_holder<T, false>(const state_holder<T, false> &)
constructor state_holder<T, false>::state_holder<T, false>(state_holder<T, false> &&)
constructor state_holder<T, false>::state_holder<T, false>(state_holder<T, true>) Converts a stateless holder into an owning one by copying the referenced state.
constructor state_holder<T, false>::state_holder<T, false>(std::reference_wrapper<const T>)
constructor state_holder<T, false>::state_holder<T, false>(std::reference_wrapper<T>)
constructor state_holder<T, false>::state_holder<T, false>(T) Constructs the holder by moving in a state value.
class state_holder<T, Stateless> Holds a state value, either by ownership or by reference, depending on the Stateless template parameter.
class state_holder<T, true> Stateless (non-owning) specialization of state_holder .
constructor state_holder<T, true>::state_holder<T, true>()
constructor state_holder<T, true>::state_holder<T, true>(const state_holder<T, true> &)
constructor state_holder<T, true>::state_holder<T, true>(const T &)
constructor state_holder<T, true>::state_holder<T, true>(state_holder<T, true> &&)
constructor state_holder<T, true>::state_holder<T, true>(std::reference_wrapper<T>) Constructs the holder from a reference wrapper, storing a pointer to the referenced object.
constructor state_holder<T, true>::state_holder<T, true>(T)
constructor state_holder<T, true>::state_holder<T, true>(T &)
constructor state_holder<T, true>::state_holder<T, true>(T &&)
class static_assert_eq<T, left, right>
class static_assert_type_eq<Left, Right>
function expression_vtable<T, Dims>::static_begin_pass(void *, shape<Dims>, shape<Dims>) begin_pass trampoline: forwards to begin_pass for Expression.
function expression_vtable<T, Dims>::static_end_pass(void *, shape<Dims>, shape<Dims>) end_pass trampoline: forwards to end_pass for Expression.
function expression_vtable<T, Dims>::static_get_elements(void *, shape<Dims>, T *) get_elements trampoline: forwards to get_elements for Expression.
function expression_vtable<T, Dims>::static_reset(void *) reset trampoline: forwards to reset for Expression.
function expression_vtable<T, Dims>::static_set_elements(void *, shape<Dims>, const T *) set_elements trampoline: forwards to set_elements for Expression.
function expression_vtable<T, Dims>::static_shapeof(void *, shape<Dims> &) shapeof trampoline: queries expression_traits::get_shape for Expression.
variable shape<0>::static_size Compile-time size of the shape, always zero.
variable univector<T, Size>::static_size Compile-time size of the vector.
function expression_vtable<T, Dims>::static_substitute(void *, expression_handle<T, Dims>) substitute trampoline: invokes kfr::substitute on Expression.
namespace ::std
function stddev(const E1 &) Computes the standard deviation of the given expression.
function steady_time() Returns the current time in nanoseconds since epoch using steady_clock.
variable tensor_range::step Step between elements. Defaults to 1. May be negative for a reverse iteration.
variable generator_exp<T, VecWidth>::step
variable generator_expj<T, VecWidth>::step
variable generator_exp2<T, VecWidth>::step
variable generator_cossin<T, VecWidth>::step
variable generator_sin<T, VecWidth>::step
variable range<T>::iterator::step
variable range<T>::step
variable expression_counter<T, Dims>::steps
enum constant speaker_arrangement::Stereo L, R.
struct stereo_matrix 2x2 mixing matrix functor for stereo channel transformations.
enum constant speaker_arrangement::StereoCenter Lc, Rc.
enum constant speaker_arrangement::StereoCLfe C, Lfe.
enum constant speaker_arrangement::StereoSide Sl, Sr.
enum constant speaker_arrangement::StereoSurround Ls, Rs.
variable tensor_range::stop End of the range (exclusive). std::nullopt means "to the end" (or "from the beginning" for negative steps).
variable expression_linspace<T, truncated>::stop
function ebu_r128<T>::stop() Pause measurement: packets are still filtered but buffers are frozen.
function stop_constexpr() Non-constexpr function used to halt constant evaluation in
variable dft_resampler_params::stopband_atten_db Desired stopband attenuation in dB (e.g. 144). Controls Kaiser beta.
struct stopwatch RAII-style stopwatch measuring wall-clock elapsed time via clock_now .
constructor stopwatch::stopwatch()
typedef inline_vector<T, N>::stored_size_type Smallest unsigned integer able to hold values up to
function str_find(const cstring<N1> &, const cstring<Nneedle> &)
function str_replace(const cstring<N1> &, const cstring<Nfrom> &, const cstring<Nto> &)
variable stride_pointer<const T, groupsize>::stride Offset (in groups) between consecutive groups.
variable strided_channel<T>::stride Stride (in elements) between successive samples.
class stride_pointer<const T, groupsize> Read-only strided pointer: a pointer paired with a stride that supports grouped gather reads.
class stride_pointer<T, groupsize> Mutable strided pointer: a pointer paired with a stride that supports grouped scatter writes.
constructor stride_pointer<T, groupsize>::stride_pointer<T, groupsize>(T *, size_t)
class strided_channel<T> Represents a strided audio channel.
function tensor<T, NDims>::strides() Returns the strides of the tensor.
class struct_with_alignment<T, A> Wrapper exposing a member of type T with the requested alignment.
class struct_with_alignment<T, false> Packed, unaligned specialization of struct_with_alignment.
function shape<Dims>::sub_shape_undef(const shape<dims> &, const shape<dims> &) Variant of sub_shape that also propagates undefined_size .
function shape<Dims>::sub_shape(const shape<dims> &, const shape<dims> &) Subtract one shape from another, treating infinite_size as infinite.
function subadd(const vec<T, N> &, const vec<T, N> &) Returns a vector with a-b in the low half and a+b in the high half.
function shape<Dims>::sub(const shape<dims> &) Element-wise subtraction of two shapes.
function sub(const T1 &, const T2 &) Subtraction of two values.
function sub(E1 &&, E2 &&) Creates an expression that returns the difference between x and y.
function sub(initialvalue<T>) Identity element for sub (returns zero).
typedef cvals_t<T, values>::subscript
class cvals_t<T, values>::subscript_t<cvals_t<size_t, indices...>>
class cvals_t<T, values>::subscript_t
function substitute(const internal_generic::anything &, Args &&...) Fallback substitute that accepts any expression and arguments and does nothing.
function expression_handle<T, Dims>::substitute(expression_handle<T, Dims>) Replace the placeholder inside the referenced expression with new_handle.
function substitute(expression_handle<T, Dims> &, expression_handle<T, Dims>, csize_t<Key>) Substitute the placeholder inside the expression referenced by expr.
function substitute(expression_placeholder<T, Dims, Key> &, expression_handle<T, Dims>, csize_t<Key>) Bind a placeholder to a concrete expression handle.
function substitute(expression_with_arguments<Args...> &, expression_handle<T, Dims>, csize_t<Key>) Recursively substitute a placeholder inside a composite expression.
typedef compound_type_traits<T>::subtype
typedef subtype The immediate subtype of a compound type
typedef compound_type_traits<std::pair<T, T>>::subtype
typedef typebits<T>::subtype
typedef compound_type_traits<kfr::vec_shape<T, N>>::subtype
typedef compound_type_traits<kfr::vec<T, N>>::subtype
typedef compound_type_traits<std::complex<T>>::subtype Scalar component type of the complex value.
function shape<Dims>::sum() Sum of every axis size.
function sum(const E1 &) Returns the sum of all the elements in x.
function sumsqr(const E1 &) Returns the sum of squares of all the elements in x.
variable vec<T, N>::SW
struct swallow Utility class to use in list-initialization context Accepts any number of arguments and discards them; useful for pack expansion side effects.
function swallow::swallow(T &&...) Constructs from any arguments, discarding them
function audio_data<IsInterleaved>::swap(audio_data<IsInterleaved> &) Exchanges the contents of this buffer with other.
function audio_data<IsInterleaved>::swap(audio_data<IsInterleaved> &, audio_data<IsInterleaved> &) Swaps two audio_data buffers.
function swapbyteorder(const T &) Swap byte order of x .
function swap(const vec<T, N> &) Swaps adjacent groups of elements lanes.
function file_handle::swap(file_handle &)
function small_buffer<T, Capacity>::swap(small_buffer<T, Capacity> &, small_buffer<T, Capacity> &) Swaps the contents of two buffers.
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.
variable wave_encoding_options::switch_to_rf64_if_over_4gb
enum constant window_symmetry::symmetric
variable symmetric_linspace
struct symmetric_linspace_t Tag type used to select the symmetric-linspace constructor of expression_linspace .
function symmlinspace(T, size_t, cbool_t<truncated>) Creates an expression that returns evenly spaced numbers over a symmetric interval.
function generator_linear<T, VecWidth>::sync(T) Reinitializes the generator so the next vector starts at start.
function generator_exp<T, VecWidth>::sync(T) Reinitializes the generator so the next vector starts at start.
function generator_expj<T, VecWidth>::sync(T) Reinitializes the generator so the next vector starts at phase start.
function generator_exp2<T, VecWidth>::sync(T) Reinitializes the generator so the next vector starts at start.
function generator_cossin<T, VecWidth>::sync(T) Reinitializes the generator so the next vector starts at phase start.
function generator_sin<T, VecWidth>::sync(T) Reinitializes the generator so the next vector starts at phase start.

T¶

typedef expression_delay<delay, E, stateless, STag>::T
typedef expression_delay<1, E, stateless, STag>::T
enum constant (Unnamed enum at base/univector.hpp:42:1)::tag_array_ref Tag for a non-owning reference to external data.
enum constant (Unnamed enum at base/univector.hpp:42:1)::tag_dynamic_vector Tag for a dynamically sized, owning vector.
variable moving_sum_state<U, Tag>::tail_cursor Read cursor (oldest sample).
variable moving_sum_state<U, tag_dynamic_vector>::tail_cursor Read cursor (oldest sample).
function tall() Build a range that spans the entire axis (defaults for all three components).
function tan(const T1 &) Computes the tangent of the input (in radians).
function tandeg(const T1 &) Computes the tangent of the input (in degrees).
function tandeg(E1 &&) Creates an expression that returns the trigonometric tangent of x (expressed in degrees).
function tan(E1 &&) Creates an expression that returns the trigonometric tangent of x.
function tanh(const T1 &) Returns the hyperbolic tangent of x.
function tanh(E1 &&) Creates an expression that returns the hyperbolic tangent of x.
variable short_fir_state<tapcount, T, U>::taps Filter coefficients (zero-padded).
variable fir_params<T>::taps Filter coefficients (reversed order).
variable samplerate_converter<T>::taps Number of filter taps.
function abstract_stream<T>::tell()
function memory_reader<T>::tell()
function memory_writer<T>::tell()
function reader_adapter<From, To>::tell()
function writer_adapter<From, To>::tell()
function file_reader<T>::tell()
function file_writer<T>::tell()
function audio_writer_wav<T>::tell()
function audio_reader_wav<T>::tell() Returns current position
function audio_reader_flac<T>::tell() Returns current position
function audio_reader_mp3<T>::tell() Returns current position
variable convolve_filter<T>::temp
variable dft_stage<T>::temp_size Size in bytes of scratch buffer required by this stage.
variable dft_plan<T>::temp_size The temporary (scratch) buffer size for the DFT plan.
variable dft_plan_md<T, Dims>::temp_size Scratch buffer size in bytes required by
variable dft_plan_md_real<T, Dims>::temp_size Scratch buffer size in bytes required by
function tensor_from_container(Container) Creates a 1D tensor referencing the data of a container. The container is moved into a memory finalizer so the data remains valid for the tensor's lifetime.
struct tensor<T, NDims>::tensor_iterator Tensor iterator. Iterates through the flattened array in row-major order.
struct tensor_range Half-open or one-ended range descriptor for tensor slicing.
class tensor_subscript<T, Derived, Dims> Base for the subscript operator helper of tensor.
class tensor_subscript<T, Derived, std::integer_sequence<index_t, Dims...>> Specialization of tensor_subscript for an explicit integer sequence of dimensions.
class tensor<T, dynamic_shape> Specialization of tensor for a dynamic shape. Not implemented yet.
class tensor<T, NDims> Holds or references multidimensional data and provides access to individual elements and complex operations on the data.
constructor tensor<T, NDims>::tensor<T, NDims>() Default constructor. Creates a tensor with a null shape.
constructor tensor<T, NDims>::tensor<T, NDims>(const shape_type &) Constructs a tensor with the given shape and allocates memory for it.
constructor tensor<T, NDims>::tensor<T, NDims>(const shape_type &, const shape_type &) Constructs a tensor with the given shape and a packed stride layout.
constructor tensor<T, NDims>::tensor<T, NDims>(const shape_type &, const shape_type &, std::initializer_list<T>) Constructs a tensor with the given shape and strides and fills it from a flat initializer list.
constructor tensor<T, NDims>::tensor<T, NDims>(const shape_type &, const shape_type &, T) Constructs a tensor with the given shape and strides, allocates memory, and fills it with value .
constructor tensor<T, NDims>::tensor<T, NDims>(const shape_type &, const std::initializer_list<T> &) Constructs a tensor with the given shape, allocates memory, and fills it from a flat initializer list.
constructor tensor<T, NDims>::tensor<T, NDims>(const shape_type &, T) Constructs a tensor with the given shape, allocates memory, and fills it with value.
function tensor<T, NDims>::tensor<T, NDims>(const std::initializer_list<std::initializer_list<std::initializer_list<std::initializer_list>>> &) Initializes a 4D tensor from a braced list. Defined for 4D tensors only.
function tensor<T, NDims>::tensor<T, NDims>(const std::initializer_list<std::initializer_list<std::initializer_list>> &) Initializes a 3D tensor from a braced list. Defined for 3D tensors only.
function tensor<T, NDims>::tensor<T, NDims>(const std::initializer_list<std::initializer_list> &) Initializes a 2D tensor from a braced list. Defined for 2D tensors only.
function tensor<T, NDims>::tensor<T, NDims>(const std::initializer_list &) Initializes a 1D tensor from a braced list. Defined for 1D tensors only.
constructor tensor<T, NDims>::tensor<T, NDims>(const tensor<T, NDims> &)
constructor tensor<T, NDims>::tensor<T, NDims>(const tensor<T, NDims> &&)
function tensor<T, NDims>::tensor<T, NDims>(Input &&) Constructs a tensor by evaluating an expression.
constructor tensor<T, NDims>::tensor<T, NDims>(T *, const shape_type &, const shape_type &, memory_finalizer) Constructs a tensor from an external pointer, shape, strides, and finalizer.
constructor tensor<T, NDims>::tensor<T, NDims>(T *, const shape_type &, memory_finalizer) Constructs a tensor from an external pointer, shape, and finalizer using default strides.
constructor tensor<T, NDims>::tensor<T, NDims>(tensor<T, NDims> &&)
constructor tensor<T, NDims>::tensor<T, NDims>(tensor<T, NDims> &)
variable test_vector_sizes Set of vector sizes used by the test harness.
enum constant speaker_type::Tfc Top front center.
enum constant speaker_type::Tfl Top front left.
enum constant speaker_type::Tfr Top front right.
class timestamps<max_count, fence> High-resolution scoped profiler using RDTSC (x86) or CNTVCT_EL0 (AArch64).
namespace ::tl
enum constant speaker_type::Tm Top middle.
function tensor<T, NDims>::to_array() Copies the tensor elements into a std::array.
function to_filter(E &&) Creates a filter from an expression containing a placeholder.
function to_filter(expression_handle<T, 1> &&) Creates a filter from an expression handle containing a placeholder.
function shape<0>::to_flat(const shape<0> &) Flat offset for a scalar; the only valid offset is 0.
function shape<Dims>::to_flat(const shape<Dims> &) Convert multi-dimensional indices to a flat offset.
function to_handle(E &) Converts the given expression into an opaque handle.
function to_handle(E &&) Converts the given expression into an opaque handle.
function to_sos(const zpk &) Converts a zero-pole-gain filter to second-order sections (SOS) form.
function shape<Dims>::to_std_array() Convert the shape to a std::array.
function to_string(audiofile_error) Converts an audiofile_error to its string representation.
function tensor<T, NDims>::to_string(int, int, std::string, std::string, std::string) Returns a string representation of the tensor.
function to_vec(const portable_vec<T, N> &) Convert a portable_vec to the native vec type.
function to_vec(const shape<Dims> &) Converts a shape to a vector of unsigned integers.
function to_vec(const std::array<T, N> &) Converts a std::array of N elements to a vector.
function shape<Dims>::tomask() Build a dimset mask with bits set for non-collapsed axes.
function shape<0>::tomask() Build a dimset with all bits set.
enum constant audiofile_error::too_large data chunk too large for standard WAV
function histogram_data<Bins, TCount>::total() Returns the total number of values added to the histogram.
variable audiofile_format::total_frames
function audio_data<IsInterleaved>::total_samples() Calculates the total number of audio samples.
function tprocess_body(Out &&, In &&, size_t, size_t, size_t, shape<outdims>, shape<indims>) Core loop body that copies a vectorized slice from in to out.
function trace(E1 &&) Creates an expression that prints the requested values to the console for debugging purposes.
function shape<Dims>::trailing_zeros() Number of trailing axes of size 1, counting from the back.
function shape<0>::trailing_zeros() A scalar shape has no trailing collapsed axes.
function trange(std::optional<signed_index_t>, std::optional<signed_index_t>, std::optional<signed_index_t>) Build a tensor_range from explicit start/stop/step values.
variable expression_reduce<Tout, Dims, Twork, Tin, ReduceFn, TransformFn, FinalFn>::transformfn
variable dft_resampler_params::transition_width Transition bandwidth normalised to the lower-rate Nyquist (0..1].
function samplerate_converter<T>::transition_width() Calculates the transition width based on sidelobe attenuation and depth.
function samplerate_converter<T>::transition_width(sample_rate_conversion_quality) Returns the transition width for a given quality level.
function shape<Dims>::transpose() Reverse the order of the axes.
function tensor<T, NDims>::transpose() Returns a tensor with the order of axes reversed. For 0D and 1D tensors returns *this.
function transpose(const vec<T, N> &) Transposes a vector viewed as a side1 x side2 matrix (row-major).
function transpose(const vec<T, N> &) Identity overload of transpose() for small vectors (size <= 3).
function transpose(const vec<vec<T, N>, N> &) Transposes a vector of vectors (matrix of vectors).
function transposeinverse(const vec<T, N> &) Inverse transpose of a vector viewed as a side1 x side2 matrix (row-major).
function transposeinverse(const vec<T, N> &) Identity overload of transposeinverse() for small vectors (size <= 3).
enum constant speaker_type::Trc Top rear center.
function trender(const E &) Evaluates an expression and returns the result as a tensor.
function trender(const E &, shape<Traits::dims>) Evaluates an expression up to size and returns the result as a tensor.
function triangle(const T1 &) Triangle wave of a phase in radians.
function triangle(E1 &&) Expression overload of triangle ; applies element-wise to an expression.
function trianglenorm(const T1 &) Triangle wave of a phase ramp in [0, 1) cycles (alias of rawtriangle ).
function trianglenorm(E1 &&) Expression overload of trianglenorm ; applies element-wise to an expression.
enum constant window_type::triangular
enum constant audio_dithering::triangular
function shape<Dims>::trim() Reduce the shape to a lower rank by dropping leading axes.
function shape<0>::trim() Reduce the scalar shape to a smaller rank.
enum constant speaker_type::Trl Top rear left.
enum constant speaker_type::Trr Top rear right.
function shape<Dims>::trunc() Drop the last axis. Synonym for remove_back .
function truncate(Arg &&, std::type_identity_t<shape<Dims>>) Creates an expression that exposes arg starting at the origin with the given size.
function univector_base<T, Class, true>::truncate(size_t) Returns subrange of the vector starting from 0. If requested size is greater than this->size, returns only available elements
function univector_base<T, Class, true>::truncate(size_t) Returns subrange of the vector starting from 0. If requested size is greater than this->size, returns only available elements
function audio_data<IsInterleaved>::truncate(size_t) Truncates the audio data to the specified length.
function trunc(const T1 &) Returns the integer part of x by removing its fractional part.
function trunc(E1 &&) Creates an expression that returns the integer part of x by removing its fractional part.
function compiletime::trunc(T) Compile-time truncation toward zero.
function spsc_ring_buffer<T>::try_dequeue(T *, size_t, const univector<T, Tag> &, bool) Attempts to dequeue size elements from buffer into dest.
function spsc_ring_buffer<T>::try_enqueue(const T *, size_t, univector<T, Tag> &, bool) Attempts to enqueue size elements from source into buffer.
function tstart(signed_index_t, signed_index_t) Build a range that starts at start and continues to the end of the axis.
function tstep(signed_index_t) Build a range that uses the specified step but no explicit start or stop.
function tstop(signed_index_t, signed_index_t) Build a range that stops at stop.
typedef special_constants<T>::Tsub The scalar subtype used to provide the constants.
typedef constants<T>::Tsub
enum constant window_type::tukey
class ::std::tuple_element<I, kfr::vec<T, N>>
class ::std::tuple_size<kfr::vec<T, N>>
variable ngfft_plan<T>::twiddles User-allocated pointer to twiddle factors. The required element count is obtained from ngfft_twiddle_count(); the buffer must be cache-line aligned. Initialise via ngfft_initialize() before first use.
typedef cval_t<T, val>::type
typedef cvals_t<T, values>::type
typedef cvals_t<T, values>::subscript_t<cvals_t<size_t, indices...>>::type
typedef cvals_t<T>::type
typedef ctype_t<T>::type The wrapped type
typedef map_indices_impl<size, Fn>::type
typedef construct_common_type<CT, Tpl>::type
typedef vector_types_for_size_t_impl<vec_tpl, T, csizes_t<sizes...>>::type
typedef bitmask<bits>::type The unsigned integer type selected for the requested width.
typedef representation<T>::type
typedef representation<named_arg<T>>::type
typedef representation<std::pair<T1, T2>>::type
typedef representation<std::unique_ptr<T1>>::type
typedef representation<std::weak_ptr<T1>>::type
typedef representation<std::shared_ptr<T1>>::type
typedef representation<std::shared_ptr<void>>::type
typedef representation<std::array<T, Size>>::type
typedef representation<std::vector<T, Allocator>>::type
typedef representation<std::string_view>::type
typedef native_vector_type<T>::type
typedef vec_template<N>::type
typedef vecvec_template<N1, N2>::type
typedef vec_vec_template<N1, N2>::type
typedef representation<kfr::generic::vec<T, N>>::type
typedef representation<fmt_t<kfr::generic::vec<T, N>, t, width, prec>>::type
typedef representation<kfr::generic::mask<T, N>>::type
typedef ::std::tuple_element<I, kfr::vec<T, N>>::type
typedef representation<kfr::complex<T>>::type Result type of the conversion.
typedef representation<fmt_t<kfr::complex<T>, t, width, prec>>::type Result type of the conversion.
typedef vec_of_complex<N>::type The complex vector type for component type
typedef representation<kfr::shape<dims>>::type
typedef representation<kfr::univector<T, Tag>>::type
typedef representation<fmt_t<kfr::univector<T, Tag>, t, width, prec>>::type
typedef audio_sample_get_type<audio_sample_type::i16>::type Native C++ type corresponding to audio_sample_type::i16 .
typedef audio_sample_get_type<audio_sample_type::i24>::type Native C++ type corresponding to audio_sample_type::i24 .
typedef audio_sample_get_type<audio_sample_type::i32>::type Native C++ type corresponding to audio_sample_type::i32 .
typedef audio_sample_get_type<audio_sample_type::f32>::type Native C++ type corresponding to audio_sample_type::f32 .
typedef audio_sample_get_type<audio_sample_type::f64>::type Native C++ type corresponding to audio_sample_type::f64 .
variable audio_sample_traits<i16>::type Matching audio_sample_type enumerator.
variable audio_sample_traits<i24>::type Matching audio_sample_type enumerator.
variable audio_sample_traits<i32>::type Matching audio_sample_type enumerator.
variable audio_sample_traits<f32>::type Matching audio_sample_type enumerator.
variable audio_sample_traits<f64>::type Matching audio_sample_type enumerator.
typedef expand_cvals<T, Tpl, cvals_t<T, vals...>>::type
typedef representation<kfr::fraction>::type
typedef representation<kfr::tensor<T, dims>>::type
typedef representation<fmt_t<kfr::tensor<T, dims>, t, width, prec>>::type
typedef representation<kfr::npy_decode_result>::type
typedef window_by_type<window_type::rectangular>::type
typedef window_by_type<window_type::triangular>::type
typedef window_by_type<window_type::bartlett>::type
typedef window_by_type<window_type::cosine>::type
typedef window_by_type<window_type::hann>::type
typedef window_by_type<window_type::bartlett_hann>::type
typedef window_by_type<window_type::hamming>::type
typedef window_by_type<window_type::bohman>::type
typedef window_by_type<window_type::blackman>::type
typedef window_by_type<window_type::blackman_harris>::type
typedef window_by_type<window_type::kaiser>::type
typedef window_by_type<window_type::flattop>::type
typedef window_by_type<window_type::gaussian>::type
typedef window_by_type<window_type::lanczos>::type
typedef window_by_type<window_type::cosine_np>::type
typedef window_by_type<window_type::planck_taper>::type
typedef window_by_type<window_type::tukey>::type
variable audio_format::type
typedef representation<kfr::special_value>::type
typedef representation<kfr::cpu_t>::type
struct type_id_t
constructor type_id_t::type_id_t(const void *)
typedef expression_with_arguments<Args>::type_list
typedef expression_with_arguments<Arg>::type_list
function type_name() Gets the fully qualified name of the type, including namespace and template parameters (if any)
function type_name(T) Gets the fully qualified name of the type, including namespace and template parameters (if any)
typedef type_of Extracts the wrapped type from a ctype_t-like wrapper
enum constant datatype::typebits_mask
class typebits<T>
variable typeclass
enum constant datatype::typeclass_mask
function typeindex() Returns the zero-based index of type

U¶

enum constant datatype::u
typedef u16
enum constant datatype::u16
typedef u16x1
typedef u16x16
typedef u16x2
typedef u16x2x2
typedef u16x3
typedef u16x32
typedef u16x4
typedef u16x4x4
typedef u16x64
typedef u16x8
enum constant datatype::u24
struct u24 Unsigned 24-bit integer stored in three bytes (little-endian).
typedef u32
enum constant datatype::u32
typedef u32x1
typedef u32x16
typedef u32x2
typedef u32x2x2
typedef u32x3
typedef u32x32
typedef u32x4
typedef u32x4x4
typedef u32x64
typedef u32x8
typedef u64
enum constant datatype::u64
typedef u64x1
typedef u64x16
typedef u64x2
typedef u64x2x2
typedef u64x3
typedef u64x32
typedef u64x4
typedef u64x4x4
typedef u64x64
typedef u64x8
typedef u8
enum constant datatype::u8
typedef u8x1
typedef u8x16
typedef u8x2
typedef u8x2x2
typedef u8x3
typedef u8x32
typedef u8x4
typedef u8x4x4
typedef u8x64
typedef u8x8
concept u_class
function ubitcast(const From &) Reinterpret the bits of a scalar value as its unsigned counterpart type.
function ubitcast(const vec<From, N> &) Reinterpret the bits of a vector as a vector of its unsigned counterpart type.
typedef opencl_names::uchar16
typedef opencl_names::uchar2
typedef opencl_names::uchar3
typedef opencl_names::uchar4
typedef opencl_names::uchar8
function uibitcast(const From &) Reinterpret the bits of a scalar value as its unsigned-or-signed counterpart type.
function uibitcast(const vec<From, N> &) Reinterpret the bits of a vector as a vector of its unsigned-or-signed counterpart type.
typedef opencl_names::uint16
typedef opencl_names::uint2
typedef opencl_names::uint3
typedef opencl_names::uint4
typedef opencl_names::uint8
typedef uitype
typedef opencl_names::ulong16
typedef opencl_names::ulong2
typedef opencl_names::ulong3
typedef opencl_names::ulong4
typedef opencl_names::ulong8
typedef umax
function tensor<T, NDims>::unary_inplace(Fn &&) Applies fn to each element in place.
function tensor<T, NDims>::unary(Fn &&) Applies a unary function to each element and returns the resulting tensor.
variable undefined_size Sentinel value denoting a dimension whose size is not yet known.
function undefinedvector() Return an uninitialized vector of the given type and size.
function undefinedvector(vec_shape<T, N>) Return an uninitialized vector matching the given shape.
function unitimpulse() Returns expression template that generates a unit impulse
typedef univector2d Alias for a 2D container of univectors.
typedef univector3d Alias for a 3D container of univectors.
class univector_base<T, Class, false> Specialization for univectors that cannot be assigned from expressions. Provides only reference access to the underlying data.
class univector_base<T, Class, is_expression> Base class for all univector specializations, providing common operations such as slicing, references and ring-buffer helpers. Ring-buffer helpers operate on caller-owned cursors and are intended for single-threaded use only; concurrent access requires external synchronization.
class univector_base<T, Class, true> Specialization for univectors that can be assigned from expressions.
typedef univector_dyn Alias for univector<T, tag_dynamic_vector> ;
typedef univector_ref Alias for univector<T, tag_array_ref> ;
typedef univector_tag Tag type that selects the storage strategy of a univector or abstract_vector .
class univector<T, Size> Class that represent data in KFR. Many KFR functions can take this class as an argument. Can inherit from std::vector, std::array or keep only reference to data and its size.
constructor univector<T, Size>::univector<T, Size>()
function univector<T, Size>::univector<T, Size>(const T &, const Args &...) Constructs the vector from a brace-enclosed list of values.
constructor univector<T, Size>::univector<T, Size>(const univector<T, Size> &)
function univector<T, Size>::univector<T, Size>(Input &&) Constructs the vector and initializes it from an input expression.
constructor univector<T, Size>::univector<T, Size>(size_t, const T &) Constructs the vector with Size copies of value.
constructor univector<T, Size>::univector<T, Size>(univector<T, Size> &)
constructor univector<T, Size>::univector<T, Size>(univector<T, Size> &&)
class univector<T, tag_array_ref> Non-owning univector specialization that holds a reference to external data.
constructor univector<T, tag_array_ref>::univector<T, tag_array_ref>(array_ref<T> &&)
constructor univector<T, tag_array_ref>::univector<T, tag_array_ref>(const array_ref<T> &)
function univector<T, tag_array_ref>::univector<T, tag_array_ref>(const univector<T, Tag> &) Constructs a reference from a const univector of any storage tag.
constructor univector<T, tag_array_ref>::univector<T, tag_array_ref>(const univector<T, tag_array_ref> &)
function univector<T, tag_array_ref>::univector<T, tag_array_ref>(const univector<U, Tag> &) Constructs a const reference from a const univector of a different element type. Only participates in overload resolution when T is const-qualified and the underlying element types match after removing const.
function univector<T, tag_array_ref>::univector<T, tag_array_ref>(univector<T, Tag> &) Constructs a reference from a mutable univector of any storage tag.
constructor univector<T, tag_array_ref>::univector<T, tag_array_ref>(univector<T, tag_array_ref> &)
constructor univector<T, tag_array_ref>::univector<T, tag_array_ref>(univector<T, tag_array_ref> &&)
function univector<T, tag_array_ref>::univector<T, tag_array_ref>(univector<U, Tag> &) Constructs a const reference from a mutable univector of a different element type.
function univector<T, tag_array_ref>::univector<T, tag_array_ref>(univector<U, Tag> &&) Constructs a const reference by taking a reference to the data of a temporary univector.
class univector<T, tag_dynamic_vector> Dynamically sized, owning univector backed by std::vector using KFR's data_allocator . Memory is aligned to the maximum vector alignment.
constructor univector<T, tag_dynamic_vector>::univector<T, tag_dynamic_vector>()
constructor univector<T, tag_dynamic_vector>::univector<T, tag_dynamic_vector>(const array_ref<const T> &) Constructs from a const array_ref by copying its elements.
constructor univector<T, tag_dynamic_vector>::univector<T, tag_dynamic_vector>(const array_ref<T> &) Constructs from a mutable array_ref by copying its elements.
function univector<T, tag_dynamic_vector>::univector<T, tag_dynamic_vector>(const std::vector<T, Allocator> &) Deleted overload to prevent construction from a std::vector with a foreign allocator.
constructor univector<T, tag_dynamic_vector>::univector<T, tag_dynamic_vector>(const std::vector<T, data_allocator<T>> &) Copy-constructs from a std::vector using the same allocator.
constructor univector<T, tag_dynamic_vector>::univector<T, tag_dynamic_vector>(const univector<T, tag_dynamic_vector> &)
function univector<T, tag_dynamic_vector>::univector<T, tag_dynamic_vector>(Input &&) Constructs the vector from an input expression, resizing to the expression's size. The expression must be finite and have at most one dimension.
function univector<T, tag_dynamic_vector>::univector<T, tag_dynamic_vector>(std::vector<T, Allocator> &&) Deleted overload to prevent construction from a std::vector with a foreign allocator.
constructor univector<T, tag_dynamic_vector>::univector<T, tag_dynamic_vector>(std::vector<T, data_allocator<T>> &&) Move-constructs from a std::vector using the same allocator.
constructor univector<T, tag_dynamic_vector>::univector<T, tag_dynamic_vector>(univector<T, tag_dynamic_vector> &)
constructor univector<T, tag_dynamic_vector>::univector<T, tag_dynamic_vector>(univector<T, tag_dynamic_vector> &&)
enum constant audio_sample_type::unknown
enum constant audiofile_container::unknown
enum constant audiofile_codec::unknown
enum constant audiofile_error::unknown An unknown error occurred
enum (Unnamed enum at base/univector.hpp:42:1) Compile-time tags selecting the storage strategy of a univector .
enum (Unnamed enum at capi.h:119:1) Supported architectures enumeration.
function unpack(E &&...) Creates an expression that fans out a vector input into several output expressions.
typedef unsigned_type Maps a bit width to the corresponding unsigned integer type
variable unsigned_types Type list of all unsigned integer element types.
variable unsigned_vector_types Instance of unsigned_vector_types_t for use as a value parameter pack.
typedef unsigned_vector_types_t Type list of unsigned-integer vector instantiations for the test sizes.
typedef unwrap_bit
function unwrap_bit_value(const bit<T> &) Overload unwrapping a bit<T> to its underlying mask value.
function unwrap_bit_value(const T &) Returns the underlying mask value of a bit, or the value itself for non-bit types.
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.
typedef vec<T, N>::uscalar_type
variable audio_format::use_w64
variable dft_stage<T>::user Stage-specific user value (e.g. log2 of the stage size).
typedef opencl_names::ushort16
typedef opencl_names::ushort2
typedef opencl_names::ushort3
typedef opencl_names::ushort4
typedef opencl_names::ushort8
typedef vec<T, N>::usimd_type
typedef usubtype
typedef utype
typedef vec<T, N>::uvalue_type
typedef glsl_names::uvec2
typedef glsl_names::uvec3
typedef glsl_names::uvec4

V¶

variable vec<T, N>::element::v Owning vector.
variable vec<T, N>::(Anonymous union at simd/vec.hpp:831:5)::v
variable random_state::v Internal 128-bit state stored as four 32-bit lanes.
variable vec_halves<T, 1>::val The single scalar value.
function val_of(cval_t<T, value>) Extracts the value from a cval_t constant
function val_of(T) Returns the value itself (overload for runtime values)
function audiofile_format::valid()
variable cval_t<T, val>::value The wrapped constant value
variable autocast_impl<Tfrom>::value
variable bitmask<bits>::value The stored bit value.
variable bit<T>::value The raw mask value.
variable struct_with_alignment<T, A>::value The wrapped value.
variable struct_with_alignment<T, false>::value The wrapped value.
variable cstring<N>::value
variable named_arg<T>::value
variable fmt_t<T, t, width, prec>::value
variable axis_params<Axis, N>::value Alias of width kept for backwards compatibility.
variable expression_scalar<T>::value
variable generator<T, VecWidth, Class, Twork>::value
variable expression_reduce<Tout, Dims, Twork, Tin, ReduceFn, TransformFn, FinalFn>::value
variable range<T>::iterator::value
typedef value_or_ref
typedef cval_t<T, val>::value_type
typedef vec_shape<T, N>::value_type The element type stored in the vector.
typedef cstring<N>::value_type
typedef portable_vec<T, N>::value_type
typedef vec<T, N>::value_type
typedef expression_traits<T>::value_type
typedef expression_with_traits<Arg>::value_type
typedef expression_function<Fn, Args>::value_type Value type produced by the expression.
typedef expression_discard<Tin, Dims>::value_type
typedef expression_traits<expression_scalar<T>>::value_type
typedef expression_traits<expression_counter<T, Dims>>::value_type
typedef expression_traits<expression_slice<Arg>>::value_type
typedef expression_traits<expression_cast<T, Arg>>::value_type
typedef expression_traits<expression_lambda<T, Dims, Fn, Rnd>>::value_type
typedef expression_traits<expression_padded<Arg>>::value_type
typedef expression_traits<expression_reverse<Arg>>::value_type
typedef expression_traits<expression_fixshape<Arg, fixed_shape_t<ShapeValues...>>>::value_type
typedef expression_traits<expression_reshape<Arg, OutDims>>::value_type
typedef expression_traits<expression_linspace<T, truncated>>::value_type
typedef expression_traits<expression_concatenate<Arg1, Arg2, ConcatAxis>>::value_type
typedef expression_unpack<E>::value_type
typedef expression_adjacent<Fn, E>::value_type
typedef expression_trace<E>::value_type
typedef expression_dimensions<Dims, E>::value_type
typedef array_ref<T>::value_type
typedef data_allocator<T>::value_type
typedef univector<T, Size>::value_type
typedef univector<T, tag_array_ref>::value_type
typedef univector<T, tag_dynamic_vector>::value_type
typedef expression_traits<univector<T, Tag>>::value_type
typedef expression_traits<expression_handle<T, Dims>>::value_type
typedef expression_placeholder<T, Dims, Key>::value_type
typedef expression_traits<expression_placeholder<T, Dims, Key>>::value_type
typedef generator<T, VecWidth, Class, Twork>::value_type
typedef inline_vector<T, N>::value_type
typedef tensor<T, NDims>::value_type
typedef tensor<T, NDims>::tensor_iterator::value_type
typedef tensor<T, NDims>::nested_iterator_t::value_type
typedef expression_traits<tensor<T, Dims>>::value_type
typedef expression_random_uniform<T, Dims, Reference>::value_type
typedef expression_random_range<T, Dims, Reference>::value_type
typedef expression_random_normal<T, Dims, Reference>::value_type
typedef expression_reduce<Tout, Dims, Twork, Tin, ReduceFn, TransformFn, FinalFn>::value_type
typedef expression_histogram<Bins, E, TCount>::value_type
typedef expression_window<T>::value_type
typedef range<T>::value_type
typedef expression_iir_l<filters, T, E1, Stateless>::value_type
typedef expression_iir<filters, T, E1, Stateless>::value_type
typedef expression_short_fir<tapcount, T, U, E1, stateless>::value_type
typedef expression_fir<T, U, E1, stateless>::value_type
typedef expression_moving_sum<U, E1, STag, stateless>::value_type
typedef expression_delay<delay, E, stateless, STag>::value_type
typedef expression_delay<1, E, stateless, STag>::value_type
typedef expression_goertzel<T>::value_type
typedef expression_parallel_goertzel<T, width>::value_type
typedef expression_traits<strided_channel<T>>::value_type
typedef value_type_of Extracts the
function histogram_data<Bins, TCount>::values() Returns a reference to the bin counts, excluding the below/above counters.
function variance(const E1 &) Computes the variance of the given input expression.
deduction guide vec Deduction guide: a braced list of scalars deduces to vec<common_type, N> .
typedef glsl_names::vec2
typedef glsl_names::vec3
typedef glsl_names::vec4
class vec_halves<T, 1> Specialization of vec_halves for single-element vectors.
class vec_halves<T, N> Splits a vec<T, N> into its two halves for recursive decomposition.
class vec_of_complex<N> Helper that maps a scalar component type T to vec<complex<T>, N>.
variable vec_rank Rank of a type within the compound-vector hierarchy.
class vec_shape<T, N> Describes the shape of a SIMD vector of N elements of type T.
constructor vec_shape<T, N>::vec_shape<T, N>() Default constructor.
class vec_template<N> Alias template producing vec<T, N> for a fixed N .
class vec_vec_template<N1, N2> Alias template producing vec<vec<T, N1>, N2> for fixed N1 , N2 .
class vec<T, 0> Rejected specialization for zero-sized vectors.
class vec<T, N> SIMD vector type of T elements with default width vector_width .
constructor vec<T, N>::vec<T, N>() Default constructor (elements are left uninitialized).
constructor vec<T, N>::vec<T, N>(cones_t) Construct an all-ones vector (tag constructor).
constructor vec<T, N>::vec<T, N>(const portable_vec<T, N> &) Reinterpret a portable_vec as a vec (layout-compatible).
constructor vec<T, N>::vec<T, N>(const simd_type &) Construct from a native SIMD register.
function vec<T, N>::vec<T, N>(const U &) Broadcast a compound value to all elements (non-scalar element type).
function vec<T, N>::vec<T, N>(const value_type *, cbool_t<aligned>) Load from a memory location.
function vec<T, N>::vec<T, N>(const value_type &, const value_type &, const Us &...) Construct from two or more compound values (non-scalar element type).
constructor vec<T, N>::vec<T, N>(const vec<std::conditional_t<compound_type_traits<T>::is_scalar, bit<T>, T>, N> &) Construct a value vector from a mask of the same scalar type.
constructor vec<T, N>::vec<T, N>(const vec<T, N> &) Copy constructor.
function vec<T, N>::vec<T, N>(const vec<T, Ns> &...) Concatenate several vectors whose sizes sum to N .
function vec<T, N>::vec<T, N>(const vec<U, N> &) Promote from a vector of a different (possibly compound) type.
constructor vec<T, N>::vec<T, N>(const vec<unwrap_bit<T>, N> &) Construct a mask vector from a value vector of the same scalar type.
constructor vec<T, N>::vec<T, N>(czeros_t) Construct an all-zeros vector (tag constructor).
function vec<T, N>::vec<T, N>(from_lambda, Fn &&) Construct from a generator callable.
constructor vec<T, N>::vec<T, N>(vec<T, N> &&) Move constructor.
function vector_alignment(size_t) Return the alignment (next power of two of size ) for a vector of size bytes.
variable vector_capacity Total SIMD capacity (in elements) for type T on the native platform.
typedef histogram_data<Bins, TCount>::vector_type
typedef vector_types_for_size_t Convenience alias for the type list produced by vector_types_for_size_t_impl.
class vector_types_for_size_t_impl<vec_tpl, T, csizes_t<sizes...>> Specialization that expands the size list into a ctypes_t of vector types.
class vector_types_for_size_t_impl<vec_tpl, T, sizes> Builds a type list of vector instantiations of vec_tpl for element type T over the test vector sizes.
variable vector_width SIMD vector width (in elements) for type T on the native platform.
variable vector_width_for SIMD vector width (in elements) for type T on the given CPU.
class vecvec_template<N1, N2> Alias template producing vec<vec<T, N1>, N2> for fixed N1 , N2 .
typedef vecx Convenience alias building nested vec types from a list of sizes.
variable cpu_features::vendor NUL-terminated CPUID vendor string (leaf 0).
variable version
variable version_full KFR version string including architecture and compiler name
variable version_major
variable version_minor
variable version_patch
variable version_string KFR version string
variable generator_linear<T, VecWidth>::vstep
variable generator_exp<T, VecWidth>::vstep
variable generator_exp2<T, VecWidth>::vstep
variable expression_handle<T, Dims>::vtable Pointer to the static vtable for the instance type.

W¶

enum constant audiofile_container::w64 Sony WAVE64
struct w64_decoding_options Options for decoding W64 audio files.
struct w64_encoding_options Represents options for W64 audio encoding.
enum constant audiofile_container::wave RIFF WAVE
struct wave_decoding_options Options for decoding WAVE audio files.
struct wave_encoding_options Represents options for WAVE audio encoding, including RF64 support for large files.
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 exception::what()
function widen(const vec<T, Nout> &, TS) Identity overload of widen() for the Nout == input length case.
function widen(const vec<T, N> &, std::type_identity_t<T>) Widens x to length Nout by appending lanes set to newvalue.
variable compound_type_traits<T>::width
variable compound_type_traits<std::pair<T, T>>::width
variable typebits<T>::width
variable compound_type_traits<kfr::vec_shape<T, N>>::width
variable compound_type_traits<kfr::vec<T, N>>::width
variable compound_type_traits<std::complex<T>>::width Number of immediate sub-elements (real and imaginary).
variable axis_params<Axis, N>::width The vector width.
variable generator<T, VecWidth, Class, Twork>::width
variable expression_reduce<Tout, Dims, Twork, Tin, ReduceFn, TransformFn, FinalFn>::width
function widthof() Returns the width (number of scalar components) of
function widthof(T) Returns the width (number of scalar components) of
function window_bartlett_hann(size_t, ctype_t<T>) Returns template expression that generates a Bartlett-Hann window of length size
function window_bartlett(size_t, ctype_t<T>) Returns template expression that generates a Bartlett window of length size
function window_blackman_harris(size_t, window_symmetry, ctype_t<T>) Returns template expression that generates a Blackman-Harris window of length size
function window_blackman(size_t, std::type_identity_t<T>, window_symmetry, ctype_t<T>) Returns template expression that generates a Blackman window of length size where α = alpha
function window_bohman(size_t, ctype_t<T>) Returns template expression that generates a Bohman window of length size
class window_by_type<window_type> Type trait mapping a window_type to its corresponding expression type
struct window_by_type<window_type::bartlett>
struct window_by_type<window_type::bartlett_hann>
struct window_by_type<window_type::blackman>
struct window_by_type<window_type::blackman_harris>
struct window_by_type<window_type::bohman>
struct window_by_type<window_type::cosine>
struct window_by_type<window_type::cosine_np>
struct window_by_type<window_type::flattop>
struct window_by_type<window_type::gaussian>
struct window_by_type<window_type::hamming>
struct window_by_type<window_type::hann>
struct window_by_type<window_type::kaiser>
struct window_by_type<window_type::lanczos>
struct window_by_type<window_type::planck_taper>
struct window_by_type<window_type::rectangular>
struct window_by_type<window_type::triangular>
struct window_by_type<window_type::tukey>
function window_cosine_np(size_t, ctype_t<T>) Returns template expression that generates a cosine window (numpy compatible) of length size
function window_cosine(size_t, ctype_t<T>) Returns template expression that generates a cosine window of length size
function window_flattop(size_t, ctype_t<T>) Returns template expression that generates a flat-top window of length size
function window_gaussian(size_t, std::type_identity_t<T>, ctype_t<T>) Returns template expression that generates a Gaussian window of length size where α = alpha
function window_hamming(size_t, std::type_identity_t<T>, ctype_t<T>) Returns template expression that generates a Hamming window of length size where α = alpha
function window_hann(size_t, ctype_t<T>) Returns template expression that generates a Hann window of length size
function window_kaiser(size_t, std::type_identity_t<T>, ctype_t<T>) Returns template expression that generates a Kaiser window of length size where β = beta
function window_lanczos(size_t, ctype_t<T>) Returns template expression that generates a Lanczos window of length size
class window_linspace<T> Linspace expression specialized for window abscissa generation
constructor window_linspace<T>::window_linspace<T>(cval_t<window_metrics, window_metrics::metrics_0_1>, size_t, window_symmetry)
constructor window_linspace<T>::window_linspace<T>(cval_t<window_metrics, window_metrics::metrics_m1_1_trunc2>, size_t, window_symmetry)
constructor window_linspace<T>::window_linspace<T>(cval_t<window_metrics, window_metrics::metrics_m1_1_trunc>, size_t, window_symmetry)
constructor window_linspace<T>::window_linspace<T>(cval_t<window_metrics, window_metrics::metrics_m1_1>, size_t, window_symmetry)
constructor window_linspace<T>::window_linspace<T>(cval_t<window_metrics, window_metrics::metrics_mpi_pi>, size_t, window_symmetry)
enum window_metrics Selects the abscissa range and endpoint handling used by window expressions
function samplerate_converter<T>::window_param(fbase)
function samplerate_converter<T>::window_param(sample_rate_conversion_quality) Computes the Kaiser window parameter for a given quality level.
function window_planck_taper(size_t, std::type_identity_t<T>, window_symmetry, ctype_t<T>) Returns template expression that generates a Planck-taper window of length size
function window_rectangular(size_t, ctype_t<T>) Returns template expression that generates a rectangular window of length size
enum window_symmetry Window symmetry mode
function window_triangular(size_t, ctype_t<T>) Returns template expression that generates a triangular window of length size
function window_tukey(size_t, std::type_identity_t<T>, window_symmetry, ctype_t<T>) Returns template expression that generates a Tukey window of length size (numpy compatible)
enum window_type Window function types supported by KFR
function samplerate_converter<T>::window(fbase) Computes the Kaiser window function for a given sample position.
function window(size_t, cval_t<window_type, type>, std::type_identity_t<T>, window_symmetry, ctype_t<T>) Returns a window expression of the requested compile-time type
function window(size_t, window_type, std::type_identity_t<T>, window_symmetry, ctype_t<T>) Returns a type-erased window expression of the requested runtime type
function wrap_bit_value(const T &) Pass-through overload of wrap_bit_value for non-bit types.
function wrap_bit_value(const unwrap_bit<T> &) Wraps a raw mask value into a bit<T> .
function wrap_fmt(const U &, ctype_t<Fmt>) Wrap val with the format type Fmt when Fmt is not void.
function wrap_fmt(const U &, ctype_t<void>) Identity pass-through used when no format type is specified.
variable stride_pointer<T, groupsize>::writable_ptr
function audio_writer<T>::write_channels(const univector2d<T, Tag1, Tag2> &)
function write_group(T *, size_t, const vec<T, group * count * N> &) Writes count groups of group*N elements separated by stride groups.
enum constant open_file_mode::write_new
function audio_encoder::write(const audio_data_interleaved &) Writes a chunk of interleaved audio data to the encoder.
function writer_adapter<From, To>::write(const To *, size_t)
function abstract_writer<T>::write(const T *, size_t)
function memory_writer<T>::write(const T *, size_t)
function file_writer<T>::write(const T *, size_t)
function audio_writer_wav<T>::write(const T *, size_t) Write data to underlying binary writer data is PCM samples in interleaved format size is the number of samples (PCM frames * channels)
function abstract_writer<T>::write(const U &)
function stride_pointer<T, groupsize>::write(const vec<T, N> &, csize_t<N>) Scatters N elements of val to the underlying pointer using the stored stride.
variable writer_adapter<From, To>::writer
function audio_encoder::writer() Retrieves the binary writer associated with the encoder.
class writer_adapter<From, To>
constructor writer_adapter<From, To>::writer_adapter<From, To>(std::shared_ptr<abstract_writer<From>>)
function write(T *, const vec<T, N> &) Writes a vector of N elements of type T to memory.
function vec<T, N>::write(value_type *, cbool_t<aligned>) Store to a memory location.

Z¶

variable zpk::z Zeros of the transfer function
function zeroize(T1 &) Fills a value with zeros
function zeros() Creates an expression that always evaluates to zero.
function zerovector() Return an all-zeros vector of the given type and size.
function zerovector(vec_shape<T, N>) Return an all-zeros vector matching the given shape.
function zerovector(vec<T, N>) Return an all-zeros vector matching the type of the given vector.
function zip(const vec<T, N1> &, const vec<T, Ns> &...) Zips multiple vectors into a vector of vectors.
struct zpk Zero-pole-gain (ZPK) representation of a linear time-invariant (LTI) filter.

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