11#ifndef EIGEN_BINARY_FUNCTORS_H
12#define EIGEN_BINARY_FUNCTORS_H
15#include "../InternalHeaderCheck.h"
23template <
typename Arg1,
typename Arg2>
24struct binary_op_base {
25 using first_argument_type = Arg1;
26 using second_argument_type = Arg2;
34template <
typename LhsScalar,
typename RhsScalar>
35struct scalar_sum_op : binary_op_base<LhsScalar, RhsScalar> {
36 using result_type =
typename ScalarBinaryOpTraits<LhsScalar, RhsScalar, scalar_sum_op>::ReturnType;
37#ifdef EIGEN_SCALAR_BINARY_OP_PLUGIN
38 scalar_sum_op(){EIGEN_SCALAR_BINARY_OP_PLUGIN}
40 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE result_type
41 operator()(
const LhsScalar& a,
const RhsScalar& b)
const {
44 template <
typename Packet>
45 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(
const Packet& a,
const Packet& b)
const {
46 return internal::padd(a, b);
48 template <
typename Packet>
49 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type predux(
const Packet& a)
const {
50 return internal::predux(a);
53template <
typename LhsScalar,
typename RhsScalar>
54struct functor_traits<scalar_sum_op<LhsScalar, RhsScalar>> {
56 Cost = (int(NumTraits<LhsScalar>::AddCost) + int(NumTraits<RhsScalar>::AddCost)) / 2,
57 PacketAccess = std::is_same<LhsScalar, RhsScalar>::value && packet_traits<LhsScalar>::HasAdd &&
58 packet_traits<RhsScalar>::HasAdd
65template <
typename Scalar>
66struct functor_is_commutative<scalar_sum_op<Scalar, Scalar>>
67 : bool_constant<is_arithmetic<Scalar>::value || NumTraits<Scalar>::IsComplex> {};
70EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE
bool scalar_sum_op<bool, bool>::operator()(
const bool& a,
71 const bool& b)
const {
80template <
typename LhsScalar,
typename RhsScalar>
81struct scalar_product_op : binary_op_base<LhsScalar, RhsScalar> {
82 using result_type =
typename ScalarBinaryOpTraits<LhsScalar, RhsScalar, scalar_product_op>::ReturnType;
83#ifdef EIGEN_SCALAR_BINARY_OP_PLUGIN
84 scalar_product_op(){EIGEN_SCALAR_BINARY_OP_PLUGIN}
86 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE result_type
87 operator()(
const LhsScalar& a,
const RhsScalar& b)
const {
88 return internal::mul(a, b);
90 template <
typename Packet>
91 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(
const Packet& a,
const Packet& b)
const {
92 return internal::pmul(a, b);
94 template <
typename Packet>
95 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type predux(
const Packet& a)
const {
96 return internal::predux_mul(a);
99template <
typename LhsScalar,
typename RhsScalar>
100struct functor_traits<scalar_product_op<LhsScalar, RhsScalar>> {
102 Cost = (int(NumTraits<LhsScalar>::MulCost) + int(NumTraits<RhsScalar>::MulCost)) / 2,
103 PacketAccess = std::is_same<LhsScalar, RhsScalar>::value && packet_traits<LhsScalar>::HasMul &&
104 packet_traits<RhsScalar>::HasMul
109template <
typename LhsScalar,
typename RhsScalar,
typename =
void>
110struct scalar_product_commutativity
111 : bool_constant<is_arithmetic<LhsScalar>::value && is_arithmetic<RhsScalar>::value> {};
113template <
typename LhsScalar,
typename RhsScalar>
114struct scalar_product_commutativity<
115 LhsScalar, RhsScalar,
117 decltype(ScalarBinaryOpTraits<LhsScalar, RhsScalar, scalar_product_op<LhsScalar, RhsScalar>>::IsCommutative)>>
119 ScalarBinaryOpTraits<LhsScalar, RhsScalar, scalar_product_op<LhsScalar, RhsScalar>>::IsCommutative> {};
122template <
typename LhsScalar,
typename RhsScalar>
123struct functor_is_commutative<scalar_product_op<LhsScalar, RhsScalar>>
124 : scalar_product_commutativity<LhsScalar, RhsScalar> {};
126template <
typename RealScalar>
127struct functor_is_commutative<scalar_product_op<std::complex<RealScalar>, std::complex<RealScalar>>>
128 : bool_constant<is_arithmetic<RealScalar>::value ||
129 scalar_product_commutativity<std::complex<RealScalar>, std::complex<RealScalar>>::value> {};
131template <
typename RealScalar>
132struct functor_is_commutative<scalar_product_op<std::complex<RealScalar>, RealScalar>>
133 : bool_constant<is_arithmetic<RealScalar>::value ||
134 scalar_product_commutativity<std::complex<RealScalar>, RealScalar>::value> {};
136template <
typename RealScalar>
137struct functor_is_commutative<scalar_product_op<RealScalar, std::complex<RealScalar>>>
138 : bool_constant<is_arithmetic<RealScalar>::value ||
139 scalar_product_commutativity<RealScalar, std::complex<RealScalar>>::value> {};
148template <
typename LhsScalar,
typename RhsScalar>
149struct fast_mult_op : scalar_product_op<LhsScalar, RhsScalar> {
150 using result_type =
typename scalar_product_op<LhsScalar, RhsScalar>::result_type;
151 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type operator()(
const LhsScalar& a,
const RhsScalar& b)
const {
152 return mul(a, b, bool_constant<std::is_same<LhsScalar, RhsScalar>::value>());
156 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type mul(
const LhsScalar& a,
const RhsScalar& b, std::true_type)
const {
159 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type mul(
const LhsScalar& a,
const RhsScalar& b, std::false_type)
const {
160 return internal::mul(a, b);
163template <
typename LhsScalar,
typename RhsScalar>
164struct functor_traits<fast_mult_op<LhsScalar, RhsScalar>> : functor_traits<scalar_product_op<LhsScalar, RhsScalar>> {};
167EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE
bool scalar_product_op<bool, bool>::operator()(
const bool& a,
168 const bool& b)
const {
178template <
typename LhsScalar,
typename RhsScalar>
179struct scalar_conj_product_op : binary_op_base<LhsScalar, RhsScalar> {
180 enum { Conj = NumTraits<LhsScalar>::IsComplex };
182 using result_type =
typename ScalarBinaryOpTraits<LhsScalar, RhsScalar, scalar_conj_product_op>::ReturnType;
184 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE result_type operator()(
const LhsScalar& a,
const RhsScalar& b)
const {
185 return conj_helper<LhsScalar, RhsScalar, Conj, false>().pmul(a, b);
188 template <
typename Packet>
189 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(
const Packet& a,
const Packet& b)
const {
190 return conj_helper<Packet, Packet, Conj, false>().pmul(a, b);
193template <
typename LhsScalar,
typename RhsScalar>
194struct functor_traits<scalar_conj_product_op<LhsScalar, RhsScalar>> {
196 Cost = NumTraits<LhsScalar>::MulCost,
197 PacketAccess = std::is_same<LhsScalar, RhsScalar>::value && packet_traits<LhsScalar>::HasMul
206template <
typename LhsScalar,
typename RhsScalar,
int NaNPropagation>
207struct scalar_min_op : binary_op_base<LhsScalar, RhsScalar> {
208 using result_type =
typename ScalarBinaryOpTraits<LhsScalar, RhsScalar, scalar_min_op>::ReturnType;
209 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE result_type operator()(
const LhsScalar& a,
const RhsScalar& b)
const {
210 return internal::pmin<NaNPropagation>(a, b);
212 template <
typename Packet>
213 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(
const Packet& a,
const Packet& b)
const {
214 return internal::pmin<NaNPropagation>(a, b);
216 template <
typename Packet>
217 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type predux(
const Packet& a)
const {
218 return internal::predux_min<NaNPropagation>(a);
222template <
typename LhsScalar,
typename RhsScalar,
int NaNPropagation>
223struct functor_traits<scalar_min_op<LhsScalar, RhsScalar, NaNPropagation>> {
225 Cost = (NumTraits<LhsScalar>::AddCost + NumTraits<RhsScalar>::AddCost) / 2,
226 PacketAccess = std::is_same<LhsScalar, RhsScalar>::value && packet_traits<LhsScalar>::HasMin
236template <
typename Scalar,
int NaNPropagation>
237struct functor_is_commutative<scalar_min_op<Scalar, Scalar, NaNPropagation>> : is_arithmetic<Scalar> {};
244template <
typename LhsScalar,
typename RhsScalar,
int NaNPropagation>
245struct scalar_max_op : binary_op_base<LhsScalar, RhsScalar> {
246 using result_type =
typename ScalarBinaryOpTraits<LhsScalar, RhsScalar, scalar_max_op>::ReturnType;
247 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE result_type operator()(
const LhsScalar& a,
const RhsScalar& b)
const {
248 return internal::pmax<NaNPropagation>(a, b);
250 template <
typename Packet>
251 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(
const Packet& a,
const Packet& b)
const {
252 return internal::pmax<NaNPropagation>(a, b);
254 template <
typename Packet>
255 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type predux(
const Packet& a)
const {
256 return internal::predux_max<NaNPropagation>(a);
260template <
typename LhsScalar,
typename RhsScalar,
int NaNPropagation>
261struct functor_traits<scalar_max_op<LhsScalar, RhsScalar, NaNPropagation>> {
263 Cost = (NumTraits<LhsScalar>::AddCost + NumTraits<RhsScalar>::AddCost) / 2,
264 PacketAccess = std::is_same<LhsScalar, RhsScalar>::value && packet_traits<LhsScalar>::HasMax
268template <
typename Scalar,
int NaNPropagation>
269struct functor_is_commutative<scalar_max_op<Scalar, Scalar, NaNPropagation>> : is_arithmetic<Scalar> {};
275template <
typename LhsScalar,
typename RhsScalar, ComparisonName cmp,
bool UseTypedComparators = false>
278template <
typename LhsScalar,
typename RhsScalar, ComparisonName cmp,
bool UseTypedComparators>
279struct functor_traits<scalar_cmp_op<LhsScalar, RhsScalar, cmp, UseTypedComparators>> {
281 Cost = (NumTraits<LhsScalar>::AddCost + NumTraits<RhsScalar>::AddCost) / 2,
282 PacketAccess = (UseTypedComparators || std::is_same<LhsScalar, bool>::value) &&
283 std::is_same<LhsScalar, RhsScalar>::value && packet_traits<LhsScalar>::HasCmp
287template <
typename LhsScalar,
typename RhsScalar,
bool UseTypedComparators>
288struct scalar_cmp_op<LhsScalar, RhsScalar, cmp_EQ, UseTypedComparators> : binary_op_base<LhsScalar, RhsScalar> {
289 using result_type = std::conditional_t<UseTypedComparators, LhsScalar, bool>;
290 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE result_type operator()(
const LhsScalar& a,
const RhsScalar& b)
const {
291 return result_type(a == b);
293 template <
typename Packet>
294 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(
const Packet& a,
const Packet& b)
const {
295 const Packet cst_one = pset1<Packet>(result_type(
true));
296 return pand(pcmp_eq(a, b), cst_one);
300template <
typename LhsScalar,
typename RhsScalar,
bool UseTypedComparators>
301struct scalar_cmp_op<LhsScalar, RhsScalar, cmp_LT, UseTypedComparators> : binary_op_base<LhsScalar, RhsScalar> {
302 using result_type = std::conditional_t<UseTypedComparators, LhsScalar, bool>;
303 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE result_type operator()(
const LhsScalar& a,
const RhsScalar& b)
const {
304 return result_type(a < b);
306 template <
typename Packet>
307 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(
const Packet& a,
const Packet& b)
const {
308 const Packet cst_one = pset1<Packet>(result_type(
true));
309 return pand(pcmp_lt(a, b), cst_one);
313template <
typename LhsScalar,
typename RhsScalar,
bool UseTypedComparators>
314struct scalar_cmp_op<LhsScalar, RhsScalar, cmp_LE, UseTypedComparators> : binary_op_base<LhsScalar, RhsScalar> {
315 using result_type = std::conditional_t<UseTypedComparators, LhsScalar, bool>;
316 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE result_type operator()(
const LhsScalar& a,
const RhsScalar& b)
const {
317 return result_type(a <= b);
319 template <
typename Packet>
320 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(
const Packet& a,
const Packet& b)
const {
321 const Packet cst_one = pset1<Packet>(result_type(
true));
322 return pand(cst_one, pcmp_le(a, b));
326template <
typename LhsScalar,
typename RhsScalar,
bool UseTypedComparators>
327struct scalar_cmp_op<LhsScalar, RhsScalar, cmp_GT, UseTypedComparators> : binary_op_base<LhsScalar, RhsScalar> {
328 using result_type = std::conditional_t<UseTypedComparators, LhsScalar, bool>;
329 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE result_type operator()(
const LhsScalar& a,
const RhsScalar& b)
const {
330 return result_type(a > b);
332 template <
typename Packet>
333 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(
const Packet& a,
const Packet& b)
const {
334 const Packet cst_one = pset1<Packet>(result_type(
true));
335 return pand(cst_one, pcmp_lt(b, a));
339template <
typename LhsScalar,
typename RhsScalar,
bool UseTypedComparators>
340struct scalar_cmp_op<LhsScalar, RhsScalar, cmp_GE, UseTypedComparators> : binary_op_base<LhsScalar, RhsScalar> {
341 using result_type = std::conditional_t<UseTypedComparators, LhsScalar, bool>;
342 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE result_type operator()(
const LhsScalar& a,
const RhsScalar& b)
const {
343 return result_type(a >= b);
345 template <
typename Packet>
346 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(
const Packet& a,
const Packet& b)
const {
347 const Packet cst_one = pset1<Packet>(result_type(
true));
348 return pand(cst_one, pcmp_le(b, a));
352template <
typename LhsScalar,
typename RhsScalar,
bool UseTypedComparators>
353struct scalar_cmp_op<LhsScalar, RhsScalar, cmp_UNORD, UseTypedComparators> : binary_op_base<LhsScalar, RhsScalar> {
354 using result_type = std::conditional_t<UseTypedComparators, LhsScalar, bool>;
355 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE result_type operator()(
const LhsScalar& a,
const RhsScalar& b)
const {
356 return result_type(!(a <= b || b <= a));
358 template <
typename Packet>
359 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(
const Packet& a,
const Packet& b)
const {
360 const Packet cst_one = pset1<Packet>(result_type(
true));
361 return pandnot(cst_one, por(pcmp_le(a, b), pcmp_le(b, a)));
365template <
typename LhsScalar,
typename RhsScalar,
bool UseTypedComparators>
366struct scalar_cmp_op<LhsScalar, RhsScalar, cmp_NEQ, UseTypedComparators> : binary_op_base<LhsScalar, RhsScalar> {
367 using result_type = std::conditional_t<UseTypedComparators, LhsScalar, bool>;
368 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE result_type operator()(
const LhsScalar& a,
const RhsScalar& b)
const {
369 return result_type(a != b);
371 template <
typename Packet>
372 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(
const Packet& a,
const Packet& b)
const {
373 const Packet cst_one = pset1<Packet>(result_type(
true));
374 return pandnot(cst_one, pcmp_eq(a, b));
383template <
typename Scalar>
384struct scalar_hypot_op<Scalar, Scalar> : binary_op_base<Scalar, Scalar> {
385 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE Scalar operator()(
const Scalar& x,
const Scalar& y)
const {
391 return internal::positive_real_hypot(x, y);
394template <
typename Scalar>
395struct functor_traits<scalar_hypot_op<Scalar, Scalar>> {
397 Cost = 3 * NumTraits<Scalar>::AddCost + 2 * NumTraits<Scalar>::MulCost + 2 * scalar_div_cost<Scalar, false>::value,
406template <
typename Scalar,
typename Exponent>
407struct scalar_pow_op : binary_op_base<Scalar, Exponent> {
408 using result_type =
typename ScalarBinaryOpTraits<Scalar, Exponent, scalar_pow_op>::ReturnType;
409#ifdef EIGEN_SCALAR_BINARY_OP_PLUGIN
411 using LhsScalar = Scalar;
412 using RhsScalar = Exponent;
413 EIGEN_SCALAR_BINARY_OP_PLUGIN
417 EIGEN_DEVICE_FUNC
constexpr inline result_type operator()(
const Scalar& a,
const Exponent& b)
const {
418 return numext::pow(a, b);
421 template <
typename Packet>
422 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(
const Packet& a,
const Packet& b)
const {
423 return generic_pow(a, b);
427template <
typename Scalar,
typename Exponent>
428struct functor_traits<scalar_pow_op<Scalar, Exponent>> {
430 Cost = 5 * NumTraits<Scalar>::MulCost,
431 PacketAccess = (!NumTraits<Scalar>::IsComplex && !NumTraits<Scalar>::IsInteger && packet_traits<Scalar>::HasPow)
442template <
typename LhsScalar,
typename RhsScalar>
443struct scalar_difference_op : binary_op_base<LhsScalar, RhsScalar> {
444 EIGEN_STATIC_ASSERT((!std::is_same<LhsScalar, bool>::value || !std::is_same<RhsScalar, bool>::value),
445 BOOLEAN_SUBTRACTION_IS_NOT_SUPPORTED__CAST_TO_A_SIGNED_INTEGER_TYPE)
446 using result_type =
typename ScalarBinaryOpTraits<LhsScalar, RhsScalar, scalar_difference_op>::ReturnType;
447#ifdef EIGEN_SCALAR_BINARY_OP_PLUGIN
448 scalar_difference_op(){EIGEN_SCALAR_BINARY_OP_PLUGIN}
450 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE result_type
451 operator()(
const LhsScalar& a,
const RhsScalar& b)
const {
454 template <
typename Packet>
455 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(
const Packet& a,
const Packet& b)
const {
456 return internal::psub(a, b);
459template <
typename LhsScalar,
typename RhsScalar>
460struct functor_traits<scalar_difference_op<LhsScalar, RhsScalar>> {
462 Cost = (int(NumTraits<LhsScalar>::AddCost) + int(NumTraits<RhsScalar>::AddCost)) / 2,
463 PacketAccess = std::is_same<LhsScalar, RhsScalar>::value && packet_traits<LhsScalar>::HasSub &&
464 packet_traits<RhsScalar>::HasSub
468template <typename Packet, bool IsInteger = NumTraits<typename unpacket_traits<Packet>::type>::IsInteger>
469struct maybe_raise_div_by_zero {
470 static EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE
void run(Packet x) { EIGEN_UNUSED_VARIABLE(x); }
473#ifndef EIGEN_GPU_COMPILE_PHASE
474template <
typename Packet>
475struct maybe_raise_div_by_zero<Packet, true> {
476 static EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE
void run(Packet x) {
477 if (EIGEN_PREDICT_FALSE(predux_any(pcmp_eq(x, pzero(x))))) {
480 volatile typename unpacket_traits<Packet>::type zero = 0;
481 volatile typename unpacket_traits<Packet>::type val = 1;
493template <
typename LhsScalar,
typename RhsScalar>
494struct scalar_quotient_op : binary_op_base<LhsScalar, RhsScalar> {
495 using result_type =
typename ScalarBinaryOpTraits<LhsScalar, RhsScalar, scalar_quotient_op>::ReturnType;
496#ifdef EIGEN_SCALAR_BINARY_OP_PLUGIN
497 scalar_quotient_op(){EIGEN_SCALAR_BINARY_OP_PLUGIN}
499 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type
500 operator()(
const LhsScalar& a,
const RhsScalar& b)
const {
501 return numext::divide(a, b);
503 template <
typename Packet>
504 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(
const Packet& a,
const Packet& b)
const {
505 return internal::pdiv(a, b);
508template <
typename LhsScalar,
typename RhsScalar>
509struct functor_traits<scalar_quotient_op<LhsScalar, RhsScalar>> {
510 using result_type =
typename scalar_quotient_op<LhsScalar, RhsScalar>::result_type;
512 PacketAccess = std::is_same<LhsScalar, RhsScalar>::value && packet_traits<LhsScalar>::HasDiv &&
513 packet_traits<RhsScalar>::HasDiv,
514 Cost = scalar_div_cost<result_type, PacketAccess>::value
527template <
typename LhsScalar,
typename RhsScalar>
528struct scalar_modulus_op : binary_op_base<LhsScalar, RhsScalar> {
529 using result_type =
typename ScalarBinaryOpTraits<LhsScalar, RhsScalar, scalar_modulus_op>::ReturnType;
530 static constexpr bool Enable = std::is_same<LhsScalar, RhsScalar>::value && NumTraits<LhsScalar>::IsInteger;
531 EIGEN_STATIC_ASSERT(Enable,
"LhsScalar and RhsScalar must be the same integer type")
532#ifdef EIGEN_SCALAR_BINARY_OP_PLUGIN
533 scalar_modulus_op(){EIGEN_SCALAR_BINARY_OP_PLUGIN}
535 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE result_type
536 operator()(
const LhsScalar& a,
const RhsScalar& b)
const {
540template <
typename LhsScalar,
typename RhsScalar>
541struct functor_traits<scalar_modulus_op<LhsScalar, RhsScalar>> {
542 using result_type =
typename scalar_modulus_op<LhsScalar, RhsScalar>::result_type;
543 static constexpr bool PacketAccess =
false;
544 static constexpr int Cost = scalar_div_cost<result_type, false>::value;
552template <
typename Scalar>
553struct scalar_boolean_and_op {
554 using result_type = Scalar;
557 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE Scalar operator()(
const Scalar& a,
const Scalar& b)
const {
558 return Scalar((a != Scalar(0)) && (b != Scalar(0)));
560 template <
typename Packet>
561 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(
const Packet& a,
const Packet& b)
const {
562 EIGEN_IF_CONSTEXPR ((std::is_same<Scalar, bool>::value)) {
565 const Packet cst_one = pset1<Packet>(Scalar(
true));
567 Packet not_a = pcmp_eq(a, pzero(a));
568 Packet not_b = pcmp_eq(b, pzero(b));
569 Packet a_nand_b = por(not_a, not_b);
570 return pandnot(cst_one, a_nand_b);
576EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE
bool scalar_boolean_and_op<bool>::operator()(
const bool& a,
577 const bool& b)
const {
580template <
typename Scalar>
581struct functor_traits<scalar_boolean_and_op<Scalar>> {
582 enum { Cost = NumTraits<Scalar>::AddCost, PacketAccess = packet_traits<Scalar>::HasCmp };
590template <
typename Scalar>
591struct scalar_boolean_or_op {
592 using result_type = Scalar;
595 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE Scalar operator()(
const Scalar& a,
const Scalar& b)
const {
596 return Scalar((a != Scalar(0)) || (b != Scalar(0)));
598 template <
typename Packet>
599 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(
const Packet& a,
const Packet& b)
const {
600 EIGEN_IF_CONSTEXPR ((std::is_same<Scalar, bool>::value)) {
603 const Packet cst_one = pset1<Packet>(Scalar(
true));
606 Packet a_nor_b = pcmp_eq(por(a, b), pzero(a));
607 return pandnot(cst_one, a_nor_b);
612EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE
bool scalar_boolean_or_op<bool>::operator()(
const bool& a,
613 const bool& b)
const {
616template <
typename Scalar>
617struct functor_traits<scalar_boolean_or_op<Scalar>> {
618 enum { Cost = NumTraits<Scalar>::AddCost, PacketAccess = packet_traits<Scalar>::HasCmp };
626template <
typename Scalar>
627struct scalar_boolean_xor_op {
628 using result_type = Scalar;
631 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE Scalar operator()(
const Scalar& a,
const Scalar& b)
const {
632 return Scalar((a != Scalar(0)) != (b != Scalar(0)));
634 template <
typename Packet>
635 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(
const Packet& a,
const Packet& b)
const {
636 EIGEN_IF_CONSTEXPR ((std::is_same<Scalar, bool>::value)) {
639 const Packet cst_one = pset1<Packet>(Scalar(
true));
641 Packet not_a = pcmp_eq(a, pzero(a));
642 Packet not_b = pcmp_eq(b, pzero(b));
643 Packet a_xor_b = pxor(not_a, not_b);
644 return pand(cst_one, a_xor_b);
648template <
typename Scalar>
649struct functor_traits<scalar_boolean_xor_op<Scalar>> {
650 enum { Cost = NumTraits<Scalar>::AddCost, PacketAccess = packet_traits<Scalar>::HasCmp };
653template <typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
654struct bitwise_binary_impl {
655 static constexpr size_t Size =
sizeof(Scalar);
656 using uint_t =
typename numext::get_integer_by_size<Size>::unsigned_type;
657 static EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE Scalar run_and(
const Scalar& a,
const Scalar& b) {
658 uint_t a_as_uint = numext::bit_cast<uint_t, Scalar>(a);
659 uint_t b_as_uint = numext::bit_cast<uint_t, Scalar>(b);
660 uint_t result = a_as_uint & b_as_uint;
661 return numext::bit_cast<Scalar, uint_t>(result);
663 static EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE Scalar run_or(
const Scalar& a,
const Scalar& b) {
664 uint_t a_as_uint = numext::bit_cast<uint_t, Scalar>(a);
665 uint_t b_as_uint = numext::bit_cast<uint_t, Scalar>(b);
666 uint_t result = a_as_uint | b_as_uint;
667 return numext::bit_cast<Scalar, uint_t>(result);
669 static EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE Scalar run_xor(
const Scalar& a,
const Scalar& b) {
670 uint_t a_as_uint = numext::bit_cast<uint_t, Scalar>(a);
671 uint_t b_as_uint = numext::bit_cast<uint_t, Scalar>(b);
672 uint_t result = a_as_uint ^ b_as_uint;
673 return numext::bit_cast<Scalar, uint_t>(result);
677template <
typename Scalar>
678struct bitwise_binary_impl<Scalar, true> {
679 using Real =
typename NumTraits<Scalar>::Real;
680 static EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE Scalar run_and(
const Scalar& a,
const Scalar& b) {
681 Real real_result = bitwise_binary_impl<Real>::run_and(numext::real(a), numext::real(b));
682 Real imag_result = bitwise_binary_impl<Real>::run_and(numext::imag(a), numext::imag(b));
683 return Scalar(real_result, imag_result);
685 static EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE Scalar run_or(
const Scalar& a,
const Scalar& b) {
686 Real real_result = bitwise_binary_impl<Real>::run_or(numext::real(a), numext::real(b));
687 Real imag_result = bitwise_binary_impl<Real>::run_or(numext::imag(a), numext::imag(b));
688 return Scalar(real_result, imag_result);
690 static EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE Scalar run_xor(
const Scalar& a,
const Scalar& b) {
691 Real real_result = bitwise_binary_impl<Real>::run_xor(numext::real(a), numext::real(b));
692 Real imag_result = bitwise_binary_impl<Real>::run_xor(numext::imag(a), numext::imag(b));
693 return Scalar(real_result, imag_result);
702template <
typename Scalar>
703struct scalar_bitwise_and_op {
704 EIGEN_STATIC_ASSERT(!NumTraits<Scalar>::RequireInitialization,
705 BITWISE OPERATIONS MAY ONLY BE PERFORMED ON PLAIN DATA TYPES)
706 EIGEN_STATIC_ASSERT((!std::is_same<Scalar, bool>::value), DONT USE BITWISE OPS ON BOOLEAN TYPES)
707 using result_type = Scalar;
708 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE Scalar operator()(
const Scalar& a,
const Scalar& b)
const {
709 return bitwise_binary_impl<Scalar>::run_and(a, b);
711 template <
typename Packet>
712 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(
const Packet& a,
const Packet& b)
const {
716template <
typename Scalar>
717struct functor_traits<scalar_bitwise_and_op<Scalar>> {
718 enum { Cost = NumTraits<Scalar>::AddCost, PacketAccess =
true };
726template <
typename Scalar>
727struct scalar_bitwise_or_op {
728 EIGEN_STATIC_ASSERT(!NumTraits<Scalar>::RequireInitialization,
729 BITWISE OPERATIONS MAY ONLY BE PERFORMED ON PLAIN DATA TYPES)
730 EIGEN_STATIC_ASSERT((!std::is_same<Scalar, bool>::value), DONT USE BITWISE OPS ON BOOLEAN TYPES)
731 using result_type = Scalar;
732 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE Scalar operator()(
const Scalar& a,
const Scalar& b)
const {
733 return bitwise_binary_impl<Scalar>::run_or(a, b);
735 template <
typename Packet>
736 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(
const Packet& a,
const Packet& b)
const {
740template <
typename Scalar>
741struct functor_traits<scalar_bitwise_or_op<Scalar>> {
742 enum { Cost = NumTraits<Scalar>::AddCost, PacketAccess =
true };
750template <
typename Scalar>
751struct scalar_bitwise_xor_op {
752 EIGEN_STATIC_ASSERT(!NumTraits<Scalar>::RequireInitialization,
753 BITWISE OPERATIONS MAY ONLY BE PERFORMED ON PLAIN DATA TYPES)
754 EIGEN_STATIC_ASSERT((!std::is_same<Scalar, bool>::value), DONT USE BITWISE OPS ON BOOLEAN TYPES)
755 using result_type = Scalar;
756 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE Scalar operator()(
const Scalar& a,
const Scalar& b)
const {
757 return bitwise_binary_impl<Scalar>::run_xor(a, b);
759 template <
typename Packet>
760 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(
const Packet& a,
const Packet& b)
const {
764template <
typename Scalar>
765struct functor_traits<scalar_bitwise_xor_op<Scalar>> {
766 enum { Cost = NumTraits<Scalar>::AddCost, PacketAccess =
true };
774template <
typename LhsScalar,
typename RhsScalar>
775struct scalar_absolute_difference_op : binary_op_base<LhsScalar, RhsScalar> {
776 using result_type =
typename ScalarBinaryOpTraits<LhsScalar, RhsScalar, scalar_absolute_difference_op>::ReturnType;
777#ifdef EIGEN_SCALAR_BINARY_OP_PLUGIN
778 scalar_absolute_difference_op(){EIGEN_SCALAR_BINARY_OP_PLUGIN}
780 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE result_type
781 operator()(
const LhsScalar& a,
const RhsScalar& b)
const {
782 return numext::absdiff(a, b);
784 template <
typename Packet>
785 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(
const Packet& a,
const Packet& b)
const {
786 return internal::pabsdiff(a, b);
789template <
typename LhsScalar,
typename RhsScalar>
790struct functor_traits<scalar_absolute_difference_op<LhsScalar, RhsScalar>> {
792 Cost = (NumTraits<LhsScalar>::AddCost + NumTraits<RhsScalar>::AddCost) / 2,
793 PacketAccess = std::is_same<LhsScalar, RhsScalar>::value && packet_traits<LhsScalar>::HasAbsDiff
797template <
typename LhsScalar,
typename RhsScalar>
798struct scalar_atan2_op {
799 using Scalar = LhsScalar;
801 static constexpr bool Enable =
802 std::is_same<LhsScalar, RhsScalar>::value && !NumTraits<Scalar>::IsInteger && !NumTraits<Scalar>::IsComplex;
803 EIGEN_STATIC_ASSERT(Enable,
"LhsScalar and RhsScalar must be the same non-integer, non-complex type")
805 EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE Scalar operator()(const Scalar& y, const Scalar& x)
const {
806 return numext::atan2(y, x);
808 template <
typename Packet>
809 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(
const Packet& y,
const Packet& x)
const {
810 return internal::patan2(y, x);
814template <
typename LhsScalar,
typename RhsScalar>
815struct functor_traits<scalar_atan2_op<LhsScalar, RhsScalar>> {
816 using Scalar = LhsScalar;
818 PacketAccess = std::is_same<LhsScalar, RhsScalar>::value && packet_traits<Scalar>::HasATan &&
819 packet_traits<Scalar>::HasDiv && !NumTraits<Scalar>::IsInteger && !NumTraits<Scalar>::IsComplex,
820 Cost = int(scalar_div_cost<Scalar, PacketAccess>::value) + int(functor_traits<scalar_atan_op<Scalar>>::Cost)
828template <
typename BinaryOp>
829struct bind1st_op : BinaryOp {
830 using first_argument_type =
typename BinaryOp::first_argument_type;
831 using second_argument_type =
typename BinaryOp::second_argument_type;
832 using result_type =
typename BinaryOp::result_type;
834 EIGEN_DEVICE_FUNC
constexpr explicit bind1st_op(
const first_argument_type& val) : m_value(val) {}
836 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE result_type operator()(
const second_argument_type& b)
const {
837 return BinaryOp::operator()(m_value, b);
840 template <
typename Packet>
841 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(
const Packet& b)
const {
842 return BinaryOp::packetOp(internal::pset1<Packet>(m_value), b);
845 first_argument_type m_value;
847template <
typename BinaryOp>
848struct functor_traits<bind1st_op<BinaryOp>> : functor_traits<BinaryOp> {};
850template <
typename BinaryOp>
851struct bind2nd_op : BinaryOp {
852 using first_argument_type =
typename BinaryOp::first_argument_type;
853 using second_argument_type =
typename BinaryOp::second_argument_type;
854 using result_type =
typename BinaryOp::result_type;
856 EIGEN_DEVICE_FUNC
constexpr explicit bind2nd_op(
const second_argument_type& val) : m_value(val) {}
858 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE result_type operator()(
const first_argument_type& a)
const {
859 return BinaryOp::operator()(a, m_value);
862 template <
typename Packet>
863 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(
const Packet& a)
const {
864 return BinaryOp::packetOp(a, internal::pset1<Packet>(m_value));
867 second_argument_type m_value;
869template <
typename BinaryOp>
870struct functor_traits<bind2nd_op<BinaryOp>> : functor_traits<BinaryOp> {};