Path Tracer
GenericPacketMath.h
1 // This file is part of Eigen, a lightweight C++ template library
2 // for linear algebra.
3 //
4 // Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
5 // Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
6 //
7 // This Source Code Form is subject to the terms of the Mozilla
8 // Public License v. 2.0. If a copy of the MPL was not distributed
9 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
10 
11 #ifndef EIGEN_GENERIC_PACKET_MATH_H
12 #define EIGEN_GENERIC_PACKET_MATH_H
13 
14 namespace Eigen {
15 
16 namespace internal {
17 
26 #ifndef EIGEN_DEBUG_ALIGNED_LOAD
27 #define EIGEN_DEBUG_ALIGNED_LOAD
28 #endif
29 
30 #ifndef EIGEN_DEBUG_UNALIGNED_LOAD
31 #define EIGEN_DEBUG_UNALIGNED_LOAD
32 #endif
33 
34 #ifndef EIGEN_DEBUG_ALIGNED_STORE
35 #define EIGEN_DEBUG_ALIGNED_STORE
36 #endif
37 
38 #ifndef EIGEN_DEBUG_UNALIGNED_STORE
39 #define EIGEN_DEBUG_UNALIGNED_STORE
40 #endif
41 
42 struct default_packet_traits
43 {
44  enum {
45  HasHalfPacket = 0,
46 
47  HasAdd = 1,
48  HasSub = 1,
49  HasShift = 1,
50  HasMul = 1,
51  HasNegate = 1,
52  HasAbs = 1,
53  HasArg = 0,
54  HasAbs2 = 1,
55  HasAbsDiff = 0,
56  HasMin = 1,
57  HasMax = 1,
58  HasConj = 1,
59  HasSetLinear = 1,
60  HasBlend = 0,
61  // This flag is used to indicate whether packet comparison is supported.
62  // pcmp_eq, pcmp_lt and pcmp_le should be defined for it to be true.
63  HasCmp = 0,
64 
65  HasDiv = 0,
66  HasSqrt = 0,
67  HasRsqrt = 0,
68  HasExp = 0,
69  HasExpm1 = 0,
70  HasLog = 0,
71  HasLog1p = 0,
72  HasLog10 = 0,
73  HasPow = 0,
74 
75  HasSin = 0,
76  HasCos = 0,
77  HasTan = 0,
78  HasASin = 0,
79  HasACos = 0,
80  HasATan = 0,
81  HasSinh = 0,
82  HasCosh = 0,
83  HasTanh = 0,
84  HasLGamma = 0,
85  HasDiGamma = 0,
86  HasZeta = 0,
87  HasPolygamma = 0,
88  HasErf = 0,
89  HasErfc = 0,
90  HasNdtri = 0,
91  HasBessel = 0,
92  HasIGamma = 0,
93  HasIGammaDerA = 0,
94  HasGammaSampleDerAlpha = 0,
95  HasIGammac = 0,
96  HasBetaInc = 0,
97 
98  HasRound = 0,
99  HasRint = 0,
100  HasFloor = 0,
101  HasCeil = 0,
102  HasSign = 0
103  };
104 };
105 
106 template<typename T> struct packet_traits : default_packet_traits
107 {
108  typedef T type;
109  typedef T half;
110  enum {
111  Vectorizable = 0,
112  size = 1,
113  AlignedOnScalar = 0,
114  HasHalfPacket = 0
115  };
116  enum {
117  HasAdd = 0,
118  HasSub = 0,
119  HasMul = 0,
120  HasNegate = 0,
121  HasAbs = 0,
122  HasAbs2 = 0,
123  HasMin = 0,
124  HasMax = 0,
125  HasConj = 0,
126  HasSetLinear = 0
127  };
128 };
129 
130 template<typename T> struct packet_traits<const T> : packet_traits<T> { };
131 
132 template <typename Src, typename Tgt> struct type_casting_traits {
133  enum {
134  VectorizedCast = 0,
135  SrcCoeffRatio = 1,
136  TgtCoeffRatio = 1
137  };
138 };
139 
142 template<typename T, int unique_id = 0>
143 struct eigen_packet_wrapper
144 {
145  EIGEN_ALWAYS_INLINE operator T&() { return m_val; }
146  EIGEN_ALWAYS_INLINE operator const T&() const { return m_val; }
147  EIGEN_ALWAYS_INLINE eigen_packet_wrapper() {}
148  EIGEN_ALWAYS_INLINE eigen_packet_wrapper(const T &v) : m_val(v) {}
149  EIGEN_ALWAYS_INLINE eigen_packet_wrapper& operator=(const T &v) {
150  m_val = v;
151  return *this;
152  }
153 
154  T m_val;
155 };
156 
158 template <typename SrcPacket, typename TgtPacket>
159 EIGEN_DEVICE_FUNC inline TgtPacket
160 pcast(const SrcPacket& a) {
161  return static_cast<TgtPacket>(a);
162 }
163 template <typename SrcPacket, typename TgtPacket>
164 EIGEN_DEVICE_FUNC inline TgtPacket
165 pcast(const SrcPacket& a, const SrcPacket& /*b*/) {
166  return static_cast<TgtPacket>(a);
167 }
168 template <typename SrcPacket, typename TgtPacket>
169 EIGEN_DEVICE_FUNC inline TgtPacket
170 pcast(const SrcPacket& a, const SrcPacket& /*b*/, const SrcPacket& /*c*/, const SrcPacket& /*d*/) {
171  return static_cast<TgtPacket>(a);
172 }
173 template <typename SrcPacket, typename TgtPacket>
174 EIGEN_DEVICE_FUNC inline TgtPacket
175 pcast(const SrcPacket& a, const SrcPacket& /*b*/, const SrcPacket& /*c*/, const SrcPacket& /*d*/,
176  const SrcPacket& /*e*/, const SrcPacket& /*f*/, const SrcPacket& /*g*/, const SrcPacket& /*h*/) {
177  return static_cast<TgtPacket>(a);
178 }
179 
181 template <typename Target, typename Packet>
182 EIGEN_DEVICE_FUNC inline Target
183 preinterpret(const Packet& a); /* { return reinterpret_cast<const Target&>(a); } */
184 
186 template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
187 padd(const Packet& a, const Packet& b) { return a+b; }
188 // Avoid compiler warning for boolean algebra.
189 template<> EIGEN_DEVICE_FUNC inline bool
190 padd(const bool& a, const bool& b) { return a || b; }
191 
193 template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
194 psub(const Packet& a, const Packet& b) { return a-b; }
195 
197 template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
198 pnegate(const Packet& a) { return -a; }
199 
200 template<> EIGEN_DEVICE_FUNC inline bool
201 pnegate(const bool& a) { return !a; }
202 
204 template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
205 pconj(const Packet& a) { return numext::conj(a); }
206 
208 template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
209 pmul(const Packet& a, const Packet& b) { return a*b; }
210 // Avoid compiler warning for boolean algebra.
211 template<> EIGEN_DEVICE_FUNC inline bool
212 pmul(const bool& a, const bool& b) { return a && b; }
213 
215 template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
216 pdiv(const Packet& a, const Packet& b) { return a/b; }
217 
219 template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
220 ptrue(const Packet& /*a*/) { Packet b; memset((void*)&b, 0xff, sizeof(b)); return b;}
221 
223 template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
224 pzero(const Packet& /*a*/) { Packet b; memset((void*)&b, 0, sizeof(b)); return b;}
225 
227 template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
228 pcmp_le(const Packet& a, const Packet& b) { return a<=b ? ptrue(a) : pzero(a); }
229 
231 template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
232 pcmp_lt(const Packet& a, const Packet& b) { return a<b ? ptrue(a) : pzero(a); }
233 
235 template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
236 pcmp_eq(const Packet& a, const Packet& b) { return a==b ? ptrue(a) : pzero(a); }
237 
239 template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
240 pcmp_lt_or_nan(const Packet& a, const Packet& b) { return a>=b ? pzero(a) : ptrue(a); }
241 template<> EIGEN_DEVICE_FUNC inline float pzero<float>(const float& a) {
242  EIGEN_UNUSED_VARIABLE(a)
243  return 0.f;
244 }
245 
246 template<> EIGEN_DEVICE_FUNC inline double pzero<double>(const double& a) {
247  EIGEN_UNUSED_VARIABLE(a)
248  return 0.;
249 }
250 
251 template <typename RealScalar>
252 EIGEN_DEVICE_FUNC inline std::complex<RealScalar> ptrue(const std::complex<RealScalar>& /*a*/) {
253  RealScalar b;
254  b = ptrue(b);
255  return std::complex<RealScalar>(b, b);
256 }
257 
258 template <typename Packet, typename Op>
259 EIGEN_DEVICE_FUNC inline Packet bitwise_helper(const Packet& a, const Packet& b, Op op) {
260  const unsigned char* a_ptr = reinterpret_cast<const unsigned char*>(&a);
261  const unsigned char* b_ptr = reinterpret_cast<const unsigned char*>(&b);
262  Packet c;
263  unsigned char* c_ptr = reinterpret_cast<unsigned char*>(&c);
264  for (size_t i = 0; i < sizeof(Packet); ++i) {
265  *c_ptr++ = op(*a_ptr++, *b_ptr++);
266  }
267  return c;
268 }
269 
271 template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
272 pand(const Packet& a, const Packet& b) {
273 #if defined(EIGEN_HIP_DEVICE_COMPILE)
274  return bitwise_helper(a ,b, std::bit_and<unsigned char>());
275 #else
276  EIGEN_USING_STD(bit_and);
277  return bitwise_helper(a ,b, bit_and<unsigned char>());
278 #endif
279 }
280 
282 template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
283 por(const Packet& a, const Packet& b) {
284 #if defined(EIGEN_HIP_DEVICE_COMPILE)
285  return bitwise_helper(a ,b, std::bit_or<unsigned char>());
286 #else
287  EIGEN_USING_STD(bit_or);
288  return bitwise_helper(a ,b, bit_or<unsigned char>());
289 #endif
290 }
291 
293 template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
294 pxor(const Packet& a, const Packet& b) {
295 #if defined(EIGEN_HIP_DEVICE_COMPILE)
296  return bitwise_helper(a ,b, std::bit_xor<unsigned char>());
297 #else
298  EIGEN_USING_STD(bit_xor);
299  return bitwise_helper(a ,b, bit_xor<unsigned char>());
300 #endif
301 }
302 
304 template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
305 pandnot(const Packet& a, const Packet& b) { return pand(a, pxor(ptrue(b), b)); }
306 
308 template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
309 pselect(const Packet& mask, const Packet& a, const Packet& b) {
310  return por(pand(a,mask),pandnot(b,mask));
311 }
312 
313 template<> EIGEN_DEVICE_FUNC inline float pselect<float>(
314  const float& cond, const float& a, const float&b) {
315  return numext::equal_strict(cond,0.f) ? b : a;
316 }
317 
318 template<> EIGEN_DEVICE_FUNC inline double pselect<double>(
319  const double& cond, const double& a, const double& b) {
320  return numext::equal_strict(cond,0.) ? b : a;
321 }
322 
323 template<> EIGEN_DEVICE_FUNC inline bool pselect<bool>(
324  const bool& cond, const bool& a, const bool& b) {
325  return cond ? a : b;
326 }
327 
330 template<int NaNPropagation>
331 struct pminmax_impl {
332  template <typename Packet, typename Op>
333  static EIGEN_DEVICE_FUNC inline Packet run(const Packet& a, const Packet& b, Op op) {
334  return op(a,b);
335  }
336 };
337 
340 template<>
341 struct pminmax_impl<PropagateNaN> {
342  template <typename Packet, typename Op>
343  static EIGEN_DEVICE_FUNC inline Packet run(const Packet& a, const Packet& b, Op op) {
344  Packet not_nan_mask_a = pcmp_eq(a, a);
345  Packet not_nan_mask_b = pcmp_eq(b, b);
346  return pselect(not_nan_mask_a,
347  pselect(not_nan_mask_b, op(a, b), b),
348  a);
349  }
350 };
351 
355 template<>
356 struct pminmax_impl<PropagateNumbers> {
357  template <typename Packet, typename Op>
358  static EIGEN_DEVICE_FUNC inline Packet run(const Packet& a, const Packet& b, Op op) {
359  Packet not_nan_mask_a = pcmp_eq(a, a);
360  Packet not_nan_mask_b = pcmp_eq(b, b);
361  return pselect(not_nan_mask_a,
362  pselect(not_nan_mask_b, op(a, b), a),
363  b);
364  }
365 };
366 
367 
368 #ifndef SYCL_DEVICE_ONLY
369 #define EIGEN_BINARY_OP_NAN_PROPAGATION(Type, Func) Func
370 #else
371 #define EIGEN_BINARY_OP_NAN_PROPAGATION(Type, Func) \
372 [](const Type& a, const Type& b) { \
373  return Func(a, b);}
374 #endif
375 
378 template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
379 pmin(const Packet& a, const Packet& b) { return numext::mini(a,b); }
380 
383 template <int NaNPropagation, typename Packet>
384 EIGEN_DEVICE_FUNC inline Packet pmin(const Packet& a, const Packet& b) {
385  return pminmax_impl<NaNPropagation>::run(a, b, EIGEN_BINARY_OP_NAN_PROPAGATION(Packet, (pmin<Packet>)));
386 }
387 
390 template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
391 pmax(const Packet& a, const Packet& b) { return numext::maxi(a, b); }
392 
395 template <int NaNPropagation, typename Packet>
396 EIGEN_DEVICE_FUNC inline Packet pmax(const Packet& a, const Packet& b) {
397  return pminmax_impl<NaNPropagation>::run(a, b, EIGEN_BINARY_OP_NAN_PROPAGATION(Packet,(pmax<Packet>)));
398 }
399 
401 template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
402 pabs(const Packet& a) { return numext::abs(a); }
403 template<> EIGEN_DEVICE_FUNC inline unsigned int
404 pabs(const unsigned int& a) { return a; }
405 template<> EIGEN_DEVICE_FUNC inline unsigned long
406 pabs(const unsigned long& a) { return a; }
407 template<> EIGEN_DEVICE_FUNC inline unsigned long long
408 pabs(const unsigned long long& a) { return a; }
409 
411 template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
412 parg(const Packet& a) { using numext::arg; return arg(a); }
413 
414 
416 template<int N> EIGEN_DEVICE_FUNC inline int
417 parithmetic_shift_right(const int& a) { return a >> N; }
418 template<int N> EIGEN_DEVICE_FUNC inline long int
419 parithmetic_shift_right(const long int& a) { return a >> N; }
420 
422 template<int N> EIGEN_DEVICE_FUNC inline int
423 plogical_shift_right(const int& a) { return static_cast<int>(static_cast<unsigned int>(a) >> N); }
424 template<int N> EIGEN_DEVICE_FUNC inline long int
425 plogical_shift_right(const long int& a) { return static_cast<long>(static_cast<unsigned long>(a) >> N); }
426 
428 template<int N> EIGEN_DEVICE_FUNC inline int
429 plogical_shift_left(const int& a) { return a << N; }
430 template<int N> EIGEN_DEVICE_FUNC inline long int
431 plogical_shift_left(const long int& a) { return a << N; }
432 
436 template <typename Packet>
437 EIGEN_DEVICE_FUNC inline Packet pfrexp(const Packet& a, Packet& exponent) {
438  int exp;
439  EIGEN_USING_STD(frexp);
440  Packet result = frexp(a, &exp);
441  exponent = static_cast<Packet>(exp);
442  return result;
443 }
444 
448 template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
449 pldexp(const Packet &a, const Packet &exponent) {
450  EIGEN_USING_STD(ldexp)
451  return ldexp(a, static_cast<int>(exponent));
452 }
453 
455 template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
456 pabsdiff(const Packet& a, const Packet& b) { return pselect(pcmp_lt(a, b), psub(b, a), psub(a, b)); }
457 
459 template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
460 pload(const typename unpacket_traits<Packet>::type* from) { return *from; }
461 
463 template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
464 ploadu(const typename unpacket_traits<Packet>::type* from) { return *from; }
465 
470 template<typename Packet> EIGEN_DEVICE_FUNC inline
471 typename enable_if<unpacket_traits<Packet>::masked_load_available, Packet>::type
472 ploadu(const typename unpacket_traits<Packet>::type* from, typename unpacket_traits<Packet>::mask_t umask);
473 
475 template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
476 pset1(const typename unpacket_traits<Packet>::type& a) { return a; }
477 
479 template<typename Packet,typename BitsType> EIGEN_DEVICE_FUNC inline Packet
480 pset1frombits(BitsType a);
481 
483 template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
484 pload1(const typename unpacket_traits<Packet>::type *a) { return pset1<Packet>(*a); }
485 
491 template<typename Packet> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet
492 ploaddup(const typename unpacket_traits<Packet>::type* from) { return *from; }
493 
500 template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
501 ploadquad(const typename unpacket_traits<Packet>::type* from)
502 { return pload1<Packet>(from); }
503 
513 template<typename Packet> EIGEN_DEVICE_FUNC
514 inline void pbroadcast4(const typename unpacket_traits<Packet>::type *a,
515  Packet& a0, Packet& a1, Packet& a2, Packet& a3)
516 {
517  a0 = pload1<Packet>(a+0);
518  a1 = pload1<Packet>(a+1);
519  a2 = pload1<Packet>(a+2);
520  a3 = pload1<Packet>(a+3);
521 }
522 
530 template<typename Packet> EIGEN_DEVICE_FUNC
531 inline void pbroadcast2(const typename unpacket_traits<Packet>::type *a,
532  Packet& a0, Packet& a1)
533 {
534  a0 = pload1<Packet>(a+0);
535  a1 = pload1<Packet>(a+1);
536 }
537 
539 template<typename Packet> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet
540 plset(const typename unpacket_traits<Packet>::type& a) { return a; }
541 
544 template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
545 peven_mask(const Packet& /*a*/) {
546  typedef typename unpacket_traits<Packet>::type Scalar;
547  const size_t n = unpacket_traits<Packet>::size;
548  Scalar elements[n];
549  for(size_t i = 0; i < n; ++i) {
550  memset(elements+i, ((i & 1) == 0 ? 0xff : 0), sizeof(Scalar));
551  }
552  return ploadu<Packet>(elements);
553 }
554 
555 
557 template<typename Scalar, typename Packet> EIGEN_DEVICE_FUNC inline void pstore(Scalar* to, const Packet& from)
558 { (*to) = from; }
559 
561 template<typename Scalar, typename Packet> EIGEN_DEVICE_FUNC inline void pstoreu(Scalar* to, const Packet& from)
562 { (*to) = from; }
563 
568 template<typename Scalar, typename Packet>
569 EIGEN_DEVICE_FUNC inline
570 typename enable_if<unpacket_traits<Packet>::masked_store_available, void>::type
571 pstoreu(Scalar* to, const Packet& from, typename unpacket_traits<Packet>::mask_t umask);
572 
573  template<typename Scalar, typename Packet> EIGEN_DEVICE_FUNC inline Packet pgather(const Scalar* from, Index /*stride*/)
574  { return ploadu<Packet>(from); }
575 
576  template<typename Scalar, typename Packet> EIGEN_DEVICE_FUNC inline void pscatter(Scalar* to, const Packet& from, Index /*stride*/)
577  { pstore(to, from); }
578 
580 template<typename Scalar> EIGEN_DEVICE_FUNC inline void prefetch(const Scalar* addr)
581 {
582 #if defined(EIGEN_HIP_DEVICE_COMPILE)
583  // do nothing
584 #elif defined(EIGEN_CUDA_ARCH)
585 #if defined(__LP64__) || EIGEN_OS_WIN64
586  // 64-bit pointer operand constraint for inlined asm
587  asm(" prefetch.L1 [ %1 ];" : "=l"(addr) : "l"(addr));
588 #else
589  // 32-bit pointer operand constraint for inlined asm
590  asm(" prefetch.L1 [ %1 ];" : "=r"(addr) : "r"(addr));
591 #endif
592 #elif (!EIGEN_COMP_MSVC) && (EIGEN_COMP_GNUC || EIGEN_COMP_CLANG || EIGEN_COMP_ICC)
593  __builtin_prefetch(addr);
594 #endif
595 }
596 
598 template<typename Packet> EIGEN_DEVICE_FUNC inline Packet preverse(const Packet& a)
599 { return a; }
600 
602 template<typename Packet> EIGEN_DEVICE_FUNC inline Packet pcplxflip(const Packet& a)
603 {
604  return Packet(numext::imag(a),numext::real(a));
605 }
606 
607 /**************************
608 * Special math functions
609 ***************************/
610 
612 template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
613 Packet psin(const Packet& a) { EIGEN_USING_STD(sin); return sin(a); }
614 
616 template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
617 Packet pcos(const Packet& a) { EIGEN_USING_STD(cos); return cos(a); }
618 
620 template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
621 Packet ptan(const Packet& a) { EIGEN_USING_STD(tan); return tan(a); }
622 
624 template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
625 Packet pasin(const Packet& a) { EIGEN_USING_STD(asin); return asin(a); }
626 
628 template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
629 Packet pacos(const Packet& a) { EIGEN_USING_STD(acos); return acos(a); }
630 
632 template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
633 Packet patan(const Packet& a) { EIGEN_USING_STD(atan); return atan(a); }
634 
636 template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
637 Packet psinh(const Packet& a) { EIGEN_USING_STD(sinh); return sinh(a); }
638 
640 template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
641 Packet pcosh(const Packet& a) { EIGEN_USING_STD(cosh); return cosh(a); }
642 
644 template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
645 Packet ptanh(const Packet& a) { EIGEN_USING_STD(tanh); return tanh(a); }
646 
648 template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
649 Packet pexp(const Packet& a) { EIGEN_USING_STD(exp); return exp(a); }
650 
652 template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
653 Packet pexpm1(const Packet& a) { return numext::expm1(a); }
654 
656 template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
657 Packet plog(const Packet& a) { EIGEN_USING_STD(log); return log(a); }
658 
660 template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
661 Packet plog1p(const Packet& a) { return numext::log1p(a); }
662 
664 template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
665 Packet plog10(const Packet& a) { EIGEN_USING_STD(log10); return log10(a); }
666 
668 template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
669 Packet plog2(const Packet& a) {
670  typedef typename internal::unpacket_traits<Packet>::type Scalar;
671  return pmul(pset1<Packet>(Scalar(EIGEN_LOG2E)), plog(a));
672 }
673 
675 template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
676 Packet psqrt(const Packet& a) { EIGEN_USING_STD(sqrt); return sqrt(a); }
677 
679 template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
680 Packet prsqrt(const Packet& a) {
681  typedef typename internal::unpacket_traits<Packet>::type Scalar;
682  return pdiv(pset1<Packet>(Scalar(1)), psqrt(a));
683 }
684 
686 template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
687 Packet pround(const Packet& a) { using numext::round; return round(a); }
688 
690 template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
691 Packet pfloor(const Packet& a) { using numext::floor; return floor(a); }
692 
695 template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
696 Packet print(const Packet& a) { using numext::rint; return rint(a); }
697 
699 template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
700 Packet pceil(const Packet& a) { using numext::ceil; return ceil(a); }
701 
703 template<typename Packet>
704 EIGEN_DEVICE_FUNC inline typename unpacket_traits<Packet>::type
705 pfirst(const Packet& a)
706 { return a; }
707 
712 template<typename Packet>
713 EIGEN_DEVICE_FUNC inline typename conditional<(unpacket_traits<Packet>::size%8)==0,typename unpacket_traits<Packet>::half,Packet>::type
714 predux_half_dowto4(const Packet& a)
715 { return a; }
716 
717 // Slow generic implementation of Packet reduction.
718 template <typename Packet, typename Op>
719 EIGEN_DEVICE_FUNC inline typename unpacket_traits<Packet>::type
720 predux_helper(const Packet& a, Op op) {
721  typedef typename unpacket_traits<Packet>::type Scalar;
722  const size_t n = unpacket_traits<Packet>::size;
723  Scalar elements[n];
724  pstoreu<Scalar>(elements, a);
725  for(size_t k = n / 2; k > 0; k /= 2) {
726  for(size_t i = 0; i < k; ++i) {
727  elements[i] = op(elements[i], elements[i + k]);
728  }
729  }
730  return elements[0];
731 }
732 
734 template<typename Packet>
735 EIGEN_DEVICE_FUNC inline typename unpacket_traits<Packet>::type
736 predux(const Packet& a)
737 {
738  return a;
739 }
740 
742 template <typename Packet>
743 EIGEN_DEVICE_FUNC inline typename unpacket_traits<Packet>::type predux_mul(
744  const Packet& a) {
745  typedef typename unpacket_traits<Packet>::type Scalar;
746  return predux_helper(a, EIGEN_BINARY_OP_NAN_PROPAGATION(Scalar, (pmul<Scalar>)));
747 }
748 
750 template <typename Packet>
751 EIGEN_DEVICE_FUNC inline typename unpacket_traits<Packet>::type predux_min(
752  const Packet &a) {
753  typedef typename unpacket_traits<Packet>::type Scalar;
754  return predux_helper(a, EIGEN_BINARY_OP_NAN_PROPAGATION(Scalar, (pmin<PropagateFast, Scalar>)));
755 }
756 
757 template <int NaNPropagation, typename Packet>
758 EIGEN_DEVICE_FUNC inline typename unpacket_traits<Packet>::type predux_min(
759  const Packet& a) {
760  typedef typename unpacket_traits<Packet>::type Scalar;
761  return predux_helper(a, EIGEN_BINARY_OP_NAN_PROPAGATION(Scalar, (pmin<NaNPropagation, Scalar>)));
762 }
763 
765 template <typename Packet>
766 EIGEN_DEVICE_FUNC inline typename unpacket_traits<Packet>::type predux_max(
767  const Packet &a) {
768  typedef typename unpacket_traits<Packet>::type Scalar;
769  return predux_helper(a, EIGEN_BINARY_OP_NAN_PROPAGATION(Scalar, (pmax<PropagateFast, Scalar>)));
770 }
771 
772 template <int NaNPropagation, typename Packet>
773 EIGEN_DEVICE_FUNC inline typename unpacket_traits<Packet>::type predux_max(
774  const Packet& a) {
775  typedef typename unpacket_traits<Packet>::type Scalar;
776  return predux_helper(a, EIGEN_BINARY_OP_NAN_PROPAGATION(Scalar, (pmax<NaNPropagation, Scalar>)));
777 }
778 
779 #undef EIGEN_BINARY_OP_NAN_PROPAGATION
780 
784 // not needed yet
785 // template<typename Packet> EIGEN_DEVICE_FUNC inline bool predux_all(const Packet& a)
786 // { return bool(a); }
787 
791 template<typename Packet> EIGEN_DEVICE_FUNC inline bool predux_any(const Packet& a)
792 {
793  // Dirty but generic implementation where "true" is assumed to be non 0 and all the sames.
794  // It is expected that "true" is either:
795  // - Scalar(1)
796  // - bits full of ones (NaN for floats),
797  // - or first bit equals to 1 (1 for ints, smallest denormal for floats).
798  // For all these cases, taking the sum is just fine, and this boils down to a no-op for scalars.
799  typedef typename unpacket_traits<Packet>::type Scalar;
800  return numext::not_equal_strict(predux(a), Scalar(0));
801 }
802 
803 /***************************************************************************
804 * The following functions might not have to be overwritten for vectorized types
805 ***************************************************************************/
806 
808 // NOTE: this function must really be templated on the packet type (think about different packet types for the same scalar type)
809 template<typename Packet>
810 inline void pstore1(typename unpacket_traits<Packet>::type* to, const typename unpacket_traits<Packet>::type& a)
811 {
812  pstore(to, pset1<Packet>(a));
813 }
814 
816 template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
817 pmadd(const Packet& a,
818  const Packet& b,
819  const Packet& c)
820 { return padd(pmul(a, b),c); }
821 
824 template<typename Packet, int Alignment>
825 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet ploadt(const typename unpacket_traits<Packet>::type* from)
826 {
827  if(Alignment >= unpacket_traits<Packet>::alignment)
828  return pload<Packet>(from);
829  else
830  return ploadu<Packet>(from);
831 }
832 
835 template<typename Scalar, typename Packet, int Alignment>
836 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void pstoret(Scalar* to, const Packet& from)
837 {
838  if(Alignment >= unpacket_traits<Packet>::alignment)
839  pstore(to, from);
840  else
841  pstoreu(to, from);
842 }
843 
849 template<typename Packet, int LoadMode>
850 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet ploadt_ro(const typename unpacket_traits<Packet>::type* from)
851 {
852  return ploadt<Packet, LoadMode>(from);
853 }
854 
855 /***************************************************************************
856 * Fast complex products (GCC generates a function call which is very slow)
857 ***************************************************************************/
858 
859 // Eigen+CUDA does not support complexes.
860 #if !defined(EIGEN_GPUCC)
861 
862 template<> inline std::complex<float> pmul(const std::complex<float>& a, const std::complex<float>& b)
863 { return std::complex<float>(a.real()*b.real() - a.imag()*b.imag(), a.imag()*b.real() + a.real()*b.imag()); }
864 
865 template<> inline std::complex<double> pmul(const std::complex<double>& a, const std::complex<double>& b)
866 { return std::complex<double>(a.real()*b.real() - a.imag()*b.imag(), a.imag()*b.real() + a.real()*b.imag()); }
867 
868 #endif
869 
870 
871 /***************************************************************************
872  * PacketBlock, that is a collection of N packets where the number of words
873  * in the packet is a multiple of N.
874 ***************************************************************************/
875 template <typename Packet,int N=unpacket_traits<Packet>::size> struct PacketBlock {
876  Packet packet[N];
877 };
878 
879 template<typename Packet> EIGEN_DEVICE_FUNC inline void
880 ptranspose(PacketBlock<Packet,1>& /*kernel*/) {
881  // Nothing to do in the scalar case, i.e. a 1x1 matrix.
882 }
883 
884 /***************************************************************************
885  * Selector, i.e. vector of N boolean values used to select (i.e. blend)
886  * words from 2 packets.
887 ***************************************************************************/
888 template <size_t N> struct Selector {
889  bool select[N];
890 };
891 
892 template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
893 pblend(const Selector<unpacket_traits<Packet>::size>& ifPacket, const Packet& thenPacket, const Packet& elsePacket) {
894  return ifPacket.select[0] ? thenPacket : elsePacket;
895 }
896 
897 /***************************************************************************
898  * Some generic implementations to be used by implementors
899 ***************************************************************************/
900 
904 template<typename Packet> EIGEN_STRONG_INLINE Packet
905 pfrexp_float(const Packet& a, Packet& exponent);
906 
910 template<typename Packet> EIGEN_STRONG_INLINE Packet
911 pldexp_float(Packet a, Packet exponent);
912 
916 template<typename Packet> EIGEN_STRONG_INLINE Packet
917 pldexp_double(Packet a, Packet exponent);
918 
919 } // end namespace internal
920 
921 } // end namespace Eigen
922 
923 #endif // EIGEN_GENERIC_PACKET_MATH_H
Eigen::internal::eigen_packet_wrapper
Definition: GenericPacketMath.h:144
Eigen
Namespace containing all symbols from the Eigen library.
Definition: LDLT.h:16
Eigen::internal::PacketBlock
Definition: GenericPacketMath.h:875
Eigen::internal::pminmax_impl
Definition: GenericPacketMath.h:331
Eigen::internal::Selector
Definition: GenericPacketMath.h:888
Eigen::internal::packet_traits
Definition: GenericPacketMath.h:107
Eigen::internal::default_packet_traits
Definition: GenericPacketMath.h:43
Eigen::PropagateNaN
@ PropagateNaN
Definition: Constants.h:342
Eigen::internal::unpacket_traits
Definition: XprHelper.h:184
Eigen::internal::Packet
Definition: ZVector/PacketMath.h:53
Eigen::internal::type_casting_traits
Definition: GenericPacketMath.h:132
Eigen::PropagateNumbers
@ PropagateNumbers
Definition: Constants.h:344
Eigen::Index
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:42
Generated by   doxygen 1.8.19