angleutils.h

Go to the documentation of this file.

#ifndef ION_MATH_ANGLEUTILS_H_
#define ION_MATH_ANGLEUTILS_H_


#include <algorithm>
#include <cmath>

#include "ion/math/angle.h"
#include "ion/math/utils.h"
#include "ion/math/vector.h"
#include "ion/math/vectorutils.h"

namespace ion {
namespace math {

template <typename T>
inline Angle<T> ArcCosine(T v) {
  return Angle<T>::FromRadians(acos(v));
}
template <>
inline Angle<float> ArcCosine(float v) {
  return Angle<float>::FromRadians(acosf(v));
}

template <typename T>
inline Angle<T> ArcSine(T v) {
  return Angle<T>::FromRadians(asin(v));
}
template <>
inline Angle<float> ArcSine(float v) {
  return Angle<float>::FromRadians(asinf(v));
}

template <typename T>
inline Angle<T> ArcTangent(T v) {
  return Angle<T>::FromRadians(atan(v));
}
template <>
inline Angle<float> ArcTangent(float v) {
  return Angle<float>::FromRadians(atanf(v));
}

template <typename T>
inline Angle<T> ArcTangent2(T y, T x) {
  return Angle<T>::FromRadians(atan2(y, x));
}
template <>
inline Angle<float> ArcTangent2(float y, float x) {
  return Angle<float>::FromRadians(atan2f(y, x));
}

template <typename T>
inline T Cosine(const ion::math::Angle<T>& angle) {
  return Cosine(angle.Radians());
}

template <typename T>
inline T Sine(const ion::math::Angle<T>& angle) {
  return Sine(angle.Radians());
}

template <typename T>
inline T Tangent(const ion::math::Angle<T>& angle) {
  return Tangent(angle.Radians());
}

template <int Dimension, typename T>
inline Angle<T> AngleBetween(const ion::math::Vector<Dimension, T>& a,
                             const ion::math::Vector<Dimension, T>& b) {
  static const T kOne = static_cast<T>(1);
  DCHECK_LE(Abs(LengthSquared(a) - kOne),
            std::numeric_limits<T>::epsilon() * 100)
      << "First input vector to AngleBetween must have unit length.";
  DCHECK_LE(Abs(LengthSquared(b) - kOne),
            std::numeric_limits<T>::epsilon() * 100)
      << "Second input vector to AngleBetween must have unit length.";

  return ArcCosine(Clamp(Dot(a, b), -kOne, kOne));
}

}  // namespace math
}  // namespace ion

#endif  // ION_MATH_ANGLEUTILS_H_