Eigen::numext Namespace Reference

Functions
template<>
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float	sqrt (const float &x)
template<>
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double	sqrt (const double &x)
template<typename T >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T	mini (const T &x, const T &y)
template<typename T >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T	maxi (const T &x, const T &y)
template<typename Scalar >
EIGEN_DEVICE_FUNC	EIGEN_MATHFUNC_RETVAL (real, Scalar) real(const Scalar &x)
template<typename Scalar >
EIGEN_DEVICE_FUNC internal::add_const_on_value_type< EIGEN_MATHFUNC_RETVAL(real_ref, Scalar)>::type	real_ref (const Scalar &x)
template<typename Scalar >
EIGEN_DEVICE_FUNC	EIGEN_MATHFUNC_RETVAL (real_ref, Scalar) real_ref(Scalar &x)
template<typename Scalar >
EIGEN_DEVICE_FUNC	EIGEN_MATHFUNC_RETVAL (imag, Scalar) imag(const Scalar &x)
template<typename Scalar >
EIGEN_DEVICE_FUNC	EIGEN_MATHFUNC_RETVAL (arg, Scalar) arg(const Scalar &x)
template<typename Scalar >
EIGEN_DEVICE_FUNC internal::add_const_on_value_type< EIGEN_MATHFUNC_RETVAL(imag_ref, Scalar)>::type	imag_ref (const Scalar &x)
template<typename Scalar >
EIGEN_DEVICE_FUNC	EIGEN_MATHFUNC_RETVAL (imag_ref, Scalar) imag_ref(Scalar &x)
template<typename Scalar >
EIGEN_DEVICE_FUNC	EIGEN_MATHFUNC_RETVAL (conj, Scalar) conj(const Scalar &x)
template<typename Scalar >
EIGEN_DEVICE_FUNC	EIGEN_MATHFUNC_RETVAL (abs2, Scalar) abs2(const Scalar &x)
template<typename Scalar >
EIGEN_DEVICE_FUNC	EIGEN_MATHFUNC_RETVAL (norm1, Scalar) norm1(const Scalar &x)
template<typename Scalar >
EIGEN_DEVICE_FUNC	EIGEN_MATHFUNC_RETVAL (hypot, Scalar) hypot(const Scalar &x
template<typename Scalar >
EIGEN_DEVICE_FUNC	EIGEN_MATHFUNC_RETVAL (log1p, Scalar) log1p(const Scalar &x)
template<typename ScalarX , typename ScalarY >
EIGEN_DEVICE_FUNC internal::pow_impl< ScalarX, ScalarY >::result_type	pow (const ScalarX &x, const ScalarY &y)
template<typename T >
EIGEN_DEVICE_FUNC bool()	isnan (const T &x)
template<typename T >
EIGEN_DEVICE_FUNC bool()	isinf (const T &x)
template<typename T >
EIGEN_DEVICE_FUNC bool()	isfinite (const T &x)
template<typename Scalar >
EIGEN_DEVICE_FUNC	EIGEN_MATHFUNC_RETVAL (round, Scalar) round(const Scalar &x)
template<typename T >
EIGEN_DEVICE_FUNC T()	floor (const T &x)
template<typename T >
EIGEN_DEVICE_FUNC T()	ceil (const T &x)
int	log2 (int x)
template<typename T >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T	sqrt (const T &x)
template<typename T >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T	log (const T &x)
template<typename T >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE internal::enable_if< NumTraits< T >::IsSigned||NumTraits< T >::IsComplex, typenameNumTraits< T >::Real >::type	abs (const T &x)
template<typename T >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE internal::enable_if<!(NumTraits< T >::IsSigned||NumTraits< T >::IsComplex), typenameNumTraits< T >::Real >::type	abs (const T &x)
template<typename T >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T	exp (const T &x)
template<typename T >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T	cos (const T &x)
template<typename T >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T	sin (const T &x)
template<typename T >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T	tan (const T &x)
template<typename T >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T	acos (const T &x)
template<typename T >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T	asin (const T &x)
template<typename T >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T	atan (const T &x)
template<typename T >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T	cosh (const T &x)
template<typename T >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T	sinh (const T &x)
template<typename T >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T	tanh (const T &x)
template<typename T >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T	fmod (const T &a, const T &b)
template<typename T >
EIGEN_STRONG_INLINE void	swap (T &a, T &b)
template<typename T >
T	div_ceil (const T &a, const T &b)
template<typename X , typename Y >
EIGEN_STRONG_INLINE bool	equal_strict (const X &x, const Y &y)
template<>
EIGEN_STRONG_INLINE bool	equal_strict (const float &x, const float &y)
template<>
EIGEN_STRONG_INLINE bool	equal_strict (const double &x, const double &y)
template<typename X , typename Y >
EIGEN_STRONG_INLINE bool	not_equal_strict (const X &x, const Y &y)
template<>
EIGEN_STRONG_INLINE bool	not_equal_strict (const float &x, const float &y)
template<>
EIGEN_STRONG_INLINE bool	not_equal_strict (const double &x, const double &y)

Variables
EIGEN_DEVICE_FUNC const Scalar &	y

Function Documentation

abs() [1/2]

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE internal::enable_if< NumTraits< T >::IsSigned||NumTraits< T >::IsComplex, typenameNumTraits< T >::Real >::type Eigen::numext::abs

(

const T &

x

)

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

Referenced by Eigen::Hyperplane< _Scalar, _AmbientDim, _Options >::absDistance(), Eigen::QuaternionBase< Derived >::angularDistance(), Eigen::Hyperplane< _Scalar, _AmbientDim, _Options >::intersection(), Eigen::internal::scalar_fuzzy_default_impl< Scalar, false, false >::isApprox(), Eigen::MatrixBase< Derived >::isDiagonal(), Eigen::MatrixBase< Derived >::isLowerTriangular(), Eigen::internal::scalar_fuzzy_default_impl< Scalar, false, false >::isMuchSmallerThan(), Eigen::MatrixBase< Derived >::isUpperTriangular(), Eigen::internal::scalar_abs_op< Scalar >::operator()(), Eigen::internal::abs_knowing_score< Scalar, typename >::operator()(), and Eigen::QuaternionBase< Derived >::slerp().

Here is the caller graph for this function:

abs() [2/2]

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE internal::enable_if<!(NumTraits< T >::IsSigned||NumTraits< T >::IsComplex), typenameNumTraits< T >::Real >::type Eigen::numext::abs

(

const T &

x

)

                {
  return x;
}

acos()

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T Eigen::numext::acos

(

const T &

x

)

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

References acos().

Here is the call graph for this function:

asin()

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T Eigen::numext::asin

(

const T &

x

)

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

References asin().

Here is the call graph for this function:

atan()

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T Eigen::numext::atan

(

const T &

x

)

                   {
  EIGEN_USING_STD_MATH(atan);
  return atan(x);
}

References atan().

Here is the call graph for this function:

ceil()

template<typename T >

EIGEN_DEVICE_FUNC T() Eigen::numext::ceil

(

const T &

x

)

{
  EIGEN_USING_STD_MATH(ceil);
  return ceil(x);
}

References ceil().

Referenced by Eigen::internal::pceil().

Here is the call graph for this function:

Here is the caller graph for this function:

cos()

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T Eigen::numext::cos

(

const T &

x

)

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

References cos().

Here is the call graph for this function:

cosh()

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T Eigen::numext::cosh

(

const T &

x

)

                   {
  EIGEN_USING_STD_MATH(cosh);
  return cosh(x);
}

References cosh().

Here is the call graph for this function:

div_ceil()

template<typename T >

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

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

References div_ceil().

Referenced by div_ceil(), and Eigen::internal::evaluateProductBlockingSizesHeuristic().

Here is the call graph for this function:

Here is the caller graph for this function:

EIGEN_MATHFUNC_RETVAL() [1/11]

template<typename Scalar >

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

inline

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

References abs2(), and EIGEN_MATHFUNC_IMPL.

Here is the call graph for this function:

EIGEN_MATHFUNC_RETVAL() [2/11]

template<typename Scalar >

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

inline

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

References arg(), and EIGEN_MATHFUNC_IMPL.

Here is the call graph for this function:

EIGEN_MATHFUNC_RETVAL() [3/11]

template<typename Scalar >

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

inline

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

References EIGEN_MATHFUNC_IMPL.

EIGEN_MATHFUNC_RETVAL() [4/11]

template<typename Scalar >

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

inline

References EIGEN_MATHFUNC_IMPL, and y.

EIGEN_MATHFUNC_RETVAL() [5/11]

template<typename Scalar >

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

inline

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

References EIGEN_MATHFUNC_IMPL, and imag().

Here is the call graph for this function:

EIGEN_MATHFUNC_RETVAL() [6/11]

template<typename Scalar >

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

inline

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

References EIGEN_MATHFUNC_IMPL, and imag_ref().

Here is the call graph for this function:

EIGEN_MATHFUNC_RETVAL() [7/11]

template<typename Scalar >

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

inline

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

References EIGEN_MATHFUNC_IMPL, and log1p().

Here is the call graph for this function:

EIGEN_MATHFUNC_RETVAL() [8/11]

template<typename Scalar >

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

inline

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

References EIGEN_MATHFUNC_IMPL.

EIGEN_MATHFUNC_RETVAL() [9/11]

template<typename Scalar >

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

inline

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

References EIGEN_MATHFUNC_IMPL, and real().

Here is the call graph for this function:

EIGEN_MATHFUNC_RETVAL() [10/11]

template<typename Scalar >

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

inline

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

References EIGEN_MATHFUNC_IMPL, and real_ref().

Here is the call graph for this function:

EIGEN_MATHFUNC_RETVAL() [11/11]

template<typename Scalar >

EIGEN_DEVICE_FUNC Eigen::numext::EIGEN_MATHFUNC_RETVAL ( round  , Scalar    ) const &

inline

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

References EIGEN_MATHFUNC_IMPL, and round().

Here is the call graph for this function:

equal_strict() [1/3]

template<>

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

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

References equal_strict(), and Eigen::internal::y.

Here is the call graph for this function:

equal_strict() [2/3]

template<>

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

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

References equal_strict(), and Eigen::internal::y.

Here is the call graph for this function:

equal_strict() [3/3]

template<typename X , typename Y >

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

{ return x == y; }

References equal_strict(), and Eigen::internal::y.

Referenced by equal_strict(), equal_strict(), equal_strict(), Eigen::internal::std_fallback::log1p(), and Eigen::half_impl::operator==().

Here is the call graph for this function:

Here is the caller graph for this function:

exp()

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T Eigen::numext::exp

(

const T &

x

)

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

References exp().

Referenced by Eigen::internal::scalar_exp_op< Scalar >::operator()().

Here is the call graph for this function:

Here is the caller graph for this function:

floor()

template<typename T >

EIGEN_DEVICE_FUNC T() Eigen::numext::floor

(

const T &

x

)

{
  EIGEN_USING_STD_MATH(floor);
  return floor(x);
}

References floor().

Referenced by Eigen::internal::pfloor().

Here is the call graph for this function:

Here is the caller graph for this function:

fmod()

template<typename T >

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

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

References fmod().

Referenced by fmod(), Eigen::Rotation2D< _Scalar >::smallestAngle(), and Eigen::Rotation2D< _Scalar >::smallestPositiveAngle().

Here is the call graph for this function:

Here is the caller graph for this function:

imag_ref()

template<typename Scalar >

EIGEN_DEVICE_FUNC internal::add_const_on_value_type< EIGEN_MATHFUNC_RETVAL(imag_ref, Scalar)>::type Eigen::numext::imag_ref ( const Scalar &  x )

inline

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

References Eigen::internal::imag_ref_default_impl< Scalar, NumTraits< Scalar >::IsComplex >::run().

Referenced by EIGEN_MATHFUNC_RETVAL(), and Eigen::internal::scalar_imag_ref_op< Scalar >::operator()().

Here is the call graph for this function:

Here is the caller graph for this function:

isfinite()

template<typename T >

EIGEN_DEVICE_FUNC bool() Eigen::numext::isfinite

(

const T &

x

)

{ return internal::isfinite_impl(x); }

References Eigen::internal::isfinite_impl().

Referenced by Eigen::EigenSolver< _MatrixType >::compute(), Eigen::BDCSVD< _MatrixType >::computeSingVals(), Eigen::internal::isfinite_impl(), and Eigen::internal::ldlt_inplace< Lower >::updateInPlace().

Here is the call graph for this function:

Here is the caller graph for this function:

isinf()

template<typename T >

EIGEN_DEVICE_FUNC bool() Eigen::numext::isinf

(

const T &

x

)

{ return internal::isinf_impl(x); }

References Eigen::internal::isinf_impl().

Referenced by Eigen::internal::isinf_impl().

Here is the call graph for this function:

Here is the caller graph for this function:

isnan()

template<typename T >

EIGEN_DEVICE_FUNC bool() Eigen::numext::isnan

(

const T &

x

)

{ return internal::isnan_impl(x); }

References Eigen::internal::isnan_impl().

Referenced by Eigen::internal::isinf_impl(), and Eigen::internal::isnan_impl().

Here is the call graph for this function:

Here is the caller graph for this function:

log()

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T Eigen::numext::log

(

const T &

x

)

                  {
  EIGEN_USING_STD_MATH(log);
  return log(x);
}

References log().

Referenced by Eigen::internal::scalar_log_op< Scalar >::operator()().

Here is the call graph for this function:

Here is the caller graph for this function:

log2()

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

inline

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

{
  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];
}

