11#ifndef EIGEN_UNARY_FUNCTORS_H
12#define EIGEN_UNARY_FUNCTORS_H
15#include "../InternalHeaderCheck.h"
26template <
typename Scalar>
27struct scalar_opposite_op {
28 EIGEN_STATIC_ASSERT((!std::is_same<Scalar, bool>::value),
29 BOOLEAN_NEGATION_IS_NOT_SUPPORTED__CAST_TO_A_SIGNED_INTEGER_TYPE)
30 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE Scalar operator()(
const Scalar& a)
const {
return numext::negate(a); }
31 template <
typename Packet>
32 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(
const Packet& a)
const {
33 return internal::pnegate(a);
36template <
typename Scalar>
37struct functor_traits<scalar_opposite_op<Scalar>> {
38 enum { Cost = NumTraits<Scalar>::AddCost, PacketAccess = packet_traits<Scalar>::HasNegate };
46template <
typename Scalar>
48 using result_type =
typename NumTraits<Scalar>::Real;
49 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE result_type operator()(
const Scalar& a)
const {
50 return numext::abs(a);
52 template <
typename Packet>
53 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(
const Packet& a)
const {
54 return internal::pabs(a);
57template <
typename Scalar>
58struct functor_traits<scalar_abs_op<Scalar>> {
59 enum { Cost = NumTraits<Scalar>::AddCost, PacketAccess = packet_traits<Scalar>::HasAbs };
67template <
typename Scalar>
68struct scalar_score_coeff_op : scalar_abs_op<Scalar> {
69 using Score_is_abs = void;
71template <
typename Scalar>
72struct functor_traits<scalar_score_coeff_op<Scalar>> : functor_traits<scalar_abs_op<Scalar>> {};
75template <
typename Scalar,
typename =
void>
76struct abs_knowing_score {
77 using result_type =
typename NumTraits<Scalar>::Real;
78 template <
typename Score>
79 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE result_type operator()(
const Scalar& a,
const Score&)
const {
80 return numext::abs(a);
83template <
typename Scalar>
84struct abs_knowing_score<Scalar, typename scalar_score_coeff_op<Scalar>::Score_is_abs> {
85 using result_type =
typename NumTraits<Scalar>::Real;
86 template <
typename Scal>
87 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE result_type operator()(
const Scal&,
const result_type& a)
const {
97template <
typename Scalar>
98struct scalar_abs2_op {
99 using result_type =
typename NumTraits<Scalar>::Real;
100 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE result_type operator()(
const Scalar& a)
const {
101 return numext::abs2(a);
103 template <
typename Packet>
104 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(
const Packet& a)
const {
105 return internal::pmul(a, a);
108template <
typename Scalar>
109struct functor_traits<scalar_abs2_op<Scalar>> {
111 Cost = NumTraits<Scalar>::MulCost,
112 PacketAccess = packet_traits<Scalar>::HasMul && !NumTraits<Scalar>::IsComplex
121template <
typename Scalar>
122struct scalar_conjugate_op {
123 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE Scalar operator()(
const Scalar& a)
const {
return numext::conj(a); }
124 template <
typename Packet>
125 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(
const Packet& a)
const {
126 return internal::pconj(a);
129template <
typename Scalar>
130struct functor_traits<scalar_conjugate_op<Scalar>> {
141 PacketAccess = packet_traits<Scalar>::HasConj
150template <
typename Scalar>
151struct scalar_arg_op {
152 using result_type =
typename NumTraits<Scalar>::Real;
153 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE result_type operator()(
const Scalar& a)
const {
154 return numext::arg(a);
156 template <
typename Packet>
157 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(
const Packet& a)
const {
158 return internal::parg(a);
161template <
typename Scalar>
162struct functor_traits<scalar_arg_op<Scalar>> {
164 Cost = NumTraits<Scalar>::IsComplex ? 5 * NumTraits<Scalar>::MulCost : NumTraits<Scalar>::AddCost,
165 PacketAccess = packet_traits<Scalar>::HasArg
174template <
typename Scalar>
175struct scalar_carg_op {
176 using result_type = Scalar;
177 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE Scalar operator()(
const Scalar& a)
const {
178 return Scalar(numext::arg(a));
180 template <
typename Packet>
181 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(
const Packet& a)
const {
185template <
typename Scalar>
186struct functor_traits<scalar_carg_op<Scalar>> {
187 using RealScalar =
typename NumTraits<Scalar>::Real;
189 Cost = functor_traits<scalar_atan2_op<RealScalar>>::Cost,
193 NumTraits<Scalar>::IsComplex && packet_traits<RealScalar>::HasATan && packet_traits<RealScalar>::HasDiv
202template <
typename Scalar,
typename NewType>
203struct scalar_cast_op {
204 using result_type = NewType;
205 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE NewType operator()(
const Scalar& a)
const {
206 return cast<Scalar, NewType>(a);
210template <
typename Scalar,
typename NewType>
211struct functor_traits<scalar_cast_op<Scalar, NewType>> {
212 enum { Cost = std::is_same<Scalar, NewType>::value ? 0 : NumTraits<NewType>::AddCost, PacketAccess =
false };
221template <
typename SrcType,
typename DstType>
222struct core_cast_op : scalar_cast_op<SrcType, DstType> {};
224template <
typename SrcType,
typename DstType>
225struct functor_traits<core_cast_op<SrcType, DstType>> {
226 using CastingTraits = type_casting_traits<SrcType, DstType>;
228 Cost = std::is_same<SrcType, DstType>::value ? 0 : NumTraits<DstType>::AddCost,
229 PacketAccess = CastingTraits::VectorizedCast && (CastingTraits::SrcCoeffRatio <= 8)
238template <
typename Scalar,
int N>
239struct scalar_arithmetic_shift_right_op {
240 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE Scalar operator()(
const Scalar& a)
const {
241 return numext::arithmetic_shift_right(a, N);
243 template <
typename Packet>
244 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(
const Packet& a)
const {
245 return internal::parithmetic_shift_right<N>(a);
249template <
typename Scalar,
int N>
250struct functor_traits<scalar_arithmetic_shift_right_op<Scalar, N>> {
251 enum { Cost = NumTraits<Scalar>::AddCost, PacketAccess = packet_traits<Scalar>::HasShift && N != 0 };
259template <
typename Scalar,
int N>
260struct scalar_logical_shift_right_op {
261 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE Scalar operator()(
const Scalar& a)
const {
262 return numext::logical_shift_right(a, N);
264 template <
typename Packet>
265 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(
const Packet& a)
const {
266 return internal::plogical_shift_right<N>(a);
269template <
typename Scalar,
int N>
270struct functor_traits<scalar_logical_shift_right_op<Scalar, N>> {
271 enum { Cost = NumTraits<Scalar>::AddCost, PacketAccess = packet_traits<Scalar>::HasShift && N != 0 };
279template <
typename Scalar,
int N>
280struct scalar_logical_shift_left_op {
281 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE Scalar operator()(
const Scalar& a)
const {
282 return numext::logical_shift_left(a, N);
284 template <
typename Packet>
285 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(
const Packet& a)
const {
286 return internal::plogical_shift_left<N>(a);
289template <
typename Scalar,
int N>
290struct functor_traits<scalar_logical_shift_left_op<Scalar, N>> {
291 enum { Cost = NumTraits<Scalar>::AddCost, PacketAccess = packet_traits<Scalar>::HasShift };
299template <
typename Scalar>
300struct scalar_real_op {
301 using result_type =
typename NumTraits<Scalar>::Real;
302 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE result_type operator()(
const Scalar& a)
const {
303 return numext::real(a);
306template <
typename Scalar>
307struct functor_traits<scalar_real_op<Scalar>> {
308 enum { Cost = 0, PacketAccess =
false };
316template <
typename Scalar>
317struct scalar_imag_op {
318 using result_type =
typename NumTraits<Scalar>::Real;
319 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE result_type operator()(
const Scalar& a)
const {
320 return numext::imag(a);
323template <
typename Scalar>
324struct functor_traits<scalar_imag_op<Scalar>> {
325 enum { Cost = 0, PacketAccess =
false };
333template <
typename Scalar>
334struct scalar_real_ref_op {
335 using result_type =
typename NumTraits<Scalar>::Real;
336 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE
const result_type& operator()(
const Scalar& a)
const {
337 return numext::real_ref(a);
339 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE result_type& operator()(Scalar& a)
const {
340 return numext::real_ref(a);
343template <
typename Scalar>
344struct functor_traits<scalar_real_ref_op<Scalar>> {
345 enum { Cost = 0, PacketAccess =
false };
353template <
typename Scalar>
354struct scalar_imag_ref_op {
358 static_assert(NumTraits<Scalar>::IsComplex,
359 "THE IMAGINARY PART OF A REAL-VALUED OBJECT IS NOT AN LVALUE. USE THE READ-ONLY imag() OVERLOAD.");
360 using result_type =
typename NumTraits<Scalar>::Real;
361 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE result_type& operator()(Scalar& a)
const {
362 return numext::imag_ref(a);
364 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE
const result_type& operator()(
const Scalar& a)
const {
365 return numext::imag_ref(a);
368template <
typename Scalar>
369struct functor_traits<scalar_imag_ref_op<Scalar>> {
370 enum { Cost = 0, PacketAccess =
false };
379template <
typename Scalar>
380struct scalar_exp_op {
381 EIGEN_DEVICE_FUNC
constexpr inline Scalar operator()(
const Scalar& a)
const {
return internal::pexp(a); }
382 template <
typename Packet>
383 EIGEN_DEVICE_FUNC
inline Packet packetOp(
const Packet& a)
const {
384 return internal::pexp(a);
387template <
typename Scalar>
388struct functor_traits<scalar_exp_op<Scalar>> {
390 PacketAccess = packet_traits<Scalar>::HasExp,
392#ifdef EIGEN_VECTORIZE_FMA
394 Cost = (
sizeof(Scalar) == 4
396 ? (8 * NumTraits<Scalar>::AddCost + 6 * NumTraits<Scalar>::MulCost)
398 : (14 * NumTraits<Scalar>::AddCost + 6 * NumTraits<Scalar>::MulCost +
399 scalar_div_cost<Scalar, packet_traits<Scalar>::HasDiv>::value))
401 Cost = (
sizeof(Scalar) == 4
403 ? (21 * NumTraits<Scalar>::AddCost + 13 * NumTraits<Scalar>::MulCost)
405 : (23 * NumTraits<Scalar>::AddCost + 12 * NumTraits<Scalar>::MulCost +
406 scalar_div_cost<Scalar, packet_traits<Scalar>::HasDiv>::value))
411template <
typename Scalar>
412struct scalar_exp2_op {
413 EIGEN_DEVICE_FUNC
constexpr inline Scalar operator()(
const Scalar& a)
const {
return internal::pexp2(a); }
414 template <
typename Packet>
415 EIGEN_DEVICE_FUNC
inline Packet packetOp(
const Packet& a)
const {
416 return internal::pexp2(a);
419template <
typename Scalar>
420struct functor_traits<scalar_exp2_op<Scalar>> {
423 PacketAccess = packet_traits<Scalar>::HasExp && !NumTraits<Scalar>::IsComplex,
424 Cost = functor_traits<scalar_exp_op<Scalar>>::Cost
434template <
typename Scalar>
435struct scalar_ldexp_op {
436 static_assert(!NumTraits<Scalar>::IsComplex && !NumTraits<Scalar>::IsInteger,
437 "ldexp is only defined for real floating-point scalar types");
438 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE
explicit scalar_ldexp_op(
int exponent) : m_exponent(exponent) {}
439 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(
const Scalar& a)
const {
440 return numext::ldexp(a, m_exponent);
442 template <
typename Packet>
443 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(
const Packet& a)
const {
445 return internal::pldexp(a, pset1<Packet>(
static_cast<Scalar
>(m_exponent)));
449 const int m_exponent;
451template <
typename Scalar>
452struct functor_traits<scalar_ldexp_op<Scalar>> {
455 PacketAccess = packet_traits<Scalar>::HasExp,
456 Cost = 4 * NumTraits<Scalar>::MulCost
466template <
typename Scalar>
467struct scalar_expm1_op {
468 EIGEN_DEVICE_FUNC
constexpr inline Scalar operator()(
const Scalar& a)
const {
return numext::expm1(a); }
469 template <
typename Packet>
470 EIGEN_DEVICE_FUNC
inline Packet packetOp(
const Packet& a)
const {
471 return internal::pexpm1(a);
474template <
typename Scalar>
475struct functor_traits<scalar_expm1_op<Scalar>> {
477 PacketAccess = packet_traits<Scalar>::HasExpm1,
478 Cost = functor_traits<scalar_exp_op<Scalar>>::Cost
488template <
typename Scalar>
489struct scalar_log_op {
490 EIGEN_DEVICE_FUNC
constexpr inline Scalar operator()(
const Scalar& a)
const {
return numext::log(a); }
491 template <
typename Packet>
492 EIGEN_DEVICE_FUNC
inline Packet packetOp(
const Packet& a)
const {
493 return internal::plog(a);
496template <
typename Scalar>
497struct functor_traits<scalar_log_op<Scalar>> {
499 PacketAccess = packet_traits<Scalar>::HasLog,
502#ifdef EIGEN_VECTORIZE_FMA
504 ? (20 * NumTraits<Scalar>::AddCost + 7 * NumTraits<Scalar>::MulCost)
507 ? (36 * NumTraits<Scalar>::AddCost + 14 * NumTraits<Scalar>::MulCost)
510 :
sizeof(Scalar) == 4 ? 40 : 85)
520template <
typename Scalar>
521struct scalar_log1p_op {
522 EIGEN_DEVICE_FUNC
constexpr inline Scalar operator()(
const Scalar& a)
const {
return numext::log1p(a); }
523 template <
typename Packet>
524 EIGEN_DEVICE_FUNC
inline Packet packetOp(
const Packet& a)
const {
525 return internal::plog1p(a);
528template <
typename Scalar>
529struct functor_traits<scalar_log1p_op<Scalar>> {
531 PacketAccess = packet_traits<Scalar>::HasLog1p,
532 Cost = functor_traits<scalar_log_op<Scalar>>::Cost
542template <
typename Scalar>
543struct scalar_log10_op {
544 EIGEN_DEVICE_FUNC
constexpr inline Scalar operator()(
const Scalar& a)
const {
return numext::log10(a); }
545 template <
typename Packet>
546 EIGEN_DEVICE_FUNC
inline Packet packetOp(
const Packet& a)
const {
547 return internal::plog10(a);
550template <
typename Scalar>
551struct functor_traits<scalar_log10_op<Scalar>> {
552 enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasLog10 };
561template <
typename Scalar>
562struct scalar_log2_op {
563 using RealScalar =
typename NumTraits<Scalar>::Real;
564 EIGEN_DEVICE_FUNC
constexpr inline Scalar operator()(
const Scalar& a)
const {
565 return run(a, std::integral_constant<int, kKind>());
567 template <
typename Packet>
568 EIGEN_DEVICE_FUNC
inline Packet packetOp(
const Packet& a)
const {
569 return internal::plog2(a);
574 static constexpr int kKind =
575 std::is_floating_point<Scalar>::value ? 0
576 : std::is_floating_point<RealScalar>::value && std::is_same<Scalar, std::complex<RealScalar>>::value ? 1
580 EIGEN_DEVICE_FUNC
static Scalar run(
const Scalar& a, std::integral_constant<int, 0>) {
return numext::log2(a); }
581 EIGEN_DEVICE_FUNC
static Scalar run(
const Scalar& a, std::integral_constant<int, 1>) {
582 return internal::complex_log2(a);
584 EIGEN_DEVICE_FUNC
static Scalar run(
const Scalar& a, std::integral_constant<int, 2>) {
585 return internal::mul(RealScalar(EIGEN_LOG2E), numext::log(a));
588template <
typename Scalar>
589struct functor_traits<scalar_log2_op<Scalar>> {
590 enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasLog };
597template <
typename Scalar>
598struct scalar_sqrt_op {
599 EIGEN_DEVICE_FUNC
constexpr inline Scalar operator()(
const Scalar& a)
const {
return numext::sqrt(a); }
600 template <
typename Packet>
601 EIGEN_DEVICE_FUNC
inline Packet packetOp(
const Packet& a)
const {
602 return internal::psqrt(a);
605template <
typename Scalar>
606struct functor_traits<scalar_sqrt_op<Scalar>> {
610 Cost = (
sizeof(Scalar) == 8 ? 28
612 : (3 * NumTraits<Scalar>::AddCost + 5 * NumTraits<Scalar>::MulCost)),
615 Cost = (
sizeof(Scalar) == 8 ? 28 : 14),
617 PacketAccess = packet_traits<Scalar>::HasSqrt
623struct scalar_sqrt_op<bool> {
624 EIGEN_DEPRECATED EIGEN_DEVICE_FUNC
inline bool operator()(
const bool& a)
const {
return a; }
625 template <
typename Packet>
626 EIGEN_DEPRECATED EIGEN_DEVICE_FUNC
inline Packet packetOp(
const Packet& a)
const {
631struct functor_traits<scalar_sqrt_op<bool>> {
632 enum { Cost = 1, PacketAccess = packet_traits<bool>::Vectorizable };
639template <
typename Scalar>
640struct scalar_cbrt_op {
641 EIGEN_DEVICE_FUNC
constexpr inline Scalar operator()(
const Scalar& a)
const {
return numext::cbrt(a); }
642 template <
typename Packet>
643 EIGEN_DEVICE_FUNC
inline Packet packetOp(
const Packet& a)
const {
644 return internal::pcbrt(a);
648template <
typename Scalar>
649struct functor_traits<scalar_cbrt_op<Scalar>> {
650 enum { Cost = 20 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasCbrt };
657template <
typename Scalar>
658struct scalar_rsqrt_op {
659 EIGEN_DEVICE_FUNC
constexpr inline Scalar operator()(
const Scalar& a)
const {
return numext::rsqrt(a); }
660 template <
typename Packet>
661 EIGEN_DEVICE_FUNC
inline Packet packetOp(
const Packet& a)
const {
662 return internal::prsqrt(a);
666template <
typename Scalar>
667struct functor_traits<scalar_rsqrt_op<Scalar>> {
668 enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasRsqrt };
675template <
typename Scalar>
676struct scalar_cos_op {
677 EIGEN_DEVICE_FUNC
constexpr inline Scalar operator()(
const Scalar& a)
const {
return numext::cos(a); }
678 template <
typename Packet>
679 EIGEN_DEVICE_FUNC
inline Packet packetOp(
const Packet& a)
const {
680 return internal::pcos(a);
683template <
typename Scalar>
684struct functor_traits<scalar_cos_op<Scalar>> {
685 enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasCos };
692template <
typename Scalar>
693struct scalar_sin_op {
694 EIGEN_DEVICE_FUNC
constexpr inline Scalar operator()(
const Scalar& a)
const {
return numext::sin(a); }
695 template <
typename Packet>
696 EIGEN_DEVICE_FUNC
inline Packet packetOp(
const Packet& a)
const {
697 return internal::psin(a);
700template <
typename Scalar>
701struct functor_traits<scalar_sin_op<Scalar>> {
702 enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasSin };
709template <
typename Scalar>
710struct scalar_tan_op {
711 EIGEN_DEVICE_FUNC
constexpr inline Scalar operator()(
const Scalar& a)
const {
return numext::tan(a); }
712 template <
typename Packet>
713 EIGEN_DEVICE_FUNC
inline Packet packetOp(
const Packet& a)
const {
714 return internal::ptan(a);
717template <
typename Scalar>
718struct functor_traits<scalar_tan_op<Scalar>> {
719 enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasTan };
726template <
typename Scalar>
727struct scalar_acos_op {
728 EIGEN_DEVICE_FUNC
constexpr inline Scalar operator()(
const Scalar& a)
const {
return numext::acos(a); }
729 template <
typename Packet>
730 EIGEN_DEVICE_FUNC
inline Packet packetOp(
const Packet& a)
const {
731 return internal::pacos(a);
734template <
typename Scalar>
735struct functor_traits<scalar_acos_op<Scalar>> {
736 enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasACos };
743template <
typename Scalar>
744struct scalar_asin_op {
745 EIGEN_DEVICE_FUNC
constexpr inline Scalar operator()(
const Scalar& a)
const {
return numext::asin(a); }
746 template <
typename Packet>
747 EIGEN_DEVICE_FUNC
inline Packet packetOp(
const Packet& a)
const {
748 return internal::pasin(a);
751template <
typename Scalar>
752struct functor_traits<scalar_asin_op<Scalar>> {
753 enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasASin };
760template <
typename Scalar>
761struct scalar_atan_op {
762 EIGEN_DEVICE_FUNC
constexpr inline Scalar operator()(
const Scalar& a)
const {
return numext::atan(a); }
763 template <
typename Packet>
764 EIGEN_DEVICE_FUNC
inline Packet packetOp(
const Packet& a)
const {
765 return internal::patan(a);
768template <
typename Scalar>
769struct functor_traits<scalar_atan_op<Scalar>> {
770 enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasATan };
777template <
typename Scalar>
778struct scalar_tanh_op {
779 EIGEN_DEVICE_FUNC
constexpr inline Scalar operator()(
const Scalar& a)
const {
return numext::tanh(a); }
780 template <
typename Packet>
781 EIGEN_DEVICE_FUNC
inline Packet packetOp(
const Packet& x)
const {
786template <
typename Scalar>
787struct functor_traits<scalar_tanh_op<Scalar>> {
789 PacketAccess = packet_traits<Scalar>::HasTanh,
790 Cost = ((EIGEN_FAST_MATH && std::is_same<Scalar, float>::value)
792#ifdef EIGEN_VECTORIZE_FMA
795 ? (2 * NumTraits<Scalar>::AddCost + 6 * NumTraits<Scalar>::MulCost +
796 scalar_div_cost<Scalar, packet_traits<Scalar>::HasDiv>::value)
798 ? (11 * NumTraits<Scalar>::AddCost + 11 * NumTraits<Scalar>::MulCost +
799 scalar_div_cost<Scalar, packet_traits<Scalar>::HasDiv>::value)
802 : (6 * NumTraits<Scalar>::AddCost + 3 * NumTraits<Scalar>::MulCost +
803 2 * scalar_div_cost<Scalar, packet_traits<Scalar>::HasDiv>::value +
804 functor_traits<scalar_exp_op<Scalar>>::Cost))
812template <
typename Scalar>
813struct scalar_atanh_op {
814 EIGEN_DEVICE_FUNC
constexpr inline Scalar operator()(
const Scalar& a)
const {
return numext::atanh(a); }
815 template <
typename Packet>
816 EIGEN_DEVICE_FUNC
inline Packet packetOp(
const Packet& x)
const {
821template <
typename Scalar>
822struct functor_traits<scalar_atanh_op<Scalar>> {
823 enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasATanh };
830template <
typename Scalar>
831struct scalar_sinh_op {
832 EIGEN_DEVICE_FUNC
constexpr inline Scalar operator()(
const Scalar& a)
const {
return numext::sinh(a); }
833 template <
typename Packet>
834 EIGEN_DEVICE_FUNC
inline Packet packetOp(
const Packet& a)
const {
835 return internal::psinh(a);
838template <
typename Scalar>
839struct functor_traits<scalar_sinh_op<Scalar>> {
840 enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasSinh };
847template <
typename Scalar>
848struct scalar_asinh_op {
849 EIGEN_DEVICE_FUNC
constexpr inline Scalar operator()(
const Scalar& a)
const {
return numext::asinh(a); }
850 template <
typename Packet>
851 EIGEN_DEVICE_FUNC
inline Packet packetOp(
const Packet& a)
const {
852 return internal::pasinh(a);
856template <
typename Scalar>
857struct functor_traits<scalar_asinh_op<Scalar>> {
858 enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasASinh };
865template <
typename Scalar>
866struct scalar_cosh_op {
867 EIGEN_DEVICE_FUNC
constexpr inline Scalar operator()(
const Scalar& a)
const {
return numext::cosh(a); }
868 template <
typename Packet>
869 EIGEN_DEVICE_FUNC
inline Packet packetOp(
const Packet& a)
const {
870 return internal::pcosh(a);
873template <
typename Scalar>
874struct functor_traits<scalar_cosh_op<Scalar>> {
875 enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasCosh };
882template <
typename Scalar>
883struct scalar_acosh_op {
884 EIGEN_DEVICE_FUNC
constexpr inline Scalar operator()(
const Scalar& a)
const {
return numext::acosh(a); }
885 template <
typename Packet>
886 EIGEN_DEVICE_FUNC
inline Packet packetOp(
const Packet& a)
const {
887 return internal::pacosh(a);
891template <
typename Scalar>
892struct functor_traits<scalar_acosh_op<Scalar>> {
893 enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasACosh };
900template <
typename Scalar>
901struct scalar_inverse_op {
902 EIGEN_DEVICE_FUNC
constexpr inline Scalar operator()(
const Scalar& a)
const {
return Scalar(1) / a; }
903 template <
typename Packet>
904 EIGEN_DEVICE_FUNC
inline Packet packetOp(
const Packet& a)
const {
905 return internal::preciprocal(a);
908template <
typename Scalar>
909struct functor_traits<scalar_inverse_op<Scalar>> {
911 PacketAccess = packet_traits<Scalar>::HasDiv,
915 Cost = (packet_traits<Scalar>::HasReciprocal ? 4 * NumTraits<Scalar>::MulCost
916 : scalar_div_cost<Scalar, PacketAccess>::value)
924template <
typename Scalar>
925struct scalar_square_op {
926 EIGEN_DEVICE_FUNC
constexpr inline Scalar operator()(
const Scalar& a)
const {
return internal::mul(a, a); }
927 template <
typename Packet>
928 EIGEN_DEVICE_FUNC
inline Packet packetOp(
const Packet& a)
const {
929 return internal::pmul(a, a);
932template <
typename Scalar>
933struct functor_traits<scalar_square_op<Scalar>> {
934 enum { Cost = NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasMul };
939struct scalar_square_op<bool> {
940 EIGEN_DEPRECATED EIGEN_DEVICE_FUNC
inline bool operator()(
const bool& a)
const {
return a; }
941 template <
typename Packet>
942 EIGEN_DEPRECATED EIGEN_DEVICE_FUNC
inline Packet packetOp(
const Packet& a)
const {
947struct functor_traits<scalar_square_op<bool>> {
948 enum { Cost = 0, PacketAccess = packet_traits<bool>::Vectorizable };
955template <
typename Scalar>
956struct scalar_cube_op {
957 EIGEN_DEVICE_FUNC
constexpr inline Scalar operator()(
const Scalar& a)
const {
958 return internal::mul(a, internal::mul(a, a));
960 template <
typename Packet>
961 EIGEN_DEVICE_FUNC
inline Packet packetOp(
const Packet& a)
const {
962 return internal::pmul(a, pmul(a, a));
965template <
typename Scalar>
966struct functor_traits<scalar_cube_op<Scalar>> {
967 enum { Cost = 2 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasMul };
972struct scalar_cube_op<bool> {
973 EIGEN_DEPRECATED EIGEN_DEVICE_FUNC
inline bool operator()(
const bool& a)
const {
return a; }
974 template <
typename Packet>
975 EIGEN_DEPRECATED EIGEN_DEVICE_FUNC
inline Packet packetOp(
const Packet& a)
const {
980struct functor_traits<scalar_cube_op<bool>> {
981 enum { Cost = 0, PacketAccess = packet_traits<bool>::Vectorizable };
988template <
typename Scalar>
989struct scalar_round_op {
990 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE Scalar operator()(
const Scalar& a)
const {
return numext::round(a); }
991 template <
typename Packet>
992 EIGEN_DEVICE_FUNC
inline Packet packetOp(
const Packet& a)
const {
993 return internal::pround(a);
996template <
typename Scalar>
997struct functor_traits<scalar_round_op<Scalar>> {
999 Cost = NumTraits<Scalar>::MulCost,
1000 PacketAccess = packet_traits<Scalar>::HasRound || NumTraits<Scalar>::IsInteger
1008template <
typename Scalar>
1009struct scalar_floor_op {
1010 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE Scalar operator()(
const Scalar& a)
const {
return numext::floor(a); }
1011 template <
typename Packet>
1012 EIGEN_DEVICE_FUNC
inline Packet packetOp(
const Packet& a)
const {
1013 return internal::pfloor(a);
1016template <
typename Scalar>
1017struct functor_traits<scalar_floor_op<Scalar>> {
1019 Cost = NumTraits<Scalar>::MulCost,
1020 PacketAccess = packet_traits<Scalar>::HasRound || NumTraits<Scalar>::IsInteger
1028template <
typename Scalar>
1029struct scalar_rint_op {
1030 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE Scalar operator()(
const Scalar& a)
const {
return numext::rint(a); }
1031 template <
typename Packet>
1032 EIGEN_DEVICE_FUNC
inline Packet packetOp(
const Packet& a)
const {
1033 return internal::print(a);
1036template <
typename Scalar>
1037struct functor_traits<scalar_rint_op<Scalar>> {
1039 Cost = NumTraits<Scalar>::MulCost,
1040 PacketAccess = packet_traits<Scalar>::HasRound || NumTraits<Scalar>::IsInteger
1048template <
typename Scalar>
1049struct scalar_ceil_op {
1050 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE Scalar operator()(
const Scalar& a)
const {
return numext::ceil(a); }
1051 template <
typename Packet>
1052 EIGEN_DEVICE_FUNC
inline Packet packetOp(
const Packet& a)
const {
1053 return internal::pceil(a);
1056template <
typename Scalar>
1057struct functor_traits<scalar_ceil_op<Scalar>> {
1059 Cost = NumTraits<Scalar>::MulCost,
1060 PacketAccess = packet_traits<Scalar>::HasRound || NumTraits<Scalar>::IsInteger
1068template <
typename Scalar>
1069struct scalar_trunc_op {
1070 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE Scalar operator()(
const Scalar& a)
const {
return numext::trunc(a); }
1071 template <
typename Packet>
1072 EIGEN_DEVICE_FUNC
inline Packet packetOp(
const Packet& a)
const {
1073 return internal::ptrunc(a);
1076template <
typename Scalar>
1077struct functor_traits<scalar_trunc_op<Scalar>> {
1079 Cost = NumTraits<Scalar>::MulCost,
1080 PacketAccess = packet_traits<Scalar>::HasRound || NumTraits<Scalar>::IsInteger
1088template <
typename Scalar,
bool UseTypedPredicate = false>
1089struct scalar_isnan_op {
1090 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE
bool operator()(
const Scalar& a)
const {
1091#if defined(EIGEN_SYCL_DEVICE_ONLY)
1092 return numext::isnan(a);
1094 return numext::isnan EIGEN_NOT_A_MACRO(a);
1099template <
typename Scalar>
1100struct scalar_isnan_op<Scalar, true> {
1101 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE Scalar operator()(
const Scalar& a)
const {
1102#if defined(EIGEN_SYCL_DEVICE_ONLY)
1103 return (numext::isnan(a) ? ptrue(a) : pzero(a));
1105 return (numext::isnan EIGEN_NOT_A_MACRO(a) ? ptrue(a) : pzero(a));
1108 template <
typename Packet>
1109 EIGEN_DEVICE_FUNC
inline Packet packetOp(
const Packet& a)
const {
1114template <
typename Scalar,
bool UseTypedPredicate>
1115struct functor_traits<scalar_isnan_op<Scalar, UseTypedPredicate>> {
1116 enum { Cost = NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasCmp && UseTypedPredicate };
1123template <
typename Scalar,
bool UseTypedPredicate = false>
1124struct scalar_isinf_op {
1125 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE
bool operator()(
const Scalar& a)
const {
1126#if defined(EIGEN_SYCL_DEVICE_ONLY)
1127 return numext::isinf(a);
1129 return (numext::isinf)(a);
1134template <
typename Scalar>
1135struct scalar_isinf_op<Scalar, true> {
1136 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE Scalar operator()(
const Scalar& a)
const {
1137#if defined(EIGEN_SYCL_DEVICE_ONLY)
1138 return (numext::isinf(a) ? ptrue(a) : pzero(a));
1140 return (numext::isinf EIGEN_NOT_A_MACRO(a) ? ptrue(a) : pzero(a));
1143 template <
typename Packet>
1144 EIGEN_DEVICE_FUNC
inline Packet packetOp(
const Packet& a)
const {
1148template <
typename Scalar,
bool UseTypedPredicate>
1149struct functor_traits<scalar_isinf_op<Scalar, UseTypedPredicate>> {
1150 enum { Cost = NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasCmp && UseTypedPredicate };
1157template <
typename Scalar,
bool UseTypedPredicate = false>
1158struct scalar_isfinite_op {
1159 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE
bool operator()(
const Scalar& a)
const {
1160#if defined(EIGEN_SYCL_DEVICE_ONLY)
1161 return numext::isfinite(a);
1163 return (numext::isfinite)(a);
1168template <
typename Scalar>
1169struct scalar_isfinite_op<Scalar, true> {
1170 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE Scalar operator()(
const Scalar& a)
const {
1171#if defined(EIGEN_SYCL_DEVICE_ONLY)
1172 return (numext::isfinite(a) ? ptrue(a) : pzero(a));
1174 return (numext::isfinite EIGEN_NOT_A_MACRO(a) ? ptrue(a) : pzero(a));
1177 template <
typename Packet>
1178 EIGEN_DEVICE_FUNC
inline Packet packetOp(
const Packet& a)
const {
1179 return pisfinite(a);
1182template <
typename Scalar,
bool UseTypedPredicate>
1183struct functor_traits<scalar_isfinite_op<Scalar, UseTypedPredicate>> {
1184 enum { Cost = NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasCmp && UseTypedPredicate };
1192template <
typename Scalar>
1193struct scalar_boolean_not_op {
1194 using result_type = Scalar;
1197 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE Scalar operator()(
const Scalar& a)
const {
1198 return Scalar(a == Scalar(0));
1200 template <
typename Packet>
1201 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(
const Packet& a)
const {
1202 const Packet cst_one = pset1<Packet>(Scalar(
true));
1203 EIGEN_IF_CONSTEXPR ((std::is_same<Scalar, bool>::value)) {
1205 return pandnot(cst_one, a);
1207 Packet not_a = pcmp_eq(a, pzero(a));
1208 return pand(not_a, cst_one);
1212template <
typename Scalar>
1213struct functor_traits<scalar_boolean_not_op<Scalar>> {
1214 enum { Cost = NumTraits<Scalar>::AddCost, PacketAccess = packet_traits<Scalar>::HasCmp };
1217template <typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
1218struct bitwise_unary_impl {
1219 static constexpr size_t Size =
sizeof(Scalar);
1220 using uint_t =
typename numext::get_integer_by_size<Size>::unsigned_type;
1221 static EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE Scalar run_not(
const Scalar& a) {
1222 uint_t a_as_uint = numext::bit_cast<uint_t, Scalar>(a);
1223 uint_t result = ~a_as_uint;
1224 return numext::bit_cast<Scalar, uint_t>(result);
1228template <
typename Scalar>
1229struct bitwise_unary_impl<Scalar, true> {
1230 using Real =
typename NumTraits<Scalar>::Real;
1231 static EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE Scalar run_not(
const Scalar& a) {
1232 Real real_result = bitwise_unary_impl<Real>::run_not(numext::real(a));
1233 Real imag_result = bitwise_unary_impl<Real>::run_not(numext::imag(a));
1234 return Scalar(real_result, imag_result);
1243template <
typename Scalar>
1244struct scalar_bitwise_not_op {
1245 EIGEN_STATIC_ASSERT(!NumTraits<Scalar>::RequireInitialization,
1246 BITWISE OPERATIONS MAY ONLY BE PERFORMED ON PLAIN DATA TYPES)
1247 EIGEN_STATIC_ASSERT((!std::is_same<Scalar, bool>::value), DONT USE BITWISE OPS ON BOOLEAN TYPES)
1248 using result_type = Scalar;
1249 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE Scalar operator()(
const Scalar& a)
const {
1250 return bitwise_unary_impl<Scalar>::run_not(a);
1252 template <
typename Packet>
1253 EIGEN_STRONG_INLINE Packet packetOp(
const Packet& a)
const {
1254 return pandnot(ptrue(a), a);
1257template <
typename Scalar>
1258struct functor_traits<scalar_bitwise_not_op<Scalar>> {
1259 enum { Cost = NumTraits<Scalar>::AddCost, PacketAccess =
true };
1266template <
typename Scalar>
1267struct scalar_sign_op {
1268 EIGEN_DEVICE_FUNC
constexpr inline Scalar operator()(
const Scalar& a)
const {
return numext::sign(a); }
1270 template <
typename Packet>
1271 EIGEN_DEVICE_FUNC
inline Packet packetOp(
const Packet& a)
const {
1272 return internal::psign(a);
1276template <
typename Scalar>
1277struct functor_traits<scalar_sign_op<Scalar>> {
1279 Cost = NumTraits<Scalar>::IsComplex ? (8 * NumTraits<Scalar>::MulCost)
1280 : (3 * NumTraits<Scalar>::AddCost),
1281 PacketAccess = packet_traits<Scalar>::HasSign && packet_traits<Scalar>::Vectorizable
1286template <
typename T,
typename EnableIf =
void>
1287struct scalar_logistic_op_impl {
1288 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T operator()(
const T& x)
const {
return packetOp(x); }
1290 template <
typename Packet>
1291 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(
const Packet& x)
const {
1292 const Packet one = pset1<Packet>(T(1));
1293 const Packet inf = pset1<Packet>(NumTraits<T>::infinity());
1294 const Packet e = pexp(x);
1295 const Packet inf_mask = pcmp_eq(e, inf);
1296 return pselect(inf_mask, one, pdiv(e, padd(one, e)));
1301template <
typename T>
1302struct scalar_logistic_op_impl<T, std::enable_if_t<NumTraits<T>::IsComplex>> {
1303 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE T operator()(
const T& x)
const {
1304 const T e = numext::exp(x);
1305 return (numext::isinf)(numext::real(e)) ? T(1) : e / (e + T(1));
1313template <
typename T>
1314struct scalar_logistic_op : scalar_logistic_op_impl<T> {};
1336struct scalar_logistic_op<float> {
1337 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
float operator()(
const float& x)
const {
1339 const float cst_exp_hi = 16.6355324f;
1340 const float e = numext::exp(numext::mini(x, cst_exp_hi));
1341 return e / (1.0f + e);
1344 template <
typename Packet>
1345 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(
const Packet& _x)
const {
1346 const Packet cst_zero = pset1<Packet>(0.0f);
1347 const Packet cst_one = pset1<Packet>(1.0f);
1348 const Packet cst_half = pset1<Packet>(0.5f);
1350 const Packet cst_exp_hi = pset1<Packet>(16.6355324f);
1351 const Packet cst_exp_lo = pset1<Packet>(-104.f);
1356 Packet zero_mask = pcmp_lt(_x, cst_exp_lo);
1357 Packet x = pmin(_x, cst_exp_hi);
1363 x = pmul(x, cst_half);
1368 const Packet cst_cephes_LOG2EF = pset1<Packet>(1.44269504088896341f);
1369 Packet m = pfloor(pmadd(x, cst_cephes_LOG2EF, cst_half));
1373 const Packet cst_cephes_exp_C1 = pset1<Packet>(-0.693359375f);
1374 const Packet cst_cephes_exp_C2 = pset1<Packet>(2.12194440e-4f);
1375 Packet r = pmadd(m, cst_cephes_exp_C1, x);
1376 r = pmadd(m, cst_cephes_exp_C2, r);
1381 Packet r2 = pmul(r, r);
1382 const Packet cst_p2 = pset1<Packet>(0.49999141693115234375f);
1383 const Packet cst_p3 = pset1<Packet>(0.16666877269744873046875f);
1384 const Packet cst_p4 = pset1<Packet>(4.1898667812347412109375e-2f);
1385 const Packet cst_p5 = pset1<Packet>(8.33471305668354034423828125e-3f);
1387 const Packet p_even = pmadd(r2, cst_p4, cst_p2);
1388 const Packet p_odd = pmadd(r2, cst_p5, cst_p3);
1389 const Packet p_low = padd(r, cst_one);
1390 Packet p = pmadd(r, p_odd, p_even);
1391 p = pmadd(r2, p, p_low);
1394 Packet e = pldexp_fast(p, m);
1400 return pselect(zero_mask, cst_zero, pdiv(e, padd(cst_one, e)));
1405template <
typename T>
1406struct functor_traits<scalar_logistic_op<T>> {
1410 Cost = scalar_div_cost<T, packet_traits<T>::HasDiv>::value +
1411 (std::is_same<T, float>::value ? NumTraits<T>::AddCost * 15 + NumTraits<T>::MulCost * 11
1412 : NumTraits<T>::AddCost * 2 + functor_traits<scalar_exp_op<T>>::Cost),
1414 PacketAccess = !NumTraits<T>::IsComplex && packet_traits<T>::HasAdd && packet_traits<T>::HasDiv &&
1415 packet_traits<T>::HasCmp &&
1416 (std::is_same<T, float>::value
1417 ? packet_traits<T>::HasMul && packet_traits<T>::HasMax && packet_traits<T>::HasMin
1418 : packet_traits<T>::HasNegate && packet_traits<T>::HasExp)
1422template <typename Scalar, typename ExponentScalar, bool IsBaseInteger = NumTraits<Scalar>::IsInteger,
1423 bool IsExponentInteger = NumTraits<ExponentScalar>::IsInteger,
1424 bool IsBaseComplex = NumTraits<Scalar>::IsComplex,
1425 bool IsExponentComplex = NumTraits<ExponentScalar>::IsComplex>
1426struct scalar_unary_pow_op {
1427 using PromotedExponent =
typename internal::promote_scalar_arg<
1428 Scalar, ExponentScalar,
1429 internal::has_ReturnType<ScalarBinaryOpTraits<Scalar, ExponentScalar, scalar_unary_pow_op>>::value>::type;
1430 using result_type =
typename ScalarBinaryOpTraits<Scalar, PromotedExponent, scalar_unary_pow_op>::ReturnType;
1431 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE scalar_unary_pow_op(
const ExponentScalar& exponent)
1432 : m_exponent(exponent) {}
1433 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE result_type operator()(
const Scalar& a)
const {
1434 EIGEN_USING_STD(pow);
1435 return static_cast<result_type
>(pow(a, m_exponent));
1439 const ExponentScalar m_exponent;
1440 scalar_unary_pow_op() {}
1443template <
typename T>
1444constexpr int exponent_digits() {
1445 return CHAR_BIT *
sizeof(T) - NumTraits<T>::digits() - NumTraits<T>::IsSigned;
1448template <
typename From,
typename To>
1449struct is_floating_exactly_representable {
1452 static constexpr bool value =
1453 (exponent_digits<To>() >= exponent_digits<From>() && NumTraits<To>::digits() >= NumTraits<From>::digits());
1457template <
typename Scalar,
typename ExponentScalar>
1458struct scalar_unary_pow_op<Scalar, ExponentScalar, false, false, false, false> {
1459 template <bool IsExactlyRepresentable = is_floating_exactly_representable<ExponentScalar, Scalar>::value>
1460 std::enable_if_t<IsExactlyRepresentable, void> check_is_representable()
const {}
1463 template <bool IsExactlyRepresentable = is_floating_exactly_representable<ExponentScalar, Scalar>::value>
1464 EIGEN_DEPRECATED std::enable_if_t<!IsExactlyRepresentable, void> check_is_representable()
const {}
1466 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE scalar_unary_pow_op(
const ExponentScalar& exponent)
1467 : m_exponent(static_cast<Scalar>(exponent)) {
1468 check_is_representable();
1471 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE Scalar operator()(
const Scalar& a)
const {
1472 return static_cast<Scalar
>(numext::pow(a, m_exponent));
1474 template <
typename Packet>
1475 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet packetOp(
const Packet& a)
const {
1476 return unary_pow_impl<Packet, Scalar>::run(a, m_exponent);
1480 const Scalar m_exponent;
1481 scalar_unary_pow_op() {}
1487template <
typename Scalar,
typename ExponentScalar>
1488struct scalar_unary_pow_op<Scalar, ExponentScalar, false, false, true, false> {
1489 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE scalar_unary_pow_op(
const ExponentScalar& exponent)
1490 : m_exponent(exponent),
1491 m_use_repeated_squaring((numext::isfinite)(exponent) && numext::round(exponent) == exponent &&
1492 unary_pow::use_repeated_squaring<Scalar>(exponent)) {}
1493 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(
const Scalar& a)
const {
1494 if (m_use_repeated_squaring)
return unary_pow::int_pow(a, m_exponent);
1496 EIGEN_USING_STD(pow);
1497 return static_cast<Scalar
>(pow(a, m_exponent));
1501 const ExponentScalar m_exponent;
1502 const bool m_use_repeated_squaring;
1503 scalar_unary_pow_op() {}
1506template <
typename Scalar,
typename ExponentScalar,
bool BaseIsInteger,
bool BaseIsComplex>
1507struct scalar_unary_pow_op<Scalar, ExponentScalar, BaseIsInteger, true, BaseIsComplex, false> {
1508 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE scalar_unary_pow_op(
const ExponentScalar& exponent)
1509 : m_exponent(exponent) {}
1510 EIGEN_DEVICE_FUNC
constexpr EIGEN_STRONG_INLINE Scalar operator()(
const Scalar& a)
const {
1511 return unary_pow_impl<Scalar, ExponentScalar>::run(a, m_exponent);
1513 template <
typename Packet>
1514 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet packetOp(
const Packet& a)
const {
1515 return unary_pow_impl<Packet, ExponentScalar>::run(a, m_exponent);
1519 const ExponentScalar m_exponent;
1520 scalar_unary_pow_op() {}
1523template <
typename Scalar,
typename ExponentScalar>
1524struct functor_traits<scalar_unary_pow_op<Scalar, ExponentScalar>> {
1526 GenPacketAccess = functor_traits<scalar_pow_op<Scalar, ExponentScalar>>::PacketAccess,
1532 !NumTraits<ExponentScalar>::IsComplex && packet_traits<Scalar>::HasMul &&
1533 (packet_traits<Scalar>::HasDiv || NumTraits<Scalar>::IsInteger) &&
1534 packet_traits<
typename NumTraits<Scalar>::Real>::HasCmp &&
1535 (!NumTraits<Scalar>::IsComplex || unary_pow::use_double_word<
typename packet_traits<Scalar>::type>::value),
1536 PacketAccess = NumTraits<ExponentScalar>::IsInteger ? IntPacketAccess : (IntPacketAccess && GenPacketAccess),
1537 Cost = functor_traits<scalar_pow_op<Scalar, ExponentScalar>>::Cost