Fix bug #314:

- remove most of the metaprogramming kung fu in MathFunctions.h (only keep functions that differs from the std)
- remove the overloads for array expression that were in the std namespace

23 files changed, 116 insertions, 88 deletions

diff --git a/test/adjoint.cpp b/test/adjoint.cpp
index b6cf0a68b..b35e5674b 100644
--- a/test/adjoint.cpp
+++ b/test/adjoint.cpp
@@ -16,6 +16,7 @@ template<typename MatrixType> void adjoint(const MatrixType& m)
   /* this test covers the following files:
      Transpose.h Conjugate.h Dot.h
   */
+  using std::abs;
   typedef typename MatrixType::Index Index;
   typedef typename MatrixType::Scalar Scalar;
   typedef typename NumTraits<Scalar>::Real RealScalar;
@@ -63,7 +64,7 @@ template<typename MatrixType> void adjoint(const MatrixType& m)
     VERIFY_IS_APPROX(v3, v1.normalized());
     VERIFY_IS_APPROX(v3.norm(), RealScalar(1));
   }
-  VERIFY_IS_MUCH_SMALLER_THAN(internal::abs(vzero.dot(v1)),  static_cast<RealScalar>(1));
+  VERIFY_IS_MUCH_SMALLER_THAN(abs(vzero.dot(v1)),  static_cast<RealScalar>(1));
   
   // check compatibility of dot and adjoint
   
