_Ctraits< double > Class Template Reference

Public Types
typedef double	_Ty

Static Public Member Functions
static _Ty	_Flt_eps ()
static _Ty	_Flt_max ()
static _Ty	_Cosh (_Ty _Left, _Ty _Right)
static short	_Exp (_Ty *_Pleft, _Ty _Right, short _Exponent)
static _Ty	_Infv (_Ty)
static bool	_Isinf (_Ty _Left)
static bool	_Isnan (_Ty _Left)
static _Ty	_Nanv (_Ty)
static _Ty	_Sinh (_Ty _Left, _Ty _Right)
static _Ty	asinh (_Ty _Left)
static _Ty	atan2 (_Ty _Yval, _Ty _Xval)
static _Ty	cos (_Ty _Left)
static _Ty	exp (_Ty _Left)
static _Ty	ldexp (_Ty _Left, int _Exponent)
static _Ty	log (_Ty _Left)
static _Ty	log1p (_Ty _Left)
static _Ty	pow (_Ty _Left, _Ty _Right)
static _Ty	sin (_Ty _Left)
static _Ty	sqrt (_Ty _Left)
static _Ty	tan (_Ty _Left)

Member Typedef Documentation

typedef double _Ctraits< double >::_Ty

Member Function Documentation

static _Ty _Ctraits< double >::_Cosh ( _Ty  _Left, _Ty  _Right  )

inlinestatic

        {   // return cosh(_Left) * _Right
        return (_CSTD _Cosh(_Left, _Right));
        }

static short _Ctraits< double >::_Exp ( _Ty *  _Pleft, _Ty  _Right, short  _Exponent  )

inlinestatic

        {   // compute exp(*_Pleft) * _Right * 2 ^ _Exponent
        return (_CSTD _Exp(_Pleft, _Right, _Exponent));
        }

static _Ty _Ctraits< double >::_Flt_eps ( )

inlinestatic

        {   // get epsilon
        return (DBL_EPSILON);
        }

static _Ty _Ctraits< double >::_Flt_max ( )

inlinestatic

        {   // get max
        return (DBL_MAX);
        }

static _Ty _Ctraits< double >::_Infv ( _Ty  )

inlinestatic

        {   // return infinity
        return (numeric_limits<double>::infinity());
        }

static bool _Ctraits< double >::_Isinf ( _Ty  _Left )

inlinestatic

        {   // test for infinity
        return (_CSTD _Dtest(&_Left) == _INFCODE);
        }

static bool _Ctraits< double >::_Isnan ( _Ty  _Left )

inlinestatic

        {   // test for NaN
        return (_CSTD _Dtest(&_Left) == _NANCODE);
        }

static _Ty _Ctraits< double >::_Nanv ( _Ty  )

inlinestatic

        {   // return NaN
        return (numeric_limits<double>::quiet_NaN());
        }

static _Ty _Ctraits< double >::_Sinh ( _Ty  _Left, _Ty  _Right  )

inlinestatic

        {   // return sinh(_Left) * _Right
        return (_CSTD _Sinh(_Left, _Right));
        }

static _Ty _Ctraits< double >::asinh ( _Ty  _Left )

inlinestatic

        {   // return asinh(_Left)
        if (_Isnan(_Left) || _Isinf(_Left) || _Left == 0)
            return (0);
        else
            {   // _Left finite nonzero
            bool _Neg = _Left < 0;
            _Ty _Ans;

            if (_Neg)
                _Left = -_Left;
            if (_Left < 2 / _Flt_eps())
                _Ans = log1p(_Left
                    + _Left * _Left / (1 + sqrt(_Left * _Left + 1)));
            else
                _Ans = log(_Left)   // _Left big, compute log(_Left+_Left)
                    + (_Ty)0.69314718055994530941723212145817658L;
            return (_Neg ? -_Ans : _Ans);
            }
        }

static _Ty _Ctraits< double >::atan2 ( _Ty  _Yval, _Ty  _Xval  )

inlinestatic

        {   // return atan(_Yval / _Xval)
        return (_CSTD atan2(_Yval, _Xval));
        }

static _Ty _Ctraits< double >::cos ( _Ty  _Left )

inlinestatic

        {   // return cos(_Left)
        return (_CSTD cos(_Left));
        }

static _Ty _Ctraits< double >::exp ( _Ty  _Left )

inlinestatic

        {   // return exp(_Left)
        return (_CSTD exp(_Left));
        }

static _Ty _Ctraits< double >::ldexp ( _Ty  _Left, int  _Exponent  )

inlinestatic

        {   // return _Left * 2 ^ _Exponent
        return (_CSTD ldexp(_Left, _Exponent));
        }

static _Ty _Ctraits< double >::log ( _Ty  _Left )

inlinestatic

        {   // return log(_Left)
        return (_CSTD log(_Left));
        }

static _Ty _Ctraits< double >::log1p ( _Ty  _Left )

inlinestatic

        {   // return log(1 + _Left)
        if (_Isnan(_Left) || _Left == 0 || (_Isinf(_Left) && 0 < _Left))
            return (_Left);
        else if (_Left < -1)
            return (_Nanv(_Left));
        else if (_Left == -1)
            return (-_Infv(_Left));
        else if (_Left == 0)
            return (_Left);
        else
            {   // compute log(1 + _Left) with fixup for small _Left
            _Ty _Leftp1 = 1 + _Left;
            return (log(_Leftp1) - ((_Leftp1 - 1) - _Left) / _Leftp1);
            }
        }

static _Ty _Ctraits< double >::pow ( _Ty  _Left, _Ty  _Right  )

inlinestatic

        {   // return _Left ^ _Right
        return (_CSTD pow(_Left, _Right));
        }

static _Ty _Ctraits< double >::sin ( _Ty  _Left )

inlinestatic

        {   // return sin(_Left)
        return (_CSTD sin(_Left));
        }

static _Ty _Ctraits< double >::sqrt ( _Ty  _Left )

inlinestatic

        {   // return sqrt(_Left)
        return (_CSTD sqrt(_Left));
        }

static _Ty _Ctraits< double >::tan ( _Ty  _Left )

inlinestatic

        {   // return tan(_Left)
        return (_CSTD tan(_Left));
        }

---

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

• VS2015/inc/complex