expressions¶

`expression_traits` class¶

template <typename T> expression_traits

template <has_expression_traits T> expression_traits

template <has_expression_traits T> expression_traits

template <has_expression_traits T> expression_traits

template <has_expression_traits T> expression_traits

template <has_expression_traits T> expression_traits

template <typename T> expression_traits

`expression_traits_defaults` class¶

expression_traits_defaults

`expression_traits` class¶

template <expr_element T> expression_traits

`anything` class (`internal_generic::anything`)¶

anything

`expression_with_arguments` class (`generic::expression_with_arguments`)¶

template <typename... Args> expression_with_arguments

template <typename Arg> expression_with_arguments

`expression_with_traits` class (`generic::expression_with_traits`)¶

template <typename Arg> expression_with_traits

`expression_function` class (`generic::expression_function`)¶

template <typename Fn, typename... Args> expression_function

`expression_discard` class (`generic::expression_discard`)¶

template <typename Tin, index_t Dims> expression_discard

`sink` function (`generic::sink`)¶

template <size_t width = 0, index_t Axis = infinite_size,
          typename E,
          typename Traits = expression_traits<E>>
const E &sink(E &&expr)

Read the expression expr through the whole range.
Param expr the input expression
Returns the input expression is returned

`rebind` function (`generic::rebind`)¶

template <typename Fn, typename... OldArgs,
          typename... NewArgs>
expression_function<Fn, NewArgs...>
rebind(const expression_function<Fn, OldArgs...> &e,
       NewArgs &&...args)

Construct a new expression using the same function as in e and new arguments
Param e an expression
Param args new arguments for the function

`add` function (`generic::add`)¶

template <typename... E>
  requires expression_arguments<E...>
expression_make_function<fn::add, E...> add(E &&...x)

Returns template expression that returns sum of all the arguments passed to a function.

`mul` function (`generic::mul`)¶

template <typename... E>
  requires expression_arguments<E...>
expression_make_function<fn::mul, E...> mul(E &&...x)

Returns template expression that returns product of all the arguments passed to a function.

`sqr` function (`generic::sqr`)¶

template <expression_argument E1>
expression_make_function<fn::sqr, E1> sqr(E1 &&x)

Returns template expression that returns square of x.

`cub` function (`generic::cub`)¶

template <expression_argument E1>
expression_make_function<fn::cub, E1> cub(E1 &&x)

Returns template expression that returns cube of x.

`make_complex` function (`generic::make_complex`)¶

template <typename E1, typename E2>
  requires expression_arguments<E1, E2>
expression_make_function<fn::make_complex, E1, E2>
make_complex(E1 &&re, E2 &&im)

Constructs complex value from real and imaginary parts

`real` function (`generic::real`)¶

template <expression_argument E1>
expression_make_function<fn::real, E1> real(E1 &&x)

Returns the real part of the complex value

`imag` function (`generic::imag`)¶

template <expression_argument E1>
expression_make_function<fn::imag, E1> imag(E1 &&x)

Returns the imaginary part of the complex value

`cconj` function (`generic::cconj`)¶

template <expression_argument E1>
expression_make_function<fn::cconj, E1> cconj(E1 &&x)

Returns template expression that returns the complex conjugate of the complex number x

`select` function (`generic::select`)¶

template <typename E1, typename E2, typename E3>
  requires expression_arguments<E1, E2, E3>
expression_make_function<fn::select, E1, E2, E3>
select(E1 &&m, E2 &&x, E3 &&y)

Returns template expression that returns x if m is true, otherwise return y. Order of the arguments is same as in ternary operator.

`abs` function (`generic::abs`)¶

template <expression_argument E1>
expression_make_function<fn::abs, E1> abs(E1 &&x)

Returns template expression that returns the absolute value of x.

`min` function (`generic::min`)¶

template <typename E1, typename E2>
  requires expression_arguments<E1, E2>