diff --git a/test/array.cpp b/test/array.cpp
index 3548fa641..4c6393d9a 100644
--- a/test/array.cpp
+++ b/test/array.cpp
@@ -83,6 +83,7 @@ template<typename ArrayType> void array(const ArrayType& m)
 
 template<typename ArrayType> void comparisons(const ArrayType& m)
 {
+  using std::abs;
   typedef typename ArrayType::Index Index;
   typedef typename ArrayType::Scalar Scalar;
   typedef typename NumTraits<Scalar>::Real RealScalar;
@@ -120,7 +121,7 @@ template<typename ArrayType> void comparisons(const ArrayType& m)
   Scalar mid = (m1.cwiseAbs().minCoeff() + m1.cwiseAbs().maxCoeff())/Scalar(2);
   for (int j=0; j<cols; ++j)
   for (int i=0; i<rows; ++i)
-    m3(i,j) = internal::abs(m1(i,j))<mid ? 0 : m1(i,j);
+    m3(i,j) = abs(m1(i,j))<mid ? 0 : m1(i,j);
   VERIFY_IS_APPROX( (m1.abs()<ArrayType::Constant(rows,cols,mid))
                         .select(ArrayType::Zero(rows,cols),m1), m3);
   // shorter versions:
@@ -149,6 +150,7 @@ template<typename ArrayType> void comparisons(const ArrayType& m)
 
 template<typename ArrayType> void array_real(const ArrayType& m)
 {
+  using std::abs;
   typedef typename ArrayType::Index Index;
   typedef typename ArrayType::Scalar Scalar;
   typedef typename NumTraits<Scalar>::Real RealScalar;
@@ -163,49 +165,49 @@ template<typename ArrayType> void array_real(const ArrayType& m)
   Scalar  s1 = internal::random<Scalar>();
 
   // these tests are mostly to check possible compilation issues.
-  VERIFY_IS_APPROX(m1.sin(), std::sin(m1));
-  VERIFY_IS_APPROX(m1.sin(), internal::sin(m1));
-  VERIFY_IS_APPROX(m1.cos(), std::cos(m1));
-  VERIFY_IS_APPROX(m1.cos(), internal::cos(m1));
-  VERIFY_IS_APPROX(m1.asin(), std::asin(m1));
-  VERIFY_IS_APPROX(m1.asin(), internal::asin(m1));
-  VERIFY_IS_APPROX(m1.acos(), std::acos(m1));
-  VERIFY_IS_APPROX(m1.acos(), internal::acos(m1));
-  VERIFY_IS_APPROX(m1.tan(), std::tan(m1));
-  VERIFY_IS_APPROX(m1.tan(), internal::tan(m1));
+//   VERIFY_IS_APPROX(m1.sin(), std::sin(m1));
+  VERIFY_IS_APPROX(m1.sin(), sin(m1));
+//   VERIFY_IS_APPROX(m1.cos(), std::cos(m1));
+  VERIFY_IS_APPROX(m1.cos(), cos(m1));
+//   VERIFY_IS_APPROX(m1.asin(), std::asin(m1));
+  VERIFY_IS_APPROX(m1.asin(), asin(m1));
+//   VERIFY_IS_APPROX(m1.acos(), std::acos(m1));
+  VERIFY_IS_APPROX(m1.acos(), acos(m1));
+//   VERIFY_IS_APPROX(m1.tan(), std::tan(m1));
+  VERIFY_IS_APPROX(m1.tan(), tan(m1));
   
-  VERIFY_IS_APPROX(internal::cos(m1+RealScalar(3)*m2), internal::cos((m1+RealScalar(3)*m2).eval()));
-  VERIFY_IS_APPROX(std::cos(m1+RealScalar(3)*m2), std::cos((m1+RealScalar(3)*m2).eval()));
+  VERIFY_IS_APPROX(cos(m1+RealScalar(3)*m2), cos((m1+RealScalar(3)*m2).eval()));
+//   VERIFY_IS_APPROX(std::cos(m1+RealScalar(3)*m2), std::cos((m1+RealScalar(3)*m2).eval()));
 
-  VERIFY_IS_APPROX(m1.abs().sqrt(), std::sqrt(std::abs(m1)));
-  VERIFY_IS_APPROX(m1.abs().sqrt(), internal::sqrt(internal::abs(m1)));
-  VERIFY_IS_APPROX(m1.abs(), internal::sqrt(internal::abs2(m1)));
+//   VERIFY_IS_APPROX(m1.abs().sqrt(), std::sqrt(std::abs(m1)));
+  VERIFY_IS_APPROX(m1.abs().sqrt(), sqrt(abs(m1)));
+  VERIFY_IS_APPROX(m1.abs(), sqrt(internal::abs2(m1)));
 
   VERIFY_IS_APPROX(internal::abs2(internal::real(m1)) + internal::abs2(internal::imag(m1)), internal::abs2(m1));
-  VERIFY_IS_APPROX(internal::abs2(std::real(m1)) + internal::abs2(std::imag(m1)), internal::abs2(m1));
+  VERIFY_IS_APPROX(internal::abs2(real(m1)) + internal::abs2(imag(m1)), internal::abs2(m1));
   if(!NumTraits<Scalar>::IsComplex)
     VERIFY_IS_APPROX(internal::real(m1), m1);
 
-  VERIFY_IS_APPROX(m1.abs().log(), std::log(std::abs(m1)));
-  VERIFY_IS_APPROX(m1.abs().log(), internal::log(internal::abs(m1)));
+  //VERIFY_IS_APPROX(m1.abs().log(), std::log(std::abs(m1)));
+  VERIFY_IS_APPROX(m1.abs().log(), log(abs(m1)));
 
-  VERIFY_IS_APPROX(m1.exp(), std::exp(m1));
-  VERIFY_IS_APPROX(m1.exp() * m2.exp(), std::exp(m1+m2));
-  VERIFY_IS_APPROX(m1.exp(), internal::exp(m1));
-  VERIFY_IS_APPROX(m1.exp() / m2.exp(), std::exp(m1-m2));
+//   VERIFY_IS_APPROX(m1.exp(), std::exp(m1));
+  VERIFY_IS_APPROX(m1.exp() * m2.exp(), exp(m1+m2));
+  VERIFY_IS_APPROX(m1.exp(), exp(m1));
+  VERIFY_IS_APPROX(m1.exp() / m2.exp(),(m1-m2).exp());
 
   VERIFY_IS_APPROX(m1.pow(2), m1.square());
-  VERIFY_IS_APPROX(std::pow(m1,2), m1.square());
+  VERIFY_IS_APPROX(pow(m1,2), m1.square());
 
   ArrayType exponents = ArrayType::Constant(rows, cols, RealScalar(2));
-  VERIFY_IS_APPROX(std::pow(m1,exponents), m1.square());
+  VERIFY_IS_APPROX(Eigen::pow(m1,exponents), m1.square());
 
   m3 = m1.abs();
   VERIFY_IS_APPROX(m3.pow(RealScalar(0.5)), m3.sqrt());
-  VERIFY_IS_APPROX(std::pow(m3,RealScalar(0.5)), m3.sqrt());
+  VERIFY_IS_APPROX(pow(m3,RealScalar(0.5)), m3.sqrt());
 
   // scalar by array division
-  const RealScalar tiny = std::sqrt(std::numeric_limits<RealScalar>::epsilon());
+  const RealScalar tiny = sqrt(std::numeric_limits<RealScalar>::epsilon());
   s1 += Scalar(tiny);
   m1 += ArrayType::Constant(rows,cols,Scalar(tiny));
   VERIFY_IS_APPROX(s1/m1, s1 * m1.inverse());
@@ -223,11 +225,11 @@ template<typename ArrayType> void array_complex(const ArrayType& m)
 
   for (Index i = 0; i < m.rows(); ++i)
     for (Index j = 0; j < m.cols(); ++j)
-      m2(i,j) = std::sqrt(m1(i,j));
+      m2(i,j) = sqrt(m1(i,j));
 
   VERIFY_IS_APPROX(m1.sqrt(), m2);
-  VERIFY_IS_APPROX(m1.sqrt(), std::sqrt(m1));
-  VERIFY_IS_APPROX(m1.sqrt(), internal::sqrt(m1));
+//   VERIFY_IS_APPROX(m1.sqrt(), std::sqrt(m1));
+  VERIFY_IS_APPROX(m1.sqrt(), Eigen::sqrt(m1));
 }
 
 template<typename ArrayType> void min_max(const ArrayType& m)
diff --git a/test/array_for_matrix.cpp b/test/array_for_matrix.cpp
index 5a599c321..cd8ef03a0 100644
--- a/test/array_for_matrix.cpp
+++ b/test/array_for_matrix.cpp
@@ -73,6 +73,7 @@ template<typename MatrixType> void array_for_matrix(const MatrixType& m)
 
 template<typename MatrixType> void comparisons(const MatrixType& m)
 {
+  using std::abs;
   typedef typename MatrixType::Index Index;
   typedef typename MatrixType::Scalar Scalar;
   typedef typename NumTraits<Scalar>::Real RealScalar;
@@ -110,7 +111,7 @@ template<typename MatrixType> void comparisons(const MatrixType& m)
   Scalar mid = (m1.cwiseAbs().minCoeff() + m1.cwiseAbs().maxCoeff())/Scalar(2);
   for (int j=0; j<cols; ++j)
   for (int i=0; i<rows; ++i)
-    m3(i,j) = internal::abs(m1(i,j))<mid ? 0 : m1(i,j);
+    m3(i,j) = abs(m1(i,j))<mid ? 0 : m1(i,j);
   VERIFY_IS_APPROX( (m1.array().abs()<MatrixType::Constant(rows,cols,mid).array())
                         .select(MatrixType::Zero(rows,cols),m1), m3);
   // shorter versions:
@@ -133,11 +134,12 @@ template<typename MatrixType> void comparisons(const MatrixType& m)
 
 template<typename VectorType> void lpNorm(const VectorType& v)
 {
+  using std::sqrt;
   VectorType u = VectorType::Random(v.size());
 
   VERIFY_IS_APPROX(u.template lpNorm<Infinity>(), u.cwiseAbs().maxCoeff());
   VERIFY_IS_APPROX(u.template lpNorm<1>(), u.cwiseAbs().sum());
-  VERIFY_IS_APPROX(u.template lpNorm<2>(), internal::sqrt(u.array().abs().square().sum()));
+  VERIFY_IS_APPROX(u.template lpNorm<2>(), sqrt(u.array().abs().square().sum()));
   VERIFY_IS_APPROX(internal::pow(u.template lpNorm<5>(), typename VectorType::RealScalar(5)), u.array().abs().pow(5).sum());
 }
 
diff --git a/test/eigen2support.cpp b/test/eigen2support.cpp
index 7e02bdf5b..bfcc87323 100644
--- a/test/eigen2support.cpp
+++ b/test/eigen2support.cpp
@@ -43,7 +43,9 @@ template<typename MatrixType> void eigen2support(const MatrixType& m)
   VERIFY_IS_EQUAL((m1.col(0).end(1)), (m1.col(0).segment(rows-1,1)));
   VERIFY_IS_EQUAL((m1.col(0).template end<1>()), (m1.col(0).segment(rows-1,1)));
   
-  using namespace internal;
+  using std::cos;
+  using internal::real;
+  using internal::abs2;
   VERIFY_IS_EQUAL(ei_cos(s1), cos(s1));
   VERIFY_IS_EQUAL(ei_real(s1), real(s1));
   VERIFY_IS_EQUAL(ei_abs2(s1), abs2(s1));
diff --git a/test/geo_alignedbox.cpp b/test/geo_alignedbox.cpp
index 5886f9181..4a51fc71e 100644
--- a/test/geo_alignedbox.cpp
+++ b/test/geo_alignedbox.cpp
@@ -109,7 +109,7 @@ void specificTest1()
 
     VERIFY_IS_APPROX( 14.0f, box.volume() );
     VERIFY_IS_APPROX( 53.0f, box.diagonal().squaredNorm() );
-    VERIFY_IS_APPROX( internal::sqrt( 53.0f ), box.diagonal().norm() );
+    VERIFY_IS_APPROX( std::sqrt( 53.0f ), box.diagonal().norm() );
 
     VERIFY_IS_APPROX( m, box.corner( BoxType::BottomLeft ) );
     VERIFY_IS_APPROX( M, box.corner( BoxType::TopRight ) );
diff --git a/test/geo_hyperplane.cpp b/test/geo_hyperplane.cpp
index 3fc80c4c7..2845ba95d 100644
--- a/test/geo_hyperplane.cpp
+++ b/test/geo_hyperplane.cpp
@@ -79,6 +79,7 @@ template<typename HyperplaneType> void hyperplane(const HyperplaneType& _plane)
 
 template<typename Scalar> void lines()
 {
+  using std::abs;
   typedef Hyperplane<Scalar, 2> HLine;
   typedef ParametrizedLine<Scalar, 2> PLine;
   typedef Matrix<Scalar,2,1> Vector;
@@ -90,7 +91,7 @@ template<typename Scalar> void lines()
     Vector u = Vector::Random();
     Vector v = Vector::Random();
     Scalar a = internal::random<Scalar>();
-    while (internal::abs(a-1) < 1e-4) a = internal::random<Scalar>();
+    while (abs(a-1) < 1e-4) a = internal::random<Scalar>();
     while (u.norm() < 1e-4) u = Vector::Random();
     while (v.norm() < 1e-4) v = Vector::Random();
 
diff --git a/test/geo_parametrizedline.cpp b/test/geo_parametrizedline.cpp
index 4e1f845dd..7b2e34abe 100644
--- a/test/geo_parametrizedline.cpp
+++ b/test/geo_parametrizedline.cpp
@@ -18,6 +18,7 @@ template<typename LineType> void parametrizedline(const LineType& _line)
   /* this test covers the following files:
      ParametrizedLine.h
   */
+  using std::abs;
   typedef typename LineType::Index Index;
   const Index dim = _line.dim();
   typedef typename LineType::Scalar Scalar;
@@ -35,7 +36,7 @@ template<typename LineType> void parametrizedline(const LineType& _line)
   LineType l0(p0, d0);
 
   Scalar s0 = internal::random<Scalar>();
-  Scalar s1 = internal::abs(internal::random<Scalar>());
+  Scalar s1 = abs(internal::random<Scalar>());
 
   VERIFY_IS_MUCH_SMALLER_THAN( l0.distance(p0), RealScalar(1) );
   VERIFY_IS_MUCH_SMALLER_THAN( l0.distance(p0+s0*d0), RealScalar(1) );
diff --git a/test/geo_quaternion.cpp b/test/geo_quaternion.cpp
index 6e6922864..c3fceafdf 100644
--- a/test/geo_quaternion.cpp
+++ b/test/geo_quaternion.cpp
@@ -23,6 +23,7 @@ template<typename T> T bounded_acos(T v)
 
 template<typename QuatType> void check_slerp(const QuatType& q0, const QuatType& q1)
 {
+  using std::abs;
   typedef typename QuatType::Scalar Scalar;
   typedef Matrix<Scalar,3,1> VectorType;
   typedef AngleAxis<Scalar> AA;
@@ -36,9 +37,9 @@ template<typename QuatType> void check_slerp(const QuatType& q0, const QuatType&
   {
     QuatType q = q0.slerp(t,q1);
     Scalar theta = AA(q*q0.inverse()).angle();
-    VERIFY(internal::abs(q.norm() - 1) < largeEps);
+    VERIFY(abs(q.norm() - 1) < largeEps);
     if(theta_tot==0)  VERIFY(theta_tot==0);
-    else              VERIFY(internal::abs(theta/theta_tot - t) < largeEps);
+    else              VERIFY(abs(theta/theta_tot - t) < largeEps);
   }
 }
 
@@ -47,7 +48,7 @@ template<typename Scalar, int Options> void quaternion(void)
   /* this test covers the following files:
      Quaternion.h
   */
-
+  using std::abs;
   typedef Matrix<Scalar,3,3> Matrix3;
   typedef Matrix<Scalar,3,1> Vector3;
   typedef Matrix<Scalar,4,1> Vector4;
@@ -82,13 +83,13 @@ template<typename Scalar, int Options> void quaternion(void)
   q2 = AngleAxisx(a, v1.normalized());
 
   // angular distance
-  Scalar refangle = internal::abs(AngleAxisx(q1.inverse()*q2).angle());
+  Scalar refangle = abs(AngleAxisx(q1.inverse()*q2).angle());
   if (refangle>Scalar(M_PI))
     refangle = Scalar(2)*Scalar(M_PI) - refangle;
 
   if((q1.coeffs()-q2.coeffs()).norm() > 10*largeEps)
   {
-    VERIFY_IS_MUCH_SMALLER_THAN(internal::abs(q1.angularDistance(q2) - refangle), Scalar(1));
+    VERIFY_IS_MUCH_SMALLER_THAN(abs(q1.angularDistance(q2) - refangle), Scalar(1));
   }
 
   // rotation matrix conversion
@@ -109,7 +110,7 @@ template<typename Scalar, int Options> void quaternion(void)
 
   // Do not execute the test if the rotation angle is almost zero, or
   // the rotation axis and v1 are almost parallel.
-  if (internal::abs(aa.angle()) > 5*test_precision<Scalar>()
+  if (abs(aa.angle()) > 5*test_precision<Scalar>()
       && (aa.axis() - v1.normalized()).norm() < 1.99
       && (aa.axis() + v1.normalized()).norm() < 1.99) 
   {
diff --git a/test/geo_transformations.cpp b/test/geo_transformations.cpp
index f4d65aabc..30a0aba66 100644
--- a/test/geo_transformations.cpp
+++ b/test/geo_transformations.cpp
@@ -88,6 +88,8 @@ template<typename Scalar, int Mode, int Options> void transformations()
   /* this test covers the following files:
      Cross.h Quaternion.h, Transform.cpp
   */
+  using std::cos;
+  using std::abs;
   typedef Matrix<Scalar,2,2> Matrix2;
   typedef Matrix<Scalar,3,3> Matrix3;
   typedef Matrix<Scalar,4,4> Matrix4;
@@ -115,7 +117,7 @@ template<typename Scalar, int Mode, int Options> void transformations()
 
   VERIFY_IS_APPROX(v0, AngleAxisx(a, v0.normalized()) * v0);
   VERIFY_IS_APPROX(-v0, AngleAxisx(Scalar(M_PI), v0.unitOrthogonal()) * v0);
-  VERIFY_IS_APPROX(internal::cos(a)*v0.squaredNorm(), v0.dot(AngleAxisx(a, v0.unitOrthogonal()) * v0));
+  VERIFY_IS_APPROX(cos(a)*v0.squaredNorm(), v0.dot(AngleAxisx(a, v0.unitOrthogonal()) * v0));
   m = AngleAxisx(a, v0.normalized()).toRotationMatrix().adjoint();
   VERIFY_IS_APPROX(Matrix3::Identity(), m * AngleAxisx(a, v0.normalized()));
   VERIFY_IS_APPROX(Matrix3::Identity(), AngleAxisx(a, v0.normalized()) * m);
@@ -155,7 +157,7 @@ template<typename Scalar, int Mode, int Options> void transformations()
   // Transform
   // TODO complete the tests !
   a = 0;
-  while (internal::abs(a)<Scalar(0.1))
+  while (abs(a)<Scalar(0.1))
     a = internal::random<Scalar>(-Scalar(0.4)*Scalar(M_PI), Scalar(0.4)*Scalar(M_PI));
   q1 = AngleAxisx(a, v0.normalized());
   Transform3 t0, t1, t2;
@@ -249,7 +251,7 @@ template<typename Scalar, int Mode, int Options> void transformations()
   Vector2 v20 = Vector2::Random();
   Vector2 v21 = Vector2::Random();
   for (int k=0; k<2; ++k)
-    if (internal::abs(v21[k])<Scalar(1e-3)) v21[k] = Scalar(1e-3);
+    if (abs(v21[k])<Scalar(1e-3)) v21[k] = Scalar(1e-3);
   t21.setIdentity();
   t21.linear() = Rotation2D<Scalar>(a).toRotationMatrix();
   VERIFY_IS_APPROX(t20.fromPositionOrientationScale(v20,a,v21).matrix(),
diff --git a/test/inverse.cpp b/test/inverse.cpp
index cff42dd8d..5544eb671 100644
--- a/test/inverse.cpp
+++ b/test/inverse.cpp
@@ -13,6 +13,7 @@
 
 template<typename MatrixType> void inverse(const MatrixType& m)
 {
+  using std::abs;
   typedef typename MatrixType::Index Index;
   /* this test covers the following files:
      Inverse.h
@@ -63,7 +64,7 @@ template<typename MatrixType> void inverse(const MatrixType& m)
   MatrixType m3 = v3*v3.transpose(), m4(rows,cols);
   m3.computeInverseAndDetWithCheck(m4, det, invertible);
   VERIFY( rows==1 ? invertible : !invertible );
-  VERIFY_IS_MUCH_SMALLER_THAN(internal::abs(det-m3.determinant()), RealScalar(1));
+  VERIFY_IS_MUCH_SMALLER_THAN(abs(det-m3.determinant()), RealScalar(1));
   m3.computeInverseWithCheck(m4, invertible);
   VERIFY( rows==1 ? invertible : !invertible );
 #endif
diff --git a/test/linearstructure.cpp b/test/linearstructure.cpp
index fd071c995..618984d5c 100644
--- a/test/linearstructure.cpp
+++ b/test/linearstructure.cpp
@@ -11,6 +11,7 @@
 
 template<typename MatrixType> void linearStructure(const MatrixType& m)
 {
+  using std::abs;
   /* this test covers the following files:
      CwiseUnaryOp.h, CwiseBinaryOp.h, SelfCwiseBinaryOp.h 
   */
@@ -27,7 +28,7 @@ template<typename MatrixType> void linearStructure(const MatrixType& m)
              m3(rows, cols);
 
   Scalar s1 = internal::random<Scalar>();
-  while (internal::abs(s1)<1e-3) s1 = internal::random<Scalar>();
+  while (abs(s1)<1e-3) s1 = internal::random<Scalar>();
 
   Index r = internal::random<Index>(0, rows-1),
         c = internal::random<Index>(0, cols-1);
diff --git a/test/meta.cpp b/test/meta.cpp
index dc1d128d5..0ba968ba9 100644
--- a/test/meta.cpp
+++ b/test/meta.cpp
@@ -56,7 +56,7 @@ void test_meta()
   VERIFY(( internal::is_same<float,internal::remove_pointer<float* const >::type >::value));
   
   VERIFY(internal::meta_sqrt<1>::ret == 1);
-  #define VERIFY_META_SQRT(X) VERIFY(internal::meta_sqrt<X>::ret == int(internal::sqrt(double(X))))
+  #define VERIFY_META_SQRT(X) VERIFY(internal::meta_sqrt<X>::ret == int(std::sqrt(double(X))))
   VERIFY_META_SQRT(2);
   VERIFY_META_SQRT(3);
   VERIFY_META_SQRT(4);
diff --git a/test/packetmath.cpp b/test/packetmath.cpp
index c1464e994..cb96d615c 100644
--- a/test/packetmath.cpp
+++ b/test/packetmath.cpp
@@ -99,6 +99,7 @@ struct packet_helper<false,Packet>
 
 template<typename Scalar> void packetmath()
 {
+  using std::abs;
   typedef typename internal::packet_traits<Scalar>::type Packet;
   const int PacketSize = internal::packet_traits<Scalar>::size;
   typedef typename NumTraits<Scalar>::Real RealScalar;
@@ -113,7 +114,7 @@ template<typename Scalar> void packetmath()
   {
     data1[i] = internal::random<Scalar>()/RealScalar(PacketSize);
     data2[i] = internal::random<Scalar>()/RealScalar(PacketSize);
-    refvalue = (std::max)(refvalue,internal::abs(data1[i]));
+    refvalue = (std::max)(refvalue,abs(data1[i]));
   }
 
   internal::pstore(data2, internal::pload<Packet>(data1));
@@ -207,6 +208,7 @@ template<typename Scalar> void packetmath()
 
 template<typename Scalar> void packetmath_real()
 {
+  using std::abs;
   typedef typename internal::packet_traits<Scalar>::type Packet;
   const int PacketSize = internal::packet_traits<Scalar>::size;
 
@@ -220,32 +222,32 @@ template<typename Scalar> void packetmath_real()
     data1[i] = internal::random<Scalar>(-1e3,1e3);
     data2[i] = internal::random<Scalar>(-1e3,1e3);
   }
-  CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasSin, internal::sin, internal::psin);
-  CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasCos, internal::cos, internal::pcos);
-  CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasTan, internal::tan, internal::ptan);
+  CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasSin, std::sin, internal::psin);
+  CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasCos, std::cos, internal::pcos);
+  CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasTan, std::tan, internal::ptan);
   
   for (int i=0; i<size; ++i)
   {
     data1[i] = internal::random<Scalar>(-1,1);
     data2[i] = internal::random<Scalar>(-1,1);
   }
-  CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasASin, internal::asin, internal::pasin);
-  CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasACos, internal::acos, internal::pacos);
+  CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasASin, std::asin, internal::pasin);
+  CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasACos, std::acos, internal::pacos);
 
   for (int i=0; i<size; ++i)
   {
     data1[i] = internal::random<Scalar>(-87,88);
     data2[i] = internal::random<Scalar>(-87,88);
   }
