#include <mckl/internal/config.h>
#include <mckl/internal/assert.hpp>
#include <mckl/math/constants.hpp>
#include <mckl/math/erf.hpp>
#include <algorithm>
#include <array>
#include <cmath>
#include <complex>
#include <mkl_vml.h>

Namespaces
	mckl

	mckl::internal

Macros
#define	MCKL_DEFINE_MATH_VMF_1(func, name)

#define	MCKL_DEFINE_MATH_VMF_2(func, name)

#define	MCKL_DEFINE_MATH_VMF_2SV(func, name)

#define	MCKL_DEFINE_MATH_VMF_2VS(func, name)

#define	MCKL_DEFINE_MATH_VMF_B(op, name)

#define	MCKL_DEFINE_MATH_VMF_BSV(op, name)

#define	MCKL_DEFINE_MATH_VMF_BVS(op, name)

#define	MCKL_DEFINE_MATH_VMF_FMA(op, name, attr)

#define	MCKL_DEFINE_MATH_VMF_FPCLASSIFY_COUNT(func, test)

#define	MCKL_DEFINE_MATH_VMF_FPCLASSIFY_FIND(func, test)

#define	MCKL_DEFINE_MATH_VMF_VML_1C(func, name)

#define	MCKL_DEFINE_MATH_VMF_VML_1R(func, name)

#define	MCKL_DEFINE_MATH_VMF_VML_2C(func, name)

#define	MCKL_DEFINE_MATH_VMF_VML_2R(func, name)

Functions
template<typename T >
bool	mckl::internal::__issubnormal (T a)

template<typename T >
bool	mckl::internal::__iszero (T a)

void	mckl::abs (std::size_t n, const float a, float y)

void	mckl::abs (std::size_t n, const double a, double y)

void	mckl::abs (std::size_t n, const std::complex< float > a, float y)

void	mckl::abs (std::size_t n, const std::complex< double > a, double y)

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

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

void	mckl::acos (std::size_t n, const float a, float y)

void	mckl::acos (std::size_t n, const double a, double y)

void	mckl::acos (std::size_t n, const std::complex< float > a, std::complex< float > y)

void	mckl::acos (std::size_t n, const std::complex< double > a, std::complex< double > y)

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

void	mckl::acosh (std::size_t n, const float a, float y)

void	mckl::acosh (std::size_t n, const double a, double y)

void	mckl::acosh (std::size_t n, const std::complex< float > a, std::complex< float > y)

void	mckl::acosh (std::size_t n, const std::complex< double > a, std::complex< double > y)

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

void	mckl::acospi (std::size_t n, const double a, double y)

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

void	mckl::add (std::size_t n, const double a, const double b, double *y)

void	mckl::add (std::size_t n, const float a, const float b, float *y)

void	mckl::add (std::size_t n, const std::complex< double > a, const std::complex< double > b, std::complex< double > *y)

void	mckl::add (std::size_t n, const std::complex< float > a, const std::complex< float > b, std::complex< float > *y)

template<typename T >
void	mckl::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 >
T	mckl::add (T a, T b)

template<typename T >
void	mckl::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	mckl::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	mckl::arg (std::size_t n, const std::complex< float > a, float y)

void	mckl::arg (std::size_t n, const std::complex< double > a, double y)

template<typename T >
void	mckl::arg (std::size_t n, const std::complex< T > a, T y)
	For \(i=1,\ldots,n\), compute \(y_i = \arg(a_i)\). More...

void	mckl::asin (std::size_t n, const float a, float y)

void	mckl::asin (std::size_t n, const double a, double y)

void	mckl::asin (std::size_t n, const std::complex< float > a, std::complex< float > y)

void	mckl::asin (std::size_t n, const std::complex< double > a, std::complex< double > y)

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

void	mckl::asinh (std::size_t n, const float a, float y)

void	mckl::asinh (std::size_t n, const double a, double y)

void	mckl::asinh (std::size_t n, const std::complex< float > a, std::complex< float > y)

void	mckl::asinh (std::size_t n, const std::complex< double > a, std::complex< double > y)

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

void	mckl::asinpi (std::size_t n, const double a, double y)

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

void	mckl::atan (std::size_t n, const float a, float y)

void	mckl::atan (std::size_t n, const double a, double y)

void	mckl::atan (std::size_t n, const std::complex< float > a, std::complex< float > y)

void	mckl::atan (std::size_t n, const std::complex< double > a, std::complex< double > y)

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

void	mckl::atan2 (std::size_t n, const double a, const double b, double *y)

void	mckl::atan2 (std::size_t n, const float a, const float b, float *y)

template<typename T >
void	mckl::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...

template<typename T >
void	mckl::atan2 (std::size_t n, const T a, T b, T y)
	For \(i=1,\ldots,n\), compute \(y_i = \arctan(a_i / b)\) with signs to determine the quadrant. More...

