xcomplex File Reference

Macros
#define	_GENERIC_MATHC0X(FUN, VAL)
#define	_GENERIC_MATHC1X(FUN, VAL)

Functions
	_TMPLT (_Ty) inline _CMPLX(_Ty) operator+(const _CMPLX(_Ty)&_Left
const	_CMPLX (_Ty)&_Right)
_Tmp	real (_Tmp.real()+_Right)
	return (_Tmp)
_Tmp	real (_Tmp.real()-_Right)
_Tmp	real (_Tmp.real()*_Right)
_Tmp	imag (_Tmp.imag()*_Right)
_Tmp	real (_Tmp.real()/_Right)
_Tmp	imag (_Tmp.imag()/_Right)
	if (_Right< 0) _Count=0-_Count
	for (_CMPLX(_Ty) _Zv=_CMPLX(_Ty)(1);;_Tmp *=_Tmp)
else	return (exp(_Right *log(_CMPLX(_Ty)(_Left))))
else	return (exp(_Right *log(_Left)))
template<class _Ty1 , class _Ty2 >
complex< typename _Common_float_type< _Ty1, _Ty2 >::type >	polar (const _Ty1 &_Left, const _Ty2 &_Right)
template<class _Ty1 , class _Ty2 >
complex< typename _Common_float_type< _Ty1, _Ty2 >::type >	pow (const complex< _Ty1 > &_Left, const complex< _Ty2 > &_Right)
template<class _Ty1 , class _Ty2 >
complex< typename _Common_float_type< _Ty1, _Ty2 >::type >	pow (const complex< _Ty1 > &_Left, const _Ty2 &_Right)
template<class _Ty1 , class _Ty2 >
complex< typename _Common_float_type< _Ty1, _Ty2 >::type >	pow (const _Ty1 &_Left, const complex< _Ty2 > &_Right)
template<class _Ty1 , class _Ty2 >
enable_if< is_integral< _Ty1 >::value &&is_integral< _Ty2 >::value, complex< _Ty1 > >::type	pow (const complex< _Ty1 > &_Left, _Ty2 &_Right)

Variables
const _Ty &	_Right
unsigned int	_Count = _Right
const _Ty &	_Theta

Macro Definition Documentation

#define _GENERIC_MATHC0X	(		FUN,
			VAL
	)

Value:

template<class _Ty> inline \
    typename enable_if<is_arithmetic<_Ty>::value, \
        typename _Promote_to_float<_Ty>::type>::type \
    FUN(_Ty) \
    { \
    typedef typename _Promote_to_float<_Ty>::type type; \
	return ((type)VAL); \
    }

#define _GENERIC_MATHC1X	(		FUN,
			VAL
	)

Value:

template<class _Ty> inline \
    typename enable_if<is_arithmetic<_Ty>::value, \
        typename _Promote_to_float<_Ty>::type>::type \
    FUN(_Ty _Left) \
    { \
    typedef typename _Promote_to_float<_Ty>::type type; \
	return ((type)VAL); \
    }

Function Documentation

const _CMPLX

(

_Ty

)

    {   // add complex to complex
    _CMPLX(_Ty) _Tmp(_Left);
    return (_Tmp += _Right);
    }

_TMPLT

(

_Ty

)

const

    {   // return +complex
    return (_CMPLX(_Ty)(_Left));
    }

for

(

_CMPLX(_Ty)

_Zv = _CMPLX(_Ty)(1); ; _Tmp *= _Tmp

)

        {   // fold in _Left ^ (2 ^ _Count) as needed
        if ((_Count & 1) != 0)
            _Zv *= _Tmp;
        if ((_Count >>= 1) == 0)
            return (_Right < 0 ? _CMPLX(_Ty)(1) / _Zv : _Zv);
        }

if ( )

pure virtual

        {
            memset(_Destination, 0, _DestinationSize);

            _CRT_MEMCPY_S_VALIDATE_RETURN_ERRCODE(_Source != NULL,                 EINVAL);
            _CRT_MEMCPY_S_VALIDATE_RETURN_ERRCODE(_DestinationSize >= _SourceSize, ERANGE);

            // Unreachable, but required to suppress /analyze warnings:
            return EINVAL;
        }

_Tmp imag

(

_Tmp.imag()*

_Right

)

_Tmp imag

(

_Tmp.imag()/

_Right

)

template<class _Ty1 , class _Ty2 >

complex<typename _Common_float_type<_Ty1, _Ty2>::type> polar ( const _Ty1 &  _Left, const _Ty2 &  _Right  )

inline

    {   // bring mixed types to a common type
    typedef complex<typename _Common_float_type<_Ty1, _Ty2>::type> type;
    return (_STD polar((type)_Left, (type)_Right));
    }

template<class _Ty1 , class _Ty2 >

complex<typename _Common_float_type<_Ty1, _Ty2>::type> pow ( const complex< _Ty1 > &  _Left, const complex< _Ty2 > &  _Right  )

inline

    {   // bring mixed types to a common type
    typedef complex<typename _Common_float_type<_Ty1, _Ty2>::type> type;
    return (_STD pow(type(_Left), type(_Right)));
    }

template<class _Ty1 , class _Ty2 >

complex<typename _Common_float_type<_Ty1, _Ty2>::type> pow ( const complex< _Ty1 > &  _Left, const _Ty2 &  _Right  )

inline

    {   // bring mixed types to a common type
    typedef complex<typename _Common_float_type<_Ty1, _Ty2>::type> type;
    return (_STD pow(type(_Left), type(_Right)));
    }

template<class _Ty1 , class _Ty2 >

complex<typename _Common_float_type<_Ty1, _Ty2>::type> pow ( const _Ty1 &  _Left, const complex< _Ty2 > &  _Right  )

inline

    {   // bring mixed types to a common type
    typedef complex<typename _Common_float_type<_Ty1, _Ty2>::type> type;
    return (_STD pow(type(_Left), type(_Right)));
    }

template<class _Ty1 , class _Ty2 >

enable_if<is_integral<_Ty1>::value && is_integral<_Ty2>::value, complex<_Ty1> >::type pow ( const complex< _Ty1 > &  _Left, _Ty2 &  _Right  )

inline

    {   // raise Gaussian integer to an integer power
    typedef complex<_Ty1> type;
    type _Ans = type(1, 0);

    if (_Right < 0)
        _Ans = type(0, 0);  // ignore 1/type(0, 0) error
    else if (0 < _Right)
        {   // raise to a positive power
        for (type _Factor = _Left; ; _Factor *= _Factor)
            {   // fold in _Left^(2^N))
            if ((_Right & 1) != 0)
                _Ans *= _Factor;
            if ((_Right >>= 1) == 0)
                break;
            }
        }
    return (_Ans);
    }

_Tmp real

(

_Tmp.real()+

_Right

)

_Tmp real

(

_Tmp.real()-

_Right

)

_Tmp real

(

_Tmp.real()*

_Right

)

_Tmp real

(

_Tmp.real()/

_Right

)

return

(

_Tmp

)

else return

(

exp(_Right *log(_CMPLX(_Ty)(_Left)))

)

else return

(

exp(_Right *log(_Left))

)

Variable Documentation

unsigned int _Count = _Right

const _Ty& _Right

Initial value:

{   
    _CMPLX(_Ty) _Tmp(_Left)

const _Ty& _Theta

Initial value:

{   
    return (_CMPLX(_Ty)(_Rho * _CTR(_Ty)::cos(_Theta),
        _Rho * _CTR(_Ty)::sin(_Theta)))