#include <vsmc/internal/config.hpp>
#include <vsmc/cxx11/cmath.hpp>
#include <vsmc/math/constants.hpp>
#include <mkl.h>

Namespaces
	vsmc

	vsmc::math

	vsmc::math::internal

Macros
#define	VSMC_DEFINE_MATH_VMATH_1(ns, func, name)

#define	VSMC_DEFINE_MATH_VMATH_2(ns, func, name)

#define	VSMC_DEFINE_MATH_VMATH_B(op, vname)

#define	VSMC_DEFINE_MATH_VMATH_VML_1(name)

#define	VSMC_DEFINE_MATH_VMATH_VML_2(name)

#define	VSMC_VMATH_THRESHOLD 1000
	When MKL (VML) or vecLib (vForce) is available, the threshold of the number of elements above which these libraries will be used. More...

#define	VSMC_VMATH_THRESHOLD_Abs VSMC_VMATH_THRESHOLD

#define	VSMC_VMATH_THRESHOLD_Acos VSMC_VMATH_THRESHOLD

#define	VSMC_VMATH_THRESHOLD_Acosh VSMC_VMATH_THRESHOLD

#define	VSMC_VMATH_THRESHOLD_Add VSMC_VMATH_THRESHOLD

#define	VSMC_VMATH_THRESHOLD_Asin VSMC_VMATH_THRESHOLD

#define	VSMC_VMATH_THRESHOLD_Asinh VSMC_VMATH_THRESHOLD

#define	VSMC_VMATH_THRESHOLD_Atan VSMC_VMATH_THRESHOLD

#define	VSMC_VMATH_THRESHOLD_Atan2 VSMC_VMATH_THRESHOLD

#define	VSMC_VMATH_THRESHOLD_Atanh VSMC_VMATH_THRESHOLD

#define	VSMC_VMATH_THRESHOLD_Cbrt VSMC_VMATH_THRESHOLD

#define	VSMC_VMATH_THRESHOLD_CdfNorm VSMC_VMATH_THRESHOLD

#define	VSMC_VMATH_THRESHOLD_CdfNormInv VSMC_VMATH_THRESHOLD

#define	VSMC_VMATH_THRESHOLD_Cos VSMC_VMATH_THRESHOLD

#define	VSMC_VMATH_THRESHOLD_Cosh VSMC_VMATH_THRESHOLD

#define	VSMC_VMATH_THRESHOLD_Div VSMC_VMATH_THRESHOLD

#define	VSMC_VMATH_THRESHOLD_Erf VSMC_VMATH_THRESHOLD

#define	VSMC_VMATH_THRESHOLD_Erfc VSMC_VMATH_THRESHOLD

#define	VSMC_VMATH_THRESHOLD_ErfcInv VSMC_VMATH_THRESHOLD

#define	VSMC_VMATH_THRESHOLD_ErfInv VSMC_VMATH_THRESHOLD

#define	VSMC_VMATH_THRESHOLD_Exp VSMC_VMATH_THRESHOLD

#define	VSMC_VMATH_THRESHOLD_Expm1 VSMC_VMATH_THRESHOLD

#define	VSMC_VMATH_THRESHOLD_Hypot VSMC_VMATH_THRESHOLD

#define	VSMC_VMATH_THRESHOLD_Inv VSMC_VMATH_THRESHOLD

#define	VSMC_VMATH_THRESHOLD_InvCbrt VSMC_VMATH_THRESHOLD

#define	VSMC_VMATH_THRESHOLD_InvSqrt VSMC_VMATH_THRESHOLD

#define	VSMC_VMATH_THRESHOLD_LGamma VSMC_VMATH_THRESHOLD

#define	VSMC_VMATH_THRESHOLD_LinearFrac VSMC_VMATH_THRESHOLD

#define	VSMC_VMATH_THRESHOLD_Ln VSMC_VMATH_THRESHOLD

#define	VSMC_VMATH_THRESHOLD_Log10 VSMC_VMATH_THRESHOLD

#define	VSMC_VMATH_THRESHOLD_Log1p VSMC_VMATH_THRESHOLD

#define	VSMC_VMATH_THRESHOLD_Mul VSMC_VMATH_THRESHOLD

#define	VSMC_VMATH_THRESHOLD_Pow VSMC_VMATH_THRESHOLD

