piecewise_linear_distribution< _Ty > Class Template Reference

Inheritance diagram for piecewise_linear_distribution< _Ty >:

Classes
struct	param_type

Public Types
typedef piecewise_linear_distribution< _Ty >	_Myt
typedef discrete_distribution< size_t >	_Mybase
typedef _Mybase::param_type	_Mypbase
typedef _Mypbase::_Noinit	_Noinit
typedef _Ty	result_type
Public Types inherited from discrete_distribution< size_t >
typedef discrete_distribution< size_t >	_Myt
typedef vector< double >	_Myvec
typedef size_t	result_type

Public Member Functions
	piecewise_linear_distribution ()
template<class _InIt1 , class _Init2 >
	piecewise_linear_distribution (_InIt1 _First1, _InIt1 _Last1, _Init2 _First2)
template<class _Fn >
	piecewise_linear_distribution (_XSTD initializer_list< _Ty > _Ilist, _Fn _Func)
template<class _Fn >
	piecewise_linear_distribution (size_t _Count, _Ty _Low, _Ty _High, _Fn _Func)
	piecewise_linear_distribution (const param_type &_Par0)
vector< _Ty >	intervals () const
vector< _Ty >	densities () const
param_type	param () const
void	param (const param_type &_Par0)
result_type()	min () const
result_type()	max () const
void	reset ()
template<class _Engine >
result_type	operator() (_Engine &_Eng) const
template<class _Engine >
result_type	operator() (_Engine &_Eng, const param_type &_Par0) const
template<class _Elem , class _Traits >
basic_istream< _Elem, _Traits > &	_Read (basic_istream< _Elem, _Traits > &_Istr, param_type &_Par0)
template<class _Elem , class _Traits >
basic_ostream< _Elem, _Traits > &	_Write (basic_ostream< _Elem, _Traits > &_Ostr) const
template<class _Engine >
result_type	_Eval (_Engine &_Eng, const param_type &_Par0) const
Public Member Functions inherited from discrete_distribution< size_t >
	discrete_distribution ()
	discrete_distribution (_XSTD initializer_list< double > _Ilist)
	discrete_distribution (size_t _Count, double _Low, double _High, _Fn _Func)
	discrete_distribution (const param_type &_Par0)
_Myvec	probabilities () const
param_type	param () const
void	param (const param_type &_Par0)
result_type()	min () const
result_type()	max () const
void	reset ()
result_type	operator() (_Engine &_Eng) const
result_type	operator() (_Engine &_Eng, const param_type &_Par0) const
basic_istream< _Elem, _Traits > &	_Read (basic_istream< _Elem, _Traits > &_Istr, param_type &_Par0)
basic_ostream< _Elem, _Traits > &	_Write (basic_ostream< _Elem, _Traits > &_Ostr, const param_type &_Par0) const

Public Attributes
param_type	_Par
Public Attributes inherited from discrete_distribution< size_t >
param_type	_Par

Member Typedef Documentation

template<class _Ty = double>

typedef discrete_distribution<size_t> piecewise_linear_distribution< _Ty >::_Mybase

template<class _Ty = double>

typedef _Mybase::param_type piecewise_linear_distribution< _Ty >::_Mypbase

template<class _Ty = double>

typedef piecewise_linear_distribution<_Ty> piecewise_linear_distribution< _Ty >::_Myt

template<class _Ty = double>

typedef _Mypbase::_Noinit piecewise_linear_distribution< _Ty >::_Noinit

template<class _Ty = double>

typedef _Ty piecewise_linear_distribution< _Ty >::result_type

Constructor & Destructor Documentation

template<class _Ty = double>

piecewise_linear_distribution< _Ty >::piecewise_linear_distribution ( )

inline

        {   // default constructor
        }

template<class _Ty = double>

template<class _InIt1 , class _Init2 >

piecewise_linear_distribution< _Ty >::piecewise_linear_distribution ( _InIt1  _First1, _InIt1  _Last1, _Init2  _First2  )

inline

            : _Par(_First1, _Last1, _First2)
        {   // construct from [_First1, _Last1) and [_First2, ...)
        }

template<class _Ty = double>

template<class _Fn >

piecewise_linear_distribution< _Ty >::piecewise_linear_distribution ( _XSTD initializer_list< _Ty >  _Ilist, _Fn  _Func  )

inline

            : _Par(_Ilist, _Func)
        {   // construct from _Ilist and function
        }

template<class _Ty = double>

template<class _Fn >

piecewise_linear_distribution< _Ty >::piecewise_linear_distribution ( size_t  _Count, _Ty  _Low, _Ty  _High, _Fn  _Func  )

inline

            : _Par(_Count, _Low, _High, _Func)
        {   // construct from value range and function
        }