-  CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasExp, internal::exp, internal::pexp);
+  CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasExp, std::exp, internal::pexp);
 
   for (int i=0; i<size; ++i)
   {
     data1[i] = internal::random<Scalar>(0,1e6);
     data2[i] = internal::random<Scalar>(0,1e6);
   }
-  CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasLog, internal::log, internal::plog);
-  CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasSqrt, internal::sqrt, internal::psqrt);
+  CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasLog, std::log, internal::plog);
+  CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasSqrt, std::sqrt, internal::psqrt);
 
   ref[0] = data1[0];
   for (int i=0; i<PacketSize; ++i)
@@ -254,7 +256,7 @@ template<typename Scalar> void packetmath_real()
 
   CHECK_CWISE2((std::min), internal::pmin);
   CHECK_CWISE2((std::max), internal::pmax);
-  CHECK_CWISE1(internal::abs, internal::pabs);
+  CHECK_CWISE1(abs, internal::pabs);
 
   ref[0] = data1[0];
   for (int i=0; i<PacketSize; ++i)
diff --git a/test/pastix_support.cpp b/test/pastix_support.cpp
index 0e57227f9..14da0944b 100644
--- a/test/pastix_support.cpp
+++ b/test/pastix_support.cpp
@@ -41,4 +41,4 @@ void test_pastix_support()
   CALL_SUBTEST_2(test_pastix_T<double>());
   CALL_SUBTEST_3( (test_pastix_T_LU<std::complex<float> >()) );
   CALL_SUBTEST_4(test_pastix_T_LU<std::complex<double> >());