template<typename T >
void	mckl::atan2 (std::size_t n, T a, const T b, T y)
	For \(i=1,\ldots,n\), compute \(y_i = \arctan(a / b_i)\) with signs to determine the quadrant. More...

void	mckl::atan2pi (std::size_t n, const float a, const float b, float *y)

void	mckl::atan2pi (std::size_t n, const double a, const double b, double *y)

template<typename T >
void	mckl::atan2pi (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) / \pi\) with signs to determine the quadrant. More...

template<typename T >
void	mckl::atan2pi (std::size_t n, const T a, T b, T y)
	For \(i=1,\ldots,n\), compute \(y_i = \arctan(a_i / b) / \pi\) with signs to determine the quadrant. More...

template<typename T >
void	mckl::atan2pi (std::size_t n, T a, const T b, T y)
	For \(i=1,\ldots,n\), compute \(y_i = \arctan(a / b_i) / \pi\) with signs to determine the quadrant. More...

void	mckl::atanh (std::size_t n, const float a, float y)

void	mckl::atanh (std::size_t n, const double a, double y)

void	mckl::atanh (std::size_t n, const std::complex< float > a, std::complex< float > y)

void	mckl::atanh (std::size_t n, const std::complex< double > a, std::complex< double > y)

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

void	mckl::atanpi (std::size_t n, const float a, float y)

void	mckl::atanpi (std::size_t n, const double a, double y)

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

void	mckl::cbrt (std::size_t n, const float a, float y)

void	mckl::cbrt (std::size_t n, const double a, double y)

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

void	mckl::cdfnorm (std::size_t n, const float a, float y)

void	mckl::cdfnorm (std::size_t n, const double a, double y)

template<typename T >
T	mckl::cdfnorm (T a)

template<typename T >
void	mckl::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\). More...

void	mckl::cdfnorminv (std::size_t n, const float a, float y)

void	mckl::cdfnorminv (std::size_t n, const double a, double y)

template<typename T >
T	mckl::cdfnorminv (T a)

template<typename T >
void	mckl::cdfnorminv (std::size_t n, const T a, T y)
	For \(i=1,\ldots,n\), compute \(y_i = \sqrt{2}\mathrm{erfc}^{-1}(2 - 2a_i)\). More...

void	mckl::ceil (std::size_t n, const float a, float y)

void	mckl::ceil (std::size_t n, const double a, double y)

template<typename T >
void	mckl::ceil (std::size_t n, const T a, T y)
	For \(i=1,\ldots,n\), compute \(y_i = \lceil a_i \rceil\). More...

void	mckl::cis (std::size_t n, const float a, std::complex< float > y)

void	mckl::cis (std::size_t n, const double a, std::complex< double > y)

template<typename T >
void	mckl::cis (std::size_t n, const T a, std::complex< T > y)
	For \(i=1,\ldots,n\), compute \(y_i = \cos(a_i) + i\sin(a_i)\). More...

void	mckl::conj (std::size_t n, const std::complex< float > a, std::complex< float > y)

void	mckl::conj (std::size_t n, const std::complex< double > a, std::complex< double > y)

template<typename T >
void	mckl::conj (std::size_t n, const T a, T y)
	For \(i=1,\ldots,n\), compute \(y_i = \bar{a}_i\). More...

void	mckl::cos (std::size_t n, const float a, float y)

void	mckl::cos (std::size_t n, const double a, double y)

void	mckl::cos (std::size_t n, const std::complex< float > a, std::complex< float > y)

void	mckl::cos (std::size_t n, const std::complex< double > a, std::complex< double > y)

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

void	mckl::cosd (std::size_t n, const float a, float y)

void	mckl::cosd (std::size_t n, const double a, double y)

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

void	mckl::cosh (std::size_t n, const float a, float y)

void	mckl::cosh (std::size_t n, const double a, double y)

void	mckl::cosh (std::size_t n, const std::complex< float > a, std::complex< float > y)

void	mckl::cosh (std::size_t n, const std::complex< double > a, std::complex< double > y)

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

void	mckl::cospi (std::size_t n, const float a, float y)

void	mckl::cospi (std::size_t n, const double a, double y)

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

template<typename T >
std::size_t	mckl::count_finite (std::size_t n, const T *a)
	Return the number of elements that are finite. More...

template<typename T >
std::size_t	mckl::count_finite (std::size_t n, const std::complex< T > *a)

template<typename T >
std::size_t	mckl::count_inf (std::size_t n, const T *a)
	Return the number of elements that are infinity. More...

template<typename T >
std::size_t	mckl::count_inf (std::size_t n, const std::complex< T > *a)

template<typename T >
std::size_t	mckl::count_nan (std::size_t n, const std::complex< T > *a)

template<typename T >
std::size_t	mckl::count_nan (std::size_t n, const T *a)
	Return the number of elements that are nan. More...