#define	VSMC_VMATH_THRESHOLD_Pow2o3 VSMC_VMATH_THRESHOLD

#define	VSMC_VMATH_THRESHOLD_Pow3o2 VSMC_VMATH_THRESHOLD

#define	VSMC_VMATH_THRESHOLD_Powx VSMC_VMATH_THRESHOLD

#define	VSMC_VMATH_THRESHOLD_Sin VSMC_VMATH_THRESHOLD

#define	VSMC_VMATH_THRESHOLD_SinCos VSMC_VMATH_THRESHOLD

#define	VSMC_VMATH_THRESHOLD_Sinh VSMC_VMATH_THRESHOLD

#define	VSMC_VMATH_THRESHOLD_Sqr VSMC_VMATH_THRESHOLD

#define	VSMC_VMATH_THRESHOLD_Sqrt VSMC_VMATH_THRESHOLD

#define	VSMC_VMATH_THRESHOLD_Sub VSMC_VMATH_THRESHOLD

#define	VSMC_VMATH_THRESHOLD_Tan VSMC_VMATH_THRESHOLD

#define	VSMC_VMATH_THRESHOLD_Tanh VSMC_VMATH_THRESHOLD

#define	VSMC_VMATH_THRESHOLD_TGamma VSMC_VMATH_THRESHOLD

Functions
template<typename T >
void	vsmc::math::vAbs (std::size_t n, const T a, T y)
	For \(i=1,\ldots,n\), compute \(y_i = \|a_i\|\). More...

void	vsmc::math::vAbs (std::size_t n, const double a, double y)

void	vsmc::math::vAbs (std::size_t n, const float a, float y)

template<typename T >
void	vsmc::math::vAcos (std::size_t n, const T a, T y)
	For \(i=1,\ldots,n\), compute \(y_i = \arccos(a_i)\). More...

void	vsmc::math::vAcos (std::size_t n, const float a, float y)

void	vsmc::math::vAcos (std::size_t n, const double a, double y)

template<typename T >
void	vsmc::math::vAcosh (std::size_t n, const T a, T y)
	For \(i=1,\ldots,n\), compute \(y_i = \mathrm{arc}\cosh(a_i)\). More...

void	vsmc::math::vAcosh (std::size_t n, const float a, float y)

void	vsmc::math::vAcosh (std::size_t n, const double a, double y)

