vector.h

#ifndef VECTOR_H
#define VECTOR_H

#define _USE_MATH_DEFINES
#include <math.h>
#include <stdlib.h>
#include <cfloat>
#include <iostream>
#include <vector>

#define drand48() ((double)rand()/RAND_MAX)

class Vector3D {
public:
    Vector3D() {}
    Vector3D(double e0) { m_dE[0] = e0; m_dE[1] = e0; m_dE[2] = e0; }
    Vector3D(double e0, double e1, double e2) { m_dE[0] = e0; m_dE[1] = e1; m_dE[2] = e2; }
    
    inline double x() const { return m_dE[0]; } 
    inline double y() const { return m_dE[1]; } 
    inline double z() const { return m_dE[2]; } 
    inline double r() const { return m_dE[0]; } 
    inline double g() const { return m_dE[1]; } 
    inline double b() const { return m_dE[2]; } 

    inline const Vector3D &operator+() const { return *this; } 
    inline Vector3D operator-() const { return Vector3D(-m_dE[0], -m_dE[1], -m_dE[2]); } 
    inline double operator[](int i) const { return m_dE[i]; } 
    inline double &operator[](int i) { return m_dE[i]; } 
    inline Vector3D &operator+=(const Vector3D &v2); 
    inline Vector3D &operator-=(const Vector3D &v2); 
    inline Vector3D &operator*=(const Vector3D &v2); 
    inline Vector3D &operator/=(const Vector3D &v2); 
    inline Vector3D &operator*=(const double t); 
    inline Vector3D &operator/=(const double t); 

    inline double Length() const { return sqrt(m_dE[0] * m_dE[0] + m_dE[1] * m_dE[1] + m_dE[2] * m_dE[2]); } 
    inline double SquaredLength() const { return m_dE[0] * m_dE[0] + m_dE[1] * m_dE[1] + m_dE[2] * m_dE[2]; } 
    inline double Dot(const Vector3D &v2) { return m_dE[0] * v2.m_dE[0] + m_dE[1] * v2.m_dE[1] + m_dE[2] * v2.m_dE[2]; } 

    inline Vector3D Cross(const Vector3D &v2) {
        return Vector3D((m_dE[1] * v2.m_dE[2] - m_dE[2] * v2.m_dE[1]),
            (-(m_dE[0] * v2.m_dE[2] - m_dE[2] * v2.m_dE[0])),
            (m_dE[0] * v2.m_dE[1] - m_dE[1] * v2.m_dE[0]));
    }

    inline void MakeUnitVector(); 

    double m_dE[3]; 
};

inline std::istream &operator>>(std::istream &is, Vector3D &t) {
    is >> t.m_dE[0] >> t.m_dE[1] >> t.m_dE[2];
    return is;
}

inline std::ostream &operator<<(std::ostream &os, const  Vector3D &t) {
    os << t.m_dE[0] << " " << t.m_dE[1] << " " << t.m_dE[2];
    return os;
}

inline void Vector3D::MakeUnitVector() {
    double k = 1.0 / sqrt(m_dE[0] * m_dE[0] + m_dE[1] * m_dE[1] + m_dE[2] * m_dE[2]);
    m_dE[0] *= k; m_dE[1] *= k; m_dE[2] *= k;
}

inline Vector3D operator+(const  Vector3D &v1, const  Vector3D &v2) {
    return  Vector3D(v1.m_dE[0] + v2.m_dE[0], v1.m_dE[1] + v2.m_dE[1], v1.m_dE[2] + v2.m_dE[2]);
}

inline Vector3D operator+(const Vector3D &v1, const int &i2) {
    return Vector3D(v1.m_dE[0] + i2, v1.m_dE[1] + i2, v1.m_dE[2] + i2);
}

inline Vector3D operator+(const Vector3D &v1, const double &i2) {
    return Vector3D(v1.m_dE[0] + i2, v1.m_dE[1] + i2, v1.m_dE[2] + i2);
}