-} 
\ No newline at end of file
+} 
diff --git a/test/prec_inverse_4x4.cpp b/test/prec_inverse_4x4.cpp
index f7d0aff70..9bab30a25 100644
--- a/test/prec_inverse_4x4.cpp
+++ b/test/prec_inverse_4x4.cpp
@@ -29,6 +29,7 @@ template<typename MatrixType> void inverse_permutation_4x4()
 
 template<typename MatrixType> void inverse_general_4x4(int repeat)
 {
+  using std::abs;
   typedef typename MatrixType::Scalar Scalar;
   typedef typename MatrixType::RealScalar RealScalar;
   double error_sum = 0., error_max = 0.;
@@ -38,7 +39,7 @@ template<typename MatrixType> void inverse_general_4x4(int repeat)
     RealScalar absdet;
     do {
       m = MatrixType::Random();
-      absdet = internal::abs(m.determinant());
+      absdet = abs(m.determinant());
     } while(absdet < NumTraits<Scalar>::epsilon());
     MatrixType inv = m.inverse();
     double error = double( (m*inv-MatrixType::Identity()).norm() * absdet / NumTraits<Scalar>::epsilon() );
diff --git a/test/qr.cpp b/test/qr.cpp
index 37fb7aa4d..237aa98d8 100644
--- a/test/qr.cpp
+++ b/test/qr.cpp
@@ -53,6 +53,8 @@ template<typename MatrixType, int Cols2> void qr_fixedsize()
 
 template<typename MatrixType> void qr_invertible()
 {
+  using std::log;
+  using std::abs;
   typedef typename NumTraits<typename MatrixType::Scalar>::Real RealScalar;
   typedef typename MatrixType::Scalar Scalar;
 
@@ -76,12 +78,12 @@ template<typename MatrixType> void qr_invertible()
   // now construct a matrix with prescribed determinant
   m1.setZero();
   for(int i = 0; i < size; i++) m1(i,i) = internal::random<Scalar>();
-  RealScalar absdet = internal::abs(m1.diagonal().prod());
+  RealScalar absdet = abs(m1.diagonal().prod());
   m3 = qr.householderQ(); // get a unitary
   m1 = m3 * m1 * m3;
   qr.compute(m1);
   VERIFY_IS_APPROX(absdet, qr.absDeterminant());
-  VERIFY_IS_APPROX(internal::log(absdet), qr.logAbsDeterminant());
+  VERIFY_IS_APPROX(log(absdet), qr.logAbsDeterminant());
 }
 
 template<typename MatrixType> void qr_verify_assert()
diff --git a/test/qr_colpivoting.cpp b/test/qr_colpivoting.cpp
index dd0812819..0fd19c4ee 100644
--- a/test/qr_colpivoting.cpp
+++ b/test/qr_colpivoting.cpp
@@ -72,6 +72,8 @@ template<typename MatrixType, int Cols2> void qr_fixedsize()
 
 template<typename MatrixType> void qr_invertible()
 {
+  using std::log;
+  using std::abs;
   typedef typename NumTraits<typename MatrixType::Scalar>::Real RealScalar;
   typedef typename MatrixType::Scalar Scalar;
 
@@ -95,12 +97,12 @@ template<typename MatrixType> void qr_invertible()
   // now construct a matrix with prescribed determinant
   m1.setZero();
   for(int i = 0; i < size; i++) m1(i,i) = internal::random<Scalar>();
-  RealScalar absdet = internal::abs(m1.diagonal().prod());
+  RealScalar absdet = abs(m1.diagonal().prod());
   m3 = qr.householderQ(); // get a unitary
   m1 = m3 * m1 * m3;
   qr.compute(m1);
   VERIFY_IS_APPROX(absdet, qr.absDeterminant());
-  VERIFY_IS_APPROX(internal::log(absdet), qr.logAbsDeterminant());
+  VERIFY_IS_APPROX(log(absdet), qr.logAbsDeterminant());
 }
 
 template<typename MatrixType> void qr_verify_assert()
diff --git a/test/qr_fullpivoting.cpp b/test/qr_fullpivoting.cpp
index e5c9790c8..8b8188da3 100644
--- a/test/qr_fullpivoting.cpp
+++ b/test/qr_fullpivoting.cpp
@@ -51,6 +51,8 @@ template<typename MatrixType> void qr()
 
 template<typename MatrixType> void qr_invertible()
 {
+  using std::log;
+  using std::abs;
   typedef typename NumTraits<typename MatrixType::Scalar>::Real RealScalar;
   typedef typename MatrixType::Scalar Scalar;
 
@@ -78,12 +80,12 @@ template<typename MatrixType> void qr_invertible()
   // now construct a matrix with prescribed determinant
   m1.setZero();
   for(int i = 0; i < size; i++) m1(i,i) = internal::random<Scalar>();
-  RealScalar absdet = internal::abs(m1.diagonal().prod());
+  RealScalar absdet = abs(m1.diagonal().prod());
   m3 = qr.matrixQ(); // get a unitary
   m1 = m3 * m1 * m3;
   qr.compute(m1);
   VERIFY_IS_APPROX(absdet, qr.absDeterminant());
-  VERIFY_IS_APPROX(internal::log(absdet), qr.logAbsDeterminant());
+  VERIFY_IS_APPROX(log(absdet), qr.logAbsDeterminant());
 }
 
 template<typename MatrixType> void qr_verify_assert()
diff --git a/test/real_qz.cpp b/test/real_qz.cpp
index 951cf5b31..c31621439 100644
--- a/test/real_qz.cpp
+++ b/test/real_qz.cpp
@@ -16,7 +16,7 @@ template<typename MatrixType> void real_qz(const MatrixType& m)
   /* this test covers the following files:
      RealQZ.h
   */
-  
+  using std::abs;
   typedef typename MatrixType::Index Index;
   typedef typename MatrixType::Scalar Scalar;
   typedef typename NumTraits<Scalar>::Real RealScalar;
@@ -36,11 +36,11 @@ template<typename MatrixType> void real_qz(const MatrixType& m)
   bool all_zeros = true;
   for (Index i=0; i<A.cols(); i++)
     for (Index j=0; j<i; j++) {
-      if (internal::abs(qz.matrixT()(i,j))!=Scalar(0.0))
+      if (abs(qz.matrixT()(i,j))!=Scalar(0.0))
         all_zeros = false;
-      if (j<i-1 && internal::abs(qz.matrixS()(i,j))!=Scalar(0.0))
+      if (j<i-1 && abs(qz.matrixS()(i,j))!=Scalar(0.0))
         all_zeros = false;
-      if (j==i-1 && j>0 && internal::abs(qz.matrixS()(i,j))!=Scalar(0.0) && internal::abs(qz.matrixS()(i-1,j-1))!=Scalar(0.0))
+      if (j==i-1 && j>0 && abs(qz.matrixS()(i,j))!=Scalar(0.0) && abs(qz.matrixS()(i-1,j-1))!=Scalar(0.0))
         all_zeros = false;
     }
   VERIFY_IS_EQUAL(all_zeros, true);
diff --git a/test/redux.cpp b/test/redux.cpp
index e07d4b1e4..dd6edd1bd 100644
--- a/test/redux.cpp
+++ b/test/redux.cpp
@@ -61,6 +61,7 @@ template<typename MatrixType> void matrixRedux(const MatrixType& m)
 
 template<typename VectorType> void vectorRedux(const VectorType& w)
 {
+  using std::abs;
   typedef typename VectorType::Index Index;
   typedef typename VectorType::Scalar Scalar;
   typedef typename NumTraits<Scalar>::Real RealScalar;
@@ -80,7 +81,7 @@ template<typename VectorType> void vectorRedux(const VectorType& w)
       minc = (std::min)(minc, internal::real(v[j]));
       maxc = (std::max)(maxc, internal::real(v[j]));
     }
-    VERIFY_IS_MUCH_SMALLER_THAN(internal::abs(s - v.head(i).sum()), Scalar(1));
+    VERIFY_IS_MUCH_SMALLER_THAN(abs(s - v.head(i).sum()), Scalar(1));
     VERIFY_IS_APPROX(p, v_for_prod.head(i).prod());
     VERIFY_IS_APPROX(minc, v.real().head(i).minCoeff());
     VERIFY_IS_APPROX(maxc, v.real().head(i).maxCoeff());
@@ -97,7 +98,7 @@ template<typename VectorType> void vectorRedux(const VectorType& w)
       minc = (std::min)(minc, internal::real(v[j]));
       maxc = (std::max)(maxc, internal::real(v[j]));
     }
