vector.h

Go to the documentation of this file.

#ifndef ION_MATH_VECTOR_H_
#define ION_MATH_VECTOR_H_


#include "base/integral_types.h"
#include "ion/base/logging.h"
#include "ion/base/static_assert.h"
#include "ion/base/stringutils.h"

namespace ion {
namespace math {




template <int Dimension, typename T>
class VectorBase {
 public:
  enum { kDimension = Dimension };
  typedef T ValueType;

  void Set(T e0);                    // Only when Dimension == 1.
  void Set(T e0, T e1);              // Only when Dimension == 2.
  void Set(T e0, T e1, T e2);        // Only when Dimension == 3.
  void Set(T e0, T e1, T e2, T e3);  // Only when Dimension == 4.

  T& operator[](int index) {
    DCHECK(index >= 0 && index < Dimension);
    return elem_[index];
  }

  const T& operator[](int index) const {
    DCHECK(index >= 0 && index < Dimension);
    return elem_[index];
  }

  static bool AreValuesEqual(const VectorBase& v0, const VectorBase& v1);

  T* Data() { return &elem_[0]; }
  const T* Data() const { return &elem_[0]; }

  void Print(std::ostream& out, const char tag) const {  // NOLINT
    out << tag << "[";
    for (int i = 0; i < Dimension; ++i) {
      out << elem_[i];
      if (i != Dimension - 1)
        out << ", ";
    }
    out << "]";
  }

  template <char tag>
  void Read(std::istream& in) {  // NOLINT
    VectorBase v;
    if (base::GetExpectedChar<tag>(in) && base::GetExpectedChar<'['>(in)) {
      for (int i = 0; i < Dimension; ++i) {
        in >> v.elem_[i];
        if (i != Dimension - 1 && !base::GetExpectedChar<','>(in))
          return;
      }
      if (base::GetExpectedChar<']'>(in))
        *this = v;
    }
  }

 protected:
  VectorBase() : elem_() {}

  explicit VectorBase(T e0);           // Only when Dimension == 1.
  VectorBase(T e0, T e1);              // Only when Dimension == 2.
  VectorBase(T e0, T e1, T e2);        // Only when Dimension == 3.
  VectorBase(T e0, T e1, T e2, T e3);  // Only when Dimension == 4.

  VectorBase(const VectorBase<Dimension - 1, T>& v, T s);

  template <typename U> explicit VectorBase(const VectorBase<Dimension, U>& v);

  static const VectorBase Zero();

  static const VectorBase Fill(T value);


  void Add(const VectorBase& v);
  void Subtract(const VectorBase& v);
  void Multiply(T s);
  void Divide(T s);

  const VectorBase Negation() const;

  static const VectorBase Product(const VectorBase& v0, const VectorBase& v1);
  static const VectorBase Quotient(const VectorBase& v0, const VectorBase& v1);
  static const VectorBase Sum(const VectorBase& v0, const VectorBase& v1);
  static const VectorBase Difference(const VectorBase& v0,
                                     const VectorBase& v1);
  static const VectorBase Scale(const VectorBase& v, T s);
  static const VectorBase Divide(const VectorBase& v, T s);

  template <int Dim, typename U> struct StaticHelper;

 private:
  T elem_[Dimension];
};




template <int Dimension, typename T>
class Vector : public VectorBase<Dimension, T> {
 public:
  Vector() : BaseType() {}

  explicit Vector(T e0) : BaseType(e0) {}
  Vector(T e0, T e1) : BaseType(e0, e1) {}
  Vector(T e0, T e1, T e2) : BaseType(e0, e1, e2) {}
  Vector(T e0, T e1, T e2, T e3) : BaseType(e0, e1, e2, e3) {}

  Vector(const Vector<Dimension - 1, T>& v, T s) : BaseType(v, s) {}

  template <typename U> explicit Vector(const Vector<Dimension, U>& v)
      : BaseType(v) {}

  static const Vector Zero() { return ToVector(BaseType::Zero()); }

  static const Vector Fill(T value) { return ToVector(BaseType::Fill(value)); }

  static const Vector AxisX();
  static const Vector AxisY();
  static const Vector AxisZ();
  static const Vector AxisW();

  void operator+=(const Vector& v) { BaseType::Add(v); }
  void operator-=(const Vector& v) { BaseType::Subtract(v); }
  void operator*=(T s) { BaseType::Multiply(s); }
  void operator/=(T s) { BaseType::Divide(s); }

  const Vector operator-() const { return ToVector(BaseType::Negation()); }

