Velocity.hpp

#pragma once
 
#include <chrono>
#include "state_representation/units/Distance.hpp"
#include "state_representation/units/Angle.hpp"
 
using namespace std::chrono_literals;
 
namespace state_representation::units {
template<class T>
class Velocity;
 
using LinearVelocity = Velocity<Distance>;
using AngularVelocity = Velocity<Angle>;
 
inline namespace literals {
constexpr LinearVelocity operator ""_m_s(long double n);
 
constexpr LinearVelocity operator ""_m_h(long double n);
 
constexpr LinearVelocity operator ""_m_ms(long double n);
 
constexpr LinearVelocity operator ""_km_h(long double n);
 
constexpr LinearVelocity operator ""_km_s(long double n);
 
constexpr LinearVelocity operator ""_km_ms(long double n);
 
constexpr LinearVelocity operator ""_mm_h(long double n);
 
constexpr AngularVelocity operator ""_rad_s(long double n);
 
constexpr AngularVelocity operator ""_deg_s(long double n);
}
 
template<class T>
class Velocity {
private:
  long double value; 
 
public:
  constexpr Velocity(long double n = 0.0);
 
  constexpr Velocity(const Velocity<T>& vel);
 
  constexpr long double get_value() const;
 
  constexpr Velocity<T>& operator-();
 
  constexpr Velocity<T>& operator+=(const Velocity<T>& rhs);
 
  constexpr Velocity<T> operator+(const Velocity<T>& rhs) const;
 
  constexpr Velocity<T>& operator-=(const Velocity<T>& rhs);
 
  constexpr Velocity<T> operator-(const Velocity<T>& rhs) const;
 
  constexpr Velocity<T>& operator*=(double lambda);
 
  constexpr Velocity<T> operator*(double lambda) const;
 
  constexpr Velocity<T>& operator/=(double lambda);
 
  constexpr Velocity<T> operator/(double lambda) const;
 
  constexpr bool operator==(const Velocity<T>& rhs) const;
 
  constexpr bool operator!=(const Velocity<T>& rhs) const;
 
  constexpr bool operator>(const Velocity<T>& rhs) const;
 
  constexpr bool operator>=(const Velocity<T>& rhs) const;
 
  constexpr bool operator<(const Velocity<T>& rhs) const;
 
  constexpr bool operator<=(const Velocity<T>& rhs) const;
 
  friend constexpr double operator/(const Velocity<T>& lhs, const Velocity<T>& rhs) {
    return lhs.value / rhs.value;
  }
 
  friend constexpr Velocity<T> operator*(double lambda, const Velocity<T>& rhs) {
    return Velocity<T>(lambda * rhs.value);
  }
 
  template<class Rep, class DurationRatio>
  friend constexpr Velocity<T> operator/(const T& lhs, const std::chrono::duration<Rep, DurationRatio>& rhs);
};
 
template<class T>
constexpr Velocity<T>::Velocity(long double n):
    value(n) {}
 
template<class T>
constexpr Velocity<T>::Velocity(const Velocity<T>& vel):
    value(vel.value) {}
 
template<class T>
constexpr long double Velocity<T>::get_value() const {
  return this->value;
}
 
template<class T>
constexpr Velocity<T>& Velocity<T>::operator-() {
  this->value = -this->value;
  return (*this);
}
 
template<class T>
constexpr Velocity<T>& Velocity<T>::operator+=(const Velocity<T>& rhs) {
  this->value = this->value + rhs.value;
  return (*this);
}
 
template<class T>
constexpr Velocity<T> Velocity<T>::operator+(const Velocity<T>& rhs) const {
  Velocity<T> result(*this);
  result += rhs;
  return result;
}
 
template<class T>
constexpr Velocity<T>& Velocity<T>::operator-=(const Velocity<T>& rhs) {
  this->value = this->value - rhs.value;
  return (*this);
}
 
template<class T>
constexpr Velocity<T> Velocity<T>::operator-(const Velocity<T>& rhs) const {
  Velocity<T> result(*this);
  result -= rhs;
  return result;
}
 
template<class T>
constexpr Velocity<T>& Velocity<T>::operator*=(double lambda) {
  this->value = this->value * lambda;
  return (*this);
}
 
template<class T>
constexpr Velocity<T> Velocity<T>::operator*(double lambda) const {
  Velocity<T> result(*this);
  result *= lambda;
  return result;
}
 
template<class T>
constexpr Velocity<T>& Velocity<T>::operator/=(double lambda) {
  this->value = this->value / lambda;
  return (*this);
}
 
template<class T>
constexpr Velocity<T> Velocity<T>::operator/(double lambda) const {
  Velocity<T> result(*this);
  result /= lambda;
  return result;
}
 
template<class T>
constexpr bool Velocity<T>::operator==(const Velocity<T>& rhs) const {
  return (abs(this->value - rhs.value) < 1e-4);
}
 
template<class T>
constexpr bool Velocity<T>::operator!=(const Velocity<T>& rhs) const {
  return !((*this) == rhs);
}
 
template<class T>
constexpr bool Velocity<T>::operator>(const Velocity<T>& rhs) const {
  return ((this->value - rhs.value) > 1e-4);
}
 
template<class T>
constexpr bool Velocity<T>::operator>=(const Velocity<T>& rhs) const {
  return (((*this) > rhs) or ((*this) == rhs));
}
 
template<class T>
constexpr bool Velocity<T>::operator<(const Velocity<T>& rhs) const {
  return ((rhs.value - this->value) > 1e-4);
}
 
template<class T>
constexpr bool Velocity<T>::operator<=(const Velocity<T>& rhs) const {
  return (((*this) < rhs) or ((*this) == rhs));
}
 
template<class T, class Rep, class DurationRatio>
constexpr Velocity<T> operator/(const T& dist, const std::chrono::duration<Rep, DurationRatio>& rhs) {
  const auto rhsInSeconds = std::chrono::duration_cast<std::chrono::seconds>(rhs);
  return Velocity<T>(dist.get_value() / rhsInSeconds.count());
}
 
inline namespace literals {
constexpr LinearVelocity operator ""_m_s(long double n) {
  Distance d = 1.0_m;
  auto t = 1.0s;
  return n * (d / t);
}
 
constexpr LinearVelocity operator ""_m_h(long double n) {
  Distance d = 1.0_m;
  auto t = 1.0h;
  return n * (d / t);
}
 
constexpr LinearVelocity operator ""_m_ms(long double n) {
  Distance d = 1.0_m;
  auto t = 1.0ms;
  return n * (d / t);
}
 
constexpr LinearVelocity operator ""_km_h(long double n) {
  Distance d = 1.0_km;
  auto t = 1.0h;
  return n * (d / t);
}
 
constexpr LinearVelocity operator ""_km_s(long double n) {
  Distance d = 1.0_km;
  auto t = 1.0s;
  return n * (d / t);
}
 
constexpr LinearVelocity operator ""_km_ms(long double n) {
  Distance d = 1.0_km;
  auto t = 1.0ms;
  return n * (d / t);
}
 
constexpr LinearVelocity operator ""_mm_h(long double n) {
  Distance d = 1.0_mm;
  auto t = 1.0h;
  return n * (d / t);
}
 
constexpr AngularVelocity operator ""_rad_s(long double n) {
  Angle a = 1.0_rad;
  auto t = 1.0s;
  return n * (a / t);
}
 
constexpr AngularVelocity operator ""_deg_s(long double n) {
  Angle a = 1.0_deg;
  auto t = 1.0s;
  return n * (a / t);
}
}
}