-    VERIFY_IS_MUCH_SMALLER_THAN(internal::abs(s - v.tail(size-i).sum()), Scalar(1));
+    VERIFY_IS_MUCH_SMALLER_THAN(abs(s - v.tail(size-i).sum()), Scalar(1));
     VERIFY_IS_APPROX(p, v_for_prod.tail(size-i).prod());
     VERIFY_IS_APPROX(minc, v.real().tail(size-i).minCoeff());
     VERIFY_IS_APPROX(maxc, v.real().tail(size-i).maxCoeff());
@@ -114,7 +115,7 @@ template<typename VectorType> void vectorRedux(const VectorType& w)
       minc = (std::min)(minc, internal::real(v[j]));
       maxc = (std::max)(maxc, internal::real(v[j]));
     }
-    VERIFY_IS_MUCH_SMALLER_THAN(internal::abs(s - v.segment(i, size-2*i).sum()), Scalar(1));
+    VERIFY_IS_MUCH_SMALLER_THAN(abs(s - v.segment(i, size-2*i).sum()), Scalar(1));
     VERIFY_IS_APPROX(p, v_for_prod.segment(i, size-2*i).prod());
     VERIFY_IS_APPROX(minc, v.real().segment(i, size-2*i).minCoeff());
     VERIFY_IS_APPROX(maxc, v.real().segment(i, size-2*i).maxCoeff());