template<typename T >
void	vsmc::math::vAdd (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...

void	vsmc::math::vAdd (std::size_t n, const float a, const float b, float *y)

void	vsmc::math::vAdd (std::size_t n, const double a, const double b, double *y)

template<typename T >
void	vsmc::math::vAsin (std::size_t n, const T a, T y)
	For \(i=1,\ldots,n\), compute \(y_i = \arcsin(a_i)\). More...

void	vsmc::math::vAsin (std::size_t n, const float a, float y)

void	vsmc::math::vAsin (std::size_t n, const double a, double y)

template<typename T >
void	vsmc::math::vAsinh (std::size_t n, const T a, T y)
	For \(i=1,\ldots,n\), compute \(y_i = \mathrm{arc}\sinh(a_i)\). More...

void	vsmc::math::vAsinh (std::size_t n, const float a, float y)

void	vsmc::math::vAsinh (std::size_t n, const double a, double y)

template<typename T >
void	vsmc::math::vAtan (std::size_t n, const T a, T y)
	For \(i=1,\ldots,n\), compute \(y_i = \arctan(a_i)\). More...

void	vsmc::math::vAtan (std::size_t n, const float a, float y)

void	vsmc::math::vAtan (std::size_t n, const double a, double y)

template<typename T >
void	vsmc::math::vAtan2 (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	vsmc::math::vAtan2 (std::size_t n, const float a, const float b, float *y)

void	vsmc::math::vAtan2 (std::size_t n, const double a, const double b, double *y)

template<typename T >
void	vsmc::math::vAtanh (std::size_t n, const T a, T y)
	For \(i=1,\ldots,n\), compute \(y_i = \mathrm{arc}\tanh(a_i)\). More...

void	vsmc::math::vAtanh (std::size_t n, const float a, float y)

void	vsmc::math::vAtanh (std::size_t n, const double a, double y)

template<typename T >
void	vsmc::math::vCbrt (std::size_t n, const T a, T y)
	For \(i=1,\ldots,n\), compute \(y_i = \sqrt[3]{a_i}\). More...

void	vsmc::math::vCbrt (std::size_t n, const float a, float y)

void	vsmc::math::vCbrt (std::size_t n, const double a, double y)

template<typename T >
void	vsmc::math::vCdfNorm (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	vsmc::math::vCdfNorm (std::size_t n, const float a, float y)

void	vsmc::math::vCdfNorm (std::size_t n, const double a, double y)

template<typename T >
void	vsmc::math::vCdfNormInv (std::size_t n, const T a, T y)
	For \(i=1,\ldots,n\), compute \(y_i = \sqrt{2}\mathrm{Erf}^{-1}(2a_i - 1)\), inverse of the standard Nomral CDF. More...

void	vsmc::math::vCdfNormInv (std::size_t n, const float a, float y)

void	vsmc::math::vCdfNormInv (std::size_t n, const double a, double y)

template<typename T >
void	vsmc::math::vCos (std::size_t n, const T a, T y)
	For \(i=1,\ldots,n\), compute \(y_i = \sin(a_i)\). More...

void	vsmc::math::vCos (std::size_t n, const float a, float y)

void	vsmc::math::vCos (std::size_t n, const double a, double y)

template<typename T >
void	vsmc::math::vCosh (std::size_t n, const T a, T y)
	For \(i=1,\ldots,n\), compute \(y_i = \cosh(a_i)\). More...

void	vsmc::math::vCosh (std::size_t n, const float a, float y)

void	vsmc::math::vCosh (std::size_t n, const double a, double y)

template<typename T >
void	vsmc::math::vDiv (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...

void	vsmc::math::vDiv (std::size_t n, const float a, const float b, float *y)

void	vsmc::math::vDiv (std::size_t n, const double a, const double b, double *y)

template<typename T >
void	vsmc::math::vErf (std::size_t n, const T a, T y)
	For \(i=1,\ldots,n\), compute \(y_i = \mathrm{Erf}(a_i)\). More...

void	vsmc::math::vErf (std::size_t n, const double a, double y)

void	vsmc::math::vErf (std::size_t n, const float a, float y)

template<typename T >
void	vsmc::math::vErfc (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	vsmc::math::vErfc (std::size_t n, const float a, float y)

void	vsmc::math::vErfc (std::size_t n, const double a, double y)

template<typename T >
void	vsmc::math::vErfcInv (std::size_t n, const T a, T y)
	For \(i=1,\ldots,n\), compute \(y_i = \mathrm{Erf}^{-1}(1 - a_i)\). More...

void	vsmc::math::vErfcInv (std::size_t n, const float a, float y)

void	vsmc::math::vErfcInv (std::size_t n, const double a, double y)

template<typename T >
void	vsmc::math::vErfInv (std::size_t n, const T a, T y)
	For \(i=1,\ldots,n\), compute \(y_i = \mathrm{Erf}^{-1}(a_i)\). More...

void	vsmc::math::vErfInv (std::size_t n, const float a, float y)

void	vsmc::math::vErfInv (std::size_t n, const double a, double y)

template<typename T >
void	vsmc::math::vExp (std::size_t n, const T a, T y)
	For \(i=1,\ldots,n\), compute \(y_i = e^{a_i}\). More...

void	vsmc::math::vExp (std::size_t n, const float a, float y)

void	vsmc::math::vExp (std::size_t n, const double a, double y)

template<typename T >
void	vsmc::math::vExpm1 (std::size_t n, const T a, T y)
	For \(i=1,\ldots,n\), compute \(y_i = e^{a_i} - 1\). More...

void	vsmc::math::vExpm1 (std::size_t n, const float a, float y)

void	vsmc::math::vExpm1 (std::size_t n, const double a, double y)

template<typename T >
void	vsmc::math::vHypot (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...

void	vsmc::math::vHypot (std::size_t n, const float a, const float b, float *y)

void	vsmc::math::vHypot (std::size_t n, const double a, const double b, double *y)

template<typename T >
void	vsmc::math::vInv (std::size_t n, const T a, T y)
	For \(i=1,\ldots,n\), compute \(y_i = a_i^{-1}\). More...

void	vsmc::math::vInv (std::size_t n, const double a, double y)

void	vsmc::math::vInv (std::size_t n, const float a, float y)

template<typename T >
void	vsmc::math::vInvCbrt (std::size_t n, const T a, T y)
	For \(i=1,\ldots,n\), compute \(y_i = 1 / \sqrt[3]{a_i}\). More...

void	vsmc::math::vInvCbrt (std::size_t n, const float a, float y)

void	vsmc::math::vInvCbrt (std::size_t n, const double a, double y)

template<typename T >
void	vsmc::math::vInvSqrt (std::size_t n, const T a, T y)
	For \(i=1,\ldots,n\), compute \(y_i = 1 / \sqrt{a_i}\). More...

void	vsmc::math::vInvSqrt (std::size_t n, const float a, float y)

void	vsmc::math::vInvSqrt (std::size_t n, const double a, double y)

template<typename T >
void	vsmc::math::vLGamma (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	vsmc::math::vLGamma (std::size_t n, const double a, double y)

void	vsmc::math::vLGamma (std::size_t n, const float a, float y)

template<typename T >
void	vsmc::math::vLinearFrac (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	vsmc::math::vLinearFrac (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	vsmc::math::vLinearFrac (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	vsmc::math::vLn (std::size_t n, const T a, T y)
	For \(i=1,\ldots,n\), compute \(y_i = \ln(a_i)\). More...

void	vsmc::math::vLn (std::size_t n, const double a, double y)

void	vsmc::math::vLn (std::size_t n, const float a, float y)

template<typename T >
void	vsmc::math::vLog10 (std::size_t n, const T a, T y)
	For \(i=1,\ldots,n\), compute \(y_i = \log_{10}(a_i)\). More...

void	vsmc::math::vLog10 (std::size_t n, const float a, float y)

void	vsmc::math::vLog10 (std::size_t n, const double a, double y)

template<typename T >
void	vsmc::math::vLog1p (std::size_t n, const T a, T y)
	For \(i=1,\ldots,n\), compute \(y_i = \log(a_i + 1)\). More...

void	vsmc::math::vLog1p (std::size_t n, const float a, float y)

void	vsmc::math::vLog1p (std::size_t n, const double a, double y)

template<typename T >
T	vsmc::math::internal::vmath_cdfnorm (T a)

template<typename T >
T	vsmc::math::internal::vmath_cdfnorminv (T a)

template<typename T >
T	vsmc::math::internal::vmath_erfcinv (T a)

template<typename T >
T	vsmc::math::internal::vmath_erfinv (T a)

template<typename T >
T	vsmc::math::internal::vmath_inv (T a)

template<typename T >
T	vsmc::math::internal::vmath_invcbrt (T a)

template<typename T >
T	vsmc::math::internal::vmath_invsqrt (T a)

template<typename T >
T	vsmc::math::internal::vmath_pow2o3 (T a)

template<typename T >
T	vsmc::math::internal::vmath_pow3o2 (T a)

template<typename T >
T	vsmc::math::internal::vmath_sqr (T a)

template<typename T >
void	vsmc::math::vMul (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...

void	vsmc::math::vMul (std::size_t n, const double a, const double b, double *y)

void	vsmc::math::vMul (std::size_t n, const float a, const float b, float *y)

template<typename T >
void	vsmc::math::vPow (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...

void	vsmc::math::vPow (std::size_t n, const float a, const float b, float *y)

void	vsmc::math::vPow (std::size_t n, const double a, const double b, double *y)

template<typename T >
void	vsmc::math::vPow2o3 (std::size_t n, const T a, T y)
	For \(i=1,\ldots,n\), compute \(y_i = a_i^{2/3}\). More...

void	vsmc::math::vPow2o3 (std::size_t n, const double a, double y)

void	vsmc::math::vPow2o3 (std::size_t n, const float a, float y)

template<typename T >
void	vsmc::math::vPow3o2 (std::size_t n, const T a, T y)
	For \(i=1,\ldots,n\), compute \(y_i = a_i^{3/2}\). More...

void	vsmc::math::vPow3o2 (std::size_t n, const float a, float y)

void	vsmc::math::vPow3o2 (std::size_t n, const double a, double y)

template<typename T >
void	vsmc::math::vPowx (std::size_t n, const T a, T b, T y)
	For \(i=1,\ldots,n\), compute \(y_i = a_i^b\). More...

void	vsmc::math::vPowx (std::size_t n, const float a, float b, float y)

void	vsmc::math::vPowx (std::size_t n, const double a, double b, double y)

template<typename T >
void	vsmc::math::vSin (std::size_t n, const T a, T y)
	For \(i=1,\ldots,n\), compute \(y_i = \cos(a_i)\). More...

void	vsmc::math::vSin (std::size_t n, const double a, double y)

void	vsmc::math::vSin (std::size_t n, const float a, float y)

template<typename T >
void	vsmc::math::vSinCos (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	vsmc::math::vSinCos (std::size_t n, const float a, float y, float *z)

void	vsmc::math::vSinCos (std::size_t n, const double a, double y, double *z)

template<typename T >
void	vsmc::math::vSinh (std::size_t n, const T a, T y)
	For \(i=1,\ldots,n\), compute \(y_i = \sinh(a_i)\). More...

void	vsmc::math::vSinh (std::size_t n, const double a, double y)

void	vsmc::math::vSinh (std::size_t n, const float a, float y)

template<typename T >
void	vsmc::math::vSqr (std::size_t n, const T a, T y)
	For \(i=1,\ldots,n\), compute \(y_i = a_i^2\). More...

void	vsmc::math::vSqr (std::size_t n, const double a, double y)

void	vsmc::math::vSqr (std::size_t n, const float a, float y)

template<typename T >
void	vsmc::math::vSqrt (std::size_t n, const T a, T y)
	For \(i=1,\ldots,n\), compute \(y_i = \sqrt{a_i}\). More...

void	vsmc::math::vSqrt (std::size_t n, const double a, double y)

void	vsmc::math::vSqrt (std::size_t n, const float a, float y)

template<typename T >
void	vsmc::math::vSub (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...

void	vsmc::math::vSub (std::size_t n, const double a, const double b, double *y)

void	vsmc::math::vSub (std::size_t n, const float a, const float b, float *y)

template<typename T >
void	vsmc::math::vTan (std::size_t n, const T a, T y)
	For \(i=1,\ldots,n\), compute \(y_i = \tan(a_i)\). More...

void	vsmc::math::vTan (std::size_t n, const double a, double y)

void	vsmc::math::vTan (std::size_t n, const float a, float y)

template<typename T >
void	vsmc::math::vTanh (std::size_t n, const T a, T y)
	For \(i=1,\ldots,n\), compute \(y_i = \tanh(a_i)\). More...

void	vsmc::math::vTanh (std::size_t n, const double a, double y)

void	vsmc::math::vTanh (std::size_t n, const float a, float y)

template<typename T >
void	vsmc::math::vTGamma (std::size_t n, const T a, T y)
	For \(i=1,\ldots,n\), compute \(y_i = \Gamma(a_i)\), the Gamma function. More...

void	vsmc::math::vTGamma (std::size_t n, const double a, double y)

void	vsmc::math::vTGamma (std::size_t n, const float a, float y)

Macro Definition Documentation

#define VSMC_DEFINE_MATH_VMATH_1	(	ns,
		func,
		name
	)

Value:

template <typename T>                                                        \
inline void v##name (std::size_t n, const T *a, T *y)                        \
{                                                                            \
    using ns::func;                                                          \
    for (std::size_t i = 0; i != n; ++i)                                     \
        y[i] = func(a[i]);                                                   \
}

Definition at line 236 of file vmath.hpp.

#define VSMC_DEFINE_MATH_VMATH_2	(	ns,
		func,
		name
	)

Value:

template <typename T>                                                        \
inline void v##name (std::size_t n, const T *a, const T *b, T *y)            \
{                                                                            \
    using ns::func;                                                          \
    for (std::size_t i = 0; i != n; ++i)                                     \
        y[i] = func(a[i], b[i]);                                             \
}

Definition at line 245 of file vmath.hpp.

#define VSMC_DEFINE_MATH_VMATH_B	(	op,
		vname
	)

Value:

template <typename T>                                                        \
inline void v##vname (std::size_t n, const T *a, const T *b, T *y)           \
{                                                                            \
    for (std::size_t i = 0; i != n; ++i)                                     \
        y[i] = a[i] op b[i];                                                 \
}

Definition at line 254 of file vmath.hpp.

#define VSMC_DEFINE_MATH_VMATH_VML_1 ( name )

Value:

inline void v##name                                                          \
(std::size_t n, const float *a, float *y)                                    \
{                                                                            \
    n < VSMC_VMATH_THRESHOLD_##name ?                                        \
        v##name<float>(n, a, y):                                             \
        ::vs##name(static_cast<MKL_INT>(n), a, y);                           \
}                                                                            \
inline void v##name                                                          \
(std::size_t n, const double *a, double *y)                                  \
{                                                                            \
    n < VSMC_VMATH_THRESHOLD_##name ?                                        \
        v##name<double>(n, a, y):                                            \
        ::vd##name(static_cast<MKL_INT>(n), a, y);                           \
}

Definition at line 519 of file vmath.hpp.

#define VSMC_DEFINE_MATH_VMATH_VML_2 ( name )

Value:

inline void v##name                                                          \
(std::size_t n, const float *a, const float *b, float *y)                    \
{                                                                            \
    n < VSMC_VMATH_THRESHOLD_##name ?                                        \
        v##name<float>(n, a, b, y):                                          \
        ::vs##name(static_cast<MKL_INT>(n), a, b, y);                        \
}                                                                            \
inline void v##name                                                          \
(std::size_t n, const double *a, const double *b, double *y)                 \
{                                                                            \
    n < VSMC_VMATH_THRESHOLD_##name ?                                        \
        v##name<double>(n, a, b, y):                                         \
        ::vd##name(static_cast<MKL_INT>(n), a, b, y);                        \
}

Definition at line 535 of file vmath.hpp.

#define VSMC_VMATH_THRESHOLD_Abs VSMC_VMATH_THRESHOLD

Definition at line 77 of file vmath.hpp.

#define VSMC_VMATH_THRESHOLD_Acos VSMC_VMATH_THRESHOLD

Definition at line 165 of file vmath.hpp.

#define VSMC_VMATH_THRESHOLD_Acosh VSMC_VMATH_THRESHOLD

Definition at line 193 of file vmath.hpp.

#define VSMC_VMATH_THRESHOLD_Add VSMC_VMATH_THRESHOLD

Definition at line 61 of file vmath.hpp.

#define VSMC_VMATH_THRESHOLD_Asin VSMC_VMATH_THRESHOLD

Definition at line 169 of file vmath.hpp.

#define VSMC_VMATH_THRESHOLD_Asinh VSMC_VMATH_THRESHOLD

Definition at line 197 of file vmath.hpp.

#define VSMC_VMATH_THRESHOLD_Atan VSMC_VMATH_THRESHOLD

Definition at line 173 of file vmath.hpp.

#define VSMC_VMATH_THRESHOLD_Atan2 VSMC_VMATH_THRESHOLD

Definition at line 177 of file vmath.hpp.

#define VSMC_VMATH_THRESHOLD_Atanh VSMC_VMATH_THRESHOLD

Definition at line 201 of file vmath.hpp.

#define VSMC_VMATH_THRESHOLD_Cbrt VSMC_VMATH_THRESHOLD

Definition at line 101 of file vmath.hpp.

#define VSMC_VMATH_THRESHOLD_CdfNorm VSMC_VMATH_THRESHOLD

Definition at line 213 of file vmath.hpp.

#define VSMC_VMATH_THRESHOLD_CdfNormInv VSMC_VMATH_THRESHOLD

Definition at line 225 of file vmath.hpp.

#define VSMC_VMATH_THRESHOLD_Cos VSMC_VMATH_THRESHOLD

Definition at line 149 of file vmath.hpp.

#define VSMC_VMATH_THRESHOLD_Cosh VSMC_VMATH_THRESHOLD

Definition at line 181 of file vmath.hpp.

#define VSMC_VMATH_THRESHOLD_Div VSMC_VMATH_THRESHOLD

Definition at line 89 of file vmath.hpp.

#define VSMC_VMATH_THRESHOLD_Erf VSMC_VMATH_THRESHOLD

Definition at line 205 of file vmath.hpp.

#define VSMC_VMATH_THRESHOLD_Erfc VSMC_VMATH_THRESHOLD

Definition at line 209 of file vmath.hpp.

#define VSMC_VMATH_THRESHOLD_ErfcInv VSMC_VMATH_THRESHOLD

Definition at line 221 of file vmath.hpp.

#define VSMC_VMATH_THRESHOLD_ErfInv VSMC_VMATH_THRESHOLD

Definition at line 217 of file vmath.hpp.

#define VSMC_VMATH_THRESHOLD_Exp VSMC_VMATH_THRESHOLD

Definition at line 129 of file vmath.hpp.

#define VSMC_VMATH_THRESHOLD_Expm1 VSMC_VMATH_THRESHOLD

Definition at line 133 of file vmath.hpp.

#define VSMC_VMATH_THRESHOLD_Hypot VSMC_VMATH_THRESHOLD

Definition at line 125 of file vmath.hpp.

#define VSMC_VMATH_THRESHOLD_Inv VSMC_VMATH_THRESHOLD

Definition at line 85 of file vmath.hpp.

#define VSMC_VMATH_THRESHOLD_InvCbrt VSMC_VMATH_THRESHOLD

Definition at line 105 of file vmath.hpp.

#define VSMC_VMATH_THRESHOLD_InvSqrt VSMC_VMATH_THRESHOLD

Definition at line 97 of file vmath.hpp.

#define VSMC_VMATH_THRESHOLD_LGamma VSMC_VMATH_THRESHOLD

Definition at line 229 of file vmath.hpp.

#define VSMC_VMATH_THRESHOLD_LinearFrac VSMC_VMATH_THRESHOLD

Definition at line 81 of file vmath.hpp.

#define VSMC_VMATH_THRESHOLD_Ln VSMC_VMATH_THRESHOLD

Definition at line 137 of file vmath.hpp.

#define VSMC_VMATH_THRESHOLD_Log10 VSMC_VMATH_THRESHOLD

Definition at line 141 of file vmath.hpp.

#define VSMC_VMATH_THRESHOLD_Log1p VSMC_VMATH_THRESHOLD

Definition at line 145 of file vmath.hpp.

#define VSMC_VMATH_THRESHOLD_Mul VSMC_VMATH_THRESHOLD

Definition at line 73 of file vmath.hpp.

#define VSMC_VMATH_THRESHOLD_Pow VSMC_VMATH_THRESHOLD

Definition at line 117 of file vmath.hpp.

#define VSMC_VMATH_THRESHOLD_Pow2o3 VSMC_VMATH_THRESHOLD

Definition at line 109 of file vmath.hpp.

#define VSMC_VMATH_THRESHOLD_Pow3o2 VSMC_VMATH_THRESHOLD

Definition at line 113 of file vmath.hpp.

#define VSMC_VMATH_THRESHOLD_Powx VSMC_VMATH_THRESHOLD

Definition at line 121 of file vmath.hpp.

#define VSMC_VMATH_THRESHOLD_Sin VSMC_VMATH_THRESHOLD

Definition at line 153 of file vmath.hpp.

#define VSMC_VMATH_THRESHOLD_SinCos VSMC_VMATH_THRESHOLD

Definition at line 157 of file vmath.hpp.

#define VSMC_VMATH_THRESHOLD_Sinh VSMC_VMATH_THRESHOLD

Definition at line 185 of file vmath.hpp.

#define VSMC_VMATH_THRESHOLD_Sqr VSMC_VMATH_THRESHOLD

Definition at line 69 of file vmath.hpp.

#define VSMC_VMATH_THRESHOLD_Sqrt VSMC_VMATH_THRESHOLD

Definition at line 93 of file vmath.hpp.

#define VSMC_VMATH_THRESHOLD_Sub VSMC_VMATH_THRESHOLD

Definition at line 65 of file vmath.hpp.

#define VSMC_VMATH_THRESHOLD_Tan VSMC_VMATH_THRESHOLD

Definition at line 161 of file vmath.hpp.

#define VSMC_VMATH_THRESHOLD_Tanh VSMC_VMATH_THRESHOLD

Definition at line 189 of file vmath.hpp.

#define VSMC_VMATH_THRESHOLD_TGamma VSMC_VMATH_THRESHOLD

Definition at line 233 of file vmath.hpp.

Namespaces

Macros

Functions

Macro Definition Documentation