Namespace kfr¶

A¶

class abstract_reader<T> Base class for all typed readers
class abstract_stream<T> Base class for all typed readers and writer
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
function acos(E1 &&) Creates an expression that returns the arc cosine of x.
function advance(T *, ptrdiff_t)
function advance(void *, ptrdiff_t)
struct aiff_decoding_options Options for decoding AIFF audio files.
struct aiff_encoding_options Represents options for AIFF audio encoding.
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
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.
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.
class array_ref<T> Reference to array
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 as_string(const Args &...) Convert arbitrary values to a std::string using KFR's built-in formatting.
function asin(E1 &&) Creates an expression that returns the arc sine of x.
function assertion_failed(const std::string &, const char *, int) Prints a failed assertion to stderr.
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 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.
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.
struct audio_decoder Abstract base class for audio decoders providing methods for opening and reading audio files.
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.
struct audio_encoding_options Represents options for audio encoding, including dithering settings.
class audio_filter Multi-channel audio filter that operates on audio_data and maintains a per-channel array of filter<fbase> instances.
struct audio_format
struct audio_format_and_length
struct audio_quantization Represents audio quantization parameters.
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
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
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
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
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.
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.

B¶

typedef b8 Short names for common types
typedef binary_reader Binary reader
typedef binary_writer Binary writer
function bind_func(Fn &&, Args &&...)
class biquad_section<T> Structure for holding biquad filter coefficients.
class biquad_state<T, filters> Per-section delay-line state for a cascade of filters biquad sections.
enum biquad_type Type of biquad filter response used by coefficient design helpers.
function bitcast_anything(const Tin &)
class bitmask<bits> Holds an unsigned integer wide enough to store bits bits.
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.
class bit<T> Boolean value stored as a mask of type T (all-ones for true, all-zeros for false).
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.
typedef byte_reader Byte reader
typedef byte_writer Byte writer

C¶

typedef c32 Alias for complex<f32>
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 cabs(E1 &&) Creates an expression that returns the absolute value (magnitude) of the complex number x.
function cabssqr(E1 &&) Creates an expression that returns the squared absolute value (magnitude squared) of the complex number x.
struct caff_decoding_options Options for decoding CAFF audio files.
struct caff_encoding_options Represents options for CAFF audio encoding.
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.
function carg(E1 &&) Creates an expression that returns the phase angle (argument) of the complex number x.
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.
typedef cbase Alias for complex<fbase>
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(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 cconcat(T1, Ts...) Returns a value of the concatenated list type
function ccos(E1 &&) Creates an expression that returns the cosine of the complex value 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.
typedef cdirect_t Tag type selecting the direct (forward) DFT direction.
function cexp10(E1 &&) Creates an expression that returns 10 raised to the complex number x.
function cexp2(E1 &&) Creates an expression that returns 2 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 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 .
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 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(E1 &&) Creates an expression that returns the common (base-10) 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(E1 &&) Creates an expression that returns the natural logarithm of the complex number x.
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
struct cmp_eq
struct cmp_ge
struct cmp_gt
struct cmp_le
struct cmp_lt
struct cmp_ne
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 comparison<Fn, L, R>
namespace compiletime
typedef complex Complex number type alias.
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 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 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.
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>
typedef container_value_type
class convolve_filter<T> Streaming convolution filter using the overlap-add (block convolution) method.
function convolve(const univector<T1, Tag1> &, const univector<T2, Tag2> &) Computes the linear convolution of two real or complex signals.
struct coreaudio_decoding_options Options for decoding audio using Core Audio.
function correlate(const univector<T1, Tag1> &, const univector<T2, Tag2> &) Computes the linear correlation of two real or complex signals.
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(E1 &&) Creates an expression that returns the hyperbolic cosine of x.
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.
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 coth(E1 &&) Creates an expression that returns the hyperbolic cotangent of x.
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_coreaudio_decoder(const coreaudio_decoding_options &) Creates a Core Audio-based audio decoder.
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_for_file(const std::string &, const audio_decoding_options &)
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_mediafoundation_decoder(const mediafoundation_decoding_options &) Creates a Media Foundation-based audio decoder.
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 csin(E1 &&) Creates an expression that returns the sine of the complex value 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(E1 &&) Creates an expression that returns the square 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 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 &&)
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.
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.
function current_epsilon()
class cursor<Dims> Multi-dimensional iteration cursor.
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.
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.
variable cvalseq Constant instance of cvalseq_t with
typedef cvalseq_t Compile-time arithmetic sequence of size values starting at start with step step .
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¶