inline Vector3D operator-(const Vector3D &v1, const Vector3D &v2) {
    return Vector3D(v1.m_dE[0] - v2.m_dE[0], v1.m_dE[1] - v2.m_dE[1], v1.m_dE[2] - v2.m_dE[2]);
}

inline Vector3D operator-(const Vector3D &v1, const int &i2) {
    return Vector3D(v1.m_dE[0] - i2, v1.m_dE[1] - i2, v1.m_dE[2] - i2);
}

inline Vector3D operator-(const Vector3D &v1, double &i2) {
    return Vector3D(v1.m_dE[0] - i2, v1.m_dE[1] - i2, v1.m_dE[2] - i2);
}

inline Vector3D operator*(const Vector3D &v1, const Vector3D &v2) {
    return Vector3D(v1.m_dE[0] * v2.m_dE[0], v1.m_dE[1] * v2.m_dE[1], v1.m_dE[2] * v2.m_dE[2]);
}

inline Vector3D operator/(const Vector3D &v1, const Vector3D &v2) {
    return Vector3D(v1.m_dE[0] / v2.m_dE[0], v1.m_dE[1] / v2.m_dE[1], v1.m_dE[2] / v2.m_dE[2]);
}

inline Vector3D operator*(double t, const Vector3D &v) {
    return Vector3D(t*v.m_dE[0], t*v.m_dE[1], t*v.m_dE[2]);
}

inline Vector3D operator/(Vector3D v, double t) {
    return Vector3D(v.m_dE[0] / t, v.m_dE[1] / t, v.m_dE[2] / t);
}

inline Vector3D operator/(double t, Vector3D v) {
    return Vector3D(t / v.m_dE[0], t / v.m_dE[1], t / v.m_dE[2]);
}

inline Vector3D operator*(const Vector3D &v, double t) {
    return Vector3D(t*v.m_dE[0], t*v.m_dE[1], t*v.m_dE[2]);
}

inline Vector3D &Vector3D::operator+=(const Vector3D &v) {
    m_dE[0] += v.m_dE[0];
    m_dE[1] += v.m_dE[1];
    m_dE[2] += v.m_dE[2];
    return *this;
}

inline Vector3D &Vector3D::operator*=(const Vector3D &v) {
    m_dE[0] *= v.m_dE[0];
    m_dE[1] *= v.m_dE[1];
    m_dE[2] *= v.m_dE[2];
    return *this;
}

inline Vector3D &Vector3D::operator/=(const Vector3D &v) {
    m_dE[0] /= v.m_dE[0];
    m_dE[1] /= v.m_dE[1];
    m_dE[2] /= v.m_dE[2];
    return *this;
}

inline Vector3D &Vector3D::operator-=(const Vector3D& v) {
    m_dE[0] -= v.m_dE[0];
    m_dE[1] -= v.m_dE[1];
    m_dE[2] -= v.m_dE[2];
    return *this;
}

inline Vector3D &Vector3D::operator*=(const double t) {
    m_dE[0] *= t;
    m_dE[1] *= t;
    m_dE[2] *= t;
    return *this;
}

inline Vector3D &Vector3D::operator/=(const double t) {
    double k = 1.0 / t;

    m_dE[0] *= k;
    m_dE[1] *= k;
    m_dE[2] *= k;
    return *this;
}

inline Vector3D UnitVector(Vector3D v) {
    return v / v.Length();
}

inline double StdDot(const Vector3D &v1, const Vector3D &v2) { 
    return v1.m_dE[0] * v2.m_dE[0] + v1.m_dE[1] * v2.m_dE[1] + v1.m_dE[2] * v2.m_dE[2];
}

inline Vector3D StdCross(const Vector3D &v1, const Vector3D &v2) {
    return Vector3D((v1.m_dE[1] * v2.m_dE[2] - v1.m_dE[2] * v2.m_dE[1]),
        (-(v1.m_dE[0] * v2.m_dE[2] - v1.m_dE[2] * v2.m_dE[0])),
        (v1.m_dE[0] * v2.m_dE[1] - v1.m_dE[1] * v2.m_dE[0]));
}

#endif // VECTOR_H