Don't qualify potentially overloaded functions with the std namespace

[libs/math.git] / source / geometry / angle.h

diff --git a/source/geometry/angle.h b/source/geometry/angle.h
index 2cfb1176005206c870efbf6cefd87170a938afde..fbf6d061af0b9aef10b2f0cbb8b58e8b84ed8ac4 100644 (file)
--- a/source/geometry/angle.h
+++ b/source/geometry/angle.h
@@ -198,49 +198,57 @@ inline Angle<T> wrap_balanced(const Angle<T> &a)
 template<typename T>
 inline Angle<T> abs(const Angle<T> &angle)
 {
-       return Angle<T>::from_radians(std::abs(angle.radians()));
+       using std::abs;
+       return Angle<T>::from_radians(abs(angle.radians()));
 }
 
 template<typename T>
 inline T sin(const Angle<T> &angle)
 {
-       return std::sin(angle.radians());
+       using std::sin;
+       return sin(angle.radians());
 }
 
 template<typename T>
 inline Angle<T> asin(T s)
 {
-       return Angle<T>::from_radians(std::asin(s));
+       using std::asin;
+       return Angle<T>::from_radians(asin(s));
 }
 
 template<typename T>
 inline T cos(const Angle<T> &angle)
 {
-       return std::cos(angle.radians());
+       using std::cos;
+       return cos(angle.radians());
 }
 
 template<typename T>
 inline Angle<T> acos(T s)
 {
-       return Angle<T>::from_radians(std::acos(s));
+       using std::acos;
+       return Angle<T>::from_radians(acos(s));
 }
 
 template<typename T>
 inline T tan(const Angle<T> &angle)
 {
-       return std::tan(angle.radians());
+       using std::tan;
+       return tan(angle.radians());
 }
 
 template<typename T>
 inline Angle<T> atan(T s)
 {
-       return Angle<T>::from_radians(std::atan(s));
+       using std::atan;
+       return Angle<T>::from_radians(atan(s));
 }
 
 template<typename T>
 inline Angle<T> atan2(T y, T x)
 {
-       return Angle<T>::from_radians(std::atan2(y, x));
+       using std::atan2;
+       return Angle<T>::from_radians(atan2(y, x));
 }
 
 } // namespace Geometry