class data_allocator<T> Aligned allocator
enum datatype An enumeration representing data type
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).
typedef decay_common Decays to the common type of the supplied arguments after decay.
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 decode_audio_file(const std::string &, audiofile_format *, const audio_decoding_options &)
function deep_is_equal(const T1 &, const T2 &)
typedef deep_subtype The deepest scalar subtype of a (possibly nested) compound type
variable default_audio_frames_to_read The default number of audio frames to read in one operation.
variable default_dft_algorithm
variable default_memory_alignment
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.
enum dft_decomp Decomposition direction for a butterfly pass.
enum dft_family Family of DFT algorithms (groups related algorithms).
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.
class dft_plan_md<T, Dims> Multidimensional complex DFT plan.
class dft_plan_real<T> Real-to-complex and complex-to-real 1D DFT plan.
class dft_plan<T> Class for performing 1D DFT/FFT.
struct dft_resampler_params Parameters for constructing a dft_resampler .
class dft_resampler<T> FFT-based sample-rate converter and FIR filter using overlap-save.
typedef dft_stage_ptr
class dft_stage<T> Base structure representing a single DFT stage.
enum dft_type Direction(s) of DFT computation requested for a plan.
typedef dimset Fixed-size bitmask indexed by tensor axis.
function distance(const void *, const void *)
function dont_deduce(T)
variable dynamic_shape Sentinel rank value indicating a run-time-determined rank.

E¶

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)
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 encode_audio_file(const std::string &, const audio_data_interleaved &, const audiofile_format &, audio_decoder *, const audio_encoding_options &) Encodes interleaved audio data and writes it to a file (Windows-specific overload).
function encode_audio_file(const std::string &, const audio_data_planar &, const audiofile_format &, audio_decoder *, const audio_encoding_options &) Encodes planar audio data and writes it to a file (Windows-specific overload).
class epsilon_scope<T>
struct epsilon_scope<void>
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.
class exception
function exp10(E1 &&) Creates an expression that returns 10 raised to the given power x.
function exp2(E1 &&) Creates an expression that returns 2 raised to the given power x.
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(E1 &&) Creates an expression that returns \(e\) raised to the given power x.
concept expr_element Concept satisfied by scalar vector element types.
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_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.
class expression_counter<T, Dims> Expression that produces a sequence of values start, start + step, start + 2*step, ... for one or more dimensions.
variable expression_dims Inline variable holding the number of dimensions of an expression.
class expression_filter<T> Filter adapter that wraps an expression containing a placeholder.
class expression_fixshape<Arg, Shape> Expression that overrides the shape of another expression with a compile-time shape.
class expression_handle<T, Dims> Opaque type-erased handle to an expression (forward declaration).
class expression_lambda<T, Dims, Fn, Rnd> Expression backed by a user-provided callable.
class expression_linspace<T, truncated> Expression that produces evenly spaced values from start to stop.
class expression_padded<Arg> Expression that extends another expression with a constant fill value.
class expression_placeholder<T, Dims, Key> A placeholder expression that can be bound to a concrete expression at runtime.
variable expression_random_access Inline variable indicating whether an expression supports random access.
class expression_reshape<Arg, OutDims> Expression that exposes the same data as another expression with a different shape.
struct expression_resource Base class for owning the storage of a type-erased expression.
class expression_resource_impl<E> expression_resource that owns an expression of type E by value.
class expression_reverse<Arg> Expression that exposes another expression with its trailing dimension reversed.
class expression_scalar<T> Expression that wraps a single scalar value of type T.
class expression_slice<Arg> Expression that exposes a sub-region of another expression.
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.
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.

F¶

