1

#ifndef COOR_H

     2

#define COOR_H

     3

     4

#include <iostream>

     5

     6

/**

     7

 * 2D Vector class. Implements standard vector operations.

     8

 */

     9

template <typename T>

    10

class _Vector {

    11

public:

    12

    T x;

    13

    T y;

    14

    15

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

    16

    /**

    17

     * @param x Initial x-coordinate.

    18

     * @param y Initial y-coordinate.

    19

     */

    20

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

    21

    /**

    22

     * @param v Other vector to be copied.

    23

     */

    24

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

    25

    26

    void operator=(const _Vector &v) {

    27

        this->x = v.x;

    28

        this->y = v.y;

    29

    }

    30

    _Vector operator+(const _Vector &v) const {

    31

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

    32

    }

    33

    _Vector operator-(const _Vector &v) const {

    34

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

    35

    }

    36

    _Vector operator*(const T &d) const {

    37

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

    38

    }

    39

    _Vector operator/(const T &d) const {

    40

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

    41

    } 

    42

    void operator+=(const _Vector &v) {

    43

        this->x += v.x;

    44

        this->y += v.y;

    45

    }

    46

    void operator-=(const _Vector &v) {

    47

        this->x -= v.x;

    48

        this->y -= v.y;

    49

    }

    50

    void operator*=(const T &f) {

    51

        this->x *= f;

    52

        this->y *= f;

    53

    }

    54

    void operator/=(const T &d) {

    55

        this->x /= d;

    56

        this->y /= d;

    57

    }

    58

};

    59

    60

template<typename T>

    61

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

    62

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

    63

}

    64

template<typename T>

    65

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

    66

    return !(v1 == v2);

    67

}

    68

    69

template<typename T>

    70

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

    71

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

    72

}

    73

    74

typedef _Vector<float> Vector;

    75

    76

#endif