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 &);
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>
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>
template<typename T>
inline Angle<T> &Angle<T>::wrap_with_base(const Angle<T> &b)
{
+ const float 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;
}
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