template<typename T >
std::size_t	mckl::count_normal (std::size_t n, const T *a)
	Return the number of elements that are normal. More...

template<typename T >
std::size_t	mckl::count_normal (std::size_t n, const std::complex< T > *a)

template<typename T >
std::size_t	mckl::count_not_finite (std::size_t n, const std::complex< T > *a)

template<typename T >
std::size_t	mckl::count_not_finite (std::size_t n, const T *a)
	Return the number of elements that are not finite. More...

template<typename T >
std::size_t	mckl::count_not_inf (std::size_t n, const T *a)
	Return the number of elements that are not infinity. More...

template<typename T >
std::size_t	mckl::count_not_inf (std::size_t n, const std::complex< T > *a)

template<typename T >
std::size_t	mckl::count_not_nan (std::size_t n, const T *a)
	Return the number of elements that are not nan. More...

template<typename T >
std::size_t	mckl::count_not_nan (std::size_t n, const std::complex< T > *a)

template<typename T >
std::size_t	mckl::count_not_normal (std::size_t n, const T *a)
	Return the number of elements that are not normal. More...

template<typename T >
std::size_t	mckl::count_not_normal (std::size_t n, const std::complex< T > *a)

template<typename T >
std::size_t	mckl::count_not_subnormal (std::size_t n, const T *a)
	Return the number of elements that are not subnormal. More...

template<typename T >
std::size_t	mckl::count_not_subnormal (std::size_t n, const std::complex< T > *a)

template<typename T >
std::size_t	mckl::count_not_zero (std::size_t n, const std::complex< T > *a)

template<typename T >
std::size_t	mckl::count_not_zero (std::size_t n, const T *a)
	Return the number of elements that are not zero. More...

template<typename T >
std::size_t	mckl::count_subnormal (std::size_t n, const T *a)
	Return the number of elements that are subnormal. More...

template<typename T >
std::size_t	mckl::count_subnormal (std::size_t n, const std::complex< T > *a)

template<typename T >
std::size_t	mckl::count_zero (std::size_t n, const std::complex< T > *a)

template<typename T >
std::size_t	mckl::count_zero (std::size_t n, const T *a)
	Return the number of elements that are zero. More...

void	mckl::div (std::size_t n, const float a, const float b, float *y)

void	mckl::div (std::size_t n, const double a, const double b, double *y)

void	mckl::div (std::size_t n, const std::complex< double > a, const std::complex< double > b, std::complex< double > *y)

void	mckl::div (std::size_t n, const std::complex< float > a, const std::complex< float > b, std::complex< float > *y)

template<typename T >
void	mckl::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 >
T	mckl::div (T a, T b)

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

void	mckl::erf (std::size_t n, const double a, double y)

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

void	mckl::erfc (std::size_t n, const float a, float y)

void	mckl::erfc (std::size_t n, const double a, double y)

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

void	mckl::erfcinv (std::size_t n, const float a, float y)

void	mckl::erfcinv (std::size_t n, const double a, double y)

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

void	mckl::erfinv (std::size_t n, const float a, float y)

void	mckl::erfinv (std::size_t n, const double a, double y)

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

void	mckl::exp (std::size_t n, const float a, float y)

void	mckl::exp (std::size_t n, const double a, double y)

void	mckl::exp (std::size_t n, const std::complex< float > a, std::complex< float > y)

void	mckl::exp (std::size_t n, const std::complex< double > a, std::complex< double > y)

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

void	mckl::exp10 (std::size_t n, const double a, double y)

void	mckl::exp10 (std::size_t n, const float a, float y)

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

void	mckl::exp2 (std::size_t n, const float a, float y)

void	mckl::exp2 (std::size_t n, const double a, double y)

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

void	mckl::expint1 (std::size_t n, const float a, float y)

void	mckl::expint1 (std::size_t n, const double a, double y)

void	mckl::expm1 (std::size_t n, const float a, float y)

void	mckl::expm1 (std::size_t n, const double a, double y)

template<typename T >
void	mckl::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 T >
std::size_t	mckl::find_finite (std::size_t n, const T *a)
	Return the index of the first element that is finite. More...

template<typename T >
std::size_t	mckl::find_finite (std::size_t n, const std::complex< T > *a)

template<typename T >
std::size_t	mckl::find_inf (std::size_t n, const T *a)
	Return the index of the first element that is infinity. More...

template<typename T >
std::size_t	mckl::find_inf (std::size_t n, const std::complex< T > *a)

template<typename T >
std::size_t	mckl::find_nan (std::size_t n, const std::complex< T > *a)

template<typename T >
std::size_t	mckl::find_nan (std::size_t n, const T *a)
	Return the index of the first element that is nan. More...

template<typename T >
std::size_t	mckl::find_normal (std::size_t n, const std::complex< T > *a)

template<typename T >
std::size_t	mckl::find_normal (std::size_t n, const T *a)
	Return the index of the first element that is normal. More...

