angle.hpp

#pragma once
 
 
#include <cmath>
 
#include "global.hpp"
 
 
namespace Cvb
{
 
CVB_BEGIN_INLINE_NS
 
 
 
class Angle final
{
  public:
 
 
 
    static Angle FromDegrees(double deg, bool trim = false) noexcept
    {
      Angle res(trim);
      res.SetDeg(deg);
      return res;
    }
 
 
    static Angle FromRadians(double rad, bool trim = false) noexcept
    {
      Angle res(trim);
      res.SetRad(rad);
      return res;
    }
 
 
    explicit Angle(bool trim = false) noexcept
      : trim_(trim)
    {
    }
 
 
    double Rad() const noexcept
    {
      return rad_;
    }
 
 
    void SetRad(double rad) noexcept
    {
      rad_ = rad;
      Trim();
    }
 
 
    double Deg() const noexcept
    {
      return rad_ * 180.0 / CVB_M_PI;
    }
 
 
    void SetDeg(double deg) noexcept
    {
      rad_ = deg* CVB_M_PI / 180.0;
      Trim();
    }
 
 
 
    bool IsTrimmed() const noexcept
    {
      return trim_;
    }
 
 
    void SetIsTrimmed(bool trim) noexcept
    {
      trim_ = trim;
      Trim();
    }
 
 
    bool operator==(const Angle& angle) const noexcept
    {
      return rad_ == angle.rad_;
    }
 
 
    bool operator!=(const Angle & angle) const  noexcept
    {
      return !(*this == angle);
    }
 
 
    bool operator<(const Angle & angle) const  noexcept
    {
      return rad_ < angle.rad_;
    }
 
 
    bool operator <= (const Angle & angle) const  noexcept
    {
      return (*this == angle) || (*this < angle);
    }
 
 
    bool operator>(const Angle & angle) const  noexcept
    {
      return (*this != angle) && !(*this < angle);
    }
 
 
 
    bool operator>=(const Angle & angle) const  noexcept
    {
      return !(*this < angle);
    }
 
 
    Angle& operator +=(const Angle & angle) noexcept
    {
      rad_ += angle.rad_;
      trim_ &= angle.trim_;
      return *this;
    }
 
 
    Angle& operator -=(const Angle & angle) noexcept
    {
      rad_ -= angle.rad_;
      trim_ &= angle.trim_;
      return *this;
    }
 
 
    Angle& operator *=(const double & value) noexcept
    {
      rad_ *= value;
      return *this;
    }
 
 
    Angle& operator /=(const double & value) noexcept
    {
      rad_ /= value;
      return *this;
    }
 
 
 
  private:
 
    void Trim()
    {
      if (!trim_)
        return;
 
      while (rad_ > CVB_M_PI)
        rad_ -= CVB_M_PI * 2;
      while (rad_ <= -CVB_M_PI)
        rad_ += CVB_M_PI * 2;
    }
 
    double rad_ = 0.0;
 
    bool trim_ = false;
};
 
 
 
 
inline Angle operator+(const Angle & lhs, const Angle & rhs)
{
  return Angle::FromRadians(lhs.Rad() + rhs.Rad(), lhs.IsTrimmed() && rhs.IsTrimmed());
}
 
 
inline Angle operator-(const Angle & lhs, const Angle & rhs)
{
  return Angle::FromRadians(lhs.Rad() - rhs.Rad(), lhs.IsTrimmed() && rhs.IsTrimmed());
}
 
 
inline Angle operator/(const Angle & lhs, const double & rhs)
{
  return Angle::FromRadians(lhs.Rad() / rhs, lhs.IsTrimmed());
}
 
 
inline Angle operator*(const Angle & lhs, const double & rhs)
{
  return Angle::FromRadians(lhs.Rad() * rhs, lhs.IsTrimmed());
}
 
 
inline Angle operator*(const double & lhs, const Angle & rhs)
{
  return rhs * lhs;
}
 
 
 
inline Angle Abs(Angle angle) noexcept
{
  return Angle::FromRadians(std::abs(angle.Rad()), angle.IsTrimmed());
}
 
 
inline Angle Acos(double d) noexcept
{
  return Angle::FromRadians(acos(d), false);
}
 
 
inline Angle Asin(double d) noexcept
{
  return Angle::FromRadians(asin(d), false);
}
 
 
inline Angle Atan(double d) noexcept
{
  return Angle::FromRadians(atan(d), false);
}
 
 
 
inline Angle Atan2(double y, double x) noexcept
{
  return Angle::FromRadians(atan2(y, x), false);
}
 
 
 
inline double Cos(Angle angle) noexcept
{
  return cos(angle.Rad());
}
 
 
inline double Cosh(Angle angle) noexcept
{
  return cosh(angle.Rad());
}
 
 
 
inline double Sin(Angle angle) noexcept
{
  return sin(angle.Rad());
}
 
 
inline double Sinh(Angle angle) noexcept
{
  return sinh(angle.Rad());
}
 
 
inline double Tan(Angle angle) noexcept
{
  return tan(angle.Rad());
}
 
 
inline double Tanh(Angle angle) noexcept
{
  return tanh(angle.Rad());
}
 
 
inline int Sign(Angle angle) noexcept
{
  return ((0.0 < angle.Rad()) - (angle.Rad() < 0.0));
}
 
 
inline Angle Max(Angle a, Angle b) noexcept
{
  if (b > a)
    return b;
  else
    return a;
}
 
 
inline Angle Min(Angle a, Angle b) noexcept
{
  if (b < a)
    return b;
  else
    return a;
}
 
CVB_END_INLINE_NS
 
 
 
}