diff --git a/test/sparselu.cpp b/test/sparselu.cpp
index e960f9c93..2a73320eb 100644
--- a/test/sparselu.cpp
+++ b/test/sparselu.cpp
@@ -40,4 +40,4 @@ void test_sparselu()
   CALL_SUBTEST_2(test_sparselu_T<double>());
   CALL_SUBTEST_3(test_sparselu_T<std::complex<float> >()); 
   CALL_SUBTEST_4(test_sparselu_T<std::complex<double> >());
-}
\ No newline at end of file
+}
diff --git a/test/stable_norm.cpp b/test/stable_norm.cpp
index a25dbf51c..c09fc17b7 100644
--- a/test/stable_norm.cpp
+++ b/test/stable_norm.cpp
@@ -32,6 +32,8 @@ template<typename MatrixType> void stable_norm(const MatrixType& m)
   /* this test covers the following files:
      StableNorm.h
   */
+  using std::sqrt;
+  using std::abs;
   typedef typename MatrixType::Index Index;
   typedef typename MatrixType::Scalar Scalar;
   typedef typename NumTraits<Scalar>::Real RealScalar;
@@ -73,21 +75,21 @@ template<typename MatrixType> void stable_norm(const MatrixType& m)
 
   // test isFinite
   VERIFY(!isFinite( std::numeric_limits<RealScalar>::infinity()));
