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                 Vector2D<Scalar> &Rotate90(void) {
  45                         return *this = Vector2D<Scalar>(-Y(), X());
  46                 };
  47                 Vector2D<Scalar> &Rotate(Scalar by) {
  48                         Scalar sine(std::sin(by)), cosine(std::cos(by));
  49                         return *this = Vector2D<Scalar>(X() * cosine - Y() * sine, X() * sine + y * cosine);
  50                 };
  51
  52         public:
  53                 Vector2D<Scalar> &operator +=(const Vector2D<Scalar> &o) {
  54                         x += o.X();
  55                         y += o.Y();
  56                         return *this;
  57                 };
  58                 Vector2D<Scalar> &operator -=(const Vector2D<Scalar> &o) {
  59                         x -= o.X();
  60                         y -= o.Y();
  61                         return *this;
  62                 };
  63                 template<typename T>
  64                 Vector2D<Scalar> &operator +=(T s) { x += s; y += s; return *this; };
  65                 template<typename T>
  66                 Vector2D<Scalar> &operator -=(T s) { x -= s; y -= s; return *this; };
  67                 template<typename T>
  68                 Vector2D<Scalar> &operator *=(T s) { x *= s; y *= s; return *this; };
  69                 template<typename T>
  70                 Vector2D<Scalar> &operator /=(T s) { x /= s; y /= s; return *this; };
  71
  72         private:
  73                 Scalar x, y;
  74
  75 };
  76
  77 template<typename Scalar>
  78 inline Vector2D<Scalar> &Vector2D<Scalar>::Reflect(const Vector2D<Scalar> &normal) {
  79         Scalar doubleDot(2 * Dot(normal));
  80         x -= doubleDot * normal.X();
  81         y -= doubleDot * normal.Y();
  82         return *this;
  83 };
  84
  85
  86 template<typename Scalar>
  87 inline bool operator ==(const Vector2D<Scalar> &lhs, const Vector2D<Scalar> &rhs) {
  88         return lhs.X() == rhs.X() && lhs.Y() == rhs.Y();
  89 };
  90
  91 template<typename Scalar>
  92 inline bool operator !=(const Vector2D<Scalar> &lhs, const Vector2D<Scalar> &rhs) {
  93         return !(lhs == rhs);
  94 };
  95
  96 template<typename Scalar>
  97 inline Vector2D<Scalar> operator +(const Vector2D<Scalar> &v) {
  98         return v;
  99 };
 100 template<typename Scalar>
 101 inline Vector2D<Scalar> operator -(const Vector2D<Scalar> &v) {
 102         return Vector2D<Scalar>(-v.X(), -v.Y());
 103 };
 104
 105 template<typename Scalar>
 106 inline Vector2D<Scalar> operator +(const Vector2D<Scalar> &lhs, const Vector2D<Scalar> &rhs) {
 107         Vector2D<Scalar> temp(lhs);
 108         temp += rhs;
 109         return temp;
 110 };
 111 template<typename Scalar>
 112 inline Vector2D<Scalar> operator -(const Vector2D<Scalar> &lhs, const Vector2D<Scalar> &rhs) {
 113         Vector2D<Scalar> temp(lhs);
 114         temp -= rhs;
 115         return temp;
 116 };
 117
 118 template<typename VScalar, typename SScalar>
 119 inline Vector2D<VScalar> operator +(const Vector2D<VScalar> &v, SScalar s) {
 120         Vector2D<VScalar> temp(v);
 121         temp += s;
 122         return temp;
 123 };
 124 template<typename VScalar, typename SScalar>
 125 inline Vector2D<VScalar> operator -(const Vector2D<VScalar> &v, SScalar s) {
 126         Vector2D<VScalar> temp(v);
 127         temp -= s;
 128         return temp;
 129 };
 130
 131 template<typename VScalar, typename SScalar>
 132 inline Vector2D<VScalar> operator +(SScalar s, const Vector2D<VScalar> &v) {
 133         Vector2D<VScalar> temp(v);
 134         temp += s;
 135         return temp;
 136 };
 137 template<typename VScalar, typename SScalar>
 138 inline Vector2D<VScalar> operator -(SScalar s, const Vector2D<VScalar> &v) {
 139         Vector2D<VScalar> temp(v);
 140         temp -= s;
 141         return temp;
 142 };
 143
 144 template<typename VScalar, typename SScalar>
 145 inline Vector2D<VScalar> operator *(const Vector2D<VScalar> &v, SScalar s) {
 146         Vector2D<VScalar> temp(v);
 147         temp *= s;
 148         return temp;
 149 };
 150 template<typename VScalar, typename SScalar>
 151 inline Vector2D<VScalar> operator *(SScalar s, const Vector2D<VScalar> &v) {
 152         Vector2D<VScalar> temp(v);
 153         temp *= s;
 154         return temp;
 155 };
 156 template<typename VScalar, typename SScalar>
 157 inline Vector2D<VScalar> operator /(const Vector2D<VScalar> &v, SScalar s) {
 158         Vector2D<VScalar> temp(v);
 159         temp /= s;
 160         return temp;
 161 };
 162 template<typename VScalar, typename SScalar>
 163 inline Vector2D<VScalar> operator /(SScalar s, const Vector2D<VScalar> &v) {
 164         Vector2D<VScalar> temp(v);
 165         temp /= s;
 166         return temp;
 167 };
 168
 169
 170 template<typename Scalar>
 171 std::ostream &operator <<(std::ostream &out, const Vector2D<Scalar> &v) {
 172         return out << '<' << v.X() << '|' << v.Y() << '>';
 173 }
 174
 175 }
 176
 177 #endif /* GEOMETRY_VECTOR2D_H_ */