Rename free functions isFinite, isInf, isNaN to be compatible with c++11

7 files changed, 77 insertions, 93 deletions

diff --git a/Eigen/src/Core/GlobalFunctions.h b/Eigen/src/Core/GlobalFunctions.h
index 1924c8e5f..33151a0de 100644
--- a/Eigen/src/Core/GlobalFunctions.h
+++ b/Eigen/src/Core/GlobalFunctions.h
@@ -62,9 +62,9 @@ namespace Eigen
   EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(round,scalar_round_op)
   EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(floor,scalar_floor_op)
   EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(ceil,scalar_ceil_op)
-  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(isNaN,scalar_isNaN_op)
-  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(isInf,scalar_isInf_op)
-  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(isFinite,scalar_isFinite_op)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(isnan,scalar_isnan_op)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(isinf,scalar_isinf_op)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(isfinite,scalar_isfinite_op)
   
   template<typename Derived>
   inline const Eigen::CwiseUnaryOp<Eigen::internal::scalar_pow_op<typename Derived::Scalar>, const Derived>
diff --git a/Eigen/src/Core/MathFunctions.h b/Eigen/src/Core/MathFunctions.h
index 1ce935909..dfdca4f94 100644
--- a/Eigen/src/Core/MathFunctions.h
+++ b/Eigen/src/Core/MathFunctions.h
@@ -803,14 +803,12 @@ template<typename T>
 EIGEN_DEVICE_FUNC
 bool (isfinite)(const std::complex<T>& x)
 {
-  using std::real;
-  using std::imag;
-  return isfinite(real(x)) && isfinite(imag(x));
+  return numext::isfinite(numext::real(x)) && numext::isfinite(numext::imag(x));
 }
 
 template<typename T>
 EIGEN_DEVICE_FUNC
