//: complex.h
#ifndef _COMPLEX_H_
#define _COMPLEX_H_
namespace numeric {
//////////////////////////////////////////////////////////////////////////
#include <math.h>
#define LOG10 2.30258512496948
//////////////////////////////////////////////////////////////////////////
//template<typename _tp>
//class complex;
//
//template<class _arg1, class _arg2, class _oper>
//struct _binary_expr_cc;
//////////////////////////////////////////////////////////////////////////
template<typename _tp1, typename _tp2>
struct _return_type
{
typedef double value_type;
};
template<typename _tp1>
struct _return_type<_tp1, long double>
{
typedef long double value_type;
};
template<typename _tp2>
struct _return_type<long double, _tp2>
{
typedef long double value_type;
};
template<>
struct _return_type<float, float>
{
typedef float value_type;
};
//////////////////////////////////////////////////////////////////////////
template<typename _tp>
struct constnt
{
typedef typename _tp value_type;
public:
const _tp& _m_cnst;
public:
constnt(const _tp& __t) : _m_cnst(__t) {}
//constnt(const constnt& __c) : _m_cnst(__c._m_cnst) { }
public:
inline value_type real() const
{ return _m_cnst; }
inline value_type imag() const
{ return 0; }
};
//////////////////////////////////////////////////////////////////////////
struct _abs_cc
{
template<class _arg>
static inline typename _arg::value_type
evaluate(const _arg& __a)
{ return sqrt(__a.real()*__a.real()+__a.imag()*__a.imag()); }
};
struct _arg_cc
{
template<class _arg>
static inline typename _arg::value_type
evaluate(const _arg& __a)
{ return atan2(__a.imag(), __a.real()); }
};
struct _norm_cc
{
template<class _arg>
static inline typename _arg::value_type
evaluate(const _arg& __a)
{ return (__a.real()*__a.real()+__a.imag()*__a.imag()); }
};
//////////////////////////////////////////////////////////////////////////
struct _conjg_cc
{
template<class _arg>
static inline typename _arg::value_type
real(const _arg& __a)
{ return __a.real(); }
template<class _arg>
static inline typename _arg::value_type
imag(const _arg& __a)
{ return -__a.imag(); }
};
struct _cos_cc
{
template<class _arg>
static inline typename _arg::value_type
real(const _arg& __a)
{ return cos(__a.real())*cosh(__a.imag()); }
template<class _arg>
static inline typename _arg::value_type
imag(const _arg& __a)
{ return -sin(__a.real())*sinh(__a.imag()); }
};
struct _cosh_cc
{
template<class _arg>
static inline typename _arg::value_type
real(const _arg& __a)
{ return cosh(__a.real())*cos(__a.imag()); }
template<class _arg>
static inline typename _arg::value_type
imag(const _arg& __a)
{ return sinh(__a.real())*sin(__a.imag()); }
};
struct _exp_cc
{
template<class _arg>
static inline typename _arg::value_type
real(const _arg& __a)
{
typedef typename _arg::value_type value_type;
//value_type tmp = exp(__a.real());
return exp(__a.real())*cos(__a.imag());
}
template<class _arg>
static inline typename _arg::value_type
imag(const _arg& __a)
{
typedef typename _arg::value_type value_type;
//value_type tmp = exp(__a.real());
return exp(__a.real())*sin(__a.imag());
}
};
struct _log_cc
{
template<class _arg>
static inline typename _arg::value_type
real(const _arg& __a)
{
typedef typename _arg::value_type value_type;
value_type tmp = __a.real()*__a.real()+__a.imag()*__a.imag();
return log(tmp)*0.5;
}
template<class _arg>
static inline typename _arg::value_type
imag(const _arg& __a)
{
return atan2(__a.imag(), __a.real());
}
};
struct _log10_cc
{
template<class _arg>
static inline typename _arg::value_type
real(const _arg& __a)
{
typedef typename _arg::value_type value_type;
value_type tmp = __a.real()*__a.real()+__a.imag()*__a.imag();
return log10(tmp)*0.5;
}
template<class _arg>
static inline typename _arg::value_type
imag(const _arg& __a)
{
return arg(__a)/LOG10;
}
};
struct _sin_cc
{
template<class _arg>
static inline typename _arg::value_type
real(const _arg& __a)
{ return sin(__a.real())*cosh(__a.imag()); }
template<class _arg>
static inline typename _arg::value_type
imag(const _arg& __a)
{ return cos(__a.real())*sinh(__a.imag()); }
};
struct _sinh_cc
{
template<class _arg>
static inline typename _arg::value_type
real(const _arg& __a)
{ return sinh(__a.real())*cos(__a.imag()); }
template<class _arg>
static inline typename _arg::value_type
imag(const _arg& __a)
{ return cosh(__a.real())*sin(__a.imag()); }
};
//////////////////////////////////////////////////////////////////////////
struct _pow_cc
{
template<class _arg1, class _arg2>
static inline typename _return_type<typename _arg1::value_type,
typename _arg2::value_type>::value_type
real(const _arg1& __a, const _arg2& __b)
{
//typedef typename
//_return_type<typename _arg1::value_type,
// typename _arg2::value_type
// >::value_type value_type;
//value_type t1 = log(__a.real()*__a.real()+__a.imag()*__a.imag())*0.5;
//value_type t2 = arg(__a);
//return exp(t1*__b.real()-t2*__b.imag())*cos(t1*__b.imag()+t2*__b.real());
return exp(__b*log(__a)).real();
}
template<class _arg1, class _arg2>
static inline typename _return_type<typename _arg1::value_type,
typename _arg2::value_type>::value_type
imag(const _arg1& __a, const _arg2& __b)
{
//typedef typename
//_return_type<typename _arg1::value_type,
// typename _arg2::value_type
// >::value_type value_type;
//value_type t1 = log(__a.real()*__a.real()+__a.imag()*__a.imag())*0.5;
//value_type t2 = arg(__a);
//return exp(t1*__b.real()-t2*__b.imag())*sin(t1*__b.imag()+t2*__b.real());
return exp(__b*log(__a)).imag();
}
};
//////////////////////////////////////////////////////////////////////////
struct _unary_add_cc
{
template<class _arg>
static inline typename _arg::value_type
real(const _arg& __a)
{ return __a.real(); }
template<class _arg>
static inline typename _arg::value_type
imag(const _arg& __a)
{ return __a.imag(); }
};
//////////////////////////////////////////////////////////////////////////
struct _unary_sub_cc
{
template<class _arg>
static inline typename _arg::value_type
real(const _arg& __a)
{ return -__a.real(); }
template<class _arg>
static inline typename _arg::value_type
imag(const _arg& __a)
{ return -__a.imag(); }
};
//////////////////////////////////////////////////////////////////////////
struct _binary_add_cc
{
template<class _arg1, class _arg2>
static inline typename _return_type<typename _arg1::value_type,
typename _arg2::value_type>::value_type
real(const _arg1& __a, const _arg2& __b)
{ return __a.real() + __b.real(); }
template<class _arg1, class _arg2>
static inline typename _return_type<typename _arg1::value_type,
typename _arg2::value_type>::value_type
imag(const _arg1& __a, const _arg2& __b)
{ return __a.imag() + __b.imag(); }
};
//////////////////////////////////////////////////////////////////////////
struct _binary_sub_cc
{
template<class _arg1, class _arg2>
static inline typename _return_type<typename _arg1::value_type,
typename _arg2::value_type>::value_type
real(const _arg1& __a, const _arg2& __b)
{ return __a.real() - __b.real(); }
template<class _arg1, class _arg2>
static inline typename _return_type<typename _arg1::value_type,
typename _arg2::value_type>::value_type
imag(const _arg1& __a, const _arg2& __b)
{ return __a.imag() - __b.imag(); }
};
//////////////////////////////////////////////////////////////////////////
struct _binary_mul_cc
{
template<class _arg1, class _arg2>
static inline typename _return_type<typename _arg1::value_type,
typename _arg2::value_type>::value_type
real(const _arg1& __a, const _arg2& __b)
{ return __a.real()*__b.real() - __a.imag()*__b.imag(); }
template<class _arg1, class _arg2>
static inline typename _return_type<typename _arg1::value_type,
typename _arg2::value_type>::value_type
imag(const _arg1& __a, const _arg2& __b)
{ return __a.imag()*__b.real() + __a.real()*__b.imag(); }
};
//////////////////////////////////////////////////////////////////////////
struct _binary_div_cc
{
template<class _arg1, class _arg2>
static inline typename _return_type<typename _arg1::value_type,
typename _arg2::value_type>::value_type
real(const _arg1& __a, const _arg2& __b)
{ return (__a.real()*__b.real() + __a.imag()*__b.imag())/
(__b.real()*__b.real() + __b.imag()*__b.imag()); }
template<class _arg1, class _arg2>
static inline typename _return_type<typename _arg1::value_type,
typename _arg2::value_type>::value_type
imag(const _arg1& __a, const _arg2& __b)
{ return (__a.imag()*__b.real() - __a.real()*__b.imag())/
(__b.real()*__b.real() + __b.imag()*__b.imag()); }
};
//////////////////////////////////////////////////////////////////////////
template<class _arg, class _oper>
struct _unary_expr_cc
{
typedef typename _arg::value_type value_type;
public:
const _arg& _m_arg;
public:
_unary_expr_cc(const _arg& __a) : _m_arg(__a)
{ }
inline value_type real() const
{ return _oper::real(_m_arg); }
inline value_type imag() const
{ return _oper::imag(_m_arg); }
public:
_unary_expr_cc<_unary_expr_cc<_arg,_oper>,_unary_add_cc>
operator+() const
{
typedef _unary_expr_cc<_unary_expr_cc<_arg,_oper>,
_unary_add_cc> _expr;
return _expr(*this);
}
_unary_expr_cc<_unary_expr_cc<_arg,_oper>,_unary_sub_cc>
operator-() const
{
typedef _unary_expr_cc<_unary_expr_cc<_arg,_oper>,
_unary_sub_cc> _expr;
return _expr(*this);
}
};
//////////////////////////////////////////////////////////////////////////
template<class _arg1, class _arg2, class _oper>
struct _binary_expr_cc
{
typedef typename
_return_type<typename _arg1::value_type,
typename _arg2::value_type>::value_type
value_type;
public:
const _arg1& _m_arg1;
const _arg2& _m_arg2;
public:
_binary_expr_cc(const _arg1& __a, const _arg2& __b)
: _m_arg1(__a), _m_arg2(__b)
{ }
public:
inline value_type real() const
{ return _oper::real(_m_arg1, _m_arg2); }
inline value_type imag() const
{ return _oper::imag(_m_arg1, _m_arg2); }
public:
_unary_expr_cc<_binary_expr_cc<_arg1,_arg2,_oper>,_unary_add_cc>
operator+() const
{
typedef _unary_expr_cc<_binary_expr_cc<_arg1,_arg2,_oper>,
_unary_add_cc
> _expr;
return _expr(*this);
}
_unary_expr_cc<_binary_expr_cc<_arg1,_arg2,_oper>,_unary_sub_cc>
operator-() const
{
typedef _unary_expr_cc<_binary_expr_cc<_arg1,_arg2,_oper>,
_unary_sub_cc
> _expr;
return _expr(*this);
}
};
//////////////////////////////////////////////////////////////////////////
#ifdef _DEBUG
// 在debug下，由于编译器对生成的临时变量严格按照C++标准来处理(也就是临时
// 变量生存期问题)，所以需要针对常量类型进行特化。但是现在的编译器在
// release下都能对代码作出很好的优化，临时变量被优化掉了，所以没有特化
// 也能得到正确的结果!
template<typename _tp, class _arg2, class _oper>
struct _binary_expr_cc<constnt<_tp>,_arg2,_oper>
{
typedef typename
_return_type<typename _tp,
typename _arg2::value_type>::value_type
value_type;
public:
const constnt<_tp> _m_arg1;
const _arg2& _m_arg2;
public:
_binary_expr_cc(const constnt<_tp>& __a, const _arg2& __b)
: _m_arg1(__a), _m_arg2(__b)
{ //cout << "hello" << endl; }
public:
inline value_type real() const
{ return _oper::real(_m_arg1, _m_arg2); }
inline value_type imag() const
{ return _oper::imag(_m_arg1, _m_arg2); }
public:
_unary_expr_cc<_binary_expr_cc<constnt<_tp>,_arg2,_oper>,_unary_add_cc>
operator+() const
{
typedef _unary_expr_cc<_binary_expr_cc<constnt<_tp>,_arg2,_oper>,
_unary_add_cc
> _expr;
return _expr(*this);
}
};
//////////////////////////////////////////////////////////////////////////
template<class _arg1, class _tp, class _oper>
struct _binary_expr_cc<_arg1,constnt<_tp>,_oper>
{
typedef typename
_return_type<typename _arg1::value_type,
typename _tp
>::value_type value_type;
public:
const _arg1& _m_arg1;
const constnt<_tp> _m_arg2;
public:
_binary_expr_cc(const _arg1& __a, const constnt<_tp>& __b)
: _m_arg1(__a), _m_arg2(__b)
{ }
public:
inline value_type real() const
{ return _oper::real(_m_arg1, _m_arg2); }
inline value_type imag() const
{ return _oper::imag(_m_arg1, _m_arg2); }
public:
_unary_expr_cc<_binary_expr_cc<_arg1,constnt<_tp>,_oper>,
_unary_add_cc
>
operator+() const
{
typedef _unary_expr_cc<_binary_expr_cc<_arg1,constnt<_tp>,_oper>,
_unary_add_cc
> _expr;
return _expr(*this);
}
_unary_expr_cc<_binary_expr_cc<_arg1,constnt<_tp>,_oper>,
_unary_sub_cc
>
operator-() const
{
typedef _unary_expr_cc<_binary_expr_cc<_arg1,constnt<_tp>,_oper>,
_unary_sub_cc
> _expr;
return _expr(*this);
}
};
#endif // _DEBUG
//////////////////////////////////////////////////////////////////////////
template<typename _tp>
class complex
{
public:
typedef typename _tp value_type;
protected:
value_type _m_real;
value_type _m_imag;
public:
complex(const _tp& __real = _tp(), const _tp& __imag = _tp())
: _m_real(__real), _m_imag(__imag)
{
#ifdef _DEBUG
if ((typeid(value_type) != typeid(float)) &&
(typeid(value_type) != typeid(double)) &&
(typeid(value_type) != typeid(long double))) {
cout << "complex模板参数类型只支持浮点数!" << endl;
exit(0);
}
#endif // _DEBUG
}
complex(const complex& __c)
: _m_real(__c._m_real), _m_imag(__c._m_imag)
{ }
public:
template<class _arg, class _oper>
complex(const _unary_expr_cc<_arg,_oper>& __e)
: _m_real(__e.real()), _m_imag(__e.imag())
{ }
template<class _arg1, class _arg2, class _oper>
complex(const _binary_expr_cc<_arg1,_arg2,_oper>& __e)
: _m_real(__e.real()), _m_imag(__e.imag())
{ }
public:
inline complex& operator=(const complex& __c)
{
_m_real = __c.real();
_m_imag = __c.imag();
return *this;
}
template<class _arg, class _oper>
inline complex& operator=(const _unary_expr_cc<_arg,_oper>& __e)
{
_m_real = __e.real();
_m_imag = __e.imag();
return *this;
}
template<class _arg1, class _arg2, class _oper>
inline complex& operator=(const _binary_expr_cc<_arg1,_arg2,_oper>& __e)
{
_m_real = __e.real();
_m_imag = __e.imag();
return *this;
}
public:
inline complex& operator+=(const complex& __c)
{
_m_real += __c.real();
_m_imag += __c.imag();
return *this;
}
template<class _arg, class _oper>
inline complex& operator+=(const _unary_expr_cc<_arg,_oper>& __e)
{
_m_real += __e.real();
_m_imag += __e.imag();
return *this;
}
template<class _arg1, class _arg2, class _oper>
inline complex& operator+=(const _binary_expr_cc<_arg1,_arg2,_oper>& __e)
{
_m_real += __e.real();
_m_imag += __e.imag();
return *this;
}
inline complex& operator-=(const complex& __c)
{
_m_real -= __c.real();
_m_imag -= __c.imag();
return *this;
}
template<class _arg, class _oper>
inline complex& operator-=(const _unary_expr_cc<_arg,_oper>& __e)
{
_m_real -= __e.real();
_m_imag -= __e.imag();
return *this;
}
template<class _arg1, class _arg2, class _oper>
inline complex& operator-=(const _binary_expr_cc<_arg1,_arg2,_oper>& __e)
{
_m_real -= __e.real();
_m_imag -= __e.imag();
return *this;
}
inline complex& operator*=(const complex& __c)
{
static _tp rx, iy;
rx = _m_real*__c.real() - _m_imag*__c.imag();
iy = _m_real*__c.imag() + _m_imag*__c.real();
_m_real = rx;
_m_imag = iy;
return *this;
}
template<class _arg, class _oper>
inline complex& operator*=(const _unary_expr_cc<_arg,_oper>& __e)
{
static _tp rx, iy, ex, ey;
ex = __e.real();
ey = __e.imag();
rx = _m_real*ex - _m_imag*ey;
iy = _m_real*ey + _m_imag*ex;
_m_real = rx;
_m_imag = iy;
return *this;
}
template<class _arg1, class _arg2, class _oper>
inline complex& operator*=(const _binary_expr_cc<_arg1,_arg2,_oper>& __e)
{
static _tp rx, iy;
rx = _m_real*__e.real() - _m_imag*__e.imag();
iy = _m_real*__e.imag() + _m_imag*__e.real();
_m_real = rx;
_m_imag = iy;
return *this;
}
inline complex& operator/=(const complex& __c)
{
static _tp rx, iy, cx, cy, rt;
cx = __c.real();
cy = __c.imag();
rt = 1/(cx*cx+cy*cy);
rx = _m_real*cx + _m_imag*cy;
iy = -_m_real*cy + _m_imag*cx;
_m_real = rx*rt;
_m_imag = iy*rt;
return *this;
}
template<class _arg, class _oper>
inline complex& operator/=(const _unary_expr_cc<_arg,_oper>& __e)
{
static _tp rx, iy, ex, ey, rt;
ex = __e.real();
ey = __e.imag();
rt = 1/(ex*ex+ey*ey);
rx = _m_real*ex + _m_imag*ey;
iy = -_m_real*ey + _m_imag*ex;
_m_real = rx*rt;
_m_imag = iy*rt;
return *this;
}
template<class _arg1, class _arg2, class _oper>
inline complex& operator/=(const _binary_expr_cc<_arg1,_arg2,_oper>& __e)
{
static _tp rx, iy, ex, ey, rt;
ex = __e.real();
ey = __e.imag();
rt = 1/(ex*ex+ey*ey);
rx = _m_real*ex + _m_imag*ey;
iy = -_m_real*ey + _m_imag*ex;
_m_real = rx*rt;
_m_imag = iy*rt;
return *this;
}
public:
inline value_type real() const { return _m_real; }
inline value_type imag() const { return _m_imag; }
inline value_type& real() { return _m_real; }
inline value_type& imag() { return _m_imag; }
public:
_unary_expr_cc<complex<_tp>,_unary_add_cc> operator+() const
{ return _unary_expr_cc<complex<_tp>,_unary_add_cc>(*this); }
_unary_expr_cc<complex<_tp>,_unary_sub_cc> operator-() const
{ return _unary_expr_cc<complex<_tp>,_unary_sub_cc>(*this); }
};
//////////////////////////////////////////////////////////////////////////
//template<class _arg1, class _arg2>
//_binary_expr_cc<_arg1,_arg2,_add_cc>
//operator+(const _arg1& a, const _arg2& b)
//{
// typedef _binary_expr_cc<_arg1,_arg2,_add_cc> _expr;
// return _expr(a,b);
//}
#define _DEFINE_COMPLEX_BINARY_FUNC(_func, _name) \
\
template<class _arg11,class _arg12,class _oper1, \
class _arg21,class _arg22,class _oper2> \
inline \
_binary_expr_cc<_binary_expr_cc<_arg11,_arg12,_oper1>, \
_binary_expr_cc<_arg21,_arg22,_oper2>, \
_name \
> \
_func(const _binary_expr_cc<_arg11,_arg12,_oper1>& a, \
const _binary_expr_cc<_arg21,_arg22,_oper2>& b) \
{ \
typedef _binary_expr_cc<_binary_expr_cc<_arg11,_arg12,_oper1>, \
_binary_expr_cc<_arg21,_arg22,_oper2>, \
_name \
> _expr; \
return _expr(a,b); \
} \
\
template<class _arg1,class _oper1, \
class _arg21,class _arg22,class _oper2> \
inline \
_binary_expr_cc<_unary_expr_cc<_arg1,_oper1>, \
_binary_expr_cc<_arg21,_arg22,_oper2>, \
_name \
> \
_func(const _unary_expr_cc<_arg1,_oper1>& a, \
const _binary_expr_cc<_arg21,_arg22,_oper2>& b) \
{ \
typedef _binary_expr_cc<_unary_expr_cc<_arg1,_oper1>, \
_binary_expr_cc<_arg21,_arg22,_oper2>, \
_name \
> _expr; \
return _expr(a,b); \
} \
\
template<class _arg11,class _arg12,class _oper1, \
class _arg2,class _oper2> \
inline \
_binary_expr_cc<_binary_expr_cc<_arg11,_arg12,_oper1>, \
_unary_expr_cc<_arg2,_oper2>, \
_name \
> \
_func(const _binary_expr_cc<_arg11,_arg12,_oper1>& a, \
const _unary_expr_cc<_arg2,_oper2>& b) \
{ \
typedef _binary_expr_cc<_binary_expr_cc<_arg11,_arg12,_oper1>, \
_unary_expr_cc<_arg2,_oper2>, \
_name \
> _expr; \
return _expr(a,b); \
} \
\
template<class _arg1,class _oper1, \
class _arg2,class _oper2> \
inline \
_binary_expr_cc<_unary_expr_cc<_arg1,_oper1>, \
_unary_expr_cc<_arg2,_oper2>, \
_name \
> \
_func(const _unary_expr_cc<_arg1,_oper1>& a, \
const _unary_expr_cc<_arg2,_oper2>& b) \
{ \
typedef _binary_expr_cc<_unary_expr_cc<_arg1,_oper1>, \
_unary_expr_cc<_arg2,_oper2>, \
_name \
> _expr; \
return _expr(a,b); \
} \
\
template<class _arg11, class _arg12, class _oper, class _tp> \
inline \
_binary_expr_cc<_binary_expr_cc<_arg11,_arg12,_oper>, \
complex<_tp>, \
_name \
> \
_func(const _binary_expr_cc<_arg11,_arg12,_oper>& a, \
const complex<_tp>& b) \
{ \
typedef _binary_expr_cc<_binary_expr_cc<_arg11,_arg12,_oper>, \
complex<_tp>, \
_name \
> _expr; \
return _expr(a,b); \
} \
\
template<class _tp, class _arg21, class _arg22, class _oper> \
inline \
_binary_expr_cc<complex<_tp>, \
_binary_expr_cc<_arg21,_arg22,_oper>, \
_name \
> \
_func(const complex<_tp>& a, \
const _binary_expr_cc<_arg21,_arg22,_oper>& b) \
{ \
typedef _binary_expr_cc<complex<_tp>, \
_binary_expr_cc<_arg21,_arg22,_oper>, \
_name \
> _expr; \
return _expr(a,b); \
} \
\
template<class _arg11, class _arg12, class _oper, class _tp> \
inline \
_binary_expr_cc<_binary_expr_cc<_arg11,_arg12,_oper>, \
constnt<_tp>, \
_name \
> \
_func(const _binary_expr_cc<_arg11,_arg12,_oper>& a, const _tp& b) \
{ \
typedef _binary_expr_cc<_binary_expr_cc<_arg11,_arg12,_oper>, \
constnt<_tp>, \
_name \
> _expr; \
return _expr(a,b); \
} \
\
template<class _tp, class _arg21, class _arg22, class _oper> \
inline \
_binary_expr_cc<constnt<_tp>, \
_binary_expr_cc<_arg21,_arg22,_oper>, \
_name \
> \
_func(const _tp& a, const _binary_expr_cc<_arg21,_arg22,_oper>& b) \
{ \
typedef _binary_expr_cc<constnt<_tp>, \
_binary_expr_cc<_arg21,_arg22,_oper>, \
_name \
> _expr; \
return _expr(a,b); \
} \
\
template<class _arg,class _oper,class _tp> \
inline \
_binary_expr_cc<_unary_expr_cc<_arg,_oper>, \
complex<_tp>, \
_name \
> \
_func(const _unary_expr_cc<_arg,_oper>& a, const complex<_tp>& b) \
{ \
typedef _binary_expr_cc<_unary_expr_cc<_arg,_oper>, \
complex<_tp>, \
_name \
> _expr; \
return _expr(a,b); \
} \
\
template<class _tp, class _arg,class _oper> \
inline \
_binary_expr_cc<complex<_tp>, \
_unary_expr_cc<_arg,_oper>, \
_name \
> \
_func(const complex<_tp>& a, const _unary_expr_cc<_arg,_oper>& b) \
{ \
typedef _binary_expr_cc<complex<_tp>, \
_unary_expr_cc<_arg,_oper>, \
_name \
> _expr; \
return _expr(a,b); \
} \
\
template<class _arg,class _oper,class _tp> \
inline \
_binary_expr_cc<_unary_expr_cc<_arg,_oper>, \
constnt<_tp>, \
_name \
> \
_func(const _unary_expr_cc<_arg,_oper>& a, const constnt<_tp>& b) \
{ /*这个函数不常用，只是用作备用*/ \
typedef _binary_expr_cc<_unary_expr_cc<_arg,_oper>, \
constnt<_tp>, \
_name \
> _expr; \
return _expr(a,b); \
} \
\
template<class _tp, class _arg,class _oper> \
inline \
_binary_expr_cc<constnt<_tp>, \
_unary_expr_cc<_arg,_oper>, \
_name \
> \
_func(const constnt<_tp>& a, const _unary_expr_cc<_arg,_oper>& b) \
{ \
typedef _binary_expr_cc<constnt<_tp>, \
_unary_expr_cc<_arg,_oper>, \
_name \
> _expr; \
return _expr(a,b); \
} \
\
template<class _arg,class _oper,class _tp> \
inline \
_binary_expr_cc<_unary_expr_cc<_arg,_oper>, \
constnt<_tp>, \
_name \
> \
_func(const _unary_expr_cc<_arg,_oper>& a, const _tp& b) \
{ \
typedef _binary_expr_cc<_unary_expr_cc<_arg,_oper>, \
constnt<_tp>, \
_name \
> _expr; \
return _expr(a,b); \
} \
\
template<class _tp, class _arg,class _oper> \
inline \
_binary_expr_cc<constnt<_tp>, \
_unary_expr_cc<_arg,_oper>, \
_name \
> \
_func(const _tp& a, const _unary_expr_cc<_arg,_oper>& b) \
{ \
typedef _binary_expr_cc<constnt<_tp>, \
_unary_expr_cc<_arg,_oper>, \
_name \
> _expr; \
return _expr(a,b); \
} \
\
template<class _tp1, class _tp2> \
inline \
_binary_expr_cc<complex<_tp1>,complex<_tp2>,_name> \
_func(const complex<_tp1>& __a, const complex<_tp2>& __b) \
{ \
typedef _binary_expr_cc<complex<_tp1>, \
complex<_tp2>, \
_name \
> _expr; \
return _expr(__a,__b); \
} \
\
template<class _tp1, class _tp2> \
inline \
_binary_expr_cc<complex<_tp1>, \
constnt<_tp2>, \
_name \
> \
_func(const complex<_tp1>& __a, const _tp2& __b) \
{ \
typedef _binary_expr_cc<complex<_tp1>, \
constnt<_tp2>, \
_name \
> _expr; \
return _expr(__a,__b); \
} \
\
template<class _tp1, class _tp2> \
inline \
_binary_expr_cc<constnt<_tp1>, \
complex<_tp2>, \
_name \
> \
_func(const _tp1& a, const complex<_tp2>& b) \
{ \
typedef _binary_expr_cc<constnt<_tp1>, \
complex<_tp2>, \
_name \
> _expr; \
return _expr(a,b); \
}
_DEFINE_COMPLEX_BINARY_FUNC(operator+, _binary_add_cc)
_DEFINE_COMPLEX_BINARY_FUNC(operator-, _binary_sub_cc)
_DEFINE_COMPLEX_BINARY_FUNC(operator*, _binary_mul_cc)
_DEFINE_COMPLEX_BINARY_FUNC(operator/, _binary_div_cc)
_DEFINE_COMPLEX_BINARY_FUNC( pow, _pow_cc)
//////////////////////////////////////////////////////////////////////////
#define _DEFINE_COMPLEX_UNARY_FUNC(_func, _name) \
\
template<class _arg1, class _arg2, class _oper> \
_unary_expr_cc<_binary_expr_cc<_arg1,_arg2,_oper>, \
_name \
> \
_func(const _binary_expr_cc<_arg1,_arg2,_oper>& __e) \
{ \
typedef _unary_expr_cc<_binary_expr_cc<_arg1,_arg2,_oper>, \
_name \
> _expr; \
return _expr(__e); \
} \
\
template<class _arg, class _oper> \
_unary_expr_cc<_unary_expr_cc<_arg,_oper>, \
_name \
> \
_func(const _unary_expr_cc<_arg,_oper>& __e) \
{ \
typedef _unary_expr_cc<_unary_expr_cc<_arg,_oper>, \
_name \
> _expr; \
return _expr(__e); \
} \
\
template<class _tp> \
_unary_expr_cc<complex<_tp>, \
_name \
> \
_func(const complex<_tp>& __c) \
{ \
typedef _unary_expr_cc<complex<_tp>, \
_name \
> _expr; \
return _expr(__c); \
}
_DEFINE_COMPLEX_UNARY_FUNC( cos, _cos_cc)
_DEFINE_COMPLEX_UNARY_FUNC( cosh, _cosh_cc)
_DEFINE_COMPLEX_UNARY_FUNC( exp, _exp_cc)
_DEFINE_COMPLEX_UNARY_FUNC( log, _log_cc)
_DEFINE_COMPLEX_UNARY_FUNC(log10, _log10_cc)
_DEFINE_COMPLEX_UNARY_FUNC( sin, _sin_cc)
_DEFINE_COMPLEX_UNARY_FUNC( sinh, _sinh_cc)
//////////////////////////////////////////////////////////////////////////
#define _DEFINE_COMPLEX_UNARY_FUNC_EX(_func, _name) \
\
template<class _arg1, class _arg2, class _oper> \
typename _return_type<typename _arg1::value_type, \
typename _arg2::value_type \
>::value_type \
_func(const _binary_expr_cc<_arg1,_arg2,_oper>& __e) \
{ \
return _name::evaluate(__e); \
} \
\
template<class _arg, class _oper> \
typename _arg::value_type \
_func(const _unary_expr_cc<_arg,_oper>& __e) \
{ \
return _name::evaluate(__e); \
} \
\
template<typename _tp> \
typename _tp \
_func(const complex<_tp>& __c) \
{ \
return _name::evaluate(__c); \
}
_DEFINE_COMPLEX_UNARY_FUNC_EX( abs, _abs_cc)
_DEFINE_COMPLEX_UNARY_FUNC_EX( arg, _arg_cc)
_DEFINE_COMPLEX_UNARY_FUNC_EX(norm, _norm_cc)
//////////////////////////////////////////////////////////////////////////
}
#endif // _COMPLEX_H_
// test.cpp
#include <ctime>
#include <iostream>
using namespace std;
//#include <complex>
//using namespace std;
#include "complex.h"
using namespace numeric;
void main()
{
complex<double> c1(1,1), c2(2,2), c3(3,3), c4(4,4), c5(5,5), cc(0,0);
double d = 1.2, rx = 0, iy = 0;
clock_t time = clock();
for (int i=0; i<10000; ++i) {
for (int j=0; j<10000; ++j) {
// 由于被编译器的循环优化会优化=,所以采用@=
cc *= cos(d+(c1+c2)+c3);
}
}
time = clock() - time;
cout << (double)time/CLK_TCK << endl;
cout << '(' << rx
<< ',' << iy
<< ')' << endl;
cout << '(' << cc.real()
<< ',' << cc.imag()
<< ')' << endl;
}
/*************************************************************************
程序分别用intel c++ compiler 8.0, vc7.1和gcc 3.3.3编译。其中icc80和vc71
顺利编译通过，gcc编译出错。
首先用intel的编译器来测试程序：
(1) 简单运算(+,-,*,/,=,+=,-=,*=,/=)
通过测试发现，它在+、-及+=、-=上的效率约是compaq visual fortran 6.5
的complex类型的两倍多。而在稍微复杂的*、/、*=、/=上，它的效率要高出
cvf好多。
(2) 函数计算(cos, sin, exp, log)
这些函数计算与cvf相比仍然约是两倍多(fortran没有log10、sinh和cosh)。
(3) pow函数
在测试的时候发现一个有趣的问题：intel编译器在处理pow函数时对数据非常
敏感。比如申明
complex<double> c1(1,1),c2(2,2),c3(3,3),cc(0,0);
double d = 1.2;
然后计算下面语句10000*10000次
cc += pow(d+c1+c2,c3);
如果将c2(2,2)的虚部改为任何不为2的数，对比两次计算耗时，可以发现两者
差别居然有近70倍。
fortan没有pow函数，但是pow(x,y)可以表达成exp(y*log(x))。
使用vs71编译器来测试程序：
(1) 简单运算(+,-,*,/,=,+=,-=,*=,/=)
编译出的程序运行效率和visual fortran差不多，+=和-=稍微低于fortran，而
*=则约是fortran的1/3，但是/=居然有fortran的两倍。
(2) 函数计算(cos, sin, exp, sinh, cosh)
使用@=(@可以是+、-、*、/)运算符时，计算的效率和stl的complex没什么差别。
(3) 函数(log, log10)
这两个函数与(2)中的函数表现差不多，但是如果将@=(+=或-=)中的一个赋值
表达式注释掉，效率就会高出很多，但这个方法对(2)中的函数不管用。
(4) 函数(pow)
这个函数如果直接使用@=的话，也和stl的complex类差不多。但是(3)中的方法对
它也有效，更有意思的地方是——如果在循环中直接赋值：
cc.real() += pow(d+c1+c2,c3).real();
cc.imag() += pow(d+c1+c2,c3).imag();
这样得到的效率居然是fortran的两倍多。但是这种方法对(3)(2)都不管用。
*************************************************************************/
|
本类阅读TOP10