Vector3.h

Go to the documentation of this file.

#ifndef VECTOR3
#define VECTOR3

#include <cmath>
#include <ostream>

template<class T>
class Vec3 {
public:
    T x;
    T y;
    T z;

public:
    Vec3(T value=0) : x(value), y(value), z(value) {}

    Vec3(T _x, T _y, T _z) : x(_x), y(_y), z(_z) {}

    template<class T2>
    Vec3(Vec3<T2> v): x(v.x), y(v.y), z(v.z) {}

    Vec3<T> operator+(const Vec3<T> &v) const {
      return Vec3<T>(x+v.x,y+v.y,z+v.z);
    }

    Vec3<T>& operator+=(const Vec3<T> &v) {
      x += v.x;
      y += v.y;
      z += v.z;
      return (*this);
    }

    Vec3<T> operator-(const Vec3<T> &v) const {
      return Vec3<T>(x-v.x,y-v.y,z-v.z);
    }

    Vec3<T>& operator-=(const Vec3<T> &v) {
      x -= v.x;
      y -= v.y;
      z -= v.z;
      return (*this);
    }

    Vec3<T> operator*(const double &d) const {
      return Vec3<T>(T(x*d),T(y*d),T(z*d));
    }

    Vec3<T>& operator*=(const double &d) {
      x = T(x*d);
      y = T(y*d);
      z = T(z*d);
      return (*this);
    }

    Vec3<T> operator/(const double &d) const {
      return Vec3<T>(T(x/d),T(y/d),T(z/d));
    }
    
    Vec3<T>& operator/=(const double &d) {
      x = T(x/d);
      y = T(y/d);
      z = T(z/d);
      return (*this);
    }

    double operator*(const Vec3<T> &v) const {
      return x*v.x + y*v.y + z*v.z;
    }

    Vec3<T> cross(const Vec3<T> &v) const {
      Vec3<T> tmp;
      tmp.x=y*v.z-z*v.y;
      tmp.y=z*v.x-x*v.z;
      tmp.z=x*v.y-y*v.x;
      return tmp;
    }

     Vec3<T> operator%(const Vec3<T> &v) const {
      return Vec3<T>(x*v.x, y*v.y, z*v.z);
    }

    Vec3<T>& normalize() {
      double n = norm();
      (*this) /= n;
      return (*this);
    }

    double norm() const {
      return std::sqrt(double(x*x+y*y+z*z));
    }
    
    double norm2() const {
      return x*x+y*y+z*z;
    }

    bool operator==(const Vec3<T> &v) const {
      return (x==v.x && y==v.y && z==v.z);
    }

    bool operator!=(const Vec3<T> &v) const {
      return !((*this)==v);
    }

    friend Vec3<T> operator*(const double &d, const Vec3<T> &v) {
      return v*d;
    }

    operator T() { return x; }

    friend std::ostream& operator<<(std::ostream &os, const Vec3<T> &v) {
      os << v.x << " " << v.y<<" "<<v.z;
      return os;
    }



};



template class Vec3<float>;
template class Vec3<double>;
template class Vec3<int>;

typedef Vec3<float>     Vec3f;
typedef Vec3<double>    Vec3d;
typedef Vec3<int>       Vec3i;

#endif