Eigen/src/Core/MathFunctions.h
Go to the documentation of this file.
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>
53 {
54  typedef T type;
55 };
56 
57 template<typename T> struct always_void { typedef void type; };
58 
59 template<typename T>
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 
77 {
79  EIGEN_DEVICE_FUNC
80  static inline RealScalar run(const Scalar& x)
81  {
82  return x;
83  }
84 };
85 
86 template<typename Scalar>
88 {
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>
115 {
116  typedef typename NumTraits<Scalar>::Real type;
117 };
118 
119 /****************************************************************************
120 * Implementation of imag *
121 ****************************************************************************/
122 
125 {
127  EIGEN_DEVICE_FUNC
128  static inline RealScalar run(const Scalar&)
129  {
130  return RealScalar(0);
131  }
132 };
133 
134 template<typename Scalar>
136 {
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>
163 {
164  typedef typename NumTraits<Scalar>::Real type;
165 };
166 
167 /****************************************************************************
168 * Implementation of real_ref *
169 ****************************************************************************/
170 
171 template<typename Scalar>
173 {
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>
189 {
190  typedef typename NumTraits<Scalar>::Real & type;
191 };
192 
193 /****************************************************************************
194 * Implementation of imag_ref *
195 ****************************************************************************/
196 
197 template<typename Scalar, bool IsComplex>
199 {
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>
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>
233 {
234  typedef typename NumTraits<Scalar>::Real & type;
235 };
236 
237 /****************************************************************************
238 * Implementation of conj *
239 ****************************************************************************/
240 
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>
264 {
265  typedef Scalar type;
266 };
267 
268 /****************************************************************************
269 * Implementation of abs2 *
270 ****************************************************************************/
271 
272 template<typename Scalar,bool IsComplex>
274 {
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 {
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 {
298  EIGEN_DEVICE_FUNC
299  static inline RealScalar run(const Scalar& x)
300  {
302  }
303 };
304 
305 template<typename Scalar>
307 {
308  typedef typename NumTraits<Scalar>::Real type;
309 };
310 
311 /****************************************************************************
312 * Implementation of norm1 *
313 ****************************************************************************/
314 
315 template<typename Scalar, bool IsComplex>
317 {
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>
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>
343 {
344  typedef typename NumTraits<Scalar>::Real type;
345 };
346 
347 /****************************************************************************
348 * Implementation of hypot *
349 ****************************************************************************/
350 
351 template<typename Scalar> struct hypot_impl;
352 
353 template<typename Scalar>
355 {
356  typedef typename NumTraits<Scalar>::Real type;
357 };
358 
359 /****************************************************************************
360 * Implementation of cast *
361 ****************************************************************************/
362 
363 template<typename OldType, typename NewType>
364 struct cast_impl
365 {
366  EIGEN_DEVICE_FUNC
367  static inline NewType run(const OldType& x)
368  {
369  return static_cast<NewType>(x);
370  }
371 };
372 
373 // here, for once, we're plainly returning NewType: we don't want cast to do weird things.
374 
375 template<typename OldType, typename NewType>
376 EIGEN_DEVICE_FUNC
377 inline NewType cast(const OldType& x)
378 {
380 }
381 
382 /****************************************************************************
383 * Implementation of round *
384 ****************************************************************************/
385 
386 #if EIGEN_HAS_CXX11_MATH
387  template<typename Scalar>
388  struct round_impl {
389  static inline Scalar run(const Scalar& x)
390  {
391  EIGEN_STATIC_ASSERT((!NumTraits<Scalar>::IsComplex), NUMERIC_TYPE_MUST_BE_REAL)
392  using std::round;
393  return round(x);
394  }
395  };
396 #else
397  template<typename Scalar>
398  struct round_impl
399  {
400  static inline Scalar run(const Scalar& x)
401  {
402  EIGEN_STATIC_ASSERT((!NumTraits<Scalar>::IsComplex), NUMERIC_TYPE_MUST_BE_REAL)
403  EIGEN_USING_STD_MATH(floor);
404  EIGEN_USING_STD_MATH(ceil);
405  return (x > Scalar(0)) ? floor(x + Scalar(0.5)) : ceil(x - Scalar(0.5));
406  }
407  };
408 #endif
409 
410 template<typename Scalar>
412 {
413  typedef Scalar type;
414 };
415 
416 /****************************************************************************
417 * Implementation of arg *
418 ****************************************************************************/
419 
420 #if EIGEN_HAS_CXX11_MATH
421  template<typename Scalar>
422  struct arg_impl {
423  static inline Scalar run(const Scalar& x)
424  {
425  EIGEN_USING_STD_MATH(arg);
426  return arg(x);
427  }
428  };
429 #else
432  {
434  EIGEN_DEVICE_FUNC
435  static inline RealScalar run(const Scalar& x)
436  {
437  return (x < Scalar(0)) ? Scalar(EIGEN_PI) : Scalar(0); }
438  };
439 
440  template<typename Scalar>
442  {
444  EIGEN_DEVICE_FUNC
445  static inline RealScalar run(const Scalar& x)
446  {
447  EIGEN_USING_STD_MATH(arg);
448  return arg(x);
449  }
450  };
451 
452  template<typename Scalar> struct arg_impl : arg_default_impl<Scalar> {};
453 #endif
454 
455 template<typename Scalar>
457 {
458  typedef typename NumTraits<Scalar>::Real type;
459 };
460 
461 /****************************************************************************
462 * Implementation of log1p *
463 ****************************************************************************/
464 
465 namespace std_fallback {
466  // fallback log1p implementation in case there is no log1p(Scalar) function in namespace of Scalar,
467  // or that there is no suitable std::log1p function available
468  template<typename Scalar>
469  EIGEN_DEVICE_FUNC inline Scalar log1p(const Scalar& x) {
471  typedef typename NumTraits<Scalar>::Real RealScalar;
472  EIGEN_USING_STD_MATH(log);
473  Scalar x1p = RealScalar(1) + x;
474  return numext::equal_strict(x1p, Scalar(1)) ? x : x * ( log(x1p) / (x1p - RealScalar(1)) );
475  }
476 }
477 
478 template<typename Scalar>
479 struct log1p_impl {
480  static inline Scalar run(const Scalar& x)
481  {
483  #if EIGEN_HAS_CXX11_MATH
484  using std::log1p;
485  #endif
486  using std_fallback::log1p;
487  return log1p(x);
488  }
489 };
490 
491 
492 template<typename Scalar>
494 {
495  typedef Scalar type;
496 };
497 
498 /****************************************************************************
499 * Implementation of pow *
500 ****************************************************************************/
501 
502 template<typename ScalarX,typename ScalarY, bool IsInteger = NumTraits<ScalarX>::IsInteger&&NumTraits<ScalarY>::IsInteger>
503 struct pow_impl
504 {
505  //typedef Scalar retval;
507  static EIGEN_DEVICE_FUNC inline result_type run(const ScalarX& x, const ScalarY& y)
508  {
509  EIGEN_USING_STD_MATH(pow);
510  return pow(x, y);
511  }
512 };
513 
514 template<typename ScalarX,typename ScalarY>
515 struct pow_impl<ScalarX,ScalarY, true>
516 {
517  typedef ScalarX result_type;
518  static EIGEN_DEVICE_FUNC inline ScalarX run(ScalarX x, ScalarY y)
519  {
520  ScalarX res(1);
522  if(y & 1) res *= x;
523  y >>= 1;
524  while(y)
525  {
526  x *= x;
527  if(y&1) res *= x;
528  y >>= 1;
529  }
530  return res;
531  }
532 };
533 
534 /****************************************************************************
535 * Implementation of random *
536 ****************************************************************************/
537 
538 template<typename Scalar,
539  bool IsComplex,
540  bool IsInteger>
542 
543 template<typename Scalar>
544 struct random_impl : random_default_impl<Scalar, NumTraits<Scalar>::IsComplex, NumTraits<Scalar>::IsInteger> {};
545 
546 template<typename Scalar>
548 {
549  typedef Scalar type;
550 };
551 
552 template<typename Scalar> inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random(const Scalar& x, const Scalar& y);
553 template<typename Scalar> inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random();
554 
555 template<typename Scalar>
556 struct random_default_impl<Scalar, false, false>
557 {
558  static inline Scalar run(const Scalar& x, const Scalar& y)
559  {
560  return x + (y-x) * Scalar(std::rand()) / Scalar(RAND_MAX);
561  }
562  static inline Scalar run()
563  {
564  return run(Scalar(NumTraits<Scalar>::IsSigned ? -1 : 0), Scalar(1));
565  }
566 };
567 
568 enum {
573 };
574 
575 template<unsigned int n, int lower, int upper> struct meta_floor_log2_selector
576 {
577  enum { middle = (lower + upper) / 2,
579  : (n < (1 << middle)) ? int(meta_floor_log2_move_down)
580  : (n==0) ? int(meta_floor_log2_bogus)
582  };
583 };
584 
585 template<unsigned int n,
586  int lower = 0,
587  int upper = sizeof(unsigned int) * CHAR_BIT - 1,
589 struct meta_floor_log2 {};
590 
591 template<unsigned int n, int lower, int upper>
593 {
595 };
596 
597 template<unsigned int n, int lower, int upper>
598 struct meta_floor_log2<n, lower, upper, meta_floor_log2_move_up>
599 {
601 };
602 
603 template<unsigned int n, int lower, int upper>
605 {
606  enum { value = (n >= ((unsigned int)(1) << (lower+1))) ? lower+1 : lower };
607 };
608 
609 template<unsigned int n, int lower, int upper>
610 struct meta_floor_log2<n, lower, upper, meta_floor_log2_bogus>
611 {
612  // no value, error at compile time
613 };
614 
615 template<typename Scalar>
616 struct random_default_impl<Scalar, false, true>
617 {
618  static inline Scalar run(const Scalar& x, const Scalar& y)
619  {
620  if (y <= x)
621  return x;
622  // ScalarU is the unsigned counterpart of Scalar, possibly Scalar itself.
623  typedef typename make_unsigned<Scalar>::type ScalarU;
624  // ScalarX is the widest of ScalarU and unsigned int.
625  // We'll deal only with ScalarX and unsigned int below thus avoiding signed
626  // types and arithmetic and signed overflows (which are undefined behavior).
627  typedef typename conditional<(ScalarU(-1) > unsigned(-1)), ScalarU, unsigned>::type ScalarX;
628  // The following difference doesn't overflow, provided our integer types are two's
629  // complement and have the same number of padding bits in signed and unsigned variants.
630  // This is the case in most modern implementations of C++.
631  ScalarX range = ScalarX(y) - ScalarX(x);
632  ScalarX offset = 0;
633  ScalarX divisor = 1;
634  ScalarX multiplier = 1;
635  const unsigned rand_max = RAND_MAX;
636  if (range <= rand_max) divisor = (rand_max + 1) / (range + 1);
637  else multiplier = 1 + range / (rand_max + 1);
638  // Rejection sampling.
639  do {
640  offset = (unsigned(std::rand()) * multiplier) / divisor;
641  } while (offset > range);
642  return Scalar(ScalarX(x) + offset);
643  }
644 
645  static inline Scalar run()
646  {
647 #ifdef EIGEN_MAKING_DOCS
648  return run(Scalar(NumTraits<Scalar>::IsSigned ? -10 : 0), Scalar(10));
649 #else
651  scalar_bits = sizeof(Scalar) * CHAR_BIT,
652  shift = EIGEN_PLAIN_ENUM_MAX(0, int(rand_bits) - int(scalar_bits)),
653  offset = NumTraits<Scalar>::IsSigned ? (1 << (EIGEN_PLAIN_ENUM_MIN(rand_bits,scalar_bits)-1)) : 0
654  };
655  return Scalar((std::rand() >> shift) - offset);
656 #endif
657  }
658 };
659 
660 template<typename Scalar>
661 struct random_default_impl<Scalar, true, false>
662 {
663  static inline Scalar run(const Scalar& x, const Scalar& y)
664  {
665  return Scalar(random(real(x), real(y)),
666  random(imag(x), imag(y)));
667  }
668  static inline Scalar run()
669  {
670  typedef typename NumTraits<Scalar>::Real RealScalar;
671  return Scalar(random<RealScalar>(), random<RealScalar>());
672  }
673 };
674 
675 template<typename Scalar>
676 inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random(const Scalar& x, const Scalar& y)
677 {
678  return EIGEN_MATHFUNC_IMPL(random, Scalar)::run(x, y);
679 }
680 
681 template<typename Scalar>
683 {
684  return EIGEN_MATHFUNC_IMPL(random, Scalar)::run();
685 }
686 
687 // Implementatin of is* functions
688 
689 // std::is* do not work with fast-math and gcc, std::is* are available on MSVC 2013 and newer, as well as in clang.
690 #if (EIGEN_HAS_CXX11_MATH && !(EIGEN_COMP_GNUC_STRICT && __FINITE_MATH_ONLY__)) || (EIGEN_COMP_MSVC>=1800) || (EIGEN_COMP_CLANG)
691 #define EIGEN_USE_STD_FPCLASSIFY 1
692 #else
693 #define EIGEN_USE_STD_FPCLASSIFY 0
694 #endif
695 
696 template<typename T>
697 EIGEN_DEVICE_FUNC
699 isnan_impl(const T&) { return false; }
700 
701 template<typename T>
702 EIGEN_DEVICE_FUNC
703 typename internal::enable_if<internal::is_integral<T>::value,bool>::type
704 isinf_impl(const T&) { return false; }
705 
706 template<typename T>
707 EIGEN_DEVICE_FUNC
708 typename internal::enable_if<internal::is_integral<T>::value,bool>::type
709 isfinite_impl(const T&) { return true; }
710 
711 template<typename T>
712 EIGEN_DEVICE_FUNC
714 isfinite_impl(const T& x)
715 {
716  #ifdef __CUDA_ARCH__
717  return (::isfinite)(x);
718  #elif EIGEN_USE_STD_FPCLASSIFY
719  using std::isfinite;
720  return isfinite EIGEN_NOT_A_MACRO (x);
721  #else
722  return x<=NumTraits<T>::highest() && x>=NumTraits<T>::lowest();
723  #endif
724 }
725 
726 template<typename T>
727 EIGEN_DEVICE_FUNC
729 isinf_impl(const T& x)
730 {
731  #ifdef __CUDA_ARCH__
732  return (::isinf)(x);
733  #elif EIGEN_USE_STD_FPCLASSIFY
734  using std::isinf;
735  return isinf EIGEN_NOT_A_MACRO (x);
736  #else
737  return x>NumTraits<T>::highest() || x<NumTraits<T>::lowest();
738  #endif
739 }
740 
741 template<typename T>
742 EIGEN_DEVICE_FUNC
744 isnan_impl(const T& x)
745 {
746  #ifdef __CUDA_ARCH__
747  return (::isnan)(x);
748  #elif EIGEN_USE_STD_FPCLASSIFY
749  using std::isnan;
750  return isnan EIGEN_NOT_A_MACRO (x);
751  #else
752  return x != x;
753  #endif
754 }
755 
756 #if (!EIGEN_USE_STD_FPCLASSIFY)
757 
758 #if EIGEN_COMP_MSVC
759 
760 template<typename T> EIGEN_DEVICE_FUNC bool isinf_msvc_helper(T x)
761 {
762  return _fpclass(x)==_FPCLASS_NINF || _fpclass(x)==_FPCLASS_PINF;
763 }
764 
765 //MSVC defines a _isnan builtin function, but for double only
766 EIGEN_DEVICE_FUNC inline bool isnan_impl(const long double& x) { return _isnan(x)!=0; }
767 EIGEN_DEVICE_FUNC inline bool isnan_impl(const double& x) { return _isnan(x)!=0; }
768 EIGEN_DEVICE_FUNC inline bool isnan_impl(const float& x) { return _isnan(x)!=0; }
769 
770 EIGEN_DEVICE_FUNC inline bool isinf_impl(const long double& x) { return isinf_msvc_helper(x); }
771 EIGEN_DEVICE_FUNC inline bool isinf_impl(const double& x) { return isinf_msvc_helper(x); }
772 EIGEN_DEVICE_FUNC inline bool isinf_impl(const float& x) { return isinf_msvc_helper(x); }
773 
774 #elif (defined __FINITE_MATH_ONLY__ && __FINITE_MATH_ONLY__ && EIGEN_COMP_GNUC)
775 
776 #if EIGEN_GNUC_AT_LEAST(5,0)
777  #define EIGEN_TMP_NOOPT_ATTRIB EIGEN_DEVICE_FUNC inline __attribute__((optimize("no-finite-math-only")))
778 #else
779  // NOTE the inline qualifier and noinline attribute are both needed: the former is to avoid linking issue (duplicate symbol),
780  // while the second prevent too aggressive optimizations in fast-math mode:
781  #define EIGEN_TMP_NOOPT_ATTRIB EIGEN_DEVICE_FUNC inline __attribute__((noinline,optimize("no-finite-math-only")))
782 #endif
783 
784 template<> EIGEN_TMP_NOOPT_ATTRIB bool isnan_impl(const long double& x) { return __builtin_isnan(x); }
785 template<> EIGEN_TMP_NOOPT_ATTRIB bool isnan_impl(const double& x) { return __builtin_isnan(x); }
786 template<> EIGEN_TMP_NOOPT_ATTRIB bool isnan_impl(const float& x) { return __builtin_isnan(x); }
787 template<> EIGEN_TMP_NOOPT_ATTRIB bool isinf_impl(const double& x) { return __builtin_isinf(x); }
788 template<> EIGEN_TMP_NOOPT_ATTRIB bool isinf_impl(const float& x) { return __builtin_isinf(x); }
789 template<> EIGEN_TMP_NOOPT_ATTRIB bool isinf_impl(const long double& x) { return __builtin_isinf(x); }
790 
791 #undef EIGEN_TMP_NOOPT_ATTRIB
792 
793 #endif
794 
795 #endif
796 
797 // The following overload are defined at the end of this file
798 template<typename T> EIGEN_DEVICE_FUNC bool isfinite_impl(const std::complex<T>& x);
799 template<typename T> EIGEN_DEVICE_FUNC bool isnan_impl(const std::complex<T>& x);
800 template<typename T> EIGEN_DEVICE_FUNC bool isinf_impl(const std::complex<T>& x);
801 
802 template<typename T> T generic_fast_tanh_float(const T& a_x);
803 
804 } // end namespace internal
805 
806 /****************************************************************************
807 * Generic math functions *
808 ****************************************************************************/
809 
810 namespace numext {
811 
812 #ifndef __CUDA_ARCH__
813 template<typename T>
814 EIGEN_DEVICE_FUNC
815 EIGEN_ALWAYS_INLINE T mini(const T& x, const T& y)
816 {
817  EIGEN_USING_STD_MATH(min);
818  return min EIGEN_NOT_A_MACRO (x,y);
819 }
820 
821 template<typename T>
822 EIGEN_DEVICE_FUNC
823 EIGEN_ALWAYS_INLINE T maxi(const T& x, const T& y)
824 {
825  EIGEN_USING_STD_MATH(max);
826  return max EIGEN_NOT_A_MACRO (x,y);
827 }
828 #else
829 template<typename T>
830 EIGEN_DEVICE_FUNC
831 EIGEN_ALWAYS_INLINE T mini(const T& x, const T& y)
832 {
833  return y < x ? y : x;
834 }
835 template<>
836 EIGEN_DEVICE_FUNC
837 EIGEN_ALWAYS_INLINE float mini(const float& x, const float& y)
838 {
839  return fminf(x, y);
840 }
841 template<typename T>
842 EIGEN_DEVICE_FUNC
843 EIGEN_ALWAYS_INLINE T maxi(const T& x, const T& y)
844 {
845  return x < y ? y : x;
846 }
847 template<>
848 EIGEN_DEVICE_FUNC
849 EIGEN_ALWAYS_INLINE float maxi(const float& x, const float& y)
850 {
851  return fmaxf(x, y);
852 }
853 #endif
854 
855 
856 template<typename Scalar>
857 EIGEN_DEVICE_FUNC
859 {
860  return EIGEN_MATHFUNC_IMPL(real, Scalar)::run(x);
861 }
862 
863 template<typename Scalar>
864 EIGEN_DEVICE_FUNC
866 {
868 }
869 
870 template<typename Scalar>
871 EIGEN_DEVICE_FUNC
873 {
874  return EIGEN_MATHFUNC_IMPL(real_ref, Scalar)::run(x);
875 }
876 
877 template<typename Scalar>
878 EIGEN_DEVICE_FUNC
880 {
881  return EIGEN_MATHFUNC_IMPL(imag, Scalar)::run(x);
882 }
883 
884 template<typename Scalar>
885 EIGEN_DEVICE_FUNC
887 {
888  return EIGEN_MATHFUNC_IMPL(arg, Scalar)::run(x);
889 }
890 
891 template<typename Scalar>
892 EIGEN_DEVICE_FUNC
894 {
896 }
897 
898 template<typename Scalar>
899 EIGEN_DEVICE_FUNC
901 {
902  return EIGEN_MATHFUNC_IMPL(imag_ref, Scalar)::run(x);
903 }
904 
905 template<typename Scalar>
906 EIGEN_DEVICE_FUNC
908 {
909  return EIGEN_MATHFUNC_IMPL(conj, Scalar)::run(x);
910 }
911 
912 template<typename Scalar>
913 EIGEN_DEVICE_FUNC
915 {
916  return EIGEN_MATHFUNC_IMPL(abs2, Scalar)::run(x);
917 }
918 
919 template<typename Scalar>
920 EIGEN_DEVICE_FUNC
921 inline EIGEN_MATHFUNC_RETVAL(norm1, Scalar) norm1(const Scalar& x)
922 {
923  return EIGEN_MATHFUNC_IMPL(norm1, Scalar)::run(x);
924 }
925 
926 template<typename Scalar>
927 EIGEN_DEVICE_FUNC
928 inline EIGEN_MATHFUNC_RETVAL(hypot, Scalar) hypot(const Scalar& x, const Scalar& y)
929 {
930  return EIGEN_MATHFUNC_IMPL(hypot, Scalar)::run(x, y);
931 }
932 
933 template<typename Scalar>
934 EIGEN_DEVICE_FUNC
936 {
937  return EIGEN_MATHFUNC_IMPL(log1p, Scalar)::run(x);
938 }
939 
940 #ifdef __CUDACC__
941 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
942 float log1p(const float &x) { return ::log1pf(x); }
943 
944 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
945 double log1p(const double &x) { return ::log1p(x); }
946 #endif
947 
948 template<typename ScalarX,typename ScalarY>
949 EIGEN_DEVICE_FUNC
950 inline typename internal::pow_impl<ScalarX,ScalarY>::result_type pow(const ScalarX& x, const ScalarY& y)
951 {
953 }
954 
955 template<typename T> EIGEN_DEVICE_FUNC bool (isnan) (const T &x) { return internal::isnan_impl(x); }
956 template<typename T> EIGEN_DEVICE_FUNC bool (isinf) (const T &x) { return internal::isinf_impl(x); }
957 template<typename T> EIGEN_DEVICE_FUNC bool (isfinite)(const T &x) { return internal::isfinite_impl(x); }
958 
959 template<typename Scalar>
960 EIGEN_DEVICE_FUNC
962 {
963  return EIGEN_MATHFUNC_IMPL(round, Scalar)::run(x);
964 }
965 
966 template<typename T>
967 EIGEN_DEVICE_FUNC
968 T (floor)(const T& x)
969 {
970  EIGEN_USING_STD_MATH(floor);
971  return floor(x);
972 }
973 
974 #ifdef __CUDACC__
975 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
976 float floor(const float &x) { return ::floorf(x); }
977 
978 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
979 double floor(const double &x) { return ::floor(x); }
980 #endif
981 
982 template<typename T>
983 EIGEN_DEVICE_FUNC
984 T (ceil)(const T& x)
985 {
986  EIGEN_USING_STD_MATH(ceil);
987  return ceil(x);
988 }
989 
990 #ifdef __CUDACC__
991 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
992 float ceil(const float &x) { return ::ceilf(x); }
993 
994 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
995 double ceil(const double &x) { return ::ceil(x); }
996 #endif
997 
998 
1001 inline int log2(int x)
1002 {
1003  eigen_assert(x>=0);
1004  unsigned int v(x);
1005  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 };
1006  v |= v >> 1;
1007  v |= v >> 2;
1008  v |= v >> 4;
1009  v |= v >> 8;
1010  v |= v >> 16;
1011  return table[(v * 0x07C4ACDDU) >> 27];
1012 }
1013 
1023 template<typename T>
1024 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1025 T sqrt(const T &x)
1026 {
1027  EIGEN_USING_STD_MATH(sqrt);
1028  return sqrt(x);
1029 }
1030 
1031 template<typename T>
1032 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1033 T log(const T &x) {
1034  EIGEN_USING_STD_MATH(log);
1035  return log(x);
1036 }
1037 
1038 #ifdef __CUDACC__
1039 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1040 float log(const float &x) { return ::logf(x); }
1041 
1042 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1043 double log(const double &x) { return ::log(x); }
1044 #endif
1045 
1046 template<typename T>
1047 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1049 abs(const T &x) {
1050  EIGEN_USING_STD_MATH(abs);
1051  return abs(x);
1052 }
1053 
1054 template<typename T>
1055 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1057 abs(const T &x) {
1058  return x;
1059 }
1060 
1061 #if defined(__SYCL_DEVICE_ONLY__)
1062 EIGEN_ALWAYS_INLINE float abs(float x) { return cl::sycl::fabs(x); }
1063 EIGEN_ALWAYS_INLINE double abs(double x) { return cl::sycl::fabs(x); }
1064 #endif // defined(__SYCL_DEVICE_ONLY__)
1065 
1066 #ifdef __CUDACC__
1067 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1068 float abs(const float &x) { return ::fabsf(x); }
1069 
1070 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1071 double abs(const double &x) { return ::fabs(x); }
1072 
1073 template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1074 float abs(const std::complex<float>& x) {
1075  return ::hypotf(x.real(), x.imag());
1076 }
1077 
1078 template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1079 double abs(const std::complex<double>& x) {
1080  return ::hypot(x.real(), x.imag());
1081 }
1082 #endif
1083 
1084 template<typename T>
1085 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1086 T exp(const T &x) {
1087  EIGEN_USING_STD_MATH(exp);
1088  return exp(x);
1089 }
1090 
1091 #ifdef __CUDACC__
1092 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1093 float exp(const float &x) { return ::expf(x); }
1094 
1095 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1096 double exp(const double &x) { return ::exp(x); }
1097 #endif
1098 
1099 template<typename T>
1100 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1101 T cos(const T &x) {
1102  EIGEN_USING_STD_MATH(cos);
1103  return cos(x);
1104 }
1105 
1106 #ifdef __CUDACC__
1107 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1108 float cos(const float &x) { return ::cosf(x); }
1109 
1110 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1111 double cos(const double &x) { return ::cos(x); }
1112 #endif
1113 
1114 template<typename T>
1115 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1116 T sin(const T &x) {
1117  EIGEN_USING_STD_MATH(sin);
1118  return sin(x);
1119 }
1120 
1121 #ifdef __CUDACC__
1122 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1123 float sin(const float &x) { return ::sinf(x); }
1124 
1125 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1126 double sin(const double &x) { return ::sin(x); }
1127 #endif
1128 
1129 template<typename T>
1130 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1131 T tan(const T &x) {
1132  EIGEN_USING_STD_MATH(tan);
1133  return tan(x);
1134 }
1135 
1136 #ifdef __CUDACC__
1137 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1138 float tan(const float &x) { return ::tanf(x); }
1139 
1140 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1141 double tan(const double &x) { return ::tan(x); }
1142 #endif
1143 
1144 template<typename T>
1145 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1146 T acos(const T &x) {
1147  EIGEN_USING_STD_MATH(acos);
1148  return acos(x);
1149 }
1150 
1151 #ifdef __CUDACC__
1152 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1153 float acos(const float &x) { return ::acosf(x); }
1154 
1155 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1156 double acos(const double &x) { return ::acos(x); }
1157 #endif
1158 
1159 template<typename T>
1160 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1161 T asin(const T &x) {
1162  EIGEN_USING_STD_MATH(asin);
1163  return asin(x);
1164 }
1165 
1166 #ifdef __CUDACC__
1167 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1168 float asin(const float &x) { return ::asinf(x); }
1169 
1170 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1171 double asin(const double &x) { return ::asin(x); }
1172 #endif
1173 
1174 template<typename T>
1175 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1176 T atan(const T &x) {
1177  EIGEN_USING_STD_MATH(atan);
1178  return atan(x);
1179 }
1180 
1181 #ifdef __CUDACC__
1182 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1183 float atan(const float &x) { return ::atanf(x); }
1184 
1185 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1186 double atan(const double &x) { return ::atan(x); }
1187 #endif
1188 
1189 
1190 template<typename T>
1191 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1192 T cosh(const T &x) {
1193  EIGEN_USING_STD_MATH(cosh);
1194  return cosh(x);
1195 }
1196 
1197 #ifdef __CUDACC__
1198 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1199 float cosh(const float &x) { return ::coshf(x); }
1200 
1201 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1202 double cosh(const double &x) { return ::cosh(x); }
1203 #endif
1204 
1205 template<typename T>
1206 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1207 T sinh(const T &x) {
1208  EIGEN_USING_STD_MATH(sinh);
1209  return sinh(x);
1210 }
1211 
1212 #ifdef __CUDACC__
1213 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1214 float sinh(const float &x) { return ::sinhf(x); }
1215 
1216 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1217 double sinh(const double &x) { return ::sinh(x); }
1218 #endif
1219 
1220 template<typename T>
1221 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1222 T tanh(const T &x) {
1223  EIGEN_USING_STD_MATH(tanh);
1224  return tanh(x);
1225 }
1226 
1227 #if (!defined(__CUDACC__)) && EIGEN_FAST_MATH
1228 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1229 float tanh(float x) { return internal::generic_fast_tanh_float(x); }
1230 #endif
1231 
1232 #ifdef __CUDACC__
1233 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1234 float tanh(const float &x) { return ::tanhf(x); }
1235 
1236 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1237 double tanh(const double &x) { return ::tanh(x); }
1238 #endif
1239 
1240 template <typename T>
1241 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1242 T fmod(const T& a, const T& b) {
1243  EIGEN_USING_STD_MATH(fmod);
1244  return fmod(a, b);
1245 }
1246 
1247 #ifdef __CUDACC__
1248 template <>
1249 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1250 float fmod(const float& a, const float& b) {
1251  return ::fmodf(a, b);
1252 }
1253 
1254 template <>
1255 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1256 double fmod(const double& a, const double& b) {
1257  return ::fmod(a, b);
1258 }
1259 #endif
1260 
1261 } // end namespace numext
1262 
1263 namespace internal {
1264 
1265 template<typename T>
1266 EIGEN_DEVICE_FUNC bool isfinite_impl(const std::complex<T>& x)
1267 {
1269 }
1270 
1271 template<typename T>
1272 EIGEN_DEVICE_FUNC bool isnan_impl(const std::complex<T>& x)
1273 {
1274  return (numext::isnan)(numext::real(x)) || (numext::isnan)(numext::imag(x));
1275 }
1276 
1277 template<typename T>
1278 EIGEN_DEVICE_FUNC bool isinf_impl(const std::complex<T>& x)
1279 {
1280  return ((numext::isinf)(numext::real(x)) || (numext::isinf)(numext::imag(x))) && (!(numext::isnan)(x));
1281 }
1282 
1283 /****************************************************************************
1284 * Implementation of fuzzy comparisons *
1285 ****************************************************************************/
1286 
1287 template<typename Scalar,
1288  bool IsComplex,
1289  bool IsInteger>
1291 
1292 template<typename Scalar>
1293 struct scalar_fuzzy_default_impl<Scalar, false, false>
1294 {
1296  template<typename OtherScalar> EIGEN_DEVICE_FUNC
1297  static inline bool isMuchSmallerThan(const Scalar& x, const OtherScalar& y, const RealScalar& prec)
1298  {
1299  return numext::abs(x) <= numext::abs(y) * prec;
1300  }
1301  EIGEN_DEVICE_FUNC
1302  static inline bool isApprox(const Scalar& x, const Scalar& y, const RealScalar& prec)
1303  {
1304  return numext::abs(x - y) <= numext::mini(numext::abs(x), numext::abs(y)) * prec;
1305  }
1306  EIGEN_DEVICE_FUNC
1307  static inline bool isApproxOrLessThan(const Scalar& x, const Scalar& y, const RealScalar& prec)
1308  {
1309  return x <= y || isApprox(x, y, prec);
1310  }
1311 };
1312 
1313 template<typename Scalar>
1314 struct scalar_fuzzy_default_impl<Scalar, false, true>
1315 {
1317  template<typename OtherScalar> EIGEN_DEVICE_FUNC
1318  static inline bool isMuchSmallerThan(const Scalar& x, const Scalar&, const RealScalar&)
1319  {
1320  return x == Scalar(0);
1321  }
1322  EIGEN_DEVICE_FUNC
1323  static inline bool isApprox(const Scalar& x, const Scalar& y, const RealScalar&)
1324  {
1325  return x == y;
1326  }
1327  EIGEN_DEVICE_FUNC
1328  static inline bool isApproxOrLessThan(const Scalar& x, const Scalar& y, const RealScalar&)
1329  {
1330  return x <= y;
1331  }
1332 };
1333 
1334 template<typename Scalar>
1335 struct scalar_fuzzy_default_impl<Scalar, true, false>
1336 {
1338  template<typename OtherScalar> EIGEN_DEVICE_FUNC
1339  static inline bool isMuchSmallerThan(const Scalar& x, const OtherScalar& y, const RealScalar& prec)
1340  {
1341  return numext::abs2(x) <= numext::abs2(y) * prec * prec;
1342  }
1343  EIGEN_DEVICE_FUNC
1344  static inline bool isApprox(const Scalar& x, const Scalar& y, const RealScalar& prec)
1345  {
1346  return numext::abs2(x - y) <= numext::mini(numext::abs2(x), numext::abs2(y)) * prec * prec;
1347  }
1348 };
1349 
1350 template<typename Scalar>
1351 struct scalar_fuzzy_impl : scalar_fuzzy_default_impl<Scalar, NumTraits<Scalar>::IsComplex, NumTraits<Scalar>::IsInteger> {};
1352 
1353 template<typename Scalar, typename OtherScalar> EIGEN_DEVICE_FUNC
1354 inline bool isMuchSmallerThan(const Scalar& x, const OtherScalar& y,
1356 {
1357  return scalar_fuzzy_impl<Scalar>::template isMuchSmallerThan<OtherScalar>(x, y, precision);
1358 }
1359 
1360 template<typename Scalar> EIGEN_DEVICE_FUNC
1361 inline bool isApprox(const Scalar& x, const Scalar& y,
1363 {
1365 }
1366 
1367 template<typename Scalar> EIGEN_DEVICE_FUNC
1368 inline bool isApproxOrLessThan(const Scalar& x, const Scalar& y,
1370 {
1372 }
1373 
1374 /******************************************
1375 *** The special case of the bool type ***
1376 ******************************************/
1377 
1378 template<> struct random_impl<bool>
1379 {
1380  static inline bool run()
1381  {
1382  return random<int>(0,1)==0 ? false : true;
1383  }
1384 };
1385 
1386 template<> struct scalar_fuzzy_impl<bool>
1387 {
1388  typedef bool RealScalar;
1389 
1390  template<typename OtherScalar> EIGEN_DEVICE_FUNC
1391  static inline bool isMuchSmallerThan(const bool& x, const bool&, const bool&)
1392  {
1393  return !x;
1394  }
1395 
1396  EIGEN_DEVICE_FUNC
1397  static inline bool isApprox(bool x, bool y, bool)
1398  {
1399  return x == y;
1400  }
1401 
1402  EIGEN_DEVICE_FUNC
1403  static inline bool isApproxOrLessThan(const bool& x, const bool& y, const bool&)
1404  {
1405  return (!x) || y;
1406  }
1407 
1408 };
1409 
1410 
1411 } // end namespace internal
1412 
1413 } // end namespace Eigen
1414 
1415 #endif // EIGEN_MATHFUNCTIONS_H
static EIGEN_DEVICE_FUNC bool isMuchSmallerThan(const Scalar &x, const OtherScalar &y, const RealScalar &prec)
#define EIGEN_ALWAYS_INLINE
Definition: Macros.h:509
SCALAR Scalar
Definition: bench_gemm.cpp:33
static Scalar run(const Scalar &x)
static EIGEN_DEVICE_FUNC RealScalar run(const Scalar &x)
#define max(a, b)
Definition: datatypes.h:20
EIGEN_DEVICE_FUNC bool isMuchSmallerThan(const Scalar &x, const OtherScalar &y, const typename NumTraits< Scalar >::Real &precision=NumTraits< Scalar >::dummy_precision())
const AutoDiffScalar< DerType > & conj(const AutoDiffScalar< DerType > &x)
static EIGEN_DEVICE_FUNC RealScalar & run(Scalar &x)
EIGEN_DEVICE_FUNC internal::add_const_on_value_type< EIGEN_MATHFUNC_RETVAL(real_ref, Scalar) >::type real_ref(const Scalar &x)
#define EIGEN_NOT_A_MACRO
Definition: Macros.h:327
float real
Definition: datatypes.h:10
static char lower
static EIGEN_DEVICE_FUNC Scalar run(const Scalar &x)
static EIGEN_DEVICE_FUNC RealScalar run(const Scalar &x)
Scalar * b
Definition: benchVecAdd.cpp:17
static EIGEN_DEVICE_FUNC const RealScalar & run(const Scalar &x)
static EIGEN_DEVICE_FUNC bool isApproxOrLessThan(const bool &x, const bool &y, const bool &)
EIGEN_DEVICE_FUNC bool() isfinite(const T &x)
return int(ret)+1
#define EIGEN_PI
EIGEN_DEVICE_FUNC const ExpReturnType exp() const
#define min(a, b)
Definition: datatypes.h:19
static EIGEN_DEVICE_FUNC bool isApprox(bool x, bool y, bool)
static Scalar run(const Scalar &x)
ArrayXcf v
Definition: Cwise_arg.cpp:1
EIGEN_DEVICE_FUNC internal::enable_if< internal::is_integral< T >::value, bool >::type isnan_impl(const T &)
int n
EIGEN_DEVICE_FUNC const TanhReturnType tanh() const
EIGEN_DEVICE_FUNC const LogReturnType log() const
#define EIGEN_PLAIN_ENUM_MAX(a, b)
Definition: Macros.h:876
set noclip points set clip one set noclip two set bar set border lt lw set xdata set ydata set zdata set x2data set y2data set boxwidth set dummy y set format x g set format y g set format x2 g set format y2 g set format z g set angles radians set nogrid set key title set key left top Right noreverse box linetype linewidth samplen spacing width set nolabel set noarrow set nologscale set logscale x set set pointsize set encoding default set nopolar set noparametric set set set set surface set nocontour set clabel set mapping cartesian set nohidden3d set cntrparam order set cntrparam linear set cntrparam levels auto set cntrparam points set size set set xzeroaxis lt lw set x2zeroaxis lt lw set yzeroaxis lt lw set y2zeroaxis lt lw set tics in set ticslevel set tics set mxtics default set mytics default set mx2tics default set my2tics default set xtics border mirror norotate autofreq set ytics border mirror norotate autofreq set ztics border nomirror norotate autofreq set nox2tics set noy2tics set timestamp bottom norotate offset
EIGEN_DEVICE_FUNC const SqrtReturnType sqrt() const
EIGEN_DEVICE_FUNC const CoshReturnType cosh() const
Namespace containing all symbols from the Eigen library.
Definition: jet.h:637
DerType::Scalar imag(const AutoDiffScalar< DerType > &)
static EIGEN_DEVICE_FUNC bool isApprox(const Scalar &x, const Scalar &y, const RealScalar &prec)
Holds information about the various numeric (i.e. scalar) types allowed by Eigen. ...
Definition: NumTraits.h:150
T generic_fast_tanh_float(const T &a_x)
#define EIGEN_STATIC_ASSERT(CONDITION, MSG)
Definition: StaticAssert.h:124
static EIGEN_DEVICE_FUNC const RealScalar & run(const Scalar &x)
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T maxi(const T &x, const T &y)
#define isfinite(X)
Definition: main.h:74
static EIGEN_DEVICE_FUNC RealScalar run(const Scalar &x)
static EIGEN_DEVICE_FUNC RealScalar run(const Scalar &)
#define isinf(X)
Definition: main.h:73
Definition: cast.h:1853
static EIGEN_DEVICE_FUNC RealScalar run(const Scalar &x)
EIGEN_DEVICE_FUNC internal::enable_if< internal::is_integral< T >::value, bool >::type isfinite_impl(const T &)
Real fabs(const Real &a)
static EIGEN_DEVICE_FUNC bool isApprox(const Scalar &x, const Scalar &y, const RealScalar &)
static EIGEN_DEVICE_FUNC RealScalar run(const Scalar &x)
Array33i a
static EIGEN_DEVICE_FUNC RealScalar & run(Scalar &x)
static EIGEN_DEVICE_FUNC RealScalar run(const Scalar &x)
cout<< "Here is the matrix m:"<< endl<< m<< endl;Matrix< ptrdiff_t, 3, 1 > res
EIGEN_DEVICE_FUNC const RoundReturnType round() const
EIGEN_DEVICE_FUNC const CosReturnType cos() const
EIGEN_DEVICE_FUNC const CeilReturnType ceil() const
EIGEN_STRONG_INLINE bool equal_strict(const X &x, const Y &y)
Definition: Meta.h:513
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE internal::enable_if< NumTraits< T >::IsSigned||NumTraits< T >::IsComplex, typename NumTraits< T >::Real >::type abs(const T &x)
static EIGEN_DEVICE_FUNC bool isMuchSmallerThan(const bool &x, const bool &, const bool &)
EIGEN_DEVICE_FUNC const Log1pReturnType log1p() const
static EIGEN_DEVICE_FUNC Scalar run(const Scalar &x)
static EIGEN_DEVICE_FUNC result_type run(const ScalarX &x, const ScalarY &y)
EIGEN_DEVICE_FUNC const SinhReturnType sinh() const
static EIGEN_DEVICE_FUNC Scalar run(const Scalar &x)
static EIGEN_DEVICE_FUNC ScalarX run(ScalarX x, ScalarY y)
static EIGEN_DEVICE_FUNC NewType run(const OldType &x)
#define eigen_assert(x)
Definition: Macros.h:579
static EIGEN_DEVICE_FUNC RealScalar run(const Scalar &x)
EIGEN_DEVICE_FUNC NewType cast(const OldType &x)
Eigen::Triplet< double > T
EIGEN_DEVICE_FUNC Scalar log1p(const Scalar &x)
static EIGEN_DEVICE_FUNC bool isApprox(const Scalar &x, const Scalar &y, const RealScalar &prec)
EIGEN_DEVICE_FUNC const AtanReturnType atan() const
NumTraits< Scalar >::Real RealScalar
EIGEN_DEVICE_FUNC internal::add_const_on_value_type< EIGEN_MATHFUNC_RETVAL(imag_ref, Scalar) >::type imag_ref(const Scalar &x)
#define EIGEN_STATIC_ASSERT_NON_INTEGER(TYPE)
Definition: StaticAssert.h:184
static EIGEN_DEVICE_FUNC bool isMuchSmallerThan(const Scalar &x, const OtherScalar &y, const RealScalar &prec)
static EIGEN_DEVICE_FUNC bool isMuchSmallerThan(const Scalar &x, const Scalar &, const RealScalar &)
EIGEN_DEVICE_FUNC bool() isnan(const T &x)
ScalarBinaryOpTraits< ScalarX, ScalarY, internal::scalar_pow_op< ScalarX, ScalarY > >::ReturnType result_type
EIGEN_DEVICE_FUNC const TanReturnType tan() const
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE internal::enable_if<!(NumTraits< T >::IsSigned||NumTraits< T >::IsComplex), typename NumTraits< T >::Real >::type abs(const T &x)
EIGEN_DEVICE_FUNC bool() isinf(const T &x)
NumTraits< Scalar >::Real RealScalar
Definition: bench_gemm.cpp:34
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T mini(const T &x, const T &y)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Abs2ReturnType abs2() const
EIGEN_DEVICE_FUNC internal::pow_impl< ScalarX, ScalarY >::result_type pow(const ScalarX &x, const ScalarY &y)
EIGEN_DEVICE_FUNC const AcosReturnType acos() const
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const ArgReturnType arg() const
EIGEN_DEVICE_FUNC internal::enable_if< internal::is_integral< T >::value, bool >::type isinf_impl(const T &)
const mpreal hypot(const mpreal &x, const mpreal &y, mp_rnd_t rnd_mode=mpreal::get_default_rnd())
Definition: mpreal.h:2280
EIGEN_DEVICE_FUNC const FloorReturnType floor() const
ArrayXXf table(10, 4)
#define EIGEN_PLAIN_ENUM_MIN(a, b)
Definition: Macros.h:875
cout precision(2)
static constexpr int log2(size_t n, int k=0)
static EIGEN_DEVICE_FUNC bool isApproxOrLessThan(const Scalar &x, const Scalar &y, const RealScalar &prec)
const mpreal random(unsigned int seed=0)
Definition: mpreal.h:2614
static EIGEN_DEVICE_FUNC RealScalar run(const Scalar &x)
EIGEN_DEVICE_FUNC const ImagReturnType imag() const
Determines whether the given binary operation of two numeric types is allowed and what the scalar ret...
Definition: XprHelper.h:766
EIGEN_DEVICE_FUNC const SinReturnType sin() const
static EIGEN_DEVICE_FUNC const Scalar run(const Scalar &)
EIGEN_DEVICE_FUNC bool isApprox(const Scalar &x, const Scalar &y, const typename NumTraits< Scalar >::Real &precision=NumTraits< Scalar >::dummy_precision())
EIGEN_DEVICE_FUNC bool isApproxOrLessThan(const Scalar &x, const Scalar &y, const typename NumTraits< Scalar >::Real &precision=NumTraits< Scalar >::dummy_precision())
void run(Expr &expr, Dev &dev)
Definition: TensorSyclRun.h:33
set noclip points set clip one set noclip two set bar set border lt lw set xdata set ydata set zdata set x2data set y2data set boxwidth set dummy x
const AutoDiffScalar< DerType > & real(const AutoDiffScalar< DerType > &x)
#define EIGEN_MATHFUNC_IMPL(func, scalar)
static EIGEN_DEVICE_FUNC bool isApproxOrLessThan(const Scalar &x, const Scalar &y, const RealScalar &)
static EIGEN_DEVICE_FUNC RealScalar run(const Scalar &x)
EIGEN_MATHFUNC_RETVAL(random, Scalar) random(const Scalar &x
EIGEN_DEVICE_FUNC const AsinReturnType asin() const
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T fmod(const T &a, const T &b)
#define isnan(X)
Definition: main.h:72
ScalarWithExceptions conj(const ScalarWithExceptions &x)
Definition: exceptions.cpp:74
Definition: pytypes.h:897


gtsam
Author(s):
autogenerated on Sat May 8 2021 02:42:46