struct f16 16-bit half-precision floating-point value stored as raw bits.
typedef f32
typedef f32_reader float reader
typedef f32_writer float writer
typedef f64
typedef f80
concept f_class
function factorial_approx(E1 &&) Creates an expression that returns the approximate factorial of x.
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 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 file_extension(const file_path &)
struct file_handle
typedef file_path
class file_reader<T> Typed file reader
class file_writer<T> Typed file writer
typedef filepath
typedef filter_fir Alias for
class filter<T> Abstract base class for single-argument filters, mainly intended for DSP processing.
typedef findinttype
class fir_filter<T, U> Runtime FIR filter implementing the filter<U> interface.
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.
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.
typedef fir_taps Alias for a fixed-size vector of FIR filter coefficients.
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.
function fixshape(Arg &&, const fixed_shape_t<ShapeValues...> &) Creates an expression that overrides the shape of arg with a compile-time shape.
struct flac_decoding_options Options for decoding FLAC audio files.
struct flac_encoding_options Represents options for FLAC audio encoding.
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.
function floor_div(long long, long long)
typedef flt_type
typedef fmax
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_generic
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
class fn_return_constant<T, value> Functor returning a fixed constant of type T , ignoring all arguments.
class fn_returns<T>
function fopen_path(const file_path &, open_file_mode)
variable force_compiletime_size_t Forces a compile-time evaluation of the given size_t value.
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.
function fprintfmt(FILE *, const std::string &, const Args &...) Print to a file f using a {}"-based format string.
struct fraction Exact rational number represented as a numerator/denominator pair.
function from_error_code(std::error_code) Converts a standard error code to an audiofile_error.
function from_maskbits(T) Interprets value as a signed integer and tests the sign bit.
typedef fsubtype
typedef ftype
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(E1 &&) Creates an expression that returns the approximate gamma function of x.
namespace generic
function get_cpu() Returns the CPU instruction set selected for use at runtime.
function get_element(E &&, shape<Dims>) Reads a single element from an expression at the given index.
function get_elements(const strided_channel<T> &, const shape<1> &, const axis_params<0, N> &)
function get_first(T1 &&, Ts &&...) Function that returns its first argument and ignores all other arguments
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 get_shape(T &&) Returns the shape of an expression instance.
function get_third(T1 &&, T2 &&, T3 &&, Ts &&...) Function that returns its third argument and ignores all other arguments

H¶

class half_comparison<L>
concept has_begin_end Concept satisfied by types that support
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.

I¶

typedef i16
struct i24 Signed 24-bit integer stored in three bytes (little-endian).
typedef i32
typedef i64
typedef i8
concept i_class
class iir_filter<T> Runtime IIR filter object usable as a streaming filter.
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.
class iir_params<T, tag_dynamic_vector> Dynamic-size specialization of iir_params.
deduction guide iir_state
deduction guide iir_state
class iir_state<T, filters> Combined IIR filter parameters and runtime state.
function ilog2(T) Returns the base-2 logarithm of
typedef imax
function implicit_cast(U &&)
typedef index_t Unsigned integer type used for tensor indices and axis sizes.
variable index_undefined Sentinel index value meaning "no index".
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.
variable infinity Positive infinity as a double .
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.
concept input_expression Concept satisfied by expressions that can be read from.
concept input_output_expression Concept satisfied by expressions that are both readable and writable.
typedef int_type Maps a bit width to the corresponding signed integer type
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.
namespace internal_generic
function is_between(T, std::type_identity_t<T>, std::type_identity_t<T>)
variable is_bit True when T is a bit<U> 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 is_divisible(T, T)
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.
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 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
function is_sequence(csizes_t<number, numbers...>)
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.
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
typedef isubtype
typedef itype

J¶

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)

L¶

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.
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 linspace(T1, T2, size_t, bool, cbool_t<truncated>) Creates an expression that returns evenly spaced numbers over a specified interval.
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(E1 &&) Creates an expression that returns the common (base-10) logarithm of x.
function log2(E1 &&) Creates an expression that returns the binary (base-2) logarithm of x.
function log_fmadd(E1 &&, E2 &&, E3 &&) Creates an expression that returns log(x) * m + a.
function logb(E1 &&) Creates an expression that returns the rounded binary (base-2) logarithm of x.
function log(E1 &&) Creates an expression that returns the natural logarithm of x.
class logic_error
function logm(E1 &&, E2 &&) Creates an expression that returns log(x) * y.
function logn(E1 &&, E2 &&) Creates an expression that returns the logarithm of x with base y.

M¶

