Eigen  3.3.9
 
Loading...
Searching...
No Matches
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
18namespace 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
23long abs(long x) { return (labs(x)); }
24double abs(double x) { return (fabs(x)); }
25float abs(float x) { return (fabsf(x)); }
26long double abs(long double x) { return (fabsl(x)); }
27#endif
28
29namespace internal {
30
50
51template<typename T, typename dummy = void>
52struct global_math_functions_filtering_base
53{
54 typedef T type;
55};
56
57template<typename T> struct always_void { typedef void type; };
58
59template<typename T>
60struct 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
75template<typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
76struct 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
86template<typename Scalar>
87struct 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
98template<typename Scalar> struct real_impl : real_default_impl<Scalar> {};
99
100#ifdef __CUDA_ARCH__
101template<typename T>
102struct 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
113template<typename Scalar>
114struct real_retval
115{
116 typedef typename NumTraits<Scalar>::Real type;
117};
118
119/****************************************************************************
120* Implementation of imag *
121****************************************************************************/
122
123template<typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
124struct 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
134template<typename Scalar>
135struct 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
146template<typename Scalar> struct imag_impl : imag_default_impl<Scalar> {};
147
148#ifdef __CUDA_ARCH__
149template<typename T>
150struct 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
161template<typename Scalar>
162struct imag_retval
163{
164 typedef typename NumTraits<Scalar>::Real type;
165};
166
167/****************************************************************************
168* Implementation of real_ref *
169****************************************************************************/
170
171template<typename Scalar>
172struct 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
187template<typename Scalar>
188struct real_ref_retval
189{
190 typedef typename NumTraits<Scalar>::Real & type;
191};
192
193/****************************************************************************
194* Implementation of imag_ref *
195****************************************************************************/
196
197template<typename Scalar, bool IsComplex>
198struct 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
213template<typename Scalar>
214struct 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
228template<typename Scalar>
229struct imag_ref_impl : imag_ref_default_impl<Scalar, NumTraits<Scalar>::IsComplex> {};
230
231template<typename Scalar>
232struct imag_ref_retval
233{
234 typedef typename NumTraits<Scalar>::Real & type;
235};
236
237/****************************************************************************
238* Implementation of conj *
239****************************************************************************/
240
241template<typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
242struct conj_impl
243{
244 EIGEN_DEVICE_FUNC
245 static inline Scalar run(const Scalar& x)
246 {
247 return x;
248 }
249};
250
251template<typename Scalar>
252struct 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
262template<typename Scalar>
263struct conj_retval
264{
265 typedef Scalar type;
266};
267
268/****************************************************************************
269* Implementation of abs2 *
270****************************************************************************/
271
272template<typename Scalar,bool IsComplex>
273struct 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
283template<typename Scalar>
284struct 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 x.real()*x.real() + x.imag()*x.imag();
291 }
292};
293
294template<typename Scalar>
295struct 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
305template<typename Scalar>
306struct abs2_retval
307{
308 typedef typename NumTraits<Scalar>::Real type;
309};
310
311/****************************************************************************
312* Implementation of norm1 *
313****************************************************************************/
314
315template<typename Scalar, bool IsComplex>
316struct norm1_default_impl;
317
318template<typename Scalar>
319struct norm1_default_impl<Scalar,true>
320{
321 typedef typename NumTraits<Scalar>::Real RealScalar;
322 EIGEN_DEVICE_FUNC
323 static inline RealScalar run(const Scalar& x)
324 {
325 EIGEN_USING_STD_MATH(abs);
326 return abs(x.real()) + abs(x.imag());
327 }
328};
329
330template<typename Scalar>
331struct norm1_default_impl<Scalar, false>
332{
333 EIGEN_DEVICE_FUNC
334 static inline Scalar run(const Scalar& x)
335 {
336 EIGEN_USING_STD_MATH(abs);
337 return abs(x);
338 }
339};
340
341template<typename Scalar>
342struct norm1_impl : norm1_default_impl<Scalar, NumTraits<Scalar>::IsComplex> {};
343
344template<typename Scalar>
345struct norm1_retval
346{
347 typedef typename NumTraits<Scalar>::Real type;
348};
349
350/****************************************************************************
351* Implementation of hypot *
352****************************************************************************/
353
354template<typename Scalar> struct hypot_impl;
355
356template<typename Scalar>
357struct hypot_retval
358{
359 typedef typename NumTraits<Scalar>::Real type;
360};
361
362/****************************************************************************
363* Implementation of cast *
364****************************************************************************/
365
366template<typename OldType, typename NewType>
367struct cast_impl
368{
369 EIGEN_DEVICE_FUNC
370 static inline NewType run(const OldType& x)
371 {
372 return static_cast<NewType>(x);
373 }
374};
375
376// here, for once, we're plainly returning NewType: we don't want cast to do weird things.
377
378template<typename OldType, typename NewType>
379EIGEN_DEVICE_FUNC
380inline NewType cast(const OldType& x)
381{
382 return cast_impl<OldType, NewType>::run(x);
383}
384
385/****************************************************************************
386* Implementation of round *
387****************************************************************************/
388
389#if EIGEN_HAS_CXX11_MATH
390 template<typename Scalar>
391 struct round_impl {
392 static inline Scalar run(const Scalar& x)
393 {
394 EIGEN_STATIC_ASSERT((!NumTraits<Scalar>::IsComplex), NUMERIC_TYPE_MUST_BE_REAL)
395 using std::round;
396 return round(x);
397 }
398 };
399#else
400 template<typename Scalar>
401 struct round_impl
402 {
403 static inline Scalar run(const Scalar& x)
404 {
405 EIGEN_STATIC_ASSERT((!NumTraits<Scalar>::IsComplex), NUMERIC_TYPE_MUST_BE_REAL)
406 EIGEN_USING_STD_MATH(floor);
407 EIGEN_USING_STD_MATH(ceil);
408 return (x > Scalar(0)) ? floor(x + Scalar(0.5)) : ceil(x - Scalar(0.5));
409 }
410 };
411#endif
412
413template<typename Scalar>
414struct round_retval
415{
416 typedef Scalar type;
417};
418
419/****************************************************************************
420* Implementation of arg *
421****************************************************************************/
422
423#if EIGEN_HAS_CXX11_MATH
424 template<typename Scalar>
425 struct arg_impl {
426 static inline Scalar run(const Scalar& x)
427 {
428 EIGEN_USING_STD_MATH(arg);
429 return arg(x);
430 }
431 };
432#else
433 template<typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
434 struct arg_default_impl
435 {
436 typedef typename NumTraits<Scalar>::Real RealScalar;
437 EIGEN_DEVICE_FUNC
438 static inline RealScalar run(const Scalar& x)
439 {
440 return (x < Scalar(0)) ? Scalar(EIGEN_PI) : Scalar(0); }
441 };
442
443 template<typename Scalar>
444 struct arg_default_impl<Scalar,true>
445 {
446 typedef typename NumTraits<Scalar>::Real RealScalar;
447 EIGEN_DEVICE_FUNC
448 static inline RealScalar run(const Scalar& x)
449 {
450 EIGEN_USING_STD_MATH(arg);
451 return arg(x);
452 }
453 };
454
455 template<typename Scalar> struct arg_impl : arg_default_impl<Scalar> {};
456#endif
457
458template<typename Scalar>
459struct arg_retval
460{
461 typedef typename NumTraits<Scalar>::Real type;
462};
463
464/****************************************************************************
465* Implementation of expm1 *
466****************************************************************************/
467
468// This implementation is based on GSL Math's expm1.
469namespace std_fallback {
470 // fallback expm1 implementation in case there is no expm1(Scalar) function in namespace of Scalar,
471 // or that there is no suitable std::expm1 function available. Implementation
472 // attributed to Kahan. See: http://www.plunk.org/~hatch/rightway.php.
473 template<typename Scalar>
474 EIGEN_DEVICE_FUNC inline Scalar expm1(const Scalar& x) {
475 EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar)
476 typedef typename NumTraits<Scalar>::Real RealScalar;
477
478 EIGEN_USING_STD_MATH(exp);
479 Scalar u = exp(x);
480 if (numext::equal_strict(u, Scalar(1))) {
481 return x;
482 }
483 Scalar um1 = u - RealScalar(1);
484 if (numext::equal_strict(um1, Scalar(-1))) {
485 return RealScalar(-1);
486 }
487
488 EIGEN_USING_STD_MATH(log);
489 return (u - RealScalar(1)) * x / log(u);
490 }
491}
492
493template<typename Scalar>
494struct expm1_impl {
495 EIGEN_DEVICE_FUNC static inline Scalar run(const Scalar& x)
496 {
497 EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar)
498 #if EIGEN_HAS_CXX11_MATH
499 using std::expm1;
500 #else
501 using std_fallback::expm1;
502 #endif
503 return expm1(x);
504 }
505};
506
507// Specialization for complex types that are not supported by std::expm1.
508template <typename RealScalar>
509struct expm1_impl<std::complex<RealScalar> > {
510 EIGEN_DEVICE_FUNC static inline std::complex<RealScalar> run(
511 const std::complex<RealScalar>& x) {
512 EIGEN_STATIC_ASSERT_NON_INTEGER(RealScalar)
513 return std_fallback::expm1(x);
514 }
515};
516
517template<typename Scalar>
518struct expm1_retval
519{
520 typedef Scalar type;
521};
522
523/****************************************************************************
524* Implementation of log1p *
525****************************************************************************/
526
527namespace std_fallback {
528 // fallback log1p implementation in case there is no log1p(Scalar) function in namespace of Scalar,
529 // or that there is no suitable std::log1p function available
530 template<typename Scalar>
531 EIGEN_DEVICE_FUNC inline Scalar log1p(const Scalar& x) {
532 EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar)
533 typedef typename NumTraits<Scalar>::Real RealScalar;
534 EIGEN_USING_STD_MATH(log);
535 Scalar x1p = RealScalar(1) + x;
536 return numext::equal_strict(x1p, Scalar(1)) ? x : x * ( log(x1p) / (x1p - RealScalar(1)) );
537 }
538}
539
540template<typename Scalar>
541struct log1p_impl {
542 static EIGEN_DEVICE_FUNC inline Scalar run(const Scalar& x)
543 {
544 EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar)
545 #if EIGEN_HAS_CXX11_MATH
546 using std::log1p;
547 #else
548 using std_fallback::log1p;
549 #endif
550 return log1p(x);
551 }
552};
553
554// Specialization for complex types that are not supported by std::log1p.
555template <typename RealScalar>
556struct log1p_impl<std::complex<RealScalar> > {
557 EIGEN_DEVICE_FUNC static inline std::complex<RealScalar> run(
558 const std::complex<RealScalar>& x) {
559 EIGEN_STATIC_ASSERT_NON_INTEGER(RealScalar)
560 return std_fallback::log1p(x);
561 }
562};
563
564template<typename Scalar>
565struct log1p_retval
566{
567 typedef Scalar type;
568};
569
570/****************************************************************************
571* Implementation of pow *
572****************************************************************************/
573
574template<typename ScalarX,typename ScalarY, bool IsInteger = NumTraits<ScalarX>::IsInteger&&NumTraits<ScalarY>::IsInteger>
575struct pow_impl
576{
577 //typedef Scalar retval;
578 typedef typename ScalarBinaryOpTraits<ScalarX,ScalarY,internal::scalar_pow_op<ScalarX,ScalarY> >::ReturnType result_type;
579 static EIGEN_DEVICE_FUNC inline result_type run(const ScalarX& x, const ScalarY& y)
580 {
581 EIGEN_USING_STD_MATH(pow);
582 return pow(x, y);
583 }
584};
585
586template<typename ScalarX,typename ScalarY>
587struct pow_impl<ScalarX,ScalarY, true>
588{
589 typedef ScalarX result_type;
590 static EIGEN_DEVICE_FUNC inline ScalarX run(ScalarX x, ScalarY y)
591 {
592 ScalarX res(1);
593 eigen_assert(!NumTraits<ScalarY>::IsSigned || y >= 0);
594 if(y & 1) res *= x;
595 y >>= 1;
596 while(y)
597 {
598 x *= x;
599 if(y&1) res *= x;
600 y >>= 1;
601 }
602 return res;
603 }
604};
605
606/****************************************************************************
607* Implementation of random *
608****************************************************************************/
609
610template<typename Scalar,
611 bool IsComplex,
612 bool IsInteger>
613struct random_default_impl {};
614
615template<typename Scalar>
616struct random_impl : random_default_impl<Scalar, NumTraits<Scalar>::IsComplex, NumTraits<Scalar>::IsInteger> {};
617
618template<typename Scalar>
619struct random_retval
620{
621 typedef Scalar type;
622};
623
624template<typename Scalar> inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random(const Scalar& x, const Scalar& y);
625template<typename Scalar> inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random();
626
627enum {
628 meta_floor_log2_terminate,
629 meta_floor_log2_move_up,
630 meta_floor_log2_move_down,
631 meta_floor_log2_bogus
632};
633
634template<unsigned int n, int lower, int upper> struct meta_floor_log2_selector
635{
636 enum { middle = (lower + upper) / 2,
637 value = (upper <= lower + 1) ? int(meta_floor_log2_terminate)
638 : (n < (1 << middle)) ? int(meta_floor_log2_move_down)
639 : (n==0) ? int(meta_floor_log2_bogus)
640 : int(meta_floor_log2_move_up)
641 };
642};
643
644template<unsigned int n,
645 int lower = 0,
646 int upper = sizeof(unsigned int) * CHAR_BIT - 1,
647 int selector = meta_floor_log2_selector<n, lower, upper>::value>
648struct meta_floor_log2 {};
649
650template<unsigned int n, int lower, int upper>
651struct meta_floor_log2<n, lower, upper, meta_floor_log2_move_down>
652{
653 enum { value = meta_floor_log2<n, lower, meta_floor_log2_selector<n, lower, upper>::middle>::value };
654};
655
656template<unsigned int n, int lower, int upper>
657struct meta_floor_log2<n, lower, upper, meta_floor_log2_move_up>
658{
659 enum { value = meta_floor_log2<n, meta_floor_log2_selector<n, lower, upper>::middle, upper>::value };
660};
661
662template<unsigned int n, int lower, int upper>
663struct meta_floor_log2<n, lower, upper, meta_floor_log2_terminate>
664{
665 enum { value = (n >= ((unsigned int)(1) << (lower+1))) ? lower+1 : lower };
666};
667
668template<unsigned int n, int lower, int upper>
669struct meta_floor_log2<n, lower, upper, meta_floor_log2_bogus>
670{
671 // no value, error at compile time
672};
673
674#define EIGEN_RAND_MAX INT_MAX
675// Fill a signed positive int with random bits.
676// This is to overcome issues in MSVC which limits RAND_MAX to 32767.
677inline int random_int() {
678#if RAND_MAX == INT_MAX
679 return std::rand();
680#else
681 enum {
682 rand_bits = meta_floor_log2<(unsigned int)(RAND_MAX)+1>::value,
683 int_bits = meta_floor_log2<(unsigned int)(INT_MAX)+1>::value,
684 };
685 unsigned int out = std::rand();
686 for (int bit = rand_bits; bit < int(int_bits); bit += rand_bits) {
687 out = (out << rand_bits) ^ std::rand();
688 }
689 return static_cast<int>(out & INT_MAX);
690#endif
691}
692
693template<typename Scalar>
694struct random_default_impl<Scalar, false, false>
695{
696 static inline Scalar run(const Scalar& x, const Scalar& y)
697 {
698 return x + (y-x) * Scalar(random_int()) / Scalar(EIGEN_RAND_MAX);
699 }
700 static inline Scalar run()
701 {
702 return run(Scalar(NumTraits<Scalar>::IsSigned ? -1 : 0), Scalar(1));
703 }
704};
705
706template<typename Scalar>
707struct random_default_impl<Scalar, false, true>
708{
709 static inline Scalar run(const Scalar& x, const Scalar& y)
710 {
711 if (y <= x)
712 return x;
713 // ScalarU is the unsigned counterpart of Scalar, possibly Scalar itself.
714 typedef typename make_unsigned<Scalar>::type ScalarU;
715 // ScalarX is the widest of ScalarU and unsigned int.
716 // We'll deal only with ScalarX and unsigned int below thus avoiding signed
717 // types and arithmetic and signed overflows (which are undefined behavior).
718 typedef typename conditional<(ScalarU(-1) > unsigned(-1)), ScalarU, unsigned>::type ScalarX;
719 // The following difference doesn't overflow, provided our integer types are two's
720 // complement and have the same number of padding bits in signed and unsigned variants.
721 // This is the case in most modern implementations of C++.
722 ScalarX range = ScalarX(y) - ScalarX(x);
723 ScalarX offset = 0;
724 ScalarX divisor = 1;
725 ScalarX multiplier = 1;
726 const unsigned rand_max = EIGEN_RAND_MAX;
727 if (range <= rand_max) divisor = (rand_max + 1) / (range + 1);
728 else multiplier = 1 + range / (rand_max + 1);
729 // Rejection sampling.
730 do {
731 offset = (unsigned(random_int()) * multiplier) / divisor;
732 } while (offset > range);
733 return Scalar(ScalarX(x) + offset);
734 }
735
736 static inline Scalar run()
737 {
738#ifdef EIGEN_MAKING_DOCS
739 return run(Scalar(NumTraits<Scalar>::IsSigned ? -10 : 0), Scalar(10));
740#else
741 enum { rand_bits = meta_floor_log2<(unsigned int)(EIGEN_RAND_MAX)+1>::value,
742 scalar_bits = sizeof(Scalar) * CHAR_BIT,
743 shift = EIGEN_PLAIN_ENUM_MAX(0, int(rand_bits) - int(scalar_bits)),
744 offset = NumTraits<Scalar>::IsSigned ? (1 << (EIGEN_PLAIN_ENUM_MIN(rand_bits,scalar_bits)-1)) : 0
745 };
746 return Scalar((random_int() >> shift) - offset);
747#endif
748 }
749};
750
751template<typename Scalar>
752struct random_default_impl<Scalar, true, false>
753{
754 static inline Scalar run(const Scalar& x, const Scalar& y)
755 {
756 return Scalar(random(x.real(), y.real()),
757 random(x.imag(), y.imag()));
758 }
759 static inline Scalar run()
760 {
761 typedef typename NumTraits<Scalar>::Real RealScalar;
762 return Scalar(random<RealScalar>(), random<RealScalar>());
763 }
764};
765
766template<typename Scalar>
767inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random(const Scalar& x, const Scalar& y)
768{
769 return EIGEN_MATHFUNC_IMPL(random, Scalar)::run(x, y);
770}
771
772template<typename Scalar>
773inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random()
774{
775 return EIGEN_MATHFUNC_IMPL(random, Scalar)::run();
776}
777
778// Implementatin of is* functions
779
780// std::is* do not work with fast-math and gcc, std::is* are available on MSVC 2013 and newer, as well as in clang.
781#if (EIGEN_HAS_CXX11_MATH && !(EIGEN_COMP_GNUC_STRICT && __FINITE_MATH_ONLY__)) || (EIGEN_COMP_MSVC>=1800) || (EIGEN_COMP_CLANG)
782#define EIGEN_USE_STD_FPCLASSIFY 1
783#else
784#define EIGEN_USE_STD_FPCLASSIFY 0
785#endif
786
787template<typename T>
788EIGEN_DEVICE_FUNC
789typename internal::enable_if<internal::is_integral<T>::value,bool>::type
790isnan_impl(const T&) { return false; }
791
792template<typename T>
793EIGEN_DEVICE_FUNC
794typename internal::enable_if<internal::is_integral<T>::value,bool>::type
795isinf_impl(const T&) { return false; }
796
797template<typename T>
798EIGEN_DEVICE_FUNC
799typename internal::enable_if<internal::is_integral<T>::value,bool>::type
800isfinite_impl(const T&) { return true; }
801
802template<typename T>
803EIGEN_DEVICE_FUNC
804typename internal::enable_if<(!internal::is_integral<T>::value)&&(!NumTraits<T>::IsComplex),bool>::type
805isfinite_impl(const T& x)
806{
807 #ifdef __CUDA_ARCH__
808 return (::isfinite)(x);
809 #elif EIGEN_USE_STD_FPCLASSIFY
810 using std::isfinite;
811 return isfinite EIGEN_NOT_A_MACRO (x);
812 #else
813 return x<=NumTraits<T>::highest() && x>=NumTraits<T>::lowest();
814 #endif
815}
816
817template<typename T>
818EIGEN_DEVICE_FUNC
819typename internal::enable_if<(!internal::is_integral<T>::value)&&(!NumTraits<T>::IsComplex),bool>::type
820isinf_impl(const T& x)
821{
822 #ifdef __CUDA_ARCH__
823 return (::isinf)(x);
824 #elif EIGEN_USE_STD_FPCLASSIFY
825 using std::isinf;
826 return isinf EIGEN_NOT_A_MACRO (x);
827 #else
828 return x>NumTraits<T>::highest() || x<NumTraits<T>::lowest();
829 #endif
830}
831
832template<typename T>
833EIGEN_DEVICE_FUNC
834typename internal::enable_if<(!internal::is_integral<T>::value)&&(!NumTraits<T>::IsComplex),bool>::type
835isnan_impl(const T& x)
836{
837 #ifdef __CUDA_ARCH__
838 return (::isnan)(x);
839 #elif EIGEN_USE_STD_FPCLASSIFY
840 using std::isnan;
841 return isnan EIGEN_NOT_A_MACRO (x);
842 #else
843 return x != x;
844 #endif
845}
846
847#if (!EIGEN_USE_STD_FPCLASSIFY)
848
849#if EIGEN_COMP_MSVC
850
851template<typename T> EIGEN_DEVICE_FUNC bool isinf_msvc_helper(T x)
852{
853 return _fpclass(x)==_FPCLASS_NINF || _fpclass(x)==_FPCLASS_PINF;
854}
855
856//MSVC defines a _isnan builtin function, but for double only
857EIGEN_DEVICE_FUNC inline bool isnan_impl(const long double& x) { return _isnan(x)!=0; }
858EIGEN_DEVICE_FUNC inline bool isnan_impl(const double& x) { return _isnan(x)!=0; }
859EIGEN_DEVICE_FUNC inline bool isnan_impl(const float& x) { return _isnan(x)!=0; }
860
861EIGEN_DEVICE_FUNC inline bool isinf_impl(const long double& x) { return isinf_msvc_helper(x); }
862EIGEN_DEVICE_FUNC inline bool isinf_impl(const double& x) { return isinf_msvc_helper(x); }
863EIGEN_DEVICE_FUNC inline bool isinf_impl(const float& x) { return isinf_msvc_helper(x); }
864
865#elif (defined __FINITE_MATH_ONLY__ && __FINITE_MATH_ONLY__ && EIGEN_COMP_GNUC)
866
867#if EIGEN_GNUC_AT_LEAST(5,0)
868 #define EIGEN_TMP_NOOPT_ATTRIB EIGEN_DEVICE_FUNC inline __attribute__((optimize("no-finite-math-only")))
869#else
870 // NOTE the inline qualifier and noinline attribute are both needed: the former is to avoid linking issue (duplicate symbol),
871 // while the second prevent too aggressive optimizations in fast-math mode:
872 #define EIGEN_TMP_NOOPT_ATTRIB EIGEN_DEVICE_FUNC inline __attribute__((noinline,optimize("no-finite-math-only")))
873#endif
874
875template<> EIGEN_TMP_NOOPT_ATTRIB bool isnan_impl(const long double& x) { return __builtin_isnan(x); }
876template<> EIGEN_TMP_NOOPT_ATTRIB bool isnan_impl(const double& x) { return __builtin_isnan(x); }
877template<> EIGEN_TMP_NOOPT_ATTRIB bool isnan_impl(const float& x) { return __builtin_isnan(x); }
878template<> EIGEN_TMP_NOOPT_ATTRIB bool isinf_impl(const double& x) { return __builtin_isinf(x); }
879template<> EIGEN_TMP_NOOPT_ATTRIB bool isinf_impl(const float& x) { return __builtin_isinf(x); }
880template<> EIGEN_TMP_NOOPT_ATTRIB bool isinf_impl(const long double& x) { return __builtin_isinf(x); }
881
882#undef EIGEN_TMP_NOOPT_ATTRIB
883
884#endif
885
886#endif
887
888// The following overload are defined at the end of this file
889template<typename T> EIGEN_DEVICE_FUNC bool isfinite_impl(const std::complex<T>& x);
890template<typename T> EIGEN_DEVICE_FUNC bool isnan_impl(const std::complex<T>& x);
891template<typename T> EIGEN_DEVICE_FUNC bool isinf_impl(const std::complex<T>& x);
892
893template<typename T> T generic_fast_tanh_float(const T& a_x);
894
895} // end namespace internal
896
897/****************************************************************************
898* Generic math functions *
899****************************************************************************/
900
901namespace numext {
902
903#ifndef __CUDA_ARCH__
904template<typename T>
905EIGEN_DEVICE_FUNC
906EIGEN_ALWAYS_INLINE T mini(const T& x, const T& y)
907{
908 EIGEN_USING_STD_MATH(min);
909 return min EIGEN_NOT_A_MACRO (x,y);
910}
911
912template<typename T>
913EIGEN_DEVICE_FUNC
914EIGEN_ALWAYS_INLINE T maxi(const T& x, const T& y)
915{
916 EIGEN_USING_STD_MATH(max);
917 return max EIGEN_NOT_A_MACRO (x,y);
918}
919#else
920template<typename T>
921EIGEN_DEVICE_FUNC
922EIGEN_ALWAYS_INLINE T mini(const T& x, const T& y)
923{
924 return y < x ? y : x;
925}
926template<>
927EIGEN_DEVICE_FUNC
928EIGEN_ALWAYS_INLINE float mini(const float& x, const float& y)
929{
930 return fminf(x, y);
931}
932template<typename T>
933EIGEN_DEVICE_FUNC
934EIGEN_ALWAYS_INLINE T maxi(const T& x, const T& y)
935{
936 return x < y ? y : x;
937}
938template<>
939EIGEN_DEVICE_FUNC
940EIGEN_ALWAYS_INLINE float maxi(const float& x, const float& y)
941{
942 return fmaxf(x, y);
943}
944#endif
945
946
947template<typename Scalar>
948EIGEN_DEVICE_FUNC
949inline EIGEN_MATHFUNC_RETVAL(real, Scalar) real(const Scalar& x)
950{
951 return EIGEN_MATHFUNC_IMPL(real, Scalar)::run(x);
952}
953
954template<typename Scalar>
955EIGEN_DEVICE_FUNC
956inline typename internal::add_const_on_value_type< EIGEN_MATHFUNC_RETVAL(real_ref, Scalar) >::type real_ref(const Scalar& x)
957{
958 return internal::real_ref_impl<Scalar>::run(x);
959}
960
961template<typename Scalar>
962EIGEN_DEVICE_FUNC
963inline EIGEN_MATHFUNC_RETVAL(real_ref, Scalar) real_ref(Scalar& x)
964{
965 return EIGEN_MATHFUNC_IMPL(real_ref, Scalar)::run(x);
966}
967
968template<typename Scalar>
969EIGEN_DEVICE_FUNC
970inline EIGEN_MATHFUNC_RETVAL(imag, Scalar) imag(const Scalar& x)
971{
972 return EIGEN_MATHFUNC_IMPL(imag, Scalar)::run(x);
973}
974
975template<typename Scalar>
976EIGEN_DEVICE_FUNC
977inline EIGEN_MATHFUNC_RETVAL(arg, Scalar) arg(const Scalar& x)
978{
979 return EIGEN_MATHFUNC_IMPL(arg, Scalar)::run(x);
980}
981
982template<typename Scalar>
983EIGEN_DEVICE_FUNC
984inline typename internal::add_const_on_value_type< EIGEN_MATHFUNC_RETVAL(imag_ref, Scalar) >::type imag_ref(const Scalar& x)
985{
986 return internal::imag_ref_impl<Scalar>::run(x);
987}
988
989template<typename Scalar>
990EIGEN_DEVICE_FUNC
991inline EIGEN_MATHFUNC_RETVAL(imag_ref, Scalar) imag_ref(Scalar& x)
992{
993 return EIGEN_MATHFUNC_IMPL(imag_ref, Scalar)::run(x);
994}
995
996template<typename Scalar>
997EIGEN_DEVICE_FUNC
998inline EIGEN_MATHFUNC_RETVAL(conj, Scalar) conj(const Scalar& x)
999{
1000 return EIGEN_MATHFUNC_IMPL(conj, Scalar)::run(x);
1001}
1002
1003template<typename Scalar>
1004EIGEN_DEVICE_FUNC
1005inline EIGEN_MATHFUNC_RETVAL(abs2, Scalar) abs2(const Scalar& x)
1006{
1007 return EIGEN_MATHFUNC_IMPL(abs2, Scalar)::run(x);
1008}
1009
1010EIGEN_DEVICE_FUNC
1011inline bool abs2(bool x) { return x; }
1012
1013template<typename Scalar>
1014EIGEN_DEVICE_FUNC
1015inline EIGEN_MATHFUNC_RETVAL(norm1, Scalar) norm1(const Scalar& x)
1016{
1017 return EIGEN_MATHFUNC_IMPL(norm1, Scalar)::run(x);
1018}
1019
1020template<typename Scalar>
1021EIGEN_DEVICE_FUNC
1022inline EIGEN_MATHFUNC_RETVAL(hypot, Scalar) hypot(const Scalar& x, const Scalar& y)
1023{
1024 return EIGEN_MATHFUNC_IMPL(hypot, Scalar)::run(x, y);
1025}
1026
1027template<typename Scalar>
1028EIGEN_DEVICE_FUNC
1029inline EIGEN_MATHFUNC_RETVAL(log1p, Scalar) log1p(const Scalar& x)
1030{
1031 return EIGEN_MATHFUNC_IMPL(log1p, Scalar)::run(x);
1032}
1033
1034#ifdef EIGEN_CUDACC
1035template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1036float log1p(const float &x) { return ::log1pf(x); }
1037
1038template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1039double log1p(const double &x) { return ::log1p(x); }
1040#endif
1041
1042template<typename ScalarX,typename ScalarY>
1043EIGEN_DEVICE_FUNC
1044inline typename internal::pow_impl<ScalarX,ScalarY>::result_type pow(const ScalarX& x, const ScalarY& y)
1045{
1046 return internal::pow_impl<ScalarX,ScalarY>::run(x, y);
1047}
1048
1049template<typename T> EIGEN_DEVICE_FUNC bool (isnan) (const T &x) { return internal::isnan_impl(x); }
1050template<typename T> EIGEN_DEVICE_FUNC bool (isinf) (const T &x) { return internal::isinf_impl(x); }
1051template<typename T> EIGEN_DEVICE_FUNC bool (isfinite)(const T &x) { return internal::isfinite_impl(x); }
1052
1053template<typename Scalar>
1054EIGEN_DEVICE_FUNC
1055inline EIGEN_MATHFUNC_RETVAL(round, Scalar) round(const Scalar& x)
1056{
1057 return EIGEN_MATHFUNC_IMPL(round, Scalar)::run(x);
1058}
1059
1060template<typename T>
1061EIGEN_DEVICE_FUNC
1062T (floor)(const T& x)
1063{
1064 EIGEN_USING_STD_MATH(floor);
1065 return floor(x);
1066}
1067
1068#ifdef EIGEN_CUDACC
1069template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1070float floor(const float &x) { return ::floorf(x); }
1071
1072template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1073double floor(const double &x) { return ::floor(x); }
1074#endif
1075
1076template<typename T>
1077EIGEN_DEVICE_FUNC
1078T (ceil)(const T& x)
1079{
1080 EIGEN_USING_STD_MATH(ceil);
1081 return ceil(x);
1082}
1083
1084#ifdef EIGEN_CUDACC
1085template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1086float ceil(const float &x) { return ::ceilf(x); }
1087
1088template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1089double ceil(const double &x) { return ::ceil(x); }
1090#endif
1091
1092
1095inline int log2(int x)
1096{
1097 eigen_assert(x>=0);
1098 unsigned int v(x);
1099 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 };
1100 v |= v >> 1;
1101 v |= v >> 2;
1102 v |= v >> 4;
1103 v |= v >> 8;
1104 v |= v >> 16;
1105 return table[(v * 0x07C4ACDDU) >> 27];
1106}
1107
1117template<typename T>
1118EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1119T sqrt(const T &x)
1120{
1121 EIGEN_USING_STD_MATH(sqrt);
1122 return sqrt(x);
1123}
1124
1125template<typename T>
1126EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1127T log(const T &x) {
1128 EIGEN_USING_STD_MATH(log);
1129 return log(x);
1130}
1131
1132#ifdef EIGEN_CUDACC
1133template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1134float log(const float &x) { return ::logf(x); }
1135
1136template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1137double log(const double &x) { return ::log(x); }
1138#endif
1139
1140template<typename T>
1141EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1142typename internal::enable_if<NumTraits<T>::IsSigned || NumTraits<T>::IsComplex,typename NumTraits<T>::Real>::type
1143abs(const T &x) {
1144 EIGEN_USING_STD_MATH(abs);
1145 return abs(x);
1146}
1147
1148template<typename T>
1149EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1150typename internal::enable_if<!(NumTraits<T>::IsSigned || NumTraits<T>::IsComplex),typename NumTraits<T>::Real>::type
1151abs(const T &x) {
1152 return x;
1153}
1154
1155#if defined(__SYCL_DEVICE_ONLY__)
1156EIGEN_ALWAYS_INLINE float abs(float x) { return cl::sycl::fabs(x); }
1157EIGEN_ALWAYS_INLINE double abs(double x) { return cl::sycl::fabs(x); }
1158#endif // defined(__SYCL_DEVICE_ONLY__)
1159
1160#ifdef EIGEN_CUDACC
1161template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1162float abs(const float &x) { return ::fabsf(x); }
1163
1164template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1165double abs(const double &x) { return ::fabs(x); }
1166
1167template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1168float abs(const std::complex<float>& x) {
1169 return ::hypotf(x.real(), x.imag());
1170}
1171
1172template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1173double abs(const std::complex<double>& x) {
1174 return ::hypot(x.real(), x.imag());
1175}
1176#endif
1177
1178template<typename T>
1179EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1180T exp(const T &x) {
1181 EIGEN_USING_STD_MATH(exp);
1182 return exp(x);
1183}
1184
1185#ifdef EIGEN_CUDACC
1186template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1187float exp(const float &x) { return ::expf(x); }
1188
1189template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1190double exp(const double &x) { return ::exp(x); }
1191#endif
1192
1193template<typename T>
1194EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1195T cos(const T &x) {
1196 EIGEN_USING_STD_MATH(cos);
1197 return cos(x);
1198}
1199
1200#ifdef EIGEN_CUDACC
1201template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1202float cos(const float &x) { return ::cosf(x); }
1203
1204template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1205double cos(const double &x) { return ::cos(x); }
1206#endif
1207
1208template<typename T>
1209EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1210T sin(const T &x) {
1211 EIGEN_USING_STD_MATH(sin);
1212 return sin(x);
1213}
1214
1215#ifdef EIGEN_CUDACC
1216template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1217float sin(const float &x) { return ::sinf(x); }
1218
1219template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1220double sin(const double &x) { return ::sin(x); }
1221#endif
1222
1223template<typename T>
1224EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1225T tan(const T &x) {
1226 EIGEN_USING_STD_MATH(tan);
1227 return tan(x);
1228}
1229
1230#ifdef EIGEN_CUDACC
1231template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1232float tan(const float &x) { return ::tanf(x); }
1233
1234template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1235double tan(const double &x) { return ::tan(x); }
1236#endif
1237
1238template<typename T>
1239EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1240T acos(const T &x) {
1241 EIGEN_USING_STD_MATH(acos);
1242 return acos(x);
1243}
1244
1245#ifdef EIGEN_CUDACC
1246template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1247float acos(const float &x) { return ::acosf(x); }
1248
1249template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1250double acos(const double &x) { return ::acos(x); }
1251#endif
1252
1253template<typename T>
1254EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1255T asin(const T &x) {
1256 EIGEN_USING_STD_MATH(asin);
1257 return asin(x);
1258}
1259
1260#ifdef EIGEN_CUDACC
1261template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1262float asin(const float &x) { return ::asinf(x); }
1263
1264template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1265double asin(const double &x) { return ::asin(x); }
1266#endif
1267
1268template<typename T>
1269EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1270T atan(const T &x) {
1271 EIGEN_USING_STD_MATH(atan);
1272 return atan(x);
1273}
1274
1275#ifdef EIGEN_CUDACC
1276template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1277float atan(const float &x) { return ::atanf(x); }
1278
1279template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1280double atan(const double &x) { return ::atan(x); }
1281#endif
1282
1283
1284template<typename T>
1285EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1286T cosh(const T &x) {
1287 EIGEN_USING_STD_MATH(cosh);
1288 return cosh(x);
1289}
1290
1291#ifdef EIGEN_CUDACC
1292template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1293float cosh(const float &x) { return ::coshf(x); }
1294
1295template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1296double cosh(const double &x) { return ::cosh(x); }
1297#endif
1298
1299template<typename T>
1300EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1301T sinh(const T &x) {
1302 EIGEN_USING_STD_MATH(sinh);
1303 return sinh(x);
1304}
1305
1306#ifdef EIGEN_CUDACC
1307template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1308float sinh(const float &x) { return ::sinhf(x); }
1309
1310template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1311double sinh(const double &x) { return ::sinh(x); }
1312#endif
1313
1314template<typename T>
1315EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1316T tanh(const T &x) {
1317 EIGEN_USING_STD_MATH(tanh);
1318 return tanh(x);
1319}
1320
1321#if (!defined(EIGEN_CUDACC)) && EIGEN_FAST_MATH
1322EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1323float tanh(float x) { return internal::generic_fast_tanh_float(x); }
1324#endif
1325
1326#ifdef EIGEN_CUDACC
1327template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1328float tanh(const float &x) { return ::tanhf(x); }
1329
1330template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1331double tanh(const double &x) { return ::tanh(x); }
1332#endif
1333
1334template <typename T>
1335EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1336T fmod(const T& a, const T& b) {
1337 EIGEN_USING_STD_MATH(fmod);
1338 return fmod(a, b);
1339}
1340
1341#ifdef EIGEN_CUDACC
1342template <>
1343EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1344float fmod(const float& a, const float& b) {
1345 return ::fmodf(a, b);
1346}
1347
1348template <>
1349EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1350double fmod(const double& a, const double& b) {
1351 return ::fmod(a, b);
1352}
1353#endif
1354
1355} // end namespace numext
1356
1357namespace internal {
1358
1359template<typename T>
1360EIGEN_DEVICE_FUNC bool isfinite_impl(const std::complex<T>& x)
1361{
1362 return (numext::isfinite)(numext::real(x)) && (numext::isfinite)(numext::imag(x));
1363}
1364
1365template<typename T>
1366EIGEN_DEVICE_FUNC bool isnan_impl(const std::complex<T>& x)
1367{
1368 return (numext::isnan)(numext::real(x)) || (numext::isnan)(numext::imag(x));
1369}
1370
1371template<typename T>
1372EIGEN_DEVICE_FUNC bool isinf_impl(const std::complex<T>& x)
1373{
1374 return ((numext::isinf)(numext::real(x)) || (numext::isinf)(numext::imag(x))) && (!(numext::isnan)(x));
1375}
1376
1377/****************************************************************************
1378* Implementation of fuzzy comparisons *
1379****************************************************************************/
1380
1381template<typename Scalar,
1382 bool IsComplex,
1383 bool IsInteger>
1384struct scalar_fuzzy_default_impl {};
1385
1386template<typename Scalar>
1387struct scalar_fuzzy_default_impl<Scalar, false, false>
1388{
1389 typedef typename NumTraits<Scalar>::Real RealScalar;
1390 template<typename OtherScalar> EIGEN_DEVICE_FUNC
1391 static inline bool isMuchSmallerThan(const Scalar& x, const OtherScalar& y, const RealScalar& prec)
1392 {
1393 return numext::abs(x) <= numext::abs(y) * prec;
1394 }
1395 EIGEN_DEVICE_FUNC
1396 static inline bool isApprox(const Scalar& x, const Scalar& y, const RealScalar& prec)
1397 {
1398 return numext::abs(x - y) <= numext::mini(numext::abs(x), numext::abs(y)) * prec;
1399 }
1400 EIGEN_DEVICE_FUNC
1401 static inline bool isApproxOrLessThan(const Scalar& x, const Scalar& y, const RealScalar& prec)
1402 {
1403 return x <= y || isApprox(x, y, prec);
1404 }
1405};
1406
1407template<typename Scalar>
1408struct scalar_fuzzy_default_impl<Scalar, false, true>
1409{
1410 typedef typename NumTraits<Scalar>::Real RealScalar;
1411 template<typename OtherScalar> EIGEN_DEVICE_FUNC
1412 static inline bool isMuchSmallerThan(const Scalar& x, const Scalar&, const RealScalar&)
1413 {
1414 return x == Scalar(0);
1415 }
1416 EIGEN_DEVICE_FUNC
1417 static inline bool isApprox(const Scalar& x, const Scalar& y, const RealScalar&)
1418 {
1419 return x == y;
1420 }
1421 EIGEN_DEVICE_FUNC
1422 static inline bool isApproxOrLessThan(const Scalar& x, const Scalar& y, const RealScalar&)
1423 {
1424 return x <= y;
1425 }
1426};
1427
1428template<typename Scalar>
1429struct scalar_fuzzy_default_impl<Scalar, true, false>
1430{
1431 typedef typename NumTraits<Scalar>::Real RealScalar;
1432 template<typename OtherScalar> EIGEN_DEVICE_FUNC
1433 static inline bool isMuchSmallerThan(const Scalar& x, const OtherScalar& y, const RealScalar& prec)
1434 {
1435 return numext::abs2(x) <= numext::abs2(y) * prec * prec;
1436 }
1437 EIGEN_DEVICE_FUNC
1438 static inline bool isApprox(const Scalar& x, const Scalar& y, const RealScalar& prec)
1439 {
1440 return numext::abs2(x - y) <= numext::mini(numext::abs2(x), numext::abs2(y)) * prec * prec;
1441 }
1442};
1443
1444template<typename Scalar>
1445struct scalar_fuzzy_impl : scalar_fuzzy_default_impl<Scalar, NumTraits<Scalar>::IsComplex, NumTraits<Scalar>::IsInteger> {};
1446
1447template<typename Scalar, typename OtherScalar> EIGEN_DEVICE_FUNC
1448inline bool isMuchSmallerThan(const Scalar& x, const OtherScalar& y,
1449 const typename NumTraits<Scalar>::Real &precision = NumTraits<Scalar>::dummy_precision())
1450{
1451 return scalar_fuzzy_impl<Scalar>::template isMuchSmallerThan<OtherScalar>(x, y, precision);
1452}
1453
1454template<typename Scalar> EIGEN_DEVICE_FUNC
1455inline bool isApprox(const Scalar& x, const Scalar& y,
1456 const typename NumTraits<Scalar>::Real &precision = NumTraits<Scalar>::dummy_precision())
1457{
1458 return scalar_fuzzy_impl<Scalar>::isApprox(x, y, precision);
1459}
1460
1461template<typename Scalar> EIGEN_DEVICE_FUNC
1462inline bool isApproxOrLessThan(const Scalar& x, const Scalar& y,
1463 const typename NumTraits<Scalar>::Real &precision = NumTraits<Scalar>::dummy_precision())
1464{
1465 return scalar_fuzzy_impl<Scalar>::isApproxOrLessThan(x, y, precision);
1466}
1467
1468/******************************************
1469*** The special case of the bool type ***
1470******************************************/
1471
1472template<> struct random_impl<bool>
1473{
1474 static inline bool run()
1475 {
1476 return random<int>(0,1)==0 ? false : true;
1477 }
1478};
1479
1480template<> struct scalar_fuzzy_impl<bool>
1481{
1482 typedef bool RealScalar;
1483
1484 template<typename OtherScalar> EIGEN_DEVICE_FUNC
1485 static inline bool isMuchSmallerThan(const bool& x, const bool&, const bool&)
1486 {
1487 return !x;
1488 }
1489
1490 EIGEN_DEVICE_FUNC
1491 static inline bool isApprox(bool x, bool y, bool)
1492 {
1493 return x == y;
1494 }
1495
1496 EIGEN_DEVICE_FUNC
1497 static inline bool isApproxOrLessThan(const bool& x, const bool& y, const bool&)
1498 {
1499 return (!x) || y;
1500 }
1501
1502};
1503
1504
1505} // end namespace internal
1506
1507} // end namespace Eigen
1508
1509#endif // EIGEN_MATHFUNCTIONS_H
Eigen::ArrayBase::pow
const CwiseBinaryOp< internal::scalar_pow_op< Derived::Scalar, ScalarExponent >, Derived, Constant< ScalarExponent > > pow(const Eigen::ArrayBase< Derived > &x, const ScalarExponent &exponent)
Eigen
Namespace containing all symbols from the Eigen library.
Definition A05_PortingFrom2To3.dox:1
Eigen::cosh
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_cosh_op< typename Derived::Scalar >, const Derived > cosh(const Eigen::ArrayBase< Derived > &x)
Eigen::real
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_real_op< typename Derived::Scalar >, const Derived > real(const Eigen::ArrayBase< Derived > &x)
Eigen::conj
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_conjugate_op< typename Derived::Scalar >, const Derived > conj(const Eigen::ArrayBase< Derived > &x)
Eigen::abs
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_abs_op< typename Derived::Scalar >, const Derived > abs(const Eigen::ArrayBase< Derived > &x)
Eigen::abs2
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_abs2_op< typename Derived::Scalar >, const Derived > abs2(const Eigen::ArrayBase< Derived > &x)
Eigen::atan
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_atan_op< typename Derived::Scalar >, const Derived > atan(const Eigen::ArrayBase< Derived > &x)
Eigen::round
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_round_op< typename Derived::Scalar >, const Derived > round(const Eigen::ArrayBase< Derived > &x)
Eigen::imag
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_imag_op< typename Derived::Scalar >, const Derived > imag(const Eigen::ArrayBase< Derived > &x)
Eigen::asin
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_asin_op< typename Derived::Scalar >, const Derived > asin(const Eigen::ArrayBase< Derived > &x)
Eigen::acos
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_acos_op< typename Derived::Scalar >, const Derived > acos(const Eigen::ArrayBase< Derived > &x)
Eigen::sinh
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_sinh_op< typename Derived::Scalar >, const Derived > sinh(const Eigen::ArrayBase< Derived > &x)
Eigen::arg
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_arg_op< typename Derived::Scalar >, const Derived > arg(const Eigen::ArrayBase< Derived > &x)