Eigen::numext Namespace Reference

Classes
struct	equal_strict_impl
struct	equal_strict_impl< X, Y, true, false, true, true >
struct	equal_strict_impl< X, Y, true, true, true, false >
struct	get_integer_by_size
struct	get_integer_by_size< 1 >
struct	get_integer_by_size< 2 >
struct	get_integer_by_size< 4 >
struct	get_integer_by_size< 8 >
struct	signbit_impl
struct	signbit_impl< Scalar, false, true >
struct	signbit_impl< Scalar, true, false >
struct	signbit_impl< Scalar, true, true >

Typedefs
typedef std::int16_t	int16_t
typedef std::int32_t	int32_t
typedef std::int64_t	int64_t
typedef std::int8_t	int8_t
typedef std::uint16_t	uint16_t
typedef std::uint32_t	uint32_t
typedef std::uint64_t	uint64_t
typedef std::uint8_t	uint8_t

Functions
template<typename T >
EIGEN_ALWAYS_INLINE std::enable_if_t< NumTraits< T >::IsSigned||NumTraits< T >::IsComplex, typename NumTraits< T >::Real >	abs (const T &x)
template<typename T >
EIGEN_ALWAYS_INLINE std::enable_if_t<!(NumTraits< T >::IsSigned||NumTraits< T >::IsComplex), typename NumTraits< T >::Real >	abs (const T &x)
bool	abs2 (bool x)
template<>
EIGEN_ALWAYS_INLINE double	absdiff (const double &x, const double &y)
template<>
EIGEN_ALWAYS_INLINE float	absdiff (const float &x, const float &y)
template<>
EIGEN_ALWAYS_INLINE long double	absdiff (const long double &x, const long double &y)
template<typename T >
EIGEN_ALWAYS_INLINE T	absdiff (const T &x, const T &y)
template<typename T >
EIGEN_ALWAYS_INLINE T	acos (const T &x)
template<typename T >
EIGEN_ALWAYS_INLINE T	acosh (const T &x)
template<typename T >
EIGEN_ALWAYS_INLINE T	asin (const T &x)
template<typename T >
EIGEN_ALWAYS_INLINE T	asinh (const T &x)
template<typename T >
EIGEN_ALWAYS_INLINE T	atan (const T &x)
template<typename T , std::enable_if_t<!NumTraits< T >::IsComplex, int > = 0>
EIGEN_ALWAYS_INLINE T	atan2 (const T &y, const T &x)
template<typename T >
EIGEN_ALWAYS_INLINE T	atanh (const T &x)
template<typename Tgt , typename Src >
Tgt	bit_cast (const Src &src)
template<>
Eigen::bfloat16	bit_cast< Eigen::bfloat16, uint16_t > (const uint16_t &src)
template<>
Eigen::half	bit_cast< Eigen::half, uint16_t > (const uint16_t &src)
template<>
uint16_t	bit_cast< uint16_t, Eigen::bfloat16 > (const Eigen::bfloat16 &src)
template<>
uint16_t	bit_cast< uint16_t, Eigen::half > (const Eigen::half &src)
template<typename Scalar >
Scalar()	ceil (const Scalar &x)
template<typename T >
EIGEN_ALWAYS_INLINE T	cos (const T &x)
template<typename T >
EIGEN_ALWAYS_INLINE T	cosh (const T &x)
template<typename T >
T	div_ceil (const T &a, const T &b)
template<typename Scalar >
	EIGEN_MATHFUNC_RETVAL (abs2, Scalar) abs2(const Scalar &x)
template<typename Scalar >
	EIGEN_MATHFUNC_RETVAL (arg, Scalar) arg(const Scalar &x)
template<typename Scalar >
	EIGEN_MATHFUNC_RETVAL (conj, Scalar) conj(const Scalar &x)
template<typename Scalar >
	EIGEN_MATHFUNC_RETVAL (expm1, Scalar) expm1(const Scalar &x)