-bool (isNaN)(const T& x)
+bool (isnan)(const T& x)
 {
   #ifdef EIGEN_HAS_C99_MATH
     using std::isnan;
@@ -822,17 +820,14 @@ bool (isNaN)(const T& x)
 
 template<typename T>
 EIGEN_DEVICE_FUNC
-bool (isNaN)(const std::complex<T>& x)
+bool (isnan)(const std::complex<T>& x)
 {
-  using std::real;
-  using std::imag;
-  using std::isnan;
-  return isnan(real(x)) || isnan(imag(x));
+  return numext::isnan(numext::real(x)) || numext::isnan(numext::imag(x));
 }
 
 template<typename T>
 EIGEN_DEVICE_FUNC
-bool (isInf)(const T& x)
+bool (isinf)(const T& x)
 {
   #ifdef EIGEN_HAS_C99_MATH
     using std::isinf;
@@ -844,12 +839,9 @@ bool (isInf)(const T& x)
 
 template<typename T>
 EIGEN_DEVICE_FUNC
-bool (isInf)(const std::complex<T>& x)
+bool (isinf)(const std::complex<T>& x)
 {
-  using std::real;
-  using std::imag;
-  using std::isinf;
-  return isinf(real(x)) || isinf(imag(x));
+  return numext::isinf(numext::real(x)) || numext::isinf(numext::imag(x));
 }
 
 template<typename Scalar>
diff --git a/Eigen/src/Core/functors/UnaryFunctors.h b/Eigen/src/Core/functors/UnaryFunctors.h
index a6fa5ee31..2fc84e01f 100644
--- a/Eigen/src/Core/functors/UnaryFunctors.h
+++ b/Eigen/src/Core/functors/UnaryFunctors.h
@@ -586,15 +586,15 @@ struct functor_traits<scalar_ceil_op<Scalar> >
 
 /** \internal
   * \brief Template functor to compute whether a scalar is NaN
-  * \sa class CwiseUnaryOp, ArrayBase::isNaN()
+  * \sa class CwiseUnaryOp, ArrayBase::isnan()
   */
-template<typename Scalar> struct scalar_isNaN_op {
-  EIGEN_EMPTY_STRUCT_CTOR(scalar_isNaN_op)
+template<typename Scalar> struct scalar_isnan_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_isnan_op)
   typedef bool result_type;
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type operator() (const Scalar& a) const { return numext::isNaN(a); }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type operator() (const Scalar& a) const { return numext::isnan(a); }
 };
 template<typename Scalar>
-struct functor_traits<scalar_isNaN_op<Scalar> >
+struct functor_traits<scalar_isnan_op<Scalar> >
 {
   enum {
     Cost = NumTraits<Scalar>::MulCost,
@@ -603,16 +603,16 @@ struct functor_traits<scalar_isNaN_op<Scalar> >
 };
 
 /** \internal
-  * \brief Template functor to compute the isInf of a scalar
-  * \sa class CwiseUnaryOp, ArrayBase::isInf()
+  * \brief Template functor to check whether a scalar is +/-inf
+  * \sa class CwiseUnaryOp, ArrayBase::isinf()
   */
-template<typename Scalar> struct scalar_isInf_op {
-  EIGEN_EMPTY_STRUCT_CTOR(scalar_isInf_op)
+template<typename Scalar> struct scalar_isinf_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_isinf_op)
   typedef bool result_type;
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type operator() (const Scalar& a) const { return numext::isInf(a); }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type operator() (const Scalar& a) const { return numext::isinf(a); }
 };
 template<typename Scalar>
-struct functor_traits<scalar_isInf_op<Scalar> >
+struct functor_traits<scalar_isinf_op<Scalar> >
 {
   enum {
     Cost = NumTraits<Scalar>::MulCost,
@@ -621,16 +621,16 @@ struct functor_traits<scalar_isInf_op<Scalar> >
 };
 
 /** \internal
-  * \brief Template functor to compute the isFinite of a scalar
-  * \sa class CwiseUnaryOp, ArrayBase::isFinite()
+  * \brief Template functor to check whether a scalar has a finite value
+  * \sa class CwiseUnaryOp, ArrayBase::isfinite()
   */
-template<typename Scalar> struct scalar_isFinite_op {
-  EIGEN_EMPTY_STRUCT_CTOR(scalar_isFinite_op)
+template<typename Scalar> struct scalar_isfinite_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_isfinite_op)
   typedef bool result_type;
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type operator() (const Scalar& a) const { return numext::isfinite(a); }
 };
 template<typename Scalar>
-struct functor_traits<scalar_isFinite_op<Scalar> >
+struct functor_traits<scalar_isfinite_op<Scalar> >
 {
   enum {
     Cost = NumTraits<Scalar>::MulCost,
diff --git a/Eigen/src/plugins/ArrayCwiseUnaryOps.h b/Eigen/src/plugins/ArrayCwiseUnaryOps.h
index c9f7c8f6e..5a3c92ea2 100644
--- a/Eigen/src/plugins/ArrayCwiseUnaryOps.h
+++ b/Eigen/src/plugins/ArrayCwiseUnaryOps.h
@@ -25,9 +25,9 @@ typedef CwiseUnaryOp<internal::scalar_cube_op<Scalar>, const Derived> CubeReturn
 typedef CwiseUnaryOp<internal::scalar_round_op<Scalar>, const Derived> RoundReturnType;
 typedef CwiseUnaryOp<internal::scalar_floor_op<Scalar>, const Derived> FloorReturnType;
 typedef CwiseUnaryOp<internal::scalar_ceil_op<Scalar>, const Derived> CeilReturnType;
-typedef CwiseUnaryOp<internal::scalar_isNaN_op<Scalar>, const Derived> IsNaNReturnType;
-typedef CwiseUnaryOp<internal::scalar_isInf_op<Scalar>, const Derived> IsInfReturnType;
-typedef CwiseUnaryOp<internal::scalar_isFinite_op<Scalar>, const Derived> IsFiniteReturnType;
+typedef CwiseUnaryOp<internal::scalar_isnan_op<Scalar>, const Derived> IsNaNReturnType;
+typedef CwiseUnaryOp<internal::scalar_isinf_op<Scalar>, const Derived> IsInfReturnType;
+typedef CwiseUnaryOp<internal::scalar_isfinite_op<Scalar>, const Derived> IsFiniteReturnType;
 
 /** \returns an expression of the coefficient-wise absolute value of \c *this
   *
@@ -366,12 +366,12 @@ ceil() const
   return CeilReturnType(derived());
 }
 
-/** \returns an expression of the coefficient-wise isNaN of *this.
+/** \returns an expression of the coefficient-wise isnan of *this.
   *
   * Example: \include Cwise_isNaN.cpp
   * Output: \verbinclude Cwise_isNaN.out
   *
-  * \sa isFinite(), isInf()
+  * \sa isfinite(), isinf()
   */
 inline const IsNaNReturnType
 isNaN() const
@@ -379,12 +379,12 @@ isNaN() const
   return IsNaNReturnType(derived());
 }
 
-/** \returns an expression of the coefficient-wise isInf of *this.
+/** \returns an expression of the coefficient-wise isinf of *this.
   *
   * Example: \include Cwise_isInf.cpp
   * Output: \verbinclude Cwise_isInf.out
   *
-  * \sa isNaN(), isFinite()
+  * \sa isnan(), isfinite()
   */
 inline const IsInfReturnType
 isInf() const
@@ -392,12 +392,12 @@ isInf() const
   return IsInfReturnType(derived());
 }
 
-/** \returns an expression of the coefficient-wise isFinite of *this.
+/** \returns an expression of the coefficient-wise isfinite of *this.
   *
   * Example: \include Cwise_isFinite.cpp
   * Output: \verbinclude Cwise_isFinite.out
   *
-  * \sa isNaN(), isInf()
+  * \sa isnan(), isinf()
   */
 inline const IsFiniteReturnType
 isFinite() const
diff --git a/test/array.cpp b/test/array.cpp
index 90c75e9f0..b802e52f6 100644
--- a/test/array.cpp
+++ b/test/array.cpp
@@ -215,9 +215,9 @@ template<typename ArrayType> void array_real(const ArrayType& m)
   VERIFY_IS_APPROX(m1.round(), round(m1));
   VERIFY_IS_APPROX(m1.floor(), floor(m1));
   VERIFY_IS_APPROX(m1.ceil(), ceil(m1));
-  VERIFY((m1.isNaN() == isNaN(m1)).all());
-  VERIFY((m1.isInf() == isInf(m1)).all());
-  VERIFY((m1.isFinite() == isFinite(m1)).all());
+  VERIFY((m1.isNaN() == isnan(m1)).all());
+  VERIFY((m1.isInf() == isinf(m1)).all());
+  VERIFY((m1.isFinite() == isfinite(m1)).all());
   VERIFY_IS_APPROX(m1.inverse(), inverse(m1));
   VERIFY_IS_APPROX(m1.abs(), abs(m1));
   VERIFY_IS_APPROX(m1.abs2(), abs2(m1));
@@ -243,9 +243,9 @@ template<typename ArrayType> void array_real(const ArrayType& m)
   VERIFY_IS_APPROX(tanh(m1), (0.5*(exp(m1)-exp(-m1)))/(0.5*(exp(m1)+exp(-m1))));
   VERIFY_IS_APPROX(arg(m1), ((ArrayType)(m1<0))*std::acos(-1.0));
   VERIFY((round(m1) <= ceil(m1) && round(m1) >= floor(m1)).all());
-  VERIFY(isNaN(m1*0.0/0.0).all());
-  VERIFY(isInf(m1/0.0).all());
-  VERIFY((isFinite(m1) && !isFinite(m1*0.0/0.0) && !isFinite(m1/0.0)).all());
+  VERIFY(isnan(m1*0.0/0.0).all());
+  VERIFY(isinf(m1/0.0).all());
+  VERIFY((isfinite(m1) && !isfinite(m1*0.0/0.0) && !isfinite(m1/0.0)).all());
   VERIFY_IS_APPROX(inverse(inverse(m1)),m1);
   VERIFY((abs(m1) == m1 || abs(m1) == -m1).all());
   VERIFY_IS_APPROX(m3, sqrt(abs2(m1)));
@@ -317,9 +317,9 @@ template<typename ArrayType> void array_complex(const ArrayType& m)
   VERIFY_IS_APPROX(m1.cosh(), cosh(m1));
   VERIFY_IS_APPROX(m1.tanh(), tanh(m1));
   VERIFY_IS_APPROX(m1.arg(), arg(m1));
-  VERIFY((m1.isNaN() == isNaN(m1)).all());
-  VERIFY((m1.isInf() == isInf(m1)).all());
-  VERIFY((m1.isFinite() == isFinite(m1)).all());
+  VERIFY((m1.isNaN() == isnan(m1)).all());
+  VERIFY((m1.isInf() == isinf(m1)).all());
+  VERIFY((m1.isFinite() == isfinite(m1)).all());
   VERIFY_IS_APPROX(m1.inverse(), inverse(m1));
   VERIFY_IS_APPROX(m1.log(), log(m1));
   VERIFY_IS_APPROX(m1.log10(), log10(m1));
@@ -345,9 +345,9 @@ template<typename ArrayType> void array_complex(const ArrayType& m)
   VERIFY_IS_APPROX(arg(m1), m3);
 
   std::complex<RealScalar> zero(0.0,0.0);
-  VERIFY(isNaN(m1*zero/zero).all());
-  VERIFY(isInf(m1/zero).all());
-  VERIFY((isFinite(m1) && !isFinite(m1*zero/zero) && !isFinite(m1/zero)).all());
+  VERIFY(isnan(m1*zero/zero).all());
+  VERIFY(isinf(m1/zero).all());
+  VERIFY((isfinite(m1) && !isfinite(m1*zero/zero) && !isfinite(m1/zero)).all());
 
   VERIFY_IS_APPROX(inverse(inverse(m1)),m1);
   VERIFY_IS_APPROX(conj(m1.conjugate()), m1);
diff --git a/test/packetmath.cpp b/test/packetmath.cpp
index e3a754627..2f1accd1b 100644
--- a/test/packetmath.cpp
+++ b/test/packetmath.cpp
@@ -317,7 +317,7 @@ template<typename Scalar> void packetmath_real()
     data1[0] = std::numeric_limits<Scalar>::quiet_NaN();
     packet_helper<internal::packet_traits<Scalar>::HasExp,Packet> h;
     h.store(data2, internal::pexp(h.load(data1))); 
-    VERIFY(numext::isNaN(data2[0]));
+    VERIFY(numext::isnan(data2[0]));
   }
 
   for (int i=0; i<size; ++i)
