src/math/Vector.h

   1 #ifndef SPACE_VECTOR_H_
   2 #define SPACE_VECTOR_H_
   3
   4 #include <algorithm>
   5 #include <ostream>
   6
   7
   8 namespace space {
   9
  10 template<class Scalar>
  11 class Vector {
  12
  13 public:
  14         constexpr Vector() : x(0), y(0) { }
  15         constexpr Vector(Scalar x, Scalar y) : x(x), y(y) { }
  16
  17         template<class Other>
  18         constexpr Vector(Vector<Other> other) : x(other.x), y(other.y) { }
  19
  20 public:
  21         Vector<Scalar> &operator +=(Vector<Scalar> other) {
  22                 x += other.x;
  23                 y += other.y;
  24                 return *this;
  25         }
  26         Vector<Scalar> &operator -=(Vector<Scalar> other) {
  27                 x -= other.x;
  28                 y -= other.y;
  29                 return *this;
  30         }
  31
  32 public:
  33         Scalar x;
  34         Scalar y;
  35
  36 };
  37
  38
  39 template<class Scalar>
  40 constexpr Vector<Scalar> operator -(Vector<Scalar> v) {
  41         return Vector<Scalar>(-v.x, -v.y);
  42 }
  43
  44
  45 template<class Scalar>
  46 constexpr Vector<Scalar> operator +(Vector<Scalar> lhs, Vector<Scalar> rhs) {
  47         return Vector<Scalar>(lhs.x + rhs.x, lhs.y + rhs.y);
  48 }
  49
  50 template<class Scalar>
  51 constexpr Vector<Scalar> operator -(Vector<Scalar> lhs, Vector<Scalar> rhs) {
  52         return Vector<Scalar>(lhs.x - rhs.x, lhs.y - rhs.y);
  53 }
  54
  55
  56 template<class Scalar>
  57 constexpr Vector<Scalar> operator *(Vector<Scalar> lhs, Scalar rhs) {
  58         return Vector<Scalar>(lhs.x * rhs, lhs.y * rhs);
  59 }
  60
  61 template<class Scalar>
  62 constexpr Vector<Scalar> operator *(Scalar lhs, Vector<Scalar> rhs) {
  63         return rhs * lhs;
  64 }
  65 template<class Scalar>
  66 constexpr Vector<Scalar> operator *(Vector<Scalar> lhs, Vector<Scalar> rhs) {
  67         return Vector<Scalar>(lhs.x * rhs.x, lhs.y * rhs.y);
  68 }
  69
  70
  71 template<class Scalar>
  72 constexpr Vector<Scalar> operator /(Vector<Scalar> lhs, Scalar rhs) {
  73         return Vector<Scalar>(lhs.x / rhs, lhs.y / rhs);
  74 }
  75
  76 template<class Scalar>
  77 constexpr Vector<Scalar> operator /(Scalar lhs, Vector<Scalar> rhs) {
  78         return rhs / lhs;
  79 }
  80 template<class Scalar>
  81 constexpr Vector<Scalar> operator /(Vector<Scalar> lhs, Vector<Scalar> rhs) {
  82         return Vector<Scalar>(lhs.x / rhs.x, lhs.y / rhs.y);
  83 }
  84
  85
  86 template<class Scalar>
  87 constexpr bool operator ==(Vector<Scalar> lhs, Vector<Scalar> rhs) {
  88         return lhs.x == rhs.x && lhs.y == rhs.y;
  89 }
  90 template<class Scalar>
  91 constexpr bool operator !=(Vector<Scalar> lhs, Vector<Scalar> rhs) {
  92         return lhs.x != rhs.x && lhs.y != rhs.y;
  93 }
  94
  95
  96 template<class Scalar>
  97 inline std::ostream &operator <<(std::ostream &out, Vector<Scalar> v) {
  98         return out << '<' << v.x << ',' << v.y << '>';
  99 }
 100
 101 }
 102
 103
 104 namespace std {
 105
 106 template<class Scalar>
 107 constexpr space::Vector<Scalar> min(
 108                 space::Vector<Scalar> lhs,
 109                 space::Vector<Scalar> rhs
 110 ) {
 111         return space::Vector<Scalar>(
 112                 min(lhs.x, rhs.x),
 113                 min(lhs.y, rhs.y)
 114         );
 115 }
 116
 117 template<class Scalar>
 118 constexpr space::Vector<Scalar> max(
 119                 space::Vector<Scalar> lhs,
 120                 space::Vector<Scalar> rhs
 121 ) {
 122         return space::Vector<Scalar>(
 123                 max(lhs.x, rhs.x),
 124                 max(lhs.y, rhs.y)
 125         );
 126 }
 127
 128 }
 129
 130 #endif