template<class _Ty = double>

piecewise_linear_distribution< _Ty >::piecewise_linear_distribution ( const param_type &  _Par0 )

inlineexplicit

        : _Par(_Par0)
        {   // construct from parameter package
        }

Member Function Documentation

template<class _Ty = double>

template<class _Engine >

result_type piecewise_linear_distribution< _Ty >::_Eval ( _Engine &  _Eng, const param_type &  _Par0  ) const

inline

        {   // return next value
        size_t _Px = (*(_Mybase *)this)(_Eng, _Par0);
        double _P0 = _Par0._Pvec[_Px];
        double _P1 = _Par0._Pvec[_Px + 1];
        double _Sum = _P0 + _P1;

        if (_Sum <= 0.0)
            return (_Par0._Bvec[_Px + 1]);
        else
            {   // distribute result between (Bx, Px) and (Bx+1, Px+1)
            uniform_real<_Ty> _Dist;
            result_type _X0 = _Dist(_Eng);

            _X0 = ((_P1 - _P0) * _X0 + (_P0 + _P0)) * _X0 / _Sum;
            return (_Par0._Bvec[_Px]
                + _X0 * (_Par0._Bvec[_Px + 1] - _Par0._Bvec[_Px]));
            }
        }

template<class _Ty = double>

template<class _Elem , class _Traits >

basic_istream<_Elem, _Traits>& piecewise_linear_distribution< _Ty >::_Read ( basic_istream< _Elem, _Traits > &  _Istr, param_type &  _Par0  )

inline

        {   // read state from _Istr
        size_t _Nvals;
        _Istr >> _Nvals;
        _Par0._Pvec.clear();
        for (; 0 < _Nvals; --_Nvals)
            {   // get a value and add to vector
            double _Val;
            _In(_Istr, _Val);
            _Par0._Pvec.push_back(_Val);
            }
        _Par0._Init(false); // don't renormalize, just compute CDF

        _Par._Bvec.clear();
        for (size_t _Idx = _Par._Pvec.size(); 0 < _Idx; --_Idx)
            {   // get a value and add to intervals vector
            double _Val;
            _In(_Istr, _Val);
            _Par._Bvec.push_back(_Val);
            }
        return (_Istr);
        }

template<class _Ty = double>

template<class _Elem , class _Traits >

basic_ostream<_Elem, _Traits>& piecewise_linear_distribution< _Ty >::_Write ( basic_ostream< _Elem, _Traits > &  _Ostr ) const

inline

        {   // write state to _Ostr
        _Mybase::_Write(_Ostr, _Par);

        for (size_t _Idx = 0; _Idx < _Par._Bvec.size(); ++_Idx)
            _Out(_Ostr, _Par._Bvec[_Idx]);
        return (_Ostr);
        }

template<class _Ty = double>

vector<_Ty> piecewise_linear_distribution< _Ty >::densities ( ) const

inline

        { // return densities vector
        return (_Par.densities());
        }

template<class _Ty = double>

vector<_Ty> piecewise_linear_distribution< _Ty >::intervals ( ) const

inline

        { // return intervals vector
        return (_Par.intervals());
        }

template<class _Ty = double>

result_type() piecewise_linear_distribution< _Ty >::max ( ) const

inline

        {   // return maximum possible generated value
        return (_Par._Bvec.back());
        }

template<class _Ty = double>

result_type() piecewise_linear_distribution< _Ty >::min ( ) const

inline

        {   // return minimum possible generated value
        return (_Par._Bvec.front());
        }

template<class _Ty = double>

template<class _Engine >

result_type piecewise_linear_distribution< _Ty >::operator() ( _Engine &  _Eng ) const

inline

        {   // return next value
        return (_Eval(_Eng, _Par));
        }

template<class _Ty = double>

template<class _Engine >

result_type piecewise_linear_distribution< _Ty >::operator() ( _Engine &  _Eng, const param_type &  _Par0  ) const

inline

        {   // return next value, given parameter package
        return (_Eval(_Eng, _Par0));
        }

template<class _Ty = double>

param_type piecewise_linear_distribution< _Ty >::param ( ) const

inline

        {   // return parameter package
        return (_Par);
        }

template<class _Ty = double>

void piecewise_linear_distribution< _Ty >::param ( const param_type &  _Par0 )

inline

        {   // set parameter package
        _Par = _Par0;
        }

template<class _Ty = double>

void piecewise_linear_distribution< _Ty >::reset ( )

inline

        {   // clear internal state
        }

Member Data Documentation

template<class _Ty = double>

param_type piecewise_linear_distribution< _Ty >::_Par

---

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

• VS2013/inc/random