| 
| void  | abs (std::size_t n, const float *a, float *y) | 
|   | 
| void  | abs (std::size_t n, const double *a, double *y) | 
|   | 
| template<typename T >  | 
| void  | abs (std::size_t n, const T *a, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = |a_i|\).  More...
  | 
|   | 
| void  | acos (std::size_t n, const double *a, double *y) | 
|   | 
| void  | acos (std::size_t n, const float *a, float *y) | 
|   | 
| template<typename T >  | 
| void  | acos (std::size_t n, const T *a, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = \arccos(a_i)\).  More...
  | 
|   | 
| void  | acosh (std::size_t n, const float *a, float *y) | 
|   | 
| void  | acosh (std::size_t n, const double *a, double *y) | 
|   | 
| template<typename T >  | 
| void  | acosh (std::size_t n, const T *a, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = \mathrm{arc}\cosh(a_i)\).  More...
  | 
|   | 
| void  | add (std::size_t n, const float *a, const float *b, float *y) | 
|   | 
| void  | add (std::size_t n, const double *a, const double *b, double *y) | 
|   | 
| template<typename T >  | 
| void  | add (std::size_t n, const T *a, const T *b, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = a_i + b_i\).  More...
  | 
|   | 
| template<typename T >  | 
| void  | add (std::size_t n, const T *a, T b, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = a_i + b\).  More...
  | 
|   | 
| template<typename T >  | 
| void  | add (std::size_t n, T a, const T *b, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = a + b_i\).  More...
  | 
|   | 
| void  | asin (std::size_t n, const float *a, float *y) | 
|   | 
| void  | asin (std::size_t n, const double *a, double *y) | 
|   | 
| template<typename T >  | 
| void  | asin (std::size_t n, const T *a, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = \arcsin(a_i)\).  More...
  | 
|   | 
| void  | asinh (std::size_t n, const float *a, float *y) | 
|   | 
| void  | asinh (std::size_t n, const double *a, double *y) | 
|   | 
| template<typename T >  | 
| void  | asinh (std::size_t n, const T *a, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = \mathrm{arc}\sinh(a_i)\).  More...
  | 
|   | 
| void  | atan (std::size_t n, const float *a, float *y) | 
|   | 
| void  | atan (std::size_t n, const double *a, double *y) | 
|   | 
| template<typename T >  | 
| void  | atan (std::size_t n, const T *a, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = \arctan(a_i)\).  More...
  | 
|   | 
| void  | atan2 (std::size_t n, const float *a, const float *b, float *y) | 
|   | 
| void  | atan2 (std::size_t n, const double *a, const double *b, double *y) | 
|   | 
| template<typename T >  | 
| void  | atan2 (std::size_t n, const T *a, const T *b, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = \arctan(a_i / b_i)\) with signs to determine the quadrant.  More...
  | 
|   | 
| void  | atanh (std::size_t n, const float *a, float *y) | 
|   | 
| void  | atanh (std::size_t n, const double *a, double *y) | 
|   | 
| template<typename T >  | 
| void  | atanh (std::size_t n, const T *a, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = \mathrm{arc}\tanh(a_i)\).  More...
  | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | beta_distribution (RNGType &rng, std::size_t n, RealType *r, RealType alpha, RealType beta) | 
|   | Generating beta random variates.  More...
  | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | beta_distribution (RNGType &rng, std::size_t n, RealType *r, const typename BetaDistribution< RealType >::param_type ¶m) | 
|   | 
| template<MKL_INT BRNG, int Bits>  | 
| void  | beta_distribution (MKLEngine< BRNG, Bits > &, std::size_t, float *, float, float) | 
|   | 
| template<MKL_INT BRNG, int Bits>  | 
| void  | beta_distribution (MKLEngine< BRNG, Bits > &, std::size_t, double *, double, double) | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | cauchy_distribution (RNGType &rng, std::size_t n, RealType *r, RealType a, RealType b) | 
|   | Generating cauchy random variates.  More...
  | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | cauchy_distribution (RNGType &rng, std::size_t n, RealType *r, const typename CauchyDistribution< RealType >::param_type ¶m) | 
|   | 
| template<MKL_INT BRNG, int Bits>  | 
| void  | cauchy_distribution (MKLEngine< BRNG, Bits > &, std::size_t, float *, float, float) | 
|   | 
| template<MKL_INT BRNG, int Bits>  | 
| void  | cauchy_distribution (MKLEngine< BRNG, Bits > &, std::size_t, double *, double, double) | 
|   | 
| void  | cbrt (std::size_t n, const float *a, float *y) | 
|   | 
| void  | cbrt (std::size_t n, const double *a, double *y) | 
|   | 
| template<typename T >  | 
| void  | cbrt (std::size_t n, const T *a, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = \sqrt[3]{a_i}\).  More...
  | 
|   | 
| void  | cdfnorm (std::size_t n, const double *a, double *y) | 
|   | 
| void  | cdfnorm (std::size_t n, const float *a, float *y) | 
|   | 
| template<typename T >  | 
| void  | cdfnorm (std::size_t n, const T *a, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = 1 - \mathrm{Erfc}(a_i / \sqrt{2}) / 2\), the standard Normal CDF.  More...
  | 
|   | 
| void  | cdfnorminv (std::size_t n, const double *a, double *y) | 
|   | 
| void  | cdfnorminv (std::size_t n, const float *a, float *y) | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | chi_squared_distribution (RNGType &rng, std::size_t n, RealType *r, RealType df) | 
|   | Generating \(\chi^2\) random variates.  More...
  | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | chi_squared_distribution (RNGType &rng, std::size_t n, RealType *r, const typename ChiSquaredDistribution< RealType >::param_type ¶m) | 
