complex< double > Class Template Reference

Inheritance diagram for complex< double >:

Public Types
typedef double	_Ty
typedef complex< _Ty >	_Myt
Public Types inherited from _Complex_base< double, _Dcomplex_value >
typedef _Ctraits< double >	_Myctraits
typedef _Complex_base< double, _Dcomplex_value >	_Myt
typedef double	value_type

Public Member Functions
constexpr	complex (const complex< float > &)
constexpr	complex (const complex< long double > &)
constexpr	complex (const _Ty &_Realval=0, const _Ty &_Imagval=0)
constexpr	complex (const _Dcomplex_value &_Right)
constexpr	complex (const _Lcomplex_value &_Right)
complex< _Ty > &	operator= (const _Ty &_Right)
_Myt &	operator+= (const _Ty &_Right)
_Myt &	operator-= (const _Ty &_Right)
_Myt &	operator*= (const _Ty &_Right)
_Myt &	operator/= (const _Ty &_Right)
_Myt &	operator+= (const _Myt &_Right)
_Myt &	operator-= (const _Myt &_Right)
_Myt &	operator*= (const _Myt &_Right)
_Myt &	operator/= (const _Myt &_Right)
template<class _Other >
_Myt &	operator= (const complex< _Other > &_Right)
template<class _Other >
_Myt &	operator+= (const complex< _Other > &_Right)
template<class _Other >
_Myt &	operator-= (const complex< _Other > &_Right)
template<class _Other >
_Myt &	operator*= (const complex< _Other > &_Right)
template<class _Other >
_Myt &	operator/= (const complex< _Other > &_Right)
Public Member Functions inherited from _Complex_base< double, _Dcomplex_value >
constexpr	_Complex_base (const double &_Realval, const double &_Imagval)

Member Typedef Documentation

typedef complex<_Ty> complex< double >::_Myt

typedef double complex< double >::_Ty

Constructor & Destructor Documentation

constexpr complex< double >::complex ( const complex< float > &  _Right )

inline

        : _Complex_base<double, _Dcomplex_value>(
            (_Ty)_Right.real(), (_Ty)_Right.imag())
    {   // construct complex<double> from complex<float>
    }

constexpr complex< double >::complex ( const complex< long double > &  _Right )

inlineexplicit

        : _Complex_base<double, _Dcomplex_value>(
            (_Ty)_Right.real(), (_Ty)_Right.imag())
    {   // construct complex<double> from complex<long double>
    }

constexpr complex< double >::complex ( const _Ty &  _Realval = 0, const _Ty &  _Imagval = 0  )

inline

        : _Complex_base<double, _Dcomplex_value>(_Realval, _Imagval)
        {   // construct from double components
        }

constexpr complex< double >::complex ( const _Dcomplex_value &  _Right )

inline

        : _Complex_base<double, _Dcomplex_value>(_Right._Val[_RE],
            _Right._Val[_IM])
        {   // construct from double complex value
        }

constexpr complex< double >::complex ( const _Lcomplex_value &  _Right )

inline

        : _Complex_base<double, _Dcomplex_value>(_Right._Val[_RE],
            _Right._Val[_IM])
        {   // construct from long double complex value
        }

Member Function Documentation

_Myt& complex< double >::operator*= ( const _Ty &  _Right )

inline

        {   // multiply by real
        _Val[_RE] = _Val[_RE] * _Right;
        _Val[_IM] = _Val[_IM] * _Right;
        return (*this);
        }

_Myt& complex< double >::operator*= ( const _Myt &  _Right )

inline

        {   // multiply by other complex
        this->_Mul(_Right);
        return (*this);
        }

template<class _Other >

_Myt& complex< double >::operator*= ( const complex< _Other > &  _Right )

inline

        {   // multiply by other complex
        this->_Mul(_Right);
        return (*this);
        }

_Myt& complex< double >::operator+= ( const _Ty &  _Right )

inline

        {   // add real
        _Val[_RE] = _Val[_RE] + _Right;
        return (*this);
        }

_Myt& complex< double >::operator+= ( const _Myt &  _Right )

inline

        {   // add other complex
        this->_Add(_Right);
        return (*this);
        }

template<class _Other >

_Myt& complex< double >::operator+= ( const complex< _Other > &  _Right )

inline

        {   // add other complex
        this->_Add(_Right);
        return (*this);
        }

_Myt& complex< double >::operator-= ( const _Ty &  _Right )

inline

        {   // subtract real
        _Val[_RE] = _Val[_RE] - _Right;
        return (*this);
        }

_Myt& complex< double >::operator-= ( const _Myt &  _Right )

inline

        {   // subtract other complex
        this->_Sub(_Right);
        return (*this);
        }

template<class _Other >

_Myt& complex< double >::operator-= ( const complex< _Other > &  _Right )

inline

        {   // subtract other complex
        this->_Sub(_Right);
        return (*this);
        }

_Myt& complex< double >::operator/= ( const _Ty &  _Right )

inline

        {   // divide by real
        _Val[_RE] = _Val[_RE] / _Right;
        _Val[_IM] = _Val[_IM] / _Right;
        return (*this);
        }

_Myt& complex< double >::operator/= ( const _Myt &  _Right )

inline

        {   // divide by other complex
        this->_Div(_Right);
        return (*this);
        }

template<class _Other >

_Myt& complex< double >::operator/= ( const complex< _Other > &  _Right )

inline

        {   // divide by other complex
        this->_Div(_Right);
        return (*this);
        }

complex<_Ty>& complex< double >::operator= ( const _Ty &  _Right )

inline

        {   // assign real
        _Val[_RE] = _Right;
        _Val[_IM] = 0;
        return (*this);
        }

template<class _Other >

_Myt& complex< double >::operator= ( const complex< _Other > &  _Right )

inline

        {   // assign another complex
        _Val[_RE] = (_Ty)_Right._Val[_RE];
        _Val[_IM] = (_Ty)_Right._Val[_IM];
        return (*this);
        }

---

The documentation for this class was generated from the following file:

• VS2015/inc/complex