expression_make_function<fn::min, E1, E2> min(E1 &&x,
                                              E2 &&y)

Returns the smaller of two values. Accepts and returns expressions.

`max` function (`generic::max`)¶

template <typename E1, typename E2>
  requires expression_arguments<E1, E2>
expression_make_function<fn::max, E1, E2> max(E1 &&x,
                                              E2 &&y)

Returns the greater of two values. Accepts and returns expressions.

`absmin` function (`generic::absmin`)¶

template <typename E1, typename E2>
  requires expression_arguments<E1, E2>
expression_make_function<fn::absmin, E1, E2> absmin(E1 &&x,
                                                    E2 &&y)

Returns the smaller in magnitude of two values. Accepts and returns expressions.

`absmax` function (`generic::absmax`)¶

template <typename E1, typename E2>
  requires expression_arguments<E1, E2>
expression_make_function<fn::absmax, E1, E2> absmax(E1 &&x,
                                                    E2 &&y)

Returns the greater in magnitude of two values. Accepts and returns expressions.

`floor` function (`generic::floor`)¶

template <expression_argument E1>
expression_make_function<fn::floor, E1> floor(E1 &&x)

Returns the largest integer value not greater than x. Accepts and returns expressions.

`clamp` function (`generic::clamp`)¶

template <typename E1, typename E2, typename E3>
  requires expression_arguments<E1, E2, E3>
expression_make_function<fn::clamp, E1, E2, E3>
clamp(E1 &&x, E2 &&lo, E3 &&hi)

Creates an expression that returns the first argument clamped to a range [lo, hi]

template <typename E1, typename E2>
  requires expression_arguments<E1, E2>
expression_make_function<fn::clamp, E1, E2> clamp(E1 &&x,
                                                  E2 &&hi)

Creates an expression that returns the first argument clamped to a range [0, hi]

`satadd` function (`generic::satadd`)¶

template <typename E1, typename E2>
  requires expression_arguments<E1, E2>
expression_make_function<fn::satadd, E1, E2> satadd(E1 &&x,
                                                    E2 &&y)

Creates an expression that adds two arguments using saturation

`satsub` function (`generic::satsub`)¶

template <typename E1, typename E2>
  requires expression_arguments<E1, E2>
expression_make_function<fn::satsub, E1, E2> satsub(E1 &&x,
                                                    E2 &&y)

Creates an expression that subtracts two arguments using saturation

`expression_scalar` class¶

template <typename T> expression_scalar

`expression_traits` class¶

template <typename T> expression_traits

`expression_counter` class¶

template <typename T, index_t Dims = 1> expression_counter

`expression_traits` class¶

template <typename T, index_t Dims> expression_traits

`expression_slice` class¶

template <typename Arg> expression_slice

`expression_traits` class¶

template <typename Arg> expression_traits

`expression_cast` class¶

template <typename T, typename Arg> expression_cast

`expression_traits` class¶

template <typename T, typename Arg> expression_traits

`expression_lambda` class¶

template <typename T, index_t Dims, typename Fn, bool Rnd>
expression_lambda

`expression_traits` class¶

template <typename T, index_t Dims, typename Fn, bool Rnd>
expression_traits

`expression_padded` class¶

template <typename Arg> expression_padded

`expression_traits` class¶

template <typename Arg> expression_traits

`expression_reverse` class¶

template <typename Arg> expression_reverse

`expression_traits` class¶

template <typename Arg> expression_traits

`fixed_shape_t` class¶

template <index_t... Values> fixed_shape_t

`expression_fixshape` class¶

template <typename Arg, typename Shape> expression_fixshape

`expression_traits` class¶

template <typename Arg, index_t... ShapeValues>
expression_traits

`expression_reshape` class¶

template <typename Arg, index_t OutDims> expression_reshape

`expression_traits` class¶

template <typename Arg, index_t OutDims> expression_traits