-  VERIFY(!isFinite(internal::sqrt(-internal::abs(big))));
+  VERIFY(!isFinite(sqrt(-abs(big))));
 
   // test overflow
-  VERIFY(isFinite(internal::sqrt(size)*internal::abs(big)));
-  VERIFY_IS_NOT_APPROX(internal::sqrt(copy(vbig.squaredNorm())),   internal::abs(internal::sqrt(size)*big)); // here the default norm must fail
-  VERIFY_IS_APPROX(vbig.stableNorm(), internal::sqrt(size)*internal::abs(big));
-  VERIFY_IS_APPROX(vbig.blueNorm(),   internal::sqrt(size)*internal::abs(big));
-  VERIFY_IS_APPROX(vbig.hypotNorm(),  internal::sqrt(size)*internal::abs(big));
+  VERIFY(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(internal::sqrt(size)*internal::abs(small)));
-  VERIFY_IS_NOT_APPROX(internal::sqrt(copy(vsmall.squaredNorm())),   internal::abs(internal::sqrt(size)*small)); // here the default norm must fail
-  VERIFY_IS_APPROX(vsmall.stableNorm(), internal::sqrt(size)*internal::abs(small));
-  VERIFY_IS_APPROX(vsmall.blueNorm(),   internal::sqrt(size)*internal::abs(small));
-  VERIFY_IS_APPROX(vsmall.hypotNorm(),  internal::sqrt(size)*internal::abs(small));
+  VERIFY(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));
+  VERIFY_IS_APPROX(vsmall.hypotNorm(),  sqrt(size)*abs(small));
 
 // Test compilation of cwise() version
   VERIFY_IS_APPROX(vrand.colwise().stableNorm(),      vrand.colwise().norm());
