Eigen  5.0.1-dev+master
 
Loading...
Searching...
No Matches
UnaryFunctors.h
1// This file is part of Eigen, a lightweight C++ template library
2// for linear algebra.
3//
4// Copyright (C) 2008-2016 Gael Guennebaud <gael.guennebaud@inria.fr>
5//
6// This Source Code Form is subject to the terms of the Mozilla
7// Public License v. 2.0. If a copy of the MPL was not distributed
8// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
9// SPDX-License-Identifier: MPL-2.0
10
11#ifndef EIGEN_UNARY_FUNCTORS_H
12#define EIGEN_UNARY_FUNCTORS_H
13
14// IWYU pragma: private
15#include "../InternalHeaderCheck.h"
16
17namespace Eigen {
18
19namespace internal {
20
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);
34 }
35};
36template <typename Scalar>
37struct functor_traits<scalar_opposite_op<Scalar>> {
38 enum { Cost = NumTraits<Scalar>::AddCost, PacketAccess = packet_traits<Scalar>::HasNegate };
39};
40
46template <typename Scalar>
47struct scalar_abs_op {
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);
51 }
52 template <typename Packet>
53 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& a) const {
54 return internal::pabs(a);
55 }
56};
57template <typename Scalar>
58struct functor_traits<scalar_abs_op<Scalar>> {
59 enum { Cost = NumTraits<Scalar>::AddCost, PacketAccess = packet_traits<Scalar>::HasAbs };
60};
61
67template <typename Scalar>
68struct scalar_score_coeff_op : scalar_abs_op<Scalar> {
69 using Score_is_abs = void;
70};
71template <typename Scalar>
72struct functor_traits<scalar_score_coeff_op<Scalar>> : functor_traits<scalar_abs_op<Scalar>> {};
73
74/* Avoid recomputing abs when we know the score and they are the same. Not a true Eigen functor. */
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);
81 }
82};
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 {
88 return a;
89 }
90};
91
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);
102 }
103 template <typename Packet>
104 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& a) const {
105 return internal::pmul(a, a);
106 }
107};
108template <typename Scalar>
109struct functor_traits<scalar_abs2_op<Scalar>> {
110 enum {
111 Cost = NumTraits<Scalar>::MulCost,
112 PacketAccess = packet_traits<Scalar>::HasMul && !NumTraits<Scalar>::IsComplex
113 };
114};
115
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);
127 }
128};
129template <typename Scalar>
130struct functor_traits<scalar_conjugate_op<Scalar>> {
131 enum {
132 Cost = 0,
133 // Yes the cost is zero even for complexes because in most cases for which
134 // the cost is used, conjugation turns to be a no-op. Some examples:
135 // cost(a*conj(b)) == cost(a*b)
136 // cost(a+conj(b)) == cost(a+b)
137 // <etc.
138 // If we don't set it to zero, then:
139 // A.conjugate().lazyProduct(B.conjugate())
140 // will bake its operands. We definitely don't want that!
141 PacketAccess = packet_traits<Scalar>::HasConj
142 };
143};
144
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);
155 }
156 template <typename Packet>
157 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& a) const {
158 return internal::parg(a);
159 }
160};
161template <typename Scalar>
162struct functor_traits<scalar_arg_op<Scalar>> {
163 enum {
164 Cost = NumTraits<Scalar>::IsComplex ? 5 * NumTraits<Scalar>::MulCost : NumTraits<Scalar>::AddCost,
165 PacketAccess = packet_traits<Scalar>::HasArg
166 };
167};
168
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));
179 }
180 template <typename Packet>
181 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& a) const {
182 return pcarg(a);
183 }
184};
185template <typename Scalar>
186struct functor_traits<scalar_carg_op<Scalar>> {
187 using RealScalar = typename NumTraits<Scalar>::Real;
188 enum {
189 Cost = functor_traits<scalar_atan2_op<RealScalar>>::Cost,
190 // The generic pcarg lowers to patan2, whose quotient-based reduction needs pdiv. It takes complex packets only; a
191 // real argument is 0 or pi, which the scalar path returns.
192 PacketAccess =
193 NumTraits<Scalar>::IsComplex && packet_traits<RealScalar>::HasATan && packet_traits<RealScalar>::HasDiv
194 };
195};
196
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);
207 }
208};
209
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 };
213};
214
221template <typename SrcType, typename DstType>
222struct core_cast_op : scalar_cast_op<SrcType, DstType> {};
223
224template <typename SrcType, typename DstType>
225struct functor_traits<core_cast_op<SrcType, DstType>> {
226 using CastingTraits = type_casting_traits<SrcType, DstType>;
227 enum {
228 Cost = std::is_same<SrcType, DstType>::value ? 0 : NumTraits<DstType>::AddCost,
229 PacketAccess = CastingTraits::VectorizedCast && (CastingTraits::SrcCoeffRatio <= 8)
230 };
231};
232
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);
242 }
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);
246 }
247};
248// A zero shift stays scalar: immediate right-shift intrinsics such as NEON's vshr_n reject a count of zero.
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 };
252};
253
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);
263 }
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);
267 }
268};
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 };
272};
273
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);
283 }
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);
287 }
288};
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 };
292};
293
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);
304 }
305};
306template <typename Scalar>
307struct functor_traits<scalar_real_op<Scalar>> {
308 enum { Cost = 0, PacketAccess = false };
309};
310
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);
321 }
322};
323template <typename Scalar>
324struct functor_traits<scalar_imag_op<Scalar>> {
325 enum { Cost = 0, PacketAccess = false };
326};
327
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);
338 }
339 EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE result_type& operator()(Scalar& a) const {
340 return numext::real_ref(a);
341 }
342};
343template <typename Scalar>
344struct functor_traits<scalar_real_ref_op<Scalar>> {
345 enum { Cost = 0, PacketAccess = false };
346};
347
353template <typename Scalar>
354struct scalar_imag_ref_op {
355 // For a real Scalar, numext::imag_ref returns the temporary RealScalar(0) by value; binding it to the
356 // reference return types below would dangle (issue #3096). Real-valued objects get a read-only zero
357 // expression from imag() instead (see NonConstImagReturnType in CommonCwiseUnaryOps.inc).
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);
363 }
364 EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE const result_type& operator()(const Scalar& a) const {
365 return numext::imag_ref(a);
366 }
367};
368template <typename Scalar>
369struct functor_traits<scalar_imag_ref_op<Scalar>> {
370 enum { Cost = 0, PacketAccess = false };
371};
372
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);
385 }
386};
387template <typename Scalar>
388struct functor_traits<scalar_exp_op<Scalar>> {
389 enum {
390 PacketAccess = packet_traits<Scalar>::HasExp,
391 // The following numbers are based on the AVX implementation.
392#ifdef EIGEN_VECTORIZE_FMA
393 // Haswell can issue 2 add/mul/madd per cycle.
394 Cost = (sizeof(Scalar) == 4
395 // float: 8 pmadd, 4 pmul, 2 padd/psub, 6 other
396 ? (8 * NumTraits<Scalar>::AddCost + 6 * NumTraits<Scalar>::MulCost)
397 // double: 7 pmadd, 5 pmul, 3 padd/psub, 1 div, 13 other
398 : (14 * NumTraits<Scalar>::AddCost + 6 * NumTraits<Scalar>::MulCost +
399 scalar_div_cost<Scalar, packet_traits<Scalar>::HasDiv>::value))
400#else
401 Cost = (sizeof(Scalar) == 4
402 // float: 7 pmadd, 6 pmul, 4 padd/psub, 10 other
403 ? (21 * NumTraits<Scalar>::AddCost + 13 * NumTraits<Scalar>::MulCost)
404 // double: 7 pmadd, 5 pmul, 3 padd/psub, 1 div, 13 other
405 : (23 * NumTraits<Scalar>::AddCost + 12 * NumTraits<Scalar>::MulCost +
406 scalar_div_cost<Scalar, packet_traits<Scalar>::HasDiv>::value))
407#endif
408 };
409};
410
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);
417 }
418};
419template <typename Scalar>
420struct functor_traits<scalar_exp2_op<Scalar>> {
421 enum {
422 // There is no complex pexp2; complex arguments take numext::exp2.
423 PacketAccess = packet_traits<Scalar>::HasExp && !NumTraits<Scalar>::IsComplex,
424 Cost = functor_traits<scalar_exp_op<Scalar>>::Cost // TODO: measure cost of exp2
425 };
426};
427
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);
441 }
442 template <typename Packet>
443 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& a) const {
444 // pldexp clamps exponents, so a saturating conversion to Scalar is safe.
445 return internal::pldexp(a, pset1<Packet>(static_cast<Scalar>(m_exponent)));
446 }
447
448 private:
449 const int m_exponent;
450};
451template <typename Scalar>
452struct functor_traits<scalar_ldexp_op<Scalar>> {
453 enum {
454 // HasExp packets already require a tested pldexp implementation.
455 PacketAccess = packet_traits<Scalar>::HasExp,
456 Cost = 4 * NumTraits<Scalar>::MulCost
457 };
458};
459
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);
472 }
473};
474template <typename Scalar>
475struct functor_traits<scalar_expm1_op<Scalar>> {
476 enum {
477 PacketAccess = packet_traits<Scalar>::HasExpm1,
478 Cost = functor_traits<scalar_exp_op<Scalar>>::Cost // TODO: measure cost of expm1
479 };
480};
481
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);
494 }
495};
496template <typename Scalar>
497struct functor_traits<scalar_log_op<Scalar>> {
498 enum {
499 PacketAccess = packet_traits<Scalar>::HasLog,
500 Cost = (PacketAccess
501 // The following numbers are based on the AVX implementation.
502#ifdef EIGEN_VECTORIZE_FMA
503 // 8 pmadd, 6 pmul, 8 padd/psub, 16 other, can issue 2 add/mul/madd per cycle.
504 ? (20 * NumTraits<Scalar>::AddCost + 7 * NumTraits<Scalar>::MulCost)
505#else
506 // 8 pmadd, 6 pmul, 8 padd/psub, 20 other
507 ? (36 * NumTraits<Scalar>::AddCost + 14 * NumTraits<Scalar>::MulCost)
508#endif
509 // Measured cost of std::log.
510 : sizeof(Scalar) == 4 ? 40 : 85)
511 };
512};
513
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);
526 }
527};
528template <typename Scalar>
529struct functor_traits<scalar_log1p_op<Scalar>> {
530 enum {
531 PacketAccess = packet_traits<Scalar>::HasLog1p,
532 Cost = functor_traits<scalar_log_op<Scalar>>::Cost // TODO: measure cost of log1p
533 };
534};
535
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);
548 }
549};
550template <typename Scalar>
551struct functor_traits<scalar_log10_op<Scalar>> {
552 enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasLog10 };
553};
554
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>());
566 }
567 template <typename Packet>
568 EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const {
569 return internal::plog2(a);
570 }
571
572 private:
573 // 0: float, double or long double; 1: std::complex of one of them; 2: any other scalar, user types included.
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
577 : 2;
578 // std::log2 is exact at powers of two, like plog2; log2(e) * log(a) can be an ulp off there. complex_log2 takes the
579 // real part log2|a| from std::log2, like plog2 on complex packets.
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);
583 }
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));
586 }
587};
588template <typename Scalar>
589struct functor_traits<scalar_log2_op<Scalar>> {
590 enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasLog };
591};
592
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);
603 }
604};
605template <typename Scalar>
606struct functor_traits<scalar_sqrt_op<Scalar>> {
607 enum {
608#if EIGEN_FAST_MATH
609 // The following numbers are based on the AVX implementation.
610 Cost = (sizeof(Scalar) == 8 ? 28
611 // 4 pmul, 1 pmadd, 3 other
612 : (3 * NumTraits<Scalar>::AddCost + 5 * NumTraits<Scalar>::MulCost)),
613#else
614 // The following numbers are based on min VSQRT throughput on Haswell.
615 Cost = (sizeof(Scalar) == 8 ? 28 : 14),
616#endif
617 PacketAccess = packet_traits<Scalar>::HasSqrt
618 };
619};
620
621// Boolean specialization to eliminate -Wimplicit-conversion-floating-point-to-bool warnings.
622template <>
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 {
627 return a;
628 }
629};
630template <>
631struct functor_traits<scalar_sqrt_op<bool>> {
632 enum { Cost = 1, PacketAccess = packet_traits<bool>::Vectorizable };
633};
634
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);
645 }
646};
647
648template <typename Scalar>
649struct functor_traits<scalar_cbrt_op<Scalar>> {
650 enum { Cost = 20 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasCbrt };
651};
652
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);
663 }
664};
665
666template <typename Scalar>
667struct functor_traits<scalar_rsqrt_op<Scalar>> {
668 enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasRsqrt };
669};
670
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);
681 }
682};
683template <typename Scalar>
684struct functor_traits<scalar_cos_op<Scalar>> {
685 enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasCos };
686};
687
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);
698 }
699};
700template <typename Scalar>
701struct functor_traits<scalar_sin_op<Scalar>> {
702 enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasSin };
703};
704
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);
715 }
716};
717template <typename Scalar>
718struct functor_traits<scalar_tan_op<Scalar>> {
719 enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasTan };
720};
721
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);
732 }
733};
734template <typename Scalar>
735struct functor_traits<scalar_acos_op<Scalar>> {
736 enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasACos };
737};
738
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);
749 }
750};
751template <typename Scalar>
752struct functor_traits<scalar_asin_op<Scalar>> {
753 enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasASin };
754};
755
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);
766 }
767};
768template <typename Scalar>
769struct functor_traits<scalar_atan_op<Scalar>> {
770 enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasATan };
771};
772
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 {
782 return ptanh(x);
783 }
784};
785
786template <typename Scalar>
787struct functor_traits<scalar_tanh_op<Scalar>> {
788 enum {
789 PacketAccess = packet_traits<Scalar>::HasTanh,
790 Cost = ((EIGEN_FAST_MATH && std::is_same<Scalar, float>::value)
791// The following numbers are based on the AVX implementation,
792#ifdef EIGEN_VECTORIZE_FMA
793 // Haswell can issue 2 add/mul/madd per cycle.
794 // 9 pmadd, 2 pmul, 1 div, 2 other
795 ? (2 * NumTraits<Scalar>::AddCost + 6 * NumTraits<Scalar>::MulCost +
796 scalar_div_cost<Scalar, packet_traits<Scalar>::HasDiv>::value)
797#else
798 ? (11 * NumTraits<Scalar>::AddCost + 11 * NumTraits<Scalar>::MulCost +
799 scalar_div_cost<Scalar, packet_traits<Scalar>::HasDiv>::value)
800#endif
801 // This number assumes a naive implementation of tanh
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))
805 };
806};
807
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 {
817 return patanh(x);
818 }
819};
820
821template <typename Scalar>
822struct functor_traits<scalar_atanh_op<Scalar>> {
823 enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasATanh };
824};
825
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);
836 }
837};
838template <typename Scalar>
839struct functor_traits<scalar_sinh_op<Scalar>> {
840 enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasSinh };
841};
842
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);
853 }
854};
855
856template <typename Scalar>
857struct functor_traits<scalar_asinh_op<Scalar>> {
858 enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasASinh };
859};
860
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);
871 }
872};
873template <typename Scalar>
874struct functor_traits<scalar_cosh_op<Scalar>> {
875 enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasCosh };
876};
877
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);
888 }
889};
890
891template <typename Scalar>
892struct functor_traits<scalar_acosh_op<Scalar>> {
893 enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasACosh };
894};
895
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);
906 }
907};
908template <typename Scalar>
909struct functor_traits<scalar_inverse_op<Scalar>> {
910 enum {
911 PacketAccess = packet_traits<Scalar>::HasDiv,
912 // If packet_traits<Scalar>::HasReciprocal then the Estimated cost is that
913 // of computing an approximation plus a single Newton-Raphson step, which
914 // consists of 1 pmul + 1 pmadd.
915 Cost = (packet_traits<Scalar>::HasReciprocal ? 4 * NumTraits<Scalar>::MulCost
916 : scalar_div_cost<Scalar, PacketAccess>::value)
917 };
918};
919
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);
930 }
931};
932template <typename Scalar>
933struct functor_traits<scalar_square_op<Scalar>> {
934 enum { Cost = NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasMul };
935};
936
937// Boolean specialization to avoid -Wint-in-bool-context warnings on GCC.
938template <>
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 {
943 return a;
944 }
945};
946template <>
947struct functor_traits<scalar_square_op<bool>> {
948 enum { Cost = 0, PacketAccess = packet_traits<bool>::Vectorizable };
949};
950
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));
959 }
960 template <typename Packet>
961 EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const {
962 return internal::pmul(a, pmul(a, a));
963 }
964};
965template <typename Scalar>
966struct functor_traits<scalar_cube_op<Scalar>> {
967 enum { Cost = 2 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasMul };
968};
969
970// Boolean specialization to avoid -Wint-in-bool-context warnings on GCC.
971template <>
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 {
976 return a;
977 }
978};
979template <>
980struct functor_traits<scalar_cube_op<bool>> {
981 enum { Cost = 0, PacketAccess = packet_traits<bool>::Vectorizable };
982};
983
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);
994 }
995};
996template <typename Scalar>
997struct functor_traits<scalar_round_op<Scalar>> {
998 enum {
999 Cost = NumTraits<Scalar>::MulCost,
1000 PacketAccess = packet_traits<Scalar>::HasRound || NumTraits<Scalar>::IsInteger
1001 };
1002};
1003
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);
1014 }
1015};
1016template <typename Scalar>
1017struct functor_traits<scalar_floor_op<Scalar>> {
1018 enum {
1019 Cost = NumTraits<Scalar>::MulCost,
1020 PacketAccess = packet_traits<Scalar>::HasRound || NumTraits<Scalar>::IsInteger
1021 };
1022};
1023
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);
1034 }
1035};
1036template <typename Scalar>
1037struct functor_traits<scalar_rint_op<Scalar>> {
1038 enum {
1039 Cost = NumTraits<Scalar>::MulCost,
1040 PacketAccess = packet_traits<Scalar>::HasRound || NumTraits<Scalar>::IsInteger
1041 };
1042};
1043
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);
1054 }
1055};
1056template <typename Scalar>
1057struct functor_traits<scalar_ceil_op<Scalar>> {
1058 enum {
1059 Cost = NumTraits<Scalar>::MulCost,
1060 PacketAccess = packet_traits<Scalar>::HasRound || NumTraits<Scalar>::IsInteger
1061 };
1062};
1063
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);
1074 }
1075};
1076template <typename Scalar>
1077struct functor_traits<scalar_trunc_op<Scalar>> {
1078 enum {
1079 Cost = NumTraits<Scalar>::MulCost,
1080 PacketAccess = packet_traits<Scalar>::HasRound || NumTraits<Scalar>::IsInteger
1081 };
1082};
1083
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);
1093#else
1094 return numext::isnan EIGEN_NOT_A_MACRO(a);
1095#endif
1096 }
1097};
1098
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));
1104#else
1105 return (numext::isnan EIGEN_NOT_A_MACRO(a) ? ptrue(a) : pzero(a));
1106#endif
1107 }
1108 template <typename Packet>
1109 EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const {
1110 return pisnan(a);
1111 }
1112};
1113
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 };
1117};
1118
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);
1128#else
1129 return (numext::isinf)(a);
1130#endif
1131 }
1132};
1133
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));
1139#else
1140 return (numext::isinf EIGEN_NOT_A_MACRO(a) ? ptrue(a) : pzero(a));
1141#endif
1142 }
1143 template <typename Packet>
1144 EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const {
1145 return pisinf(a);
1146 }
1147};
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 };
1151};
1152
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);
1162#else
1163 return (numext::isfinite)(a);
1164#endif
1165 }
1166};
1167
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));
1173#else
1174 return (numext::isfinite EIGEN_NOT_A_MACRO(a) ? ptrue(a) : pzero(a));
1175#endif
1176 }
1177 template <typename Packet>
1178 EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const {
1179 return pisfinite(a);
1180 }
1181};
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 };
1185};
1186
1192template <typename Scalar>
1193struct scalar_boolean_not_op {
1194 using result_type = Scalar;
1195 // `false` any value `a` that satisfies `a == Scalar(0)`
1196 // `true` is the complement of `false`
1197 EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE Scalar operator()(const Scalar& a) const {
1198 return Scalar(a == Scalar(0));
1199 }
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)) {
1204 // Boolean packet lanes are canonical, so logical NOT is 1 & ~a.
1205 return pandnot(cst_one, a);
1206 } else {
1207 Packet not_a = pcmp_eq(a, pzero(a));
1208 return pand(not_a, cst_one);
1209 }
1210 }
1211};
1212template <typename Scalar>
1213struct functor_traits<scalar_boolean_not_op<Scalar>> {
1214 enum { Cost = NumTraits<Scalar>::AddCost, PacketAccess = packet_traits<Scalar>::HasCmp };
1215};
1216
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);
1225 }
1226};
1227
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);
1235 }
1236};
1237
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);
1251 }
1252 template <typename Packet>
1253 EIGEN_STRONG_INLINE Packet packetOp(const Packet& a) const {
1254 return pandnot(ptrue(a), a);
1255 }
1256};
1257template <typename Scalar>
1258struct functor_traits<scalar_bitwise_not_op<Scalar>> {
1259 enum { Cost = NumTraits<Scalar>::AddCost, PacketAccess = true };
1260};
1261
1266template <typename Scalar>
1267struct scalar_sign_op {
1268 EIGEN_DEVICE_FUNC constexpr inline Scalar operator()(const Scalar& a) const { return numext::sign(a); }
1269
1270 template <typename Packet>
1271 EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const {
1272 return internal::psign(a);
1273 }
1274};
1275
1276template <typename Scalar>
1277struct functor_traits<scalar_sign_op<Scalar>> {
1278 enum {
1279 Cost = NumTraits<Scalar>::IsComplex ? (8 * NumTraits<Scalar>::MulCost) // roughly
1280 : (3 * NumTraits<Scalar>::AddCost),
1281 PacketAccess = packet_traits<Scalar>::HasSign && packet_traits<Scalar>::Vectorizable
1282 };
1283};
1284
1285// Real-valued implementation.
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); }
1289
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)));
1297 }
1298};
1299
1300// Complex-valued implementation.
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));
1306 }
1307};
1308
1313template <typename T>
1314struct scalar_logistic_op : scalar_logistic_op_impl<T> {};
1315
1316// TODO(rmlarsen): Enable the following on host when integer_packet is defined
1317// for the relevant packet types.
1318#ifndef EIGEN_GPUCC
1319
1335template <>
1336struct scalar_logistic_op<float> {
1337 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float operator()(const float& x) const {
1338 // Truncate at the first point where the interpolant is exactly one.
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);
1342 }
1343
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);
1349 // Truncate at the first point where the interpolant is exactly one.
1350 const Packet cst_exp_hi = pset1<Packet>(16.6355324f);
1351 const Packet cst_exp_lo = pset1<Packet>(-104.f);
1352
1353 // Clamp x to the non-trivial range where S(x). Outside this
1354 // interval the correctly rounded value of S(x) is either zero
1355 // or one.
1356 Packet zero_mask = pcmp_lt(_x, cst_exp_lo);
1357 Packet x = pmin(_x, cst_exp_hi);
1358
1359 // 1. Multiplicative range reduction:
1360 // Reduce the range of x by a factor of 2. This avoids having
1361 // to compute exp(x) accurately where the result is a denormalized
1362 // value.
1363 x = pmul(x, cst_half);
1364
1365 // 2. Subtractive range reduction:
1366 // Express exp(x) as exp(m*ln(2) + r) = 2^m*exp(r), start by extracting
1367 // m = floor(x/ln(2) + 0.5), such that x = m*ln(2) + r.
1368 const Packet cst_cephes_LOG2EF = pset1<Packet>(1.44269504088896341f);
1369 Packet m = pfloor(pmadd(x, cst_cephes_LOG2EF, cst_half));
1370 // Get r = x - m*ln(2). We use a trick from Cephes where the term
1371 // m*ln(2) is subtracted out in two parts, m*C1+m*C2 = m*ln(2),
1372 // to avoid accumulating truncation errors.
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);
1377
1378 // 3. Compute an approximation to exp(r) using a degree 5 minimax polynomial.
1379 // We compute even and odd terms separately to increase instruction level
1380 // parallelism.
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);
1386
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);
1392
1393 // 4. Undo subtractive range reduction exp(m*ln(2) + r) = 2^m * exp(r).
1394 Packet e = pldexp_fast(p, m);
1395
1396 // 5. Undo multiplicative range reduction by using exp(r) = exp(r/2)^2.
1397 e = pmul(e, e);
1398
1399 // Return exp(x) / (1 + exp(x))
1400 return pselect(zero_mask, cst_zero, pdiv(e, padd(cst_one, e)));
1401 }
1402};
1403#endif // #ifndef EIGEN_GPUCC
1404
1405template <typename T>
1406struct functor_traits<scalar_logistic_op<T>> {
1407 enum {
1408 // The cost estimate for float here is for the common(?) case where
1409 // all arguments are greater than -9.
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),
1413 // Both packet paths branch with pcmp_*/pselect.
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)
1419 };
1420};
1421
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));
1436 }
1437
1438 private:
1439 const ExponentScalar m_exponent;
1440 scalar_unary_pow_op() {}
1441};
1442
1443template <typename T>
1444constexpr int exponent_digits() {
1445 return CHAR_BIT * sizeof(T) - NumTraits<T>::digits() - NumTraits<T>::IsSigned;
1446}
1447
1448template <typename From, typename To>
1449struct is_floating_exactly_representable {
1450 // TODO(rmlarsen): Add radix to NumTraits and enable this check.
1451 // (NumTraits<To>::radix == NumTraits<From>::radix) &&
1452 static constexpr bool value =
1453 (exponent_digits<To>() >= exponent_digits<From>() && NumTraits<To>::digits() >= NumTraits<From>::digits());
1454};
1455
1456// Specialization for real, non-integer types, non-complex types.
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 {}
1461
1462 // Issue a deprecation warning if we do a narrowing conversion on the exponent.
1463 template <bool IsExactlyRepresentable = is_floating_exactly_representable<ExponentScalar, Scalar>::value>
1464 EIGEN_DEPRECATED std::enable_if_t<!IsExactlyRepresentable, void> check_is_representable() const {}
1465
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();
1469 }
1470
1471 EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE Scalar operator()(const Scalar& a) const {
1472 return static_cast<Scalar>(numext::pow(a, m_exponent));
1473 }
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);
1477 }
1478
1479 private:
1480 const Scalar m_exponent;
1481 scalar_unary_pow_op() {}
1482};
1483
1484// Specialization for a complex base and a real, non-integer exponent type: integer-valued exponents take the
1485// repeated-squaring path, which is exact where the power is representable; the rest defer to pow. There is no
1486// vectorized complex pow, so this stays scalar.
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);
1495 // std::pow can promote the complex component for a wider exponent before casting back to Scalar.
1496 EIGEN_USING_STD(pow);
1497 return static_cast<Scalar>(pow(a, m_exponent));
1498 }
1499
1500 private:
1501 const ExponentScalar m_exponent;
1502 const bool m_use_repeated_squaring;
1503 scalar_unary_pow_op() {}
1504};
1505
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);
1512 }
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);
1516 }
1517
1518 private:
1519 const ExponentScalar m_exponent;
1520 scalar_unary_pow_op() {}
1521};
1522
1523template <typename Scalar, typename ExponentScalar>
1524struct functor_traits<scalar_unary_pow_op<Scalar, ExponentScalar>> {
1525 enum {
1526 GenPacketAccess = functor_traits<scalar_pow_op<Scalar, ExponentScalar>>::PacketAccess,
1527 // Only the real-exponent specializations define packetOp. Every path multiplies packets of the base type and
1528 // divides them for a negative exponent unless the base is an integer; the compares and selects run on the
1529 // real packet, which for a complex base is the component view of its packet. A complex base is vectorized
1530 // only through the double-word path, so it also needs that path's packet support.
1531 IntPacketAccess =
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
1538 };
1539};
1540
1541} // end namespace internal
1542
1543} // end namespace Eigen
1544
1545#endif // EIGEN_UNARY_FUNCTORS_H