|| || || || || || || ||

---

Vec3Real64.h

Go to the documentation of this file.

#ifndef Impala_Core_Array_Element_Vec3Real64_h
#define Impala_Core_Array_Element_Vec3Real64_h

#include <iostream>
#include "Util/Math.h"
#include "Basis/NativeTypes.h"

namespace Impala
{
namespace Core
{
namespace Array
{
namespace Element
{


class Vec3Real64 {
public:

    Vec3Real64()
    {
    }

    Vec3Real64(Real64 x, Real64 y, Real64 z)
    {
        mValues[0] = x;
        mValues[1] = y;
        mValues[2] = z;
    }

    Vec3Real64(Real64 v)
    {
        mValues[0] = v;
        mValues[1] = v;
        mValues[2] = v;
    }

    Vec3Real64(const Vec3Real64& v)
    {
        mValues[0] = v.mValues[0];
        mValues[1] = v.mValues[1];
        mValues[2] = v.mValues[2];
    }

    /*
    Vec3Real64& operator=(const Vec3Real64& v)
    {
        mValues[0] = v.mValues[0];
        mValues[1] = v.mValues[1];
        mValues[2] = v.mValues[2];
        return *this;
    }
    */

    Real64
    X() const
    {
        return mValues[0];
    }
    
    Real64
    Y() const
    {
        return mValues[1];
    }
    
    Real64
    Z() const
    {
        return mValues[2];
    }

    Real64
    getValue(int dimension) const
    {
        return mValues[dimension - 1];
    }

    int
    operator==(const Vec3Real64& v) const
    {
        return (mValues[0] == v.mValues[0]) && (mValues[1] == v.mValues[1]) &&
               (mValues[2] == v.mValues[2]);
    }

    int
    operator!=(const Vec3Real64& v) const
    {
        return (mValues[0] != v.mValues[0]) || (mValues[1] != v.mValues[1]) ||
               (mValues[2] != v.mValues[2]);
    }

    int
    operator<(const Vec3Real64& v) const
    {
        return (fabs(mValues[0]) + fabs(mValues[1]) + fabs(mValues[2])) <
            (fabs(v.mValues[0]) + fabs(v.mValues[1]) + fabs(v.mValues[2]));
    }

    int
    operator<=(const Vec3Real64& v) const
    {
        return (fabs(mValues[0]) + fabs(mValues[1]) + fabs(mValues[2])) <=
            (fabs(v.mValues[0]) + fabs(v.mValues[1]) + fabs(v.mValues[2]));
    }

    int
    operator> (const Vec3Real64& v) const
    {
        return (fabs(mValues[0]) + fabs(mValues[1]) + fabs(mValues[2])) >
            (fabs(v.mValues[0]) + fabs(v.mValues[1]) + fabs(v.mValues[2]));
    }

    int
    operator>=(const Vec3Real64& v) const
    {
        return (fabs(mValues[0]) + fabs(mValues[1]) + fabs(mValues[2])) >=
            (fabs(v.mValues[0]) + fabs(v.mValues[1]) + fabs(v.mValues[2]));
    }

    Vec3Real64&
    operator+=(const Vec3Real64& v)
    {
        mValues[0] += v.mValues[0];
        mValues[1] += v.mValues[1];
        mValues[2] += v.mValues[2];
        return *this;
    }

    Vec3Real64&
    operator-=(const Vec3Real64& v)
    {
        mValues[0] -= v.mValues[0];
        mValues[1] -= v.mValues[1];
        mValues[2] -= v.mValues[2];
        return *this;
    }

    Vec3Real64&
    operator*=(const Vec3Real64& v)
    {
        mValues[0] *= v.mValues[0];
        mValues[1] *= v.mValues[1];
        mValues[2] *= v.mValues[2];
        return *this;
    }

    Vec3Real64&
    operator*=(double v)
    {
        mValues[0] *= v;
        mValues[1] *= v;
        mValues[2] *= v;
        return *this;
    }

    Vec3Real64&
    operator/=(const Vec3Real64& v)
    {
        mValues[0] /= v.mValues[0];
        mValues[1] /= v.mValues[1];
        mValues[2] /= v.mValues[2];
        return *this;
    }

    Vec3Real64&
    operator/=(double d)
    {
        mValues[0] /= d;
        mValues[1] /= d;
        mValues[2] /= d;
        return *this;
    }

private:
    Real64 mValues[3];
};

inline std::ostream&
operator<<(std::ostream& os, const Vec3Real64& v)
{
    return os << "(" << v.X() << "," << v.Y() << "," << v.Z() << ")";
}

inline Vec3Real64
operator+(const Vec3Real64& v1, const Vec3Real64& v2)
{
    return Vec3Real64(v1.X() + v2.X(), v1.Y() + v2.Y(), v1.Z() + v2.Z());
}

inline Vec3Real64
operator-(const Vec3Real64& v1, const Vec3Real64& v2)
{
    return Vec3Real64(v1.X() - v2.X(), v1.Y() - v2.Y(), v1.Z() - v2.Z());
}

inline Vec3Real64
operator*(const Vec3Real64& v1, const Vec3Real64& v2)
{
    return Vec3Real64(v1.X() * v2.X(), v1.Y() * v2.Y(), v1.Z() * v2.Z());
}

inline Vec3Real64
operator*(const Vec3Real64& v1, double d)
{
    return Vec3Real64(v1.X() * d, v1.Y() * d, v1.Z() * d);
}

inline Vec3Real64
operator/(const Vec3Real64& v1, const Vec3Real64& v2)
{
    return Vec3Real64(v1.X() / v2.X(), v1.Y() / v2.Y(), v1.Z() / v2.Z());
}

inline Vec3Real64
operator/(const Vec3Real64& v1, double d)
{
    return Vec3Real64(v1.X() / d, v1.Y() / d, v1.Z() / d);
}

} // namespace Element
} // namespace Array
} // namespace Core
} // namespace Impala

#endif

---