Base Utilities¶

Core data structures and fundamental utilities for KFR.

A¶

function histogram_data<Bins, TCount>::above() Returns the count of values that fell above the histogram range.
function abs(E1 &&) Creates an expression that returns the absolute value of x.
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(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.
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 .
function tensor<T, NDims>::access(const shape_type &) Returns a reference to the element at indices.
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(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 adjacent(Fn &&, E1 &&) Creates an expression that returns the result of calling \(fn(x_i, x_{i-1})\) .
function tensor<T, NDims>::allocate(size_t) Allocates aligned memory for size elements.
variable generator_expj<T, VecWidth>::alpha
variable generator_cossin<T, VecWidth>::alpha
variable generator_sin<T, VecWidth>::alpha
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 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.
typedef arg Alias that decays numeric/boolean argument types while preserving expression types unchanged.
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_traits<expression_concatenate<Arg1, Arg2, ConcatAxis>>::ArgTraits1
typedef expression_traits<expression_concatenate<Arg1, Arg2, ConcatAxis>>::ArgTraits2
function asin(E1 &&) Creates an expression that returns the arc sine of x.
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 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.
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.
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.
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¶

function expression_counter<T, Dims>::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()
typedef shape<Dims>::base Underlying static array storing one index_t per axis.
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 begin_pass(const expression_handle<T, NDims> &, shape<NDims>, shape<NDims>) Internal ADL-provided implementation for expression_handle expressions.
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.
variable generator_expj<T, VecWidth>::beta
variable generator_cossin<T, VecWidth>::beta
variable generator_sin<T, VecWidth>::beta
function tensor<T, NDims>::binary_inplace(const tensor<U, dims> &, Fn &&) Applies a binary function element-wise with rhs in place.
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.

C¶

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.
function tensor<T, NDims>::calc_index(const shape_type &) Computes the linear offset of the element at indices using the tensor's strides.
enum constant npy_decode_result::cannot_read Failed to read data or header
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.
function inline_vector<T, N>::cbegin() Returns a const iterator to the first element.
function small_buffer<T, Capacity>::cbegin()
function cbrt(E1 &&) Creates an expression that returns the cube root of x.
function cconj(E1 &&) Creates an expression that returns the complex conjugate of the complex number x.
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.
function ceil(E1 &&) Creates an expression that returns the smallest integer value not less than x.
function inline_vector<T, N>::cend() Returns a const iterator to one past the last element.
function small_buffer<T, Capacity>::cend()
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 cindex Variable template form of cindex_t .
typedef cindex_t Compile-time constant of type index_t .
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 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.
typedef complex Complex number type alias.
function expression_traits<expression_concatenate<Arg1, Arg2, ConcatAxis>>::concat_shape(const shape<dims> &, const shape<dims> &)
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.
typedef tensor<T, NDims>::const_contiguous_iterator
typedef inline_vector<T, N>::const_iterator
typedef tensor<T, NDims>::const_iterator
typedef inline_vector<T, N>::const_pointer
typedef tensor<T, NDims>::const_pointer
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
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.
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 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.
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
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 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.
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.
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.
function cub(E1 &&) Creates an expression that returns the cube of x.
variable cursor<Dims>::current Current multi-dimensional index.
class cursor<Dims> Multi-dimensional iteration cursor.

D¶

variable expression_adjacent<Fn, E>::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()
function tensor<T, NDims>::deallocate(T *) Deallocates memory previously returned by allocate().
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 fraction::denominator Denominator of the fraction (always positive after normalization).
typedef tensor<T, NDims>::tensor_iterator::difference_type
typedef tensor<T, NDims>::nested_iterator_t::difference_type
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
typedef dimset Fixed-size bitmask indexed by tensor axis.
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.
variable dynamic_shape Sentinel rank value indicating a run-time-determined rank.

E¶

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 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 end_pass(const expression_handle<T, NDims> &, shape<NDims>, shape<NDims>) Internal ADL-provided implementation for expression_handle expressions.
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 expression_linspace<T, truncated>::endpoint
function eq(E1 &&, E2 &&) Creates an expression that returns whether e1 is equal to e2.
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.
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_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_counter<T, Dims> Expression that produces a sequence of values start, start + step, start + 2*step, ... for one or more dimensions.
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_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 &&)
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_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_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_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.
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.
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_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>()
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_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_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<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_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.
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 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 audio_sample_type::f32
enum constant audio_sample_type::f64
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.
variable expression_padded<Arg>::fill_value
variable expression_filter<T>::filter_expr The wrapped placeholder expression.
class filter<T> Abstract base class for single-argument filters, mainly intended for DSP processing.
destructor filter<T>::~filter<T>() Destructor.
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 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
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.
function tensor<T, NDims>::tensor_iterator::flat_index() Returns the flat (linear) index of the current element.
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 floor(E1 &&) Creates an expression that returns the largest integer value not greater than x.
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.
variable expression_vtable<T, Dims>::fn_get_elements get_elements callbacks per axis/size.
variable expression_vtable<T, Dims>::fn_reset reset callback.
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.
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 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.
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 shape<Dims>::from_std_array(const std::array<TI, Dims> &) Build a shape from a std::array.
function expression_counter<T, Dims>::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 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.

G¶

function gamma(E1 &&) Creates an expression that returns the approximate gamma function of x.
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.
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.
function fixed_shape_t<Values>::get()
function expression_reduce<Tout, Dims, Twork, Tin, ReduceFn, TransformFn, FinalFn>::get() Returns the reduced value.
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 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 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_dimensions<Dims, E>::get_elements(const expression_dimensions<Dims, E> &, shape<dims>, axis_params<VecAxis, N>)
function get_elements(const expression_fixshape<Arg, Shape> &, const shape<Traits::dims> &, const axis_params<Axis, 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 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_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_lambda<T, Dims, Fn, Rnd> &, const shape<Dims> &, const axis_params<Axis, 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 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_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 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 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 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 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.
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.
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 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_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_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_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_with_traits<Arg>::get_shape(const expression_with_traits<Arg> &)
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 generator_sin<T, VecWidth>::get_value() Returns the sine components of the current interleaved cos/sin state.
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::fraction>::get(const kfr::fraction &)
function representation<kfr::shape<dims>>::get(const kfr::shape<dims> &) Returns the string representation of 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<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 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 gt(E1 &&, E2 &&) Creates an expression that returns whether e1 is greater than e2.

H¶

variable expression_placeholder<T, Dims, Key>::handle Handle to the bound expression, or empty if unbound.
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_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.
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 horner_even(E &&...) Creates an expression that evaluates a polynomial with even powers using Horner's method.
function horner_odd(E &&...) Creates an expression that evaluates a polynomial with odd powers using Horner's method.
function horner(E &&...) Creates an expression that evaluates a polynomial using Horner's method.

I¶

enum constant audio_sample_type::i16
enum constant audio_sample_type::i24
enum constant audio_sample_type::i32
function iceil(E1 &&) Creates an expression that returns the integer equivalent of ceil( x).
function ifloor(E1 &&) Creates an expression that returns the integer equivalent of floor( x).
function imag(E1 &&) Creates an expression that returns the imaginary part of the complex value x.
variable expression_dimensions<Dims, E>::in_dims
variable expression_reshape<Arg, OutDims>::in_shape
variable tensor<T, NDims>::nested_iterator_t::index
typedef index_t Unsigned integer type used for tensor indices and axis sizes.
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 infinite_size Sentinel value denoting a dimension of unbounded/unknown size.
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.
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.
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.
variable expression_padded<Arg>::input_shape
variable expression_reverse<Arg>::input_shape
function expression_resource::instance()
function expression_resource_impl<E>::instance()
variable expression_handle<T, Dims>::instance Pointer to the concrete expression instance.
function interleave(const univector2d<Tin, Tag1, Tag2> &) Interleaves audio samples of a 2D univector into a new buffer.
function interleave(E1 &&, E2 &&) Creates an expression that interleaves the lanes of x and y.
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.
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
variable expression_linspace<T, truncated>::invsize
function ipow(E1 &&, E2 &&) Creates an expression that returns x raised to the integer power b.
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 tensor<T, NDims>::is_contiguous() Returns true if the tensor data is stored contiguously.
function tensor<T, NDims>::tensor_iterator::is_end() Returns true if this iterator is the end sentinel.
variable is_expr_element Inline variable that is true when T is a non-cv-qualified scalar vector element type.
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 tensor<T, NDims>::is_last_contiguous() Returns true if the last axis has stride 1.
variable is_output_expression Inline variable that is true when E satisfies output_expression .
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.
function tensor<T, NDims>::iterate(Fn &&) Calls fn for each element together with its multi-dimensional index.
typedef inline_vector<T, N>::iterator
typedef tensor<T, NDims>::iterator
typedef tensor<T, NDims>::tensor_iterator::iterator_category
typedef tensor<T, NDims>::nested_iterator_t::iterator_category
function itrunc(E1 &&) Creates an expression that returns the integer equivalent of trunc( x).

K¶

macro KFR_builtin_readcyclecounter

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 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.
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.
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.
function lt(E1 &&, E2 &&) Creates an expression that returns whether e1 is less than e2.

M¶

variable small_buffer<T, Capacity>::m_data Pointer to the active storage (inline or heap).
variable small_buffer<T, Capacity>::m_preallocated Inline storage for up to
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 inline_vector<T, N>::m_values Inline storage for the elements.
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_memory_finalizer(Fn &&) Creates a memory finalizer that invokes fn when the handle is destroyed.
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 tensor<T, NDims>::map(Fn &&) Applies fn to each element and returns the resulting tensor.
variable expression_with_arguments<Args>::masks Per-argument dimension masks computed from each argument's shape.
function matrix_transpose(T *, const T *, shape<Dims>) Transposes a matrix (supports scalar and compound types).
variable expression_random_range<T, Dims, Reference>::max
variable max_index_t Maximum representable value of index_t .
variable max_sindex_t Maximum representable value of signed_index_t .
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_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.
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.
typedef memory_finalizer Shared ownership handle for a memory finalizer.
variable expression_random_range<T, Dims, Reference>::min
function shape<Dims>::min(const shape<dims> &, const shape<dims> &) Element-wise minimum of two shapes.
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.
function minof(const E1 &) Returns the smallest of all the elements in x.
function mix(E1 &&, E2 &&, E3 &&) Creates an expression that returns the 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 modzerobessel(E1 &&) Creates an expression that returns the modified Bessel function of the first kind of order 0 of x.
variable expression_random_normal<T, Dims, Reference>::mu
function mul(E &&...) Creates an expression that returns the product of all the arguments passed to a function.

N¶

function ne(E1 &&, E2 &&) Creates an expression that returns whether e1 is not equal to e2.
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.
variable expression_vtable<T, Dims>::Nmax Largest supported block size.
function fraction::normalize() Reduce the fraction to lowest terms and enforce a positive denominator.
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 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.

O¶

enum constant npy_decode_result::ok Successfully loaded
function ones() Creates an expression that always evaluates to one.
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).
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 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 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 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 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 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 expression_resource_impl<E>::operator Aligned delete overload matching the aligned allocation in make_resource .
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.
operator fraction::operator Convert to float (exact value).
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).
function tensor<T, NDims>::tensor_iterator::operator++(int) Postfix increment.
function tensor<T, NDims>::nested_iterator_t::operator++(int) Postfix increment.
operator fraction::operator Convert to integer (truncates toward zero).
function random_state::operator=(random_state &&)
function histogram_data<Bins, TCount>::operator[](size_t) Returns the count in bin n.
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 small_buffer<T, Capacity>::operator[](std::size_t)
function small_buffer<T, Capacity>::operator[](std::size_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 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.
typedef opt_index_t Optional signed index used by tensor_range .
variable expression_reshape<Arg, OutDims>::out_shape
concept output_expression Concept satisfied by expressions that can be written to.

P¶

function pack(Args &&...) Creates an expression that packs several input expressions into a single vector-valued expression.
function padded(Arg &&, T) Creates an expression that extends arg with a constant fill value.
function placeholder(csize_t<Key>) Create an unbound expression_placeholder with the given key.
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
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.
function pow2(E1 &&) Creates an expression that returns x raised to the power of 2.
function pow3(E1 &&) Creates an expression that returns x raised to the power of 3.
function pow4(E1 &&) Creates an expression that returns x raised to the power of 4.
function pow5(E1 &&) Creates an expression that returns x raised to the power of 5.
function pow(E1 &&, E2 &&) Creates an expression that returns x raised to the given power y.
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 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 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 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 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.
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 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.

R¶

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
function random_bits(random_state &) Generates more than 16 bytes of random data.
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).
function real(E1 &&) Creates an expression that returns the real part of the complex value x.
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.
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.
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
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.
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.
struct representation<kfr::fraction> String representation specialization for fraction .
struct representation<kfr::npy_decode_result>
class representation<kfr::shape<dims>> String representation of a shape , used by as_string and the formatting framework.
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.
function tensor<T, NDims>::require_contiguous() Throws if the tensor is not contiguous.
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 reset(const expression_handle<T, NDims> &) Internal ADL-provided implementation for expression_handle expressions.
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 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 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.
function generator<T, VecWidth, Class, Twork>::resync(T) Reinitializes the generator state so that the next produced value corresponds to the given start.
function reverse(Arg &&) Creates an expression that exposes arg with its trailing dimension reversed.
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.
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.
function rms(const E1 &) Returns the root mean square of all the elements in x.
function root(E1 &&, E2 &&) Creates an expression that returns the real nth root of x.
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 round(E1 &&) Creates an expression that returns x rounded to the nearest integer.

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.
function satadd(E1 &&, E2 &&) Creates an expression that adds x and y using saturation.
function satsub(E1 &&, E2 &&) Creates an expression that subtracts y from x using saturation.
function save_to_npy(const tensor<T, Dims> &, Fn &&) Saves a tensor to .npy format using a custom write callback.
function scalar(T) Creates an expression that wraps a single value.
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 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 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 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_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(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 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.
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 expression_random_normal<T, Dims, Reference>::sigma
typedef signed_index_t Signed integer type used for tensor indices and axis sizes.
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 sink(E &&) Reads the expression expr through the whole range.
function shape<0>::size() Returns the number of elements (always 0).
variable expression_slice<Arg>::size
variable expression_linspace<T, truncated>::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 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_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 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 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 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
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.
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.
function sqr(E1 &&) Creates an expression that returns the square of x.
function sqrt(E1 &&) Creates an expression that returns the positive square root of x. \(\sqrt{x}\)
variable tensor<T, NDims>::tensor_iterator::src
variable tensor<T, NDims>::nested_iterator_t::src
typedef generator_expj<T, VecWidth>::ST
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
variable expression_random_uniform<T, Dims, Reference>::state
variable expression_random_range<T, Dims, Reference>::state
variable expression_random_normal<T, Dims, Reference>::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 &&)
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.
function stddev(const E1 &) Computes the standard deviation of the given expression.
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 expression_counter<T, Dims>::steps
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
typedef inline_vector<T, N>::stored_size_type Smallest unsigned integer able to hold values up to
function tensor<T, NDims>::strides() Returns the strides of the tensor.
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 shape<Dims>::sub(const shape<dims> &) Element-wise subtraction of two shapes.
function sub(E1 &&, E2 &&) Creates an expression that returns the difference between x and y.
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.
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.
function small_buffer<T, Capacity>::swap(small_buffer<T, Capacity> &, small_buffer<T, Capacity> &) Swaps the contents of two buffers.
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¶

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.
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<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<U>>>> &) 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<U>>> &) 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<U>> &) Initializes a 2D tensor from a braced list. Defined for 2D tensors only.
function tensor<T, NDims>::tensor<T, NDims>(const std::initializer_list<U> &) 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> &)
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 shape<Dims>::to_std_array() Convert the shape to a std::array.
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 shape<Dims> &) Converts a shape to a vector of unsigned integers.
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.
function histogram_data<Bins, TCount>::total() Returns the total number of values added to the histogram.
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
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 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 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.
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 trunc(E1 &&) Creates an expression that returns the integer part of x by removing its fractional part.
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 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 expression_with_arguments<Args>::type_list
typedef expression_with_arguments<Arg>::type_list

U¶

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.
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 (Unnamed enum at base/univector.hpp:42:1) Compile-time tags selecting the storage strategy of a univector .
function unpack(E &&...) Creates an expression that fans out a vector input into several output expressions.

V¶

variable random_state::v Internal 128-bit state stored as four 32-bit lanes.
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
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 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
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.
typedef histogram_data<Bins, TCount>::vector_type
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¶

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

Z¶

function zeros() Creates an expression that always evaluates to zero.

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