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