function make_array_ref(Container &&)
function make_array_ref(T *, std::size_t)
struct make_comparison
function make_cstring(cchars_t<chars...>)
function make_cstring(const char (&)[N])
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 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 maskbits(bool) Returns all-ones or all-zeros of type T depending on value.
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.
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.
function measure_rdtsc_cycle_time() Measures and returns the estimated cycle time in nanoseconds per tick for rdtsc.
struct mediafoundation_decoding_options Options for decoding audio using Media Foundation.
typedef memory_finalizer Shared ownership handle for a memory finalizer.
class memory_reader<T>
class memory_writer<T>
typedef metadata_map Metadata map for storing key-value pairs.
function modzerobessel(E1 &&) Creates an expression that returns the modified Bessel function of the first kind of order 0 of x.
class moving_sum_state<U, Tag> State for a moving-sum (rectangular window) filter with a compile-time-sized delay line.
class moving_sum_state<U, tag_dynamic_vector> Specialization of moving_sum_state for a runtime-sized window.
struct mp3_config
struct mp3_decoding_options Options for decoding MP3 audio files.

N¶

struct named
class named_arg<T>
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>
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.
function noinline(Fn &&, Args &&...)
function noop(Ts &&...) Function that returns void and ignores all its arguments
concept not_f_class
concept not_i_class
concept not_u_class
enum npy_decode_result Status returned by the .npy loading function.
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 ones() Creates an expression that always evaluates to one.
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
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 operator==(const data_allocator<T1> &, const data_allocator<T2> &)
function operator!=(const data_allocator<T1> &, const data_allocator<T2> &)
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 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 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)
typedef opt_index_t Optional signed index used by tensor_range .
typedef or_type If
concept output_expression Concept satisfied by expressions that can be written to.
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¶

function pack_elements() Returns the identity value (0) for an empty pack
function pack_elements(Arg, Args...)
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.
function padleft(size_t, const std::string &, char) Left-align text within a field of size characters by appending character.
function padright(size_t, const std::string &, char) Right-align text within a field of size characters by prepending character.
function pass_through(T &&) Function that returns its first argument
typedef pconstvoid Pointer to const void
function perfplot_save(const std::string &, T1 &&, T2 &&, const std::string &)
function perfplot_show(const std::string &, T1 &&, T2 &&, const std::string &)
function placeholder(csize_t<Key>) Create an unbound expression_placeholder with the given key.
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
function polar(E1 &&) Creates an expression that converts a complex number to polar form.
class portable_vec<T, N> A portable vector type with fixed size and layout compatible with vec<T, N> .
function pow(E1 &&, E2 &&) Creates an expression that returns x raised to the given power y.
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 ptr_cast(const U *) Reinterprets a const pointer of type
function ptr_cast(U *)
function ptr_cast(U *, ptrdiff_t)
typedef pvoid Pointer to void
function python_prologue()

Q¶

variable qnan Quiet NaN (Not-a-Number) as a double .
function q(T) Wrap the string representation of x in double quotes.

R¶

struct random_state Internal state of the pseudo-random number generator.
class range<T> Iterable range
struct raw_decoding_options Options for decoding raw audio streams.
struct raw_encoding_options Represents options for raw audio encoding.
function rdtsc() Reads the processor's cycle counter.
function read_audiofile_header(const file_path &) Reads the header of an audio file.
function read_audiofile_header(const std::string &) Creates an audio decoder from a file header.
class reader_adapter<From, To>
function ref_cast(const U &) Reinterprets a const reference of type
function ref_cast(U &)
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)
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.
typedef resample_quality Alias for sample_rate_conversion_quality.
function reshape(Arg &&, const shape<OutDims> &) Creates an expression that exposes the same data as arg with a different shape.
function return_constant(Args &&...) Function that returns constant of type T and ignores all its arguments
function returns(Ts &&...) Function that returns value-initialization of type T and ignores all its arguments
function reverse(Arg &&) Creates an expression that exposes arg with its trailing dimension reversed.
function root(E1 &&, E2 &&) Creates an expression that returns the real nth root of x.
class runtime_error

S¶