`symmetric_linspace_t` class¶

symmetric_linspace_t

`expression_linspace` class¶

template <typename T, bool truncated = true>
expression_linspace

`expression_traits` class¶

template <typename T, bool truncated> expression_traits

`linspace` function¶

template <typename T = void, bool precise = false, bool truncated = false, typename T1, typename T2,
          typename Tout = or_type<T, ftype<std::common_type_t<T1, T2>>>>
 expression_linspace<Tout, truncated> linspace(T1 start, T2 stop, size_t size,
                                                            bool endpoint = false, cbool_t<truncated> =

Returns evenly spaced numbers over a specified interval.
Param start The starting value of the sequence
Param stop The end value of the sequence. if endpoint is false, the last value is excluded
Param size Number of samples to generate
Param endpoint If true, stop is the last sample. Otherwise, it is not included
Template param truncated If true, linspace returns exactly size elements, otherwise, returns infinite sequence
Template param precise No longer used since KFR5, calculations are always precise

`symmlinspace` function¶

template <typename T, bool precise = false, bool truncated = false, typename Tout = ftype<T>>
 expression_linspace<Tout, truncated> symmlinspace(T symsize, size_t size,
                                                                cbool_t<truncated> =

Returns evenly spaced numbers over a specified interval.
Param symsize The sequence will have interval [-symsize..symsize]
Param size Number of samples to generate
Template param truncated If true, linspace returns exactly size elements, otherwise, returns infinite sequence
Template param precise No longer used since KFR5, calculations are always precise

`expression_concatenate` class¶

template <typename Arg1, typename Arg2, index_t ConcatAxis>
expression_concatenate

`expression_traits` class¶

template <typename Arg1, typename Arg2, index_t ConcatAxis>
expression_traits

`expression_unpack` class (`generic::expression_unpack`)¶

template <typename... E> expression_unpack

`expression_adjacent` class (`generic::expression_adjacent`)¶

template <typename Fn, typename E> expression_adjacent

`adjacent` function (`generic::adjacent`)¶

template <typename Fn, typename E1>
expression_adjacent<Fn, E1> adjacent(Fn &&fn, E1 &&e1)

Returns template expression that returns the result of calling \(fn(x_i, x_{i-1})\)

`expression_trace` class (`generic::expression_trace`)¶

template <typename E> expression_trace

`trace` function (`generic::trace`)¶

template <typename E1> expression_trace<E1> trace(E1 &&e1)

Returns template expression that prints all processed values for debug

`expression_dimensions` class (`generic::expression_dimensions`)¶

template <index_t Dims, typename E> expression_dimensions

`dimensions` function (`generic::dimensions`)¶

template <index_t Dims, typename E1>
expression_dimensions<Dims, E1> dimensions(E1 &&e1)

Returns template expression with gien number of dimensions

`inline_vector` class¶

template <typename T, size_t N> inline_vector

`static_array_base` class¶

template <typename T, typename indices_t> static_array_base

template <typename T, size_t... indices> static_array_base

`static_array_base` class (`static_array_base::static_array_base`)¶

template <typename U, typename otherindices_t>
static_array_base

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

expressions¶

expression_traits class¶

expression_traits_defaults class¶

expression_traits class¶

anything class (internal_generic::anything)¶

expression_with_arguments class (generic::expression_with_arguments)¶

expression_with_traits class (generic::expression_with_traits)¶

expression_function class (generic::expression_function)¶

expression_discard class (generic::expression_discard)¶

sink function (generic::sink)¶

rebind function (generic::rebind)¶

add function (generic::add)¶

mul function (generic::mul)¶

sqr function (generic::sqr)¶

cub function (generic::cub)¶

make_complex function (generic::make_complex)¶

real function (generic::real)¶

imag function (generic::imag)¶

cconj function (generic::cconj)¶

select function (generic::select)¶

abs function (generic::abs)¶

min function (generic::min)¶

max function (generic::max)¶

absmin function (generic::absmin)¶

absmax function (generic::absmax)¶

floor function (generic::floor)¶

clamp function (generic::clamp)¶

satadd function (generic::satadd)¶

satsub function (generic::satsub)¶

expression_scalar class¶

expression_traits class¶

expression_counter class¶

expression_traits class¶

expression_slice class¶

expression_traits class¶

expression_cast class¶

expression_traits class¶

expression_lambda class¶

expression_traits class¶

expression_padded class¶

expression_traits class¶

expression_reverse class¶

expression_traits class¶

fixed_shape_t class¶

expression_fixshape class¶

expression_traits class¶

expression_reshape class¶

expression_traits class¶

symmetric_linspace_t class¶

expression_linspace class¶

expression_traits class¶

linspace function¶

symmlinspace function¶

expression_concatenate class¶

expression_traits class¶

expression_unpack class (generic::expression_unpack)¶

expression_adjacent class (generic::expression_adjacent)¶

adjacent function (generic::adjacent)¶

expression_trace class (generic::expression_trace)¶

trace function (generic::trace)¶

expression_dimensions class (generic::expression_dimensions)¶

dimensions function (generic::dimensions)¶

inline_vector class¶

static_array_base class¶

static_array_base class (static_array_base::static_array_base)¶

`expression_traits` class¶

`expression_traits_defaults` class¶

`expression_traits` class¶

`anything` class (`internal_generic::anything`)¶

`expression_with_arguments` class (`generic::expression_with_arguments`)¶

`expression_with_traits` class (`generic::expression_with_traits`)¶

`expression_function` class (`generic::expression_function`)¶

`expression_discard` class (`generic::expression_discard`)¶

`sink` function (`generic::sink`)¶

`rebind` function (`generic::rebind`)¶

`add` function (`generic::add`)¶

`mul` function (`generic::mul`)¶

`sqr` function (`generic::sqr`)¶

`cub` function (`generic::cub`)¶

`make_complex` function (`generic::make_complex`)¶

`real` function (`generic::real`)¶

`imag` function (`generic::imag`)¶

`cconj` function (`generic::cconj`)¶

`select` function (`generic::select`)¶

`abs` function (`generic::abs`)¶

`min` function (`generic::min`)¶

`max` function (`generic::max`)¶

`absmin` function (`generic::absmin`)¶

`absmax` function (`generic::absmax`)¶

`floor` function (`generic::floor`)¶

`clamp` function (`generic::clamp`)¶

`satadd` function (`generic::satadd`)¶

`satsub` function (`generic::satsub`)¶

`expression_scalar` class¶

`expression_traits` class¶

`expression_counter` class¶

`expression_traits` class¶

`expression_slice` class¶

`expression_traits` class¶

`expression_cast` class¶

`expression_traits` class¶

`expression_lambda` class¶

`expression_traits` class¶

`expression_padded` class¶

`expression_traits` class¶

`expression_reverse` class¶

`expression_traits` class¶

`fixed_shape_t` class¶

`expression_fixshape` class¶

`expression_traits` class¶

`expression_reshape` class¶

`expression_traits` class¶

`symmetric_linspace_t` class¶

`expression_linspace` class¶

`expression_traits` class¶

`linspace` function¶

`symmlinspace` function¶

`expression_concatenate` class¶

`expression_traits` class¶

`expression_unpack` class (`generic::expression_unpack`)¶

`expression_adjacent` class (`generic::expression_adjacent`)¶

`adjacent` function (`generic::adjacent`)¶

`expression_trace` class (`generic::expression_trace`)¶

`trace` function (`generic::trace`)¶

`expression_dimensions` class (`generic::expression_dimensions`)¶

`dimensions` function (`generic::dimensions`)¶

`inline_vector` class¶

`static_array_base` class¶

`static_array_base` class (`static_array_base::static_array_base`)¶