diff --git a/test/umeyama.cpp b/test/umeyama.cpp
index b6c9be3a5..972a280c3 100644
--- a/test/umeyama.cpp
+++ b/test/umeyama.cpp
@@ -93,13 +93,14 @@ Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> randMatrixSpecialUnitary(int si
 template <typename MatrixType>
 void run_test(int dim, int num_elements)
 {
+  using std::abs;
   typedef typename internal::traits<MatrixType>::Scalar Scalar;
   typedef Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic> MatrixX;
   typedef Matrix<Scalar, Eigen::Dynamic, 1> VectorX;
 
   // MUST be positive because in any other case det(cR_t) may become negative for
   // odd dimensions!
-  const Scalar c = internal::abs(internal::random<Scalar>());
+  const Scalar c = abs(internal::random<Scalar>());
 
   MatrixX R = randMatrixSpecialUnitary<Scalar>(dim);
   VectorX t = Scalar(50)*VectorX::Random(dim,1);
@@ -122,6 +123,7 @@ void run_test(int dim, int num_elements)
 template<typename Scalar, int Dimension>
 void run_fixed_size_test(int num_elements)
 {
+  using std::abs;
   typedef Matrix<Scalar, Dimension+1, Dynamic> MatrixX;
   typedef Matrix<Scalar, Dimension+1, Dimension+1> HomMatrix;
   typedef Matrix<Scalar, Dimension, Dimension> FixedMatrix;
@@ -131,7 +133,7 @@ void run_fixed_size_test(int num_elements)
 
   // MUST be positive because in any other case det(cR_t) may become negative for
   // odd dimensions!
-  const Scalar c = internal::abs(internal::random<Scalar>());
+  const Scalar c = abs(internal::random<Scalar>());
 
   FixedMatrix R = randMatrixSpecialUnitary<Scalar>(dim);
   FixedVector t = Scalar(50)*FixedVector::Random(dim,1);