template<typename T >
std::size_t	mckl::find_not_finite (std::size_t n, const std::complex< T > *a)

template<typename T >
std::size_t	mckl::find_not_finite (std::size_t n, const T *a)
	Return the index of the first element that is not finite. More...

template<typename T >
std::size_t	mckl::find_not_inf (std::size_t n, const T *a)
	Return the index of the first element that is not infinity. More...

template<typename T >
std::size_t	mckl::find_not_inf (std::size_t n, const std::complex< T > *a)

template<typename T >
std::size_t	mckl::find_not_nan (std::size_t n, const T *a)
	Return the index of the first element that is not nan. More...

template<typename T >
std::size_t	mckl::find_not_nan (std::size_t n, const std::complex< T > *a)

template<typename T >
std::size_t	mckl::find_not_normal (std::size_t n, const std::complex< T > *a)

template<typename T >
std::size_t	mckl::find_not_normal (std::size_t n, const T *a)
	Return the index of the first element that is not normal. More...

template<typename T >
std::size_t	mckl::find_not_subnormal (std::size_t n, const T *a)
	Return the index of the first element that is not subnormal. More...

template<typename T >
std::size_t	mckl::find_not_subnormal (std::size_t n, const std::complex< T > *a)

template<typename T >
std::size_t	mckl::find_not_zero (std::size_t n, const T *a)
	Return the index of the first element that is not zero. More...

template<typename T >
std::size_t	mckl::find_not_zero (std::size_t n, const std::complex< T > *a)

template<typename T >
std::size_t	mckl::find_subnormal (std::size_t n, const T *a)
	Return the index of the first element that is subnormal. More...

template<typename T >
std::size_t	mckl::find_subnormal (std::size_t n, const std::complex< T > *a)

template<typename T >
std::size_t	mckl::find_zero (std::size_t n, const T *a)
	Return the index of the first element that is zero. More...

template<typename T >
std::size_t	mckl::find_zero (std::size_t n, const std::complex< T > *a)

void	mckl::floor (std::size_t n, const float a, float y)

void	mckl::floor (std::size_t n, const double a, double y)

template<typename T >
void	mckl::floor (std::size_t n, const T a, T y)
	For \(i=1,\ldots,n\), compute \(y_i = \lfloor a_i \rfloor\). More...

template<typename T >
void	mckl::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	mckl::fma (std::size_t n, const T a, const T b, T c, T *y)

template<typename T >
void	mckl::fma (std::size_t n, const T a, T b, const T c, T *y)

template<typename T >
void	mckl::fma (std::size_t n, T a, const T b, const T c, T *y)

template<typename T >
void	mckl::fma (std::size_t n, T a, T b, const T c, T y)

template<typename T >
void	mckl::fma (std::size_t n, T a, const T b, T c, T y)

template<typename T >
void	mckl::fma (std::size_t n, const T a, T b, T c, T y)

template<typename T >
T	mckl::fmadd (T a, T b, T c)

