complex< float > Class Template Reference

Inheritance diagram for complex< float >:

Public Types
typedef float	_Ty
typedef complex< _Ty >	_Myt
Public Types inherited from _Complex_base< float, _Fcomplex_value >
typedef _Ctraits< float >	_Myctraits
typedef _Complex_base< float, _Fcomplex_value >	_Myt
typedef float	value_type

Public Member Functions
constexpr	complex (const complex< double > &)
constexpr	complex (const complex< long double > &)
constexpr	complex (const _Ty &_Realval=0, const _Ty &_Imagval=0)
constexpr	complex (const _Fcomplex_value &_Right)
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< float, _Fcomplex_value >
constexpr	_Complex_base (const float &_Realval, const float &_Imagval)

Member Typedef Documentation

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

typedef float complex< float >::_Ty

Constructor & Destructor Documentation

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

inlineexplicit

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

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

inlineexplicit

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

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

inline

        : _Complex_base<float, _Fcomplex_value>(_Realval, _Imagval)
        {   // construct from float components
        }

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

inline

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

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

inline

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

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

inline

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

Member Function Documentation

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

inline

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

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

inline

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

template<class _Other >

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

inline

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

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

inline

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

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

inline

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

template<class _Other >

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

inline

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

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

inline

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

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

inline

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

template<class _Other >

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

inline

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

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

inline

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

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

inline

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

template<class _Other >

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

inline

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

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

inline

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

template<class _Other >

_Myt& complex< float >::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