Vector.h

Go to the documentation of this file.

#ifndef VECTOR_H
#define VECTOR_H

#include <cmath>
#include <sstream>

class Vec3D
{
public:

        Mdouble X, Y, Z;

        inline Vec3D(void){}

        inline Vec3D (const Mdouble x, const Mdouble y, const Mdouble z)
        {       
                X = x; Y = y; Z = z;
        }

        inline void set_zero ()
        {       
                X = 0.0; Y = 0.0; Z = 0.0;
        }

        inline Vec3D operator + (const Vec3D &A) const
        { 
                return Vec3D(X + A.X, Y + A.Y, Z + A.Z); 
        }

        inline Vec3D operator - (const Vec3D &A) const
        {
                return Vec3D(X - A.X, Y - A.Y, Z - A.Z);
        }

        inline Vec3D operator + (const Mdouble A) const
        { 
                return Vec3D(X + A, Y + A, Z + A); 
        }

        inline Vec3D operator - (const Mdouble A) const
        { 
                return Vec3D(X - A, Y - A, Z - A); 
        }

        inline Vec3D operator * (const Mdouble A) const
        { 
                return Vec3D(X * A, Y * A, Z * A); 
        }

        inline Vec3D operator / (const Mdouble A) const
        { 
                return Vec3D(X / A, Y / A, Z / A); 
        }

        inline Vec3D& operator+=(const Vec3D &A)
        {
                X += A.X;
                Y += A.Y;
                Z += A.Z;
                return *this;
        }

        inline Vec3D& operator-=(const Vec3D &A)
        {
                X -= A.X;
                Y -= A.Y;
                Z -= A.Z;
                return *this;
        }

        inline Vec3D& operator*=(const Mdouble a)
        {
                X *= a;
                Y *= a;
                Z *= a;
                return *this;
        }

        inline Vec3D& operator/=(const Mdouble a)
        {
                X /= a;
                Y /= a;
                Z /= a;
                return *this;
        }

        // Dot product
        friend inline Mdouble Dot(const Vec3D &A, const Vec3D &B)
        {
                return A.X * B.X + A.Y * B.Y + A.Z * B.Z;
        }

        // Piecewise max
        friend inline Vec3D max(const Vec3D &A, const Vec3D &B)
        {
                return Vec3D(std::max(A.X,B.X), std::max(A.Y,B.Y), std::max(A.Z,B.Z));
        }

        // Piecewise min
        friend inline Vec3D min(const Vec3D &A, const Vec3D &B)
        {
                return Vec3D(std::min(A.X,B.X), std::min(A.Y,B.Y), std::min(A.Z,B.Z));
        }

        // Pointwise square 
        friend inline Vec3D square(const Vec3D &A)
        {
                return Vec3D(A.X * A.X, A.Y * A.Y, A.Z * A.Z);
        }

        // make this vector unit length 
        inline void normalize() {
                *this  /= this->GetLength();
        }

        // make this vector unit length 
        inline void SetLength(Mdouble length) {
                *this  /= this->GetLength()*length;
        }

        // Pointwise square root
        friend inline Vec3D sqrt(const Vec3D &A)
        {
                return Vec3D(sqrt(A.X), sqrt(A.Y), sqrt(A.Z));
        }

        // Cross product
        friend inline Vec3D Cross(const Vec3D &A, const Vec3D &B)
        {
                return Vec3D(A.Y*B.Z-A.Z*B.Y, A.Z*B.X-A.X*B.Z, A.X*B.Y-A.Y*B.X);
        }

        friend inline Mdouble GetDistance(const Vec3D &A, const Vec3D &B)
        {
                return sqrt(GetDistance2(A, B));
        }

        friend inline Mdouble GetDistance2(const Vec3D &A, const Vec3D &B)
        {
                return ((A.X - B.X) * (A.X - B.X) + (A.Y - B.Y) * (A.Y - B.Y) + (A.Z - B.Z) * (A.Z - B.Z));
        }
        
        friend Mdouble GetLength2(const Vec3D &A)
        {
                return (A.X * A.X + A.Y * A.Y + A.Z * A.Z);
        }

        Mdouble GetLength2() const
        {
                return (X * X + Y * Y + Z * Z);
        }

        inline Mdouble GetLength() const
        {
                return sqrt(GetLength2());
        }

        friend inline Mdouble GetLength(const Vec3D &A)
        {
                return A.GetLength();
        }
        
        friend inline Vec3D GetUnitVector(const Vec3D &A)
        {
                Mdouble Length2 = A.GetLength2();
                if (Length2) return A/sqrt(Length2);
                else return Vec3D(0,0,0);
        }
        
        friend inline std::ostream& operator<<(std::ostream& os, const Vec3D &A)
        {
                os << A.X << ' ' << A.Y << ' ' << A.Z;
                return os;
        }
        
        friend inline std::istream& operator>>(std::istream& is, Vec3D &A)
        {
                is >> A.X >> A.Y >> A.Z;
                return is;
        }
        
        friend inline Vec3D operator+ (const Mdouble& a, const Vec3D &A) {return Vec3D(A.X + a, A.Y + a, A.Z + a);} 
        friend inline Vec3D operator- (const Mdouble& a, const Vec3D &A) {return Vec3D(A.X - a, A.Y - a, A.Z - a);} 
        friend inline Vec3D operator- (const Vec3D &A) {return Vec3D(-A.X, -A.Y, -A.Z);} 
        friend inline Vec3D operator* (const Mdouble& a, const Vec3D &A) {return Vec3D(A.X * a, A.Y * a, A.Z * a);}     
        
};

#endif