1

#ifndef COOR_H

     2

#define COOR_H

     3

     4

#include <iostream>

     5

#include <cmath>

     6

     7

/**

     8

 * 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

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

    17

    /**

    18

     * @param x Initial x-coordinate.

    19

     * @param y Initial y-coordinate.

    20

     */

    21

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

    22

    /**

    23

     * @param v Other vector to be copied.

    24

     */

    25

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

    26

    27

    void operator=(const _Vector &v) {

    28

        this->x = v.x;

    29

        this->y = v.y;

    30

    }

    31

    _Vector operator+(const _Vector &v) const {

    32

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

    33

    }

    34

    _Vector operator-(const _Vector &v) const {

    35

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

    36

    }

    37

    _Vector operator*(const T &d) const {

    38

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

    39

    }

    40

    T operator*(const _Vector &v) const {

    41

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

    42

    }

    43

    _Vector operator/(const T &d) const {

    44

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

    45

    } 

    46

    void operator+=(const _Vector &v) {

    47

        this->x += v.x;

    48

        this->y += v.y;

    49

    }

    50

    void operator-=(const _Vector &v) {

    51

        this->x -= v.x;

    52

        this->y -= v.y;

    53

    }

    54

    void operator*=(const T &f) {

    55

        this->x *= f;

    56

        this->y *= f;

    57

    }

    58

    void operator/=(const T &d) {

    59

        this->x /= d;

    60

        this->y /= d;

    61

    }

    62

    T length() const {

    63

        return sqrt(x*x+y*y);

    64

    }

    65

    _Vector roundToInt() const {

    66

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

    67

    }

    68

};

    69

    70

template<typename T>

    71

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

    72

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

    73

}

    74

template<typename T>

    75

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

    76

    return !(v1 == v2);

    77

}

    78

    79

template<typename T>

    80

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

    81

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

    82

}

    83

    84

typedef _Vector<float> Vector;

    85

    86

#endif