References eigen_assert.

Referenced by Eigen::internal::conservative_sparse_sparse_product_impl().

Here is the caller graph for this function:

maxi()

template<typename T >

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

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

References EIGEN_NOT_A_MACRO, and y.

Referenced by Eigen::internal::blueNorm_impl(), Eigen::SPQR< _MatrixType >::compute(), Eigen::internal::direct_selfadjoint_eigenvalues< SolverType, 3, false >::computeRoots(), Eigen::internal::conjugate_gradient(), Eigen::ComplexEigenSolver< _MatrixType >::doComputeEigenvectors(), Eigen::internal::evaluateProductBlockingSizesHeuristic(), Eigen::IncompleteCholesky< Scalar, _UpLo, _OrderingType >::factorize(), Eigen::SparseQR< _MatrixType, _OrderingType >::factorize(), Eigen::internal::scalar_max_op< LhsScalar, RhsScalar >::operator()(), Eigen::internal::pmax(), Eigen::internal::positive_real_hypot(), Eigen::internal::rcond_invmatrix_L1_norm_estimate(), and Eigen::QuaternionBase< Derived >::setFromTwoVectors().

Here is the caller graph for this function:

mini()

template<typename T >

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

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

References EIGEN_NOT_A_MACRO, and y.

Referenced by Eigen::internal::blueNorm_impl(), Eigen::MatrixBase< Derived >::diagonalSize(), Eigen::IncompleteCholesky< Scalar, _UpLo, _OrderingType >::factorize(), Eigen::internal::scalar_fuzzy_default_impl< Scalar, false, false >::isApprox(), Eigen::internal::scalar_fuzzy_default_impl< Scalar, true, false >::isApprox(), Eigen::SparseMatrixBase< Derived >::isApprox(), Eigen::MatrixBase< Derived >::isLowerTriangular(), Eigen::MatrixBase< Derived >::isUpperTriangular(), Eigen::internal::scalar_min_op< LhsScalar, RhsScalar >::operator()(), Eigen::internal::pmin(), Eigen::internal::positive_real_hypot(), Eigen::internal::isApprox_selector< Derived, OtherDerived, is_integer >::run(), Eigen::internal::conservative_resize_like_impl< Derived, OtherDerived, IsVector >::run(), Eigen::internal::conservative_resize_like_impl< Derived, OtherDerived, IsVector >::run(), Eigen::internal::setIdentity_impl< Derived, true >::run(), and Eigen::MatrixBase< Derived >::stableNorm().

