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 FromDegrees(double deg, bool trim = false) noexcept {…}


    static Angle FromRadians(double rad, bool trim = false) noexcept
    {
      Angle res(trim);
      res.SetRad(rad);
      return res;
    }
    static Angle FromRadians(double rad, bool trim = false) noexcept {…}


    Angle() noexcept = default;


    explicit Angle(bool trim) noexcept
        : trim_(trim)
    {
    }
    explicit Angle(bool trim) noexcept {…}


    double Rad() const noexcept
    {
      return rad_;
    }
    double Rad() const noexcept {…}


    void SetRad(double rad) noexcept
    {
      rad_ = rad;
      Trim();
    }
    void SetRad(double rad) noexcept {…}


    double Deg() const noexcept
    {
      return rad_ * 180.0 / CVB_M_PI;
    }
    double Deg() const noexcept {…}


    void SetDeg(double deg) noexcept
    {
      rad_ = deg * CVB_M_PI / 180.0;
      Trim();
    }
    void SetDeg(double deg) noexcept {…}


    bool IsTrimmed() const noexcept
    {
      return trim_;
    }
    bool IsTrimmed() const noexcept {…}


    void SetIsTrimmed(bool trim) noexcept
    {
      trim_ = trim;
      Trim();
    }
    void SetIsTrimmed(bool trim) noexcept {…}


    bool operator==(const Angle &angle) const noexcept
    {
      return rad_ == angle.rad_;
    }
    bool operator==(const Angle &angle) const noexcept {…}


    bool operator!=(const Angle &angle) const noexcept
    {
      return !(*this == angle);
    }
    bool operator!=(const Angle &angle) const noexcept {…}


    bool operator<(const Angle &angle) const noexcept
    {
      return rad_ < angle.rad_;
    }
    bool operator<(const Angle &angle) const noexcept {…}


    bool operator<=(const Angle &angle) const noexcept
    {
      return (*this == angle) || (*this < angle);
    }
    bool operator<=(const Angle &angle) const noexcept {…}


    bool operator>(const Angle &angle) const noexcept
    {
      return (*this != angle) && !(*this < angle);
    }
    bool operator>(const Angle &angle) const noexcept {…}


    bool operator>=(const Angle &angle) const noexcept
    {
      return !(*this < angle);
    }
    bool operator>=(const Angle &angle) const noexcept {…}


    Angle &operator+=(const Angle &angle) noexcept
    {
      rad_ += angle.rad_;
      trim_ &= angle.trim_;
      return *this;
    }
    Angle &operator+=(const Angle &angle) noexcept {…}


    Angle &operator-=(const Angle &angle) noexcept
    {
      rad_ -= angle.rad_;
      trim_ &= angle.trim_;
      return *this;
    }
    Angle &operator-=(const Angle &angle) noexcept {…}


    Angle &operator*=(const double &value) noexcept
    {
      rad_ *= value;
      return *this;
    }
    Angle &operator*=(const double &value) noexcept {…}


    Angle &operator/=(const double &value) noexcept
    {
      rad_ /= value;
      return *this;
    }
    Angle &operator/=(const double &value) noexcept {…}
 
  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;
  };
  class Angle final {…};


  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) {…}


  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) {…}


  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) {…}


  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) {…}


  inline Angle operator*(const double &lhs, const Angle &rhs)
  {
    return rhs * lhs;
  }
  inline Angle operator*(const double &lhs, const Angle &rhs) {…}


  inline Angle Abs(Angle angle) noexcept
  {
    return Angle::FromRadians(std::abs(angle.Rad()), angle.IsTrimmed());
  }
  inline Angle Abs(Angle angle) noexcept {…}


  inline Angle Acos(double d) noexcept
  {
    return Angle::FromRadians(acos(d), false);
  }
  inline Angle Acos(double d) noexcept {…}


  inline Angle Asin(double d) noexcept
  {
    return Angle::FromRadians(asin(d), false);
  }
  inline Angle Asin(double d) noexcept {…}


  inline Angle Atan(double d) noexcept
  {
    return Angle::FromRadians(atan(d), false);
  }
  inline Angle Atan(double d) noexcept {…}


  inline Angle Atan2(double y, double x) noexcept
  {
    return Angle::FromRadians(atan2(y, x), false);
  }
  inline Angle Atan2(double y, double x) noexcept {…}


  inline double Cos(Angle angle) noexcept
  {
    return cos(angle.Rad());
  }
  inline double Cos(Angle angle) noexcept {…}


  inline double Cosh(Angle angle) noexcept
  {
    return cosh(angle.Rad());
  }
  inline double Cosh(Angle angle) noexcept {…}


  inline double Sin(Angle angle) noexcept
  {
    return sin(angle.Rad());
  }
  inline double Sin(Angle angle) noexcept {…}


  inline double Sinh(Angle angle) noexcept
  {
    return sinh(angle.Rad());
  }
  inline double Sinh(Angle angle) noexcept {…}


  inline double Tan(Angle angle) noexcept
  {
    return tan(angle.Rad());
  }
  inline double Tan(Angle angle) noexcept {…}


  inline double Tanh(Angle angle) noexcept
  {
    return tanh(angle.Rad());
  }
  inline double Tanh(Angle angle) noexcept {…}


  inline int Sign(Angle angle) noexcept
  {
    return ((0.0 < angle.Rad()) - (angle.Rad() < 0.0));
  }
  inline int Sign(Angle angle) noexcept {…}


  inline Angle Max(Angle a, Angle b) noexcept
  {
    if (b > a)
      return b;
    else
      return a;
  }
  inline Angle Max(Angle a, Angle b) noexcept {…}


  inline Angle Min(Angle a, Angle b) noexcept
  {
    if (b < a)
      return b;
    else
      return a;
  }
  inline Angle Min(Angle a, Angle b) noexcept {…}
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb