SPAR/AIModule/SparAIModule/Utils/Vector2.h

Go to the documentation of this file.

#pragma once

#include <boost/type_traits.hpp>

// TODO templated version of arithmetic operator?

template<class T>
class Vector2
{
  static_assert<boost::is_signed<T>::value || boost::is_float<T>::value> arithmetic_operations_assume_signed_types;
  static_assert<boost::is_scalar<T>::value> arithmetic_operations_assume_scalar_types;

public:
  Vector2(const T& x, const T& y) : m_X(x), m_Y(y) { }

  template<class U>
  Vector2(const U& x, const U& y) : m_X(static_cast<T>(x)), m_Y(static_cast<T>(y)) { }
  
  template<class U>
  Vector2(const Vector2<U>& other)
    :m_X(static_cast<T>(other.x()))
    ,m_Y(static_cast<T>(other.y()))
  {
  }

  template<class U>
  Vector2<T>& operator=(const Vector2<U>& other)
  {
    m_X = static_cast<T>(other.x());
    m_Y = static_cast<T>(other.y());
    return *this;
  }

  T& x() { return m_X; }
  T& y() { return m_Y; }

  T x() const { return m_X; }
  T y() const { return m_Y; }

  Vector2<T> operator+(const Vector2<T>& other) const
  {
    return Vector2<T>(m_X + other.m_X, m_Y + other.m_Y);
  }

  Vector2<T>& operator+=(const Vector2<T>& other)
  {
    m_X += other.m_X;
    m_Y += other.m_Y;
    return *this;
  }

  Vector2<T> operator-(const Vector2<T>& other) const
  {
    return Vector2<T>(m_X - other.m_X, m_Y - other.m_Y);
  }

  Vector2<T>& operator-=(const Vector2<T>& other)
  {
    m_X -= other.m_X;
    m_Y -= other.m_Y;
    return *this;
  }

  Vector2<T> operator-() const
  {
    return Vector2<T>(-m_X, -m_Y);
  }

  // TODO use least restrictive type for return value
  template<class U>
  Vector2<T> operator*(const U& val) const
  {
    static_assert<boost::is_scalar<U>::value> multiplication_by_a_scalar_value;
    unused(multiplication_by_a_scalar_value);

    return Vector2<T>(static_cast<T>(val * m_X), static_cast<T>(val * m_Y));
  }

  template<class U>
  Vector2<T>& operator*=(const U& val)
  {
    static_assert<boost::is_scalar<U>::value> multiplication_by_a_scalar_value;
    unused(multiplication_by_a_scalar_value);

    m_X *= val;
    m_Y *= val;
    return *this;
  }

  T dot(const Vector2<T>& other) const
  {
    return (m_X * other.m_X) + (m_Y * other.m_Y);
  }

  Vector2<T> perpendicular() const
  {
    return Vector2<T>(-m_Y, m_X);
  }

  bool operator==(const Vector2<T>& other) const
  {
    return m_X == other.m_X && m_Y == other.m_Y;
  }

  bool operator!=(const Vector2<T>& other) const
  {
    return !(*this == other);
  }

  double squared_length() const
  {
    return static_cast<double>(dot(*this));
  }

  double length() const
  {
    return sqrt(squared_length());
  }

  double squared_distance_to(const Vector2<T>& other) const
  {
    return (*this - other).squared_length();
  }

  double distance_to(const Vector2<T>& other) const
  {
    return sqrt(squared_distance_to(other));
  }

private:
  T m_X;
  T m_Y;
};

template<class T, class U>
Vector2<T> operator*(const U& val, const Vector2<T>& vec)
{
  static_assert<boost::is_scalar<U>::value> multiplication_by_a_scalar_value;
  unused(multiplication_by_a_scalar_value);

  return vec * val;
};

typedef Vector2<int>    Vector2i;
typedef Vector2<float>  Vector2f;
typedef Vector2<double> Vector2d;