• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // This file is part of Eigen, a lightweight C++ template library
2 // for linear algebra.
3 //
4 // Copyright (C) 2006-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
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 
10 #ifndef EIGEN_MATHFUNCTIONS_H
11 #define EIGEN_MATHFUNCTIONS_H
12 
13 // source: http://www.geom.uiuc.edu/~huberty/math5337/groupe/digits.html
14 // TODO this should better be moved to NumTraits
15 #define EIGEN_PI 3.141592653589793238462643383279502884197169399375105820974944592307816406L
16 
17 
18 namespace Eigen {
19 
20 // On WINCE, std::abs is defined for int only, so let's defined our own overloads:
21 // This issue has been confirmed with MSVC 2008 only, but the issue might exist for more recent versions too.
22 #if EIGEN_OS_WINCE && EIGEN_COMP_MSVC && EIGEN_COMP_MSVC<=1500
abs(long x)23 long        abs(long        x) { return (labs(x));  }
abs(double x)24 double      abs(double      x) { return (fabs(x));  }
abs(float x)25 float       abs(float       x) { return (fabsf(x)); }
abs(long double x)26 long double abs(long double x) { return (fabsl(x)); }
27 #endif
28 
29 namespace internal {
30 
31 /** \internal \class global_math_functions_filtering_base
32   *
33   * What it does:
34   * Defines a typedef 'type' as follows:
35   * - if type T has a member typedef Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl, then
36   *   global_math_functions_filtering_base<T>::type is a typedef for it.
37   * - otherwise, global_math_functions_filtering_base<T>::type is a typedef for T.
38   *
39   * How it's used:
40   * To allow to defined the global math functions (like sin...) in certain cases, like the Array expressions.
41   * When you do sin(array1+array2), the object array1+array2 has a complicated expression type, all what you want to know
42   * is that it inherits ArrayBase. So we implement a partial specialization of sin_impl for ArrayBase<Derived>.
43   * So we must make sure to use sin_impl<ArrayBase<Derived> > and not sin_impl<Derived>, otherwise our partial specialization
44   * won't be used. How does sin know that? That's exactly what global_math_functions_filtering_base tells it.
45   *
46   * How it's implemented:
47   * SFINAE in the style of enable_if. Highly susceptible of breaking compilers. With GCC, it sure does work, but if you replace
48   * the typename dummy by an integer template parameter, it doesn't work anymore!
49   */
50 
51 template<typename T, typename dummy = void>
52 struct global_math_functions_filtering_base
53 {
54   typedef T type;
55 };
56 
57 template<typename T> struct always_void { typedef void type; };
58 
59 template<typename T>
60 struct global_math_functions_filtering_base
61   <T,
62    typename always_void<typename T::Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl>::type
63   >
64 {
65   typedef typename T::Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl type;
66 };
67 
68 #define EIGEN_MATHFUNC_IMPL(func, scalar) Eigen::internal::func##_impl<typename Eigen::internal::global_math_functions_filtering_base<scalar>::type>
69 #define EIGEN_MATHFUNC_RETVAL(func, scalar) typename Eigen::internal::func##_retval<typename Eigen::internal::global_math_functions_filtering_base<scalar>::type>::type
70 
71 /****************************************************************************
72 * Implementation of real                                                 *
73 ****************************************************************************/
74 
75 template<typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
76 struct real_default_impl
77 {
78   typedef typename NumTraits<Scalar>::Real RealScalar;
79   EIGEN_DEVICE_FUNC
80   static inline RealScalar run(const Scalar& x)
81   {
82     return x;
83   }
84 };
85 
86 template<typename Scalar>
87 struct real_default_impl<Scalar,true>
88 {
89   typedef typename NumTraits<Scalar>::Real RealScalar;
90   EIGEN_DEVICE_FUNC
91   static inline RealScalar run(const Scalar& x)
92   {
93     using std::real;
94     return real(x);
95   }
96 };
97 
98 template<typename Scalar> struct real_impl : real_default_impl<Scalar> {};
99 
100 #ifdef __CUDA_ARCH__
101 template<typename T>
102 struct real_impl<std::complex<T> >
103 {
104   typedef T RealScalar;
105   EIGEN_DEVICE_FUNC
106   static inline T run(const std::complex<T>& x)
107   {
108     return x.real();
109   }
110 };
111 #endif
112 
113 template<typename Scalar>
114 struct real_retval
115 {
116   typedef typename NumTraits<Scalar>::Real type;
117 };
118 
119 /****************************************************************************
120 * Implementation of imag                                                 *
121 ****************************************************************************/
122 
123 template<typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
124 struct imag_default_impl
125 {
126   typedef typename NumTraits<Scalar>::Real RealScalar;
127   EIGEN_DEVICE_FUNC
128   static inline RealScalar run(const Scalar&)
129   {
130     return RealScalar(0);
131   }
132 };
133 
134 template<typename Scalar>
135 struct imag_default_impl<Scalar,true>
136 {
137   typedef typename NumTraits<Scalar>::Real RealScalar;
138   EIGEN_DEVICE_FUNC
139   static inline RealScalar run(const Scalar& x)
140   {
141     using std::imag;
142     return imag(x);
143   }
144 };
145 
146 template<typename Scalar> struct imag_impl : imag_default_impl<Scalar> {};
147 
148 #ifdef __CUDA_ARCH__
149 template<typename T>
150 struct imag_impl<std::complex<T> >
151 {
152   typedef T RealScalar;
153   EIGEN_DEVICE_FUNC
154   static inline T run(const std::complex<T>& x)
155   {
156     return x.imag();
157   }
158 };
159 #endif
160 
161 template<typename Scalar>
162 struct imag_retval
163 {
164   typedef typename NumTraits<Scalar>::Real type;
165 };
166 
167 /****************************************************************************
168 * Implementation of real_ref                                             *
169 ****************************************************************************/
170 
171 template<typename Scalar>
172 struct real_ref_impl
173 {
174   typedef typename NumTraits<Scalar>::Real RealScalar;
175   EIGEN_DEVICE_FUNC
176   static inline RealScalar& run(Scalar& x)
177   {
178     return reinterpret_cast<RealScalar*>(&x)[0];
179   }
180   EIGEN_DEVICE_FUNC
181   static inline const RealScalar& run(const Scalar& x)
182   {
183     return reinterpret_cast<const RealScalar*>(&x)[0];
184   }
185 };
186 
187 template<typename Scalar>
188 struct real_ref_retval
189 {
190   typedef typename NumTraits<Scalar>::Real & type;
191 };
192 
193 /****************************************************************************
194 * Implementation of imag_ref                                             *
195 ****************************************************************************/
196 
197 template<typename Scalar, bool IsComplex>
198 struct imag_ref_default_impl
199 {
200   typedef typename NumTraits<Scalar>::Real RealScalar;
201   EIGEN_DEVICE_FUNC
202   static inline RealScalar& run(Scalar& x)
203   {
204     return reinterpret_cast<RealScalar*>(&x)[1];
205   }
206   EIGEN_DEVICE_FUNC
207   static inline const RealScalar& run(const Scalar& x)
208   {
209     return reinterpret_cast<RealScalar*>(&x)[1];
210   }
211 };
212 
213 template<typename Scalar>
214 struct imag_ref_default_impl<Scalar, false>
215 {
216   EIGEN_DEVICE_FUNC
217   static inline Scalar run(Scalar&)
218   {
219     return Scalar(0);
220   }
221   EIGEN_DEVICE_FUNC
222   static inline const Scalar run(const Scalar&)
223   {
224     return Scalar(0);
225   }
226 };
227 
228 template<typename Scalar>
229 struct imag_ref_impl : imag_ref_default_impl<Scalar, NumTraits<Scalar>::IsComplex> {};
230 
231 template<typename Scalar>
232 struct imag_ref_retval
233 {
234   typedef typename NumTraits<Scalar>::Real & type;
235 };
236 
237 /****************************************************************************
238 * Implementation of conj                                                 *
239 ****************************************************************************/
240 
241 template<typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
242 struct conj_impl
243 {
244   EIGEN_DEVICE_FUNC
245   static inline Scalar run(const Scalar& x)
246   {
247     return x;
248   }
249 };
250 
251 template<typename Scalar>
252 struct conj_impl<Scalar,true>
253 {
254   EIGEN_DEVICE_FUNC
255   static inline Scalar run(const Scalar& x)
256   {
257     using std::conj;
258     return conj(x);
259   }
260 };
261 
262 template<typename Scalar>
263 struct conj_retval
264 {
265   typedef Scalar type;
266 };
267 
268 /****************************************************************************
269 * Implementation of abs2                                                 *
270 ****************************************************************************/
271 
272 template<typename Scalar,bool IsComplex>
273 struct abs2_impl_default
274 {
275   typedef typename NumTraits<Scalar>::Real RealScalar;
276   EIGEN_DEVICE_FUNC
277   static inline RealScalar run(const Scalar& x)
278   {
279     return x*x;
280   }
281 };
282 
283 template<typename Scalar>
284 struct abs2_impl_default<Scalar, true> // IsComplex
285 {
286   typedef typename NumTraits<Scalar>::Real RealScalar;
287   EIGEN_DEVICE_FUNC
288   static inline RealScalar run(const Scalar& x)
289   {
290     return real(x)*real(x) + imag(x)*imag(x);
291   }
292 };
293 
294 template<typename Scalar>
295 struct abs2_impl
296 {
297   typedef typename NumTraits<Scalar>::Real RealScalar;
298   EIGEN_DEVICE_FUNC
299   static inline RealScalar run(const Scalar& x)
300   {
301     return abs2_impl_default<Scalar,NumTraits<Scalar>::IsComplex>::run(x);
302   }
303 };
304 
305 template<typename Scalar>
306 struct abs2_retval
307 {
308   typedef typename NumTraits<Scalar>::Real type;
309 };
310 
311 /****************************************************************************
312 * Implementation of norm1                                                *
313 ****************************************************************************/
314 
315 template<typename Scalar, bool IsComplex>
316 struct norm1_default_impl
317 {
318   typedef typename NumTraits<Scalar>::Real RealScalar;
319   EIGEN_DEVICE_FUNC
320   static inline RealScalar run(const Scalar& x)
321   {
322     EIGEN_USING_STD_MATH(abs);
323     return abs(real(x)) + abs(imag(x));
324   }
325 };
326 
327 template<typename Scalar>
328 struct norm1_default_impl<Scalar, false>
329 {
330   EIGEN_DEVICE_FUNC
331   static inline Scalar run(const Scalar& x)
332   {
333     EIGEN_USING_STD_MATH(abs);
334     return abs(x);
335   }
336 };
337 
338 template<typename Scalar>
339 struct norm1_impl : norm1_default_impl<Scalar, NumTraits<Scalar>::IsComplex> {};
340 
341 template<typename Scalar>
342 struct norm1_retval
343 {
344   typedef typename NumTraits<Scalar>::Real type;
345 };
346 
347 /****************************************************************************
348 * Implementation of hypot                                                *
349 ****************************************************************************/
350 
351 template<typename Scalar>
352 struct hypot_impl
353 {
354   typedef typename NumTraits<Scalar>::Real RealScalar;
355   static inline RealScalar run(const Scalar& x, const Scalar& y)
356   {
357     EIGEN_USING_STD_MATH(abs);
358     EIGEN_USING_STD_MATH(sqrt);
359     RealScalar _x = abs(x);
360     RealScalar _y = abs(y);
361     Scalar p, qp;
362     if(_x>_y)
363     {
364       p = _x;
365       qp = _y / p;
366     }
367     else
368     {
369       p = _y;
370       qp = _x / p;
371     }
372     if(p==RealScalar(0)) return RealScalar(0);
373     return p * sqrt(RealScalar(1) + qp*qp);
374   }
375 };
376 
377 template<typename Scalar>
378 struct hypot_retval
379 {
380   typedef typename NumTraits<Scalar>::Real type;
381 };
382 
383 /****************************************************************************
384 * Implementation of cast                                                 *
385 ****************************************************************************/
386 
387 template<typename OldType, typename NewType>
388 struct cast_impl
389 {
390   EIGEN_DEVICE_FUNC
391   static inline NewType run(const OldType& x)
392   {
393     return static_cast<NewType>(x);
394   }
395 };
396 
397 // here, for once, we're plainly returning NewType: we don't want cast to do weird things.
398 
399 template<typename OldType, typename NewType>
400 EIGEN_DEVICE_FUNC
401 inline NewType cast(const OldType& x)
402 {
403   return cast_impl<OldType, NewType>::run(x);
404 }
405 
406 /****************************************************************************
407 * Implementation of round                                                   *
408 ****************************************************************************/
409 
410 #if EIGEN_HAS_CXX11_MATH
411   template<typename Scalar>
412   struct round_impl {
413     static inline Scalar run(const Scalar& x)
414     {
415       EIGEN_STATIC_ASSERT((!NumTraits<Scalar>::IsComplex), NUMERIC_TYPE_MUST_BE_REAL)
416       using std::round;
417       return round(x);
418     }
419   };
420 #else
421   template<typename Scalar>
422   struct round_impl
423   {
424     static inline Scalar run(const Scalar& x)
425     {
426       EIGEN_STATIC_ASSERT((!NumTraits<Scalar>::IsComplex), NUMERIC_TYPE_MUST_BE_REAL)
427       EIGEN_USING_STD_MATH(floor);
428       EIGEN_USING_STD_MATH(ceil);
429       return (x > Scalar(0)) ? floor(x + Scalar(0.5)) : ceil(x - Scalar(0.5));
430     }
431   };
432 #endif
433 
434 template<typename Scalar>
435 struct round_retval
436 {
437   typedef Scalar type;
438 };
439 
440 /****************************************************************************
441 * Implementation of arg                                                     *
442 ****************************************************************************/
443 
444 #if EIGEN_HAS_CXX11_MATH
445   template<typename Scalar>
446   struct arg_impl {
447     static inline Scalar run(const Scalar& x)
448     {
449       EIGEN_USING_STD_MATH(arg);
450       return arg(x);
451     }
452   };
453 #else
454   template<typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
455   struct arg_default_impl
456   {
457     typedef typename NumTraits<Scalar>::Real RealScalar;
458     EIGEN_DEVICE_FUNC
459     static inline RealScalar run(const Scalar& x)
460     {
461       return (x < Scalar(0)) ? Scalar(EIGEN_PI) : Scalar(0); }
462   };
463 
464   template<typename Scalar>
465   struct arg_default_impl<Scalar,true>
466   {
467     typedef typename NumTraits<Scalar>::Real RealScalar;
468     EIGEN_DEVICE_FUNC
469     static inline RealScalar run(const Scalar& x)
470     {
471       EIGEN_USING_STD_MATH(arg);
472       return arg(x);
473     }
474   };
475 
476   template<typename Scalar> struct arg_impl : arg_default_impl<Scalar> {};
477 #endif
478 
479 template<typename Scalar>
480 struct arg_retval
481 {
482   typedef typename NumTraits<Scalar>::Real type;
483 };
484 
485 /****************************************************************************
486 * Implementation of log1p                                                   *
487 ****************************************************************************/
488 
489 namespace std_fallback {
490   // fallback log1p implementation in case there is no log1p(Scalar) function in namespace of Scalar,
491   // or that there is no suitable std::log1p function available
492   template<typename Scalar>
493   EIGEN_DEVICE_FUNC inline Scalar log1p(const Scalar& x) {
494     EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar)
495     typedef typename NumTraits<Scalar>::Real RealScalar;
496     EIGEN_USING_STD_MATH(log);
497     Scalar x1p = RealScalar(1) + x;
498     return ( x1p == Scalar(1) ) ? x : x * ( log(x1p) / (x1p - RealScalar(1)) );
499   }
500 }
501 
502 template<typename Scalar>
503 struct log1p_impl {
504   static inline Scalar run(const Scalar& x)
505   {
506     EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar)
507     #if EIGEN_HAS_CXX11_MATH
508     using std::log1p;
509     #endif
510     using std_fallback::log1p;
511     return log1p(x);
512   }
513 };
514 
515 
516 template<typename Scalar>
517 struct log1p_retval
518 {
519   typedef Scalar type;
520 };
521 
522 /****************************************************************************
523 * Implementation of pow                                                  *
524 ****************************************************************************/
525 
526 template<typename ScalarX,typename ScalarY, bool IsInteger = NumTraits<ScalarX>::IsInteger&&NumTraits<ScalarY>::IsInteger>
527 struct pow_impl
528 {
529   //typedef Scalar retval;
530   typedef typename ScalarBinaryOpTraits<ScalarX,ScalarY,internal::scalar_pow_op<ScalarX,ScalarY> >::ReturnType result_type;
531   static EIGEN_DEVICE_FUNC inline result_type run(const ScalarX& x, const ScalarY& y)
532   {
533     EIGEN_USING_STD_MATH(pow);
534     return pow(x, y);
535   }
536 };
537 
538 template<typename ScalarX,typename ScalarY>
539 struct pow_impl<ScalarX,ScalarY, true>
540 {
541   typedef ScalarX result_type;
542   static EIGEN_DEVICE_FUNC inline ScalarX run(ScalarX x, ScalarY y)
543   {
544     ScalarX res(1);
545     eigen_assert(!NumTraits<ScalarY>::IsSigned || y >= 0);
546     if(y & 1) res *= x;
547     y >>= 1;
548     while(y)
549     {
550       x *= x;
551       if(y&1) res *= x;
552       y >>= 1;
553     }
554     return res;
555   }
556 };
557 
558 /****************************************************************************
559 * Implementation of random                                               *
560 ****************************************************************************/
561 
562 template<typename Scalar,
563          bool IsComplex,
564          bool IsInteger>
565 struct random_default_impl {};
566 
567 template<typename Scalar>
568 struct random_impl : random_default_impl<Scalar, NumTraits<Scalar>::IsComplex, NumTraits<Scalar>::IsInteger> {};
569 
570 template<typename Scalar>
571 struct random_retval
572 {
573   typedef Scalar type;
574 };
575 
576 template<typename Scalar> inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random(const Scalar& x, const Scalar& y);
577 template<typename Scalar> inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random();
578 
579 template<typename Scalar>
580 struct random_default_impl<Scalar, false, false>
581 {
582   static inline Scalar run(const Scalar& x, const Scalar& y)
583   {
584     return x + (y-x) * Scalar(std::rand()) / Scalar(RAND_MAX);
585   }
586   static inline Scalar run()
587   {
588     return run(Scalar(NumTraits<Scalar>::IsSigned ? -1 : 0), Scalar(1));
589   }
590 };
591 
592 enum {
593   meta_floor_log2_terminate,
594   meta_floor_log2_move_up,
595   meta_floor_log2_move_down,
596   meta_floor_log2_bogus
597 };
598 
599 template<unsigned int n, int lower, int upper> struct meta_floor_log2_selector
600 {
601   enum { middle = (lower + upper) / 2,
602          value = (upper <= lower + 1) ? int(meta_floor_log2_terminate)
603                : (n < (1 << middle)) ? int(meta_floor_log2_move_down)
604                : (n==0) ? int(meta_floor_log2_bogus)
605                : int(meta_floor_log2_move_up)
606   };
607 };
608 
609 template<unsigned int n,
610          int lower = 0,
611          int upper = sizeof(unsigned int) * CHAR_BIT - 1,
612          int selector = meta_floor_log2_selector<n, lower, upper>::value>
613 struct meta_floor_log2 {};
614 
615 template<unsigned int n, int lower, int upper>
616 struct meta_floor_log2<n, lower, upper, meta_floor_log2_move_down>
617 {
618   enum { value = meta_floor_log2<n, lower, meta_floor_log2_selector<n, lower, upper>::middle>::value };
619 };
620 
621 template<unsigned int n, int lower, int upper>
622 struct meta_floor_log2<n, lower, upper, meta_floor_log2_move_up>
623 {
624   enum { value = meta_floor_log2<n, meta_floor_log2_selector<n, lower, upper>::middle, upper>::value };
625 };
626 
627 template<unsigned int n, int lower, int upper>
628 struct meta_floor_log2<n, lower, upper, meta_floor_log2_terminate>
629 {
630   enum { value = (n >= ((unsigned int)(1) << (lower+1))) ? lower+1 : lower };
631 };
632 
633 template<unsigned int n, int lower, int upper>
634 struct meta_floor_log2<n, lower, upper, meta_floor_log2_bogus>
635 {
636   // no value, error at compile time
637 };
638 
639 template<typename Scalar>
640 struct random_default_impl<Scalar, false, true>
641 {
642   static inline Scalar run(const Scalar& x, const Scalar& y)
643   {
644     typedef typename conditional<NumTraits<Scalar>::IsSigned,std::ptrdiff_t,std::size_t>::type ScalarX;
645     if(y<x)
646       return x;
647     // the following difference might overflow on a 32 bits system,
648     // but since y>=x the result converted to an unsigned long is still correct.
649     std::size_t range = ScalarX(y)-ScalarX(x);
650     std::size_t offset = 0;
651     // rejection sampling
652     std::size_t divisor = 1;
653     std::size_t multiplier = 1;
654     if(range<RAND_MAX) divisor = (std::size_t(RAND_MAX)+1)/(range+1);
655     else               multiplier = 1 + range/(std::size_t(RAND_MAX)+1);
656     do {
657       offset = (std::size_t(std::rand()) * multiplier) / divisor;
658     } while (offset > range);
659     return Scalar(ScalarX(x) + offset);
660   }
661 
662   static inline Scalar run()
663   {
664 #ifdef EIGEN_MAKING_DOCS
665     return run(Scalar(NumTraits<Scalar>::IsSigned ? -10 : 0), Scalar(10));
666 #else
667     enum { rand_bits = meta_floor_log2<(unsigned int)(RAND_MAX)+1>::value,
668            scalar_bits = sizeof(Scalar) * CHAR_BIT,
669            shift = EIGEN_PLAIN_ENUM_MAX(0, int(rand_bits) - int(scalar_bits)),
670            offset = NumTraits<Scalar>::IsSigned ? (1 << (EIGEN_PLAIN_ENUM_MIN(rand_bits,scalar_bits)-1)) : 0
671     };
672     return Scalar((std::rand() >> shift) - offset);
673 #endif
674   }
675 };
676 
677 template<typename Scalar>
678 struct random_default_impl<Scalar, true, false>
679 {
680   static inline Scalar run(const Scalar& x, const Scalar& y)
681   {
682     return Scalar(random(real(x), real(y)),
683                   random(imag(x), imag(y)));
684   }
685   static inline Scalar run()
686   {
687     typedef typename NumTraits<Scalar>::Real RealScalar;
688     return Scalar(random<RealScalar>(), random<RealScalar>());
689   }
690 };
691 
692 template<typename Scalar>
693 inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random(const Scalar& x, const Scalar& y)
694 {
695   return EIGEN_MATHFUNC_IMPL(random, Scalar)::run(x, y);
696 }
697 
698 template<typename Scalar>
699 inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random()
700 {
701   return EIGEN_MATHFUNC_IMPL(random, Scalar)::run();
702 }
703 
704 // Implementatin of is* functions
705 
706 // std::is* do not work with fast-math and gcc, std::is* are available on MSVC 2013 and newer, as well as in clang.
707 #if (EIGEN_HAS_CXX11_MATH && !(EIGEN_COMP_GNUC_STRICT && __FINITE_MATH_ONLY__)) || (EIGEN_COMP_MSVC>=1800) || (EIGEN_COMP_CLANG)
708 #define EIGEN_USE_STD_FPCLASSIFY 1
709 #else
710 #define EIGEN_USE_STD_FPCLASSIFY 0
711 #endif
712 
713 template<typename T>
714 EIGEN_DEVICE_FUNC
715 typename internal::enable_if<internal::is_integral<T>::value,bool>::type
716 isnan_impl(const T&) { return false; }
717 
718 template<typename T>
719 EIGEN_DEVICE_FUNC
720 typename internal::enable_if<internal::is_integral<T>::value,bool>::type
721 isinf_impl(const T&) { return false; }
722 
723 template<typename T>
724 EIGEN_DEVICE_FUNC
725 typename internal::enable_if<internal::is_integral<T>::value,bool>::type
726 isfinite_impl(const T&) { return true; }
727 
728 template<typename T>
729 EIGEN_DEVICE_FUNC
730 typename internal::enable_if<(!internal::is_integral<T>::value)&&(!NumTraits<T>::IsComplex),bool>::type
731 isfinite_impl(const T& x)
732 {
733   #ifdef __CUDA_ARCH__
734     return (::isfinite)(x);
735   #elif EIGEN_USE_STD_FPCLASSIFY
736     using std::isfinite;
737     return isfinite EIGEN_NOT_A_MACRO (x);
738   #else
739     return x<=NumTraits<T>::highest() && x>=NumTraits<T>::lowest();
740   #endif
741 }
742 
743 template<typename T>
744 EIGEN_DEVICE_FUNC
745 typename internal::enable_if<(!internal::is_integral<T>::value)&&(!NumTraits<T>::IsComplex),bool>::type
746 isinf_impl(const T& x)
747 {
748   #ifdef __CUDA_ARCH__
749     return (::isinf)(x);
750   #elif EIGEN_USE_STD_FPCLASSIFY
751     using std::isinf;
752     return isinf EIGEN_NOT_A_MACRO (x);
753   #else
754     return x>NumTraits<T>::highest() || x<NumTraits<T>::lowest();
755   #endif
756 }
757 
758 template<typename T>
759 EIGEN_DEVICE_FUNC
760 typename internal::enable_if<(!internal::is_integral<T>::value)&&(!NumTraits<T>::IsComplex),bool>::type
761 isnan_impl(const T& x)
762 {
763   #ifdef __CUDA_ARCH__
764     return (::isnan)(x);
765   #elif EIGEN_USE_STD_FPCLASSIFY
766     using std::isnan;
767     return isnan EIGEN_NOT_A_MACRO (x);
768   #else
769     return x != x;
770   #endif
771 }
772 
773 #if (!EIGEN_USE_STD_FPCLASSIFY)
774 
775 #if EIGEN_COMP_MSVC
776 
777 template<typename T> EIGEN_DEVICE_FUNC bool isinf_msvc_helper(T x)
778 {
779   return _fpclass(x)==_FPCLASS_NINF || _fpclass(x)==_FPCLASS_PINF;
780 }
781 
782 //MSVC defines a _isnan builtin function, but for double only
783 EIGEN_DEVICE_FUNC inline bool isnan_impl(const long double& x) { return _isnan(x)!=0; }
784 EIGEN_DEVICE_FUNC inline bool isnan_impl(const double& x)      { return _isnan(x)!=0; }
785 EIGEN_DEVICE_FUNC inline bool isnan_impl(const float& x)       { return _isnan(x)!=0; }
786 
787 EIGEN_DEVICE_FUNC inline bool isinf_impl(const long double& x) { return isinf_msvc_helper(x); }
788 EIGEN_DEVICE_FUNC inline bool isinf_impl(const double& x)      { return isinf_msvc_helper(x); }
789 EIGEN_DEVICE_FUNC inline bool isinf_impl(const float& x)       { return isinf_msvc_helper(x); }
790 
791 #elif (defined __FINITE_MATH_ONLY__ && __FINITE_MATH_ONLY__ && EIGEN_COMP_GNUC)
792 
793 #if EIGEN_GNUC_AT_LEAST(5,0)
794   #define EIGEN_TMP_NOOPT_ATTRIB EIGEN_DEVICE_FUNC inline __attribute__((optimize("no-finite-math-only")))
795 #else
796   // NOTE the inline qualifier and noinline attribute are both needed: the former is to avoid linking issue (duplicate symbol),
797   //      while the second prevent too aggressive optimizations in fast-math mode:
798   #define EIGEN_TMP_NOOPT_ATTRIB EIGEN_DEVICE_FUNC inline __attribute__((noinline,optimize("no-finite-math-only")))
799 #endif
800 
801 template<> EIGEN_TMP_NOOPT_ATTRIB bool isnan_impl(const long double& x) { return __builtin_isnan(x); }
802 template<> EIGEN_TMP_NOOPT_ATTRIB bool isnan_impl(const double& x)      { return __builtin_isnan(x); }
803 template<> EIGEN_TMP_NOOPT_ATTRIB bool isnan_impl(const float& x)       { return __builtin_isnan(x); }
804 template<> EIGEN_TMP_NOOPT_ATTRIB bool isinf_impl(const double& x)      { return __builtin_isinf(x); }
805 template<> EIGEN_TMP_NOOPT_ATTRIB bool isinf_impl(const float& x)       { return __builtin_isinf(x); }
806 template<> EIGEN_TMP_NOOPT_ATTRIB bool isinf_impl(const long double& x) { return __builtin_isinf(x); }
807 
808 #undef EIGEN_TMP_NOOPT_ATTRIB
809 
810 #endif
811 
812 #endif
813 
814 // The following overload are defined at the end of this file
815 template<typename T> EIGEN_DEVICE_FUNC bool isfinite_impl(const std::complex<T>& x);
816 template<typename T> EIGEN_DEVICE_FUNC bool isnan_impl(const std::complex<T>& x);
817 template<typename T> EIGEN_DEVICE_FUNC bool isinf_impl(const std::complex<T>& x);
818 
819 template<typename T> T generic_fast_tanh_float(const T& a_x);
820 
821 } // end namespace internal
822 
823 /****************************************************************************
824 * Generic math functions                                                    *
825 ****************************************************************************/
826 
827 namespace numext {
828 
829 #ifndef __CUDA_ARCH__
830 template<typename T>
831 EIGEN_DEVICE_FUNC
832 EIGEN_ALWAYS_INLINE T mini(const T& x, const T& y)
833 {
834   EIGEN_USING_STD_MATH(min);
835   return min EIGEN_NOT_A_MACRO (x,y);
836 }
837 
838 template<typename T>
839 EIGEN_DEVICE_FUNC
840 EIGEN_ALWAYS_INLINE T maxi(const T& x, const T& y)
841 {
842   EIGEN_USING_STD_MATH(max);
843   return max EIGEN_NOT_A_MACRO (x,y);
844 }
845 #else
846 template<typename T>
847 EIGEN_DEVICE_FUNC
848 EIGEN_ALWAYS_INLINE T mini(const T& x, const T& y)
849 {
850   return y < x ? y : x;
851 }
852 template<>
853 EIGEN_DEVICE_FUNC
854 EIGEN_ALWAYS_INLINE float mini(const float& x, const float& y)
855 {
856   return fminf(x, y);
857 }
858 template<typename T>
859 EIGEN_DEVICE_FUNC
860 EIGEN_ALWAYS_INLINE T maxi(const T& x, const T& y)
861 {
862   return x < y ? y : x;
863 }
864 template<>
865 EIGEN_DEVICE_FUNC
866 EIGEN_ALWAYS_INLINE float maxi(const float& x, const float& y)
867 {
868   return fmaxf(x, y);
869 }
870 #endif
871 
872 
873 template<typename Scalar>
874 EIGEN_DEVICE_FUNC
875 inline EIGEN_MATHFUNC_RETVAL(real, Scalar) real(const Scalar& x)
876 {
877   return EIGEN_MATHFUNC_IMPL(real, Scalar)::run(x);
878 }
879 
880 template<typename Scalar>
881 EIGEN_DEVICE_FUNC
882 inline typename internal::add_const_on_value_type< EIGEN_MATHFUNC_RETVAL(real_ref, Scalar) >::type real_ref(const Scalar& x)
883 {
884   return internal::real_ref_impl<Scalar>::run(x);
885 }
886 
887 template<typename Scalar>
888 EIGEN_DEVICE_FUNC
889 inline EIGEN_MATHFUNC_RETVAL(real_ref, Scalar) real_ref(Scalar& x)
890 {
891   return EIGEN_MATHFUNC_IMPL(real_ref, Scalar)::run(x);
892 }
893 
894 template<typename Scalar>
895 EIGEN_DEVICE_FUNC
896 inline EIGEN_MATHFUNC_RETVAL(imag, Scalar) imag(const Scalar& x)
897 {
898   return EIGEN_MATHFUNC_IMPL(imag, Scalar)::run(x);
899 }
900 
901 template<typename Scalar>
902 EIGEN_DEVICE_FUNC
903 inline EIGEN_MATHFUNC_RETVAL(arg, Scalar) arg(const Scalar& x)
904 {
905   return EIGEN_MATHFUNC_IMPL(arg, Scalar)::run(x);
906 }
907 
908 template<typename Scalar>
909 EIGEN_DEVICE_FUNC
910 inline typename internal::add_const_on_value_type< EIGEN_MATHFUNC_RETVAL(imag_ref, Scalar) >::type imag_ref(const Scalar& x)
911 {
912   return internal::imag_ref_impl<Scalar>::run(x);
913 }
914 
915 template<typename Scalar>
916 EIGEN_DEVICE_FUNC
917 inline EIGEN_MATHFUNC_RETVAL(imag_ref, Scalar) imag_ref(Scalar& x)
918 {
919   return EIGEN_MATHFUNC_IMPL(imag_ref, Scalar)::run(x);
920 }
921 
922 template<typename Scalar>
923 EIGEN_DEVICE_FUNC
924 inline EIGEN_MATHFUNC_RETVAL(conj, Scalar) conj(const Scalar& x)
925 {
926   return EIGEN_MATHFUNC_IMPL(conj, Scalar)::run(x);
927 }
928 
929 template<typename Scalar>
930 EIGEN_DEVICE_FUNC
931 inline EIGEN_MATHFUNC_RETVAL(abs2, Scalar) abs2(const Scalar& x)
932 {
933   return EIGEN_MATHFUNC_IMPL(abs2, Scalar)::run(x);
934 }
935 
936 template<typename Scalar>
937 EIGEN_DEVICE_FUNC
938 inline EIGEN_MATHFUNC_RETVAL(norm1, Scalar) norm1(const Scalar& x)
939 {
940   return EIGEN_MATHFUNC_IMPL(norm1, Scalar)::run(x);
941 }
942 
943 template<typename Scalar>
944 EIGEN_DEVICE_FUNC
945 inline EIGEN_MATHFUNC_RETVAL(hypot, Scalar) hypot(const Scalar& x, const Scalar& y)
946 {
947   return EIGEN_MATHFUNC_IMPL(hypot, Scalar)::run(x, y);
948 }
949 
950 template<typename Scalar>
951 EIGEN_DEVICE_FUNC
952 inline EIGEN_MATHFUNC_RETVAL(log1p, Scalar) log1p(const Scalar& x)
953 {
954   return EIGEN_MATHFUNC_IMPL(log1p, Scalar)::run(x);
955 }
956 
957 #ifdef __CUDACC__
958 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
959 float log1p(const float &x) { return ::log1pf(x); }
960 
961 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
962 double log1p(const double &x) { return ::log1p(x); }
963 #endif
964 
965 template<typename ScalarX,typename ScalarY>
966 EIGEN_DEVICE_FUNC
967 inline typename internal::pow_impl<ScalarX,ScalarY>::result_type pow(const ScalarX& x, const ScalarY& y)
968 {
969   return internal::pow_impl<ScalarX,ScalarY>::run(x, y);
970 }
971 
972 template<typename T> EIGEN_DEVICE_FUNC bool (isnan)   (const T &x) { return internal::isnan_impl(x); }
973 template<typename T> EIGEN_DEVICE_FUNC bool (isinf)   (const T &x) { return internal::isinf_impl(x); }
974 template<typename T> EIGEN_DEVICE_FUNC bool (isfinite)(const T &x) { return internal::isfinite_impl(x); }
975 
976 template<typename Scalar>
977 EIGEN_DEVICE_FUNC
978 inline EIGEN_MATHFUNC_RETVAL(round, Scalar) round(const Scalar& x)
979 {
980   return EIGEN_MATHFUNC_IMPL(round, Scalar)::run(x);
981 }
982 
983 template<typename T>
984 EIGEN_DEVICE_FUNC
985 T (floor)(const T& x)
986 {
987   EIGEN_USING_STD_MATH(floor);
988   return floor(x);
989 }
990 
991 #ifdef __CUDACC__
992 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
993 float floor(const float &x) { return ::floorf(x); }
994 
995 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
996 double floor(const double &x) { return ::floor(x); }
997 #endif
998 
999 template<typename T>
1000 EIGEN_DEVICE_FUNC
1001 T (ceil)(const T& x)
1002 {
1003   EIGEN_USING_STD_MATH(ceil);
1004   return ceil(x);
1005 }
1006 
1007 #ifdef __CUDACC__
1008 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1009 float ceil(const float &x) { return ::ceilf(x); }
1010 
1011 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1012 double ceil(const double &x) { return ::ceil(x); }
1013 #endif
1014 
1015 
1016 /** Log base 2 for 32 bits positive integers.
1017   * Conveniently returns 0 for x==0. */
1018 inline int log2(int x)
1019 {
1020   eigen_assert(x>=0);
1021   unsigned int v(x);
1022   static const int table[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 };
1023   v |= v >> 1;
1024   v |= v >> 2;
1025   v |= v >> 4;
1026   v |= v >> 8;
1027   v |= v >> 16;
1028   return table[(v * 0x07C4ACDDU) >> 27];
1029 }
1030 
1031 /** \returns the square root of \a x.
1032   *
1033   * It is essentially equivalent to \code using std::sqrt; return sqrt(x); \endcode,
1034   * but slightly faster for float/double and some compilers (e.g., gcc), thanks to
1035   * specializations when SSE is enabled.
1036   *
1037   * It's usage is justified in performance critical functions, like norm/normalize.
1038   */
1039 template<typename T>
1040 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1041 T sqrt(const T &x)
1042 {
1043   EIGEN_USING_STD_MATH(sqrt);
1044   return sqrt(x);
1045 }
1046 
1047 template<typename T>
1048 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1049 T log(const T &x) {
1050   EIGEN_USING_STD_MATH(log);
1051   return log(x);
1052 }
1053 
1054 #ifdef __CUDACC__
1055 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1056 float log(const float &x) { return ::logf(x); }
1057 
1058 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1059 double log(const double &x) { return ::log(x); }
1060 #endif
1061 
1062 template<typename T>
1063 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1064 typename internal::enable_if<NumTraits<T>::IsSigned || NumTraits<T>::IsComplex,typename NumTraits<T>::Real>::type
1065 abs(const T &x) {
1066   EIGEN_USING_STD_MATH(abs);
1067   return abs(x);
1068 }
1069 
1070 template<typename T>
1071 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1072 typename internal::enable_if<!(NumTraits<T>::IsSigned || NumTraits<T>::IsComplex),typename NumTraits<T>::Real>::type
1073 abs(const T &x) {
1074   return x;
1075 }
1076 
1077 #if defined(__SYCL_DEVICE_ONLY__)
1078 EIGEN_ALWAYS_INLINE float   abs(float x) { return cl::sycl::fabs(x); }
1079 EIGEN_ALWAYS_INLINE double  abs(double x) { return cl::sycl::fabs(x); }
1080 #endif // defined(__SYCL_DEVICE_ONLY__)
1081 
1082 #ifdef __CUDACC__
1083 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1084 float abs(const float &x) { return ::fabsf(x); }
1085 
1086 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1087 double abs(const double &x) { return ::fabs(x); }
1088 
1089 template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1090 float abs(const std::complex<float>& x) {
1091   return ::hypotf(x.real(), x.imag());
1092 }
1093 
1094 template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1095 double abs(const std::complex<double>& x) {
1096   return ::hypot(x.real(), x.imag());
1097 }
1098 #endif
1099 
1100 template<typename T>
1101 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1102 T exp(const T &x) {
1103   EIGEN_USING_STD_MATH(exp);
1104   return exp(x);
1105 }
1106 
1107 #ifdef __CUDACC__
1108 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1109 float exp(const float &x) { return ::expf(x); }
1110 
1111 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1112 double exp(const double &x) { return ::exp(x); }
1113 #endif
1114 
1115 template<typename T>
1116 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1117 T cos(const T &x) {
1118   EIGEN_USING_STD_MATH(cos);
1119   return cos(x);
1120 }
1121 
1122 #ifdef __CUDACC__
1123 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1124 float cos(const float &x) { return ::cosf(x); }
1125 
1126 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1127 double cos(const double &x) { return ::cos(x); }
1128 #endif
1129 
1130 template<typename T>
1131 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1132 T sin(const T &x) {
1133   EIGEN_USING_STD_MATH(sin);
1134   return sin(x);
1135 }
1136 
1137 #ifdef __CUDACC__
1138 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1139 float sin(const float &x) { return ::sinf(x); }
1140 
1141 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1142 double sin(const double &x) { return ::sin(x); }
1143 #endif
1144 
1145 template<typename T>
1146 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1147 T tan(const T &x) {
1148   EIGEN_USING_STD_MATH(tan);
1149   return tan(x);
1150 }
1151 
1152 #ifdef __CUDACC__
1153 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1154 float tan(const float &x) { return ::tanf(x); }
1155 
1156 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1157 double tan(const double &x) { return ::tan(x); }
1158 #endif
1159 
1160 template<typename T>
1161 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1162 T acos(const T &x) {
1163   EIGEN_USING_STD_MATH(acos);
1164   return acos(x);
1165 }
1166 
1167 #ifdef __CUDACC__
1168 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1169 float acos(const float &x) { return ::acosf(x); }
1170 
1171 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1172 double acos(const double &x) { return ::acos(x); }
1173 #endif
1174 
1175 template<typename T>
1176 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1177 T asin(const T &x) {
1178   EIGEN_USING_STD_MATH(asin);
1179   return asin(x);
1180 }
1181 
1182 #ifdef __CUDACC__
1183 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1184 float asin(const float &x) { return ::asinf(x); }
1185 
1186 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1187 double asin(const double &x) { return ::asin(x); }
1188 #endif
1189 
1190 template<typename T>
1191 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1192 T atan(const T &x) {
1193   EIGEN_USING_STD_MATH(atan);
1194   return atan(x);
1195 }
1196 
1197 #ifdef __CUDACC__
1198 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1199 float atan(const float &x) { return ::atanf(x); }
1200 
1201 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1202 double atan(const double &x) { return ::atan(x); }
1203 #endif
1204 
1205 
1206 template<typename T>
1207 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1208 T cosh(const T &x) {
1209   EIGEN_USING_STD_MATH(cosh);
1210   return cosh(x);
1211 }
1212 
1213 #ifdef __CUDACC__
1214 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1215 float cosh(const float &x) { return ::coshf(x); }
1216 
1217 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1218 double cosh(const double &x) { return ::cosh(x); }
1219 #endif
1220 
1221 template<typename T>
1222 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1223 T sinh(const T &x) {
1224   EIGEN_USING_STD_MATH(sinh);
1225   return sinh(x);
1226 }
1227 
1228 #ifdef __CUDACC__
1229 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1230 float sinh(const float &x) { return ::sinhf(x); }
1231 
1232 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1233 double sinh(const double &x) { return ::sinh(x); }
1234 #endif
1235 
1236 template<typename T>
1237 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1238 T tanh(const T &x) {
1239   EIGEN_USING_STD_MATH(tanh);
1240   return tanh(x);
1241 }
1242 
1243 #if (!defined(__CUDACC__)) && EIGEN_FAST_MATH
1244 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1245 float tanh(float x) { return internal::generic_fast_tanh_float(x); }
1246 #endif
1247 
1248 #ifdef __CUDACC__
1249 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1250 float tanh(const float &x) { return ::tanhf(x); }
1251 
1252 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1253 double tanh(const double &x) { return ::tanh(x); }
1254 #endif
1255 
1256 template <typename T>
1257 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1258 T fmod(const T& a, const T& b) {
1259   EIGEN_USING_STD_MATH(fmod);
1260   return fmod(a, b);
1261 }
1262 
1263 #ifdef __CUDACC__
1264 template <>
1265 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1266 float fmod(const float& a, const float& b) {
1267   return ::fmodf(a, b);
1268 }
1269 
1270 template <>
1271 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1272 double fmod(const double& a, const double& b) {
1273   return ::fmod(a, b);
1274 }
1275 #endif
1276 
1277 } // end namespace numext
1278 
1279 namespace internal {
1280 
1281 template<typename T>
1282 EIGEN_DEVICE_FUNC bool isfinite_impl(const std::complex<T>& x)
1283 {
1284   return (numext::isfinite)(numext::real(x)) && (numext::isfinite)(numext::imag(x));
1285 }
1286 
1287 template<typename T>
1288 EIGEN_DEVICE_FUNC bool isnan_impl(const std::complex<T>& x)
1289 {
1290   return (numext::isnan)(numext::real(x)) || (numext::isnan)(numext::imag(x));
1291 }
1292 
1293 template<typename T>
1294 EIGEN_DEVICE_FUNC bool isinf_impl(const std::complex<T>& x)
1295 {
1296   return ((numext::isinf)(numext::real(x)) || (numext::isinf)(numext::imag(x))) && (!(numext::isnan)(x));
1297 }
1298 
1299 /****************************************************************************
1300 * Implementation of fuzzy comparisons                                       *
1301 ****************************************************************************/
1302 
1303 template<typename Scalar,
1304          bool IsComplex,
1305          bool IsInteger>
1306 struct scalar_fuzzy_default_impl {};
1307 
1308 template<typename Scalar>
1309 struct scalar_fuzzy_default_impl<Scalar, false, false>
1310 {
1311   typedef typename NumTraits<Scalar>::Real RealScalar;
1312   template<typename OtherScalar> EIGEN_DEVICE_FUNC
1313   static inline bool isMuchSmallerThan(const Scalar& x, const OtherScalar& y, const RealScalar& prec)
1314   {
1315     return numext::abs(x) <= numext::abs(y) * prec;
1316   }
1317   EIGEN_DEVICE_FUNC
1318   static inline bool isApprox(const Scalar& x, const Scalar& y, const RealScalar& prec)
1319   {
1320     return numext::abs(x - y) <= numext::mini(numext::abs(x), numext::abs(y)) * prec;
1321   }
1322   EIGEN_DEVICE_FUNC
1323   static inline bool isApproxOrLessThan(const Scalar& x, const Scalar& y, const RealScalar& prec)
1324   {
1325     return x <= y || isApprox(x, y, prec);
1326   }
1327 };
1328 
1329 template<typename Scalar>
1330 struct scalar_fuzzy_default_impl<Scalar, false, true>
1331 {
1332   typedef typename NumTraits<Scalar>::Real RealScalar;
1333   template<typename OtherScalar> EIGEN_DEVICE_FUNC
1334   static inline bool isMuchSmallerThan(const Scalar& x, const Scalar&, const RealScalar&)
1335   {
1336     return x == Scalar(0);
1337   }
1338   EIGEN_DEVICE_FUNC
1339   static inline bool isApprox(const Scalar& x, const Scalar& y, const RealScalar&)
1340   {
1341     return x == y;
1342   }
1343   EIGEN_DEVICE_FUNC
1344   static inline bool isApproxOrLessThan(const Scalar& x, const Scalar& y, const RealScalar&)
1345   {
1346     return x <= y;
1347   }
1348 };
1349 
1350 template<typename Scalar>
1351 struct scalar_fuzzy_default_impl<Scalar, true, false>
1352 {
1353   typedef typename NumTraits<Scalar>::Real RealScalar;
1354   template<typename OtherScalar> EIGEN_DEVICE_FUNC
1355   static inline bool isMuchSmallerThan(const Scalar& x, const OtherScalar& y, const RealScalar& prec)
1356   {
1357     return numext::abs2(x) <= numext::abs2(y) * prec * prec;
1358   }
1359   EIGEN_DEVICE_FUNC
1360   static inline bool isApprox(const Scalar& x, const Scalar& y, const RealScalar& prec)
1361   {
1362     return numext::abs2(x - y) <= numext::mini(numext::abs2(x), numext::abs2(y)) * prec * prec;
1363   }
1364 };
1365 
1366 template<typename Scalar>
1367 struct scalar_fuzzy_impl : scalar_fuzzy_default_impl<Scalar, NumTraits<Scalar>::IsComplex, NumTraits<Scalar>::IsInteger> {};
1368 
1369 template<typename Scalar, typename OtherScalar> EIGEN_DEVICE_FUNC
1370 inline bool isMuchSmallerThan(const Scalar& x, const OtherScalar& y,
1371                               const typename NumTraits<Scalar>::Real &precision = NumTraits<Scalar>::dummy_precision())
1372 {
1373   return scalar_fuzzy_impl<Scalar>::template isMuchSmallerThan<OtherScalar>(x, y, precision);
1374 }
1375 
1376 template<typename Scalar> EIGEN_DEVICE_FUNC
1377 inline bool isApprox(const Scalar& x, const Scalar& y,
1378                      const typename NumTraits<Scalar>::Real &precision = NumTraits<Scalar>::dummy_precision())
1379 {
1380   return scalar_fuzzy_impl<Scalar>::isApprox(x, y, precision);
1381 }
1382 
1383 template<typename Scalar> EIGEN_DEVICE_FUNC
1384 inline bool isApproxOrLessThan(const Scalar& x, const Scalar& y,
1385                                const typename NumTraits<Scalar>::Real &precision = NumTraits<Scalar>::dummy_precision())
1386 {
1387   return scalar_fuzzy_impl<Scalar>::isApproxOrLessThan(x, y, precision);
1388 }
1389 
1390 /******************************************
1391 ***  The special case of the  bool type ***
1392 ******************************************/
1393 
1394 template<> struct random_impl<bool>
1395 {
1396   static inline bool run()
1397   {
1398     return random<int>(0,1)==0 ? false : true;
1399   }
1400 };
1401 
1402 template<> struct scalar_fuzzy_impl<bool>
1403 {
1404   typedef bool RealScalar;
1405 
1406   template<typename OtherScalar> EIGEN_DEVICE_FUNC
1407   static inline bool isMuchSmallerThan(const bool& x, const bool&, const bool&)
1408   {
1409     return !x;
1410   }
1411 
1412   EIGEN_DEVICE_FUNC
1413   static inline bool isApprox(bool x, bool y, bool)
1414   {
1415     return x == y;
1416   }
1417 
1418   EIGEN_DEVICE_FUNC
1419   static inline bool isApproxOrLessThan(const bool& x, const bool& y, const bool&)
1420   {
1421     return (!x) || y;
1422   }
1423 
1424 };
1425 
1426 
1427 } // end namespace internal
1428 
1429 } // end namespace Eigen
1430 
1431 #endif // EIGEN_MATHFUNCTIONS_H
1432