src/geometry/Vector2D.h

   1 /*
   2  * Vector.h
   3  *
   4  *  Created on: Apr 23, 2012
   5  *      Author: holy
   6  */
   7
   8 #ifndef GEOMETRY_VECTOR2D_H_
   9 #define GEOMETRY_VECTOR2D_H_
  10
  11 #include <cmath>
  12 #include <ostream>
  13
  14
  15 namespace geometry {
  16
  17 template<typename Scalar>
  18 class Vector2D {
  19
  20         public:
  21                 Vector2D(void) : x(), y() { };
  22                 Vector2D(Scalar x, Scalar y) : x(x), y(y) { };
  23
  24         public:
  25                 Scalar X(void) const { return x; };
  26                 Scalar Y(void) const { return y; };
  27
  28         public:
  29                 Scalar Dot(const Vector2D<Scalar> &o) const { return (X() * o.X()) + (Y() * o.Y()); };
  30                 Scalar LengthSquared(void) const { return Dot(*this); };
  31                 Scalar Length(void) const { return std::sqrt(LengthSquared()); };
  32
  33         public:
  34                 Vector2D<Scalar> &Unify(void) {
  35                         if (LengthSquared() == Scalar()) return *this;
  36                         *this /= Length();
  37                         return *this;
  38                 };
  39                 Vector2D<Scalar> Unit(void) const {
  40                         if (LengthSquared() == Scalar()) return *this;
  41                         return *this / Length();
  42                 };
  43                 Vector2D<Scalar> &Reflect(const Vector2D<Scalar> &normal);
  44
  45         public:
  46                 Vector2D<Scalar> &operator +=(const Vector2D<Scalar> &o) {
  47                         x += o.X();
  48                         y += o.Y();
  49                         return *this;
  50                 };
  51                 Vector2D<Scalar> &operator -=(const Vector2D<Scalar> &o) {
  52                         x -= o.X();
  53                         y -= o.Y();
  54                         return *this;
  55                 };
  56                 template<typename T>
  57                 Vector2D<Scalar> &operator +=(T s) { x += s; y += s; return *this; };
  58                 template<typename T>
  59                 Vector2D<Scalar> &operator -=(T s) { x -= s; y -= s; return *this; };
  60                 template<typename T>
  61                 Vector2D<Scalar> &operator *=(T s) { x *= s; y *= s; return *this; };
  62                 template<typename T>
  63                 Vector2D<Scalar> &operator /=(T s) { x /= s; y /= s; return *this; };
  64
  65         private:
  66                 Scalar x, y;
  67
  68 };
  69
  70 template<typename Scalar>
  71 inline Vector2D<Scalar> &Vector2D<Scalar>::Reflect(const Vector2D<Scalar> &normal) {
  72         Scalar doubleDot(2 * Dot(normal));
  73         x -= doubleDot * normal.X();
  74         y -= doubleDot * normal.Y();
  75         return *this;
  76 };
  77
  78
  79 template<typename Scalar>
  80 inline Vector2D<Scalar> operator +(const Vector2D<Scalar> &v) {
  81         return v;
  82 };
  83 template<typename Scalar>
  84 inline Vector2D<Scalar> operator -(const Vector2D<Scalar> &v) {
  85         return Vector2D<Scalar>(-v.X(), -v.Y());
  86 };
  87
  88 template<typename Scalar>
  89 inline Vector2D<Scalar> operator +(const Vector2D<Scalar> &lhs, const Vector2D<Scalar> &rhs) {
  90         Vector2D<Scalar> temp(lhs);
  91         temp += rhs;
  92         return temp;
  93 };
  94 template<typename Scalar>
  95 inline Vector2D<Scalar> operator -(const Vector2D<Scalar> &lhs, const Vector2D<Scalar> &rhs) {
  96         Vector2D<Scalar> temp(lhs);
  97         temp -= rhs;
  98         return temp;
  99 };
 100
 101 template<typename VScalar, typename SScalar>
 102 inline Vector2D<VScalar> operator +(const Vector2D<VScalar> &v, SScalar s) {
 103         Vector2D<VScalar> temp(v);
 104         temp += s;
 105         return temp;
 106 };
 107 template<typename VScalar, typename SScalar>
 108 inline Vector2D<VScalar> operator -(const Vector2D<VScalar> &v, SScalar s) {
 109         Vector2D<VScalar> temp(v);
 110         temp -= s;
 111         return temp;
 112 };
 113
 114 template<typename VScalar, typename SScalar>
 115 inline Vector2D<VScalar> operator +(SScalar s, const Vector2D<VScalar> &v) {
 116         Vector2D<VScalar> temp(v);
 117         temp += s;
 118         return temp;
 119 };
 120 template<typename VScalar, typename SScalar>
 121 inline Vector2D<VScalar> operator -(SScalar s, const Vector2D<VScalar> &v) {
 122         Vector2D<VScalar> temp(v);
 123         temp -= s;
 124         return temp;
 125 };
 126
 127 template<typename VScalar, typename SScalar>
 128 inline Vector2D<VScalar> operator *(const Vector2D<VScalar> &v, SScalar s) {
 129         Vector2D<VScalar> temp(v);
 130         temp *= s;
 131         return temp;
 132 };
 133 template<typename VScalar, typename SScalar>
 134 inline Vector2D<VScalar> operator *(SScalar s, const Vector2D<VScalar> &v) {
 135         Vector2D<VScalar> temp(v);
 136         temp *= s;
 137         return temp;
 138 };
 139 template<typename VScalar, typename SScalar>
 140 inline Vector2D<VScalar> operator /(const Vector2D<VScalar> &v, SScalar s) {
 141         Vector2D<VScalar> temp(v);
 142         temp /= s;
 143         return temp;
 144 };
 145 template<typename VScalar, typename SScalar>
 146 inline Vector2D<VScalar> operator /(SScalar s, const Vector2D<VScalar> &v) {
 147         Vector2D<VScalar> temp(v);
 148         temp /= s;
 149         return temp;
 150 };
 151
 152
 153 template<typename Scalar>
 154 std::ostream &operator <<(std::ostream &out, const Vector2D<Scalar> &v) {
 155         return out << '<' << v.X() << '|' << v.Y() << '>';
 156 }
 157
 158 }
 159
 160 #endif /* GEOMETRY_VECTOR2D_H_ */