angle.h

Go to the documentation of this file.

#ifndef ION_MATH_ANGLE_H_
#define ION_MATH_ANGLE_H_

#include <cmath>
#include <istream>  // NOLINT
#include <ostream>  // NOLINT

#include "ion/base/stringutils.h"

namespace ion {
namespace math {

template <typename T>
class Angle {
 public:
  Angle() : radians_(0) {}

  template <typename U>
  explicit Angle(const Angle<U> other)
      : radians_(static_cast<T>(other.Radians())) {}

  static Angle FromRadians(const T& angle) {
    return Angle(angle);
  }

  static Angle FromDegrees(const T& angle) {
    return Angle(DegreesToRadians(angle));
  }

  T Radians() const { return radians_; }
  T Degrees() const {  return RadiansToDegrees(radians_); }


  const Angle operator-() const { return Angle::FromRadians(-radians_); }

  void operator+=(const Angle& a) { radians_ += a.radians_; }
  void operator-=(const Angle& a) { radians_ -= a.radians_; }
  void operator*=(T s) { radians_ *= s; }
  void operator/=(T s) { radians_ /= s; }

  friend const Angle operator+(const Angle& a0, const Angle& a1) {
    return FromRadians(a0.radians_ + a1.radians_);
  }
  friend const Angle operator-(const Angle& a0, const Angle& a1) {
    return FromRadians(a0.radians_ - a1.radians_);
  }
  friend const Angle operator*(const Angle& a, T s) {
    return FromRadians(a.radians_ * s);
  }
  friend const Angle operator*(T s, const Angle& a) {
    return FromRadians(s * a.radians_);
  }
  friend const Angle operator/(const Angle& a, T s) {
    return FromRadians(a.radians_ / s);
  }

  friend bool operator==(const Angle& a0, const Angle& a1) {
    return a0.radians_ == a1.radians_;
  }
  friend bool operator!=(const Angle& a0, const Angle& a1) {
    return a0.radians_ != a1.radians_;
  }

  friend bool operator<(const Angle& a0, const Angle& a1) {
    return a0.radians_ < a1.radians_;
  }
  friend bool operator>(const Angle& a0, const Angle& a1) {
    return a0.radians_ > a1.radians_;
  }
  friend bool operator<=(const Angle& a0, const Angle& a1) {
    return a0.radians_ <= a1.radians_;
  }
  friend bool operator>=(const Angle& a0, const Angle& a1) {
    return a0.radians_ >= a1.radians_;
  }

 private:
  explicit Angle(const T angle_rad) {
    radians_ = angle_rad;
  }

  static T RadiansToDegrees(const T& radians) {
    static const T kRadToDeg = 180 / static_cast<T>(M_PI);
    return radians * kRadToDeg;
  }

  static T DegreesToRadians(const T& degrees) {
    static const T kDegToRad = static_cast<T>(M_PI) / 180;
    return degrees * kDegToRad;
  }

  T radians_;
};


template <typename T>
std::ostream& operator<<(std::ostream& out, const Angle<T>& a) {
  return out << a.Degrees() << " deg";
}

template <typename T>
std::istream& operator>>(std::istream& in, Angle<T>& a) {
  T angle;
  if (in >> angle) {
    if (base::GetExpectedString(in, "deg")) {
      a = Angle<T>::FromDegrees(angle);
    } else {
      in.clear();  // Resets "deg" failure.
      if (base::GetExpectedString(in, "rad"))
        a = Angle<T>::FromRadians(angle);
    }
  }

  return in;
}




typedef Angle<float> Anglef;
typedef Angle<double> Angled;

}  // namespace math
}  // namespace ion

#endif  // ION_MATH_ANGLE_H_