template<typename T >
void	mckl::fmadd (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	mckl::fmadd (std::size_t n, const T a, const T b, T c, T *y)

template<typename T >
void	mckl::fmadd (std::size_t n, const T a, T b, const T c, T *y)

template<typename T >
void	mckl::fmadd (std::size_t n, T a, const T b, const T c, T *y)

template<typename T >
void	mckl::fmadd (std::size_t n, T a, const T b, T c, T y)

template<typename T >
void	mckl::fmadd (std::size_t n, const T a, T b, T c, T y)

template<typename T >
void	mckl::fmadd (std::size_t n, T a, T b, const T c, T y)

template<typename T >
T	mckl::fmsub (T a, T b, T c)

template<typename T >
void	mckl::fmsub (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	mckl::fmsub (std::size_t n, const T a, T b, const T c, T *y)

template<typename T >
void	mckl::fmsub (std::size_t n, T a, const T b, const T c, T *y)

template<typename T >
void	mckl::fmsub (std::size_t n, T a, T b, const T c, T y)

template<typename T >
void	mckl::fmsub (std::size_t n, const T a, T b, T c, T y)

template<typename T >
void	mckl::fmsub (std::size_t n, T a, const T b, T c, T y)

template<typename T >
void	mckl::fmsub (std::size_t n, const T a, const T b, T c, T *y)

template<typename T >
T	mckl::fnmadd (T a, T b, T c)

template<typename T >
void	mckl::fnmadd (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	mckl::fnmadd (std::size_t n, const T a, const T b, T c, T *y)

template<typename T >
void	mckl::fnmadd (std::size_t n, const T a, T b, const T c, T *y)

template<typename T >
void	mckl::fnmadd (std::size_t n, T a, const T b, const T c, T *y)

template<typename T >
void	mckl::fnmadd (std::size_t n, T a, T b, const T c, T y)

template<typename T >
void	mckl::fnmadd (std::size_t n, T a, const T b, T c, T y)

template<typename T >
void	mckl::fnmadd (std::size_t n, const T a, T b, T c, T y)

template<typename T >
T	mckl::fnmsub (T a, T b, T c)

template<typename T >
void	mckl::fnmsub (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	mckl::fnmsub (std::size_t n, const T a, const T b, T c, T *y)

template<typename T >
void	mckl::fnmsub (std::size_t n, const T a, T b, const T c, T *y)

template<typename T >
void	mckl::fnmsub (std::size_t n, T a, T b, const T c, T y)

template<typename T >
void	mckl::fnmsub (std::size_t n, T a, const T b, T c, T y)

template<typename T >
void	mckl::fnmsub (std::size_t n, const T a, T b, T c, T y)

template<typename T >
void	mckl::fnmsub (std::size_t n, T a, const T b, const T c, T *y)

void	mckl::hypot (std::size_t n, const float a, const float b, float *y)

void	mckl::hypot (std::size_t n, const double a, const double b, double *y)

template<typename T >
void	mckl::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 >
void	mckl::hypot (std::size_t n, const T a, T b, T y)
	For \(i=1,\ldots,n\), compute \(y_i = \sqrt{a_i^2 + b^2}\). More...

template<typename T >
void	mckl::hypot (std::size_t n, T a, const T b, T y)
	For \(i=1,\ldots,n\), compute \(y_i = \sqrt{a^2 + b_i^2}\). More...

void	mckl::inv (std::size_t n, const double a, double y)

void	mckl::inv (std::size_t n, const float a, float y)

template<typename T >
T	mckl::inv (T a)

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

void	mckl::invcbrt (std::size_t n, const float a, float y)

void	mckl::invcbrt (std::size_t n, const double a, double y)

template<typename T >
T	mckl::invcbrt (T a)

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

void	mckl::invsqrt (std::size_t n, const double a, double y)

template<typename T >
T	mckl::invsqrt (T a)

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

void	mckl::lgamma (std::size_t n, const double a, double y)

void	mckl::lgamma (std::size_t n, const float a, float y)

template<typename T >
void	mckl::lgamma (std::size_t n, const T a, T y)
	For \(i=1,\ldots,n\), compute \(y_i = \ln\Gamma(a_i)\). More...

void	mckl::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	mckl::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	mckl::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	mckl::log (std::size_t n, const double a, double y)

void	mckl::log (std::size_t n, const float a, float y)

void	mckl::log (std::size_t n, const std::complex< float > a, std::complex< float > y)

void	mckl::log (std::size_t n, const std::complex< double > a, std::complex< double > y)

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

void	mckl::log10 (std::size_t n, const double a, double y)

void	mckl::log10 (std::size_t n, const float a, float y)

void	mckl::log10 (std::size_t n, const std::complex< float > a, std::complex< float > y)

void	mckl::log10 (std::size_t n, const std::complex< double > a, std::complex< double > y)

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

void	mckl::log1p (std::size_t n, const double a, double y)

void	mckl::log1p (std::size_t n, const float a, float y)

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

void	mckl::log2 (std::size_t n, const double a, double y)

void	mckl::log2 (std::size_t n, const float a, float y)

template<typename T >
void	mckl::log2 (std::size_t n, const T a, T y)
	For \(i=1,\ldots,n\), compute \(y_i = \log_2(a_i)\). More...

void	mckl::logb (std::size_t n, const float a, float y)

void	mckl::logb (std::size_t n, const double a, double y)

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

void	mckl::modf (std::size_t n, const float a, float y, float *z)

void	mckl::modf (std::size_t n, const double a, double y, double *z)

template<typename T >
void	mckl::modf (std::size_t n, const T a, T y, T *z)
	For \(i=1,\ldots,n\), compute the integeral and fraction parts. More...

void	mckl::mul (std::size_t n, const float a, const float b, float *y)

void	mckl::mul (std::size_t n, const double a, const double b, double *y)

void	mckl::mul (std::size_t n, const std::complex< float > a, const std::complex< float > b, std::complex< float > *y)

void	mckl::mul (std::size_t n, const std::complex< double > a, const std::complex< double > b, std::complex< double > *y)

template<typename T >
void	mckl::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 >
T	mckl::mul (T a, T b)

template<typename T >
void	mckl::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	mckl::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 T >
T	mckl::muladd (T a, T b, T c)

template<typename T >
void	mckl::muladd (std::size_t n, T a, T b, const T c, T y)

template<typename T >
void	mckl::muladd (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	mckl::muladd (std::size_t n, const T a, const T b, T c, T *y)

template<typename T >
void	mckl::muladd (std::size_t n, const T a, T b, const T c, T *y)

template<typename T >
void	mckl::muladd (std::size_t n, T a, const T b, const T c, T *y)

template<typename T >
void	mckl::muladd (std::size_t n, T a, const T b, T c, T y)

template<typename T >
void	mckl::muladd (std::size_t n, const T a, T b, T c, T y)

void	mckl::mulbyconj (std::size_t n, const std::complex< double > a, const std::complex< double > b, std::complex< double > *y)

void	mckl::mulbyconj (std::size_t n, const std::complex< float > a, const std::complex< float > b, std::complex< float > *y)

template<typename T >
T	mckl::mulbyconj (T a, T b)

template<typename T >
void	mckl::mulbyconj (std::size_t n, const T a, const T b, T *y)
	For \(i=1,\ldots,n\), compute \(y_i = a_i \bar{b}_i\). More...

template<typename T >
void	mckl::mulbyconj (std::size_t n, const T a, T b, T y)
	For \(i=1,\ldots,n\), compute \(y_i = a_i \bar{b}\). More...

template<typename T >
void	mckl::mulbyconj (std::size_t n, T a, const T b, T y)
	For \(i=1,\ldots,n\), compute \(y_i = a \bar{b}_i\). More...

template<typename T >
T	mckl::mulsub (T a, T b, T c)

template<typename T >
void	mckl::mulsub (std::size_t n, T a, const T b, T c, T y)

template<typename T >
void	mckl::mulsub (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	mckl::mulsub (std::size_t n, const T a, const T b, T c, T *y)

template<typename T >
void	mckl::mulsub (std::size_t n, T a, const T b, const T c, T *y)

template<typename T >
void	mckl::mulsub (std::size_t n, const T a, T b, const T c, T *y)

template<typename T >
void	mckl::mulsub (std::size_t n, T a, T b, const T c, T y)

template<typename T >
void	mckl::mulsub (std::size_t n, const T a, T b, T c, T y)

void	mckl::nearbyint (std::size_t n, const float a, float y)

void	mckl::nearbyint (std::size_t n, const double a, double y)

template<typename T >
void	mckl::nearbyint (std::size_t n, const T a, T y)
	For \(i=1,\ldots,n\), compute the nearest integers, using the current rounding mode. More...

template<typename T >
T	mckl::nmuladd (T a, T b, T c)

template<typename T >
void	mckl::nmuladd (std::size_t n, const T a, T b, const T c, T *y)

template<typename T >
void	mckl::nmuladd (std::size_t n, const T a, const T b, T c, T *y)

template<typename T >
void	mckl::nmuladd (std::size_t n, T a, T b, const T c, T y)

template<typename T >
void	mckl::nmuladd (std::size_t n, const T a, T b, T c, T y)

template<typename T >
void	mckl::nmuladd (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	mckl::nmuladd (std::size_t n, T a, const T b, const T c, T *y)

template<typename T >
void	mckl::nmuladd (std::size_t n, T a, const T b, T c, T y)

template<typename T >
T	mckl::nmulsub (T a, T b, T c)

template<typename T >
void	mckl::nmulsub (std::size_t n, T a, T b, const T c, T y)

template<typename T >
void	mckl::nmulsub (std::size_t n, const T a, T b, T c, T y)

template<typename T >
void	mckl::nmulsub (std::size_t n, T a, const T b, T c, T y)

template<typename T >
void	mckl::nmulsub (std::size_t n, T a, const T b, const T c, T *y)

template<typename T >
void	mckl::nmulsub (std::size_t n, const T a, T b, const T c, T *y)

template<typename T >
void	mckl::nmulsub (std::size_t n, const T a, const T b, T c, T *y)

template<typename T >
void	mckl::nmulsub (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...

void	mckl::pow (std::size_t n, const float a, const float b, float *y)

void	mckl::pow (std::size_t n, const double a, const double b, double *y)

void	mckl::pow (std::size_t n, const std::complex< float > a, const std::complex< float > b, std::complex< float > *y)

void	mckl::pow (std::size_t n, const std::complex< double > a, const std::complex< double > b, std::complex< double > *y)

void	mckl::pow (std::size_t n, const float a, float b, float y)

void	mckl::pow (std::size_t n, const double a, double b, double y)

void	mckl::pow (std::size_t n, const std::complex< float > a, std::complex< float > b, std::complex< float > y)

void	mckl::pow (std::size_t n, const std::complex< double > a, std::complex< double > b, std::complex< double > y)

template<typename T >
void	mckl::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	mckl::pow (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	mckl::pow (std::size_t n, T a, const T b, T y)
	For \(i=1,\ldots,n\), compute \(y_i = a^{b_i}\). More...

void	mckl::pow2o3 (std::size_t n, const float a, float y)

void	mckl::pow2o3 (std::size_t n, const double a, double y)

template<typename T >
T	mckl::pow2o3 (T a)

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

void	mckl::pow3o2 (std::size_t n, const double a, double y)

void	mckl::pow3o2 (std::size_t n, const float a, float y)

template<typename T >
T	mckl::pow3o2 (T a)

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

void	mckl::rint (std::size_t n, const float a, float y)

void	mckl::rint (std::size_t n, const double a, double y)

template<typename T >
void	mckl::rint (std::size_t n, const T a, T y)
	For \(i=1,\ldots,n\), compute the nearest integers, using the current rounding mode. More...

void	mckl::round (std::size_t n, const float a, float y)

void	mckl::round (std::size_t n, const double a, double y)

template<typename T >
void	mckl::round (std::size_t n, const T a, T y)
	For \(i=1,\ldots,n\), compute the nearest integers, rounding away from zero. More...

void	mckl::sin (std::size_t n, const double a, double y)

void	mckl::sin (std::size_t n, const float a, float y)

void	mckl::sin (std::size_t n, const std::complex< float > a, std::complex< float > y)

void	mckl::sin (std::size_t n, const std::complex< double > a, std::complex< double > y)

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

void	mckl::sincos (std::size_t n, const float a, float y, float *z)

void	mckl::sincos (std::size_t n, const double a, double y, double *z)

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

void	mckl::sind (std::size_t n, const double a, double y)

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

void	mckl::sinh (std::size_t n, const float a, float y)

void	mckl::sinh (std::size_t n, const double a, double y)

void	mckl::sinh (std::size_t n, const std::complex< double > a, std::complex< double > y)

void	mckl::sinh (std::size_t n, const std::complex< float > a, std::complex< float > y)

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

void	mckl::sinpi (std::size_t n, const float a, float y)

void	mckl::sinpi (std::size_t n, const double a, double y)

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

void	mckl::sqr (std::size_t n, const float a, float y)

void	mckl::sqr (std::size_t n, const double a, double y)

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

void	mckl::sqrt (std::size_t n, const float a, float y)

void	mckl::sqrt (std::size_t n, const double a, double y)

void	mckl::sqrt (std::size_t n, const std::complex< double > a, std::complex< double > y)

void	mckl::sqrt (std::size_t n, const std::complex< float > a, std::complex< float > y)

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

void	mckl::sub (std::size_t n, const double a, const double b, double *y)

void	mckl::sub (std::size_t n, const float a, const float b, float *y)

void	mckl::sub (std::size_t n, const std::complex< float > a, const std::complex< float > b, std::complex< float > *y)

void	mckl::sub (std::size_t n, const std::complex< double > a, const std::complex< double > b, std::complex< double > *y)

template<typename T >
void	mckl::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 >
T	mckl::sub (T a, T b)

template<typename T >
void	mckl::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	mckl::sub (std::size_t n, T a, const T b, T y)
	For \(i=1,\ldots,n\), compute \(y_i = a - b_i\). More...

void	mckl::tan (std::size_t n, const float a, float y)

void	mckl::tan (std::size_t n, const double a, double y)

void	mckl::tan (std::size_t n, const std::complex< float > a, std::complex< float > y)

void	mckl::tan (std::size_t n, const std::complex< double > a, std::complex< double > y)

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

void	mckl::tand (std::size_t n, const float a, float y)

void	mckl::tand (std::size_t n, const double a, double y)

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

void	mckl::tanh (std::size_t n, const double a, double y)

void	mckl::tanh (std::size_t n, const float a, float y)

void	mckl::tanh (std::size_t n, const std::complex< double > a, std::complex< double > y)

void	mckl::tanh (std::size_t n, const std::complex< float > a, std::complex< float > y)

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

void	mckl::tanpi (std::size_t n, const double a, double y)

void	mckl::tanpi (std::size_t n, const float a, float y)

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

void	mckl::tgamma (std::size_t n, const float a, float y)

void	mckl::tgamma (std::size_t n, const double a, double y)

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

void	mckl::trunc (std::size_t n, const double a, double y)

void	mckl::trunc (std::size_t n, const float a, float y)

template<typename T >
void	mckl::trunc (std::size_t n, const T a, T y)
	For \(i=1,\ldots,n\), compute \(y_i = \mathrm{sgn}(a_i)\lfloor\|a_i\|\rfloor\). More...

Macro Definition Documentation

◆ MCKL_DEFINE_MATH_VMF_1

#define MCKL_DEFINE_MATH_VMF_1	(	func,
		name
	)

Value:

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

Definition at line 519 of file vmf.hpp.

◆ MCKL_DEFINE_MATH_VMF_2

#define MCKL_DEFINE_MATH_VMF_2	(	func,
		name
	)

Value:

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

Definition at line 527 of file vmf.hpp.

◆ MCKL_DEFINE_MATH_VMF_2SV

#define MCKL_DEFINE_MATH_VMF_2SV	(	func,
		name
	)

Value:

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

Definition at line 543 of file vmf.hpp.

◆ MCKL_DEFINE_MATH_VMF_2VS

#define MCKL_DEFINE_MATH_VMF_2VS	(	func,
		name
	)

Value:

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

Definition at line 535 of file vmf.hpp.

◆ MCKL_DEFINE_MATH_VMF_B

#define MCKL_DEFINE_MATH_VMF_B	(	op,
		name
	)

Value:

template <typename T>                                                     \
    inline void name(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];                                              \
    }                                                                         \
                                                                              \
    template <typename T>                                                     \
    inline T name(T a, T b)                                                   \
    {                                                                         \
        return a op b;                                                        \
    }

Definition at line 551 of file vmf.hpp.

◆ MCKL_DEFINE_MATH_VMF_BSV

#define MCKL_DEFINE_MATH_VMF_BSV	(	op,
		name
	)

Value:

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

Definition at line 573 of file vmf.hpp.

◆ MCKL_DEFINE_MATH_VMF_BVS

#define MCKL_DEFINE_MATH_VMF_BVS	(	op,
		name
	)

Value:

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

Definition at line 565 of file vmf.hpp.

◆ MCKL_DEFINE_MATH_VMF_FMA

#define MCKL_DEFINE_MATH_VMF_FMA	(	op,
		name,
		attr
	)

