1

#ifndef VECTOR_HH

     2

#define VECTOR_HH

     3

     4

#include <iostream>

     5

#include <cmath>

     6

     7

/**

     8

 * A 2D Vector class. Implements standard vector operations.

     9

 */

    10

template <typename T>

    11

class _Vector {

    12

public:

    13

    T x;

    14

    T y;

    15

    16

    /**

    17

     * Default constructor.

    18

     */

    19

    _Vector() : x(0), y(0) {}

    20

    21

    /**

    22

     * Constuctor.

    23

     *

    24

     * @param x Initial x-coordinate

    25

     * @param y Initial y-coordinate

    26

     */

    27

    _Vector(T x, T y) : x(x), y(y) {}

    28

    29

    /**

    30

     * Copy constructor.

    31

     *

    32

     * @param v Vector to be copied.

    33

     */

    34

    _Vector(const _Vector &v) : x(v.x), y(v.y) {}

    35

    36

    // Operator declarations

    37

    void operator=(const _Vector &v) {

    38

        this->x = v.x;

    39

        this->y = v.y;

    40

    }

    41

    _Vector operator+(const _Vector &v) const {

    42

        return _Vector(this->x+v.x, this->y+v.y);

    43

    }

    44

    _Vector operator-(const _Vector &v) const {

    45

        return _Vector(this->x-v.x, this->y-v.y);

    46

    }

    47

    _Vector operator*(const T &scalar) const {

    48

        return _Vector(this->x*scalar, this->y*scalar);

    49

    }

    50

    T operator*(const _Vector &v) const {

    51

        return (this->x*v.x + this->y*v.y);

    52

    }

    53

    _Vector operator/(const T &d) const {

    54

        return _Vector(this->x/d, this->y/d);

    55

    }

    56

    void operator+=(const _Vector &v) {

    57

        *this = *this + v;

    58

    }

    59

    void operator-=(const _Vector &v) {

    60

        *this = *this - v;

    61

    }

    62

    void operator*=(const T &scalar) {

    63

        *this = *this * scalar;

    64

    }

    65

    void operator/=(const T &scalar) {

    66

        *this = *this / scalar;

    67

    }

    68

    69

    // Other operations

    70

    T length() const {

    71

        return sqrt((this->x * this->x) + (this->y * this->y));

    72

    }

    73

    _Vector roundToInt() const {

    74

        return _Vector(round(x), round(y));

    75

    }

    76

};

    77

    78

// Unary operators

    79

template<typename T>

    80

_Vector<T> operator*(const T &scalar, const _Vector<T> v) {

    81

    return (v * scalar);

    82

} 

    83

    84

// Comparison operators

    85

template<typename T>

    86

bool operator==(const _Vector<T> &v1, const _Vector<T> &v2) {

    87

    return ((v1.x == v2.x) && (v1.y == v2.y));

    88

}

    89

template<typename T>

    90

bool operator!=(const _Vector<T> &v1, const _Vector<T> &v2) {

    91

    return !(v1 == v2);

    92

}

    93

    94

// Output operator

    95

template<typename T>

    96

std::ostream& operator<<(std::ostream &s, const _Vector<T> &v) {

    97

    return s<<"("<<v.x<<", "<<v.y<<")";

    98

}

    99

   100

// Standard vector

   101

typedef _Vector<float> Vector;

   102

   103

#endif