|   | 
| template<typename T >  | 
| constexpr T  | const_e () noexcept | 
|   | \(e\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_e< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_e< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_e< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_e_inv () noexcept | 
|   | \(1/e\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_e_inv< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_e_inv< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_e_inv< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_ln_10 () noexcept | 
|   | \(\ln(10)\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_ln_10< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_ln_10< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_ln_10< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_ln_2 () noexcept | 
|   | \(\ln(2)\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_ln_2< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_ln_2< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_ln_2< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_ln_3 () noexcept | 
|   | \(\ln(3)\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_ln_3< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_ln_3< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_ln_3< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_ln_5 () noexcept | 
|   | \(\ln(5)\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_ln_5< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_ln_5< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_ln_5< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_ln_inv_10 () noexcept | 
|   | \(1/\ln(10)\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_ln_inv_10< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_ln_inv_10< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_ln_inv_10< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_ln_inv_2 () noexcept | 
|   | \(1/\ln(2)\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_ln_inv_2< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_ln_inv_2< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_ln_inv_2< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_ln_inv_3 () noexcept | 
|   | \(1/\ln(3)\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_ln_inv_3< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_ln_inv_3< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_ln_inv_3< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_ln_inv_5 () noexcept | 
|   | \(1/\ln(5)\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_ln_inv_5< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_ln_inv_5< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_ln_inv_5< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_ln_ln_2 () noexcept | 
|   | \(\ln(\ln(2))\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_ln_ln_2< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_ln_ln_2< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_ln_ln_2< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_ln_pi () noexcept | 
|   | \(\ln(\pi)\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_ln_pi< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_ln_pi< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_ln_pi< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_ln_pi_2 () noexcept | 
|   | \(\ln(2\pi)\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_ln_pi_2< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_ln_pi_2< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_ln_pi_2< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_ln_pi_2by3 () noexcept | 
|   | \(\ln((2/3)\pi)\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_ln_pi_2by3< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_ln_pi_2by3< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_ln_pi_2by3< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_ln_pi_3by4 () noexcept | 
|   | \(\ln((3/4)\pi)\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_ln_pi_3by4< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_ln_pi_3by4< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_ln_pi_3by4< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_ln_pi_4by3 () noexcept | 
|   | \(\ln((4/3)\pi)\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_ln_pi_4by3< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_ln_pi_4by3< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_ln_pi_4by3< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_ln_pi_by2 () noexcept | 
|   | \(\ln(\pi/2)\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_ln_pi_by2< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_ln_pi_by2< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_ln_pi_by2< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_ln_pi_by3 () noexcept | 
|   | \(\ln(\pi/3)\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_ln_pi_by3< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_ln_pi_by3< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_ln_pi_by3< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_ln_pi_by4 () noexcept | 
|   | \(\ln(\pi/4)\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_ln_pi_by4< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_ln_pi_by4< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_ln_pi_by4< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_ln_pi_by6 () noexcept | 
|   | \(\ln(\pi/6)\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_ln_pi_by6< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_ln_pi_by6< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_ln_pi_by6< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_pi () noexcept | 
|   | \(\pi\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_pi< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_pi< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_pi< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_pi_2 () noexcept | 
|   | \(2\pi\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_pi_2< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_pi_2< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_pi_2< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_pi_2by3 () noexcept | 
|   | \((2/3)\pi\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_pi_2by3< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_pi_2by3< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_pi_2by3< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_pi_3by4 () noexcept | 
|   | \((3/4)\pi\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_pi_3by4< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_pi_3by4< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_pi_3by4< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_pi_4by3 () noexcept | 
|   | \((4/3)\pi\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_pi_4by3< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_pi_4by3< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_pi_4by3< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_pi_by2 () noexcept | 
|   | \(\pi/2\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_pi_by2< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_pi_by2< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_pi_by2< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_pi_by3 () noexcept | 
|   | \(\pi/3\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_pi_by3< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_pi_by3< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_pi_by3< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_pi_by4 () noexcept | 
|   | \(\pi/4\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_pi_by4< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_pi_by4< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_pi_by4< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_pi_by6 () noexcept | 
|   | \(\pi/6\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_pi_by6< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_pi_by6< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_pi_by6< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_pi_inv () noexcept | 
|   | \(1/\pi\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_pi_inv< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_pi_inv< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_pi_inv< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_pi_sqr () noexcept | 
|   | \(\pi^2\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_pi_sqr< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_pi_sqr< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_pi_sqr< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_sqrt_10 () noexcept | 
|   | \(\sqrt{10}\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_sqrt_10< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_sqrt_10< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_sqrt_10< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_sqrt_1by10 () noexcept | 
|   | \(\sqrt{1/10}\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_sqrt_1by10< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_sqrt_1by10< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_sqrt_1by10< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_sqrt_1by2 () noexcept | 
|   | \(\sqrt{1/2}\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_sqrt_1by2< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_sqrt_1by2< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_sqrt_1by2< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_sqrt_1by3 () noexcept | 
|   | \(\sqrt{1/3}\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_sqrt_1by3< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_sqrt_1by3< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_sqrt_1by3< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_sqrt_1by5 () noexcept | 
|   | \(\sqrt{1/5}\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_sqrt_1by5< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_sqrt_1by5< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_sqrt_1by5< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_sqrt_2 () noexcept | 
|   | \(\sqrt{2}\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_sqrt_2< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_sqrt_2< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_sqrt_2< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_sqrt_3 () noexcept | 
|   | \(\sqrt{3}\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_sqrt_3< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_sqrt_3< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_sqrt_3< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_sqrt_5 () noexcept | 
|   | \(\sqrt{5}\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_sqrt_5< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_sqrt_5< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_sqrt_5< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_sqrt_e () noexcept | 
|   | \(\sqrt{e}\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_sqrt_e< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_sqrt_e< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_sqrt_e< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_sqrt_e_inv () noexcept | 
|   | \(\sqrt{1/e}\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_sqrt_e_inv< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_sqrt_e_inv< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_sqrt_e_inv< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_sqrt_pi () noexcept | 
|   | \(\sqrt{\pi}\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_sqrt_pi< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_sqrt_pi< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_sqrt_pi< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_sqrt_pi_2 () noexcept | 
|   | \(\sqrt{2\pi}\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_sqrt_pi_2< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_sqrt_pi_2< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_sqrt_pi_2< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_sqrt_pi_2by3 () noexcept | 
|   | \(\sqrt{(2/3)\pi}\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_sqrt_pi_2by3< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_sqrt_pi_2by3< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_sqrt_pi_2by3< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_sqrt_pi_3by4 () noexcept | 
|   | \(\sqrt{(3/4)\pi/}\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_sqrt_pi_3by4< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_sqrt_pi_3by4< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_sqrt_pi_3by4< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_sqrt_pi_4by3 () noexcept | 
|   | \(\sqrt{(4/3)\pi}\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_sqrt_pi_4by3< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_sqrt_pi_4by3< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_sqrt_pi_4by3< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_sqrt_pi_by2 () noexcept | 
|   | \(\sqrt{\pi/2}\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_sqrt_pi_by2< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_sqrt_pi_by2< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_sqrt_pi_by2< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_sqrt_pi_by3 () noexcept | 
|   | \(\sqrt{\pi/3}\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_sqrt_pi_by3< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_sqrt_pi_by3< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_sqrt_pi_by3< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_sqrt_pi_by4 () noexcept | 
|   | \(\sqrt{\pi/4}\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_sqrt_pi_by4< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_sqrt_pi_by4< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_sqrt_pi_by4< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_sqrt_pi_by6 () noexcept | 
|   | \(\sqrt{\pi/6}\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_sqrt_pi_by6< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_sqrt_pi_by6< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_sqrt_pi_by6< long double > () noexcept | 
|   | 
| template<typename T >  | 
| constexpr T  | const_sqrt_pi_inv () noexcept | 
|   | \(\sqrt{1/\pi}\)  More...
  | 
|   | 
| template<>  | 
| constexpr double  | const_sqrt_pi_inv< double > () noexcept | 
|   | 
| template<>  | 
| constexpr float  | const_sqrt_pi_inv< float > () noexcept | 
|   | 
| template<>  | 
| constexpr long double  | const_sqrt_pi_inv< long double > () noexcept | 
|   | 
| void  | cos (std::size_t n, const float *a, float *y) | 
|   | 
| void  | cos (std::size_t n, const double *a, double *y) | 
|   | 
| template<typename T >  | 
| void  | cos (std::size_t n, const T *a, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = \sin(a_i)\).  More...
  | 
|   | 
| void  | cosh (std::size_t n, const float *a, float *y) | 
|   | 
| void  | cosh (std::size_t n, const double *a, double *y) | 
|   | 
| template<typename T >  | 
| void  | cosh (std::size_t n, const T *a, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = \cosh(a_i)\).  More...
  | 
|   | 
| template<typename RealType >  | 
| int  | cov_chol (std::size_t dim, const RealType *cov, RealType *chol, MatrixLayout layout=RowMajor, bool upper=false, bool packed=false) | 
|   | Compute Cholesky decomposition of the covariance matrix.  More...
  | 
|   | 
| void  | div (std::size_t n, const float *a, const float *b, float *y) | 
|   | 
| void  | div (std::size_t n, const double *a, const double *b, double *y) | 
|   | 
| template<typename T >  | 
| void  | div (std::size_t n, const T *a, const T *b, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = a_i / b_i\).  More...
  | 
|   | 
| template<typename T >  | 
| void  | div (std::size_t n, const T *a, T b, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = a_i / b\).  More...
  | 
|   | 
| template<typename T >  | 
| void  | div (std::size_t n, T a, const T *b, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = a / b_i\).  More...
  | 
|   | 
| void  | erf (std::size_t n, const float *a, float *y) | 
|   | 
| void  | erf (std::size_t n, const double *a, double *y) | 
|   | 
| template<typename T >  | 
| void  | erf (std::size_t n, const T *a, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = \mathrm{Erf}(a_i)\).  More...
  | 
|   | 
| void  | erfc (std::size_t n, const float *a, float *y) | 
|   | 
| void  | erfc (std::size_t n, const double *a, double *y) | 
|   | 
| template<typename T >  | 
| void  | erfc (std::size_t n, const T *a, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = \mathrm{Erfc}(a_i) = \mathrm{Erf}(1 - a_i)\).  More...
  | 
|   | 
| void  | erfcinv (std::size_t n, const float *a, float *y) | 
|   | 
| void  | erfcinv (std::size_t n, const double *a, double *y) | 
|   | 
| void  | erfinv (std::size_t n, const float *a, float *y) | 
|   | 
| void  | erfinv (std::size_t n, const double *a, double *y) | 
|   | 
| void  | exp (std::size_t n, const float *a, float *y) | 
|   | 
| void  | exp (std::size_t n, const double *a, double *y) | 
|   | 
| template<typename T >  | 
| void  | exp (std::size_t n, const T *a, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = e^{a_i}\).  More...
  | 
|   | 
| template<typename T >  | 
| void  | exp10 (std::size_t n, const T *a, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = 10^{a_i}\).  More...
  | 
|   | 
| template<typename T >  | 
| void  | exp2 (std::size_t n, const T *a, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = 2^{a_i}\).  More...
  | 
|   | 
| void  | expm1 (std::size_t n, const float *a, float *y) | 
|   | 
| void  | expm1 (std::size_t n, const double *a, double *y) | 
|   | 
| template<typename T >  | 
| void  | expm1 (std::size_t n, const T *a, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = e^{a_i} - 1\).  More...
  | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | exponential_distribution (RNGType &rng, std::size_t n, RealType *r, RealType lambda) | 
|   | Generating exponential random variates.  More...
  | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | exponential_distribution (RNGType &rng, std::size_t n, RealType *r, const typename ExponentialDistribution< RealType >::param_type ¶m) | 
|   | 
| template<MKL_INT BRNG, int Bits>  | 
| void  | exponential_distribution (MKLEngine< BRNG, Bits > &, std::size_t, float *, float) | 
|   | 
| template<MKL_INT BRNG, int Bits>  | 
| void  | exponential_distribution (MKLEngine< BRNG, Bits > &, std::size_t, double *, double) | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | extreme_value_distribution (RNGType &rng, std::size_t n, RealType *r, RealType a, RealType b) | 
|   | Generating extreme_value random variates.  More...
  | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | extreme_value_distribution (RNGType &rng, std::size_t n, RealType *r, const typename ExtremeValueDistribution< RealType >::param_type ¶m) | 
|   | 
| template<MKL_INT BRNG, int Bits>  | 
| void  | extreme_value_distribution (MKLEngine< BRNG, Bits > &, std::size_t, float *, float, float) | 
|   | 
| template<MKL_INT BRNG, int Bits>  | 
| void  | extreme_value_distribution (MKLEngine< BRNG, Bits > &, std::size_t, double *, double, double) | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | fisher_f_distribution (RNGType &rng, std::size_t n, RealType *r, RealType df1, RealType df2) | 
|   | Generating Fisher-F random variates.  More...
  | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | fisher_f_distribution (RNGType &rng, std::size_t n, RealType *r, const typename FisherFDistribution< RealType >::param_type ¶m) | 
|   | 
| template<typename T >  | 
| void  | fma (std::size_t n, const T *a, const T *b, const T *c, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = a_i * b_i + c_i\).  More...
  | 
|   | 
| template<typename T >  | 
| void  | fma (std::size_t n, const T *a, const T *b, T c, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = a_i * b_i + c\).  More...
  | 
|   | 
| template<typename T >  | 
| void  | fma (std::size_t n, const T *a, T b, const T *c, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = a_i * b + c_i\).  More...
  | 
|   | 
| template<typename T >  | 
| void  | fma (std::size_t n, const T *a, T b, T c, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = a_i * b + c\).  More...
  | 
|   | 
| template<typename T >  | 
| void  | fma (std::size_t n, T a, const T *b, const T *c, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = a * b_i + c_i\).  More...
  | 
|   | 
| template<typename T >  | 
| void  | fma (std::size_t n, T a, const T *b, T c, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = a * b_i + c\).  More...
  | 
|   | 
| template<typename T >  | 
| void  | fma (std::size_t n, T a, T b, const T *c, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = a * b + c_i\).  More...
  | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | gamma_distribution (RNGType &rng, std::size_t n, RealType *r, RealType alpha, RealType beta) | 
|   | Generating gamma random variates.  More...
  | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | gamma_distribution (RNGType &rng, std::size_t n, RealType *r, const typename GammaDistribution< RealType >::param_type ¶m) | 
|   | 
| template<MKL_INT BRNG, int Bits>  | 
| void  | gamma_distribution (MKLEngine< BRNG, Bits > &, std::size_t, float *, float, float) | 
|   | 
| template<MKL_INT BRNG, int Bits>  | 
| void  | gamma_distribution (MKLEngine< BRNG, Bits > &, std::size_t, double *, double, double) | 
|   | 
| template<typename >  | 
| inline::hid_t  | hdf5io_datatype () | 
|   | HDF5 data type.  More...
  | 
|   | 
| template<>  | 
| inline::hid_t  | hdf5io_datatype< char > () | 
|   | HDF5 data type specialization for char.  More...
  | 
|   | 
| template<>  | 
| inline::hid_t  | hdf5io_datatype< double > () | 
|   | HDF5 data type specialization for double.  More...
  | 
|   | 
| template<>  | 
| inline::hid_t  | hdf5io_datatype< float > () | 
|   | HDF5 data type specialization for float.  More...
  | 
|   | 
| template<>  | 
| inline::hid_t  | hdf5io_datatype< int > () | 
|   | HDF5 data type specialization for int.  More...
  | 
|   | 
| template<>  | 
| inline::hid_t  | hdf5io_datatype< long > () | 
|   | HDF5 data type specialization for long.  More...
  | 
|   | 
| template<>  | 
| inline::hid_t  | hdf5io_datatype< long double > () | 
|   | HDF5 data type specialization for long double.  More...
  | 
|   | 
| template<>  | 
| inline::hid_t  | hdf5io_datatype< long long > () | 
|   | HDF5 data type specialization for long long.  More...
  | 
|   | 
| template<>  | 
| inline::hid_t  | hdf5io_datatype< short > () | 
|   | HDF5 data type specialization for short.  More...
  | 
|   | 
| template<>  | 
| inline::hid_t  | hdf5io_datatype< signed char > () | 
|   | HDF5 data type specialization for signed char.  More...
  | 
|   | 
| template<>  | 
| inline::hid_t  | hdf5io_datatype< unsigned char > () | 
|   | HDF5 data type specialization for unsigned char.  More...
  | 
|   | 
| template<>  | 
| inline::hid_t  | hdf5io_datatype< unsigned int > () | 
|   | HDF5 data type specialization for unsigned int.  More...
  | 
|   | 
| template<>  | 
| inline::hid_t  | hdf5io_datatype< unsigned long > () | 
|   | HDF5 data type specialization for unsigned long.  More...
  | 
|   | 
| template<>  | 
| inline::hid_t  | hdf5io_datatype< unsigned long long > () | 
|   | HDF5 data type specialization for unsigned long.  More...
  | 
|   | 
| template<>  | 
| inline::hid_t  | hdf5io_datatype< unsigned short > () | 
|   | HDF5 data type specialization for unsigned short.  More...
  | 
|   | 
| template<typename T , typename OutputIter >  | 
| OutputIter  | hdf5load (const std::string &file_name, const std::string &data_name, OutputIter first) | 
|   | Load raw data in the HDF5 format.  More...
  | 
|   | 
| inline::hsize_t  | hdf5size (const std::string &file_name, const std::string &data_name) | 
|   | Get the number of bytes of the data in the HDF5 format.  More...
  | 
|   | 
| template<typename T >  | 
| void  | hdf5store (const Sampler< T > &sampler, const std::string &file_name, const std::string &data_name, bool append=false) | 
|   | Store a Sampler in the HDF5 format.  More...
  | 
|   | 
| template<MatrixLayout Layout, std::size_t Dim, typename T >  | 
| void  | hdf5store (const StateMatrix< Layout, Dim, T > &state, const std::string &file_name, const std::string &data_name, bool append=false) | 
|   | Store a StateMatrix in the HDF5 format.  More...
  | 
|   | 
| template<MatrixLayout Layout, typename T , std::size_t StateSize, typename RealType , typename ID >  | 
| void  | hdf5store (const StateCL< StateSize, RealType, ID > &state, const std::string &file_name, const std::string &data_name, bool append=false) | 
|   | Store a StateCL in the HDF5 format.  More...
  | 
|   | 
| template<typename T >  | 
| void  | hdf5store (const Particle< T > &particle, const std::string &file_name, const std::string &data_name, bool append=false) | 
|   | Store a Particle in the HDF5 format.  More...
  | 
|   | 
| template<MatrixLayout Layout, typename T , typename U >  | 
| void  | hdf5store (const Particle< U > &particle, const std::string &file_name, const std::string &data_name, bool append=false) | 
|   | Store a Particle with StateCL value type in the HDF5 format.  More...
  | 
|   | 
| template<typename T , typename InputIterIter , typename SInputIter >  | 
| void  | hdf5store_list (std::size_t nrow, std::size_t ncol, const std::string &file_name, const std::string &data_name, InputIterIter first, SInputIter sfirst, bool append=false) | 
|   | Store a list in the HDF5 format from an iterator to iterators.  More...
  | 
|   | 
| template<typename SInputIter , typename InputIter , typename... InputIters>  | 
| void  | hdf5store_list (std::size_t nrow, const std::string &file_name, const std::string &data_name, const std::tuple< InputIter, InputIters... > &first, SInputIter sfirst, bool append=false) | 
|   | Store a list in the HDF5 format from tuple of iterators.  More...
  | 
|   | 
| void  | hdf5store_list_empty (const std::string &file_name, const std::string &data_name, bool append=false) | 
|   | Create an empty list.  More...
  | 
|   | 
| template<typename T , typename InputIter >  | 
| void  | hdf5store_list_insert (std::size_t N, const std::string &file_name, const std::string &data_name, InputIter first, const std::string &vname) | 
|   | Insert a variable into an existing list saved in HDF5 format.  More...
  | 
|   | 
| template<MatrixLayout Layout, typename T , typename InputIter >  | 
| InputIter  | hdf5store_matrix (std::size_t nrow, std::size_t ncol, const std::string &file_name, const std::string &data_name, InputIter first, bool append=false) | 
|   | Store a matrix in the HDF5 format from an input iterator.  More...
  | 
|   | 
| void  | hdf5store_new (const std::string &file_name) | 
|   | Create a new HDF5 file for store data.  More...
  | 
|   | 
| void  | hypot (std::size_t n, const float *a, const float *b, float *y) | 
|   | 
| void  | hypot (std::size_t n, const double *a, const double *b, double *y) | 
|   | 
| template<typename T >  | 
| void  | hypot (std::size_t n, const T *a, const T *b, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = \sqrt{a_i^2 + b_i^2}\).  More...
  | 
|   | 
| template<typename T , std::size_t K>  | 
| void  | increment (std::array< T, K > &ctr) | 
|   | Increment a counter by one.  More...
  | 
|   | 
| template<typename T , std::size_t K, T NSkip>  | 
| void  | increment (std::array< T, K > &ctr, std::integral_constant< T, NSkip >) | 
|   | Increment a counter by given steps.  More...
  | 
|   | 
| template<typename T , std::size_t K>  | 
| void  | increment (std::array< T, K > &ctr, T nskip) | 
|   | Increment a counter by given steps.  More...
  | 
|   | 
| template<typename T , std::size_t K, std::size_t Blocks>  | 
| void  | increment (std::array< T, K > &ctr, std::array< std::array< T, K >, Blocks > &ctr_block) | 
|   | Increment a counter by a given steps, and store each step in an array of counters.  More...
  | 
|   | 
| template<typename T , std::size_t K>  | 
| void  | increment (std::array< T, K > &ctr, std::size_t n, std::array< T, K > *ctr_block) | 
|   | Increment a counter by given steps, and store each step in an array of counters.  More...
  | 
|   | 
| void  | inv (std::size_t n, const float *a, float *y) | 
|   | 
| void  | inv (std::size_t n, const double *a, double *y) | 
|   | 
| template<typename T >  | 
| void  | inv (std::size_t n, const T *a, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = a_i^{-1}\).  More...
  | 
|   | 
| void  | invcbrt (std::size_t n, const float *a, float *y) | 
|   | 
| void  | invcbrt (std::size_t n, const double *a, double *y) | 
|   | 
| template<typename T >  | 
| void  | invcbrt (std::size_t n, const T *a, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = 1 / \sqrt[3]{a_i}\).  More...
  | 
|   | 
| void  | invsqrt (std::size_t n, const float *a, float *y) | 
|   | 
| void  | invsqrt (std::size_t n, const double *a, double *y) | 
|   | 
| template<typename T >  | 
| void  | invsqrt (std::size_t n, const T *a, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = 1 / \sqrt{a_i}\).  More...
  | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | laplace_distribution (RNGType &rng, std::size_t n, RealType *r, const typename LaplaceDistribution< RealType >::param_type ¶m) | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | laplace_distribution (RNGType &rng, std::size_t n, RealType *r, RealType a, RealType b) | 
|   | Generating laplace random variates.  More...
  | 
|   | 
| template<MKL_INT BRNG, int Bits>  | 
| void  | laplace_distribution (MKLEngine< BRNG, Bits > &, std::size_t, float *, float, float) | 
|   | 
| template<MKL_INT BRNG, int Bits>  | 
| void  | laplace_distribution (MKLEngine< BRNG, Bits > &, std::size_t, double *, double, double) | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | levy_distribution (RNGType &rng, std::size_t n, RealType *r, const typename LevyDistribution< RealType >::param_type ¶m) | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | levy_distribution (RNGType &rng, std::size_t n, RealType *r, RealType a, RealType b) | 
|   | Generating levy random variates.  More...
  | 
|   | 
| void  | lgamma (std::size_t n, const float *a, float *y) | 
|   | 
| void  | lgamma (std::size_t n, const double *a, double *y) | 
|   | 
| template<typename T >  | 
| void  | lgamma (std::size_t n, const T *a, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = \ln\Gamma(a_i)\), logarithm of the Gamma function.  More...
  | 
|   | 
| void  | linear_frac (std::size_t n, const float *a, const float *b, float beta_a, float beta_b, float mu_a, float mu_b, float *y) | 
|   | 
| void  | linear_frac (std::size_t n, const double *a, const double *b, double beta_a, double beta_b, double mu_a, double mu_b, double *y) | 
|   | 
| template<typename T >  | 
| void  | linear_frac (std::size_t n, const T *a, const T *b, T beta_a, T beta_b, T mu_a, T mu_b, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = (\beta_a a_i + \mu_a) / (\beta_b b_i + \mu_b)\).  More...
  | 
|   | 
| void  | log (std::size_t n, const float *a, float *y) | 
|   | 
| void  | log (std::size_t n, const double *a, double *y) | 
|   | 
| template<typename T >  | 
| void  | log (std::size_t n, const T *a, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = \log(a_i)\).  More...
  | 
|   | 
| void  | log10 (std::size_t n, const float *a, float *y) | 
|   | 
| void  | log10 (std::size_t n, const double *a, double *y) | 
|   | 
| template<typename T >  | 
| void  | log10 (std::size_t n, const T *a, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = \log_{10}(a_i)\).  More...
  | 
|   | 
| void  | log1p (std::size_t n, const float *a, float *y) | 
|   | 
| void  | log1p (std::size_t n, const double *a, double *y) | 
|   | 
| template<typename T >  | 
| void  | log1p (std::size_t n, const T *a, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = \log(a_i + 1)\).  More...
  | 
|   | 
| template<typename T >  | 
| void  | log2 (std::size_t n, const T *a, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = \log_2(a_i)\).  More...
  | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | logistic_distribution (RNGType &rng, std::size_t n, RealType *r, const typename LogisticDistribution< RealType >::param_type ¶m) | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | logistic_distribution (RNGType &rng, std::size_t n, RealType *r, RealType a, RealType b) | 
|   | Generating logistic random variates.  More...
  | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | lognormal_distribution (RNGType &rng, std::size_t n, RealType *r, const typename LognormalDistribution< RealType >::param_type ¶m) | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | lognormal_distribution (RNGType &rng, std::size_t n, RealType *r, RealType logmean, RealType logstddev) | 
|   | Generating lognormal random variates.  More...
  | 
|   | 
| template<MKL_INT BRNG, int Bits>  | 
| void  | lognormal_distribution (MKLEngine< BRNG, Bits > &, std::size_t, float *, float, float) | 
|   | 
| template<MKL_INT BRNG, int Bits>  | 
| void  | lognormal_distribution (MKLEngine< BRNG, Bits > &, std::size_t, double *, double, double) | 
|   | 
| template<typename RNGType >  | 
| int  | mkl_brng () | 
|   | Register a C++11 RNG engine for use as a MKL BRNG.  More...
  | 
|   | 
| template<>  | 
| int  | mkl_brng< ::vsmc::Philox2x32 > () | 
|   | 
| template<>  | 
| int  | mkl_brng< ::vsmc::Philox2x64 > () | 
|   | 
| template<>  | 
| int  | mkl_brng< ::vsmc::Philox4x32 > () | 
|   | 
| template<>  | 
| int  | mkl_brng< ::vsmc::Philox4x64 > () | 
|   | 
| template<>  | 
| int  | mkl_brng< ::vsmc::Threefry2x32 > () | 
|   | 
| template<>  | 
| int  | mkl_brng< ::vsmc::Threefry2x32AVX2 > () | 
|   | 
| template<>  | 
| int  | mkl_brng< ::vsmc::Threefry2x32SSE2 > () | 
|   | 
| template<>  | 
| int  | mkl_brng< ::vsmc::Threefry2x64 > () | 
|   | 
| template<>  | 
| int  | mkl_brng< ::vsmc::Threefry2x64AVX2 > () | 
|   | 
| template<>  | 
| int  | mkl_brng< ::vsmc::Threefry2x64SSE2 > () | 
|   | 
| template<>  | 
| int  | mkl_brng< ::vsmc::Threefry4x32 > () | 
|   | 
| template<>  | 
| int  | mkl_brng< ::vsmc::Threefry4x32AVX2 > () | 
|   | 
| template<>  | 
| int  | mkl_brng< ::vsmc::Threefry4x32SSE2 > () | 
|   | 
| template<>  | 
| int  | mkl_brng< ::vsmc::Threefry4x64 > () | 
|   | 
| template<>  | 
| int  | mkl_brng< ::vsmc::Threefry4x64AVX2 > () | 
|   | 
| template<>  | 
| int  | mkl_brng< ::vsmc::Threefry4x64SSE2 > () | 
|   | 
| template<>  | 
| int  | mkl_brng< std::knuth_b > () | 
|   | 
| template<>  | 
| int  | mkl_brng< std::minstd_rand > () | 
|   | 
| template<>  | 
| int  | mkl_brng< std::minstd_rand0 > () | 
|   | 
| template<>  | 
| int  | mkl_brng< std::mt19937 > () | 
|   | 
| template<>  | 
| int  | mkl_brng< std::mt19937_64 > () | 
|   | 
| template<>  | 
| int  | mkl_brng< std::ranlux24 > () | 
|   | 
| template<>  | 
| int  | mkl_brng< std::ranlux24_base > () | 
|   | 
| template<>  | 
| int  | mkl_brng< std::ranlux48 > () | 
|   | 
| template<>  | 
| int  | mkl_brng< std::ranlux48_base > () | 
|   | 
| void  | mul (std::size_t n, const double *a, const double *b, double *y) | 
|   | 
| void  | mul (std::size_t n, const float *a, const float *b, float *y) | 
|   | 
| template<typename T >  | 
| void  | mul (std::size_t n, const T *a, const T *b, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = a_i b_i\).  More...
  | 
|   | 
| template<typename T >  | 
| void  | mul (std::size_t n, const T *a, T b, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = a_i b\).  More...
  | 
|   | 
| template<typename T >  | 
| void  | mul (std::size_t n, T a, const T *b, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = a b_i\).  More...
  | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | normal_distribution (RNGType &rng, std::size_t n, RealType *r, const typename NormalDistribution< RealType >::param_type ¶m) | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | normal_distribution (RNGType &rng, std::size_t n, RealType *r, RealType mean, RealType stddev) | 
|   | Generating Normal random variates.  More...
  | 
|   | 
| template<MKL_INT BRNG, int Bits>  | 
| void  | normal_distribution (MKLEngine< BRNG, Bits > &, std::size_t, float *r, float, float) | 
|   | 
| template<MKL_INT BRNG, int Bits>  | 
| void  | normal_distribution (MKLEngine< BRNG, Bits > &, std::size_t, double *r, double, double) | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | normal_mv_distribution (RNGType &rng, std::size_t n, RealType *r, const typename NormalMVDistribution< RealType >::param_type ¶m) | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | normal_mv_distribution (RNGType &rng, std::size_t n, RealType *r, std::size_t dim, const RealType *mean, const RealType *chol) | 
|   | Generating multivariate Normal random varaites.  More...
  | 
|   | 
| template<MKL_INT BRNG, int Bits>  | 
| void  | normal_mv_distribution (MKLEngine< BRNG, Bits > &, std::size_t, float *, std::size_t, const float *, const float *) | 
|   | 
| template<MKL_INT BRNG, int Bits>  | 
| void  | normal_mv_distribution (MKLEngine< BRNG, Bits > &, std::size_t, double *, std::size_t, const double *, const double *) | 
|   | 
| template<typename MKLPtr , typename Derived >  | 
| bool  | operator!= (const MKLBase< MKLPtr, Derived > &ptr1, const MKLBase< MKLPtr, Derived > &ptr2) | 
|   | Comparison of inequality of two MKLBase objects.  More...
  | 
|   | 
| template<typename T >  | 
| bool  | operator!= (const SingleParticle< T > &sp1, const SingleParticle< T > &sp2) | 
|   | 
| template<typename T1 , typename T2 , std::size_t Alignment, typename Memory >  | 
| bool  | operator!= (const AlignedAllocator< T1, Alignment, Memory > &, const AlignedAllocator< T2, Alignment, Memory > &) | 
|   | 
| template<typename T >  | 
| bool  | operator!= (const M128I< T > &a, const M128I< T > &b) | 
|   | 
| bool  | operator!= (const M128 &a, const M128 &b) | 
|   | 
| bool  | operator!= (const M128D &a, const M128D &b) | 
|   | 
| template<typename T >  | 
| bool  | operator!= (const M256I< T > &a, const M256I< T > &b) | 
|   | 
| bool  | operator!= (const M256 &a, const M256 &b) | 
|   | 
| bool  | operator!= (const M256D &a, const M256D &b) | 
|   | 
| template<typename T >  | 
| M128I< T >  | operator& (const M128I< T > &a, const M128I< T > &b) | 
|   | 
| template<typename T >  | 
| M128I< T >  | operator& (const M128I< T > &a, T b) | 
|   | 
| template<typename T >  | 
| M128I< T >  | operator& (T a, const M128I< T > &b) | 
|   | 
| template<typename T >  | 
| M256I< T >  | operator& (const M256I< T > &a, const M256I< T > &b) | 
|   | 
| template<typename T >  | 
| M256I< T >  | operator& (T a, const M256I< T > &b) | 
|   | 
| template<typename T >  | 
| M256I< T >  | operator& (const M256I< T > &a, T b) | 
|   | 
| template<typename T >  | 
| M128I< T > &  | operator&= (M128I< T > &a, const M128I< T > &b) | 
|   | 
| template<typename T >  | 
| M128I< T > &  | operator&= (M128I< T > &a, T b) | 
|   | 
| template<typename T >  | 
| M256I< T > &  | operator&= (M256I< T > &a, const M256I< T > &b) | 
|   | 
| template<typename T >  | 
| M256I< T > &  | operator&= (M256I< T > &a, T b) | 
|   | 
| M128  | operator* (const M128 &a, const M128 &b) | 
|   | 
| M128  | operator* (float a, const M128 &b) | 
|   | 
| M128  | operator* (const M128 &a, float b) | 
|   | 
| M128D  | operator* (const M128D &a, const M128D &b) | 
|   | 
| M128D  | operator* (const M128D &a, double b) | 
|   | 
| M128D  | operator* (double a, const M128D &b) | 
|   | 
| M256  | operator* (const M256 &a, const M256 &b) | 
|   | 
| M256  | operator* (float a, const M256 &b) | 
|   | 
| M256  | operator* (const M256 &a, float b) | 
|   | 
| M256D  | operator* (const M256D &a, const M256D &b) | 
|   | 
| M256D  | operator* (double a, const M256D &b) | 
|   | 
| M256D  | operator* (const M256D &a, double b) | 
|   | 
| M128 &  | operator*= (M128 &a, float b) | 
|   | 
| M128 &  | operator*= (M128 &a, const M128 &b) | 
|   | 
| M128D &  | operator*= (M128D &a, const M128D &b) | 
|   | 
| M128D &  | operator*= (M128D &a, double b) | 
|   | 
| M256 &  | operator*= (M256 &a, float b) | 
|   | 
| M256 &  | operator*= (M256 &a, const M256 &b) | 
|   | 
| M256D &  | operator*= (M256D &a, double b) | 
|   | 
| M256D &  | operator*= (M256D &a, const M256D &b) | 
|   | 
| template<typename T , typename IntType >  | 
| SingleParticle< T >  | operator+ (const SingleParticle< T > &sp, IntType n) | 
|   | 
| template<typename T , typename IntType >  | 
| SingleParticle< T >  | operator+ (IntType n, const SingleParticle< T > &sp) | 
|   | 
| template<typename T >  | 
| M128I< T >  | operator+ (const M128I< T > &a, const M128I< T > &b) | 
|   | 
| template<typename T >  | 
| M128I< T >  | operator+ (const M128I< T > &a, T b) | 
|   | 
| template<typename T >  | 
| M128I< T >  | operator+ (T a, const M128I< T > &b) | 
|   | 
| M128  | operator+ (const M128 &a, const M128 &b) | 
|   | 
| M128  | operator+ (const M128 &a, float b) | 
|   | 
| M128  | operator+ (float a, const M128 &b) | 
|   | 
| M128D  | operator+ (const M128D &a, const M128D &b) | 
|   | 
| M128D  | operator+ (const M128D &a, double b) | 
|   | 
| M128D  | operator+ (double a, const M128D &b) | 
|   | 
| template<typename T >  | 
| M256I< T >  | operator+ (const M256I< T > &a, const M256I< T > &b) | 
|   | 
| template<typename T >  | 
| M256I< T >  | operator+ (const M256I< T > &a, T b) | 
|   | 
| template<typename T >  | 
| M256I< T >  | operator+ (T a, const M256I< T > &b) | 
|   | 
| M256  | operator+ (const M256 &a, const M256 &b) | 
|   | 
| M256  | operator+ (const M256 &a, float b) | 
|   | 
| M256  | operator+ (float a, const M256 &b) | 
|   | 
| M256D  | operator+ (const M256D &a, const M256D &b) | 
|   | 
| M256D  | operator+ (double a, const M256D &b) | 
|   | 
| M256D  | operator+ (const M256D &a, double b) | 
|   | 
| template<typename T >  | 
| SingleParticle< T > &  | operator++ (SingleParticle< T > &sp) | 
|   | 
| template<typename T >  | 
| SingleParticle< T >  | operator++ (SingleParticle< T > &sp, int) | 
|   | 
| template<typename T , typename IntType >  | 
| SingleParticle< T > &  | operator+= (SingleParticle< T > &sp, IntType n) | 
|   | 
| template<typename T >  | 
| M128I< T > &  | operator+= (M128I< T > &a, const M128I< T > &b) | 
|   | 
| template<typename T >  | 
| M128I< T > &  | operator+= (M128I< T > &a, T b) | 
|   | 
| M128 &  | operator+= (M128 &a, const M128 &b) | 
|   | 
| M128 &  | operator+= (M128 &a, float b) | 
|   | 
| M128D &  | operator+= (M128D &a, const M128D &b) | 
|   | 
| M128D &  | operator+= (M128D &a, double b) | 
|   | 
| template<typename T >  | 
| M256I< T > &  | operator+= (M256I< T > &a, const M256I< T > &b) | 
|   | 
| template<typename T >  | 
| M256I< T > &  | operator+= (M256I< T > &a, T b) | 
|   | 
| M256 &  | operator+= (M256 &a, float b) | 
|   | 
| M256 &  | operator+= (M256 &a, const M256 &b) | 
|   | 
| M256D &  | operator+= (M256D &a, const M256D &b) | 
|   | 
| M256D &  | operator+= (M256D &a, double b) | 
|   | 
| template<typename T , typename IntType >  | 
| SingleParticle< T >  | operator- (const SingleParticle< T > &sp, IntType n) | 
|   | 
| template<typename T >  | 
| std::ptrdiff_t  | operator- (const SingleParticle< T > &sp1, const SingleParticle< T > &sp2) | 
|   | 
| template<typename T >  | 
| M128I< T >  | operator- (const M128I< T > &a, const M128I< T > &b) | 
|   | 
| template<typename T >  | 
| M128I< T >  | operator- (const M128I< T > &a, T b) | 
|   | 
| template<typename T >  | 
| M128I< T >  | operator- (T a, const M128I< T > &b) | 
|   | 
| M128  | operator- (const M128 &a, const M128 &b) | 
|   | 
| M128  | operator- (const M128 &a, float b) | 
|   | 
| M128  | operator- (float a, const M128 &b) | 
|   | 
| M128D  | operator- (const M128D &a, const M128D &b) | 
|   | 
| M128D  | operator- (double a, const M128D &b) | 
|   | 
| M128D  | operator- (const M128D &a, double b) | 
|   | 
| template<typename T >  | 
| M256I< T >  | operator- (const M256I< T > &a, const M256I< T > &b) | 
|   | 
| template<typename T >  | 
| M256I< T >  | operator- (T a, const M256I< T > &b) | 
|   | 
| template<typename T >  | 
| M256I< T >  | operator- (const M256I< T > &a, T b) | 
|   | 
| M256  | operator- (const M256 &a, const M256 &b) | 
|   | 
| M256  | operator- (float a, const M256 &b) | 
|   | 
| M256  | operator- (const M256 &a, float b) | 
|   | 
| M256D  | operator- (const M256D &a, const M256D &b) | 
|   | 
| M256D  | operator- (double a, const M256D &b) | 
|   | 
| M256D  | operator- (const M256D &a, double b) | 
|   | 
| template<typename T >  | 
| SingleParticle< T > &  | operator-- (SingleParticle< T > &sp) | 
|   | 
| template<typename T >  | 
| SingleParticle< T >  | operator-- (SingleParticle< T > &sp, int) | 
|   | 
| template<typename T , typename IntType >  | 
| SingleParticle< T > &  | operator-= (SingleParticle< T > &sp, IntType n) | 
|   | 
| template<typename T >  | 
| M128I< T > &  | operator-= (M128I< T > &a, const M128I< T > &b) | 
|   | 
| template<typename T >  | 
| M128I< T > &  | operator-= (M128I< T > &a, T b) | 
|   | 
| M128 &  | operator-= (M128 &a, float b) | 
|   | 
| M128 &  | operator-= (M128 &a, const M128 &b) | 
|   | 
| M128D &  | operator-= (M128D &a, const M128D &b) | 
|   | 
| M128D &  | operator-= (M128D &a, double b) | 
|   | 
| template<typename T >  | 
| M256I< T > &  | operator-= (M256I< T > &a, T b) | 
|   | 
| template<typename T >  | 
| M256I< T > &  | operator-= (M256I< T > &a, const M256I< T > &b) | 
|   | 
| M256 &  | operator-= (M256 &a, const M256 &b) | 
|   | 
| M256 &  | operator-= (M256 &a, float b) | 
|   | 
| M256D &  | operator-= (M256D &a, const M256D &b) | 
|   | 
| M256D &  | operator-= (M256D &a, double b) | 
|   | 
| M128  | operator/ (const M128 &a, const M128 &b) | 
|   | 
| M128  | operator/ (float a, const M128 &b) | 
|   | 
| M128  | operator/ (const M128 &a, float b) | 
|   | 
| M128D  | operator/ (const M128D &a, const M128D &b) | 
|   | 
| M128D  | operator/ (double a, const M128D &b) | 
|   | 
| M128D  | operator/ (const M128D &a, double b) | 
|   | 
| M256  | operator/ (const M256 &a, const M256 &b) | 
|   | 
| M256  | operator/ (float a, const M256 &b) | 
|   | 
| M256  | operator/ (const M256 &a, float b) | 
|   | 
| M256D  | operator/ (const M256D &a, const M256D &b) | 
|   | 
| M256D  | operator/ (double a, const M256D &b) | 
|   | 
| M256D  | operator/ (const M256D &a, double b) | 
|   | 
| M128 &  | operator/= (M128 &a, const M128 &b) | 
|   | 
| M128 &  | operator/= (M128 &a, float b) | 
|   | 
| M128D &  | operator/= (M128D &a, double b) | 
|   | 
| M128D &  | operator/= (M128D &a, const M128D &b) | 
|   | 
| M256 &  | operator/= (M256 &a, float b) | 
|   | 
| M256 &  | operator/= (M256 &a, const M256 &b) | 
|   | 
| M256D &  | operator/= (M256D &a, double b) | 
|   | 
| M256D &  | operator/= (M256D &a, const M256D &b) | 
|   | 
| template<typename T >  | 
| bool  | operator< (const SingleParticle< T > &sp1, const SingleParticle< T > &sp2) | 
|   | 
| template<typename CharT , typename Traits , typename T , std::size_t N>  | 
| std::basic_ostream< CharT, Traits > &  | operator<< (std::basic_ostream< CharT, Traits > &os, const std::array< T, N > &ary) | 
|   | 
| template<typename CharT , typename Traits , MatrixLayout Layout, std::size_t Dim, typename T >  | 
| std::basic_ostream< CharT, Traits > &  | operator<< (std::basic_ostream< CharT, Traits > &os, const StateMatrixBase< Layout, Dim, T > &smatrix) | 
|   | 
| template<typename CharT , typename Traits , typename T , std::size_t N>  | 
| std::basic_ostream< CharT, Traits > &  | operator<< (std::basic_ostream< CharT, Traits > &os, const Vector< T > &vec) | 
|   | 
| template<typename CharT , typename Traits , typename T >  | 
| std::basic_ostream< CharT, Traits > &  | operator<< (std::basic_ostream< CharT, Traits > &os, const Sampler< T > &sampler) | 
|   | 
| template<typename CharT , typename Traits , typename T >  | 
| std::basic_ostream< CharT, Traits > &  | operator<< (std::basic_ostream< CharT, Traits > &os, const M128I< T > &a) | 
|   | 
| template<typename T >  | 
| M128I< T >  | operator<< (const M128I< T > &a, int imm8) | 
|   | 
| template<typename CharT , typename Traits >  | 
| std::basic_ostream< CharT, Traits > &  | operator<< (std::basic_ostream< CharT, Traits > &os, const M128 &a) | 
|   | 
| template<typename CharT , typename Traits >  | 
| std::basic_ostream< CharT, Traits > &  | operator<< (std::basic_ostream< CharT, Traits > &os, const M128D &a) | 
|   | 
| template<typename CharT , typename Traits , typename T >  | 
| std::basic_ostream< CharT, Traits > &  | operator<< (std::basic_ostream< CharT, Traits > &os, const M256I< T > &a) | 
|   | 
| template<typename T >  | 
| M256I< T >  | operator<< (const M256I< T > &a, int imm8) | 
|   | 
| template<typename CharT , typename Traits >  | 
| std::basic_ostream< CharT, Traits > &  | operator<< (std::basic_ostream< CharT, Traits > &os, const M256 &a) | 
|   | 
| template<typename CharT , typename Traits >  | 
| std::basic_ostream< CharT, Traits > &  | operator<< (std::basic_ostream< CharT, Traits > &os, const M256D &a) | 
|   | 
| template<typename T >  | 
| M128I< T >  | operator<<= (M128I< T > &a, int imm8) | 
|   | 
| template<typename T >  | 
| M256I< T >  | operator<<= (M256I< T > &a, int imm8) | 
|   | 
| template<typename T >  | 
| bool  | operator<= (const SingleParticle< T > &sp1, const SingleParticle< T > &sp2) | 
|   | 
| template<typename MKLPtr , typename Derived >  | 
| bool  | operator== (const MKLBase< MKLPtr, Derived > &ptr1, const MKLBase< MKLPtr, Derived > &ptr2) | 
|   | Comparison of equality of two MKLBase objects.  More...
  | 
|   | 
| template<typename T >  | 
| bool  | operator== (const SingleParticle< T > &sp1, const SingleParticle< T > &sp2) | 
|   | 
| template<typename T1 , typename T2 , std::size_t Alignment, typename Memory >  | 
| bool  | operator== (const AlignedAllocator< T1, Alignment, Memory > &, const AlignedAllocator< T2, Alignment, Memory > &) | 
|   | 
| template<typename T >  | 
| bool  | operator== (const M128I< T > &a, const M128I< T > &b) | 
|   | 
| bool  | operator== (const M128 &a, const M128 &b) | 
|   | 
| bool  | operator== (const M128D &a, const M128D &b) | 
|   | 
| template<typename T >  | 
| bool  | operator== (const M256I< T > &a, const M256I< T > &b) | 
|   | 
| bool  | operator== (const M256 &a, const M256 &b) | 
|   | 
| bool  | operator== (const M256D &a, const M256D &b) | 
|   | 
| template<typename T >  | 
| bool  | operator> (const SingleParticle< T > &sp1, const SingleParticle< T > &sp2) | 
|   | 
| template<typename T >  | 
| bool  | operator>= (const SingleParticle< T > &sp1, const SingleParticle< T > &sp2) | 
|   | 
| template<typename CharT , typename Traits , typename T , std::size_t N>  | 
| std::basic_istream< CharT, Traits > &  | operator>> (std::basic_istream< CharT, Traits > &is, std::array< T, N > &ary) | 
|   | 
| template<typename CharT , typename Traits , typename T , std::size_t N>  | 
| std::basic_istream< CharT, Traits > &  | operator>> (std::basic_istream< CharT, Traits > &is, Vector< T > &vec) | 
|   | 
| template<typename CharT , typename Traits , typename T >  | 
| std::basic_istream< CharT, Traits > &  | operator>> (std::basic_istream< CharT, Traits > &is, M128I< T > &a) | 
|   | 
| template<typename T >  | 
| M128I< T >  | operator>> (const M128I< T > &a, int imm8) | 
|   | 
| template<typename CharT , typename Traits >  | 
| std::basic_istream< CharT, Traits > &  | operator>> (std::basic_istream< CharT, Traits > &is, M128 &a) | 
|   | 
| template<typename CharT , typename Traits >  | 
| std::basic_istream< CharT, Traits > &  | operator>> (std::basic_istream< CharT, Traits > &is, M128D &a) | 
|   | 
| template<typename CharT , typename Traits , typename T >  | 
| std::basic_istream< CharT, Traits > &  | operator>> (std::basic_istream< CharT, Traits > &is, M256I< T > &a) | 
|   | 
| template<typename T >  | 
| M256I< T >  | operator>> (const M256I< T > &a, int imm8) | 
|   | 
| template<typename CharT , typename Traits >  | 
| std::basic_istream< CharT, Traits > &  | operator>> (std::basic_istream< CharT, Traits > &is, M256 &a) | 
|   | 
| template<typename CharT , typename Traits >  | 
| std::basic_istream< CharT, Traits > &  | operator>> (std::basic_istream< CharT, Traits > &is, M256D &a) | 
|   | 
| template<typename T >  | 
| M128I< T >  | operator>>= (M128I< T > &a, int imm8) | 
|   | 
| template<typename T >  | 
| M256I< T >  | operator>>= (M256I< T > &a, int imm8) | 
|   | 
| template<typename T >  | 
| M128I< T >  | operator^ (const M128I< T > &a, const M128I< T > &b) | 
|   | 
| template<typename T >  | 
| M128I< T >  | operator^ (T a, const M128I< T > &b) | 
|   | 
| template<typename T >  | 
| M128I< T >  | operator^ (const M128I< T > &a, T b) | 
|   | 
| template<typename T >  | 
| M256I< T >  | operator^ (const M256I< T > &a, const M256I< T > &b) | 
|   | 
| template<typename T >  | 
| M256I< T >  | operator^ (T a, const M256I< T > &b) | 
|   | 
| template<typename T >  | 
| M256I< T >  | operator^ (const M256I< T > &a, T b) | 
|   | 
| template<typename T >  | 
| M128I< T > &  | operator^= (M128I< T > &a, T b) | 
|   | 
| template<typename T >  | 
| M128I< T > &  | operator^= (M128I< T > &a, const M128I< T > &b) | 
|   | 
| template<typename T >  | 
| M256I< T > &  | operator^= (M256I< T > &a, const M256I< T > &b) | 
|   | 
| template<typename T >  | 
| M256I< T > &  | operator^= (M256I< T > &a, T b) | 
|   | 
| template<typename T >  | 
| M128I< T >  | operator| (const M128I< T > &a, const M128I< T > &b) | 
|   | 
| template<typename T >  | 
| M128I< T >  | operator| (T a, const M128I< T > &b) | 
|   | 
| template<typename T >  | 
| M128I< T >  | operator| (const M128I< T > &a, T b) | 
|   | 
| template<typename T >  | 
| M256I< T >  | operator| (const M256I< T > &a, const M256I< T > &b) | 
|   | 
| template<typename T >  | 
| M256I< T >  | operator| (T a, const M256I< T > &b) | 
|   | 
| template<typename T >  | 
| M256I< T >  | operator| (const M256I< T > &a, T b) | 
|   | 
| template<typename T >  | 
| M128I< T > &  | operator|= (M128I< T > &a, T b) | 
|   | 
| template<typename T >  | 
| M128I< T > &  | operator|= (M128I< T > &a, const M128I< T > &b) | 
|   | 
| template<typename T >  | 
| M256I< T > &  | operator|= (M256I< T > &a, T b) | 
|   | 
| template<typename T >  | 
| M256I< T > &  | operator|= (M256I< T > &a, const M256I< T > &b) | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | pareto_distribution (RNGType &rng, std::size_t n, RealType *r, const typename ParetoDistribution< RealType >::param_type ¶m) | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | pareto_distribution (RNGType &rng, std::size_t n, RealType *r, RealType a, RealType b) | 
|   | Generating pareto random variates.  More...
  | 
|   | 
| void  | pow (std::size_t n, const float *a, const float *b, float *y) | 
|   | 
| void  | pow (std::size_t n, const double *a, const double *b, double *y) | 
|   | 
| void  | pow (std::size_t n, const float *a, float b, float *y) | 
|   | 
| void  | pow (std::size_t n, const double *a, double b, double *y) | 
|   | 
| template<typename T >  | 
| void  | pow (std::size_t n, const T *a, const T *b, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = a_i^{b_i}\).  More...
  | 
|   | 
| template<typename T >  | 
| void  | pow (std::size_t n, const T *a, T b, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = a_i^b\).  More...
  | 
|   | 
| void  | pow2o3 (std::size_t n, const double *a, double *y) | 
|   | 
| void  | pow2o3 (std::size_t n, const float *a, float *y) | 
|   | 
| template<typename T >  | 
| void  | pow2o3 (std::size_t n, const T *a, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = a_i^{2/3}\).  More...
  | 
|   | 
| void  | pow3o2 (std::size_t n, const double *a, double *y) | 
|   | 
| void  | pow3o2 (std::size_t n, const float *a, float *y) | 
|   | 
| template<typename T >  | 
| void  | pow3o2 (std::size_t n, const T *a, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = a_i^{3/2}\).  More...
  | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | rayleigh_distribution (RNGType &rng, std::size_t n, RealType *r, const typename RayleighDistribution< RealType >::param_type ¶m) | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | rayleigh_distribution (RNGType &rng, std::size_t n, RealType *r, RealType sigma) | 
|   | Generating rayleigh random variates.  More...
  | 
|   | 
| template<MKL_INT BRNG, int Bits>  | 
| void  | rayleigh_distribution (MKLEngine< BRNG, Bits > &, std::size_t, float *, float) | 
|   | 
| template<MKL_INT BRNG, int Bits>  | 
| void  | rayleigh_distribution (MKLEngine< BRNG, Bits > &, std::size_t, double *, double) | 
|   | 
| template<typename UIntType , std::size_t W>  | 
| bool  | rdrand (UIntType *, std::integral_constant< std::size_t, W >) | 
|   | Invoke the RDRAND instruction and return the carry flag.  More...
  | 
|   | 
| template<typename UIntType >  | 
| bool  | rdrand (UIntType *rand, std::integral_constant< std::size_t, sizeof(std::uint16_t)>) | 
|   | Invoke the 16-bits RDRAND instruction and return the carry flag.  More...
  | 
|   | 
| template<typename UIntType >  | 
| bool  | rdrand (UIntType *rand, std::integral_constant< std::size_t, sizeof(std::uint32_t)>) | 
|   | Invoke the 32-bits RDRAND instruction and return the carry flag.  More...
  | 
|   | 
| template<typename UIntType >  | 
| bool  | rdrand (UIntType *rand, std::integral_constant< std::size_t, sizeof(std::uint64_t)>) | 
|   | Invoke the 64-bits RDRAND instruction and return the carry flag.  More...
  | 
|   | 
| template<typename IntType1 , typename IntType2 >  | 
| void  | resample_trans_index_rep (std::size_t M, std::size_t N, const IntType1 *index, IntType2 *replication) | 
|   | Transform parent indices into replication numbers.  More...
  | 
|   | 
| template<typename IntType1 , typename IntType2 >  | 
| void  | resample_trans_rep_index (std::size_t M, std::size_t N, const IntType1 *replication, IntType2 *index) | 
|   | Transform replication numbers into parent indices.  More...
  | 
|   | 
| template<typename IntType >  | 
| std::size_t  | resample_trans_residual (std::size_t M, std::size_t N, const double *weight, double *resid, IntType *integ) | 
|   | Transform normalized weights to normalized residual and integrals, and return the number of remaining elements to be resampled.  More...
  | 
|   | 
| template<typename IntType , typename U01SeqType >  | 
| void  | resample_trans_u01_index (std::size_t M, std::size_t N, const double *weight, U01SeqType &&u01seq, IntType *index) | 
|   | Transform uniform [0, 1] sequence into parent indices.  More...
  | 
|   | 
| template<typename IntType , typename U01SeqType >  | 
| void  | resample_trans_u01_rep (std::size_t M, std::size_t N, const double *weight, U01SeqType &&u01seq, IntType *replication) | 
|   | Transform uniform [0, 1] sequence into replication numbers.  More...
  | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | rng_rand (RNGType &rng, ChiSquaredDistribution< RealType > &dist, std::size_t n, RealType *r) | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | rng_rand (RNGType &rng, ExponentialDistribution< RealType > &dist, std::size_t n, RealType *r) | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | rng_rand (RNGType &rng, ExtremeValueDistribution< RealType > &dist, std::size_t n, RealType *r) | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | rng_rand (RNGType &rng, CauchyDistribution< RealType > &dist, std::size_t n, RealType *r) | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | rng_rand (RNGType &rng, FisherFDistribution< RealType > &dist, std::size_t n, RealType *r) | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | rng_rand (RNGType &rng, U01CCDistribution< RealType > &dist, std::size_t n, RealType *r) | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | rng_rand (RNGType &rng, U01CODistribution< RealType > &dist, std::size_t n, RealType *r) | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | rng_rand (RNGType &rng, U01OCDistribution< RealType > &dist, std::size_t n, RealType *r) | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | rng_rand (RNGType &rng, U01OODistribution< RealType > &dist, std::size_t n, RealType *r) | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | rng_rand (RNGType &rng, GammaDistribution< RealType > &dist, std::size_t n, RealType *r) | 
|   | 
| template<typename Generator >  | 
| void  | rng_rand (CounterEngine< Generator > &rng, std::size_t n, typename CounterEngine< Generator >::result_type *r) | 
|   | 
| template<typename RNGType >  | 
| void  | rng_rand (RNGType &rng, std::size_t n, typename RNGType::result_type *r) | 
|   | Generate random bits.  More...
  | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | rng_rand (RNGType &rng, BetaDistribution< RealType > &dist, std::size_t n, RealType *r) | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | rng_rand (RNGType &, DiscreteDistribution< RealType > &, std::size_t, RealType *) | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | rng_rand (RNGType &, LaplaceDistribution< RealType > &, std::size_t, RealType *) | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | rng_rand (RNGType &, LevyDistribution< RealType > &, std::size_t, RealType *) | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | rng_rand (RNGType &, LogisticDistribution< RealType > &, std::size_t, RealType *) | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | rng_rand (RNGType &, LognormalDistribution< RealType > &, std::size_t, RealType *) | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | rng_rand (RNGType &, NormalDistribution< RealType > &, std::size_t, RealType *) | 
|   | 
| template<typename RealType , std::size_t Dim, typename RNGType >  | 
| void  | rng_rand (RNGType &, NormalMVDistribution< RealType, Dim > &, std::size_t, RealType *) | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | rng_rand (RNGType &, ParetoDistribution< RealType > &, std::size_t, RealType *) | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | rng_rand (RNGType &, RayleighDistribution< RealType > &, std::size_t, RealType *) | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | rng_rand (RNGType &, StudentTDistribution< RealType > &, std::size_t, RealType *) | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | rng_rand (RNGType &, U01Distribution< RealType > &, std::size_t, RealType *) | 
|   | 
| template<typename RealType , typename RNGType , typename Left , typename Right >  | 
| void  | rng_rand (RNGType &, U01LRDistribution< RealType, Left, Right > &, std::size_t, RealType *) | 
|   | 
| template<typename UIntType , typename RNGType >  | 
| void  | rng_rand (RNGType &, UniformBitsDistribution< UIntType > &, std::size_t, UIntType *) | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | rng_rand (RNGType &, UniformRealDistribution< RealType > &, std::size_t, RealType *) | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | rng_rand (RNGType &, WeibullDistribution< RealType > &, std::size_t, RealType *) | 
|   | 
| template<MKL_INT BRNG, int Bits>  | 
| void  | rng_rand (MKLEngine< BRNG, Bits > &, std::size_t, typename MKLEngine< BRNG, Bits >::result_type *) | 
|   | 
| void  | sin (std::size_t n, const float *a, float *y) | 
|   | 
| void  | sin (std::size_t n, const double *a, double *y) | 
|   | 
| template<typename T >  | 
| void  | sin (std::size_t n, const T *a, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = \cos(a_i)\).  More...
  | 
|   | 
| void  | sincos (std::size_t n, const float *a, float *y, float *z) | 
|   | 
| void  | sincos (std::size_t n, const double *a, double *y, double *z) | 
|   | 
| template<typename T >  | 
| void  | sincos (std::size_t n, const T *a, T *y, T *z) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = \sin(a_i), z_i = \cos(a_i)\).  More...
  | 
|   | 
| void  | sinh (std::size_t n, const double *a, double *y) | 
|   | 
| void  | sinh (std::size_t n, const float *a, float *y) | 
|   | 
| template<typename T >  | 
| void  | sinh (std::size_t n, const T *a, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = \sinh(a_i)\).  More...
  | 
|   | 
| void  | sqr (std::size_t n, const float *a, float *y) | 
|   | 
| void  | sqr (std::size_t n, const double *a, double *y) | 
|   | 
| template<typename T >  | 
| void  | sqr (std::size_t n, const T *a, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = a_i^2\).  More...
  | 
|   | 
| void  | sqrt (std::size_t n, const float *a, float *y) | 
|   | 
| void  | sqrt (std::size_t n, const double *a, double *y) | 
|   | 
| template<typename T >  | 
| void  | sqrt (std::size_t n, const T *a, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = \sqrt{a_i}\).  More...
  | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | student_t_distribution (RNGType &rng, std::size_t n, RealType *r, const typename StudentTDistribution< RealType >::param_type ¶m) | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | student_t_distribution (RNGType &rng, std::size_t n, RealType *r, RealType df) | 
|   | Generating student-t random variates.  More...
  | 
|   | 
| void  | sub (std::size_t n, const double *a, const double *b, double *y) | 
|   | 
| void  | sub (std::size_t n, const float *a, const float *b, float *y) | 
|   | 
| template<typename T >  | 
| void  | sub (std::size_t n, const T *a, const T *b, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = a_i - b_i\).  More...
  | 
|   | 
| template<typename T >  | 
| void  | sub (std::size_t n, const T *a, T b, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = a_i - b\).  More...
  | 
|   | 
| template<typename T >  | 
| void  | sub (std::size_t n, T a, const T *b, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = a - b_i\).  More...
  | 
|   | 
| template<typename MKLPtr , typename Derived >  | 
| void  | swap (const MKLBase< MKLPtr, Derived > &ptr1, const MKLBase< MKLPtr, Derived > &ptr2) | 
|   | Swap two MKLBase objects.  More...
  | 
|   | 
| void  | tan (std::size_t n, const double *a, double *y) | 
|   | 
| void  | tan (std::size_t n, const float *a, float *y) | 
|   | 
| template<typename T >  | 
| void  | tan (std::size_t n, const T *a, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = \tan(a_i)\).  More...
  | 
|   | 
| void  | tanh (std::size_t n, const double *a, double *y) | 
|   | 
| void  | tanh (std::size_t n, const float *a, float *y) | 
|   | 
| template<typename T >  | 
| void  | tanh (std::size_t n, const T *a, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = \tanh(a_i)\).  More...
  | 
|   | 
| void  | tgamm (std::size_t n, const float *a, float *y) | 
|   | 
| void  | tgamm (std::size_t n, const double *a, double *y) | 
|   | 
| template<typename T >  | 
| void  | tgamma (std::size_t n, const T *a, T *y) | 
|   | For \(i=1,\ldots,n\), compute \(y_i = \Gamma(a_i)\), the Gamma function.  More...
  | 
|   | 
| template<typename UIntType , typename RealType >  | 
| RealType  | u01_cc (UIntType u) noexcept | 
|   | Convert uniform unsigned integers to floating points on [0, 1].  More...
  | 
|   | 
| template<typename UIntType , typename RealType >  | 
| void  | u01_cc (std::size_t n, const UIntType *u, RealType *r) noexcept | 
|   | Convert uniform unsigned integers to floating points on [0, 1].  More...
  | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | u01_cc_distribution (RNGType &rng, std::size_t n, RealType *r) | 
|   | Generate standard uniform random variates on [0, 1].  More...
  | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | u01_cc_distribution (RNGType &rng, std::size_t n, RealType *r, const typename U01CCDistribution< RealType >::param_type &) | 
|   | 
| template<typename UIntType , typename RealType >  | 
| RealType  | u01_co (UIntType u) noexcept | 
|   | Convert uniform unsigned integers to floating points on [0, 1)  More...
  | 
|   | 
| template<typename UIntType , typename RealType >  | 
| void  | u01_co (std::size_t n, const UIntType *u, RealType *r) noexcept | 
|   | Convert uniform unsigned integers to floating points on [0, 1)  More...
  | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | u01_co_distribution (RNGType &rng, std::size_t n, RealType *r) | 
|   | Generate standard uniform random variates on [0, 1)  More...
  | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | u01_co_distribution (RNGType &rng, std::size_t n, RealType *r, const typename U01CODistribution< RealType >::param_type &) | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | u01_distribution (RNGType &rng, std::size_t n, RealType *r, const typename U01Distribution< RealType >::param_type &) | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | u01_distribution (RNGType &rng, std::size_t n, RealType *r) | 
|   | Generate standard uniform random variates.  More...
  | 
|   | 
| template<MKL_INT BRNG, int Bits>  | 
| void  | u01_distribution (MKLEngine< BRNG, Bits > &, std::size_t, float *) | 
|   | 
| template<MKL_INT BRNG, int Bits>  | 
| void  | u01_distribution (MKLEngine< BRNG, Bits > &, std::size_t, double *) | 
|   | 
| template<typename UIntType , typename RealType , typename Left , typename Right >  | 
| RealType  | u01_lr (UIntType u) noexcept | 
|   | Convert uniform unsigned integers to floating points within [0, 1].  More...
  | 
|   | 
| template<typename UIntType , typename RealType , typename Left , typename Right >  | 
| void  | u01_lr (std::size_t n, const UIntType *u, RealType *r) noexcept | 
|   | Convert uniform unsigned integers to floating points within [0, 1].  More...
  | 
|   | 
| template<typename , typename , typename RealType , typename RNGType >  | 
| void  | u01_lr_distribution (RNGType &, std::size_t, RealType *) | 
|   | 
| template<typename UIntType , typename RealType >  | 
| RealType  | u01_oc (UIntType u) noexcept | 
|   | Convert uniform unsigned integers to floating points on (0, 1].  More...
  | 
|   | 
| template<typename UIntType , typename RealType >  | 
| void  | u01_oc (std::size_t n, const UIntType *u, RealType *r) noexcept | 
|   | Convert uniform unsigned integers to floating points on (0, 1].  More...
  | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | u01_oc_distribution (RNGType &rng, std::size_t n, RealType *r) | 
|   | Generate standard uniform random variates on (0, 1].  More...
  | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | u01_oc_distribution (RNGType &rng, std::size_t n, RealType *r, const typename U01OCDistribution< RealType >::param_type &) | 
|   | 
| template<typename UIntType , typename RealType >  | 
| RealType  | u01_oo (UIntType u) noexcept | 
|   | Convert uniform unsigned integers to floating points on (0, 1)  More...
  | 
|   | 
| template<typename UIntType , typename RealType >  | 
| void  | u01_oo (std::size_t n, const UIntType *u, RealType *r) noexcept | 
|   | Convert uniform unsigned integers to floating points on (0, 1)  More...
  | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | u01_oo_distribution (RNGType &rng, std::size_t n, RealType *r) | 
|   | Generate standard uniform random variates on (0, 1)  More...
  | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | u01_oo_distribution (RNGType &rng, std::size_t n, RealType *r, const typename U01OODistribution< RealType >::param_type &) | 
|   | 
| template<typename RealType >  | 
| void  | u01_sorted (std::size_t N, const RealType *u01, RealType *u01seq) | 
|   | Tranform a sequence of standard uniform random numbers to sorted sequence.  More...
  | 
|   | 
| template<typename RealType >  | 
| void  | u01_stratified (std::size_t N, const RealType *u01, RealType *u01seq) | 
|   | Transform a sequence of standard uniform random numbers to a stratified sequence.  More...
  | 
|   | 
| template<typename RealType >  | 
| void  | u01_systematic (std::size_t N, RealType u01, RealType *u01seq) | 
|   | Transform a single standard uniform random number to a systematic sequence.  More...
  | 
|   | 
| template<typename UIntType , typename RNGType >  | 
| void  | uniform_bits_distribution (RNGType &rng, std::size_t n, UIntType *r, const typename UniformBitsDistribution< UIntType >::param_type &) | 
|   | 
| template<typename UIntType , typename RNGType >  | 
| void  | uniform_bits_distribution (RNGType &, std::size_t, UIntType *) | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | uniform_real_distribution (RNGType &rng, std::size_t n, RealType *r, const typename UniformRealDistribution< RealType >::param_type ¶m) | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | uniform_real_distribution (RNGType &rng, std::size_t n, RealType *r, RealType a, RealType b) | 
|   | Generate uniform real random variates with open/closed variants.  More...
  | 
|   | 
| template<MKL_INT BRNG, int Bits>  | 
| void  | uniform_real_distribution (MKLEngine< BRNG, Bits > &, std::size_t, float *, float, float) | 
|   | 
| template<MKL_INT BRNG, int Bits>  | 
| void  | uniform_real_distribution (MKLEngine< BRNG, Bits > &, std::size_t, double *, double, double) | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | weibull_distribution (RNGType &rng, std::size_t n, RealType *r, const typename WeibullDistribution< RealType >::param_type ¶m) | 
|   | 
| template<typename RealType , typename RNGType >  | 
| void  | weibull_distribution (RNGType &rng, std::size_t n, RealType *r, RealType a, RealType b) | 
|   | Generating weibull random variates.  More...
  | 
|   | 
| template<MKL_INT BRNG, int Bits>  | 
| void  | weibull_distribution (MKLEngine< BRNG, Bits > &, std::size_t, float *, float, float) | 
|   | 
| template<MKL_INT BRNG, int Bits>  | 
| void  | weibull_distribution (MKLEngine< BRNG, Bits > &, std::size_t, double *, double, double) | 
|   | 
| double  | weight_ess (std::size_t N, const double *first) | 
|   | Compute the ess given normalized weights.  More...
  | 
|   | 
| void  | weight_normalize (std::size_t N, double *first) | 
|   | Normalize weights such that the summation is one.  More...
  | 
|   | 
| void  | weight_normalize_log (std::size_t N, double *first) | 
|   | Normalize logarithm weights such that the maximum is zero.  More...
  | 
|   |