Definition at line 581 of file vmf.hpp.

◆ MCKL_DEFINE_MATH_VMF_VML_1C

#define MCKL_DEFINE_MATH_VMF_VML_1C	(	func,
		name
	)

Value:

inline void name(                                                         \
        std::size_t n, const std::complex<float> *a, std::complex<float> *y)  \
    {                                                                         \
        internal::size_check<MKL_INT>(n, #name);                              \
        ::vc##func(static_cast<MKL_INT>(n),                                   \
            reinterpret_cast<const ::MKL_Complex8 *>(a),                      \
            reinterpret_cast<::MKL_Complex8 *>(y));                           \
    }                                                                         \
                                                                              \
    inline void name(std::size_t n, const std::complex<double> *a,            \
        std::complex<double> *y)                                              \
    {                                                                         \
        internal::size_check<MKL_INT>(n, #name);                              \
        ::vz##func(static_cast<MKL_INT>(n),                                   \
            reinterpret_cast<const ::MKL_Complex16 *>(a),                     \
            reinterpret_cast<::MKL_Complex16 *>(y));                          \
    }

Definition at line 63 of file vmf.hpp.

◆ MCKL_DEFINE_MATH_VMF_VML_1R

#define MCKL_DEFINE_MATH_VMF_VML_1R	(	func,
		name
	)

