#ifndef EIGEN_COMPLEX_H
#define EIGEN_COMPLEX_H
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2009 Mark Borgerding mark a borgerding net
//
// Eigen is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 3 of the License, or (at your option) any later version.
//
// Alternatively, you can redistribute it and/or
// modify it under the terms of the GNU General Public License as
// published by the Free Software Foundation; either version 2 of
// the License, or (at your option) any later version.
//
// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License and a copy of the GNU General Public License along with
// Eigen. If not, see .
// Eigen::Complex reuses as much as possible from std::complex
// and allows easy conversion to and from, even at the pointer level.
#include
namespace Eigen {
template
struct castable_pointer
{
castable_pointer(_NativeData * ptr) : _ptr(ptr) { }
operator _NativeData * () {return _ptr;}
operator _PunnedData * () {return reinterpret_cast<_PunnedData*>(_ptr);}
operator const _NativeData * () const {return _ptr;}
operator const _PunnedData * () const {return reinterpret_cast<_PunnedData*>(_ptr);}
private:
_NativeData * _ptr;
};
template
struct const_castable_pointer
{
const_castable_pointer(_NativeData * ptr) : _ptr(ptr) { }
operator const _NativeData * () const {return _ptr;}
operator const _PunnedData * () const {return reinterpret_cast<_PunnedData*>(_ptr);}
private:
_NativeData * _ptr;
};
template
struct Complex
{
typedef typename std::complex StandardComplex;
typedef T value_type;
// constructors
Complex() {}
Complex(const T& re, const T& im = T()) : _re(re),_im(im) { }
Complex(const Complex&other ): _re(other.real()) ,_im(other.imag()) {}
template
Complex(const Complex&other): _re(other.real()) ,_im(other.imag()) {}
template
Complex(const std::complex&other): _re(other.real()) ,_im(other.imag()) {}
// allow binary access to the object as a std::complex
typedef castable_pointer< Complex, StandardComplex > pointer_type;
typedef const_castable_pointer< Complex, StandardComplex > const_pointer_type;
inline
pointer_type operator & () {return pointer_type(this);}
inline
const_pointer_type operator & () const {return const_pointer_type(this);}
inline
operator StandardComplex () const {return std_type();}
inline
operator StandardComplex & () {return std_type();}
inline
const StandardComplex & std_type() const {return *reinterpret_cast(this);}
inline
StandardComplex & std_type() {return *reinterpret_cast(this);}
// every sort of accessor and mutator that has ever been in fashion.
// For a brief history, search for "std::complex over-encapsulated"
// http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#387
inline
const T & real() const {return _re;}
inline
const T & imag() const {return _im;}
inline
T & real() {return _re;}
inline
T & imag() {return _im;}
inline
T & real(const T & x) {return _re=x;}
inline
T & imag(const T & x) {return _im=x;}
inline
void set_real(const T & x) {_re = x;}
inline
void set_imag(const T & x) {_im = x;}
// *** complex member functions: ***
inline
Complex& operator= (const T& val) { _re=val;_im=0;return *this; }
inline
Complex& operator+= (const T& val) {_re+=val;return *this;}
inline
Complex& operator-= (const T& val) {_re-=val;return *this;}
inline
Complex& operator*= (const T& val) {_re*=val;_im*=val;return *this; }
inline
Complex& operator/= (const T& val) {_re/=val;_im/=val;return *this; }
inline
Complex& operator= (const Complex& rhs) {_re=rhs._re;_im=rhs._im;return *this;}
inline
Complex& operator= (const StandardComplex& rhs) {_re=rhs.real();_im=rhs.imag();return *this;}
template Complex& operator= (const Complex& rhs) { _re=rhs._re;_im=rhs._im;return *this;}
template Complex& operator+= (const Complex& rhs) { _re+=rhs._re;_im+=rhs._im;return *this;}
template Complex& operator-= (const Complex& rhs) { _re-=rhs._re;_im-=rhs._im;return *this;}
template Complex& operator*= (const Complex& rhs) { this->std_type() *= rhs.std_type(); return *this; }
template Complex& operator/= (const Complex& rhs) { this->std_type() /= rhs.std_type(); return *this; }
private:
T _re;
T _im;
};
//template T ei_to_std( const T & x) {return x;}
template
std::complex ei_to_std( const Complex & x) {return x.std_type();}
// 26.2.6 operators
template Complex operator+(const Complex& rhs) {return rhs;}
template Complex operator-(const Complex& rhs) {return -ei_to_std(rhs);}
template Complex operator+(const Complex& lhs, const Complex& rhs) { return ei_to_std(lhs) + ei_to_std(rhs);}
template Complex operator-(const Complex& lhs, const Complex& rhs) { return ei_to_std(lhs) - ei_to_std(rhs);}
template Complex operator*(const Complex& lhs, const Complex& rhs) { return ei_to_std(lhs) * ei_to_std(rhs);}
template Complex operator/(const Complex& lhs, const Complex& rhs) { return ei_to_std(lhs) / ei_to_std(rhs);}
template bool operator==(const Complex& lhs, const Complex& rhs) { return ei_to_std(lhs) == ei_to_std(rhs);}
template bool operator!=(const Complex& lhs, const Complex& rhs) { return ei_to_std(lhs) != ei_to_std(rhs);}
template Complex operator+(const Complex& lhs, const T& rhs) {return ei_to_std(lhs) + ei_to_std(rhs); }
template Complex operator-(const Complex& lhs, const T& rhs) {return ei_to_std(lhs) - ei_to_std(rhs); }
template Complex operator*(const Complex& lhs, const T& rhs) {return ei_to_std(lhs) * ei_to_std(rhs); }
template Complex operator/(const Complex& lhs, const T& rhs) {return ei_to_std(lhs) / ei_to_std(rhs); }
template bool operator==(const Complex& lhs, const T& rhs) {return ei_to_std(lhs) == ei_to_std(rhs); }
template bool operator!=(const Complex& lhs, const T& rhs) {return ei_to_std(lhs) != ei_to_std(rhs); }
template Complex operator+(const T& lhs, const Complex& rhs) {return ei_to_std(lhs) + ei_to_std(rhs); }
template Complex operator-(const T& lhs, const Complex& rhs) {return ei_to_std(lhs) - ei_to_std(rhs); }
template Complex operator*(const T& lhs, const Complex& rhs) {return ei_to_std(lhs) * ei_to_std(rhs); }
template Complex operator/(const T& lhs, const Complex& rhs) {return ei_to_std(lhs) / ei_to_std(rhs); }
template bool operator==(const T& lhs, const Complex& rhs) {return ei_to_std(lhs) == ei_to_std(rhs); }
template bool operator!=(const T& lhs, const Complex& rhs) {return ei_to_std(lhs) != ei_to_std(rhs); }
template
std::basic_istream&
operator>> (std::basic_istream& istr, Complex& rhs)
{
return istr >> rhs.std_type();
}
template
std::basic_ostream&
operator<< (std::basic_ostream& ostr, const Complex& rhs)
{
return ostr << rhs.std_type();
}
// 26.2.7 values:
template T real(const Complex&x) {return real(ei_to_std(x));}
template T abs(const Complex&x) {return abs(ei_to_std(x));}
template T arg(const Complex&x) {return arg(ei_to_std(x));}
template T norm(const Complex&x) {return norm(ei_to_std(x));}
template Complex conj(const Complex&x) { return conj(ei_to_std(x));}
template Complex polar(const T& x, const T&y) {return polar(ei_to_std(x),ei_to_std(y));}
// 26.2.8 transcendentals:
template Complex cos (const Complex&x){return cos(ei_to_std(x));}
template Complex cosh (const Complex&x){return cosh(ei_to_std(x));}
template Complex exp (const Complex&x){return exp(ei_to_std(x));}
template Complex log (const Complex&x){return log(ei_to_std(x));}
template Complex log10 (const Complex&x){return log10(ei_to_std(x));}
template Complex pow(const Complex&x, int p) {return pow(ei_to_std(x),p);}
template Complex pow(const Complex&x, const T&p) {return pow(ei_to_std(x),ei_to_std(p));}
template Complex pow(const Complex&x, const Complex&p) {return pow(ei_to_std(x),ei_to_std(p));}
template Complex pow(const T&x, const Complex&p) {return pow(ei_to_std(x),ei_to_std(p));}
template Complex sin (const Complex&x){return sin(ei_to_std(x));}
template Complex sinh (const Complex&x){return sinh(ei_to_std(x));}
template Complex sqrt (const Complex&x){return sqrt(ei_to_std(x));}
template Complex tan (const Complex&x){return tan(ei_to_std(x));}
template Complex tanh (const Complex&x){return tanh(ei_to_std(x));}
template struct NumTraits >
{
typedef _Real Real;
typedef Complex<_Real> FloatingPoint;
enum {
IsComplex = 1,
HasFloatingPoint = NumTraits::HasFloatingPoint,
ReadCost = 2,
AddCost = 2 * NumTraits::AddCost,
MulCost = 4 * NumTraits::MulCost + 2 * NumTraits::AddCost
};
};
}
#endif
/* vim: set filetype=cpp et sw=2 ts=2 ai: */