function safe_cast(const InType &) Casts between integral types after range-checking the source value.
enum sample_rate_conversion_quality Defines the quality levels for sample rate conversion.
class samplerate_converter<T> A template class for performing sample rate conversion on audio signals.
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 save_to_npy(const tensor<T, Dims> &, Fn &&) Saves a tensor to .npy format using a custom write callback.
class scalar_constants<T> Collection of mathematical and machine constants for the scalar type T .
function scalar(T) Creates an expression that wraps a single value.
function scale()
function scale(csizes_t<indices...>)
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.
enum seek_origin Seek origin
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 sequence(const Ts &...) Creates an expression that cycles through the provided list of values.
function set_elements(strided_channel<T> &, const shape<1> &, const axis_params<0, N> &, const std::type_identity_t<vec<T, N>> &)
deduction guide shape Deduction guide for shape from a parameter pack.
struct shape<0> Scalar shape specialization.
class shape<dims> Fixed-rank multidimensional shape used by tensor .
struct shape<dynamic_shape> Run-time-rank shape specialization.
class short_fir_state<tapcount, T, U> State for a short FIR filter (tap count in range 2..33).
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.
function sinc(E1 &&) Creates an expression that returns the sinc function of x.
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(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 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 size_add(size_t, size_t) Saturating addition for shape sizes.
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_shape(const shape<dims> &) Total number of elements described by a shape.
function size_sub(size_t, size_t) Saturating subtraction for shape sizes.
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.
class small_buffer<T, Capacity> A dynamically-sized buffer with a small-size optimization.
function snprintfmt(char *, size_t, const std::string &, const Args &...) Write to a buffer using a {}"-based format string.
typedef Speaker
enum speaker_arrangement Predefined speaker arrangements.
enum speaker_type Speaker types (channel positions).
typedef SpeakerArrangement
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.
class spsc_ring_buffer<T> Single-producer/single-consumer queue backed by an external univector .
function sqrt(E1 &&) Creates an expression that returns the positive square root of x. \(\sqrt{x}\)
class state_holder<T, false> Owning specialization of state_holder .
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 .
class static_assert_eq<T, left, right>
class static_assert_type_eq<Left, Right>
function steady_time() Returns the current time in nanoseconds since epoch using steady_clock.
function stop_constexpr() Non-constexpr function used to halt constant evaluation in
struct stopwatch RAII-style stopwatch measuring wall-clock elapsed time via clock_now .
function str_find(const cstring<N1> &, const cstring<Nneedle> &)
function str_replace(const cstring<N1> &, const cstring<Nfrom> &, const cstring<Nto> &)
class strided_channel<T> Represents a strided audio channel.
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 substitute(const internal_generic::anything &, Args &&...) Fallback substitute that accepts any expression and arguments and does nothing.
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 subtype The immediate subtype of a compound type
struct swallow Utility class to use in list-initialization context Accepts any number of arguments and discards them; useful for pack expansion side effects.
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.

T¶

function tall() Build a range that spans the entire axis (defaults for all three components).
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(E1 &&) Creates an expression that returns the hyperbolic tangent of x.
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_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.
variable test_vector_sizes Set of vector sizes used by the test harness.
class timestamps<max_count, fence> High-resolution scoped profiler using RDTSC (x86) or CNTVCT_EL0 (AArch64).
function to_filter(expression_handle<T, 1> &&) Creates a filter from an expression handle containing a placeholder.
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_string(audiofile_error) Converts an audiofile_error to its string representation.
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.
function truncate(Arg &&, std::type_identity_t<shape<Dims>>) Creates an expression that exposes arg starting at the origin with the given size.
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.
struct type_id_t
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
class typebits<T>
variable typeclass
function typeindex() Returns the zero-based index of type

U¶

typedef u16
struct u24 Unsigned 24-bit integer stored in three bytes (little-endian).
typedef u32
typedef u64
typedef u8
concept u_class
typedef uitype
typedef umax
variable undefined_size Sentinel value denoting a dimension whose size is not yet known.
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.
class univector<T, tag_array_ref> Non-owning univector specialization that holds a reference to external data.
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.
enum (Unnamed enum at base/univector.hpp:42:1) Compile-time tags selecting the storage strategy of a univector .
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.
typedef usubtype
typedef utype

V¶

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)
typedef value_or_ref
typedef value_type_of Extracts the
class vec_shape<T, N> Describes the shape of a SIMD vector of N elements of type T.
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 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

W¶

struct w64_decoding_options Options for decoding W64 audio files.
struct w64_encoding_options Represents options for W64 audio encoding.
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 widthof() Returns the width (number of scalar components) of
function widthof(T) Returns the width (number of scalar components) of
enum window_symmetry Window symmetry mode
enum window_type Window function types supported by KFR
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.
class writer_adapter<From, To>

Z¶

function zeroize(T1 &) Fills a value with zeros
function zeros() Creates an expression that always evaluates to zero.
struct zpk Zero-pole-gain (ZPK) representation of a linear time-invariant (LTI) filter.