Value:

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

Definition at line 50 of file vmf.hpp.

◆ MCKL_DEFINE_MATH_VMF_VML_2C

#define MCKL_DEFINE_MATH_VMF_VML_2C	(	func,
		name
	)

Value:

inline void name(std::size_t n, const std::complex<float> *a,             \
        const std::complex<float> *b, std::complex<float> *y)                 \
    {                                                                         \
        internal::size_check<MKL_INT>(n, #name);                              \
        ::vc##func(static_cast<MKL_INT>(n),                                   \
            reinterpret_cast<const ::MKL_Complex8 *>(a),                      \
            reinterpret_cast<const ::MKL_Complex8 *>(b),                      \
            reinterpret_cast<::MKL_Complex8 *>(y));                           \
    }                                                                         \
                                                                              \
    inline void name(std::size_t n, const std::complex<double> *a,            \
        const std::complex<double> *b, std::complex<double> *y)               \
    {                                                                         \
        internal::size_check<MKL_INT>(n, #name);                              \
        ::vz##func(static_cast<MKL_INT>(n),                                   \
            reinterpret_cast<const ::MKL_Complex16 *>(a),                     \
            reinterpret_cast<const ::MKL_Complex16 *>(b),                     \
            reinterpret_cast<::MKL_Complex16 *>(y));                          \
    }

Definition at line 96 of file vmf.hpp.

◆ MCKL_DEFINE_MATH_VMF_VML_2R

#define MCKL_DEFINE_MATH_VMF_VML_2R	(	func,
		name
	)

Value:

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

Definition at line 82 of file vmf.hpp.

Namespaces

Macros

Functions

Macro Definition Documentation

◆ MCKL_DEFINE_MATH_VMF_1

◆ MCKL_DEFINE_MATH_VMF_2

◆ MCKL_DEFINE_MATH_VMF_2SV

◆ MCKL_DEFINE_MATH_VMF_2VS

◆ MCKL_DEFINE_MATH_VMF_B

◆ MCKL_DEFINE_MATH_VMF_BSV

◆ MCKL_DEFINE_MATH_VMF_BVS

◆ MCKL_DEFINE_MATH_VMF_FMA

◆ MCKL_DEFINE_MATH_VMF_VML_1C

◆ MCKL_DEFINE_MATH_VMF_VML_1R

◆ MCKL_DEFINE_MATH_VMF_VML_2C

◆ MCKL_DEFINE_MATH_VMF_VML_2R