11#ifndef EIGEN_GENERIC_PACKET_MATH_H
12#define EIGEN_GENERIC_PACKET_MATH_H
26#ifndef EIGEN_DEBUG_ALIGNED_LOAD
27#define EIGEN_DEBUG_ALIGNED_LOAD
30#ifndef EIGEN_DEBUG_UNALIGNED_LOAD
31#define EIGEN_DEBUG_UNALIGNED_LOAD
34#ifndef EIGEN_DEBUG_ALIGNED_STORE
35#define EIGEN_DEBUG_ALIGNED_STORE
38#ifndef EIGEN_DEBUG_UNALIGNED_STORE
39#define EIGEN_DEBUG_UNALIGNED_STORE
42struct default_packet_traits
94 HasGammaSampleDerAlpha = 0,
106template<
typename T>
struct packet_traits : default_packet_traits
130template<
typename T>
struct packet_traits<const T> : packet_traits<T> { };
132template<
typename T>
struct unpacket_traits
140 vectorizable =
false,
141 masked_load_available=
false,
142 masked_store_available=
false
146template<
typename T>
struct unpacket_traits<const T> : unpacket_traits<T> { };
148template <
typename Src,
typename Tgt>
struct type_casting_traits {
158template<
typename T,
int unique_
id = 0>
159struct eigen_packet_wrapper
161 EIGEN_ALWAYS_INLINE
operator T&() {
return m_val; }
162 EIGEN_ALWAYS_INLINE
operator const T&()
const {
return m_val; }
163 EIGEN_ALWAYS_INLINE eigen_packet_wrapper() {}
164 EIGEN_ALWAYS_INLINE eigen_packet_wrapper(
const T &v) : m_val(v) {}
165 EIGEN_ALWAYS_INLINE eigen_packet_wrapper& operator=(
const T &v) {
177template<
typename Packet>
179 typedef typename unpacket_traits<Packet>::type Scalar;
181 value = internal::is_same<Packet, Scalar>::value
186template <
typename SrcPacket,
typename TgtPacket>
187EIGEN_DEVICE_FUNC
inline TgtPacket
188pcast(
const SrcPacket& a) {
189 return static_cast<TgtPacket
>(a);
191template <
typename SrcPacket,
typename TgtPacket>
192EIGEN_DEVICE_FUNC
inline TgtPacket
193pcast(
const SrcPacket& a,
const SrcPacket& ) {
194 return static_cast<TgtPacket
>(a);
196template <
typename SrcPacket,
typename TgtPacket>
197EIGEN_DEVICE_FUNC
inline TgtPacket
198pcast(
const SrcPacket& a,
const SrcPacket& ,
const SrcPacket& ,
const SrcPacket& ) {
199 return static_cast<TgtPacket
>(a);
201template <
typename SrcPacket,
typename TgtPacket>
202EIGEN_DEVICE_FUNC
inline TgtPacket
203pcast(
const SrcPacket& a,
const SrcPacket& ,
const SrcPacket& ,
const SrcPacket& ,
204 const SrcPacket& ,
const SrcPacket& ,
const SrcPacket& ,
const SrcPacket& ) {
205 return static_cast<TgtPacket
>(a);
209template <
typename Target,
typename Packet>
210EIGEN_DEVICE_FUNC
inline Target
211preinterpret(
const Packet& a);
214template<
typename Packet> EIGEN_DEVICE_FUNC
inline Packet
215padd(
const Packet& a,
const Packet& b) {
return a+b; }
217template<> EIGEN_DEVICE_FUNC
inline bool
218padd(
const bool& a,
const bool& b) {
return a || b; }
221template<
typename Packet> EIGEN_DEVICE_FUNC
inline Packet
222psub(
const Packet& a,
const Packet& b) {
return a-b; }
225template<
typename Packet> EIGEN_DEVICE_FUNC
inline Packet
226pnegate(
const Packet& a) {
return -a; }
228template<> EIGEN_DEVICE_FUNC
inline bool
229pnegate(
const bool& a) {
return !a; }
232template<
typename Packet> EIGEN_DEVICE_FUNC
inline Packet
233pconj(
const Packet& a) {
return numext::conj(a); }
236template<
typename Packet> EIGEN_DEVICE_FUNC
inline Packet
237pmul(
const Packet& a,
const Packet& b) {
return a*b; }
239template<> EIGEN_DEVICE_FUNC
inline bool
240pmul(
const bool& a,
const bool& b) {
return a && b; }
243template<
typename Packet> EIGEN_DEVICE_FUNC
inline Packet
244pdiv(
const Packet& a,
const Packet& b) {
return a/b; }
247template<
typename Packet,
typename EnableIf =
void>
249 static EIGEN_DEVICE_FUNC
inline Packet run(
const Packet& ){
251 memset(
static_cast<void*
>(&b), 0xff,
sizeof(Packet));
262 typename internal::enable_if<is_scalar<T>::value && NumTraits<T>::RequireInitialization>::type > {
263 static EIGEN_DEVICE_FUNC
inline T run(
const T& ){
269template<
typename Packet> EIGEN_DEVICE_FUNC
inline Packet
270ptrue(
const Packet& a) {
271 return ptrue_impl<Packet>::run(a);
275template<
typename Packet,
typename EnableIf =
void>
277 static EIGEN_DEVICE_FUNC
inline Packet run(
const Packet& ) {
279 memset(
static_cast<void*
>(&b), 0x00,
sizeof(Packet));
288 typename internal::enable_if<is_scalar<T>::value>::type> {
289 static EIGEN_DEVICE_FUNC
inline T run(
const T& ) {
295template<
typename Packet> EIGEN_DEVICE_FUNC
inline Packet
296pzero(
const Packet& a) {
297 return pzero_impl<Packet>::run(a);
301template<
typename Packet> EIGEN_DEVICE_FUNC
inline Packet
302pcmp_le(
const Packet& a,
const Packet& b) {
return a<=b ? ptrue(a) : pzero(a); }
305template<
typename Packet> EIGEN_DEVICE_FUNC
inline Packet
306pcmp_lt(
const Packet& a,
const Packet& b) {
return a<b ? ptrue(a) : pzero(a); }
309template<
typename Packet> EIGEN_DEVICE_FUNC
inline Packet
310pcmp_eq(
const Packet& a,
const Packet& b) {
return a==b ? ptrue(a) : pzero(a); }
313template<
typename Packet> EIGEN_DEVICE_FUNC
inline Packet
314pcmp_lt_or_nan(
const Packet& a,
const Packet& b) {
return a>=b ? pzero(a) : ptrue(a); }
318 EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR EIGEN_ALWAYS_INLINE T operator()(
const T& a,
const T& b)
const {
325 EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR EIGEN_ALWAYS_INLINE T operator()(
const T& a,
const T& b)
const {
332 EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR EIGEN_ALWAYS_INLINE T operator()(
const T& a,
const T& b)
const {
339 EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR EIGEN_ALWAYS_INLINE T operator()(
const T& a)
const {
346struct operator_bitwise_helper {
347 EIGEN_DEVICE_FUNC
static inline T bitwise_and(
const T& a,
const T& b) {
return bit_and<T>()(a, b); }
348 EIGEN_DEVICE_FUNC
static inline T bitwise_or(
const T& a,
const T& b) {
return bit_or<T>()(a, b); }
349 EIGEN_DEVICE_FUNC
static inline T bitwise_xor(
const T& a,
const T& b) {
return bit_xor<T>()(a, b); }
350 EIGEN_DEVICE_FUNC
static inline T bitwise_not(
const T& a) {
return bit_not<T>()(a); }
355struct bytewise_bitwise_helper {
356 EIGEN_DEVICE_FUNC
static inline T bitwise_and(
const T& a,
const T& b) {
357 return binary(a, b, bit_and<unsigned char>());
359 EIGEN_DEVICE_FUNC
static inline T bitwise_or(
const T& a,
const T& b) {
360 return binary(a, b, bit_or<unsigned char>());
362 EIGEN_DEVICE_FUNC
static inline T bitwise_xor(
const T& a,
const T& b) {
363 return binary(a, b, bit_xor<unsigned char>());
365 EIGEN_DEVICE_FUNC
static inline T bitwise_not(
const T& a) {
366 return unary(a,bit_not<unsigned char>());
370 template<
typename Op>
371 EIGEN_DEVICE_FUNC
static inline T unary(
const T& a, Op op) {
372 const unsigned char* a_ptr =
reinterpret_cast<const unsigned char*
>(&a);
374 unsigned char* c_ptr =
reinterpret_cast<unsigned char*
>(&c);
375 for (
size_t i = 0; i <
sizeof(T); ++i) {
376 *c_ptr++ = op(*a_ptr++);
381 template<
typename Op>
382 EIGEN_DEVICE_FUNC
static inline T binary(
const T& a,
const T& b, Op op) {
383 const unsigned char* a_ptr =
reinterpret_cast<const unsigned char*
>(&a);
384 const unsigned char* b_ptr =
reinterpret_cast<const unsigned char*
>(&b);
386 unsigned char* c_ptr =
reinterpret_cast<unsigned char*
>(&c);
387 for (
size_t i = 0; i <
sizeof(T); ++i) {
388 *c_ptr++ = op(*a_ptr++, *b_ptr++);
395template<
typename T,
typename EnableIf =
void>
396struct bitwise_helper :
public bytewise_bitwise_helper<T> {};
400struct bitwise_helper<T,
401 typename internal::enable_if<
402 is_scalar<T>::value && (NumTraits<T>::IsInteger || NumTraits<T>::RequireInitialization)>::type
403 > :
public operator_bitwise_helper<T> {};
406template<
typename Packet> EIGEN_DEVICE_FUNC
inline Packet
407pand(
const Packet& a,
const Packet& b) {
408 return bitwise_helper<Packet>::bitwise_and(a, b);
412template<
typename Packet> EIGEN_DEVICE_FUNC
inline Packet
413por(
const Packet& a,
const Packet& b) {
414 return bitwise_helper<Packet>::bitwise_or(a, b);
418template<
typename Packet> EIGEN_DEVICE_FUNC
inline Packet
419pxor(
const Packet& a,
const Packet& b) {
420 return bitwise_helper<Packet>::bitwise_xor(a, b);
424template<
typename Packet> EIGEN_DEVICE_FUNC
inline Packet
425pnot(
const Packet& a) {
426 return bitwise_helper<Packet>::bitwise_not(a);
430template<
typename Packet> EIGEN_DEVICE_FUNC
inline Packet
431pandnot(
const Packet& a,
const Packet& b) {
return pand(a, pnot(b)); }
434template<
typename Packet,
typename EnableIf =
void>
436 static EIGEN_DEVICE_FUNC
inline Packet run(
const Packet& mask,
const Packet& a,
const Packet& b) {
437 return por(pand(a,mask),pandnot(b,mask));
442template<
typename Packet>
443struct pselect_impl<Packet,
444 typename internal::enable_if<is_scalar<Packet>::value>::type > {
445 static EIGEN_DEVICE_FUNC
inline Packet run(
const Packet& mask,
const Packet& a,
const Packet& b) {
446 return numext::equal_strict(mask, Packet(0)) ? b : a;
451template<
typename Packet> EIGEN_DEVICE_FUNC
inline Packet
452pselect(
const Packet& mask,
const Packet& a,
const Packet& b) {
453 return pselect_impl<Packet>::run(mask, a, b);
456template<> EIGEN_DEVICE_FUNC
inline bool pselect<bool>(
457 const bool& cond,
const bool& a,
const bool& b) {
463template<
int NaNPropagation>
465 template <
typename Packet,
typename Op>
466 static EIGEN_DEVICE_FUNC
inline Packet run(
const Packet& a,
const Packet& b, Op op) {
475 template <
typename Packet,
typename Op>
476 static EIGEN_DEVICE_FUNC
inline Packet run(
const Packet& a,
const Packet& b, Op op) {
477 Packet not_nan_mask_a = pcmp_eq(a, a);
478 Packet not_nan_mask_b = pcmp_eq(b, b);
479 return pselect(not_nan_mask_a,
480 pselect(not_nan_mask_b, op(a, b), b),
490 template <
typename Packet,
typename Op>
491 static EIGEN_DEVICE_FUNC
inline Packet run(
const Packet& a,
const Packet& b, Op op) {
492 Packet not_nan_mask_a = pcmp_eq(a, a);
493 Packet not_nan_mask_b = pcmp_eq(b, b);
494 return pselect(not_nan_mask_a,
495 pselect(not_nan_mask_b, op(a, b), a),
501#ifndef SYCL_DEVICE_ONLY
502#define EIGEN_BINARY_OP_NAN_PROPAGATION(Type, Func) Func
504#define EIGEN_BINARY_OP_NAN_PROPAGATION(Type, Func) \
505[](const Type& a, const Type& b) { \
511template<
typename Packet> EIGEN_DEVICE_FUNC
inline Packet
512pmin(
const Packet& a,
const Packet& b) {
return numext::mini(a,b); }
516template <
int NaNPropagation,
typename Packet>
517EIGEN_DEVICE_FUNC
inline Packet pmin(
const Packet& a,
const Packet& b) {
518 return pminmax_impl<NaNPropagation>::run(a, b, EIGEN_BINARY_OP_NAN_PROPAGATION(Packet, (pmin<Packet>)));
523template<
typename Packet> EIGEN_DEVICE_FUNC
inline Packet
524pmax(
const Packet& a,
const Packet& b) {
return numext::maxi(a, b); }
528template <
int NaNPropagation,
typename Packet>
529EIGEN_DEVICE_FUNC
inline Packet pmax(
const Packet& a,
const Packet& b) {
530 return pminmax_impl<NaNPropagation>::run(a, b, EIGEN_BINARY_OP_NAN_PROPAGATION(Packet,(pmax<Packet>)));
534template<
typename Packet> EIGEN_DEVICE_FUNC
inline Packet
535pabs(
const Packet& a) {
return numext::abs(a); }
536template<> EIGEN_DEVICE_FUNC
inline unsigned int
537pabs(
const unsigned int& a) {
return a; }
538template<> EIGEN_DEVICE_FUNC
inline unsigned long
539pabs(
const unsigned long& a) {
return a; }
540template<> EIGEN_DEVICE_FUNC
inline unsigned long long
541pabs(
const unsigned long long& a) {
return a; }
544template<
typename Packet> EIGEN_DEVICE_FUNC
inline Packet
545paddsub(
const Packet& a,
const Packet& b) {
546 return pselect(peven_mask(a), padd(a, b), psub(a, b));
550template<
typename Packet> EIGEN_DEVICE_FUNC
inline Packet
551parg(
const Packet& a) {
using numext::arg;
return arg(a); }
555template<
int N> EIGEN_DEVICE_FUNC
inline int
556parithmetic_shift_right(
const int& a) {
return a >> N; }
557template<
int N> EIGEN_DEVICE_FUNC
inline long int
558parithmetic_shift_right(
const long int& a) {
return a >> N; }
561template<
int N> EIGEN_DEVICE_FUNC
inline int
562plogical_shift_right(
const int& a) {
return static_cast<int>(
static_cast<unsigned int>(a) >> N); }
563template<
int N> EIGEN_DEVICE_FUNC
inline long int
564plogical_shift_right(
const long int& a) {
return static_cast<long>(
static_cast<unsigned long>(a) >> N); }
567template<
int N> EIGEN_DEVICE_FUNC
inline int
568plogical_shift_left(
const int& a) {
return a << N; }
569template<
int N> EIGEN_DEVICE_FUNC
inline long int
570plogical_shift_left(
const long int& a) {
return a << N; }
575template <
typename Packet>
576EIGEN_DEVICE_FUNC
inline Packet pfrexp(
const Packet& a, Packet& exponent) {
578 EIGEN_USING_STD(frexp);
579 Packet result =
static_cast<Packet
>(frexp(a, &exp));
580 exponent =
static_cast<Packet
>(exp);
587template<
typename Packet> EIGEN_DEVICE_FUNC
inline Packet
588pldexp(
const Packet &a,
const Packet &exponent) {
589 EIGEN_USING_STD(ldexp)
590 return static_cast<Packet
>(ldexp(a,
static_cast<int>(exponent)));
594template<
typename Packet> EIGEN_DEVICE_FUNC
inline Packet
595pabsdiff(
const Packet& a,
const Packet& b) {
return pselect(pcmp_lt(a, b), psub(b, a), psub(a, b)); }
598template<
typename Packet> EIGEN_DEVICE_FUNC
inline Packet
599pload(
const typename unpacket_traits<Packet>::type* from) {
return *from; }
602template<
typename Packet> EIGEN_DEVICE_FUNC
inline Packet
603ploadu(
const typename unpacket_traits<Packet>::type* from) {
return *from; }
609template<
typename Packet> EIGEN_DEVICE_FUNC
inline
610typename enable_if<unpacket_traits<Packet>::masked_load_available, Packet>::type
611ploadu(
const typename unpacket_traits<Packet>::type* from,
typename unpacket_traits<Packet>::mask_t umask);
614template<
typename Packet> EIGEN_DEVICE_FUNC
inline Packet
615pset1(
const typename unpacket_traits<Packet>::type& a) {
return a; }
618template<
typename Packet,
typename BitsType> EIGEN_DEVICE_FUNC
inline Packet
619pset1frombits(BitsType a);
622template<
typename Packet> EIGEN_DEVICE_FUNC
inline Packet
623pload1(
const typename unpacket_traits<Packet>::type *a) {
return pset1<Packet>(*a); }
630template<
typename Packet> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet
631ploaddup(
const typename unpacket_traits<Packet>::type* from) {
return *from; }
639template<
typename Packet> EIGEN_DEVICE_FUNC
inline Packet
640ploadquad(
const typename unpacket_traits<Packet>::type* from)
641{
return pload1<Packet>(from); }
652template<
typename Packet> EIGEN_DEVICE_FUNC
653inline void pbroadcast4(
const typename unpacket_traits<Packet>::type *a,
654 Packet& a0, Packet& a1, Packet& a2, Packet& a3)
656 a0 = pload1<Packet>(a+0);
657 a1 = pload1<Packet>(a+1);
658 a2 = pload1<Packet>(a+2);
659 a3 = pload1<Packet>(a+3);
669template<
typename Packet> EIGEN_DEVICE_FUNC
670inline void pbroadcast2(
const typename unpacket_traits<Packet>::type *a,
671 Packet& a0, Packet& a1)
673 a0 = pload1<Packet>(a+0);
674 a1 = pload1<Packet>(a+1);
678template<
typename Packet> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet
679plset(
const typename unpacket_traits<Packet>::type& a) {
return a; }
683template<
typename Packet> EIGEN_DEVICE_FUNC
inline Packet
684peven_mask(
const Packet& ) {
685 typedef typename unpacket_traits<Packet>::type Scalar;
686 const size_t n = unpacket_traits<Packet>::size;
687 EIGEN_ALIGN_TO_BOUNDARY(
sizeof(Packet)) Scalar elements[n];
688 for(
size_t i = 0; i < n; ++i) {
689 memset(elements+i, ((i & 1) == 0 ? 0xff : 0),
sizeof(Scalar));
691 return ploadu<Packet>(elements);
696template<
typename Scalar,
typename Packet> EIGEN_DEVICE_FUNC
inline void pstore(Scalar* to,
const Packet& from)
700template<
typename Scalar,
typename Packet> EIGEN_DEVICE_FUNC
inline void pstoreu(Scalar* to,
const Packet& from)
707template<
typename Scalar,
typename Packet>
708EIGEN_DEVICE_FUNC
inline
709typename enable_if<unpacket_traits<Packet>::masked_store_available,
void>::type
710pstoreu(Scalar* to,
const Packet& from,
typename unpacket_traits<Packet>::mask_t umask);
712 template<
typename Scalar,
typename Packet> EIGEN_DEVICE_FUNC
inline Packet pgather(
const Scalar* from,
Index )
713 {
return ploadu<Packet>(from); }
715 template<
typename Scalar,
typename Packet> EIGEN_DEVICE_FUNC
inline void pscatter(Scalar* to,
const Packet& from,
Index )
716 { pstore(to, from); }
719template<
typename Scalar> EIGEN_DEVICE_FUNC
inline void prefetch(
const Scalar* addr)
721#if defined(EIGEN_HIP_DEVICE_COMPILE)
723#elif defined(EIGEN_CUDA_ARCH)
724#if defined(__LP64__) || EIGEN_OS_WIN64
726 asm(
" prefetch.L1 [ %1 ];" :
"=l"(addr) :
"l"(addr));
729 asm(
" prefetch.L1 [ %1 ];" :
"=r"(addr) :
"r"(addr));
731#elif (!EIGEN_COMP_MSVC) && (EIGEN_COMP_GNUC || EIGEN_COMP_CLANG || EIGEN_COMP_ICC)
732 __builtin_prefetch(addr);
737template<
typename Packet> EIGEN_DEVICE_FUNC
inline Packet preverse(
const Packet& a)
741template<
typename Packet> EIGEN_DEVICE_FUNC
inline Packet pcplxflip(
const Packet& a)
743 return Packet(numext::imag(a),numext::real(a));
751template<
typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
752Packet psin(
const Packet& a) { EIGEN_USING_STD(sin);
return sin(a); }
755template<
typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
756Packet pcos(
const Packet& a) { EIGEN_USING_STD(cos);
return cos(a); }
759template<
typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
760Packet ptan(
const Packet& a) { EIGEN_USING_STD(tan);
return tan(a); }
763template<
typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
764Packet pasin(
const Packet& a) { EIGEN_USING_STD(asin);
return asin(a); }
767template<
typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
768Packet pacos(
const Packet& a) { EIGEN_USING_STD(acos);
return acos(a); }
771template<
typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
772Packet patan(
const Packet& a) { EIGEN_USING_STD(atan);
return atan(a); }
775template<
typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
776Packet psinh(
const Packet& a) { EIGEN_USING_STD(sinh);
return sinh(a); }
779template<
typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
780Packet pcosh(
const Packet& a) { EIGEN_USING_STD(cosh);
return cosh(a); }
783template<
typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
784Packet ptanh(
const Packet& a) { EIGEN_USING_STD(tanh);
return tanh(a); }
787template<
typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
788Packet pexp(
const Packet& a) { EIGEN_USING_STD(exp);
return exp(a); }
791template<
typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
792Packet pexpm1(
const Packet& a) {
return numext::expm1(a); }
795template<
typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
796Packet plog(
const Packet& a) { EIGEN_USING_STD(log);
return log(a); }
799template<
typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
800Packet plog1p(
const Packet& a) {
return numext::log1p(a); }
803template<
typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
804Packet plog10(
const Packet& a) { EIGEN_USING_STD(log10);
return log10(a); }
807template<
typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
808Packet plog2(
const Packet& a) {
809 typedef typename internal::unpacket_traits<Packet>::type Scalar;
810 return pmul(pset1<Packet>(Scalar(EIGEN_LOG2E)), plog(a));
814template<
typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
815Packet psqrt(
const Packet& a) {
return numext::sqrt(a); }
818template<
typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
819Packet prsqrt(
const Packet& a) {
820 typedef typename internal::unpacket_traits<Packet>::type Scalar;
821 return pdiv(pset1<Packet>(Scalar(1)), psqrt(a));
825template<
typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
826Packet pround(
const Packet& a) {
using numext::round;
return round(a); }
829template<
typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
830Packet pfloor(
const Packet& a) {
using numext::floor;
return floor(a); }
834template<
typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
835Packet print(
const Packet& a) {
using numext::rint;
return rint(a); }
838template<
typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
839Packet pceil(
const Packet& a) {
using numext::ceil;
return ceil(a); }
842template<
typename Packet>
843EIGEN_DEVICE_FUNC
inline typename unpacket_traits<Packet>::type
844pfirst(
const Packet& a)
851template<
typename Packet>
852EIGEN_DEVICE_FUNC
inline typename conditional<(unpacket_traits<Packet>::size%8)==0,
typename unpacket_traits<Packet>::half,Packet>::type
853predux_half_dowto4(
const Packet& a)
857template <
typename Packet,
typename Op>
858EIGEN_DEVICE_FUNC
inline typename unpacket_traits<Packet>::type
859predux_helper(
const Packet& a, Op op) {
860 typedef typename unpacket_traits<Packet>::type Scalar;
861 const size_t n = unpacket_traits<Packet>::size;
862 EIGEN_ALIGN_TO_BOUNDARY(
sizeof(Packet)) Scalar elements[n];
863 pstoreu<Scalar>(elements, a);
864 for(
size_t k = n / 2; k > 0; k /= 2) {
865 for(
size_t i = 0; i < k; ++i) {
866 elements[i] = op(elements[i], elements[i + k]);
873template<
typename Packet>
874EIGEN_DEVICE_FUNC
inline typename unpacket_traits<Packet>::type
875predux(
const Packet& a)
881template <
typename Packet>
882EIGEN_DEVICE_FUNC
inline typename unpacket_traits<Packet>::type predux_mul(
884 typedef typename unpacket_traits<Packet>::type Scalar;
885 return predux_helper(a, EIGEN_BINARY_OP_NAN_PROPAGATION(Scalar, (pmul<Scalar>)));
889template <
typename Packet>
890EIGEN_DEVICE_FUNC
inline typename unpacket_traits<Packet>::type predux_min(
892 typedef typename unpacket_traits<Packet>::type Scalar;
893 return predux_helper(a, EIGEN_BINARY_OP_NAN_PROPAGATION(Scalar, (pmin<PropagateFast, Scalar>)));
896template <
int NaNPropagation,
typename Packet>
897EIGEN_DEVICE_FUNC
inline typename unpacket_traits<Packet>::type predux_min(
899 typedef typename unpacket_traits<Packet>::type Scalar;
900 return predux_helper(a, EIGEN_BINARY_OP_NAN_PROPAGATION(Scalar, (pmin<NaNPropagation, Scalar>)));
904template <
typename Packet>
905EIGEN_DEVICE_FUNC
inline typename unpacket_traits<Packet>::type predux_max(
907 typedef typename unpacket_traits<Packet>::type Scalar;
908 return predux_helper(a, EIGEN_BINARY_OP_NAN_PROPAGATION(Scalar, (pmax<PropagateFast, Scalar>)));
911template <
int NaNPropagation,
typename Packet>
912EIGEN_DEVICE_FUNC
inline typename unpacket_traits<Packet>::type predux_max(
914 typedef typename unpacket_traits<Packet>::type Scalar;
915 return predux_helper(a, EIGEN_BINARY_OP_NAN_PROPAGATION(Scalar, (pmax<NaNPropagation, Scalar>)));
918#undef EIGEN_BINARY_OP_NAN_PROPAGATION
930template<
typename Packet> EIGEN_DEVICE_FUNC
inline bool predux_any(
const Packet& a)
938 typedef typename unpacket_traits<Packet>::type Scalar;
939 return numext::not_equal_strict(predux(a), Scalar(0));
948template<
typename Packet>
949inline void pstore1(
typename unpacket_traits<Packet>::type* to,
const typename unpacket_traits<Packet>::type& a)
951 pstore(to, pset1<Packet>(a));
955template<
typename Packet> EIGEN_DEVICE_FUNC
inline Packet
956pmadd(
const Packet& a,
959{
return padd(pmul(a, b),c); }
963template<
typename Packet,
int Alignment>
964EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet ploadt(
const typename unpacket_traits<Packet>::type* from)
966 if(Alignment >= unpacket_traits<Packet>::alignment)
967 return pload<Packet>(from);
969 return ploadu<Packet>(from);
974template<
typename Scalar,
typename Packet,
int Alignment>
975EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
void pstoret(Scalar* to,
const Packet& from)
977 if(Alignment >= unpacket_traits<Packet>::alignment)
988template<
typename Packet,
int LoadMode>
989EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet ploadt_ro(
const typename unpacket_traits<Packet>::type* from)
991 return ploadt<Packet, LoadMode>(from);
999#if !defined(EIGEN_GPUCC)
1001template<>
inline std::complex<float> pmul(
const std::complex<float>& a,
const std::complex<float>& b)
1002{
return std::complex<float>(a.real()*b.real() - a.imag()*b.imag(), a.imag()*b.real() + a.real()*b.imag()); }
1004template<>
inline std::complex<double> pmul(
const std::complex<double>& a,
const std::complex<double>& b)
1005{
return std::complex<double>(a.real()*b.real() - a.imag()*b.imag(), a.imag()*b.real() + a.real()*b.imag()); }
1014template <typename Packet,int N=unpacket_traits<Packet>::size>
struct PacketBlock {
1018template<
typename Packet> EIGEN_DEVICE_FUNC
inline void
1019ptranspose(PacketBlock<Packet,1>& ) {
1027template <
size_t N>
struct Selector {
1031template<
typename Packet> EIGEN_DEVICE_FUNC
inline Packet
1032pblend(
const Selector<unpacket_traits<Packet>::size>& ifPacket,
const Packet& thenPacket,
const Packet& elsePacket) {
1033 return ifPacket.select[0] ? thenPacket : elsePacket;
@ PropagateNaN
Definition: Constants.h:343
@ PropagateNumbers
Definition: Constants.h:345
Namespace containing all symbols from the Eigen library.
Definition: Core:141
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:74
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_arg_op< typename Derived::Scalar >, const Derived > arg(const Eigen::ArrayBase< Derived > &x)