  friend const Vector operator+(const Vector& v0, const Vector& v1) {
    return ToVector(BaseType::Sum(v0, v1));
  }
  friend const Vector operator-(const Vector& v0, const Vector& v1) {
    return ToVector(BaseType::Difference(v0, v1));
  }
  friend const Vector operator*(const Vector& v, T s) {
    return ToVector(BaseType::Scale(v, s));
  }
  friend const Vector operator*(T s, const Vector& v) {
    return ToVector(BaseType::Scale(v, s));
  }
  friend const Vector operator*(const Vector& v, const Vector& s) {
    return ToVector(BaseType::Product(v, s));
  }
  friend const Vector operator/(const Vector& v, const Vector& s) {
    return ToVector(BaseType::Quotient(v, s));
  }
  friend const Vector operator/(const Vector& v, T s) {
    return ToVector(BaseType::Divide(v, s));
  }
  friend const Vector operator/(T s, const Vector& v) {
    return Vector(s / v[0], s / v[1], s / v[2]);
  }

  friend bool operator==(const Vector& v0, const Vector& v1) {
    return BaseType::AreValuesEqual(v0, v1);
  }
  friend bool operator!=(const Vector& v0, const Vector& v1) {
    return !BaseType::AreValuesEqual(v0, v1);
  }

 private:
  typedef VectorBase<Dimension, T> BaseType;

  static const Vector ToVector(const BaseType& b) {
    return static_cast<const Vector&>(b);
  }

  template<int D, typename U> friend class Point;
};

template <int Dimension, typename T>
std::ostream& operator<<(std::ostream& out, const Vector<Dimension, T>& v) {
  v.Print(out, 'V');
  return out;
}

template <int Dimension, typename T>
std::istream& operator>>(std::istream& in, Vector<Dimension, T>& v) {
  v. template Read<'V'>(in);
  return in;
}




template <int Dimension, typename T>
class Point : public VectorBase<Dimension, T> {
 public:
  typedef Vector<Dimension, T> VectorType;

  Point() : BaseType() {}

  explicit Point(T e0) : BaseType(e0) {}
  Point(T e0, T e1) : BaseType(e0, e1) {}
  Point(T e0, T e1, T e2) : BaseType(e0, e1, e2) {}
  Point(T e0, T e1, T e2, T e3) : BaseType(e0, e1, e2, e3) {}

  Point(const Point<Dimension - 1, T>& p, T s) : BaseType(p, s) {}

  template <typename U> explicit Point(const Point<Dimension, U>& p)
      : BaseType(p) {}

  static const Point Zero() { return ToPoint(BaseType::Zero()); }

  static const Point Fill(T value) { return ToPoint(BaseType::Fill(value)); }

  void operator+=(const Point& v) { BaseType::Add(v); }
  void operator+=(const VectorType& v) { BaseType::Add(v); }
  void operator-=(const VectorType& v) { BaseType::Subtract(v); }
  void operator*=(T s) { BaseType::Multiply(s); }
  void operator/=(T s) { BaseType::Divide(s); }

  const Point operator-() const { return ToPoint(BaseType::Negation()); }

  friend const Point operator+(const Point& p0, const Point& p1) {
    return ToPoint(BaseType::Sum(p0, p1));
  }
  friend const Point operator+(const Point& p, const VectorType& v) {
    return ToPoint(BaseType::Sum(p, v));
  }
  friend const Point operator+(const VectorType& v, const Point& p) {
    return ToPoint(BaseType::Sum(p, v));
  }

  friend const Point operator-(const Point& p, const VectorType& v) {
    return ToPoint(BaseType::Difference(p, v));
  }
  friend const VectorType operator-(const Point& p0, const Point& p1) {
    return ToVector(BaseType::Difference(p0, p1));
  }

  friend const Point operator*(const Point& p, T s) {
    return ToPoint(BaseType::Scale(p, s));
  }
  friend const Point operator*(T s, const Point& p) {
    return ToPoint(BaseType::Scale(p, s));
  }
  friend const Point operator*(const Point& v, const Point& s) {
    return ToPoint(BaseType::Product(v, s));
  }
  friend const Point operator/(const Point& v, const Point& s) {
    return ToPoint(BaseType::Quotient(v, s));
  }
  friend const Point operator/(const Point& p, T s) {
    return ToPoint(BaseType::Divide(p, s));
  }

  friend bool operator==(const Point& p0, const Point& p1) {
    return BaseType::AreValuesEqual(p0, p1);
  }
  friend bool operator!=(const Point& p0, const Point& p1) {
    return !BaseType::AreValuesEqual(p0, p1);
  }