Here is the caller graph for this function:

not_equal_strict() [1/3]

template<>

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

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

References not_equal_strict(), and Eigen::internal::y.

Here is the call graph for this function:

not_equal_strict() [2/3]

template<>

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

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

References not_equal_strict(), and Eigen::internal::y.

Here is the call graph for this function:

not_equal_strict() [3/3]

template<typename X , typename Y >

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

{ return x != y; }

References not_equal_strict(), and Eigen::internal::y.

Referenced by not_equal_strict(), not_equal_strict(), not_equal_strict(), and Eigen::half_impl::operator!=().

Here is the call graph for this function:

Here is the caller graph for this function:

pow()

template<typename ScalarX , typename ScalarY >

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

inline

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

References Eigen::internal::pow_impl< ScalarX, ScalarY, IsInteger >::run(), and y.

Referenced by Eigen::internal::scalar_pow_op< Scalar, Exponent >::operator()().

Here is the call graph for this function:

Here is the caller graph for this function:

real_ref()

template<typename Scalar >

EIGEN_DEVICE_FUNC internal::add_const_on_value_type< EIGEN_MATHFUNC_RETVAL(real_ref, Scalar)>::type Eigen::numext::real_ref ( const Scalar &  x )

inline

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

References Eigen::internal::real_ref_impl< Scalar >::run().

