kfr

Fast, modern C++ DSP framework, FFT, Sample Rate Conversion, FIR/IIR/Biquad Filters (SSE, AVX, AVX-512, ARM NEON)
Log | Files | Refs | README

commit 6851173e724382fada196c2e594766184cc6837a
parent f10ea53776425ae4ac173bad6144b32908e91e4f
Author: d.levin256@gmail.com <d.levin256@gmail.com>
Date:   Wed, 13 Dec 2023 07:11:53 +0000

Pass scalars directly

Diffstat:
Minclude/kfr/base/basic_expressions.hpp | 2+-
Minclude/kfr/base/expression.hpp | 15++++++++++++---
Minclude/kfr/base/math_expressions.hpp | 124++++++++++++++++++++++++++++++++++++++++----------------------------------------
Minclude/kfr/base/simd_expressions.hpp | 114++++++++++++++++++++++++++++++++++++++++----------------------------------------
Minclude/kfr/cometa.hpp | 7+++++++
5 files changed, 139 insertions(+), 123 deletions(-)

diff --git a/include/kfr/base/basic_expressions.hpp b/include/kfr/base/basic_expressions.hpp @@ -872,7 +872,7 @@ KFR_INTRINSIC vec<T, N> get_elements(const expression_concatenate<Arg1, Arg2, Co // ---------------------------------------------------------------------------- template <typename... Args> -using expression_pack = expression_function<fn::packtranspose, Args...>; +using expression_pack = expression_make_function<fn::packtranspose, Args...>; template <typename... Args, KFR_ACCEPT_EXPRESSIONS(Args...)> KFR_INTRINSIC expression_pack<Args...> pack(Args&&... args) diff --git a/include/kfr/base/expression.hpp b/include/kfr/base/expression.hpp @@ -280,6 +280,12 @@ KFR_INTRINSIC void set_elements(T& self, const shape<0>& index, const axis_param self = val.front(); } +template <typename T> +constexpr inline bool is_arg = is_numeric_or_bool<std::decay_t<T>>; + +template <typename T> +using arg = std::conditional_t<is_arg<T>, std::decay_t<T>, T>; + template <typename... Args> struct expression_with_arguments { @@ -336,7 +342,7 @@ struct expression_with_arguments return fold_idx_impl(std::forward<Fn>(fn), csizeseq<count>); } - KFR_INTRINSIC expression_with_arguments(Args&&... args) : args{ std::forward<Args>(args)... } + KFR_INTRINSIC expression_with_arguments(arg<Args&&>... args) : args{ std::forward<Args>(args)... } { cforeach(csizeseq<count>, [&](auto idx_) CMT_INLINE_LAMBDA @@ -496,11 +502,11 @@ struct expression_function : expression_with_arguments<Args...>, expression_trai : expression_with_arguments<Args...>{ std::move(args) }, fn(std::forward<Fn>(fn)) { } - KFR_MEM_INTRINSIC expression_function(Fn&& fn, Args&&... args) + KFR_MEM_INTRINSIC expression_function(Fn&& fn, arg<Args&&>... args) : expression_with_arguments<Args...>{ std::forward<Args>(args)... }, fn(std::forward<Fn>(fn)) { } - KFR_MEM_INTRINSIC expression_function(Args&&... args) + KFR_MEM_INTRINSIC expression_function(arg<Args&&>... args) : expression_with_arguments<Args...>{ std::forward<Args>(args)... }, fn{} { } @@ -522,6 +528,9 @@ expression_function(expression_with_arguments<Args...>&& args, Fn&& fn) -> expre template <typename... Args, typename Fn> expression_function(expression_with_arguments<Args...>& args, Fn&& fn) -> expression_function<Fn, Args...>; +template <typename Fn, typename... Args> +using expression_make_function = expression_function<Fn, arg<Args>...>; + namespace internal { diff --git a/include/kfr/base/math_expressions.hpp b/include/kfr/base/math_expressions.hpp @@ -36,7 +36,7 @@ namespace kfr * @brief Returns the trigonometric sine of x. Accepts and returns expressions. */ template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::sin, E1> sin(E1&& x) +KFR_FUNCTION expression_make_function<fn::sin, E1> sin(E1&& x) { return { fn::sin(), std::forward<E1>(x) }; } @@ -45,7 +45,7 @@ KFR_FUNCTION expression_function<fn::sin, E1> sin(E1&& x) * @brief Returns the trigonometric cosine of x. Accepts and returns expressions. */ template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::cos, E1> cos(E1&& x) +KFR_FUNCTION expression_make_function<fn::cos, E1> cos(E1&& x) { return { fn::cos(), std::forward<E1>(x) }; } @@ -54,7 +54,7 @@ KFR_FUNCTION expression_function<fn::cos, E1> cos(E1&& x) * @brief Returns an approximation of the trigonometric sine of x. Accepts and returns expressions. */ template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::fastsin, E1> fastsin(E1&& x) +KFR_FUNCTION expression_make_function<fn::fastsin, E1> fastsin(E1&& x) { return { fn::fastsin(), std::forward<E1>(x) }; } @@ -63,7 +63,7 @@ KFR_FUNCTION expression_function<fn::fastsin, E1> fastsin(E1&& x) * @brief Returns an approximation of the trigonometric cosine of x. Accepts and returns expressions. */ template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::fastcos, E1> fastcos(E1&& x) +KFR_FUNCTION expression_make_function<fn::fastcos, E1> fastcos(E1&& x) { return { fn::fastcos(), std::forward<E1>(x) }; } @@ -73,7 +73,7 @@ KFR_FUNCTION expression_function<fn::fastcos, E1> fastcos(E1&& x) * cosine of the odd elements. x must be a vector. Accepts and returns expressions. */ template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::sincos, E1> sincos(E1&& x) +KFR_FUNCTION expression_make_function<fn::sincos, E1> sincos(E1&& x) { return { fn::sincos(), std::forward<E1>(x) }; } @@ -83,7 +83,7 @@ KFR_FUNCTION expression_function<fn::sincos, E1> sincos(E1&& x) * sine of the odd elements. x must be a vector. Accepts and returns expressions. */ template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::cossin, E1> cossin(E1&& x) +KFR_FUNCTION expression_make_function<fn::cossin, E1> cossin(E1&& x) { return { fn::cossin(), std::forward<E1>(x) }; } @@ -92,7 +92,7 @@ KFR_FUNCTION expression_function<fn::cossin, E1> cossin(E1&& x) * @brief Returns the trigonometric sine of the x (expressed in degrees). Accepts and returns expressions. */ template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::sindeg, E1> sindeg(E1&& x) +KFR_FUNCTION expression_make_function<fn::sindeg, E1> sindeg(E1&& x) { return { fn::sindeg(), std::forward<E1>(x) }; } @@ -101,7 +101,7 @@ KFR_FUNCTION expression_function<fn::sindeg, E1> sindeg(E1&& x) * @brief Returns the trigonometric cosine of the x (expressed in degrees). Accepts and returns expressions. */ template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::cosdeg, E1> cosdeg(E1&& x) +KFR_FUNCTION expression_make_function<fn::cosdeg, E1> cosdeg(E1&& x) { return { fn::cosdeg(), std::forward<E1>(x) }; } @@ -111,7 +111,7 @@ KFR_FUNCTION expression_function<fn::cosdeg, E1> cosdeg(E1&& x) * (expressed in degrees). Accepts and returns expressions. */ template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::fastsindeg, E1> fastsindeg(E1&& x) +KFR_FUNCTION expression_make_function<fn::fastsindeg, E1> fastsindeg(E1&& x) { return { fn::fastsindeg(), std::forward<E1>(x) }; } @@ -121,7 +121,7 @@ KFR_FUNCTION expression_function<fn::fastsindeg, E1> fastsindeg(E1&& x) * (expressed in degrees). Accepts and returns expressions. */ template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::fastcosdeg, E1> fastcosdeg(E1&& x) +KFR_FUNCTION expression_make_function<fn::fastcosdeg, E1> fastcosdeg(E1&& x) { return { fn::fastcosdeg(), std::forward<E1>(x) }; } @@ -131,7 +131,7 @@ KFR_FUNCTION expression_function<fn::fastcosdeg, E1> fastcosdeg(E1&& x) * cosine of the odd elements. x must be expressed in degrees. Accepts and returns expressions. */ template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::sincosdeg, E1> sincosdeg(E1&& x) +KFR_FUNCTION expression_make_function<fn::sincosdeg, E1> sincosdeg(E1&& x) { return { fn::sincosdeg(), std::forward<E1>(x) }; } @@ -141,7 +141,7 @@ KFR_FUNCTION expression_function<fn::sincosdeg, E1> sincosdeg(E1&& x) * sine of the odd elements. x must be expressed in degrees. Accepts and returns expressions. */ template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::cossindeg, E1> cossindeg(E1&& x) +KFR_FUNCTION expression_make_function<fn::cossindeg, E1> cossindeg(E1&& x) { return { fn::cossindeg(), std::forward<E1>(x) }; } @@ -150,21 +150,21 @@ KFR_FUNCTION expression_function<fn::cossindeg, E1> cossindeg(E1&& x) * @brief Returns the sinc function of x. Accepts and returns expressions. */ template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::sinc, E1> sinc(E1&& x) +KFR_FUNCTION expression_make_function<fn::sinc, E1> sinc(E1&& x) { return { fn::sinc(), std::forward<E1>(x) }; } /// @brief Creates expression that returns the approximate gamma function of an argument template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::gamma, E1> gamma(E1&& x) +KFR_FUNCTION expression_make_function<fn::gamma, E1> gamma(E1&& x) { return { fn::gamma(), std::forward<E1>(x) }; } /// @brief Creates expression that returns the approximate factorial of an argument template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::factorial_approx, E1> factorial_approx(E1&& x) +KFR_FUNCTION expression_make_function<fn::factorial_approx, E1> factorial_approx(E1&& x) { return { fn::factorial_approx(), std::forward<E1>(x) }; } @@ -173,19 +173,19 @@ KFR_FUNCTION expression_function<fn::factorial_approx, E1> factorial_approx(E1&& * @brief Returns template expression that returns the positive square root of the x. \f$\sqrt{x}\f$ */ template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::sqrt, E1> sqrt(E1&& x) +KFR_FUNCTION expression_make_function<fn::sqrt, E1> sqrt(E1&& x) { return { fn::sqrt(), std::forward<E1>(x) }; } template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::tan, E1> tan(E1&& x) +KFR_FUNCTION expression_make_function<fn::tan, E1> tan(E1&& x) { return { fn::tan(), std::forward<E1>(x) }; } template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::tandeg, E1> tandeg(E1&& x) +KFR_FUNCTION expression_make_function<fn::tandeg, E1> tandeg(E1&& x) { return { fn::tandeg(), std::forward<E1>(x) }; } @@ -194,7 +194,7 @@ KFR_FUNCTION expression_function<fn::tandeg, E1> tandeg(E1&& x) * @brief Returns template expression that returns the arc sine of x. */ template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_INTRINSIC expression_function<fn::asin, E1> asin(E1&& x) +KFR_INTRINSIC expression_make_function<fn::asin, E1> asin(E1&& x) { return { fn::asin(), std::forward<E1>(x) }; } @@ -203,35 +203,35 @@ KFR_INTRINSIC expression_function<fn::asin, E1> asin(E1&& x) * @brief Returns template expression that returns the arc cosine of x. */ template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_INTRINSIC expression_function<fn::acos, E1> acos(E1&& x) +KFR_INTRINSIC expression_make_function<fn::acos, E1> acos(E1&& x) { return { fn::acos(), std::forward<E1>(x) }; } /// @brief Returns template expression that returns the sine of the the complex value x template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::csin, E1> csin(E1&& x) +KFR_FUNCTION expression_make_function<fn::csin, E1> csin(E1&& x) { return { fn::csin(), std::forward<E1>(x) }; } /// @brief Returns template expression that returns the hyperbolic sine of the complex number x template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::csinh, E1> csinh(E1&& x) +KFR_FUNCTION expression_make_function<fn::csinh, E1> csinh(E1&& x) { return { fn::csinh(), std::forward<E1>(x) }; } /// @brief Returns template expression that returns the cosine of the the complex value x template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::ccos, E1> ccos(E1&& x) +KFR_FUNCTION expression_make_function<fn::ccos, E1> ccos(E1&& x) { return { fn::ccos(), std::forward<E1>(x) }; } /// @brief Returns template expression that returns the hyperbolic cosine of the the complex value x template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::ccosh, E1> ccosh(E1&& x) +KFR_FUNCTION expression_make_function<fn::ccosh, E1> ccosh(E1&& x) { return { fn::ccosh(), std::forward<E1>(x) }; } @@ -239,91 +239,91 @@ KFR_FUNCTION expression_function<fn::ccosh, E1> ccosh(E1&& x) /// @brief Returns template expression that returns the squared absolute value (magnitude squared) of the /// complex number x template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::cabssqr, E1> cabssqr(E1&& x) +KFR_FUNCTION expression_make_function<fn::cabssqr, E1> cabssqr(E1&& x) { return { fn::cabssqr(), std::forward<E1>(x) }; } /// @brief Returns template expression that returns the absolute value (magnitude) of the complex number x template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::cabs, E1> cabs(E1&& x) +KFR_FUNCTION expression_make_function<fn::cabs, E1> cabs(E1&& x) { return { fn::cabs(), std::forward<E1>(x) }; } /// @brief Returns template expression that returns the phase angle (argument) of the complex number x template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::carg, E1> carg(E1&& x) +KFR_FUNCTION expression_make_function<fn::carg, E1> carg(E1&& x) { return { fn::carg(), std::forward<E1>(x) }; } /// @brief Returns template expression that returns the natural logarithm of the complex number x template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::clog, E1> clog(E1&& x) +KFR_FUNCTION expression_make_function<fn::clog, E1> clog(E1&& x) { return { fn::clog(), std::forward<E1>(x) }; } /// @brief Returns template expression that returns the binary (base-2) logarithm of the complex number x template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::clog2, E1> clog2(E1&& x) +KFR_FUNCTION expression_make_function<fn::clog2, E1> clog2(E1&& x) { return { fn::clog2(), std::forward<E1>(x) }; } /// @brief Returns template expression that returns the common (base-10) logarithm of the complex number x template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::clog10, E1> clog10(E1&& x) +KFR_FUNCTION expression_make_function<fn::clog10, E1> clog10(E1&& x) { return { fn::clog10(), std::forward<E1>(x) }; } /// @brief Returns template expression that returns \f$e\f$ raised to the complex number x template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::cexp, E1> cexp(E1&& x) +KFR_FUNCTION expression_make_function<fn::cexp, E1> cexp(E1&& x) { return { fn::cexp(), std::forward<E1>(x) }; } /// @brief Returns template expression that returns 2 raised to the complex number x template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::cexp2, E1> cexp2(E1&& x) +KFR_FUNCTION expression_make_function<fn::cexp2, E1> cexp2(E1&& x) { return { fn::cexp2(), std::forward<E1>(x) }; } /// @brief Returns template expression that returns 10 raised to the complex number x template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::cexp10, E1> cexp10(E1&& x) +KFR_FUNCTION expression_make_function<fn::cexp10, E1> cexp10(E1&& x) { return { fn::cexp10(), std::forward<E1>(x) }; } /// @brief Returns template expression that converts complex number to polar template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::polar, E1> polar(E1&& x) +KFR_FUNCTION expression_make_function<fn::polar, E1> polar(E1&& x) { return { fn::polar(), std::forward<E1>(x) }; } /// @brief Returns template expression that converts complex number to cartesian template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::cartesian, E1> cartesian(E1&& x) +KFR_FUNCTION expression_make_function<fn::cartesian, E1> cartesian(E1&& x) { return { fn::cartesian(), std::forward<E1>(x) }; } /// @brief Returns template expression that returns square root of the complex number x template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::csqrt, E1> csqrt(E1&& x) +KFR_FUNCTION expression_make_function<fn::csqrt, E1> csqrt(E1&& x) { return { fn::csqrt(), std::forward<E1>(x) }; } /// @brief Returns template expression that returns square of the complex number x template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::csqr, E1> csqr(E1&& x) +KFR_FUNCTION expression_make_function<fn::csqr, E1> csqr(E1&& x) { return { fn::csqr(), std::forward<E1>(x) }; } @@ -332,7 +332,7 @@ KFR_FUNCTION expression_function<fn::csqr, E1> csqr(E1&& x) * @brief Returns template expression that returns the arc tangent of x. */ template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::atan, E1> atan(E1&& x) +KFR_FUNCTION expression_make_function<fn::atan, E1> atan(E1&& x) { return { fn::atan(), std::forward<E1>(x) }; } @@ -341,7 +341,7 @@ KFR_FUNCTION expression_function<fn::atan, E1> atan(E1&& x) * @brief Returns template expression that returns the arc tangent of the x, expressed in degrees. */ template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::atandeg, E1> atandeg(E1&& x) +KFR_FUNCTION expression_make_function<fn::atandeg, E1> atandeg(E1&& x) { return { fn::atandeg(), std::forward<E1>(x) }; } @@ -350,7 +350,7 @@ KFR_FUNCTION expression_function<fn::atandeg, E1> atandeg(E1&& x) * @brief Returns template expression that returns the arc tangent of y/x. */ template <typename E1, typename E2, KFR_ACCEPT_EXPRESSIONS(E1, E2)> -KFR_FUNCTION expression_function<fn::atan2, E1, E2> atan2(E1&& x, E2&& y) +KFR_FUNCTION expression_make_function<fn::atan2, E1, E2> atan2(E1&& x, E2&& y) { return { fn::atan2(), std::forward<E1>(x), std::forward<E2>(y) }; } @@ -359,41 +359,41 @@ KFR_FUNCTION expression_function<fn::atan2, E1, E2> atan2(E1&& x, E2&& y) * @brief Returns template expression that returns the arc tangent of y/x (expressed in degrees). */ template <typename E1, typename E2, KFR_ACCEPT_EXPRESSIONS(E1, E2)> -KFR_FUNCTION expression_function<fn::atan2deg, E1, E2> atan2deg(E1&& x, E2&& y) +KFR_FUNCTION expression_make_function<fn::atan2deg, E1, E2> atan2deg(E1&& x, E2&& y) { return { fn::atan2deg(), std::forward<E1>(x), std::forward<E2>(y) }; } template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::modzerobessel, E1> modzerobessel(E1&& x) +KFR_FUNCTION expression_make_function<fn::modzerobessel, E1> modzerobessel(E1&& x) { return { fn::modzerobessel(), std::forward<E1>(x) }; } /// @brief Returns template expression that returns the hyperbolic sine of the x template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::sinh, E1> sinh(E1&& x) +KFR_FUNCTION expression_make_function<fn::sinh, E1> sinh(E1&& x) { return { fn::sinh(), std::forward<E1>(x) }; } /// @brief Returns template expression that returns the hyperbolic cosine of the x template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::cosh, E1> cosh(E1&& x) +KFR_FUNCTION expression_make_function<fn::cosh, E1> cosh(E1&& x) { return { fn::cosh(), std::forward<E1>(x) }; } /// @brief Returns template expression that returns the hyperbolic tangent of the x template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::tanh, E1> tanh(E1&& x) +KFR_FUNCTION expression_make_function<fn::tanh, E1> tanh(E1&& x) { return { fn::tanh(), std::forward<E1>(x) }; } /// @brief Returns template expression that returns the hyperbolic cotangent of the x template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::coth, E1> coth(E1&& x) +KFR_FUNCTION expression_make_function<fn::coth, E1> coth(E1&& x) { return { fn::coth(), std::forward<E1>(x) }; } @@ -401,7 +401,7 @@ KFR_FUNCTION expression_function<fn::coth, E1> coth(E1&& x) /// @brief Returns template expression that returns the hyperbolic sine of the even elements of the x and the /// hyperbolic cosine of the odd elements of the x template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::sinhcosh, E1> sinhcosh(E1&& x) +KFR_FUNCTION expression_make_function<fn::sinhcosh, E1> sinhcosh(E1&& x) { return { fn::sinhcosh(), std::forward<E1>(x) }; } @@ -409,49 +409,49 @@ KFR_FUNCTION expression_function<fn::sinhcosh, E1> sinhcosh(E1&& x) /// @brief Returns template expression that returns the hyperbolic cosine of the even elements of the x and /// the hyperbolic sine of the odd elements of the x template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::coshsinh, E1> coshsinh(E1&& x) +KFR_FUNCTION expression_make_function<fn::coshsinh, E1> coshsinh(E1&& x) { return { fn::coshsinh(), std::forward<E1>(x) }; } /// @brief Returns e raised to the given power x. Accepts and returns expressions. template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::exp, E1> exp(E1&& x) +KFR_FUNCTION expression_make_function<fn::exp, E1> exp(E1&& x) { return { fn::exp(), std::forward<E1>(x) }; } /// @brief Returns 2 raised to the given power x. Accepts and returns expressions. template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::exp2, E1> exp2(E1&& x) +KFR_FUNCTION expression_make_function<fn::exp2, E1> exp2(E1&& x) { return { fn::exp2(), std::forward<E1>(x) }; } /// @brief Returns 10 raised to the given power x. Accepts and returns expressions. template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::exp10, E1> exp10(E1&& x) +KFR_FUNCTION expression_make_function<fn::exp10, E1> exp10(E1&& x) { return { fn::exp10(), std::forward<E1>(x) }; } /// @brief Returns the natural logarithm of the x. Accepts and returns expressions. template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::log, E1> log(E1&& x) +KFR_FUNCTION expression_make_function<fn::log, E1> log(E1&& x) { return { fn::log(), std::forward<E1>(x) }; } /// @brief Returns the binary (base-2) logarithm of the x. Accepts and returns expressions. template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::log2, E1> log2(E1&& x) +KFR_FUNCTION expression_make_function<fn::log2, E1> log2(E1&& x) { return { fn::log2(), std::forward<E1>(x) }; } /// @brief Returns the common (base-10) logarithm of the x. Accepts and returns expressions. template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::log10, E1> log10(E1&& x) +KFR_FUNCTION expression_make_function<fn::log10, E1> log10(E1&& x) { return { fn::log10(), std::forward<E1>(x) }; } @@ -459,56 +459,56 @@ KFR_FUNCTION expression_function<fn::log10, E1> log10(E1&& x) /// @brief Returns the rounded binary (base-2) logarithm of the x. Version that accepts and returns /// expressions. template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::logb, E1> logb(E1&& x) +KFR_FUNCTION expression_make_function<fn::logb, E1> logb(E1&& x) { return { fn::logb(), std::forward<E1>(x) }; } /// @brief Returns the logarithm of the x with base y. Accepts and returns expressions. template <typename E1, typename E2, KFR_ACCEPT_EXPRESSIONS(E1, E2)> -KFR_FUNCTION expression_function<fn::logn, E1, E2> logn(E1&& x, E2&& y) +KFR_FUNCTION expression_make_function<fn::logn, E1, E2> logn(E1&& x, E2&& y) { return { fn::logn(), std::forward<E1>(x), std::forward<E2>(y) }; } /// @brief Returns log(x) * y. Accepts and returns expressions. template <typename E1, typename E2, KFR_ACCEPT_EXPRESSIONS(E1, E2)> -KFR_FUNCTION expression_function<fn::logm, E1, E2> logm(E1&& x, E2&& y) +KFR_FUNCTION expression_make_function<fn::logm, E1, E2> logm(E1&& x, E2&& y) { return { fn::logm(), std::forward<E1>(x), std::forward<E2>(y) }; } /// @brief Returns exp(x * m + a). Accepts and returns expressions. template <typename E1, typename E2, typename E3, KFR_ACCEPT_EXPRESSIONS(E1, E2, E3)> -KFR_FUNCTION expression_function<fn::exp_fmadd, E1, E2, E3> exp_fmadd(E1&& x, E2&& y, E3&& z) +KFR_FUNCTION expression_make_function<fn::exp_fmadd, E1, E2, E3> exp_fmadd(E1&& x, E2&& y, E3&& z) { return { fn::exp_fmadd(), std::forward<E1>(x), std::forward<E2>(y), std::forward<E3>(z) }; } /// @brief Returns log(x) * m + a. Accepts and returns expressions. template <typename E1, typename E2, typename E3, KFR_ACCEPT_EXPRESSIONS(E1, E2, E3)> -KFR_FUNCTION expression_function<fn::log_fmadd, E1, E2, E3> log_fmadd(E1&& x, E2&& y, E3&& z) +KFR_FUNCTION expression_make_function<fn::log_fmadd, E1, E2, E3> log_fmadd(E1&& x, E2&& y, E3&& z) { return { fn::log_fmadd(), std::forward<E1>(x), std::forward<E2>(y), std::forward<E3>(z) }; } /// @brief Returns the x raised to the given power y. Accepts and returns expressions. template <typename E1, typename E2, KFR_ACCEPT_EXPRESSIONS(E1, E2)> -KFR_FUNCTION expression_function<fn::pow, E1, E2> pow(E1&& x, E2&& y) +KFR_FUNCTION expression_make_function<fn::pow, E1, E2> pow(E1&& x, E2&& y) { return { fn::pow(), std::forward<E1>(x), std::forward<E2>(y) }; } /// @brief Returns the real nth root of the x. Accepts and returns expressions. template <typename E1, typename E2, KFR_ACCEPT_EXPRESSIONS(E1, E2)> -KFR_FUNCTION expression_function<fn::root, E1, E2> root(E1&& x, E2&& y) +KFR_FUNCTION expression_make_function<fn::root, E1, E2> root(E1&& x, E2&& y) { return { fn::root(), std::forward<E1>(x), std::forward<E2>(y) }; } /// @brief Returns the cube root of the x. Accepts and returns expressions. template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::cbrt, E1> cbrt(E1&& x) +KFR_FUNCTION expression_make_function<fn::cbrt, E1> cbrt(E1&& x) { return { fn::cbrt(), std::forward<E1>(x) }; } diff --git a/include/kfr/base/simd_expressions.hpp b/include/kfr/base/simd_expressions.hpp @@ -49,13 +49,13 @@ inline namespace CMT_ARCH_NAME * @brief Returns template expression that returns sum of all the arguments passed to a function. */ template <typename... E, KFR_ACCEPT_EXPRESSIONS(E...)> -KFR_INTRINSIC expression_function<fn::add, E...> add(E&&... x) +KFR_INTRINSIC expression_make_function<fn::add, E...> add(E&&... x) { return { fn::add(), std::forward<E>(x)... }; } template <typename E1, typename E2, KFR_ACCEPT_EXPRESSIONS(E1, E2)> -KFR_INTRINSIC expression_function<fn::sub, E1, E2> sub(E1&& x, E2&& y) +KFR_INTRINSIC expression_make_function<fn::sub, E1, E2> sub(E1&& x, E2&& y) { return { fn::sub(), std::forward<E1>(x), std::forward<E2>(y) }; } @@ -64,102 +64,102 @@ KFR_INTRINSIC expression_function<fn::sub, E1, E2> sub(E1&& x, E2&& y) * @brief Returns template expression that returns product of all the arguments passed to a function. */ template <typename... E, KFR_ACCEPT_EXPRESSIONS(E...)> -KFR_INTRINSIC expression_function<fn::mul, E...> mul(E&&... x) +KFR_INTRINSIC expression_make_function<fn::mul, E...> mul(E&&... x) { return { fn::mul(), std::forward<E>(x)... }; } template <typename E1, typename E2, KFR_ACCEPT_EXPRESSIONS(E1, E2)> -KFR_INTRINSIC expression_function<fn::ipow, E1, E2> ipow(E1&& x, E2&& b) +KFR_INTRINSIC expression_make_function<fn::ipow, E1, E2> ipow(E1&& x, E2&& b) { return { fn::ipow(), std::forward<E1>(x), std::forward<E2>(b) }; } template <typename E1, typename E2, typename E3, KFR_ACCEPT_EXPRESSIONS(E1, E2, E3)> -KFR_INTRINSIC expression_function<fn::mix, E1, E2, E3> mix(E1&& c, E2&& x, E3&& y) +KFR_INTRINSIC expression_make_function<fn::mix, E1, E2, E3> mix(E1&& c, E2&& x, E3&& y) { return { fn::mix(), std::forward<E1>(c), std::forward<E2>(x), std::forward<E3>(y) }; } template <typename E1, typename E2, typename E3, KFR_ACCEPT_EXPRESSIONS(E1, E2, E3)> -KFR_INTRINSIC expression_function<fn::mixs, E1, E2, E3> mixs(E1&& c, E2&& x, E3&& y) +KFR_INTRINSIC expression_make_function<fn::mixs, E1, E2, E3> mixs(E1&& c, E2&& x, E3&& y) { return { fn::mixs(), std::forward<E1>(c), std::forward<E2>(x), std::forward<E3>(y) }; } template <typename... E, KFR_ACCEPT_EXPRESSIONS(E...)> -KFR_INTRINSIC expression_function<fn::horner, E...> horner(E&&... x) +KFR_INTRINSIC expression_make_function<fn::horner, E...> horner(E&&... x) { return { fn::horner(), std::forward<E>(x)... }; } template <typename... E, KFR_ACCEPT_EXPRESSIONS(E...)> -KFR_INTRINSIC expression_function<fn::horner_even, E...> horner_even(E&&... x) +KFR_INTRINSIC expression_make_function<fn::horner_even, E...> horner_even(E&&... x) { return { fn::horner_even(), std::forward<E>(x)... }; } template <typename... E, KFR_ACCEPT_EXPRESSIONS(E...)> -KFR_INTRINSIC expression_function<fn::horner_odd, E...> horner_odd(E&&... x) +KFR_INTRINSIC expression_make_function<fn::horner_odd, E...> horner_odd(E&&... x) { return { fn::horner_odd(), std::forward<E>(x)... }; } template <typename E1, typename E2, KFR_ACCEPT_EXPRESSIONS(E1, E2)> -KFR_INTRINSIC expression_function<fn::add, E1, E2> operator+(E1&& e1, E2&& e2) +KFR_INTRINSIC expression_make_function<fn::add, E1, E2> operator+(E1&& e1, E2&& e2) { return { fn::add(), std::forward<E1>(e1), std::forward<E2>(e2) }; } template <typename E1, typename E2, KFR_ACCEPT_EXPRESSIONS(E1, E2)> -KFR_INTRINSIC expression_function<fn::sub, E1, E2> operator-(E1&& e1, E2&& e2) +KFR_INTRINSIC expression_make_function<fn::sub, E1, E2> operator-(E1&& e1, E2&& e2) { return { fn::sub(), std::forward<E1>(e1), std::forward<E2>(e2) }; } template <typename E1, typename E2, KFR_ACCEPT_EXPRESSIONS(E1, E2)> -KFR_INTRINSIC expression_function<fn::mul, E1, E2> operator*(E1&& e1, E2&& e2) +KFR_INTRINSIC expression_make_function<fn::mul, E1, E2> operator*(E1&& e1, E2&& e2) { return { fn::mul(), std::forward<E1>(e1), std::forward<E2>(e2) }; } template <typename E1, typename E2, KFR_ACCEPT_EXPRESSIONS(E1, E2)> -KFR_INTRINSIC expression_function<fn::div, E1, E2> operator/(E1&& e1, E2&& e2) +KFR_INTRINSIC expression_make_function<fn::div, E1, E2> operator/(E1&& e1, E2&& e2) { return { fn::div(), std::forward<E1>(e1), std::forward<E2>(e2) }; } template <typename E1, typename E2, KFR_ACCEPT_EXPRESSIONS(E1, E2)> -KFR_INTRINSIC expression_function<fn::mod, E1, E2> operator%(E1&& e1, E2&& e2) +KFR_INTRINSIC expression_make_function<fn::mod, E1, E2> operator%(E1&& e1, E2&& e2) { return { fn::mod(), std::forward<E1>(e1), std::forward<E2>(e2) }; } template <typename E1, typename E2, KFR_ACCEPT_EXPRESSIONS(E1, E2)> -KFR_INTRINSIC expression_function<fn::bitwiseand, E1, E2> operator&(E1&& e1, E2&& e2) +KFR_INTRINSIC expression_make_function<fn::bitwiseand, E1, E2> operator&(E1&& e1, E2&& e2) { return { fn::bitwiseand(), std::forward<E1>(e1), std::forward<E2>(e2) }; } template <typename E1, typename E2, KFR_ACCEPT_EXPRESSIONS(E1, E2)> -KFR_INTRINSIC expression_function<fn::bitwiseor, E1, E2> operator|(E1&& e1, E2&& e2) +KFR_INTRINSIC expression_make_function<fn::bitwiseor, E1, E2> operator|(E1&& e1, E2&& e2) { return { fn::bitwiseor(), std::forward<E1>(e1), std::forward<E2>(e2) }; } template <typename E1, typename E2, KFR_ACCEPT_EXPRESSIONS(E1, E2)> -KFR_INTRINSIC expression_function<fn::bitwisexor, E1, E2> operator^(E1&& e1, E2&& e2) +KFR_INTRINSIC expression_make_function<fn::bitwisexor, E1, E2> operator^(E1&& e1, E2&& e2) { return { fn::bitwisexor(), std::forward<E1>(e1), std::forward<E2>(e2) }; } template <typename E1, typename E2, KFR_ACCEPT_EXPRESSIONS(E1, E2)> -KFR_INTRINSIC expression_function<fn::shl, E1, E2> operator<<(E1&& e1, E2&& e2) +KFR_INTRINSIC expression_make_function<fn::shl, E1, E2> operator<<(E1&& e1, E2&& e2) { return { fn::shl(), std::forward<E1>(e1), std::forward<E2>(e2) }; } template <typename E1, typename E2, KFR_ACCEPT_EXPRESSIONS(E1, E2)> -KFR_INTRINSIC expression_function<fn::shr, E1, E2> operator>>(E1&& e1, E2&& e2) +KFR_INTRINSIC expression_make_function<fn::shr, E1, E2> operator>>(E1&& e1, E2&& e2) { return { fn::shr(), std::forward<E1>(e1), std::forward<E2>(e2) }; } @@ -168,7 +168,7 @@ KFR_INTRINSIC expression_function<fn::shr, E1, E2> operator>>(E1&& e1, E2&& e2) * @brief Returns template expression that returns square of x. */ template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_INTRINSIC expression_function<fn::sqr, E1> sqr(E1&& x) +KFR_INTRINSIC expression_make_function<fn::sqr, E1> sqr(E1&& x) { return { fn::sqr(), std::forward<E1>(x) }; } @@ -177,110 +177,110 @@ KFR_INTRINSIC expression_function<fn::sqr, E1> sqr(E1&& x) * @brief Returns template expression that returns cube of x. */ template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_INTRINSIC expression_function<fn::cub, E1> cub(E1&& x) +KFR_INTRINSIC expression_make_function<fn::cub, E1> cub(E1&& x) { return { fn::cub(), std::forward<E1>(x) }; } template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_INTRINSIC expression_function<fn::pow2, E1> pow2(E1&& x) +KFR_INTRINSIC expression_make_function<fn::pow2, E1> pow2(E1&& x) { return { fn::pow2(), std::forward<E1>(x) }; } template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_INTRINSIC expression_function<fn::pow3, E1> pow3(E1&& x) +KFR_INTRINSIC expression_make_function<fn::pow3, E1> pow3(E1&& x) { return { fn::pow3(), std::forward<E1>(x) }; } template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_INTRINSIC expression_function<fn::pow4, E1> pow4(E1&& x) +KFR_INTRINSIC expression_make_function<fn::pow4, E1> pow4(E1&& x) { return { fn::pow4(), std::forward<E1>(x) }; } template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_INTRINSIC expression_function<fn::pow5, E1> pow5(E1&& x) +KFR_INTRINSIC expression_make_function<fn::pow5, E1> pow5(E1&& x) { return { fn::pow5(), std::forward<E1>(x) }; } template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_INTRINSIC expression_function<fn::neg, E1> operator-(E1&& e1) +KFR_INTRINSIC expression_make_function<fn::neg, E1> operator-(E1&& e1) { return { fn::neg(), std::forward<E1>(e1) }; } template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_INTRINSIC expression_function<fn::bitwisenot, E1> operator~(E1&& e1) +KFR_INTRINSIC expression_make_function<fn::bitwisenot, E1> operator~(E1&& e1) { return { fn::bitwisenot(), std::forward<E1>(e1) }; } /// @brief Constructs complex value from real and imaginary parts template <typename E1, typename E2, KFR_ACCEPT_EXPRESSIONS(E1, E2)> -KFR_INTRINSIC expression_function<fn::make_complex, E1, E2> make_complex(E1&& re, E2&& im) +KFR_INTRINSIC expression_make_function<fn::make_complex, E1, E2> make_complex(E1&& re, E2&& im) { return { fn::make_complex{}, std::forward<E1>(re), std::forward<E2>(im) }; } template <typename E1, typename E2, KFR_ACCEPT_EXPRESSIONS(E1, E2)> -KFR_INTRINSIC expression_function<fn::equal, E1, E2> operator==(E1&& e1, E2&& e2) +KFR_INTRINSIC expression_make_function<fn::equal, E1, E2> operator==(E1&& e1, E2&& e2) { return { fn::equal(), std::forward<E1>(e1), std::forward<E2>(e2) }; } template <typename E1, typename E2, KFR_ACCEPT_EXPRESSIONS(E1, E2)> -KFR_INTRINSIC expression_function<fn::notequal, E1, E2> operator!=(E1&& e1, E2&& e2) +KFR_INTRINSIC expression_make_function<fn::notequal, E1, E2> operator!=(E1&& e1, E2&& e2) { return { fn::notequal(), std::forward<E1>(e1), std::forward<E2>(e2) }; } template <typename E1, typename E2, KFR_ACCEPT_EXPRESSIONS(E1, E2)> -KFR_INTRINSIC expression_function<fn::less, E1, E2> operator<(E1&& e1, E2&& e2) +KFR_INTRINSIC expression_make_function<fn::less, E1, E2> operator<(E1&& e1, E2&& e2) { return { fn::less(), std::forward<E1>(e1), std::forward<E2>(e2) }; } template <typename E1, typename E2, KFR_ACCEPT_EXPRESSIONS(E1, E2)> -KFR_INTRINSIC expression_function<fn::greater, E1, E2> operator>(E1&& e1, E2&& e2) +KFR_INTRINSIC expression_make_function<fn::greater, E1, E2> operator>(E1&& e1, E2&& e2) { return { fn::greater(), std::forward<E1>(e1), std::forward<E2>(e2) }; } template <typename E1, typename E2, KFR_ACCEPT_EXPRESSIONS(E1, E2)> -KFR_INTRINSIC expression_function<fn::lessorequal, E1, E2> operator<=(E1&& e1, E2&& e2) +KFR_INTRINSIC expression_make_function<fn::lessorequal, E1, E2> operator<=(E1&& e1, E2&& e2) { return { fn::lessorequal(), std::forward<E1>(e1), std::forward<E2>(e2) }; } template <typename E1, typename E2, KFR_ACCEPT_EXPRESSIONS(E1, E2)> -KFR_INTRINSIC expression_function<fn::greaterorequal, E1, E2> operator>=(E1&& e1, E2&& e2) +KFR_INTRINSIC expression_make_function<fn::greaterorequal, E1, E2> operator>=(E1&& e1, E2&& e2) { return { fn::greaterorequal(), std::forward<E1>(e1), std::forward<E2>(e2) }; } /// @brief Returns the real part of the complex value template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_INTRINSIC expression_function<fn::real, E1> real(E1&& x) +KFR_INTRINSIC expression_make_function<fn::real, E1> real(E1&& x) { return { fn::real{}, std::forward<E1>(x) }; } /// @brief Returns the imaginary part of the complex value template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_INTRINSIC expression_function<fn::imag, E1> imag(E1&& x) +KFR_INTRINSIC expression_make_function<fn::imag, E1> imag(E1&& x) { return { fn::imag{}, std::forward<E1>(x) }; } /// @brief Returns template expression that returns the complex conjugate of the complex number x template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::cconj, E1> cconj(E1&& x) +KFR_FUNCTION expression_make_function<fn::cconj, E1> cconj(E1&& x) { return { fn::cconj(), std::forward<E1>(x) }; } template <typename E1, typename E2, KFR_ACCEPT_EXPRESSIONS(E1, E2)> -CMT_INTRINSIC expression_function<fn::interleave, E1, E2> interleave(E1&& x, E2&& y) +CMT_INTRINSIC expression_make_function<fn::interleave, E1, E2> interleave(E1&& x, E2&& y) { return { fn::interleave(), std::forward<E1>(x), std::forward<E2>(y) }; } @@ -290,7 +290,7 @@ CMT_INTRINSIC expression_function<fn::interleave, E1, E2> interleave(E1&& x, E2& * is same as in ternary operator. */ template <typename E1, typename E2, typename E3, KFR_ACCEPT_EXPRESSIONS(E1, E2, E3)> -KFR_FUNCTION expression_function<fn::select, E1, E2, E3> select(E1&& m, E2&& x, E3&& y) +KFR_FUNCTION expression_make_function<fn::select, E1, E2, E3> select(E1&& m, E2&& x, E3&& y) { return { fn::select(), std::forward<E1>(m), std::forward<E2>(x), std::forward<E3>(y) }; } @@ -299,7 +299,7 @@ KFR_FUNCTION expression_function<fn::select, E1, E2, E3> select(E1&& m, E2&& x, * @brief Returns template expression that returns the absolute value of x. */ template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::abs, E1> abs(E1&& x) +KFR_FUNCTION expression_make_function<fn::abs, E1> abs(E1&& x) { return { fn::abs(), std::forward<E1>(x) }; } @@ -308,7 +308,7 @@ KFR_FUNCTION expression_function<fn::abs, E1> abs(E1&& x) * @brief Returns the smaller of two values. Accepts and returns expressions. */ template <typename E1, typename E2, KFR_ACCEPT_EXPRESSIONS(E1, E2)> -KFR_FUNCTION expression_function<fn::min, E1, E2> min(E1&& x, E2&& y) +KFR_FUNCTION expression_make_function<fn::min, E1, E2> min(E1&& x, E2&& y) { return { fn::min(), std::forward<E1>(x), std::forward<E2>(y) }; } @@ -317,7 +317,7 @@ KFR_FUNCTION expression_function<fn::min, E1, E2> min(E1&& x, E2&& y) * @brief Returns the greater of two values. Accepts and returns expressions. */ template <typename E1, typename E2, KFR_ACCEPT_EXPRESSIONS(E1, E2)> -KFR_FUNCTION expression_function<fn::max, E1, E2> max(E1&& x, E2&& y) +KFR_FUNCTION expression_make_function<fn::max, E1, E2> max(E1&& x, E2&& y) { return { fn::max(), std::forward<E1>(x), std::forward<E2>(y) }; } @@ -326,7 +326,7 @@ KFR_FUNCTION expression_function<fn::max, E1, E2> max(E1&& x, E2&& y) * @brief Returns the smaller in magnitude of two values. Accepts and returns expressions. */ template <typename E1, typename E2, KFR_ACCEPT_EXPRESSIONS(E1, E2)> -KFR_FUNCTION expression_function<fn::absmin, E1, E2> absmin(E1&& x, E2&& y) +KFR_FUNCTION expression_make_function<fn::absmin, E1, E2> absmin(E1&& x, E2&& y) { return { fn::absmin(), std::forward<E1>(x), std::forward<E2>(y) }; } @@ -335,90 +335,90 @@ KFR_FUNCTION expression_function<fn::absmin, E1, E2> absmin(E1&& x, E2&& y) * @brief Returns the greater in magnitude of two values. Accepts and returns expressions. */ template <typename E1, typename E2, KFR_ACCEPT_EXPRESSIONS(E1, E2)> -KFR_FUNCTION expression_function<fn::absmax, E1, E2> absmax(E1&& x, E2&& y) +KFR_FUNCTION expression_make_function<fn::absmax, E1, E2> absmax(E1&& x, E2&& y) { return { fn::absmax(), std::forward<E1>(x), std::forward<E2>(y) }; } /// @brief Returns the largest integer value not greater than x. Accepts and returns expressions. template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::floor, E1> floor(E1&& x) +KFR_FUNCTION expression_make_function<fn::floor, E1> floor(E1&& x) { return { fn::floor(), std::forward<E1>(x) }; } template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::ceil, E1> ceil(E1&& x) +KFR_FUNCTION expression_make_function<fn::ceil, E1> ceil(E1&& x) { return { fn::ceil(), std::forward<E1>(x) }; } template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::round, E1> round(E1&& x) +KFR_FUNCTION expression_make_function<fn::round, E1> round(E1&& x) { return { fn::round(), std::forward<E1>(x) }; } template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::trunc, E1> trunc(E1&& x) +KFR_FUNCTION expression_make_function<fn::trunc, E1> trunc(E1&& x) { return { fn::trunc(), std::forward<E1>(x) }; } template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::fract, E1> fract(E1&& x) +KFR_FUNCTION expression_make_function<fn::fract, E1> fract(E1&& x) { return { fn::fract(), std::forward<E1>(x) }; } template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::ifloor, E1> ifloor(E1&& x) +KFR_FUNCTION expression_make_function<fn::ifloor, E1> ifloor(E1&& x) { return { fn::ifloor(), std::forward<E1>(x) }; } template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::iceil, E1> iceil(E1&& x) +KFR_FUNCTION expression_make_function<fn::iceil, E1> iceil(E1&& x) { return { fn::iceil(), std::forward<E1>(x) }; } template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::iround, E1> iround(E1&& x) +KFR_FUNCTION expression_make_function<fn::iround, E1> iround(E1&& x) { return { fn::iround(), std::forward<E1>(x) }; } template <typename E1, KFR_ACCEPT_EXPRESSIONS(E1)> -KFR_FUNCTION expression_function<fn::itrunc, E1> itrunc(E1&& x) +KFR_FUNCTION expression_make_function<fn::itrunc, E1> itrunc(E1&& x) { return { fn::itrunc(), std::forward<E1>(x) }; } /// @brief Creates an expression that returns the first argument clamped to a range [lo, hi] template <typename E1, typename E2, typename E3, KFR_ACCEPT_EXPRESSIONS(E1, E2, E3)> -KFR_FUNCTION expression_function<fn::clamp, E1, E2, E3> clamp(E1&& x, E2&& lo, E3&& hi) +KFR_FUNCTION expression_make_function<fn::clamp, E1, E2, E3> clamp(E1&& x, E2&& lo, E3&& hi) { return { fn::clamp(), std::forward<E1>(x), std::forward<E2>(lo), std::forward<E3>(hi) }; } /// @brief Creates an expression that returns the first argument clamped to a range [0, hi] template <typename E1, typename E2, KFR_ACCEPT_EXPRESSIONS(E1, E2)> -KFR_FUNCTION expression_function<fn::clamp, E1, E2> clamp(E1&& x, E2&& hi) +KFR_FUNCTION expression_make_function<fn::clamp, E1, E2> clamp(E1&& x, E2&& hi) { return { fn::clamp(), std::forward<E1>(x), std::forward<E2>(hi) }; } /// @brief Creates an expression that adds two arguments using saturation template <typename E1, typename E2, KFR_ACCEPT_EXPRESSIONS(E1, E2)> -KFR_INTRINSIC expression_function<fn::satadd, E1, E2> satadd(E1&& x, E2&& y) +KFR_INTRINSIC expression_make_function<fn::satadd, E1, E2> satadd(E1&& x, E2&& y) { return { fn::satadd(), std::forward<E1>(x), std::forward<E2>(y) }; } /// @brief Creates an expression that subtracts two arguments using saturation template <typename E1, typename E2, KFR_ACCEPT_EXPRESSIONS(E1, E2)> -KFR_INTRINSIC expression_function<fn::satsub, E1, E2> satsub(E1&& x, E2&& y) +KFR_INTRINSIC expression_make_function<fn::satsub, E1, E2> satsub(E1&& x, E2&& y) { return { fn::satsub(), std::forward<E1>(x), std::forward<E2>(y) }; } diff --git a/include/kfr/cometa.hpp b/include/kfr/cometa.hpp @@ -1099,6 +1099,9 @@ using findinttype = typename details::findinttype_impl<min, max, uint8_t, int8_t template <typename T> constexpr inline bool is_number = details::is_number_impl<std::decay_t<T>>::value; +template <typename T> +constexpr inline bool is_number_or_bool = is_number<T> || std::is_same_v<std::decay_t<T>, bool>; + template <typename... Ts> constexpr inline bool is_numbers = (details::is_number_impl<std::decay_t<Ts>>::value && ...); @@ -1110,6 +1113,10 @@ constexpr inline bool is_numeric = is_number<deep_subtype<T>>; template <typename... Ts> constexpr inline bool is_numeric_args = (is_numeric<Ts> && ...); +/// @brief Check if the type argument is a number, bool or a vector of numbers of bool +template <typename T> +constexpr inline bool is_numeric_or_bool = is_number_or_bool<deep_subtype<T>>; + namespace details { template <typename T>