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(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



}