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

---

Complex64.h

Go to the documentation of this file.

#ifndef Impala_Core_Array_Element_Complex64_h
#define Impala_Core_Array_Element_Complex64_h

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

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


class Complex64 {
public:

    Complex64()
    {
    }

    Complex64(Real64 re, Real64 im)
    {
        mValues[0] = re;
        mValues[1] = im;
    }

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

    /*
    Complex64& operator=(const Complex64& 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];
    }
    
    int
    operator==(const Complex64& v) const
    {
        return (mValues[0] == v.mValues[0]) && (mValues[1] == v.mValues[1]);
    }

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

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

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

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

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

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

private:
    Real64 mValues[2];
};

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

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

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

inline Complex64
operator*(const Complex64& v1, const Complex64& v2)
{
    double re = v1.X()*v2.X() - v1.Y()*v2.Y();
    double im = v1.X()*v2.Y() + v1.Y()*v2.X();

    return Complex64(re, im);
}

inline Complex64
operator/(const Complex64& v1, const Complex64& v2)
{
    double re = v2.X();
    double im = v2.Y();
    double sq = re*re+im*im;

    double mulre = v1.X()*re + v1.Y()*im;
    double mulim = v1.Y()*re - v1.X()*im;

    return Complex64(mulre / sq, mulim / sq);
}

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

#endif

---