Common/Vector.h

#ifndef VECTOR_H_
#define VECTOR_H_

#include "Types.h"
#include <cmath>
#include <iostream>

class Vector;

inline Vector operator*(real c, const Vector& v);
//std::ostream& operator<<(std::ostream & os, const Vector &v);

class Vector {
protected:
        real x,y,z;
        real pad;


public:
        friend Vector operator*(real c, const Vector& v);
        friend std::ostream& operator<<(std::ostream & os, const Vector &v);
        Vector(): x(0.0),y(0.0),z(0.0){}
        Vector(real _x, real _y, real _z): x(_x), y(_y), z(_z){};
        Vector(const Vector & v): x(v.x),y(v.y),z(v.z) {};
        Vector(const std::pair<real, real> & p): x(p.first), y(0.0), z(p.second){};

        real getX() const { return x;}
        real getY() const { return y;}
        real getZ() const { return z;}

        void setX(real newX) { x=newX;}
        void setY(real newY) { y=newY;}
        void setZ(real newZ) { z=newZ;}

        real magnitude() const {
                return sqrt(x*x+y*y+z*z);
        }

        Vector unit() const {
                return 1/magnitude()*(*this);
        }

        Vector & normalize() {
                return (*this *= 1/(this->magnitude()));
        }

        Vector & operator+=(const Vector&v) {
                x+= v.x;
                y+=v.y;
                z+=v.z;
                return *this;
        }
        
        Vector operator+(const Vector&v) const {
                return Vector(x+v.x,y+v.y,z+v.z);
        }
        
        Vector & operator-=(const Vector&v) {
                x-=v.x;
                y-=v.y;
                z-=v.z;
            return *this;
        }
        
        Vector operator-(const Vector& v) const {
                return Vector(x-v.x,y-v.y,z-v.z);
        }

        Vector operator-() const {
                return Vector(-x,-y,-z);
        }

        Vector & operator*=(const real c) {
                x*=c;
                y*=c;
                z*=c;
                return *this;
        }

        Vector operator*(const real c) const {
                return Vector(c*x,c*y,c*z);
        }
        real operator*(const Vector& v ) const {
                return x*v.x+y*v.y+z*v.z;
        }

        Vector project(const Vector& v) const {
                return v*scalarProduct(v);
        }

        real squareMagnitude() const {
                return x*x + y*y + z*z;
        }
        real scalarProduct(const Vector& v) const {
                return x*v.x+y*v.y+z*v.z;
        }

        Vector perp2D() const {
                return Vector(-z,0.0,x);
        }

        Vector crossProduct(const Vector& v) const {
                return Vector(y*v.z-z*v.y, z*v.x-x*v.z, x*v.y-y*v.x);
        }

        Vector & operator%=(const Vector& v) {
                *this = crossProduct(v);
                return *this;
        }
        Vector operator%(const Vector &v) const {
                return crossProduct(v);
        }

        void reset() {
                x = y = z= 0.0;
        }
};

inline Vector operator*(real c, const Vector& v) {
        return Vector(c*v.x,c*v.y,c*v.z);
}


#endif /* VECTOR_H_ */