complex< _Ty > Class Template Reference

Inheritance diagram for complex< _Ty >:

Public Types
typedef complex< _Ty >	_Myt
typedef _Complex_base< _Ty, _Complex_value< _Ty > >	_Mybase
Public Types inherited from _Complex_base< _Ty, _Complex_value< _Ty > >
typedef _Ctraits< _Ty >	_Myctraits
typedef _Complex_base< _Ty, _Complex_value< _Ty > >	_Myt
typedef _Ty	value_type
Public Types inherited from _Complex_value< _Ty >
enum	{ _Re = 0, _Im = 1 }

Public Member Functions
constexpr	complex (const _Ty &_Realval=_Ty(), const _Ty &_Imagval=_Ty())
_Myt &	operator= (const _Ty &_Right)
template<class _Other >
constexpr	complex (const complex< _Other > &_Right)
template<class _Other >
_Myt &	operator= (const complex< _Other > &_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)
Public Member Functions inherited from _Complex_base< _Ty, _Complex_value< _Ty > >
constexpr	_Complex_base (const _Ty &_Realval, const _Ty &_Imagval)

Additional Inherited Members
Public Attributes inherited from _Complex_value< _Ty >
_Ty	_Val [2]

Member Typedef Documentation

template<class _Ty>

typedef _Complex_base<_Ty, _Complex_value<_Ty> > complex< _Ty >::_Mybase

template<class _Ty>

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

Constructor & Destructor Documentation

template<class _Ty>

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

inline

        : _Mybase(_Realval, _Imagval)
        {   // construct from components of same type
        }

template<class _Ty>

template<class _Other >

constexpr complex< _Ty >::complex ( const complex< _Other > &  _Right )

inline

        : _Mybase((_Ty)_Right.real(), (_Ty)_Right.imag())
        {   // construct from other complex type
        }

Member Function Documentation

template<class _Ty>

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

inline

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

template<class _Ty>

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

inline

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

template<class _Ty>

template<class _Other >

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

inline

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

template<class _Ty>

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

inline

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

template<class _Ty>

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

inline

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

template<class _Ty>

template<class _Other >

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

inline

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

template<class _Ty>

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

inline

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

template<class _Ty>

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

inline

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

template<class _Ty>

template<class _Other >

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

inline

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

template<class _Ty>

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

inline

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

template<class _Ty>

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

inline

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

template<class _Ty>

template<class _Other >

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

inline

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

template<class _Ty>

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

inline

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

template<class _Ty>

template<class _Other >

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

inline

        {   // assign other complex type
        this->_Val[_RE] = (_Ty)_Right.real();
        this->_Val[_IM] = (_Ty)_Right.imag();
        return (*this);
        }

---

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

• VS2015/inc/complex