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:
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>