Referenced by Eigen::ComplexEigenSolver< _MatrixType >::doComputeEigenvectors(), EIGEN_MATHFUNC_RETVAL(), Eigen::internal::scalar_real_ref_op< Scalar >::operator()(), Eigen::internal::pload< Packet2cf >(), Eigen::internal::pload< Packet4cf >(), Eigen::internal::ploadu< Packet2cf >(), Eigen::internal::ploadu< Packet4cf >(), Eigen::internal::pstore< std::complex< float > >(), Eigen::internal::pstore< std::complex< float > >(), Eigen::internal::pstoreu< std::complex< float > >(), Eigen::internal::pstoreu< std::complex< float > >(), Eigen::umfpack_get_determinant(), Eigen::umfpack_get_numeric(), Eigen::umfpack_numeric(), Eigen::umfpack_solve(), and Eigen::umfpack_symbolic().

Here is the call graph for this function:

Here is the caller graph for this function:

sin()

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T Eigen::numext::sin

(

const T &

x

)

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

References sin().

Here is the call graph for this function:

sinh()

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T Eigen::numext::sinh

(

const T &

x

)

                   {
  EIGEN_USING_STD_MATH(sinh);
  return sinh(x);
}

References sinh().

Here is the call graph for this function:

sqrt() [1/3]