template<typename Scalar >
	EIGEN_MATHFUNC_RETVAL (hypot, Scalar) hypot(const Scalar &x
template<typename Scalar >
	EIGEN_MATHFUNC_RETVAL (imag, Scalar) imag(const Scalar &x)
template<typename Scalar >
	EIGEN_MATHFUNC_RETVAL (imag_ref, Scalar) imag_ref(Scalar &x)
template<typename Scalar >
	EIGEN_MATHFUNC_RETVAL (log1p, Scalar) log1p(const Scalar &x)
template<typename Scalar >
	EIGEN_MATHFUNC_RETVAL (norm1, Scalar) norm1(const Scalar &x)
template<typename Scalar >
	EIGEN_MATHFUNC_RETVAL (real, Scalar) real(const Scalar &x)
template<typename Scalar >
	EIGEN_MATHFUNC_RETVAL (real_ref, Scalar) real_ref(Scalar &x)
template<typename Scalar >
	EIGEN_MATHFUNC_RETVAL (sign, Scalar) sign(const Scalar &x)
template<typename Scalar >
EIGEN_ALWAYS_INLINE	EIGEN_MATHFUNC_RETVAL (sqrt, Scalar) sqrt(const Scalar &x)
template<>
bool	equal_strict (const double &x, const double &y)
template<>
bool	equal_strict (const float &x, const float &y)
template<typename X , typename Y >
bool	equal_strict (const X &x, const Y &y)
template<typename T >
EIGEN_ALWAYS_INLINE T	exp (const T &x)
template<typename Scalar >
Scalar()	floor (const Scalar &x)
template<typename T >
EIGEN_ALWAYS_INLINE T	fmod (const T &a, const T &b)
template<typename Scalar >
internal::add_const_on_value_type_t< EIGEN_MATHFUNC_RETVAL(imag_ref, Scalar) >	imag_ref (const Scalar &x)
template<typename X >
bool	is_exactly_one (const X &x)
template<typename X >
bool	is_exactly_zero (const X &x)
template<>
EIGEN_ALWAYS_INLINE bool()	isfinite (const Eigen::bfloat16 &h)
template<typename T >
bool()	isfinite (const T &x)
template<>
EIGEN_ALWAYS_INLINE bool()	isinf (const Eigen::bfloat16 &h)
template<typename T >
bool()	isinf (const T &x)
template<>
EIGEN_ALWAYS_INLINE bool()	isnan (const Eigen::bfloat16 &h)
template<typename T >
bool()	isnan (const T &x)
template<typename T >
EIGEN_ALWAYS_INLINE T	log (const T &x)
int	log2 (int x)
template<typename T >
EIGEN_ALWAYS_INLINE T	maxi (const T &x, const T &y)
template<typename T >
EIGEN_ALWAYS_INLINE T	mini (const T &x, const T &y)
template<>
bool	not_equal_strict (const double &x, const double &y)
template<>
bool	not_equal_strict (const float &x, const float &y)
template<typename X , typename Y >
bool	not_equal_strict (const X &x, const Y &y)
template<typename ScalarX , typename ScalarY >
internal::pow_impl< ScalarX, ScalarY >::result_type	pow (const ScalarX &x, const ScalarY &y)
template<typename Scalar >
internal::add_const_on_value_type_t< EIGEN_MATHFUNC_RETVAL(real_ref, Scalar) >	real_ref (const Scalar &x)
template<typename Scalar >
Scalar	rint (const Scalar &x)
template<typename Scalar >
Scalar	round (const Scalar &x)
template<typename T >
EIGEN_ALWAYS_INLINE T	rsqrt (const T &x)
template<typename Scalar >
static constexpr EIGEN_ALWAYS_INLINE Scalar	signbit (const Scalar &x)
template<typename T >
EIGEN_ALWAYS_INLINE T	sin (const T &x)
template<typename T >
EIGEN_ALWAYS_INLINE T	sinh (const T &x)
template<>
EIGEN_ALWAYS_INLINE double	sqrt (const double &x)
template<>
EIGEN_ALWAYS_INLINE float	sqrt (const float &x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS bool	sqrt< bool > (const bool &x)
template<typename T >
void	swap (T &a, T &b)
template<typename T >
EIGEN_ALWAYS_INLINE T	tan (const T &x)
template<typename T >
EIGEN_ALWAYS_INLINE T	tanh (const T &x)

Variables
const Scalar &	y

Detailed Description

Generic math functions *

Typedef Documentation

int16_t

typedef std::int16_t Eigen::numext::int16_t

Definition at line 38 of file Meta.h.

int32_t

typedef std::int32_t Eigen::numext::int32_t

Definition at line 40 of file Meta.h.

int64_t

typedef std::int64_t Eigen::numext::int64_t

Definition at line 42 of file Meta.h.

int8_t

typedef std::int8_t Eigen::numext::int8_t

Definition at line 36 of file Meta.h.

uint16_t

typedef std::uint16_t Eigen::numext::uint16_t

Definition at line 37 of file Meta.h.

uint32_t

typedef std::uint32_t Eigen::numext::uint32_t

Definition at line 39 of file Meta.h.

uint64_t

typedef std::uint64_t Eigen::numext::uint64_t

Definition at line 41 of file Meta.h.

uint8_t

typedef std::uint8_t Eigen::numext::uint8_t

Definition at line 35 of file Meta.h.

Function Documentation

abs() [1/2]

template<typename T >

EIGEN_ALWAYS_INLINE std::enable_if_t<NumTraits<T>::IsSigned || NumTraits<T>::IsComplex,typename NumTraits<T>::Real> Eigen::numext::abs

(

const T &

x

)

Definition at line 1413 of file MathFunctions.h.

                {
  EIGEN_USING_STD(abs);
  return abs(x);
}

abs() [2/2]

template<typename T >

EIGEN_ALWAYS_INLINE std::enable_if_t<!(NumTraits<T>::IsSigned || NumTraits<T>::IsComplex),typename NumTraits<T>::Real> Eigen::numext::abs

(

const T &

x

)

Definition at line 1421 of file MathFunctions.h.

                {
  return x;
}

abs2()

bool Eigen::numext::abs2 ( bool  x )

inline

Definition at line 1198 of file MathFunctions.h.

{ return x; }

absdiff() [1/4]

template<>

EIGEN_ALWAYS_INLINE double Eigen::numext::absdiff	(	const double &	x,
		const double &	y
	)

Definition at line 1214 of file MathFunctions.h.

{
  return fabs(x - y);
}

absdiff() [2/4]

template<>

EIGEN_ALWAYS_INLINE float Eigen::numext::absdiff	(	const float &	x,
		const float &	y
	)

Definition at line 1208 of file MathFunctions.h.

{
  return fabsf(x - y);
}

absdiff() [3/4]

template<>

EIGEN_ALWAYS_INLINE long double Eigen::numext::absdiff	(	const long double &	x,
		const long double &	y
	)

Definition at line 1223 of file MathFunctions.h.

                                                                                    {
  return fabsl(x - y);
}

absdiff() [4/4]

template<typename T >

EIGEN_ALWAYS_INLINE T Eigen::numext::absdiff	(	const T &	x,
		const T &	y
	)

Definition at line 1202 of file MathFunctions.h.

{
  return x > y ? x - y : y - x;
}

acos()

template<typename T >

EIGEN_ALWAYS_INLINE T Eigen::numext::acos

(

const T &

x

)

Definition at line 1592 of file MathFunctions.h.

                   {
  EIGEN_USING_STD(acos);
  return acos(x);
}

acosh()

template<typename T >

EIGEN_ALWAYS_INLINE T Eigen::numext::acosh

(

const T &

x

)

Definition at line 1599 of file MathFunctions.h.

                    {
  EIGEN_USING_STD(acosh);
  return static_cast<T>(acosh(x));
}

asin()

template<typename T >

EIGEN_ALWAYS_INLINE T Eigen::numext::asin

(

const T &

x

)

Definition at line 1619 of file MathFunctions.h.

                   {
  EIGEN_USING_STD(asin);
  return asin(x);
}

asinh()

template<typename T >

EIGEN_ALWAYS_INLINE T Eigen::numext::asinh

(

const T &

x

)

Definition at line 1626 of file MathFunctions.h.

                    {
  EIGEN_USING_STD(asinh);
  return static_cast<T>(asinh(x));
}

atan()

template<typename T >

EIGEN_ALWAYS_INLINE T Eigen::numext::atan

(

const T &

x

)

Definition at line 1646 of file MathFunctions.h.

                   {
  EIGEN_USING_STD(atan);
  return static_cast<T>(atan(x));
}

atan2()

template<typename T , std::enable_if_t<!NumTraits< T >::IsComplex, int > = 0>

EIGEN_ALWAYS_INLINE T Eigen::numext::atan2	(	const T &	y,
		const T &	x
	)

Definition at line 1652 of file MathFunctions.h.

                                                                      {
  EIGEN_USING_STD(atan2);
  return static_cast<T>(atan2(y, x));
}

atanh()

template<typename T >

EIGEN_ALWAYS_INLINE T Eigen::numext::atanh

(

const T &

x

)

Definition at line 1659 of file MathFunctions.h.

                    {
  EIGEN_USING_STD(atanh);
  return static_cast<T>(atanh(x));
}

bit_cast()

template<typename Tgt , typename Src >

Tgt Eigen::numext::bit_cast ( const Src &  src )

inline

Definition at line 87 of file NumTraits.h.

                                                                   {
  // The behaviour of memcpy is not specified for non-trivially copyable types
  EIGEN_STATIC_ASSERT(std::is_trivially_copyable<Src>::value, THIS_TYPE_IS_NOT_SUPPORTED);
  EIGEN_STATIC_ASSERT(std::is_trivially_copyable<Tgt>::value && std::is_default_constructible<Tgt>::value,
                      THIS_TYPE_IS_NOT_SUPPORTED);
  EIGEN_STATIC_ASSERT(sizeof(Src) == sizeof(Tgt), THIS_TYPE_IS_NOT_SUPPORTED);
 
  Tgt tgt;
  // Load src into registers first. This allows the memcpy to be elided by CUDA.
  const Src staged = src;
  EIGEN_USING_STD(memcpy)
  memcpy(static_cast<void*>(&tgt),static_cast<const void*>(&staged), sizeof(Tgt));
  return tgt;
}

bit_cast< Eigen::bfloat16, uint16_t >()

template<>

Eigen::bfloat16 Eigen::numext::bit_cast< Eigen::bfloat16, uint16_t > ( const uint16_t &  src )

inline

Definition at line 795 of file BFloat16.h.

                                                                                                           {
  return Eigen::bfloat16_impl::raw_uint16_to_bfloat16(src);
}

bit_cast< Eigen::half, uint16_t >()

template<>

Eigen::half Eigen::numext::bit_cast< Eigen::half, uint16_t > ( const uint16_t &  src )

inline

Definition at line 925 of file Half.h.

                                                                                                   {
  return Eigen::half(Eigen::half_impl::raw_uint16_to_half(src));
}

bit_cast< uint16_t, Eigen::bfloat16 >()

template<>

uint16_t Eigen::numext::bit_cast< uint16_t, Eigen::bfloat16 > ( const Eigen::bfloat16 &  src )

inline

Definition at line 800 of file BFloat16.h.

                                                                                                           {
  return Eigen::bfloat16_impl::raw_bfloat16_as_uint16(src);
}

bit_cast< uint16_t, Eigen::half >()

template<>

uint16_t Eigen::numext::bit_cast< uint16_t, Eigen::half > ( const Eigen::half &  src )

inline

Definition at line 930 of file Half.h.

                                                                                                   {
  return Eigen::half_impl::raw_half_as_uint16(src);
}

ceil()

template<typename Scalar >

Scalar() Eigen::numext::ceil ( const Scalar &  x )

inline

Definition at line 1325 of file MathFunctions.h.

{
  return internal::nearest_integer_impl<Scalar>::run_ceil(x);
}

cos()

template<typename T >

EIGEN_ALWAYS_INLINE T Eigen::numext::cos

(

const T &

x

)

Definition at line 1535 of file MathFunctions.h.

                  {
  EIGEN_USING_STD(cos);
  return cos(x);
}

cosh()

template<typename T >

EIGEN_ALWAYS_INLINE T Eigen::numext::cosh

(

const T &

x

)

Definition at line 1680 of file MathFunctions.h.

                   {
  EIGEN_USING_STD(cosh);
  return static_cast<T>(cosh(x));
}

div_ceil()

template<typename T >

T Eigen::numext::div_ceil	(	const T &	a,
		const T &	b
	)

Definition at line 428 of file Meta.h.

{
  return (a+b-1) / b;
}

EIGEN_MATHFUNC_RETVAL() [1/13]

template<typename Scalar >

Eigen::numext::EIGEN_MATHFUNC_RETVAL ( abs2  , Scalar    ) const &

inline

Definition at line 1192 of file MathFunctions.h.

{
  return EIGEN_MATHFUNC_IMPL(abs2, Scalar)::run(x);
}

EIGEN_MATHFUNC_RETVAL() [2/13]

template<typename Scalar >

Eigen::numext::EIGEN_MATHFUNC_RETVAL ( arg  , Scalar    ) const &

inline

Definition at line 1157 of file MathFunctions.h.

{
  return EIGEN_MATHFUNC_IMPL(arg, Scalar)::run(x);
}

EIGEN_MATHFUNC_RETVAL() [3/13]

template<typename Scalar >

Eigen::numext::EIGEN_MATHFUNC_RETVAL ( conj  , Scalar    ) const &

inline

Definition at line 1178 of file MathFunctions.h.

{
  return EIGEN_MATHFUNC_IMPL(conj, Scalar)::run(x);
}

EIGEN_MATHFUNC_RETVAL() [4/13]

template<typename Scalar >

Eigen::numext::EIGEN_MATHFUNC_RETVAL ( expm1  , Scalar    ) const &

inline

Definition at line 1516 of file MathFunctions.h.

{
  return EIGEN_MATHFUNC_IMPL(expm1, Scalar)::run(x);
}

EIGEN_MATHFUNC_RETVAL() [5/13]

template<typename Scalar >

Eigen::numext::EIGEN_MATHFUNC_RETVAL ( hypot  , Scalar    ) const &

inline

EIGEN_MATHFUNC_RETVAL() [6/13]

template<typename Scalar >

Eigen::numext::EIGEN_MATHFUNC_RETVAL ( imag  , Scalar    ) const &

inline

Definition at line 1150 of file MathFunctions.h.

{
  return EIGEN_MATHFUNC_IMPL(imag, Scalar)::run(x);
}

EIGEN_MATHFUNC_RETVAL() [7/13]

template<typename Scalar >

Eigen::numext::EIGEN_MATHFUNC_RETVAL ( imag_ref  , Scalar    ) &

inline

Definition at line 1171 of file MathFunctions.h.

{
  return EIGEN_MATHFUNC_IMPL(imag_ref, Scalar)::run(x);
}

EIGEN_MATHFUNC_RETVAL() [8/13]

template<typename Scalar >

Eigen::numext::EIGEN_MATHFUNC_RETVAL ( log1p  , Scalar    ) const &

inline

Definition at line 1248 of file MathFunctions.h.

{
  return EIGEN_MATHFUNC_IMPL(log1p, Scalar)::run(x);
}

EIGEN_MATHFUNC_RETVAL() [9/13]

template<typename Scalar >

Eigen::numext::EIGEN_MATHFUNC_RETVAL ( norm1  , Scalar    ) const &

inline

Definition at line 1230 of file MathFunctions.h.

{
  return EIGEN_MATHFUNC_IMPL(norm1, Scalar)::run(x);
}

EIGEN_MATHFUNC_RETVAL() [10/13]

template<typename Scalar >

Eigen::numext::EIGEN_MATHFUNC_RETVAL ( real  , Scalar    ) const &

inline

Definition at line 1129 of file MathFunctions.h.

{
  return EIGEN_MATHFUNC_IMPL(real, Scalar)::run(x);
}

EIGEN_MATHFUNC_RETVAL() [11/13]

template<typename Scalar >

Eigen::numext::EIGEN_MATHFUNC_RETVAL ( real_ref  , Scalar    ) &

inline

Definition at line 1143 of file MathFunctions.h.

{
  return EIGEN_MATHFUNC_IMPL(real_ref, Scalar)::run(x);
}

EIGEN_MATHFUNC_RETVAL() [12/13]

template<typename Scalar >

Eigen::numext::EIGEN_MATHFUNC_RETVAL ( sign  , Scalar    ) const &

inline

Definition at line 1185 of file MathFunctions.h.

{
  return EIGEN_MATHFUNC_IMPL(sign, Scalar)::run(x);
}

EIGEN_MATHFUNC_RETVAL() [13/13]

template<typename Scalar >

EIGEN_ALWAYS_INLINE Eigen::numext::EIGEN_MATHFUNC_RETVAL	(	sqrt	,
		Scalar
	)		const &

Returns

the square root of x.

It is essentially equivalent to

using std::sqrt; return sqrt(x); 

but slightly faster for float/double and some compilers (e.g., gcc), thanks to specializations when SSE is enabled.

It's usage is justified in performance critical functions, like norm/normalize.

Definition at line 1369 of file MathFunctions.h.

{
  return EIGEN_MATHFUNC_IMPL(sqrt, Scalar)::run(x);
}

equal_strict() [1/3]

template<>

bool Eigen::numext::equal_strict ( const double &  x, const double &  y  )

inline

Definition at line 467 of file Meta.h.

{ return std::equal_to<double>()(x,y); }

equal_strict() [2/3]

template<>

bool Eigen::numext::equal_strict ( const float &  x, const float &  y  )

inline

Definition at line 464 of file Meta.h.

{ return std::equal_to<float>()(x,y); }

equal_strict() [3/3]

template<typename X , typename Y >

bool Eigen::numext::equal_strict ( const X &  x, const Y &  y  )

inline

Definition at line 460 of file Meta.h.

{ return equal_strict_impl<X, Y>::run(x, y); }

exp()

template<typename T >

EIGEN_ALWAYS_INLINE T Eigen::numext::exp

(

const T &

x

)

Definition at line 1481 of file MathFunctions.h.

                  {
  EIGEN_USING_STD(exp);
  return exp(x);
}

floor()

template<typename Scalar >

Scalar() Eigen::numext::floor ( const Scalar &  x )

inline

Definition at line 1306 of file MathFunctions.h.

{
  return internal::nearest_integer_impl<Scalar>::run_floor(x);
}

fmod()

template<typename T >

EIGEN_ALWAYS_INLINE T Eigen::numext::fmod	(	const T &	a,
		const T &	b
	)

Definition at line 1742 of file MathFunctions.h.

                               {
  EIGEN_USING_STD(fmod);
  return fmod(a, b);
}

imag_ref()

template<typename Scalar >

internal::add_const_on_value_type_t< EIGEN_MATHFUNC_RETVAL(imag_ref, Scalar) > Eigen::numext::imag_ref ( const Scalar &  x )

inline

Definition at line 1164 of file MathFunctions.h.

{
  return internal::imag_ref_impl<Scalar>::run(x);
}

is_exactly_one()

template<typename X >

bool Eigen::numext::is_exactly_one ( const X &  x )

inline

Definition at line 482 of file Meta.h.

{ return equal_strict(x, typename NumTraits<X>::Literal{1}); }

is_exactly_zero()

template<typename X >

bool Eigen::numext::is_exactly_zero ( const X &  x )

inline

Definition at line 475 of file Meta.h.

{ return equal_strict(x, typename NumTraits<X>::Literal{0}); }

isfinite() [1/2]

template<>

EIGEN_ALWAYS_INLINE bool() Eigen::numext::isfinite

(

const Eigen::bfloat16 &

h

)

Definition at line 790 of file BFloat16.h.

                                        {
  return (bfloat16_impl::isfinite)(h);
}

isfinite() [2/2]

template<typename T >

bool() Eigen::numext::isfinite

(

const T &

x

)

Definition at line 1278 of file MathFunctions.h.

{ return internal::isfinite_impl(x); }

isinf() [1/2]

template<>

EIGEN_ALWAYS_INLINE bool() Eigen::numext::isinf

(

const Eigen::bfloat16 &

h

)

Definition at line 784 of file BFloat16.h.

                                     {
  return (bfloat16_impl::isinf)(h);
}

isinf() [2/2]

template<typename T >

bool() Eigen::numext::isinf

(

const T &

x

)

Definition at line 1277 of file MathFunctions.h.

{ return internal::isinf_impl(x); }

isnan() [1/2]

template<>

EIGEN_ALWAYS_INLINE bool() Eigen::numext::isnan

(

const Eigen::bfloat16 &

h

)

Definition at line 778 of file BFloat16.h.

                                     {
  return (bfloat16_impl::isnan)(h);
}

isnan() [2/2]

template<typename T >

bool() Eigen::numext::isnan

(

const T &

x

)

Definition at line 1276 of file MathFunctions.h.

{ return internal::isnan_impl(x); }

log()

template<typename T >

EIGEN_ALWAYS_INLINE T Eigen::numext::log

(

const T &

x

)

Definition at line 1393 of file MathFunctions.h.

                  {
  return internal::log_impl<T>::run(x);
}

log2()

int Eigen::numext::log2 ( int  x )

inline

Log base 2 for 32 bits positive integers. Conveniently returns 0 for x==0.

Definition at line 1345 of file MathFunctions.h.

{
  eigen_assert(x>=0);
  unsigned int v(x);
  static const int table[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 };
  v |= v >> 1;
  v |= v >> 2;
  v |= v >> 4;
  v |= v >> 8;
  v |= v >> 16;
  return table[(v * 0x07C4ACDDU) >> 27];
}

maxi()

template<typename T >

EIGEN_ALWAYS_INLINE T Eigen::numext::maxi	(	const T &	x,
		const T &	y
	)

Definition at line 985 of file MathFunctions.h.

{
  EIGEN_USING_STD(max)
  return max EIGEN_NOT_A_MACRO (x,y);
}

mini()

template<typename T >

EIGEN_ALWAYS_INLINE T Eigen::numext::mini	(	const T &	x,
		const T &	y
	)

Definition at line 977 of file MathFunctions.h.

{
  EIGEN_USING_STD(min)
  return min EIGEN_NOT_A_MACRO (x,y);
}

not_equal_strict() [1/3]

template<>

bool Eigen::numext::not_equal_strict ( const double &  x, const double &  y  )

inline

Definition at line 492 of file Meta.h.

{ return std::not_equal_to<double>()(x,y); }

not_equal_strict() [2/3]

template<>

bool Eigen::numext::not_equal_strict ( const float &  x, const float &  y  )

inline

Definition at line 489 of file Meta.h.

{ return std::not_equal_to<float>()(x,y); }

not_equal_strict() [3/3]

template<typename X , typename Y >

bool Eigen::numext::not_equal_strict ( const X &  x, const Y &  y  )

inline

Definition at line 485 of file Meta.h.

{ return !equal_strict_impl<X, Y>::run(x, y); }

pow()

template<typename ScalarX , typename ScalarY >

internal::pow_impl<ScalarX,ScalarY>::result_type Eigen::numext::pow ( const ScalarX &  x, const ScalarY &  y  )

inline

Definition at line 1267 of file MathFunctions.h.

{
  return internal::pow_impl<ScalarX,ScalarY>::run(x, y);
}

real_ref()

template<typename Scalar >

internal::add_const_on_value_type_t< EIGEN_MATHFUNC_RETVAL(real_ref, Scalar) > Eigen::numext::real_ref ( const Scalar &  x )

inline

Definition at line 1136 of file MathFunctions.h.

{
  return internal::real_ref_impl<Scalar>::run(x);
}

rint()

template<typename Scalar >

Scalar Eigen::numext::rint ( const Scalar &  x )

inline

Definition at line 1288 of file MathFunctions.h.

{
  return internal::nearest_integer_impl<Scalar>::run_rint(x);
}

round()

template<typename Scalar >

Scalar Eigen::numext::round ( const Scalar &  x )

inline

Definition at line 1295 of file MathFunctions.h.

{
  return internal::nearest_integer_impl<Scalar>::run_round(x);
}

rsqrt()

template<typename T >

EIGEN_ALWAYS_INLINE T Eigen::numext::rsqrt

(

const T &

x

)

Returns

the reciprocal square root of x.

Definition at line 1386 of file MathFunctions.h.

{
  return internal::rsqrt_impl<T>::run(x);
}

signbit()

template<typename Scalar >

static constexpr EIGEN_ALWAYS_INLINE Scalar Eigen::numext::signbit ( const Scalar &  x )

staticconstexpr

Definition at line 1475 of file MathFunctions.h.

                                                                                       {
  return signbit_impl<Scalar>::run(x);
}

sin()

template<typename T >

EIGEN_ALWAYS_INLINE T Eigen::numext::sin

(

const T &

x

)

Definition at line 1554 of file MathFunctions.h.

                  {
  EIGEN_USING_STD(sin);
  return sin(x);
}

sinh()

template<typename T >

EIGEN_ALWAYS_INLINE T Eigen::numext::sinh

(

const T &

x

)

Definition at line 1699 of file MathFunctions.h.

                   {
  EIGEN_USING_STD(sinh);
  return static_cast<T>(sinh(x));
}

sqrt() [1/2]

template<>

EIGEN_ALWAYS_INLINE double Eigen::numext::sqrt

(

const double &

x

)

Definition at line 69 of file arch/SSE/MathFunctions.h.

{
#if EIGEN_COMP_GNUC_STRICT
  // This works around a GCC bug generating poor code for _mm_sqrt_pd
  // See https://gitlab.com/libeigen/eigen/commit/8dca9f97e38970
  return internal::pfirst(internal::Packet2d(__builtin_ia32_sqrtsd(_mm_set_sd(x))));
#else
  return internal::pfirst(internal::Packet2d(_mm_sqrt_pd(_mm_set_sd(x))));
#endif
}

sqrt() [2/2]

template<>

EIGEN_ALWAYS_INLINE float Eigen::numext::sqrt

(

const float &

x

)

Definition at line 62 of file arch/SSE/MathFunctions.h.

{
  return internal::pfirst(internal::Packet4f(_mm_sqrt_ss(_mm_set_ss(x))));
}

sqrt< bool >()

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS bool Eigen::numext::sqrt< bool >

(

const bool &

x

)

Definition at line 1377 of file MathFunctions.h.

{ return x; }

swap()

template<typename T >

void Eigen::numext::swap ( T &  a, T &  b  )

inline

Definition at line 419 of file Meta.h.

{ std::swap(a,b); }

tan()

template<typename T >

EIGEN_ALWAYS_INLINE T Eigen::numext::tan

(

const T &

x

)

Definition at line 1573 of file MathFunctions.h.

                  {
  EIGEN_USING_STD(tan);
  return tan(x);
}

tanh()

template<typename T >

EIGEN_ALWAYS_INLINE T Eigen::numext::tanh

(

const T &

x

)

Definition at line 1718 of file MathFunctions.h.

                   {
  EIGEN_USING_STD(tanh);
  return tanh(x);
}

Variable Documentation

y

const Scalar& Eigen::numext::y

Definition at line 1237 of file MathFunctions.h.