mirror of
https://gitlab.com/libeigen/eigen.git
synced 2025-04-29 23:34:12 +08:00
removed Eigen::Complex class since it offered insufficient advantage over std::complex when sane real,imag structure packing is assumed.
for more info see: http://www.cpptalk.net/portable-complex-numbers-between-c-c--vt46432.html
This commit is contained in:
Mark Borgerding
parent
9f899808d7
commit
adb2170eb8
@ -1,240 +0,0 @@
|
|||||||
#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 <http://www.gnu.org/licenses/>.
|
|
||||||
|
|
||||||
// Eigen::Complex reuses as much as possible from std::complex
|
|
||||||
// and allows easy conversion to and from, even at the pointer level.
|
|
||||||
|
|
||||||
/** \ingroup Unsupported_modules
|
|
||||||
* \defgroup Complex_Module Complex module
|
|
||||||
*
|
|
||||||
* \code
|
|
||||||
* #include <unsupported/Eigen/Complex>
|
|
||||||
* \endcode
|
|
||||||
*
|
|
||||||
* The C++ complex type has some severe limitations that prevent an
|
|
||||||
* optimal use within Eigen. This (still unsupported) module is an attempt
|
|
||||||
* to fix this.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <complex>
|
|
||||||
|
|
||||||
namespace Eigen {
|
|
||||||
|
|
||||||
template <typename _NativeData,typename _PunnedData>
|
|
||||||
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 <typename _NativeData,typename _PunnedData>
|
|
||||||
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 <typename T>
|
|
||||||
struct Complex
|
|
||||||
{
|
|
||||||
typedef typename std::complex<T> 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<class X>
|
|
||||||
Complex(const Complex<X>&other): _re(other.real()) ,_im(other.imag()) {}
|
|
||||||
template<class X>
|
|
||||||
Complex(const std::complex<X>&other): _re(other.real()) ,_im(other.imag()) {}
|
|
||||||
|
|
||||||
// allow binary access to the object as a std::complex
|
|
||||||
typedef castable_pointer< Complex<T>, StandardComplex > pointer_type;
|
|
||||||
typedef const_castable_pointer< Complex<T>, 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<const StandardComplex*>(this);}
|
|
||||||
|
|
||||||
inline
|
|
||||||
StandardComplex & std_type() {return *reinterpret_cast<StandardComplex*>(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<T>& operator= (const T& val) { _re=val;_im=0;return *this; }
|
|
||||||
inline
|
|
||||||
Complex<T>& operator+= (const T& val) {_re+=val;return *this;}
|
|
||||||
inline
|
|
||||||
Complex<T>& operator-= (const T& val) {_re-=val;return *this;}
|
|
||||||
inline
|
|
||||||
Complex<T>& operator*= (const T& val) {_re*=val;_im*=val;return *this; }
|
|
||||||
inline
|
|
||||||
Complex<T>& 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<class X> Complex<T>& operator= (const Complex<X>& rhs) { _re=rhs._re;_im=rhs._im;return *this;}
|
|
||||||
template<class X> Complex<T>& operator+= (const Complex<X>& rhs) { _re+=rhs._re;_im+=rhs._im;return *this;}
|
|
||||||
template<class X> Complex<T>& operator-= (const Complex<X>& rhs) { _re-=rhs._re;_im-=rhs._im;return *this;}
|
|
||||||
template<class X> Complex<T>& operator*= (const Complex<X>& rhs) { this->std_type() *= rhs.std_type(); return *this; }
|
|
||||||
template<class X> Complex<T>& operator/= (const Complex<X>& rhs) { this->std_type() /= rhs.std_type(); return *this; }
|
|
||||||
|
|
||||||
private:
|
|
||||||
T _re;
|
|
||||||
T _im;
|
|
||||||
};
|
|
||||||
|
|
||||||
//template <typename T> T ei_to_std( const T & x) {return x;}
|
|
||||||
|
|
||||||
template <typename T>
|
|
||||||
std::complex<T> ei_to_std( const Complex<T> & x) {return x.std_type();}
|
|
||||||
|
|
||||||
// 26.2.6 operators
|
|
||||||
template<class T> Complex<T> operator+(const Complex<T>& rhs) {return rhs;}
|
|
||||||
template<class T> Complex<T> operator-(const Complex<T>& rhs) {return -ei_to_std(rhs);}
|
|
||||||
|
|
||||||
template<class T> Complex<T> operator+(const Complex<T>& lhs, const Complex<T>& rhs) { return ei_to_std(lhs) + ei_to_std(rhs);}
|
|
||||||
template<class T> Complex<T> operator-(const Complex<T>& lhs, const Complex<T>& rhs) { return ei_to_std(lhs) - ei_to_std(rhs);}
|
|
||||||
template<class T> Complex<T> operator*(const Complex<T>& lhs, const Complex<T>& rhs) { return ei_to_std(lhs) * ei_to_std(rhs);}
|
|
||||||
template<class T> Complex<T> operator/(const Complex<T>& lhs, const Complex<T>& rhs) { return ei_to_std(lhs) / ei_to_std(rhs);}
|
|
||||||
template<class T> bool operator==(const Complex<T>& lhs, const Complex<T>& rhs) { return ei_to_std(lhs) == ei_to_std(rhs);}
|
|
||||||
template<class T> bool operator!=(const Complex<T>& lhs, const Complex<T>& rhs) { return ei_to_std(lhs) != ei_to_std(rhs);}
|
|
||||||
|
|
||||||
template<class T> Complex<T> operator+(const Complex<T>& lhs, const T& rhs) {return ei_to_std(lhs) + ei_to_std(rhs); }
|
|
||||||
template<class T> Complex<T> operator-(const Complex<T>& lhs, const T& rhs) {return ei_to_std(lhs) - ei_to_std(rhs); }
|
|
||||||
template<class T> Complex<T> operator*(const Complex<T>& lhs, const T& rhs) {return ei_to_std(lhs) * ei_to_std(rhs); }
|
|
||||||
template<class T> Complex<T> operator/(const Complex<T>& lhs, const T& rhs) {return ei_to_std(lhs) / ei_to_std(rhs); }
|
|
||||||
template<class T> bool operator==(const Complex<T>& lhs, const T& rhs) {return ei_to_std(lhs) == ei_to_std(rhs); }
|
|
||||||
template<class T> bool operator!=(const Complex<T>& lhs, const T& rhs) {return ei_to_std(lhs) != ei_to_std(rhs); }
|
|
||||||
|
|
||||||
template<class T> Complex<T> operator+(const T& lhs, const Complex<T>& rhs) {return ei_to_std(lhs) + ei_to_std(rhs); }
|
|
||||||
template<class T> Complex<T> operator-(const T& lhs, const Complex<T>& rhs) {return ei_to_std(lhs) - ei_to_std(rhs); }
|
|
||||||
template<class T> Complex<T> operator*(const T& lhs, const Complex<T>& rhs) {return ei_to_std(lhs) * ei_to_std(rhs); }
|
|
||||||
template<class T> Complex<T> operator/(const T& lhs, const Complex<T>& rhs) {return ei_to_std(lhs) / ei_to_std(rhs); }
|
|
||||||
template<class T> bool operator==(const T& lhs, const Complex<T>& rhs) {return ei_to_std(lhs) == ei_to_std(rhs); }
|
|
||||||
template<class T> bool operator!=(const T& lhs, const Complex<T>& rhs) {return ei_to_std(lhs) != ei_to_std(rhs); }
|
|
||||||
|
|
||||||
template<class T, class charT, class traits>
|
|
||||||
std::basic_istream<charT,traits>&
|
|
||||||
operator>> (std::basic_istream<charT,traits>& istr, Complex<T>& rhs)
|
|
||||||
{
|
|
||||||
return istr >> rhs.std_type();
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T, class charT, class traits>
|
|
||||||
std::basic_ostream<charT,traits>&
|
|
||||||
operator<< (std::basic_ostream<charT,traits>& ostr, const Complex<T>& rhs)
|
|
||||||
{
|
|
||||||
return ostr << rhs.std_type();
|
|
||||||
}
|
|
||||||
|
|
||||||
// 26.2.7 values:
|
|
||||||
template<class T> T real(const Complex<T>&x) {return real(ei_to_std(x));}
|
|
||||||
template<class T> T abs(const Complex<T>&x) {return abs(ei_to_std(x));}
|
|
||||||
template<class T> T arg(const Complex<T>&x) {return arg(ei_to_std(x));}
|
|
||||||
template<class T> T norm(const Complex<T>&x) {return norm(ei_to_std(x));}
|
|
||||||
|
|
||||||
template<class T> Complex<T> conj(const Complex<T>&x) { return conj(ei_to_std(x));}
|
|
||||||
template<class T> Complex<T> polar(const T& x, const T&y) {return polar(ei_to_std(x),ei_to_std(y));}
|
|
||||||
// 26.2.8 transcendentals:
|
|
||||||
template<class T> Complex<T> cos (const Complex<T>&x){return cos(ei_to_std(x));}
|
|
||||||
template<class T> Complex<T> cosh (const Complex<T>&x){return cosh(ei_to_std(x));}
|
|
||||||
template<class T> Complex<T> exp (const Complex<T>&x){return exp(ei_to_std(x));}
|
|
||||||
template<class T> Complex<T> log (const Complex<T>&x){return log(ei_to_std(x));}
|
|
||||||
template<class T> Complex<T> log10 (const Complex<T>&x){return log10(ei_to_std(x));}
|
|
||||||
|
|
||||||
template<class T> Complex<T> pow(const Complex<T>&x, int p) {return pow(ei_to_std(x),p);}
|
|
||||||
template<class T> Complex<T> pow(const Complex<T>&x, const T&p) {return pow(ei_to_std(x),ei_to_std(p));}
|
|
||||||
template<class T> Complex<T> pow(const Complex<T>&x, const Complex<T>&p) {return pow(ei_to_std(x),ei_to_std(p));}
|
|
||||||
template<class T> Complex<T> pow(const T&x, const Complex<T>&p) {return pow(ei_to_std(x),ei_to_std(p));}
|
|
||||||
|
|
||||||
template<class T> Complex<T> sin (const Complex<T>&x){return sin(ei_to_std(x));}
|
|
||||||
template<class T> Complex<T> sinh (const Complex<T>&x){return sinh(ei_to_std(x));}
|
|
||||||
template<class T> Complex<T> sqrt (const Complex<T>&x){return sqrt(ei_to_std(x));}
|
|
||||||
template<class T> Complex<T> tan (const Complex<T>&x){return tan(ei_to_std(x));}
|
|
||||||
template<class T> Complex<T> tanh (const Complex<T>&x){return tanh(ei_to_std(x));}
|
|
||||||
|
|
||||||
template<typename _Real> struct NumTraits<Complex<_Real> >
|
|
||||||
{
|
|
||||||
typedef _Real Real;
|
|
||||||
typedef Complex<_Real> FloatingPoint;
|
|
||||||
enum {
|
|
||||||
IsComplex = 1,
|
|
||||||
HasFloatingPoint = NumTraits<Real>::HasFloatingPoint,
|
|
||||||
ReadCost = 2,
|
|
||||||
AddCost = 2 * NumTraits<Real>::AddCost,
|
|
||||||
MulCost = 4 * NumTraits<Real>::MulCost + 2 * NumTraits<Real>::AddCost
|
|
||||||
};
|
|
||||||
};
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
/* vim: set filetype=cpp et sw=2 ts=2 ai: */
|
|
||||||
|
|
||||||
@ -24,4 +24,3 @@ if(FFTW_FOUND)
|
|||||||
ei_add_test(FFTW "-DEIGEN_FFTW_DEFAULT " "-lfftw3 -lfftw3f -lfftw3l" )
|
ei_add_test(FFTW "-DEIGEN_FFTW_DEFAULT " "-lfftw3 -lfftw3f -lfftw3l" )
|
||||||
endif(FFTW_FOUND)
|
endif(FFTW_FOUND)
|
||||||
|
|
||||||
ei_add_test(Complex)
|
|
||||||
|
|||||||
@ -1,78 +0,0 @@
|
|||||||
// This file is part of Eigen, a lightweight C++ template library
|
|
||||||
// for linear algebra. Eigen itself is part of the KDE project.
|
|
||||||
//
|
|
||||||
// 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 <http://www.gnu.org/licenses/>.
|
|
||||||
#ifdef EIGEN_TEST_FUNC
|
|
||||||
# include "main.h"
|
|
||||||
#else
|
|
||||||
# include <iostream>
|
|
||||||
# define CALL_SUBTEST(x) x
|
|
||||||
# define VERIFY(x) x
|
|
||||||
# define test_Complex main
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#include <unsupported/Eigen/Complex>
|
|
||||||
#include <vector>
|
|
||||||
|
|
||||||
using namespace std;
|
|
||||||
using namespace Eigen;
|
|
||||||
|
|
||||||
template <typename T>
|
|
||||||
void take_std( std::complex<T> * dst, int n )
|
|
||||||
{
|
|
||||||
for (int i=0;i<n;++i)
|
|
||||||
dst[i] = std::complex<T>(static_cast<float>(i),static_cast<float>(i));
|
|
||||||
cout << dst[n-1] << endl;
|
|
||||||
}
|
|
||||||
|
|
||||||
template <typename T>
|
|
||||||
void syntax()
|
|
||||||
{
|
|
||||||
// this works fine
|
|
||||||
Matrix< Complex<T>, 9, 1> a;
|
|
||||||
std::complex<T> * pa = &a[0];
|
|
||||||
//Complex<T> * pa2 = &a[0];
|
|
||||||
take_std( pa,9);
|
|
||||||
|
|
||||||
// this does not work, but I wish it would
|
|
||||||
// take_std(&a[0];)
|
|
||||||
// this does
|
|
||||||
take_std( (std::complex<T> *)&a[0],9);
|
|
||||||
|
|
||||||
// this does not work, but it would be really nice
|
|
||||||
//vector< Complex<T> > a;
|
|
||||||
// (on my gcc 4.4.1 )
|
|
||||||
// std::vector assumes operator& returns a POD pointer
|
|
||||||
|
|
||||||
// this works fine
|
|
||||||
Complex<T> b[9];
|
|
||||||
std::complex<T> * pb = &b[0]; // this works fine
|
|
||||||
|
|
||||||
take_std( pb,9);
|
|
||||||
}
|
|
||||||
|
|
||||||
void test_Complex()
|
|
||||||
{
|
|
||||||
CALL_SUBTEST( syntax<float>() );
|
|
||||||
CALL_SUBTEST( syntax<double>() );
|
|
||||||
CALL_SUBTEST( syntax<long double>() );
|
|
||||||
}
|
|
||||||
Loading…
x
Reference in New Issue
Block a user