template<>

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double Eigen::numext::sqrt

(

const double &

x

)

{
#if EIGEN_COMP_GNUC_STRICT
  // This works around a GCC bug generating poor code for _mm_sqrt_pd
  // See https://bitbucket.org/eigen/eigen/commits/14f468dba4d350d7c19c9b93072e19f7b3df563b
  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
}

References Eigen::internal::pfirst().

Here is the call graph for this function:

sqrt() [2/3]

template<>

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float Eigen::numext::sqrt

(

const float &

x

)

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

References Eigen::internal::pfirst().

Referenced by Eigen::ColPivHouseholderQR< _MatrixType >::computeInPlace(), Eigen::MatrixBase< Derived >::norm(), Eigen::MatrixBase< Derived >::normalize(), Eigen::MatrixBase< Derived >::normalized(), and Eigen::MatrixBase< Derived >::stableNormalized().

Here is the call graph for this function:

Here is the caller graph for this function:

sqrt() [3/3]

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T Eigen::numext::sqrt

(

const T &

x

)

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.

{
  EIGEN_USING_STD_MATH(sqrt);
  return sqrt(x);
}

References sqrt().

Here is the call graph for this function:

swap()

template<typename T >

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

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

Referenced by Eigen::internal::direct_selfadjoint_eigenvalues< SolverType, 3, false >::run().

Here is the caller graph for this function:

tan()

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T Eigen::numext::tan

(

const T &

x

)

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

References tan().

Here is the call graph for this function:

tanh()

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T Eigen::numext::tanh

(

const T &

x

)

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

References tanh().

Here is the call graph for this function:

Variable Documentation

y

EIGEN_DEVICE_FUNC const Scalar& Eigen::numext::y

Initial value:

{
  return EIGEN_MATHFUNC_IMPL(hypot, Scalar)::run(x, y)

Referenced by EIGEN_MATHFUNC_RETVAL(), maxi(), mini(), and pow().