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

---

Vec2Real64.h

Go to the documentation of this file.

#ifndef Impala_Core_Array_Element_Vec2Real64_h
#define Impala_Core_Array_Element_Vec2Real64_h

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

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


class Vec2Real64 {
public:

    Vec2Real64()
    {
    }

    Vec2Real64(Real64 x, Real64 y)
    {
        mValues[0] = x;
        mValues[1] = y;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

private:
    Real64 mValues[2];
};

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

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

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

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

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

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

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

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

#endif

---