Vector.h

Go to the documentation of this file.

//Copyright (c) 2013-2023, The MercuryDPM Developers Team. All rights reserved.
//For the list of developers, see <http://www.MercuryDPM.org/Team>.
//
//Redistribution and use in source and binary forms, with or without
//modification, are permitted provided that the following conditions are met:
//  * Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//  * Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//  * Neither the name MercuryDPM nor the
//    names of its contributors may be used to endorse or promote products
//    derived from this software without specific prior written permission.
//
//THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
//ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
//WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
//DISCLAIMED. IN NO EVENT SHALL THE MERCURYDPM DEVELOPERS TEAM BE LIABLE FOR ANY
//DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
//(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
//LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
//ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
//(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
//SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
#ifndef MECURYDPM_VECTOR_H
#define MECURYDPM_VECTOR_H
 
#include <cmath>
#include <sstream>
#include <iostream>
#include <cstdlib>
#include <array>
 
#include "GeneralDefine.h"
#include "Logger.h"
 
template<unsigned int N>
class SmallVector;
 
class Vec3D
{
public:
    
    /*
     * \todo: Make these private.
     * \todo what is the idea of this constructor?
     * These should be private so we can implement things like a cvec etc.
     * Use getters / setters.
     */
//    Vec3D(int i);
    
    // private:
    Mdouble X, Y, Z;
    
    Vec3D()
    { setZero(); }
    
    Vec3D(const SmallVector<3>& vector);
    
    Vec3D(const Mdouble x, const Mdouble y, const Mdouble z)
    {
        X = x;
        Y = y;
        Z = z;
    }
 
    Vec3D(std::array<double, 3> a)
    {
        X = a[0];
        Y = a[1];
        Z = a[2];
    }
 
    void setZero();
    
    void setNaN();
    
    bool isZero() const
    { return X == 0.0 && Y == 0.0 && Z == 0.0; }
    
    bool isNaN() const;
    
    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 bool operator==(const Vec3D& a) const
    {
        return X == a.X and Y == a.Y and Z == a.Z;
    };
 
    Vec3D multiplyElementwise(const Vec3D& a) const {
        return Vec3D(X*a.X, Y*a.Y, Z*a.Z);
    }
 
    Vec3D divideElementwise(const Vec3D& a) const {
        return Vec3D(X/a.X, Y/a.Y, Z/a.Z);
    }
 
    Vec3D signedSquare() const {
        return Vec3D(fabs(X)*X, fabs(Y)*Y, fabs(Z)*Z);
    }
 
    Vec3D operator*(const Mdouble a) const
    {
        return Vec3D(X * a, Y * a, Z * a);
    }
    
    Vec3D operator/(Mdouble a) const {
        return Vec3D(X / a, Y / a, Z / a);
    }
    
    Vec3D& operator+=(const Vec3D& a)
    {
        X += a.X;
        Y += a.Y;
        Z += a.Z;
        return *this;
    }
 
    bool operator>=(const Vec3D& a) const {
        return X>=a.X && Y>=a.Y && Z>=a.Z;
    }
 
    bool operator<(const Vec3D& a) const {
        return X<a.X && Y<a.Y && Z<a.Z;
    }
 
    Vec3D& operator-=(const Vec3D& a)
    {
        X -= a.X;
        Y -= a.Y;
        Z -= a.Z;
        return *this;
    }
 
    Vec3D& operator*=(Mdouble a) {
        X *= a;
        Y *= a;
        Z *= a;
        return *this;
    }
 
    Vec3D& operator/=(const Mdouble a)
    {
        X /= a;
        Y /= a;
        Z /= a;
        return *this;
    }
 
    static Mdouble dot(const Vec3D& a, const Vec3D& b);
    
    static Vec3D max(const Vec3D& a, const Vec3D& b);
    
    static Vec3D min(const Vec3D& a, const Vec3D& b);
 
    static double max(const Vec3D& a) {return std::max(std::max(a.X,a.Y),a.Z);}
 
    static double min(const Vec3D& a) {return std::min(std::min(a.X,a.Y),a.Z);}
 
    static Vec3D square(const Vec3D& a);
    
    void normalise();
    
    void setLength(Mdouble length);
    
    static Vec3D sqrt(const Vec3D& a);
    
    static Vec3D cross(const Vec3D& a, const Vec3D& b);
    
    static Mdouble getDistance(const Vec3D& a, const Vec3D& b);
    
    static Mdouble getDistanceSquared(const Vec3D& a, const Vec3D& b) {
        const double X = a.X-b.X;
        const double Y = a.Y-b.Y;
        const double Z = a.Z-b.Z;
        return (X * X + Y * Y + Z * Z);
        //return getLengthSquared(a - b);
    }
 
    
    static Mdouble getLength(const Vec3D& a);
    
    static Mdouble getLengthSquared(const Vec3D& a)
    {
        return (a.X * a.X + a.Y * a.Y + a.Z * a.Z);
    }
    
    Mdouble getLength() const;
    
    Mdouble getLengthSquared() const;
    
    Mdouble getComponent(int index) const;
    
    void setComponent(int index, double val);
    
    inline Mdouble& x()
    { return X; }
    
    inline Mdouble x() const
    { return X; }
    
    inline Mdouble& y()
    { return Y; }
    
    inline Mdouble y() const
    { return Y; }
    
    inline Mdouble& z()
    { return Z; }
    
    inline Mdouble z() const
    { return Z; }
    
    inline void setX(Mdouble x)
    { X = x; }
    
    inline void setY(Mdouble y)
    { Y = y; }
    
    inline void setZ(Mdouble z)
    { Z = z; }
    
    inline Mdouble getX() const
    { return X; }
    
    inline Mdouble getY() const
    { return Y; }
    
    inline Mdouble getZ() const
    { return Z; }
    
    inline void set(Mdouble x, Mdouble y, Mdouble z)
    {
        X = x;
        Y = y;
        Z = z;
    }
    
    Mdouble getRadialCoordinateSquared() const;
    
    Mdouble getRadialCoordinate() const;
    
    Vec3D getCylindricalCoordinates() const;
    
    Vec3D getFromCylindricalCoordinates() const;
    
    Vec3D getCylindricalTensorField(const Vec3D& position) const;
    
    bool isEqualTo(const Vec3D& other, double tol) const;
    
    static Vec3D getUnitVector(const Vec3D& a);
    
    friend std::ostream& operator<<(std::ostream& os, const Vec3D& a);
    
    friend std::istream& operator>>(std::istream& is, Vec3D& a);
    
    inline friend Vec3D operator-(const Vec3D& a) {
        return Vec3D(-a.X, -a.Y, -a.Z);
    }
    
    friend Vec3D operator*(Mdouble a, const Vec3D& b) {
        return Vec3D(b.X * a, b.Y * a, b.Z * a);
    }
 
 
 
};
 
#endif