Distance.hpp

#pragma once
 
#include <cmath>
 
namespace state_representation::units {
class Distance;
 
inline namespace literals {
constexpr Distance operator ""_m(long double n);
 
constexpr Distance operator ""_km(long double n);
 
constexpr Distance operator ""_dm(long double n);
 
constexpr Distance operator ""_cm(long double n);
 
constexpr Distance operator ""_mm(long double n);
}
 
class Distance {
private:
  long double value; 
 
public:
  constexpr Distance(long double n = 0.0);
 
  constexpr Distance(const Distance& dist);
 
  constexpr long double get_value() const;
 
  constexpr Distance& operator-();
 
  constexpr Distance& operator+=(const Distance& rhs);
 
  constexpr Distance operator+(const Distance& rhs) const;
 
  constexpr Distance& operator-=(const Distance& rhs);
 
  constexpr Distance operator-(const Distance& rhs) const;
 
  constexpr Distance& operator*=(double lambda);
 
  constexpr Distance operator*(double lambda) const;
 
  constexpr Distance& operator/=(double lambda);
 
  constexpr Distance operator/(double lambda) const;
 
  constexpr bool operator==(const Distance& rhs) const;
 
  constexpr bool operator!=(const Distance& rhs) const;
 
  constexpr bool operator>(const Distance& rhs) const;
 
  constexpr bool operator>=(const Distance& rhs) const;
 
  constexpr bool operator<(const Distance& rhs) const;
 
  constexpr bool operator<=(const Distance& rhs) const;
 
  friend constexpr double operator/(const Distance& lhs, const Distance& rhs);
 
  friend constexpr Distance operator*(double lambda, const Distance& rhs);
 
  friend constexpr Distance literals::operator ""_m(long double n);
 
  friend constexpr Distance literals::operator ""_km(long double n);
 
  friend constexpr Distance literals::operator ""_dm(long double n);
 
  friend constexpr Distance literals::operator ""_cm(long double n);
 
  friend constexpr Distance literals::operator ""_mm(long double n);
};
 
constexpr Distance::Distance(long double n) :
    value(n) {}
 
constexpr Distance::Distance(const Distance& dist) :
    value(dist.value) {}
 
constexpr long double Distance::get_value() const {
  return this->value;
}
 
constexpr Distance& Distance::operator-() {
  this->value = -this->value;
  return (*this);
}
 
constexpr Distance& Distance::operator+=(const Distance& rhs) {
  this->value = this->value + rhs.value;
  return (*this);
}
 
constexpr Distance Distance::operator+(const Distance& rhs) const {
  Distance result(*this);
  result += rhs;
  return result;
}
 
constexpr Distance& Distance::operator-=(const Distance& rhs) {
  this->value = this->value - rhs.value;
  return (*this);
}
 
constexpr Distance Distance::operator-(const Distance& rhs) const {
  Distance result(*this);
  result -= rhs;
  return result;
}
 
constexpr Distance& Distance::operator*=(double lambda) {
  this->value = this->value * lambda;
  return (*this);
}
 
constexpr Distance Distance::operator*(double lambda) const {
  Distance result(*this);
  result *= lambda;
  return result;
}
 
constexpr Distance& Distance::operator/=(double lambda) {
  this->value = this->value / lambda;
  return (*this);
}
 
constexpr Distance Distance::operator/(double lambda) const {
  Distance result(*this);
  result /= lambda;
  return result;
}
 
constexpr bool Distance::operator==(const Distance& rhs) const {
  return (abs(this->value - rhs.value) < 1e-4);
}
 
constexpr bool Distance::operator!=(const Distance& rhs) const {
  return !((*this) == rhs);
}
 
constexpr bool Distance::operator>(const Distance& rhs) const {
  return ((this->value - rhs.value) > 1e-4);
}
 
constexpr bool Distance::operator>=(const Distance& rhs) const {
  return (((*this) > rhs) or ((*this) == rhs));
}
 
constexpr bool Distance::operator<(const Distance& rhs) const {
  return ((rhs.value - this->value) > 1e-4);
}
 
constexpr bool Distance::operator<=(const Distance& rhs) const {
  return (((*this) < rhs) or ((*this) == rhs));
}
 
constexpr double operator/(const Distance& lhs, const Distance& rhs) {
  return lhs.get_value() / rhs.get_value();
}
 
constexpr Distance operator*(double lambda, const Distance& rhs) {
  return Distance(lambda * rhs.value);
}
 
inline namespace literals {
constexpr Distance operator ""_m(long double n) {
  return Distance(n);
}
 
constexpr Distance operator ""_km(long double n) {
  return Distance(1e3 * n);
}
 
constexpr Distance operator ""_dm(long double n) {
  return Distance(1e-1 * n);
}
 
constexpr Distance operator ""_cm(long double n) {
  return Distance(1e-2 * n);
}
 
constexpr Distance operator ""_mm(long double n) {
  return Distance(1e-3 * n);
}
}
}