Angle.hpp

#pragma once
 
#include <cmath>
 
namespace state_representation::units {
class Angle;
 
inline namespace literals {
constexpr Angle operator ""_rad(long double n);
 
constexpr Angle operator ""_deg(long double n);
}
 
class Angle {
private:
  long double value; 
 
public:
  constexpr Angle(long double n = 0.0);
 
  constexpr Angle(const Angle& ang);
 
  constexpr long double get_value() const;
 
  constexpr Angle& operator=(long double n);
 
  constexpr Angle& operator-();
 
  constexpr Angle& operator+=(const Angle& rhs);
 
  constexpr Angle operator+(const Angle& rhs) const;
 
  constexpr Angle& operator-=(const Angle& rhs);
 
  constexpr Angle operator-(const Angle& rhs) const;
 
  constexpr Angle& operator*=(double lambda);
 
  constexpr Angle operator*(double lambda) const;
 
  constexpr Angle& operator/=(double lambda);
 
  constexpr Angle operator/(double lambda) const;
 
  constexpr bool operator==(const Angle& rhs) const;
 
  constexpr bool operator!=(const Angle& rhs) const;
 
  constexpr bool operator>(const Angle& rhs) const;
 
  constexpr bool operator>=(const Angle& rhs) const;
 
  constexpr bool operator<(const Angle& rhs) const;
 
  constexpr bool operator<=(const Angle& rhs) const;
 
  friend constexpr double operator/(const Angle& lhs, const Angle& rhs);
 
  friend constexpr Angle operator*(double lambda, const Angle& rhs);
 
  friend constexpr Angle literals::operator ""_rad(long double n);
 
  friend constexpr Angle literals::operator ""_deg(long double n);
};
 
constexpr Angle::Angle(long double n) :
    value(atan2(sin(n), cos(n))) {}
 
constexpr Angle::Angle(const Angle& ang) :
    value(ang.value) {}
 
constexpr long double Angle::get_value() const {
  return this->value;
}
 
constexpr Angle& Angle::operator=(long double n) {
  this->value = atan2(sin(n), cos(n));
  return (*this);
}
 
constexpr Angle& Angle::operator-() {
  this->value = -this->value;
  return (*this);
}
 
constexpr Angle& Angle::operator+=(const Angle& rhs) {
  double n = this->value + rhs.value;
  this->value = atan2(sin(n), cos(n));
  return (*this);
}
 
constexpr Angle Angle::operator+(const Angle& rhs) const {
  Angle result(*this);
  result += rhs;
  return result;
}
 
constexpr Angle& Angle::operator-=(const Angle& rhs) {
  double n = this->value - rhs.value;
  this->value = atan2(sin(n), cos(n));
  return (*this);
}
 
constexpr Angle Angle::operator-(const Angle& rhs) const {
  Angle result(*this);
  result -= rhs;
  return result;
}
 
constexpr Angle& Angle::operator*=(double lambda) {
  double n = this->value * lambda;
  this->value = atan2(sin(n), cos(n));
  return (*this);
}
 
constexpr Angle Angle::operator*(double lambda) const {
  Angle result(*this);
  result *= lambda;
  return result;
}
 
constexpr Angle& Angle::operator/=(double lambda) {
  double n = this->value / lambda;
  this->value = atan2(sin(n), cos(n));
  return (*this);
}
 
constexpr Angle Angle::operator/(double lambda) const {
  Angle result(*this);
  result /= lambda;
  return result;
}
 
constexpr bool Angle::operator==(const Angle& rhs) const {
  return (abs(this->value - rhs.value) < 1e-4);
}
 
constexpr bool Angle::operator!=(const Angle& rhs) const {
  return !((*this) == rhs);
}
 
constexpr bool Angle::operator>(const Angle& rhs) const {
  return ((this->value - rhs.value) > 1e-4);
}
 
constexpr bool Angle::operator>=(const Angle& rhs) const {
  return (((*this) > rhs) or ((*this) == rhs));
}
 
constexpr bool Angle::operator<(const Angle& rhs) const {
  return ((rhs.value - this->value) > 1e-4);
}
 
constexpr bool Angle::operator<=(const Angle& rhs) const {
  return (((*this) < rhs) or ((*this) == rhs));
}
 
constexpr double operator/(const Angle& lhs, const Angle& rhs) {
  return lhs.get_value() / rhs.get_value();
}
 
constexpr Angle operator*(double lambda, const Angle& rhs) {
  return Angle(lambda * rhs.value);
}
 
inline namespace literals {
constexpr Angle operator ""_rad(long double n) {
  return Angle(n);
}
 
constexpr Angle operator ""_deg(long double n) {
  return Angle(M_PI * n / 180);
}
}
}