@@ -333,14 +333,14 @@ template<typename Scalar> void packetmath_real()
     data1[0] = std::numeric_limits<Scalar>::quiet_NaN();
     packet_helper<internal::packet_traits<Scalar>::HasLog,Packet> h;
     h.store(data2, internal::plog(h.load(data1)));
-    VERIFY(numext::isNaN(data2[0]));
+    VERIFY(numext::isnan(data2[0]));
     data1[0] = -1.0f;
     h.store(data2, internal::plog(h.load(data1)));
-    VERIFY(numext::isNaN(data2[0]));
+    VERIFY(numext::isnan(data2[0]));
 #if !EIGEN_FAST_MATH
     h.store(data2, internal::psqrt(h.load(data1)));
-    VERIFY(numext::isNaN(data2[0]));
-    VERIFY(numext::isNaN(data2[1]));
+    VERIFY(numext::isnan(data2[0]));
+    VERIFY(numext::isnan(data2[1]));
 #endif
   }
 }
diff --git a/test/stable_norm.cpp b/test/stable_norm.cpp
index 0674006de..21fae494b 100644
--- a/test/stable_norm.cpp
+++ b/test/stable_norm.cpp
@@ -9,14 +9,6 @@
 
 #include "main.h"
 
-// workaround aggressive optimization in ICC
-template<typename T> EIGEN_DONT_INLINE  T sub(T a, T b) { return a - b; }
-
-template<typename T> bool isFinite(const T& x)
-{
-  return isNotNaN(sub(x,x));
-}
-
 template<typename T> EIGEN_DONT_INLINE T copy(const T& x)
 {
   return x;
@@ -76,19 +68,19 @@ template<typename MatrixType> void stable_norm(const MatrixType& m)
 
   RealScalar size = static_cast<RealScalar>(m.size());
 
-  // test isFinite
-  VERIFY(!isFinite( std::numeric_limits<RealScalar>::infinity()));
-  VERIFY(!isFinite(sqrt(-abs(big))));
+  // test numext::isfinite
+  VERIFY(!numext::isfinite( std::numeric_limits<RealScalar>::infinity()));
+  VERIFY(!numext::isfinite(sqrt(-abs(big))));
 
   // test overflow
-  VERIFY(isFinite(sqrt(size)*abs(big)));
+  VERIFY(numext::isfinite(sqrt(size)*abs(big)));
   VERIFY_IS_NOT_APPROX(sqrt(copy(vbig.squaredNorm())), abs(sqrt(size)*big)); // here the default norm must fail
   VERIFY_IS_APPROX(vbig.stableNorm(), sqrt(size)*abs(big));
   VERIFY_IS_APPROX(vbig.blueNorm(),   sqrt(size)*abs(big));
   VERIFY_IS_APPROX(vbig.hypotNorm(),  sqrt(size)*abs(big));
 
   // test underflow
-  VERIFY(isFinite(sqrt(size)*abs(small)));
+  VERIFY(numext::isfinite(sqrt(size)*abs(small)));
   VERIFY_IS_NOT_APPROX(sqrt(copy(vsmall.squaredNorm())),   abs(sqrt(size)*small)); // here the default norm must fail
   VERIFY_IS_APPROX(vsmall.stableNorm(), sqrt(size)*abs(small));
   VERIFY_IS_APPROX(vsmall.blueNorm(),   sqrt(size)*abs(small));
@@ -111,33 +103,33 @@ template<typename MatrixType> void stable_norm(const MatrixType& m)
   {
     v = vrand;
     v(i,j) = std::numeric_limits<RealScalar>::quiet_NaN();
-    VERIFY(!isFinite(v.squaredNorm()));   VERIFY(numext::isNaN(v.squaredNorm()));
-    VERIFY(!isFinite(v.norm()));          VERIFY(numext::isNaN(v.norm()));
-    VERIFY(!isFinite(v.stableNorm()));    VERIFY(numext::isNaN(v.stableNorm()));
-    VERIFY(!isFinite(v.blueNorm()));      VERIFY(numext::isNaN(v.blueNorm()));
-    VERIFY(!isFinite(v.hypotNorm()));     VERIFY(numext::isNaN(v.hypotNorm()));
+    VERIFY(!numext::isfinite(v.squaredNorm()));   VERIFY(numext::isnan(v.squaredNorm()));
+    VERIFY(!numext::isfinite(v.norm()));          VERIFY(numext::isnan(v.norm()));
+    VERIFY(!numext::isfinite(v.stableNorm()));    VERIFY(numext::isnan(v.stableNorm()));
+    VERIFY(!numext::isfinite(v.blueNorm()));      VERIFY(numext::isnan(v.blueNorm()));
+    VERIFY(!numext::isfinite(v.hypotNorm()));     VERIFY(numext::isnan(v.hypotNorm()));
   }
   
   // +inf
   {
     v = vrand;
     v(i,j) = std::numeric_limits<RealScalar>::infinity();
-    VERIFY(!isFinite(v.squaredNorm()));   VERIFY(isPlusInf(v.squaredNorm()));
-    VERIFY(!isFinite(v.norm()));          VERIFY(isPlusInf(v.norm()));
-    VERIFY(!isFinite(v.stableNorm()));    VERIFY(isPlusInf(v.stableNorm()));
-    VERIFY(!isFinite(v.blueNorm()));      VERIFY(isPlusInf(v.blueNorm()));
-    VERIFY(!isFinite(v.hypotNorm()));     VERIFY(isPlusInf(v.hypotNorm()));
+    VERIFY(!numext::isfinite(v.squaredNorm()));   VERIFY(isPlusInf(v.squaredNorm()));
+    VERIFY(!numext::isfinite(v.norm()));          VERIFY(isPlusInf(v.norm()));
+    VERIFY(!numext::isfinite(v.stableNorm()));    VERIFY(isPlusInf(v.stableNorm()));
+    VERIFY(!numext::isfinite(v.blueNorm()));      VERIFY(isPlusInf(v.blueNorm()));
+    VERIFY(!numext::isfinite(v.hypotNorm()));     VERIFY(isPlusInf(v.hypotNorm()));
   }
   
   // -inf
   {
     v = vrand;
     v(i,j) = -std::numeric_limits<RealScalar>::infinity();
-    VERIFY(!isFinite(v.squaredNorm()));   VERIFY(isPlusInf(v.squaredNorm()));
-    VERIFY(!isFinite(v.norm()));          VERIFY(isPlusInf(v.norm()));
-    VERIFY(!isFinite(v.stableNorm()));    VERIFY(isPlusInf(v.stableNorm()));
-    VERIFY(!isFinite(v.blueNorm()));      VERIFY(isPlusInf(v.blueNorm()));
-    VERIFY(!isFinite(v.hypotNorm()));     VERIFY(isPlusInf(v.hypotNorm()));
+    VERIFY(!numext::isfinite(v.squaredNorm()));   VERIFY(isPlusInf(v.squaredNorm()));
+    VERIFY(!numext::isfinite(v.norm()));          VERIFY(isPlusInf(v.norm()));
+    VERIFY(!numext::isfinite(v.stableNorm()));    VERIFY(isPlusInf(v.stableNorm()));
+    VERIFY(!numext::isfinite(v.blueNorm()));      VERIFY(isPlusInf(v.blueNorm()));
+    VERIFY(!numext::isfinite(v.hypotNorm()));     VERIFY(isPlusInf(v.hypotNorm()));
   }
   
   // mix
@@ -147,11 +139,11 @@ template<typename MatrixType> void stable_norm(const MatrixType& m)
     v = vrand;
     v(i,j) = -std::numeric_limits<RealScalar>::infinity();
     v(i2,j2) = std::numeric_limits<RealScalar>::quiet_NaN();
-    VERIFY(!isFinite(v.squaredNorm()));   VERIFY(numext::isNaN(v.squaredNorm()));
-    VERIFY(!isFinite(v.norm()));          VERIFY(numext::isNaN(v.norm()));
-    VERIFY(!isFinite(v.stableNorm()));    VERIFY(numext::isNaN(v.stableNorm()));
-    VERIFY(!isFinite(v.blueNorm()));      VERIFY(numext::isNaN(v.blueNorm()));
-    VERIFY(!isFinite(v.hypotNorm()));     VERIFY(numext::isNaN(v.hypotNorm()));
+    VERIFY(!numext::isfinite(v.squaredNorm()));   VERIFY(numext::isnan(v.squaredNorm()));
+    VERIFY(!numext::isfinite(v.norm()));          VERIFY(numext::isnan(v.norm()));
+    VERIFY(!numext::isfinite(v.stableNorm()));    VERIFY(numext::isnan(v.stableNorm()));
+    VERIFY(!numext::isfinite(v.blueNorm()));      VERIFY(numext::isnan(v.blueNorm()));
+    VERIFY(!numext::isfinite(v.hypotNorm()));     VERIFY(numext::isnan(v.hypotNorm()));
   }
 }