|
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...
|
|
template<typename T > |
T | asum (std::size_t n, const T *x, std::size_t incx) |
| Computes the sum of magnitudes of the vector elements. More...
|
|
float | asum (std::size_t n, const float *x, std::size_t incx) |
|
double | asum (std::size_t n, const double *x, std::size_t incx) |
|
void | atan (std::size_t n, const double *a, double *y) |
|
void | atan (std::size_t n, const float *a, float *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 T > |
void | axpy (std::size_t n, T a, const T *x, std::size_t incx, T *y, std::size_t incy) |
| Computes a vector-scalar product and adds the result to a vector. More...
|
|
void | axpy (std::size_t n, float a, const float *x, std::size_t incx, float *y, std::size_t incy) |
|
void | axpy (std::size_t n, double a, const double *x, std::size_t incx, double *y, std::size_t incy) |
|
template<typename IntType , typename RNGType > |
void | bernoulli_distribution (RNGType &rng, std::size_t n, IntType *r, IntType p) |
| Generating bernoulli random variates. More...
|
|
template<MKL_INT BRNG, int Bits> |
void | bernoulli_distribution (MKLEngine< BRNG, Bits > &rng, std::size_t n, int *r, double p) |
|
template<typename IntType , typename RNGType > |
void | bernoulli_distribution (RNGType &, std::size_t, IntType *, double) |
|
template<MKL_INT BRNG, int Bits> |
void | bernoulli_distribution (MKLEngine< BRNG, Bits > &, std::size_t, MKL_INT *, double) |
|
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<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<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 float *a, float *y) |
|
void | cdfnorm (std::size_t n, const double *a, double *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 float *a, float *y) |
|
void | cdfnorminv (std::size_t n, const double *a, double *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 T > |
T | const_e () noexcept |
| \(e\) More...
|
|
template<> |
double | const_e< double > () noexcept |
|
template<> |
float | const_e< float > () noexcept |
|
template<> |
long double | const_e< long double > () noexcept |
|
template<typename T > |
T | const_e_inv () noexcept |
| \(1/e\) More...
|
|
template<> |
double | const_e_inv< double > () noexcept |
|
template<> |
float | const_e_inv< float > () noexcept |
|
template<> |
long double | const_e_inv< long double > () noexcept |
|
template<typename T > |
T | const_ln_10 () noexcept |
| \(\ln(10)\) More...
|
|
template<> |
double | const_ln_10< double > () noexcept |
|
template<> |
float | const_ln_10< float > () noexcept |
|
template<> |
long double | const_ln_10< long double > () noexcept |
|
template<typename T > |
T | const_ln_2 () noexcept |
| \(\ln(2)\) More...
|
|
template<> |
double | const_ln_2< double > () noexcept |
|
template<> |
float | const_ln_2< float > () noexcept |
|
template<> |
long double | const_ln_2< long double > () noexcept |
|
template<typename T > |
T | const_ln_3 () noexcept |
| \(\ln(3)\) More...
|
|
template<> |
double | const_ln_3< double > () noexcept |
|
template<> |
float | const_ln_3< float > () noexcept |
|
template<> |
long double | const_ln_3< long double > () noexcept |
|
template<typename T > |
T | const_ln_5 () noexcept |
| \(\ln(5)\) More...
|
|
template<> |
double | const_ln_5< double > () noexcept |
|
template<> |
float | const_ln_5< float > () noexcept |
|
template<> |
long double | const_ln_5< long double > () noexcept |
|
template<typename T > |
T | const_ln_inv_10 () noexcept |
| \(1/\ln(10)\) More...
|
|
template<> |
double | const_ln_inv_10< double > () noexcept |
|
template<> |
float | const_ln_inv_10< float > () noexcept |
|
template<> |
long double | const_ln_inv_10< long double > () noexcept |
|
template<typename T > |
T | const_ln_inv_2 () noexcept |
| \(1/\ln(2)\) More...
|
|
template<> |
double | const_ln_inv_2< double > () noexcept |
|
template<> |
float | const_ln_inv_2< float > () noexcept |
|
template<> |
long double | const_ln_inv_2< long double > () noexcept |
|
template<typename T > |
T | const_ln_inv_3 () noexcept |
| \(1/\ln(3)\) More...
|
|
template<> |
double | const_ln_inv_3< double > () noexcept |
|
template<> |
float | const_ln_inv_3< float > () noexcept |
|
template<> |
long double | const_ln_inv_3< long double > () noexcept |
|
template<typename T > |
T | const_ln_inv_5 () noexcept |
| \(1/\ln(5)\) More...
|
|
template<> |
double | const_ln_inv_5< double > () noexcept |
|
template<> |
float | const_ln_inv_5< float > () noexcept |
|
template<> |
long double | const_ln_inv_5< long double > () noexcept |
|
template<typename T > |
T | const_ln_ln_2 () noexcept |
| \(\ln(\ln(2))\) More...
|
|
template<> |
double | const_ln_ln_2< double > () noexcept |
|
template<> |
float | const_ln_ln_2< float > () noexcept |
|
template<> |
long double | const_ln_ln_2< long double > () noexcept |
|
template<typename T > |
T | const_ln_pi () noexcept |
| \(\ln(\pi)\) More...
|
|
template<> |
double | const_ln_pi< double > () noexcept |
|
template<> |
float | const_ln_pi< float > () noexcept |
|
template<> |
long double | const_ln_pi< long double > () noexcept |
|
template<typename T > |
T | const_ln_pi_2 () noexcept |
| \(\ln(2\pi)\) More...
|
|
template<> |
double | const_ln_pi_2< double > () noexcept |
|
template<> |
float | const_ln_pi_2< float > () noexcept |
|
template<> |
long double | const_ln_pi_2< long double > () noexcept |
|
template<typename T > |
T | const_ln_pi_2by3 () noexcept |
| \(\ln((2/3)\pi)\) More...
|
|
template<> |
double | const_ln_pi_2by3< double > () noexcept |
|
template<> |
float | const_ln_pi_2by3< float > () noexcept |
|
template<> |
long double | const_ln_pi_2by3< long double > () noexcept |
|
template<typename T > |
T | const_ln_pi_3by4 () noexcept |
| \(\ln((3/4)\pi)\) More...
|
|
template<> |
double | const_ln_pi_3by4< double > () noexcept |
|
template<> |
float | const_ln_pi_3by4< float > () noexcept |
|
template<> |
long double | const_ln_pi_3by4< long double > () noexcept |
|
template<typename T > |
T | const_ln_pi_4by3 () noexcept |
| \(\ln((4/3)\pi)\) More...
|
|
template<> |
double | const_ln_pi_4by3< double > () noexcept |
|
template<> |
float | const_ln_pi_4by3< float > () noexcept |
|
template<> |
long double | const_ln_pi_4by3< long double > () noexcept |
|
template<typename T > |
T | const_ln_pi_by2 () noexcept |
| \(\ln(\pi/2)\) More...
|
|
template<> |
double | const_ln_pi_by2< double > () noexcept |
|
template<> |
float | const_ln_pi_by2< float > () noexcept |
|
template<> |
long double | const_ln_pi_by2< long double > () noexcept |
|
template<typename T > |
T | const_ln_pi_by3 () noexcept |
| \(\ln(\pi/3)\) More...
|
|
template<> |
double | const_ln_pi_by3< double > () noexcept |
|
template<> |
float | const_ln_pi_by3< float > () noexcept |
|
template<> |
long double | const_ln_pi_by3< long double > () noexcept |
|
template<typename T > |
T | const_ln_pi_by4 () noexcept |
| \(\ln(\pi/4)\) More...
|
|
template<> |
double | const_ln_pi_by4< double > () noexcept |
|
template<> |
float | const_ln_pi_by4< float > () noexcept |
|
template<> |
long double | const_ln_pi_by4< long double > () noexcept |
|
template<typename T > |
T | const_ln_pi_by6 () noexcept |
| \(\ln(\pi/6)\) More...
|
|
template<> |
double | const_ln_pi_by6< double > () noexcept |
|
template<> |
float | const_ln_pi_by6< float > () noexcept |
|
template<> |
long double | const_ln_pi_by6< long double > () noexcept |
|
template<typename T > |
T | const_pi () noexcept |
| \(\pi\) More...
|
|
template<> |
double | const_pi< double > () noexcept |
|
template<> |
float | const_pi< float > () noexcept |
|
template<> |
long double | const_pi< long double > () noexcept |
|
template<typename T > |
T | const_pi_2 () noexcept |
| \(2\pi\) More...
|
|
template<> |
double | const_pi_2< double > () noexcept |
|
template<> |
float | const_pi_2< float > () noexcept |
|
template<> |
long double | const_pi_2< long double > () noexcept |
|
template<typename T > |
T | const_pi_2by3 () noexcept |
| \((2/3)\pi\) More...
|
|
template<> |
double | const_pi_2by3< double > () noexcept |
|
template<> |
float | const_pi_2by3< float > () noexcept |
|
template<> |
long double | const_pi_2by3< long double > () noexcept |
|
template<typename T > |
T | const_pi_3by4 () noexcept |
| \((3/4)\pi\) More...
|
|
template<> |
double | const_pi_3by4< double > () noexcept |
|
template<> |
float | const_pi_3by4< float > () noexcept |
|
template<> |
long double | const_pi_3by4< long double > () noexcept |
|
template<typename T > |
T | const_pi_4by3 () noexcept |
| \((4/3)\pi\) More...
|
|
template<> |
double | const_pi_4by3< double > () noexcept |
|
template<> |
float | const_pi_4by3< float > () noexcept |
|
template<> |
long double | const_pi_4by3< long double > () noexcept |
|
template<typename T > |
T | const_pi_by2 () noexcept |
| \(\pi/2\) More...
|
|
template<> |
double | const_pi_by2< double > () noexcept |
|
template<> |
float | const_pi_by2< float > () noexcept |
|
template<> |
long double | const_pi_by2< long double > () noexcept |
|
template<typename T > |
T | const_pi_by3 () noexcept |
| \(\pi/3\) More...
|
|
template<> |
double | const_pi_by3< double > () noexcept |
|
template<> |
float | const_pi_by3< float > () noexcept |
|
template<> |
long double | const_pi_by3< long double > () noexcept |
|
template<typename T > |
T | const_pi_by4 () noexcept |
| \(\pi/4\) More...
|
|
template<> |
double | const_pi_by4< double > () noexcept |
|
template<> |
float | const_pi_by4< float > () noexcept |
|
template<> |
long double | const_pi_by4< long double > () noexcept |
|
template<typename T > |
T | const_pi_by6 () noexcept |
| \(\pi/6\) More...
|
|
template<> |
double | const_pi_by6< double > () noexcept |
|
template<> |
float | const_pi_by6< float > () noexcept |
|
template<> |
long double | const_pi_by6< long double > () noexcept |
|
template<typename T > |
T | const_pi_inv () noexcept |
| \(1/\pi\) More...
|
|
template<> |
double | const_pi_inv< double > () noexcept |
|
template<> |
float | const_pi_inv< float > () noexcept |
|
template<> |
long double | const_pi_inv< long double > () noexcept |
|
template<typename T > |
T | const_pi_sqr () noexcept |
| \(\pi^2\) More...
|
|
template<> |
double | const_pi_sqr< double > () noexcept |
|
template<> |
float | const_pi_sqr< float > () noexcept |
|
template<> |
long double | const_pi_sqr< long double > () noexcept |
|
template<typename T > |
T | const_sqrt_10 () noexcept |
| \(\sqrt{10}\) More...
|
|
template<> |
double | const_sqrt_10< double > () noexcept |
|
template<> |
float | const_sqrt_10< float > () noexcept |
|
template<> |
long double | const_sqrt_10< long double > () noexcept |
|
template<typename T > |
T | const_sqrt_1by10 () noexcept |
| \(\sqrt{1/10}\) More...
|
|
template<> |
double | const_sqrt_1by10< double > () noexcept |
|
template<> |
float | const_sqrt_1by10< float > () noexcept |
|
template<> |
long double | const_sqrt_1by10< long double > () noexcept |
|
template<typename T > |
T | const_sqrt_1by2 () noexcept |
| \(\sqrt{1/2}\) More...
|
|
template<> |
double | const_sqrt_1by2< double > () noexcept |
|
template<> |
float | const_sqrt_1by2< float > () noexcept |
|
template<> |
long double | const_sqrt_1by2< long double > () noexcept |
|
template<typename T > |
T | const_sqrt_1by3 () noexcept |
| \(\sqrt{1/3}\) More...
|
|
template<> |
double | const_sqrt_1by3< double > () noexcept |
|
template<> |
float | const_sqrt_1by3< float > () noexcept |
|
template<> |
long double | const_sqrt_1by3< long double > () noexcept |
|
template<typename T > |
T | const_sqrt_1by5 () noexcept |
| \(\sqrt{1/5}\) More...
|
|
template<> |
double | const_sqrt_1by5< double > () noexcept |
|
template<> |
float | const_sqrt_1by5< float > () noexcept |
|
template<> |
long double | const_sqrt_1by5< long double > () noexcept |
|
template<typename T > |
T | const_sqrt_2 () noexcept |
| \(\sqrt{2}\) More...
|
|
template<> |
double | const_sqrt_2< double > () noexcept |
|
template<> |
float | const_sqrt_2< float > () noexcept |
|
template<> |
long double | const_sqrt_2< long double > () noexcept |
|
template<typename T > |
T | const_sqrt_3 () noexcept |
| \(\sqrt{3}\) More...
|
|
template<> |
double | const_sqrt_3< double > () noexcept |
|
template<> |
float | const_sqrt_3< float > () noexcept |
|
template<> |
long double | const_sqrt_3< long double > () noexcept |
|
template<typename T > |
T | const_sqrt_5 () noexcept |
| \(\sqrt{5}\) More...
|
|
template<> |
double | const_sqrt_5< double > () noexcept |
|
template<> |
float | const_sqrt_5< float > () noexcept |
|
template<> |
long double | const_sqrt_5< long double > () noexcept |
|
template<typename T > |
T | const_sqrt_e () noexcept |
| \(\sqrt{e}\) More...
|
|
template<> |
double | const_sqrt_e< double > () noexcept |
|
template<> |
float | const_sqrt_e< float > () noexcept |
|
template<> |
long double | const_sqrt_e< long double > () noexcept |
|
template<typename T > |
T | const_sqrt_e_inv () noexcept |
| \(\sqrt{1/e}\) More...
|
|
template<> |
double | const_sqrt_e_inv< double > () noexcept |
|
template<> |
float | const_sqrt_e_inv< float > () noexcept |
|
template<> |
long double | const_sqrt_e_inv< long double > () noexcept |
|
template<typename T > |
T | const_sqrt_pi () noexcept |
| \(\sqrt{\pi}\) More...
|
|
template<> |
double | const_sqrt_pi< double > () noexcept |
|
template<> |
float | const_sqrt_pi< float > () noexcept |
|
template<> |
long double | const_sqrt_pi< long double > () noexcept |
|
template<typename T > |
T | const_sqrt_pi_2 () noexcept |
| \(\sqrt{2\pi}\) More...
|
|
template<> |
double | const_sqrt_pi_2< double > () noexcept |
|
template<> |
float | const_sqrt_pi_2< float > () noexcept |
|
template<> |
long double | const_sqrt_pi_2< long double > () noexcept |
|
template<typename T > |
T | const_sqrt_pi_2by3 () noexcept |
| \(\sqrt{(2/3)\pi}\) More...
|
|
template<> |
double | const_sqrt_pi_2by3< double > () noexcept |
|
template<> |
float | const_sqrt_pi_2by3< float > () noexcept |
|
template<> |
long double | const_sqrt_pi_2by3< long double > () noexcept |
|
template<typename T > |
T | const_sqrt_pi_3by4 () noexcept |
| \(\sqrt{(3/4)\pi/}\) More...
|
|
template<> |
double | const_sqrt_pi_3by4< double > () noexcept |
|
template<> |
float | const_sqrt_pi_3by4< float > () noexcept |
|
template<> |
long double | const_sqrt_pi_3by4< long double > () noexcept |
|
template<typename T > |
T | const_sqrt_pi_4by3 () noexcept |
| \(\sqrt{(4/3)\pi}\) More...
|
|
template<> |
double | const_sqrt_pi_4by3< double > () noexcept |
|
template<> |
float | const_sqrt_pi_4by3< float > () noexcept |
|
template<> |
long double | const_sqrt_pi_4by3< long double > () noexcept |
|
template<typename T > |
T | const_sqrt_pi_by2 () noexcept |
| \(\sqrt{\pi/2}\) More...
|
|
template<> |
double | const_sqrt_pi_by2< double > () noexcept |
|
template<> |
float | const_sqrt_pi_by2< float > () noexcept |
|
template<> |
long double | const_sqrt_pi_by2< long double > () noexcept |
|
template<typename T > |
T | const_sqrt_pi_by3 () noexcept |
| \(\sqrt{\pi/3}\) More...
|
|
template<> |
double | const_sqrt_pi_by3< double > () noexcept |
|
template<> |
float | const_sqrt_pi_by3< float > () noexcept |
|
template<> |
long double | const_sqrt_pi_by3< long double > () noexcept |
|
template<typename T > |
T | const_sqrt_pi_by4 () noexcept |
| \(\sqrt{\pi/4}\) More...
|
|
template<> |
double | const_sqrt_pi_by4< double > () noexcept |
|
template<> |
float | const_sqrt_pi_by4< float > () noexcept |
|
template<> |
long double | const_sqrt_pi_by4< long double > () noexcept |
|
template<typename T > |
T | const_sqrt_pi_by6 () noexcept |
| \(\sqrt{\pi/6}\) More...
|
|
template<> |
double | const_sqrt_pi_by6< double > () noexcept |
|
template<> |
float | const_sqrt_pi_by6< float > () noexcept |
|
template<> |
long double | const_sqrt_pi_by6< long double > () noexcept |
|
template<typename T > |
T | const_sqrt_pi_inv () noexcept |
| \(\sqrt{1/\pi}\) More...
|
|
template<> |
double | const_sqrt_pi_inv< double > () noexcept |
|
template<> |
float | const_sqrt_pi_inv< float > () noexcept |
|
template<> |
long double | const_sqrt_pi_inv< long double > () noexcept |
|
template<typename T > |
void | copy (std::size_t n, const T *x, std::size_t incx, T *y, std::size_t incy) |
| Copies vector to another vector. More...
|
|
void | copy (std::size_t n, const float *x, std::size_t incx, float *y, std::size_t incy) |
|
void | copy (std::size_t n, const double *x, std::size_t incx, double *y, std::size_t incy) |
|
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...
|
|
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...
|
|
template<typename T > |
T | dot (std::size_t n, const T *x, std::size_t incx, const T *y, std::size_t incy) |
| Computes a vector-vector dot product. More...
|
|
float | dot (std::size_t n, const float *x, std::size_t incx, const float *y, std::size_t incy) |
|
double | dot (std::size_t n, const double *x, std::size_t incx, const double *y, std::size_t incy) |
|
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<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<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 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<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 T > |
void | gemv (MatrixOrder order, MatrixTrans trans, std::size_t m, std::size_t n, T alpha, const T *A, std::size_t lda, const T *x, std::size_t incx, T beta, T *y, std::size_t incy) |
| Computes a matrix-vector product using a general matrix. More...
|
|
void | gemv (MatrixOrder order, MatrixTrans trans, std::size_t m, std::size_t n, float alpha, const float *A, std::size_t lda, const float *x, std::size_t incx, float beta, float *y, std::size_t incy) |
|
void | gemv (MatrixOrder order, MatrixTrans trans, std::size_t m, std::size_t n, double alpha, const double *A, std::size_t lda, const double *x, std::size_t incx, double beta, double *y, std::size_t incy) |
|
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<MatrixOrder Order, std::size_t Dim, typename T > |
void | hdf5store (const StateMatrix< Order, 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<MatrixOrder Order, 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<MatrixOrder Order, 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<MatrixOrder Order, 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 double *a, double *y) |
|
void | invcbrt (std::size_t n, const float *a, float *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, 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, 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 double *a, double *y) |
|
void | log1p (std::size_t n, const float *a, float *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, 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, 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::Threefry2x64 > () |
|
template<> |
int | mkl_brng< ::vsmc::Threefry4x32 > () |
|
template<> |
int | mkl_brng< ::vsmc::Threefry4x64 > () |
|
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, 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 T > |
T | nrm2 (std::size_t n, const T *x, std::size_t incx) |
| Computes the Euclidean norm of a vector. More...
|
|
float | nrm2 (std::size_t n, const float *x, std::size_t incx) |
|
double | nrm2 (std::size_t n, const double *x, std::size_t incx) |
|
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 CharT , typename Traits , MatrixOrder Order, std::size_t Dim, typename T > |
std::basic_ostream< CharT, Traits > & | operator<< (std::basic_ostream< CharT, Traits > &os, const StateMatrixBase< Order, 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 std::array< T, N > &ary) |
|
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 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 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 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 double *a, const double *b, double *y) |
|
void | pow (std::size_t n, const float *a, const float *b, float *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 float *a, float *y) |
|
void | pow2o3 (std::size_t n, const double *a, double *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 float *a, float *y) |
|
void | pow3o2 (std::size_t n, const double *a, double *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...
|
|
void | program_option_warning (const std::string &oname, const std::string &msg, bool silent, std::ostream &os) |
| Program option warning messages. More...
|
|
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 *src_idx, 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 *src_idx) |
| 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 *src_idx) |
| 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 IntType , typename RNGType > |
void | rng_rand (RNGType &rng, BernoulliDistribution< IntType > &dist, std::size_t n, IntType *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, GammaDistribution< RealType > &dist, std::size_t n, RealType *r) |
|
template<typename RNGType > |
void | rng_rand (RNGType &rng, std::size_t n, typename RNGType::result_type *r) |
| Generate random bits. More...
|
|
template<typename Generator > |
void | rng_rand (CounterEngine< Generator > &rng, std::size_t n, typename CounterEngine< Generator >::result_type *r) |
|
template<typename IntType , typename RNGType > |
void | rng_rand (RNGType &, BernoulliIntDistribution< IntType > &, std::size_t, IntType *) |
|
template<typename UIntType , typename RNGType > |
void | rng_rand (RNGType &, UniformBitsDistribution< UIntType > &, std::size_t, UIntType *) |
|
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 , 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 &, 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 , typename Left , typename Right > |
void | rng_rand (RNGType &, U01LRDistribution< RealType, Left, Right > &, std::size_t, RealType *) |
|
template<typename RealType , typename RNGType , typename Left , typename Right > |
void | rng_rand (RNGType &, UniformRealLRDistribution< RealType, Left, Right > &, 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 *) |
|
template<typename T > |
void | scal (std::size_t n, T a, T *x, std::size_t incx) |
| Computes the product of a vector by a scalar. More...
|
|
void | scal (std::size_t n, float a, float *x, std::size_t incx) |
|
void | scal (std::size_t n, double a, double *x, std::size_t incx) |
|
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 double *a, double *y) |
|
void | sqr (std::size_t n, const float *a, float *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 double *a, double *y) |
|
void | sqrt (std::size_t n, const float *a, float *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, 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 float *a, float *y) |
|
void | tan (std::size_t n, const double *a, double *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 RealType , typename RNGType > |
void | u01_cc_distribution (RNGType &rng, std::size_t n, RealType *r) |
| Generate standard uniform random variates on closed-closed interval. More...
|
|
template<typename RealType , typename RNGType > |
void | u01_co_distribution (RNGType &rng, std::size_t n, RealType *r) |
| Generate standard uniform random variates on closed-open interval. More...
|
|
template<typename RealType , typename RNGType > |
void | u01_distribution (RNGType &rng, std::size_t n, RealType *r) |
| Generate standard uniform random variates. More...
|
|
template<typename RealType , typename Left , typename Right , typename RNGType > |
void | u01_distribution (RNGType &, std::size_t, RealType *) |
| 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 RealType , typename Left , typename Right , typename RNGType > |
void | u01_lr_distribution (RNGType &rng, std::size_t n, RealType *r) |
| Generate standard uniform random variates with open/closed variants. More...
|
|
template<typename RealType , typename RNGType > |
void | u01_lr_distribution (RNGType &, std::size_t, RealType *) |
| Generate standard uniform random variates with open/closed variants. More...
|
|
template<typename RealType , typename RNGType > |
void | u01_oc_distribution (RNGType &rng, std::size_t n, RealType *r) |
| Generate standard uniform random variates on open-closed interval. More...
|
|
template<typename RealType , typename RNGType > |
void | u01_oo_distribution (RNGType &rng, std::size_t n, RealType *r) |
| Generate standard uniform random variates on open-open interval. More...
|
|
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 &, std::size_t, UIntType *) |
|
template<typename RealType , typename RNGType > |
void | uniform_real_cc_distribution (RNGType &rng, std::size_t n, RealType *r, RealType a, RealType b) |
| Generate uniform real random variates on closed-closed interval. More...
|
|
template<typename RealType , typename RNGType > |
void | uniform_real_co_distribution (RNGType &rng, std::size_t n, RealType *r, RealType a, RealType b) |
| Generate uniform real random variates on closed-open interval. More...
|
|
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. 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 Left , typename Right , typename RNGType > |
void | uniform_real_lr_distribution (RNGType &rng, std::size_t n, RealType *r, RealType a, RealType b) |
| Generate uniform real random variates with open/closed variants. More...
|
|
template<typename RealType , typename RNGType > |
void | uniform_real_oc_distribution (RNGType &rng, std::size_t n, RealType *r, RealType a, RealType b) |
| Generate uniform real random variates on open-closed interval. More...
|
|
template<typename RealType , typename RNGType > |
void | uniform_real_oo_distribution (RNGType &rng, std::size_t n, RealType *r, RealType a, RealType b) |
| Generate uniform real random variates on open-open interval. More...
|
|
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...
|
|