X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fgeometry%2Fangle.h;h=fe4895cfe7635ebe85e58e83b353b81dc2561208;hb=HEAD;hp=2cfb1176005206c870efbf6cefd87170a938afde;hpb=29465bb366457a0087f2391cbb30ab04171fa1ff;p=libs%2Fmath.git

diff --git a/source/geometry/angle.h b/source/geometry/angle.h
index 2cfb117..fe4895c 100644
--- a/source/geometry/angle.h
+++ b/source/geometry/angle.h
@@ -20,22 +20,22 @@ private:
 public:
 	Angle(): value(0) { }
 	template<typename U>
-	Angle(const Angle<U> &other): value(other.value) { }
+	Angle(const Angle<U> &other): value(other.radians()) { }
 
 	static Angle from_degrees(T);
 	static Angle from_radians(T);
 	static Angle from_turns(T);
 
 	static Angle zero() { return from_radians(0); }
-	static Angle right() { return from_radians(M_PI/2); }
+	static Angle right() { return from_turns(0.25); }
 	static Angle quarter_turn() { return right(); }
-	static Angle straight() { return from_radians(M_PI); }
+	static Angle straight() { return from_turns(0.5); }
 	static Angle half_turn() { return straight(); }
-	static Angle full_turn() { return from_radians(2*M_PI); }
+	static Angle full_turn() { return from_turns(1); }
 
-	T degrees() const { return value*180/M_PI; }
+	T degrees() const { return value*57.2957795130823208768; }
 	T radians() const { return value; }
-	T turns() const { return value/(2*M_PI); }
+	T turns() const { return value/6.28318530717958647692; }
 
 	Angle &operator+=(const Angle &);
 	Angle &operator-=(const Angle &);
@@ -57,7 +57,7 @@ public:
 template<typename T>
 inline Angle<T> Angle<T>::from_degrees(T d)
 {
-	return Angle<T>(d*M_PI/180);
+	return Angle<T>(d/57.2957795130823208768);
 }
 
 template<typename T>
@@ -69,7 +69,7 @@ inline Angle<T> Angle<T>::from_radians(T r)
 template<typename T>
 inline Angle<T> Angle<T>::from_turns(T t)
 {
-	return Angle<T>(t*2*M_PI);
+	return Angle<T>(t*6.28318530717958647692);
 }
 
 template<typename T>
@@ -155,10 +155,11 @@ inline T operator/(const Angle<T> &a1, const Angle<T> &a2)
 template<typename T>
 inline Angle<T> &Angle<T>::wrap_with_base(const Angle<T> &b)
 {
+	const T two_pi = 6.28318530717958647692;
 	while(value<b.value)
-		value += 2*M_PI;
-	while(value>=b.value+2*M_PI)
-		value -= 2*M_PI;
+		value += two_pi;
+	while(value>=b.value+two_pi)
+		value -= two_pi;
 	return *this;
 }
 
@@ -198,49 +199,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