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- (void) const {

    48

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

    49

    }

    50

    _Vector operator*(const T &scalar) const {

    51

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

    52

    }

    53

    T operator*(const _Vector &v) const {

    54

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

    55

    }

    56

    _Vector operator/ (const T &d) const {

    57

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

    58

    }

    59

    void operator+=(const _Vector &v) {

    60

        *this = *this + v;

    61

    }

    62

    void operator-=(const _Vector &v) {

    63

        *this = *this - v;

    64

    }

    65

    void operator*=(const T &scalar) {

    66

        *this = *this * scalar;

    67

    }

    68

    void operator/=(const T &scalar) {

    69

        *this = *this / scalar;

    70

    }

    71

    72

    // Other operations

    73

    T length() const {

    74

        return sqrt(sqrLength());

    75

    }

    76

    T sqrLength() const {

    77

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

    78

    }

    79

    _Vector roundToInt() const {

    80

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

    81

    }

    82

    83

    // test Vectors as booleans

    84

    // XXX: comparing floats against zero... is a bad idea?

    85

    bool zero(void) const {

    86

        return x == 0 && y == 0;

    87

    }

    88

};

    89

    90

// Unary operators

    91

template<typename T>

    92

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

    93

    return (v * scalar);

    94

} 

    95

    96

// Comparison operators

    97

template<typename T>

    98

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

    99

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

   100

}

   101

template<typename T>

   102

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

   103

    return !(v1 == v2);

   104

}

   105

   106

// Output operator

   107

template<typename T>

   108

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

   109

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

   110

}

   111

   112

#endif