 private:
  typedef VectorBase<Dimension, T> BaseType;

  static const Point ToPoint(const BaseType& b) {
    return *static_cast<const Point*>(&b);
  }
  static const VectorType ToVector(const BaseType& b) {
    return VectorType::ToVector(b);
  }
};

template <int Dimension, typename T>
std::ostream& operator<<(std::ostream& out, const Point<Dimension, T>& p) {
  p.Print(out, 'P');
  return out;
}

template <int Dimension, typename T>
std::istream& operator>>(std::istream& in, Point<Dimension, T>& v) {
  v. template Read<'P'>(in);
  return in;
}




template <int Dimension, typename T>
VectorBase<Dimension, T>::VectorBase(T e0) {
  ION_STATIC_ASSERT(Dimension == 1, "Bad Dimension in VectorBase constructor");
  elem_[0] = e0;
}

template <int Dimension, typename T>
VectorBase<Dimension, T>::VectorBase(T e0, T e1) {
  ION_STATIC_ASSERT(Dimension == 2, "Bad Dimension in VectorBase constructor");
  elem_[0] = e0;
  elem_[1] = e1;
}

template <int Dimension, typename T>
VectorBase<Dimension, T>::VectorBase(T e0, T e1, T e2) {
  ION_STATIC_ASSERT(Dimension == 3, "Bad Dimension in VectorBase constructor");
  elem_[0] = e0;
  elem_[1] = e1;
  elem_[2] = e2;
}

template <int Dimension, typename T>
VectorBase<Dimension, T>::VectorBase(T e0, T e1, T e2, T e3) {
  ION_STATIC_ASSERT(Dimension == 4, "Bad Dimension in VectorBase constructor");
  elem_[0] = e0;
  elem_[1] = e1;
  elem_[2] = e2;
  elem_[3] = e3;
}

template <int Dimension, typename T>
VectorBase<Dimension, T>::VectorBase(const VectorBase<Dimension - 1, T>& v,
                                     T s) {
  ION_STATIC_ASSERT(Dimension >= 2, "Bad Dimension in VectorBase constructor");
  for (int i = 0; i < Dimension - 1; ++i)
    elem_[i] = v[i];
  elem_[Dimension - 1] = s;
}

template <int Dimension, typename T> template <typename U>
VectorBase<Dimension, T>::VectorBase(const VectorBase<Dimension, U>& v) {
  for (int i = 0; i < Dimension; ++i)
    elem_[i] = static_cast<T>(v[i]);
}

template <int Dimension, typename T>
void VectorBase<Dimension, T>::Set(T e0) {
  ION_STATIC_ASSERT(Dimension == 1, "Bad Dimension in VectorBase::Set");
  elem_[0] = e0;
}

template <int Dimension, typename T>
void VectorBase<Dimension, T>::Set(T e0, T e1) {
  ION_STATIC_ASSERT(Dimension == 2, "Bad Dimension in VectorBase::Set");
  elem_[0] = e0;
  elem_[1] = e1;
}

template <int Dimension, typename T>
void VectorBase<Dimension, T>::Set(T e0, T e1, T e2) {
  ION_STATIC_ASSERT(Dimension == 3, "Bad Dimension in VectorBase::Set");
  elem_[0] = e0;
  elem_[1] = e1;
  elem_[2] = e2;
}

template <int Dimension, typename T>
void VectorBase<Dimension, T>::Set(T e0, T e1, T e2, T e3) {
  ION_STATIC_ASSERT(Dimension == 4, "Bad Dimension in VectorBase::Set");
  elem_[0] = e0;
  elem_[1] = e1;
  elem_[2] = e2;
  elem_[3] = e3;
}

template <int Dimension, typename T>
template <typename U>
struct VectorBase<Dimension, T>::StaticHelper<1, U> {
  typedef math::Vector<1, U> Vector;
  typedef math::VectorBase<1, U> VectorBase;
  static const Vector AxisX() {
    return Vector(static_cast<U>(1));
  }
  static const VectorBase Fill(U value) { return VectorBase(value); }
};

template <int Dimension, typename T>
template <typename U>
struct VectorBase<Dimension, T>::StaticHelper<2, U> {
  typedef math::Vector<2, U> Vector;
  typedef math::VectorBase<2, U> VectorBase;
  static const Vector AxisX() {
    return Vector(static_cast<U>(1), static_cast<U>(0));
  }
  static const Vector AxisY() {
    return Vector(static_cast<U>(0), static_cast<U>(1));
  }
  static const VectorBase Fill(U value) { return VectorBase(value, value); }
};

template <int Dimension, typename T>
template <typename U>
struct VectorBase<Dimension, T>::StaticHelper<3, U> {
  typedef math::Vector<3, U> Vector;
  typedef math::VectorBase<3, U> VectorBase;
  static const Vector AxisX() {
    return Vector(static_cast<U>(1), static_cast<U>(0), static_cast<U>(0));
  }
  static const Vector AxisY() {
    return Vector(static_cast<U>(0), static_cast<U>(1), static_cast<U>(0));
  }
  static const Vector AxisZ() {
    return Vector(static_cast<U>(0), static_cast<U>(0), static_cast<U>(1));
  }
  static const VectorBase Fill(U value) {
    return VectorBase(value, value, value);
  }
};

template <int Dimension, typename T>
template <typename U>
struct VectorBase<Dimension, T>::StaticHelper<4, U> {
  typedef math::Vector<4, U> Vector;
  typedef math::VectorBase<4, U> VectorBase;
  static const Vector AxisX() {
    return Vector(static_cast<U>(1), static_cast<U>(0), static_cast<U>(0),
                  static_cast<U>(0));
  }
  static const Vector AxisY() {
    return Vector(static_cast<U>(0), static_cast<U>(1), static_cast<U>(0),
                  static_cast<U>(0));
  }
  static const Vector AxisZ() {
    return Vector(static_cast<U>(0), static_cast<U>(0), static_cast<U>(1),
                  static_cast<U>(0));
  }
  static const Vector AxisW() {
    return Vector(static_cast<U>(0), static_cast<U>(0), static_cast<U>(0),
                  static_cast<U>(1));
  }
  static const VectorBase Fill(U value) {
    return VectorBase(value, value, value, value);
  }
};

template <int Dimension, typename T>
const VectorBase<Dimension, T> VectorBase<Dimension, T>::Zero() {
  static VectorBase<Dimension, T> v =
      StaticHelper<Dimension, T>::Fill(static_cast<T>(0));
  return v;
}

template <int Dimension, typename T>
const VectorBase<Dimension, T> VectorBase<Dimension, T>::Fill(T value) {
  return StaticHelper<Dimension, T>::Fill(value);
}

template <int Dimension, typename T>
const Vector<Dimension, T> Vector<Dimension, T>::AxisX() {
  static const Vector<Dimension, T> v =
      BaseType::template StaticHelper<Dimension, T>::AxisX();
  return v;
}

template <int Dimension, typename T>
const Vector<Dimension, T> Vector<Dimension, T>::AxisY() {
  static const Vector<Dimension, T> v =
      BaseType::template StaticHelper<Dimension, T>::AxisY();
  return v;
}

template <int Dimension, typename T>
const Vector<Dimension, T> Vector<Dimension, T>::AxisZ() {
  static const Vector<Dimension, T> v =
      BaseType::template StaticHelper<Dimension, T>::AxisZ();
  return v;
}

template <int Dimension, typename T>
const Vector<Dimension, T> Vector<Dimension, T>::AxisW() {
  static const Vector<Dimension, T> v =
      BaseType::template StaticHelper<Dimension, T>::AxisW();
  return v;
}

template <int Dimension, typename T>
void VectorBase<Dimension, T>::Add(const VectorBase& v) {
  for (int i = 0; i < Dimension; ++i)
    elem_[i] = static_cast<T>(elem_[i] + v.elem_[i]);
}

template <int Dimension, typename T>
void VectorBase<Dimension, T>::Subtract(const VectorBase& v) {
  for (int i = 0; i < Dimension; ++i)
    elem_[i] = static_cast<T>(elem_[i] - v.elem_[i]);
}

template <int Dimension, typename T>
void VectorBase<Dimension, T>::Multiply(T s) {
  for (int i = 0; i < Dimension; ++i)
    elem_[i] = static_cast<T>(elem_[i] * s);
}

template <int Dimension, typename T>
void VectorBase<Dimension, T>::Divide(T s) {
  for (int i = 0; i < Dimension; ++i)
    elem_[i] = static_cast<T>(elem_[i] / s);
}

template <int Dimension, typename T>
const VectorBase<Dimension, T> VectorBase<Dimension, T>::Negation() const {
  VectorBase result;
  for (int i = 0; i < Dimension; ++i)
    result.elem_[i] = static_cast<T>(-elem_[i]);
  return result;
}

template <int Dimension, typename T>
const VectorBase<Dimension, T> VectorBase<Dimension, T>::Product(
    const VectorBase& v0, const VectorBase& v1) {
  VectorBase result;
  for (int i = 0; i < Dimension; ++i)
    result.elem_[i] = static_cast<T>(v0.elem_[i] * v1.elem_[i]);
  return result;
}

template <int Dimension, typename T>
const VectorBase<Dimension, T> VectorBase<Dimension, T>::Quotient(
    const VectorBase& v0, const VectorBase& v1) {
  VectorBase result;
  for (int i = 0; i < Dimension; ++i)
    result.elem_[i] = static_cast<T>(v0.elem_[i] / v1.elem_[i]);
  return result;
}

template <int Dimension, typename T>
const VectorBase<Dimension, T> VectorBase<Dimension, T>::Sum(
    const VectorBase& v0, const VectorBase& v1) {
  VectorBase result;
  for (int i = 0; i < Dimension; ++i)
    result.elem_[i] = static_cast<T>(v0.elem_[i] + v1.elem_[i]);
  return result;
}

template <int Dimension, typename T>
const VectorBase<Dimension, T> VectorBase<Dimension, T>::Difference(
    const VectorBase& v0, const VectorBase& v1) {
  VectorBase result;
  for (int i = 0; i < Dimension; ++i)
    result.elem_[i] = static_cast<T>(v0.elem_[i] - v1.elem_[i]);
  return result;
}

template <int Dimension, typename T>
const VectorBase<Dimension, T> VectorBase<Dimension, T>::Scale(
    const VectorBase& v, T s) {
  VectorBase result;
  for (int i = 0; i < Dimension; ++i)
    result.elem_[i] = static_cast<T>(v.elem_[i] * s);
  return result;
}

template <int Dimension, typename T>
const VectorBase<Dimension, T> VectorBase<Dimension, T>::Divide(
    const VectorBase& v, T s) {
  VectorBase result;
  for (int i = 0; i < Dimension; ++i)
    result.elem_[i] = static_cast<T>(v.elem_[i] / s);
  return result;
}

template <int Dimension, typename T>
bool VectorBase<Dimension, T>::AreValuesEqual(const VectorBase& v0,
                                              const VectorBase& v1) {
  for (int i = 0; i < Dimension; ++i) {
    if (v0.elem_[i] != v1.elem_[i])
      return false;
  }
  return true;
}




#define ION_INSTANTIATE_VECTOR_TYPE(type)       \
typedef type<1, int8> type ## 1i8;              \
typedef type<1, uint8> type ## 1ui8;            \
typedef type<1, int16> type ## 1i16;            \
typedef type<1, uint16> type ## 1ui16;          \
typedef type<1, int32> type ## 1i;              \
typedef type<1, uint32> type ## 1ui;            \
typedef type<1, float> type ## 1f;              \
typedef type<1, double> type ## 1d;             \
typedef type<2, int8> type ## 2i8;              \
typedef type<2, uint8> type ## 2ui8;            \
typedef type<2, int16> type ## 2i16;            \
typedef type<2, uint16> type ## 2ui16;          \
typedef type<2, int32> type ## 2i;              \
typedef type<2, uint32> type ## 2ui;            \
typedef type<2, float> type ## 2f;              \
typedef type<2, double> type ## 2d;             \
typedef type<3, int8> type ## 3i8;              \
typedef type<3, uint8> type ## 3ui8;            \
typedef type<3, int16> type ## 3i16;            \
typedef type<3, uint16> type ## 3ui16;          \
typedef type<3, int32> type ## 3i;              \
typedef type<3, uint32> type ## 3ui;            \
typedef type<3, float> type ## 3f;              \
typedef type<3, double> type ## 3d;             \
typedef type<4, int8> type ## 4i8;              \
typedef type<4, uint8> type ## 4ui8;            \
typedef type<4, int16> type ## 4i16;            \
typedef type<4, uint16> type ## 4ui16;          \
typedef type<4, int32> type ## 4i;              \
typedef type<4, uint32> type ## 4ui;            \
typedef type<4, float> type ## 4f;              \
typedef type<4, double> type ## 4d

ION_INSTANTIATE_VECTOR_TYPE(VectorBase);
ION_INSTANTIATE_VECTOR_TYPE(Vector);
ION_INSTANTIATE_VECTOR_TYPE(Point);

#undef ION_INSTANTIATE_VECTOR_TYPE

}  // namespace math
}  // namespace ion

#endif  // ION_MATH_VECTOR_H_