Eigen::numext Namespace Reference

Classes
struct	signbit_impl
struct	signbit_impl< Scalar, false, true >
struct	signbit_impl< Scalar, true, true >
struct	signbit_impl< Scalar, 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	equal_strict_impl
struct	equal_strict_impl< X, Y, true, false, true, true >
struct	equal_strict_impl< X, Y, true, true, true, false >

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

Functions
template<>
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16	bit_cast< Eigen::bfloat16, uint16_t > (const uint16_t &src)
template<>
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC uint16_t	bit_cast< uint16_t, Eigen::bfloat16 > (const Eigen::bfloat16 &src)
template<>
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool()	isnan (const Eigen::bfloat16 &h)
template<>
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool()	isinf (const Eigen::bfloat16 &h)
template<>
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool()	isfinite (const Eigen::bfloat16 &h)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16	nextafter (const bfloat16 &from, const bfloat16 &to)
template<>
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half	bit_cast< Eigen::half, uint16_t > (const uint16_t &src)
template<>
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC uint16_t	bit_cast< uint16_t, Eigen::half > (const Eigen::half &src)
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_t< EIGEN_MATHFUNC_RETVAL(real_ref, Scalar)>	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_t< EIGEN_MATHFUNC_RETVAL(imag_ref, Scalar)>	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 (sign, Scalar) sign(const Scalar &x)
template<typename Scalar >
EIGEN_DEVICE_FUNC	EIGEN_MATHFUNC_RETVAL (negate, Scalar) negate(const Scalar &x)
template<typename Scalar >
EIGEN_DEVICE_FUNC	EIGEN_MATHFUNC_RETVAL (abs2, Scalar) abs2(const Scalar &x)
EIGEN_DEVICE_FUNC bool	abs2 (bool x)
template<typename T >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T	absdiff (const T &x, const T &y)
template<>
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float	absdiff (const float &x, const float &y)
template<>
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double	absdiff (const double &x, const double &y)
template<>
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE long double	absdiff (const long double &x, const long double &y)
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_STRONG_INLINE Scalar	rint (const Scalar &x)
template<typename Scalar >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar	round (const Scalar &x)
template<typename Scalar >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar()	floor (const Scalar &x)
template<typename Scalar >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar()	ceil (const Scalar &x)
template<typename Scalar >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar()	trunc (const Scalar &x)
template<typename T >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE EIGEN_CONSTEXPR T	div_ceil (T a, T b)
template<typename T , typename U >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE EIGEN_CONSTEXPR T	round_down (T a, U b)
EIGEN_CONSTEXPR int	log2 (int x)
template<typename Scalar >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE	EIGEN_MATHFUNC_RETVAL (sqrt, Scalar) sqrt(const Scalar &x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_DEVICE_FUNC bool	sqrt< bool > (const bool &x)
template<typename T >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T	cbrt (const T &x)
template<typename T >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T	rsqrt (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 std::enable_if_t< NumTraits< T >::IsSigned||NumTraits< T >::IsComplex, typename NumTraits< T >::Real >	abs (const T &x)
template<typename T >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE std::enable_if_t<!(NumTraits< T >::IsSigned||NumTraits< T >::IsComplex), typename NumTraits< T >::Real >	abs (const T &x)
template<typename Scalar >
EIGEN_DEVICE_FUNC static constexpr EIGEN_ALWAYS_INLINE Scalar	signbit (const Scalar &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	exp2 (const T &x)
template<typename Scalar >
EIGEN_DEVICE_FUNC	EIGEN_MATHFUNC_RETVAL (expm1, Scalar) expm1(const Scalar &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	acosh (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	asinh (const T &x)
template<typename T >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T	atan (const T &x)
template<typename T , std::enable_if_t<!NumTraits< T >::IsComplex, int > = 0>
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T	atan2 (const T &y, const T &x)
template<typename T >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T	atanh (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 Scalar , typename Enable = std::enable_if_t<std::is_integral<Scalar>::value>>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar	logical_shift_left (const Scalar &a, int n)
template<typename Scalar , typename Enable = std::enable_if_t<std::is_integral<Scalar>::value>>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar	logical_shift_right (const Scalar &a, int n)
template<typename Scalar , typename Enable = std::enable_if_t<std::is_integral<Scalar>::value>>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar	arithmetic_shift_right (const Scalar &a, int n)
template<typename Tgt , typename Src >
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Tgt	bit_cast (const Src &src)
template<typename T >
EIGEN_STRONG_INLINE void	swap (T &a, T &b)
template<typename X , typename Y >
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool	equal_strict (const X &x, const Y &y)
template<>
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool	equal_strict (const float &x, const float &y)
template<>
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool	equal_strict (const double &x, const double &y)
template<typename X >
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool	is_exactly_zero (const X &x)
template<typename X >
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool	is_exactly_one (const X &x)
template<typename X , typename Y >
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool	not_equal_strict (const X &x, const Y &y)
template<>
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool	not_equal_strict (const float &x, const float &y)
template<>
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool	not_equal_strict (const double &x, const double &y)
template<>
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool()	isfinite (const AnnoyingScalar &x)
template<typename Scalar >
EIGEN_DEVICE_FUNC	EIGEN_MATHFUNC_RETVAL (bessel_i0, Scalar) bessel_i0(const Scalar &x)
template<typename Scalar >
EIGEN_DEVICE_FUNC	EIGEN_MATHFUNC_RETVAL (bessel_i0e, Scalar) bessel_i0e(const Scalar &x)
template<typename Scalar >
EIGEN_DEVICE_FUNC	EIGEN_MATHFUNC_RETVAL (bessel_i1, Scalar) bessel_i1(const Scalar &x)
template<typename Scalar >
EIGEN_DEVICE_FUNC	EIGEN_MATHFUNC_RETVAL (bessel_i1e, Scalar) bessel_i1e(const Scalar &x)
template<typename Scalar >
EIGEN_DEVICE_FUNC	EIGEN_MATHFUNC_RETVAL (bessel_k0, Scalar) bessel_k0(const Scalar &x)
template<typename Scalar >
EIGEN_DEVICE_FUNC	EIGEN_MATHFUNC_RETVAL (bessel_k0e, Scalar) bessel_k0e(const Scalar &x)
template<typename Scalar >
EIGEN_DEVICE_FUNC	EIGEN_MATHFUNC_RETVAL (bessel_k1, Scalar) bessel_k1(const Scalar &x)
template<typename Scalar >
EIGEN_DEVICE_FUNC	EIGEN_MATHFUNC_RETVAL (bessel_k1e, Scalar) bessel_k1e(const Scalar &x)
template<typename Scalar >
EIGEN_DEVICE_FUNC	EIGEN_MATHFUNC_RETVAL (bessel_j0, Scalar) bessel_j0(const Scalar &x)
template<typename Scalar >
EIGEN_DEVICE_FUNC	EIGEN_MATHFUNC_RETVAL (bessel_y0, Scalar) bessel_y0(const Scalar &x)
template<typename Scalar >
EIGEN_DEVICE_FUNC	EIGEN_MATHFUNC_RETVAL (bessel_j1, Scalar) bessel_j1(const Scalar &x)
template<typename Scalar >
EIGEN_DEVICE_FUNC	EIGEN_MATHFUNC_RETVAL (bessel_y1, Scalar) bessel_y1(const Scalar &x)
template<typename Scalar >
EIGEN_DEVICE_FUNC	EIGEN_MATHFUNC_RETVAL (lgamma, Scalar) lgamma(const Scalar &x)
template<typename Scalar >
EIGEN_DEVICE_FUNC	EIGEN_MATHFUNC_RETVAL (digamma, Scalar) digamma(const Scalar &x)
template<typename Scalar >
EIGEN_DEVICE_FUNC	EIGEN_MATHFUNC_RETVAL (zeta, Scalar) zeta(const Scalar &x
template<typename Scalar >
EIGEN_DEVICE_FUNC	EIGEN_MATHFUNC_RETVAL (polygamma, Scalar) polygamma(const Scalar &n
template<typename Scalar >
EIGEN_DEVICE_FUNC	EIGEN_MATHFUNC_RETVAL (erf, Scalar) erf(const Scalar &x)
template<typename Scalar >
EIGEN_DEVICE_FUNC	EIGEN_MATHFUNC_RETVAL (erfc, Scalar) erfc(const Scalar &x)
template<typename Scalar >
EIGEN_DEVICE_FUNC	EIGEN_MATHFUNC_RETVAL (ndtri, Scalar) ndtri(const Scalar &x)
template<typename Scalar >
EIGEN_DEVICE_FUNC	EIGEN_MATHFUNC_RETVAL (igamma, Scalar) igamma(const Scalar &a
template<typename Scalar >
EIGEN_DEVICE_FUNC	EIGEN_MATHFUNC_RETVAL (igamma_der_a, Scalar) igamma_der_a(const Scalar &a
template<typename Scalar >
EIGEN_DEVICE_FUNC	EIGEN_MATHFUNC_RETVAL (gamma_sample_der_alpha, Scalar) gamma_sample_der_alpha(const Scalar &a
template<typename Scalar >
EIGEN_DEVICE_FUNC	EIGEN_MATHFUNC_RETVAL (igammac, Scalar) igammac(const Scalar &a
template<typename Scalar >
EIGEN_DEVICE_FUNC	EIGEN_MATHFUNC_RETVAL (betainc, Scalar) betainc(const Scalar &a

Variables
EIGEN_DEVICE_FUNC const Scalar &	y
EIGEN_DEVICE_FUNC const Scalar &	q
EIGEN_DEVICE_FUNC const Scalar &	x
EIGEN_DEVICE_FUNC const Scalar &	b

Typedef Documentation

int16_t

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

int32_t

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

int64_t

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

int8_t

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

uint16_t

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

uint32_t

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

uint64_t

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

uint8_t

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

Function Documentation

abs() [1/2]

template<typename T >

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

(

const T &

x

)

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

References abs(), EIGEN_USING_STD, and plotDoE::x.

Referenced by Eigen::Hyperplane< Scalar_, AmbientDim_, Options_ >::absDistance(), Eigen::QuaternionBase< Derived >::angularDistance(), Eigen::internal::bicgstabl(), Eigen::TensorEvaluator< const TensorPaddingOp< PaddingDimensions, ArgType >, Device >::block(), Eigen::TensorEvaluator< const TensorReverseOp< ReverseDimensions, ArgType >, Device >::block(), Eigen::internal::complex_log(), Eigen::internal::complex_rsqrt(), Eigen::internal::complex_sqrt(), Eigen::PolynomialSolver< Scalar_, Deg_ >::compute(), Eigen::internal::computeFromTridiagonal_impl(), Eigen::MatrixBase< Derived >::hypotNorm(), Eigen::internal::idrstabl(), 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::omega(), Eigen::internal::scalar_abs_op< Scalar >::operator()(), Eigen::internal::abs_knowing_score< Scalar, typename >::operator()(), Eigen::internal::pabs(), Eigen::BDCSVD< MatrixType_, Options_ >::perturbCol0(), Eigen::internal::RandomToTypeNormal(), Eigen::internal::compute_inverse_and_det_with_check< MatrixType, ResultType, 3 >::run(), Eigen::internal::zeta_impl_series< double >::run(), Eigen::internal::zeta_impl_series< float >::run(), Eigen::internal::igammac_cf_impl< Scalar, mode >::run(), Eigen::internal::igamma_series_impl< Scalar, mode >::run(), Eigen::internal::zeta_impl< Scalar >::run(), Eigen::internal::unary_pow::exponent_helper< ScalarExponent, IsInteger >::safe_abs(), Eigen::QuaternionBase< Derived >::slerp(), test_cwise_complex(), test_cwise_real(), test_sum_accuracy(), and Eigen::internal::tridiagonal_qr_step().

abs() [2/2]

template<typename T >

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

(

const T &

x

)

                    {
  return x;
}

References plotDoE::x.

abs2()

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

inline

{ return x; }

Referenced by array_complex(), array_real(), Eigen::internal::blueNorm_impl(), check_abs(), check_abs< bool >(), Eigen::RealSchur< MatrixType_ >::computeFromHessenberg(), Eigen::ColPivHouseholderQR< MatrixType_, PermutationIndex_ >::computeInPlace(), Eigen::internal::direct_selfadjoint_eigenvalues< SolverType, 2, false >::computeRoots(), Eigen::SimplicialLLT< MatrixType_, UpLo_, Ordering_ >::determinant(), Eigen::SimplicialCholesky< MatrixType_, UpLo_, Ordering_ >::determinant(), dif_rmse(), Eigen::internal::dogleg(), eigen2support(), Eigen::SparseQR< MatrixType_, OrderingType_ >::factorize(), Eigen::IncompleteLUT< Scalar_, StorageIndex_ >::factorize(), Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::factorize(), Eigen::LeastSquareDiagonalPreconditioner< Scalar_ >::factorize(), fft_rmse(), hyperplane(), Eigen::internal::scalar_fuzzy_default_impl< Scalar, true, false >::isApprox(), Eigen::internal::scalar_fuzzy_default_impl< Scalar, true, false >::isMuchSmallerThan(), Eigen::MatrixBase< Derived >::isOrthogonal(), lapackNorm(), Eigen::internal::llt_rank_update_lower(), Eigen::JacobiRotation< Scalar >::makeGivens(), Eigen::MatrixBase< Derived >::makeHouseholder(), Eigen::JacobiRotation< Scalar >::makeJacobi(), Eigen::LevenbergMarquardt< FunctorType_ >::minimizeOneStep(), Eigen::LevenbergMarquardt< FunctorType_ >::minimizeOptimumStorageOneStep(), Eigen::internal::scalar_abs2_op< Scalar >::operator()(), packetmath_real(), pblueNorm(), Eigen::poly_eval(), Eigen::internal::real_2x2_jacobi_svd(), rotg(), Eigen::internal::isMuchSmallerThan_object_selector< Derived, OtherDerived, is_integer >::run(), Eigen::internal::isMuchSmallerThan_scalar_selector< Derived, is_integer >::run(), Eigen::internal::tridiagonalization_inplace_selector< MatrixType, 3, false >::run(), Eigen::internal::direct_selfadjoint_eigenvalues< SolverType, 2, false >::run(), Eigen::internal::svd_precondition_2x2_block_to_be_real< MatrixType, Options, true >::run(), Eigen::PolynomialSolverBase< Scalar_, Deg_ >::selectComplexRoot_withRespectToNorm(), Eigen::PolynomialSolverBase< Scalar_, Deg_ >::selectRealRoot_withRespectToAbsRealPart(), Eigen::HybridNonLinearSolver< FunctorType, Scalar >::solveNumericalDiffOneStep(), Eigen::HybridNonLinearSolver< FunctorType, Scalar >::solveOneStep(), stable_norm(), Eigen::internal::stable_norm_kernel(), test_abs(), test_cwise_complex(), test_cwise_real(), test_fft_real_input_energy(), test_hypot(), boost::multiprecision::test_relative_error(), Eigen::test_relative_error(), triangular_square(), Eigen::internal::tridiagonal_qr_step(), and Eigen::internal::ldlt_inplace< Lower >::updateInPlace().

absdiff() [1/4]

template<>

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

                                                                                       {
  return fabs(x - y);
}

absdiff() [2/4]

template<>

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

                                                                                    {
  return fabsf(x - y);
}

absdiff() [3/4]

template<>

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

                                                                                                      {
  return fabsl(x - y);
}

absdiff() [4/4]

template<typename T >

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

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

Referenced by Eigen::internal::scalar_absolute_difference_op< LhsScalar, RhsScalar >::operator()().

acos()

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T Eigen::numext::acos

(

const T &

x

)

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

References acos(), EIGEN_USING_STD, and plotDoE::x.

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

acosh()

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T Eigen::numext::acosh

(

const T &

x

)

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

References EIGEN_USING_STD, and plotDoE::x.

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

arithmetic_shift_right()

template<typename Scalar , typename Enable = std::enable_if_t<std::is_integral<Scalar>::value>>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar Eigen::numext::arithmetic_shift_right	(	const Scalar &	a,
		int	n
	)

                                                                                            {
  using SignedScalar = typename numext::get_integer_by_size<sizeof(Scalar)>::signed_type;
  return bit_cast<Scalar, SignedScalar>(bit_cast<SignedScalar, Scalar>(a) >> n);
}

References a, and n.

Referenced by check_shift(), Eigen::internal::scalar_shift_right_op< Scalar, N >::operator()(), arithmetic_right_shift_op< N, Scalar >::operator()(), Eigen::internal::parithmetic_shift_right(), and shift_test_impl< ArrayType >::run().

asin()

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T Eigen::numext::asin

(

const T &

x

)

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

References EIGEN_USING_STD, and plotDoE::x.

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

asinh()

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T Eigen::numext::asinh

(

const T &

x

)

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

References EIGEN_USING_STD, and plotDoE::x.

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

atan()

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T Eigen::numext::atan

(

const T &

x

)

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

References EIGEN_USING_STD, and plotDoE::x.

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

atan2()

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

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

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

References Eigen::atan2(), EIGEN_USING_STD, plotDoE::x, and Eigen::internal::y.

Referenced by Eigen::MatrixBase< Derived >::canonicalEulerAngles(), Eigen::MatrixBase< Derived >::eulerAngles(), Eigen::internal::scalar_atan2_op< LhsScalar, RhsScalar >::operator()(), and Eigen::internal::patan2().

atanh()

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T Eigen::numext::atanh

(

const T &

x

)

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

References EIGEN_USING_STD, and plotDoE::x.

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

bit_cast()

template<typename Tgt , typename Src >

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Tgt Eigen::numext::bit_cast

(

const Src &

src

)

bit-wise cast without changing the underlying bit representation.

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

References EIGEN_STATIC_ASSERT, EIGEN_USING_STD, and Eigen::value.

bit_cast< Eigen::bfloat16, uint16_t >()

template<>

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 Eigen::numext::bit_cast< Eigen::bfloat16, uint16_t >

(

const uint16_t &

src

)

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

References Eigen::bfloat16_impl::raw_uint16_to_bfloat16().

bit_cast< Eigen::half, uint16_t >()

template<>

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half Eigen::numext::bit_cast< Eigen::half, uint16_t >

(

const uint16_t &

src

)

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

References Eigen::half_impl::raw_uint16_to_half().

bit_cast< uint16_t, Eigen::bfloat16 >()

template<>

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC uint16_t Eigen::numext::bit_cast< uint16_t, Eigen::bfloat16 >

(

const Eigen::bfloat16 &

src

)

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

References Eigen::bfloat16_impl::raw_bfloat16_as_uint16().

bit_cast< uint16_t, Eigen::half >()

template<>

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC uint16_t Eigen::numext::bit_cast< uint16_t, Eigen::half >

(

const Eigen::half &

src

)

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

References Eigen::half_impl::raw_half_as_uint16().

cbrt()

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T Eigen::numext::cbrt

(

const T &

x

)

Returns

the cube root of x.

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

References EIGEN_USING_STD, and plotDoE::x.

Referenced by Thermal< Particle >::actionsAfterTimeStep(), Membrane::adjustVertexParticleSize(), array_generic(), array_real(), ClosedCSCWalls::ClosedCSCWalls(), BaseCluster::computeInternalStructure(), HertzianSinterInteraction::computeSinterForce(), HertzianSinterNormalSpecies::computeTimeStep(), CSCInit::CSCInit(), CSCWalls::CSCWalls(), HertzianViscoelasticInteraction::getElasticEnergyAtEquilibrium(), LiquidMigrationLSInteraction::getFieldVTK(), LiquidMigrationWilletInteraction::getFieldVTK(), SolidifyingLiquidMigrationWilletInteraction::getFieldVTK(), MeltableNormalSpecies::getRelativeSolidRadius(), LiquidMigrationLSInteraction::getRuptureDistance(), LiquidMigrationWilletInteraction::getRuptureDistance(), main(), LiquidBridgeBagheriSpecies::mix(), LiquidBridgeClassicalWilletSpecies::mix(), LiquidBridgeWilletSpecies::mix(), Eigen::internal::scalar_cbrt_op< Scalar >::operator()(), BaseCluster::particleInsertionSuccessful(), Eigen::internal::pcbrt(), FileReader::read(), LiquidBridgeBagheriSpecies::read(), LiquidBridgeClassicalWilletSpecies::read(), LiquidBridgeWilletSpecies::read(), PSD::scaleParticleSizeAuto(), BaseCluster::setDomainLimits(), LiquidMigrationLSSpecies::setInteractionDistance(), LiquidMigrationWilletSpecies::setInteractionDistance(), LiquidBridgeBagheriSpecies::setLiquidBridgeVolume(), LiquidBridgeClassicalWilletSpecies::setLiquidBridgeVolume(), LiquidBridgeWilletSpecies::setLiquidBridgeVolume(), ClosedCSCWalls::setupInitialConditions(), CSCInit::setupInitialConditions(), CSCWalls::setupInitialConditions(), RotatingDrumWet::setupInitialConditions(), ParticleCreation::setupInitialConditions(), HertzianSinterForceUnitTest::setupInitialConditions(), BaseCluster::setupInitialConditions(), DPMBase::splitDomain(), test_cwise_real(), unary_ops_test(), and MindlinInteraction::updateK_t().

ceil()

template<typename Scalar >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar() Eigen::numext::ceil

(

const Scalar &

x

)

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

Referenced by Eigen::internal::scalar_ceil_op< Scalar >::operator()(), Eigen::internal::nearest_integer_packetop_impl< Packet, IsScalar, IsInteger >::run_ceil(), Eigen::TensorEvaluator< const TensorImagePatchOp< Rows, Cols, ArgType >, Device >::TensorEvaluator(), Eigen::TensorEvaluator< const TensorStridingOp< Strides, ArgType >, Device >::TensorEvaluator(), and Eigen::TensorEvaluator< const TensorVolumePatchOp< Planes, Rows, Cols, ArgType >, Device >::TensorEvaluator().

cos()

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T Eigen::numext::cos

(

const T &

x

)

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

References cos(), EIGEN_USING_STD, and plotDoE::x.

Referenced by Eigen::MatrixBase< Derived >::canonicalEulerAngles(), Eigen::MatrixBase< Derived >::eulerAngles(), Eigen::TensorEvaluator< const TensorFFTOp< FFT, ArgType, FFTResultType, FFTDir >, Device >::evalToBuf(), Eigen::SkewSymmetricBase< Derived >::exponential(), Eigen::internal::kiss_cpx_fft< Scalar_ >::make_twiddles(), and Eigen::internal::scalar_cos_op< Scalar >::operator()().

cosh()

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T Eigen::numext::cosh

(

const T &

x

)

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

References EIGEN_USING_STD, and plotDoE::x.

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

div_ceil()

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE EIGEN_CONSTEXPR T Eigen::numext::div_ceil	(	T	a,
		T	b
	)

                                                                           {
  using UnsignedT = typename internal::make_unsigned<T>::type;
  EIGEN_STATIC_ASSERT((NumTraits<T>::IsInteger), THIS FUNCTION IS FOR INTEGER TYPES)
  eigen_assert(a >= 0);
  eigen_assert(b > 0);
  // Note: explicitly declaring a and b as non-negative values allows the compiler to use better optimizations
  const UnsignedT ua = UnsignedT(a);
  const UnsignedT ub = UnsignedT(b);
  // Note: This form is used because it cannot overflow.
  return ua == 0 ? 0 : (ua - 1) / ub + 1;
}

Referenced by Eigen::internal::gemm_class< Scalar, is_unit_inc >::c_update_1count(), Eigen::divup(), Eigen::internal::evaluateProductBlockingSizesHeuristic(), Eigen::internal::TensorBlockMapper< NumDims, Layout, IndexType >::InitializeBlockDimensions(), Eigen::internal::gemm_class< Scalar, is_unit_inc >::innerkernel_1uk(), Eigen::internal::gemm_class< Scalar, is_unit_inc >::kloop(), Eigen::internal::InnerMostDimReducer< Self, Op, true, true >::reduce(), cast_test_impl< SrcType, DstType, RowsAtCompileTime, ColsAtCompileTime >::run(), and Eigen::ForkJoinScheduler::RunParallelForAsync().

EIGEN_MATHFUNC_RETVAL() [1/38]

template<typename Scalar >

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

inline

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

EIGEN_MATHFUNC_RETVAL() [2/38]

template<typename Scalar >

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

inline

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

EIGEN_MATHFUNC_RETVAL() [3/38]

template<typename Scalar >

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

inline

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

References Eigen::bessel_i0(), EIGEN_MATHFUNC_IMPL, Eigen::run(), and x.

EIGEN_MATHFUNC_RETVAL() [4/38]

template<typename Scalar >

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

inline

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

References Eigen::bessel_i0e(), EIGEN_MATHFUNC_IMPL, Eigen::run(), and x.

EIGEN_MATHFUNC_RETVAL() [5/38]

template<typename Scalar >

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

inline

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

References Eigen::bessel_i1(), EIGEN_MATHFUNC_IMPL, Eigen::run(), and x.

EIGEN_MATHFUNC_RETVAL() [6/38]

template<typename Scalar >

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

inline

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

References Eigen::bessel_i1e(), EIGEN_MATHFUNC_IMPL, Eigen::run(), and x.

EIGEN_MATHFUNC_RETVAL() [7/38]

template<typename Scalar >

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

inline

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

References Eigen::bessel_j0(), EIGEN_MATHFUNC_IMPL, Eigen::run(), and x.

EIGEN_MATHFUNC_RETVAL() [8/38]

template<typename Scalar >

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

inline

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

References Eigen::bessel_j1(), EIGEN_MATHFUNC_IMPL, Eigen::run(), and x.

EIGEN_MATHFUNC_RETVAL() [9/38]

template<typename Scalar >

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

inline

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

References Eigen::bessel_k0(), EIGEN_MATHFUNC_IMPL, Eigen::run(), and x.

EIGEN_MATHFUNC_RETVAL() [10/38]

template<typename Scalar >

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

inline

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

References Eigen::bessel_k0e(), EIGEN_MATHFUNC_IMPL, Eigen::run(), and x.

EIGEN_MATHFUNC_RETVAL() [11/38]

template<typename Scalar >

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

inline

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

References Eigen::bessel_k1(), EIGEN_MATHFUNC_IMPL, Eigen::run(), and x.

EIGEN_MATHFUNC_RETVAL() [12/38]

template<typename Scalar >

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

inline

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

References Eigen::bessel_k1e(), EIGEN_MATHFUNC_IMPL, Eigen::run(), and x.

EIGEN_MATHFUNC_RETVAL() [13/38]

template<typename Scalar >

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

inline

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

References Eigen::bessel_y0(), EIGEN_MATHFUNC_IMPL, Eigen::run(), and x.

EIGEN_MATHFUNC_RETVAL() [14/38]

template<typename Scalar >

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

inline

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

References Eigen::bessel_y1(), EIGEN_MATHFUNC_IMPL, Eigen::run(), and x.

EIGEN_MATHFUNC_RETVAL() [15/38]

template<typename Scalar >

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

inline

EIGEN_MATHFUNC_RETVAL() [16/38]

template<typename Scalar >

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

inline

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

EIGEN_MATHFUNC_RETVAL() [17/38]

template<typename Scalar >

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

inline

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

References EIGEN_MATHFUNC_IMPL, Eigen::run(), and x.

EIGEN_MATHFUNC_RETVAL() [18/38]

template<typename Scalar >

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

inline

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

References EIGEN_MATHFUNC_IMPL, Eigen::run(), and x.

EIGEN_MATHFUNC_RETVAL() [19/38]

template<typename Scalar >

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

inline

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

References EIGEN_MATHFUNC_IMPL, Eigen::run(), and x.

EIGEN_MATHFUNC_RETVAL() [20/38]

template<typename Scalar >

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

inline

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

References EIGEN_MATHFUNC_IMPL, Eigen::internal::std_fallback::expm1(), Eigen::run(), and plotDoE::x.

EIGEN_MATHFUNC_RETVAL() [21/38]

template<typename Scalar >

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

inline

References a, EIGEN_MATHFUNC_IMPL, Eigen::gamma_sample_der_alpha(), Eigen::run(), and x.

EIGEN_MATHFUNC_RETVAL() [22/38]

template<typename Scalar >

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

inline

EIGEN_MATHFUNC_RETVAL() [23/38]

template<typename Scalar >

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

inline

References a, EIGEN_MATHFUNC_IMPL, Eigen::igamma(), Eigen::run(), and x.

EIGEN_MATHFUNC_RETVAL() [24/38]

template<typename Scalar >

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

inline

References a, EIGEN_MATHFUNC_IMPL, Eigen::igamma_der_a(), Eigen::run(), and x.

EIGEN_MATHFUNC_RETVAL() [25/38]

template<typename Scalar >

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

inline

References a, EIGEN_MATHFUNC_IMPL, Eigen::igammac(), Eigen::run(), and x.

EIGEN_MATHFUNC_RETVAL() [26/38]

template<typename Scalar >

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

inline

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

EIGEN_MATHFUNC_RETVAL() [27/38]

template<typename Scalar >

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

inline

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

EIGEN_MATHFUNC_RETVAL() [28/38]

template<typename Scalar >

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

inline

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

References EIGEN_MATHFUNC_IMPL, Eigen::run(), and x.

EIGEN_MATHFUNC_RETVAL() [29/38]

template<typename Scalar >

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

inline

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

EIGEN_MATHFUNC_RETVAL() [30/38]

template<typename Scalar >

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

inline

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

References EIGEN_MATHFUNC_IMPL, Eigen::run(), and x.

EIGEN_MATHFUNC_RETVAL() [31/38]

template<typename Scalar >

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

inline

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

EIGEN_MATHFUNC_RETVAL() [32/38]

template<typename Scalar >

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

inline

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

EIGEN_MATHFUNC_RETVAL() [33/38]

template<typename Scalar >

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

inline

References EIGEN_MATHFUNC_IMPL, n, Eigen::polygamma(), Eigen::run(), and x.

EIGEN_MATHFUNC_RETVAL() [34/38]

template<typename Scalar >

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

inline

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

EIGEN_MATHFUNC_RETVAL() [35/38]

template<typename Scalar >

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

inline

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

EIGEN_MATHFUNC_RETVAL() [36/38]

template<typename Scalar >

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

inline

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

EIGEN_MATHFUNC_RETVAL() [37/38]

template<typename Scalar >

EIGEN_DEVICE_FUNC 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.

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

References EIGEN_MATHFUNC_IMPL, Eigen::run(), sqrt(), and plotDoE::x.

EIGEN_MATHFUNC_RETVAL() [38/38]

template<typename Scalar >

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

inline

References EIGEN_MATHFUNC_IMPL, q, Eigen::run(), x, and Eigen::zeta().

equal_strict() [1/3]

template<>

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

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

References plotDoE::x, and Eigen::internal::y.

Referenced by is_exactly_one(), and is_exactly_zero().

equal_strict() [2/3]

template<>

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

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

References plotDoE::x, and Eigen::internal::y.

equal_strict() [3/3]

template<typename X , typename Y >

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

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

References run(), plotDoE::x, and Eigen::internal::y.

Referenced by alignedbox(), alignedboxCastTests(), check_if_equal_or_nans(), Eigen::BDCSVD< MatrixType_, Options_ >::computeSingVals(), Eigen::internal::std_fallback::expm1(), Eigen::internal::std_fallback::log1p(), matrixVisitor(), AnnoyingScalar::operator==(), Eigen::bfloat16_impl::operator==(), Eigen::half_impl::operator==(), Eigen::internal::pselect_impl< Packet, std::enable_if_t< is_scalar< Packet >::value > >::run(), Eigen::internal::sizes_match_below_dim< Dims1, Dims2, n, n >::run(), Eigen::internal::zeta_impl< Scalar >::run(), test_cwise_complex(), test_cwise_real(), and Eigen::test_is_equal().

exp()

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T Eigen::numext::exp

(

const T &

x

)

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

References EIGEN_USING_STD, and plotDoE::x.

Referenced by Eigen::internal::std_fallback::expm1(), Eigen::internal::main_igamma_term(), Eigen::internal::GaussianGenerator< T, Index, NumDims >::operator()(), Eigen::internal::scalar_logistic_op< float >::operator()(), Eigen::internal::scalar_logistic_op_impl< T, std::enable_if_t< NumTraits< T >::IsComplex > >::operator()(), and Eigen::internal::pexp().

exp2()

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T Eigen::numext::exp2

(

const T &

x

)

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

References EIGEN_USING_STD, and plotDoE::x.

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

floor()

template<typename Scalar >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar() Eigen::numext::floor

(

const Scalar &

x

)

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

Referenced by Eigen::internal::unary_pow::exponent_helper< ScalarExponent, IsInteger >::floor_div_two(), Eigen::internal::unary_pow::exponent_helper< ScalarExponent, IsInteger >::is_odd(), Eigen::internal::scalar_floor_op< Scalar >::operator()(), Eigen::internal::digamma_impl< Scalar >::run(), Eigen::internal::zeta_impl< Scalar >::run(), and Eigen::internal::nearest_integer_packetop_impl< Packet, IsScalar, IsInteger >::run_floor().

fmod()

template<typename T >

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

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

References a, b, and EIGEN_USING_STD.

Referenced by Eigen::internal::scalar_fmod_op< Scalar >::operator()(), Eigen::Rotation2D< Scalar_ >::smallestAngle(), and Eigen::Rotation2D< Scalar_ >::smallestPositiveAngle().

imag_ref()

template<typename Scalar >

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

inline

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

Referenced by basicStuffComplex(), Eigen::internal::GetMarketLine(), exp_complex_test_impl< Scalar, Packet, HasExp >::is_exactly_equal(), exp_complex_test_impl< Scalar, Packet, HasExp >::is_sign_exp_unspecified(), Eigen::internal::scalar_imag_ref_op< Scalar >::operator()(), and exp_complex_test_impl< Scalar, Packet, HasExp >::run().

is_exactly_one()

template<typename X >

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool Eigen::numext::is_exactly_one

(

const X &

x

)

Performs an exact comparison of x to one, e.g. to decide whether a factor needs to be multiplied. Use this to to bypass -Wfloat-equal warnings when exact one is what needs to be tested.

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

References equal_strict(), and plotDoE::x.

Referenced by Eigen::internal::apply_rotation_in_the_plane(), Eigen::internal::generic_product_impl< Lhs, Rhs, DenseShape, DenseShape, CoeffBasedProductMode >::eval_dynamic_impl(), Eigen::internal::trmv_selector< Mode, ColMajor >::run(), Eigen::internal::trmv_selector< Mode, RowMajor >::run(), and Eigen::internal::triangular_product_impl< Mode, LhsIsTriangular, Lhs, false, Rhs, false >::run().

is_exactly_zero()

template<typename X >

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool Eigen::numext::is_exactly_zero

(

const X &

x

)

Performs an exact comparison of x to zero, e.g. to decide whether a term can be ignored. Use this to to bypass -Wfloat-equal warnings when exact zero is what needs to be tested.

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

References equal_strict(), and plotDoE::x.

Referenced by Eigen::internal::apply_rotation_in_the_plane(), Eigen::MatrixBase< Derived >::applyHouseholderOnTheLeft(), Eigen::MatrixBase< Derived >::applyHouseholderOnTheRight(), Eigen::internal::complex_rsqrt(), Eigen::internal::complex_sqrt(), Eigen::SelfAdjointEigenSolver< MatrixType_ >::compute(), Eigen::RealQZ< MatrixType_ >::compute(), Eigen::SPQR< MatrixType_ >::compute(), Eigen::BDCSVD< MatrixType_, Options_ >::compute_impl(), Eigen::JacobiSVD< MatrixType_, Options_ >::compute_impl(), Eigen::RealSchur< MatrixType_ >::computeFromHessenberg(), Eigen::internal::computeFromTridiagonal_impl(), Eigen::FullPivLU< MatrixType_, PermutationIndex_ >::computeInPlace(), Eigen::ColPivHouseholderQR< MatrixType_, PermutationIndex_ >::computeInPlace(), Eigen::ComplexSchur< MatrixType_ >::computeShift(), Eigen::BDCSVD< MatrixType_, Options_ >::computeSingVals(), Eigen::BDCSVD< MatrixType_, Options_ >::computeSingVecs(), Eigen::BDCSVD< MatrixType_, Options_ >::computeSVDofM(), Eigen::BDCSVD< MatrixType_, Options_ >::deflation43(), Eigen::BDCSVD< MatrixType_, Options_ >::deflation44(), equalsIdentity(), Eigen::RealQZ< MatrixType_ >::findSmallSubdiagEntry(), Eigen::RealQZ< MatrixType_ >::hessenbergTriangular(), initSparse(), Eigen::internal::llt_rank_update_lower(), Eigen::JacobiRotation< Scalar >::makeGivens(), Eigen::RealSchur< MatrixType_ >::performFrancisQRStep(), Eigen::BDCSVD< MatrixType_, Options_ >::perturbCol0(), Eigen::internal::positive_real_hypot(), Eigen::internal::rcond_estimate_helper(), real_qz(), Eigen::internal::is_identically_zero_impl< AutoDiffScalar< DerivativeType > >::run(), Eigen::internal::gemv_dense_selector< OnTheRight, ColMajor, true >::run(), Eigen::internal::trmv_selector< Mode, ColMajor >::run(), Eigen::internal::sparse_solve_triangular_selector< Lhs, Rhs, Mode, Lower, ColMajor >::run(), Eigen::internal::sparse_solve_triangular_selector< Lhs, Rhs, Mode, Upper, ColMajor >::run(), Eigen::internal::sparse_solve_triangular_sparse_selector< Lhs, Rhs, Mode, UpLo, ColMajor >::run(), Eigen::internal::is_identically_zero_impl< Scalar >::run(), adjoint_specific< false >::run(), Eigen::internal::svd_precondition_2x2_block_to_be_real< MatrixType, Options, true >::run(), sparse_block(), Eigen::RealQZ< MatrixType_ >::splitOffTwoRows(), Eigen::internal::tridiagonal_qr_step(), Eigen::internal::partial_lu_impl< Scalar, StorageOrder, PivIndex, SizeAtCompileTime >::unblocked_lu(), Eigen::internal::ldlt_inplace< Lower >::updateInPlace(), and verifyIsQuasiTriangular().

isfinite() [1/3]

template<>

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool() Eigen::numext::isfinite

(

const AnnoyingScalar &

x

)

                                                                              {
  return (numext::isfinite)(*x.v);
}

References isfinite(), and x.

isfinite() [2/3]

template<>

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool() Eigen::numext::isfinite

(

const Eigen::bfloat16 &

h

)

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

References Eigen::bfloat16_impl::isfinite().

Referenced by Eigen::internal::companion< Scalar_, Deg_ >::balanced(), Eigen::internal::bicgstabl(), Eigen::EigenSolver< MatrixType_ >::compute(), Eigen::BDCSVD< MatrixType_, Options_ >::compute_impl(), Eigen::JacobiSVD< MatrixType_, Options_ >::compute_impl(), Eigen::BDCSVD< MatrixType_, Options_ >::computeSingVals(), Eigen::internal::unary_pow::handle_nonint_nonint_errors(), Eigen::internal::unary_pow::exponent_helper< ScalarExponent, IsInteger >::is_odd(), isfinite(), Eigen::internal::isfinite_impl(), Eigen::internal::scalar_isfinite_op< Scalar, UseTypedPredicate >::operator()(), Eigen::internal::scalar_isfinite_op< Scalar, true >::operator()(), Eigen::BDCSVD< MatrixType_, Options_ >::perturbCol0(), Eigen::internal::psincos_double(), Eigen::internal::psincos_float(), Eigen::internal::unary_pow_impl< Packet, ScalarExponent, false, false, ExponentIsSigned >::run(), Eigen::TensorOpCost::TensorOpCost(), and Eigen::internal::ldlt_inplace< Lower >::updateInPlace().

isfinite() [3/3]

template<typename T >

EIGEN_DEVICE_FUNC bool() Eigen::numext::isfinite

(

const T &

x

)

                                             {
  return internal::isfinite_impl(x);
}

isinf() [1/2]

template<>

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool() Eigen::numext::isinf

(

const Eigen::bfloat16 &

h

)

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

References Eigen::bfloat16_impl::isinf().

Referenced by Eigen::internal::complex_rsqrt(), Eigen::internal::complex_sqrt(), Eigen::internal::isinf_impl(), Eigen::internal::scalar_isinf_op< Scalar, UseTypedPredicate >::operator()(), Eigen::internal::scalar_isinf_op< Scalar, true >::operator()(), Eigen::internal::scalar_logistic_op_impl< T, std::enable_if_t< NumTraits< T >::IsComplex > >::operator()(), Eigen::internal::positive_real_hypot(), CustomReducer< InT, OutT >::reduce(), and Eigen::internal::igammac_cf_impl< Scalar, mode >::run().

isinf() [2/2]

template<typename T >

EIGEN_DEVICE_FUNC bool() Eigen::numext::isinf

(

const T &

x

)

                                          {
  return internal::isinf_impl(x);
}

isnan() [1/2]

template<>

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool() Eigen::numext::isnan

(

const Eigen::bfloat16 &

h

)

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

References Eigen::bfloat16_impl::isnan().

Referenced by Eigen::test::areApprox(), Eigen::test::areEqual(), Eigen::bfloat16_impl::float_to_bfloat16_rtne< false >(), Eigen::internal::minmax_coeff_visitor< Derived, is_min, NaNPropagation, false >::initpacket(), Eigen::internal::isinf_impl(), Eigen::internal::isnan_impl(), Eigen::internal::main_igamma_term(), nextafter(), Eigen::internal::scalar_isnan_op< Scalar, UseTypedPredicate >::operator()(), Eigen::internal::scalar_isnan_op< Scalar, true >::operator()(), Eigen::internal::minmax_coeff_visitor< Derived, is_min, PropagateNumbers, false >::operator()(), Eigen::internal::minmax_coeff_visitor< Derived, is_min, NaNPropagation, false >::operator()(), Eigen::internal::minmax_coeff_visitor< Derived, is_min, PropagateNumbers, false >::packet(), Eigen::internal::minmax_coeff_visitor< Derived, is_min, NaNPropagation, false >::packet(), Eigen::internal::positive_real_hypot(), CustomReducer< InT, OutT >::reduce(), Eigen::test_isCwiseApprox(), and Eigen::bfloat16_impl::truncate_to_bfloat16().

isnan() [2/2]

template<typename T >

EIGEN_DEVICE_FUNC bool() Eigen::numext::isnan

(

const T &

x

)

                                          {
  return internal::isnan_impl(x);
}

log()

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T Eigen::numext::log

(

const T &

x

)

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

References Eigen::internal::log_impl< Scalar >::run(), and plotDoE::x.

Referenced by Eigen::internal::complex_log(), Eigen::internal::std_fallback::expm1(), Eigen::internal::std_fallback::log1p(), Eigen::internal::main_igamma_term(), Eigen::internal::scalar_log_op< Scalar >::operator()(), Eigen::internal::scalar_log2_op< Scalar >::operator()(), Eigen::internal::RandomToTypeNormal(), Eigen::internal::log_impl< Scalar >::run(), Eigen::internal::igammac_cf_impl< Scalar, mode >::run(), Eigen::internal::igamma_series_impl< Scalar, mode >::run(), and Eigen::internal::digamma_impl< Scalar >::run().

log2()

EIGEN_CONSTEXPR 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);
  constexpr 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];
}

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

logical_shift_left()

template<typename Scalar , typename Enable = std::enable_if_t<std::is_integral<Scalar>::value>>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar Eigen::numext::logical_shift_left	(	const Scalar &	a,
		int	n
	)

                                                                                        {
  return a << n;
}

References a, and n.

Referenced by check_shift(), Eigen::internal::scalar_shift_left_op< Scalar, N >::operator()(), logical_left_shift_op< N, Scalar >::operator()(), Eigen::internal::plogical_shift_left(), and shift_test_impl< ArrayType >::run().

logical_shift_right()

template<typename Scalar , typename Enable = std::enable_if_t<std::is_integral<Scalar>::value>>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar Eigen::numext::logical_shift_right	(	const Scalar &	a,
		int	n
	)

                                                                                         {
  using UnsignedScalar = typename numext::get_integer_by_size<sizeof(Scalar)>::unsigned_type;
  return bit_cast<Scalar, UnsignedScalar>(bit_cast<UnsignedScalar, Scalar>(a) >> n);
}

References a, and n.

Referenced by check_shift(), logical_right_shift_op< N, Scalar >::operator()(), Eigen::internal::plogical_shift_right(), and shift_test_impl< ArrayType >::run().

maxi()

template<typename T >

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

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

Referenced by aux_evalSolver(), Eigen::internal::bicgstabl(), Eigen::TensorEvaluator< const TensorPaddingOp< PaddingDimensions, ArgType >, Device >::block(), Eigen::internal::blueNorm_impl(), Eigen::CoreThreadPoolDevice::calculateLevels(), Eigen::TensorEvaluator< const TensorStridingSlicingOp< StartIndices, StopIndices, Strides, ArgType >, Device >::clamp(), Eigen::SPQR< MatrixType_ >::compute(), Eigen::internal::TensorContractionBlockMemAllocator< LhsScalar, RhsScalar >::ComputeLhsRhsBlockSizes(), Eigen::internal::direct_selfadjoint_eigenvalues< SolverType, 3, false >::computeRoots(), Eigen::internal::conjugate_gradient(), Eigen::TensorEvaluator< const TensorAssignOp< LeftArgType, RightArgType >, Device >::costPerCoeff(), Eigen::TensorOpCost::cwiseMax(), Eigen::ComplexEigenSolver< MatrixType_ >::doComputeEigenvectors(), Eigen::internal::evaluateProductBlockingSizesHeuristic(), Eigen::SparseQR< MatrixType_, OrderingType_ >::factorize(), Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::factorize(), internal::Colamd::find_ordering(), internal::Colamd::init_scoring(), Eigen::internal::TensorBlockMapper< NumDims, Layout, IndexType >::InitializeBlockDimensions(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::insertCompressedAtByOuterInner(), Eigen::MatrixBase< Derived >::isLowerTriangular(), Eigen::MatrixBase< Derived >::isUpperTriangular(), Eigen::internal::TensorBlockResourceRequirements::merge(), Eigen::internal::scalar_clamp_op< Scalar >::operator()(), Eigen::internal::maybe_coherent_pad_helper< DerivativeType, OtherDerivativeType, EnableIf >::pad(), Eigen::internal::pmax(), Eigen::internal::positive_real_hypot(), propagate_nan_max(), propagate_number_max(), qr(), qr_invertible(), Eigen::internal::rcond_invmatrix_L1_norm_estimate(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::reserveInnerVectors(), Eigen::internal::unitOrthogonal_selector< Derived, Size >::run(), Eigen::internal::selfadjoint_matrix_vector_product< Scalar, Index, StorageOrder, UpLo, ConjugateLhs, ConjugateRhs, Version >::run(), Eigen::internal::random_longdouble_impl< Specialize >::run(), Eigen::internal::triangular_assignment_loop< Kernel, Mode, Dynamic, SetOpposite >::run(), Eigen::internal::set_from_triplets(), Eigen::QuaternionBase< Derived >::setFromTwoVectors(), test_argmax_pair_reducer(), test_clip(), test_cwise_real(), test_sum_accuracy(), test_threaded_assignment(), verify_is_approx_upto_permutation(), and Eigen::internal::TensorBlockResourceRequirements::withShapeAndSize().

mini()

template<typename T >

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

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

Referenced by Eigen::SVDBase< Derived >::allocate(), array_generic(), basicStuff(), Eigen::TensorEvaluator< const TensorPaddingOp< PaddingDimensions, ArgType >, Device >::block(), Eigen::internal::TensorBlockMapper< NumDims, Layout, IndexType >::blockDescriptor(), Eigen::internal::blueNorm_impl(), calc_overflow_threshold(), Eigen::CoreThreadPoolDevice::calculateLevels(), Eigen::TensorEvaluator< const TensorStridingSlicingOp< StartIndices, StopIndices, Strides, ArgType >, Device >::clamp(), Eigen::TensorOpCost::cwiseMin(), Eigen::MatrixBase< Derived >::diagonalSize(), Eigen::TensorContractionEvaluatorBase< Derived >::evalGemmPartial(), Eigen::SparseQR_QProduct< SparseQRType, Derived >::evalTo(), Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::factorize(), internal::Colamd::find_ordering(), gemv_bfloat16_col(), gemv_col(), gemv_complex_col(), Eigen::internal::gemvMMA_bfloat16_col(), Eigen::ColPivHouseholderQR< MatrixType_, PermutationIndex_ >::init(), internal::Colamd::init_scoring(), Eigen::internal::TensorBlockMapper< NumDims, Layout, IndexType >::InitializeBlockDimensions(), 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::random_float_impl< Scalar, false >::mantissaBits(), Eigen::TensorCostModel< Device >::numThreads(), Eigen::internal::scalar_logistic_op< float >::operator()(), Eigen::internal::scalar_clamp_op< Scalar >::operator()(), packetmath_real(), Eigen::internal::pgather_partial(), Eigen::internal::pload_partial(), Eigen::internal::ploadu_partial(), Eigen::internal::pmin(), Eigen::internal::positive_real_hypot(), propagate_nan_min(), propagate_number_min(), Eigen::internal::pscatter_partial(), Eigen::internal::pstore_partial(), Eigen::internal::pstoreu_partial(), qr_invertible(), RandomBlock(), Eigen::internal::InnerMostDimReducer< Self, Op, true, true >::reduce(), Eigen::internal::isApprox_selector< Derived, OtherDerived, is_integer >::run(), Eigen::internal::conservative_resize_like_impl< Derived, OtherDerived, IsVector >::run(), Eigen::internal::setIdentity_impl< Derived, true >::run(), Eigen::internal::general_matrix_vector_product< Index, LhsScalar, LhsMapper, ColMajor, ConjugateLhs, RhsScalar, RhsMapper, ConjugateRhs, Version >::run(), Eigen::internal::random_longdouble_impl< Specialize >::run(), Eigen::internal::dense_assignment_loop< Kernel, SliceVectorizedTraversal, NoUnrolling >::run(), Eigen::internal::triangular_assignment_loop< Kernel, Mode, Dynamic, SetOpposite >::run(), Eigen::internal::sparse_reserve_op< StorageIndex >::sparse_reserve_op(), Eigen::internal::swap_plain_array(), test_argmin_pair_reducer(), test_assign_to_tensor_slice(), test_clip(), test_cwise_real(), test_eval_tensor_slice(), test_execute_slice_lvalue(), test_execute_slice_rvalue(), test_exponent(), and Eigen::test_relative_error().

nextafter()

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 Eigen::numext::nextafter	(	const bfloat16 &	from,
		const bfloat16 &	to
	)

                                                                                                   {
  if (numext::isnan EIGEN_NOT_A_MACRO(from)) {
    return from;
  }
  if (numext::isnan EIGEN_NOT_A_MACRO(to)) {
    return to;
  }
  if (from == to) {
    return to;
  }
  uint16_t from_bits = numext::bit_cast<uint16_t>(from);
  bool from_sign = from_bits >> 15;
  // Whether we are adjusting toward the infinity with the same sign as from.
  bool toward_inf = (to > from) == !from_sign;
  if (toward_inf) {
    ++from_bits;
  } else if ((from_bits & 0x7fff) == 0) {
    // Adjusting away from inf, but from is zero, so just toggle the sign.
    from_bits ^= 0x8000;
  } else {
    --from_bits;
  }
  return numext::bit_cast<bfloat16>(from_bits);
}

References EIGEN_NOT_A_MACRO, and isnan().

Referenced by MercuryBase::hGridRebuild(), HGridOptimiser::initialise(), HGridOptimiser::initialisePolyFunc(), and test_nextafter().

not_equal_strict() [1/3]

template<>

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

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

References plotDoE::x, and Eigen::internal::y.

not_equal_strict() [2/3]

template<>

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

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

References plotDoE::x, and Eigen::internal::y.

not_equal_strict() [3/3]

template<typename X , typename Y >

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

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

References run(), plotDoE::x, and Eigen::internal::y.

Referenced by Eigen::test::areApprox(), Eigen::test::areEqual(), AnnoyingScalar::operator!=(), Eigen::bfloat16_impl::operator!=(), Eigen::half_impl::operator!=(), and Eigen::internal::predux_any().

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);
}

Referenced by Eigen::internal::scalar_pow_op< Scalar, Exponent >::operator()(), Eigen::poly_eval(), Eigen::internal::pow_impl< ScalarX, ScalarY, IsInteger >::run(), Eigen::internal::zeta_impl_series< double >::run(), Eigen::internal::zeta_impl_series< float >::run(), Eigen::internal::zeta_impl< Scalar >::run(), test_cwise_complex(), and test_cwise_real().

real_ref()

template<typename Scalar >

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

inline

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

Referenced by basicStuffComplex(), Eigen::ComplexEigenSolver< MatrixType_ >::doComputeEigenvectors(), Eigen::internal::GetMarketLine(), exp_complex_test_impl< Scalar, Packet, HasExp >::is_exactly_equal(), exp_complex_test_impl< Scalar, Packet, HasExp >::is_sign_exp_unspecified(), Eigen::klu_factor(), Eigen::klu_solve(), Eigen::klu_tsolve(), Eigen::internal::scalar_real_ref_op< Scalar >::operator()(), Eigen::internal::pload< Packet4cf >(), Eigen::internal::pload< Packet8cf >(), Eigen::internal::ploadu< Packet4cf >(), Eigen::internal::ploadu< Packet8cf >(), Eigen::internal::pstore< std::complex< float > >(), Eigen::internal::pstoreu< std::complex< float > >(), exp_complex_test_impl< Scalar, Packet, HasExp >::run(), Eigen::PolynomialSolverBase< Scalar_, Deg_ >::selectRealRoot_withRespectToAbsRealPart(), Eigen::PolynomialSolverBase< Scalar_, Deg_ >::selectRealRoot_withRespectToRealPart(), svd_fill_random(), Eigen::umfpack_get_determinant(), Eigen::umfpack_get_numeric(), Eigen::umfpack_numeric(), Eigen::umfpack_solve(), and Eigen::umfpack_symbolic().

rint()

template<typename Scalar >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar Eigen::numext::rint

(

const Scalar &

x

)

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

Referenced by Eigen::internal::scalar_rint_op< Scalar >::operator()(), and Eigen::internal::nearest_integer_packetop_impl< Packet, IsScalar, IsInteger >::run_rint().

round()

template<typename Scalar >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar Eigen::numext::round

(

const Scalar &

x

)

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

Referenced by main(), Eigen::internal::scalar_round_op< Scalar >::operator()(), Eigen::internal::unary_pow_impl< Packet, ScalarExponent, false, false, ExponentIsSigned >::run(), and Eigen::internal::nearest_integer_packetop_impl< Packet, IsScalar, IsInteger >::run_round().

round_down()

template<typename T , typename U >

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE EIGEN_CONSTEXPR T Eigen::numext::round_down	(	T	a,
		U	b
	)

                                                                             {
  using UnsignedT = typename internal::make_unsigned<T>::type;
  using UnsignedU = typename internal::make_unsigned<U>::type;
  EIGEN_STATIC_ASSERT((NumTraits<T>::IsInteger), THIS FUNCTION IS FOR INTEGER TYPES)
  EIGEN_STATIC_ASSERT((NumTraits<U>::IsInteger), THIS FUNCTION IS FOR INTEGER TYPES)
  eigen_assert(a >= 0);
  eigen_assert(b > 0);
  // Note: explicitly declaring a and b as non-negative values allows the compiler to use better optimizations
  const UnsignedT ua = UnsignedT(a);
  const UnsignedU ub = UnsignedU(b);
  return ub * (ua / ub);
}

Referenced by Eigen::internal::dense_assignment_loop_with_device< Kernel, CoreThreadPoolDevice, SliceVectorizedTraversal, NoUnrolling >::ScalarAssignmentFunctor::operator()(), Eigen::CoreThreadPoolDevice::parallelForImpl(), Eigen::internal::inner_product_impl< Evaluator, true >::run(), Eigen::internal::dense_assignment_loop_with_device< Kernel, CoreThreadPoolDevice, SliceVectorizedTraversal, NoUnrolling >::run(), Eigen::internal::dense_assignment_loop_with_device< Kernel, CoreThreadPoolDevice, LinearVectorizedTraversal, NoUnrolling >::run(), and Eigen::internal::stable_norm_impl_inner_step().

rsqrt()

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T Eigen::numext::rsqrt

(

const T &

x

)

Returns

the reciprocal square root of x.

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

References Eigen::internal::rsqrt_impl< T >::run(), and plotDoE::x.

Referenced by array_real(), Eigen::internal::scalar_rsqrt_op< Scalar >::operator()(), packetmath(), packetmath_real(), check_rsqrt_impl< T >::run(), check_rsqrt_impl< std::complex< T > >::run(), and Eigen::internal::generic_sqrt_newton_step< Packet, Steps >::run().

signbit()

template<typename Scalar >

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

staticconstexpr

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

References run(), and plotDoE::x.

Referenced by binary_op_test(), float_pow_test_impl(), Eigen::bfloat16_impl::float_to_bfloat16_rtne< false >(), exp_complex_test_impl< Scalar, Packet, HasExp >::is_exactly_equal(), Eigen::internal::test_signbit_op< Scalar >::operator()(), check_signbit_impl< T >::run(), Eigen::internal::psignbit_impl< Packet, true, IsInteger >::run(), Eigen::internal::unary_pow::exponent_helper< ScalarExponent, true >::safe_abs(), signbit_test(), Eigen::bfloat16_impl::truncate_to_bfloat16(), and unary_op_test().

sin()

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T Eigen::numext::sin

(

const T &

x

)

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

References EIGEN_USING_STD, sin(), and plotDoE::x.

Referenced by Eigen::MatrixBase< Derived >::canonicalEulerAngles(), Eigen::MatrixBase< Derived >::eulerAngles(), Eigen::TensorEvaluator< const TensorFFTOp< FFT, ArgType, FFTResultType, FFTDir >, Device >::evalToBuf(), Eigen::SkewSymmetricBase< Derived >::exponential(), Eigen::internal::kiss_cpx_fft< Scalar_ >::make_twiddles(), Eigen::internal::scalar_sin_op< Scalar >::operator()(), and Eigen::internal::expm1_impl< std::complex< RealScalar > >::run().

sinh()

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T Eigen::numext::sinh

(

const T &

x

)

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

References EIGEN_USING_STD, and plotDoE::x.

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

sqrt() [1/2]

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://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
}

References Eigen::internal::pfirst(), and x.

sqrt() [2/2]

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(), and x.

Referenced by Eigen::internal::bicgstabl(), Eigen::internal::complex_rsqrt(), Eigen::internal::complex_sqrt(), Eigen::ColPivHouseholderQR< MatrixType_, PermutationIndex_ >::computeInPlace(), Eigen::internal::conjugate_gradient(), Eigen::SkewSymmetricBase< Derived >::exponential(), Eigen::internal::idrstabl(), Eigen::MatrixBase< Derived >::makeHouseholder(), Eigen::MatrixBase< Derived >::norm(), Eigen::MatrixBase< Derived >::normalize(), Eigen::MatrixBase< Derived >::normalized(), Eigen::internal::scalar_sqrt_op< Scalar >::operator()(), Eigen::internal::psqrt(), Eigen::internal::psqrt< Packet4f >(), Eigen::internal::rsqrt_impl< T >::run(), Eigen::MatrixBase< Derived >::stableNormalize(), Eigen::MatrixBase< Derived >::stableNormalized(), test_cwise_complex(), test_cwise_real(), and Eigen::test_relative_error().

sqrt< bool >()

template<>

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

(

const bool &

x

)

                                                                                                     {
  return x;
}

References plotDoE::x.

swap()

template<typename T >

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

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

References a, and b.

Referenced by Eigen::internal::computeFromTridiagonal_impl(), Eigen::TensorStorage< T, DSizes< IndexType, NumIndices_ >, Options_ >::operator=(), Eigen::internal::direct_selfadjoint_eigenvalues< SolverType, 3, false >::run(), Eigen::internal::DenseStorage_impl< T, Size, Rows, Cols, Options >::swap(), Eigen::internal::DenseStorage_impl< T, Size, Dynamic, Cols, Options >::swap(), Eigen::internal::DenseStorage_impl< T, Size, Rows, Dynamic, Options >::swap(), Eigen::internal::DenseStorage_impl< T, Size, Dynamic, Dynamic, Options >::swap(), Eigen::internal::DenseStorage_impl< T, 0, Dynamic, Cols, Options >::swap(), Eigen::internal::DenseStorage_impl< T, 0, Rows, Dynamic, Options >::swap(), Eigen::internal::DenseStorage_impl< T, 0, Dynamic, Dynamic, Options >::swap(), Eigen::internal::DenseStorage_impl< T, Dynamic, Dynamic, Cols, Options >::swap(), Eigen::internal::DenseStorage_impl< T, Dynamic, Rows, Dynamic, Options >::swap(), Eigen::internal::DenseStorage_impl< T, Dynamic, Dynamic, Dynamic, Options >::swap(), Eigen::Pair< U, V >::swap(), Eigen::TensorStorage< T, DSizes< IndexType, NumIndices_ >, Options_ >::swap(), Eigen::internal::tuple_impl::TupleImpl< N, T1, Ts... >::swap(), and Eigen::TensorContractionEvaluatorBase< Derived >::TensorContractionEvaluatorBase().

tan()

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T Eigen::numext::tan

(

const T &

x

)

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

References EIGEN_USING_STD, and plotDoE::x.

Referenced by Eigen::internal::scalar_tan_op< Scalar >::operator()(), and Eigen::internal::digamma_impl< Scalar >::run().

tanh()

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T Eigen::numext::tanh

(

const T &

x

)

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

References EIGEN_USING_STD, and plotDoE::x.

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

trunc()

template<typename Scalar >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar() Eigen::numext::trunc

(

const Scalar &

x

)

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

Referenced by Eigen::internal::scalar_trunc_op< Scalar >::operator()(), and Eigen::internal::nearest_integer_packetop_impl< Packet, IsScalar, IsInteger >::run_trunc().

Variable Documentation

b

EIGEN_DEVICE_FUNC const Scalar& Eigen::numext::b

Referenced by Eigen::internal::generic_ndtri(), Eigen::internal::generic_ndtri_gt_exp_neg_two(), Eigen::internal::generic_ndtri_lt_exp_neg_two(), Eigen::internal::zeta_impl_series< double >::run(), Eigen::internal::zeta_impl_series< float >::run(), and Eigen::internal::zeta_impl< Scalar >::run().

q

EIGEN_DEVICE_FUNC const Scalar& Eigen::numext::q

Initial value:

{
  return EIGEN_MATHFUNC_IMPL(zeta, Scalar)::run(x, q)

Referenced by Eigen::AngleAxis< Scalar_ >::AngleAxis(), Quaternion::applyCInverse(), array_special_functions(), Eigen::internal::companion< Scalar_, Deg_ >::balancedR(), Eigen::internal::kiss_cpx_fft< Scalar_ >::bfly_generic(), check_slerp(), DropletBoundary::checkBoundaryAfterParticlesMove(), Mercury3Dclump::checkClumpForInteraction(), Mercury3Dclump::checkClumpForInteractionPeriodic(), DPMBase::checkParticleForInteractionLocal(), DPMBase::checkParticleForInteractionLocalPeriodic(), cod(), oomph::PoissonEquations< 1 >::compute_error(), Eigen::JacobiSVD< MatrixType_, Options_ >::compute_impl(), DPMBase::computeAllForces(), computeRoots(), Eigen::internal::direct_selfadjoint_eigenvalues< SolverType, 3, false >::computeRoots(), oomph::AxisymmetricPoroelasticityTractionElement< ELEMENT >::contribution_to_total_porous_flux(), oomph::LinearisedAxisymPoroelasticBJS_FSIElement< FLUID_BULK_ELEMENT, POROELASTICITY_BULK_ELEMENT >::contribution_to_total_porous_flux(), AxisymmetricIntersectionOfWalls::convertLimits(), HorizontalBaseScrew::convertLimits(), ScrewsymmetricIntersectionOfWalls::convertLimits(), oomph::FiniteElement::d_dshape_eulerian_dnodal_coordinates_templated_helper(), Eigen::EigenSolver< MatrixType_ >::doComputeEigenvectors(), oomph::LinearisedAxisymmetricQCrouzeixRaviartElement::dshape_and_dtest_eulerian_and_dnodal_coordinates_at_knot_lin_axi_nst(), oomph::LinearisedAxisymmetricQTaylorHoodElement::dshape_and_dtest_eulerian_and_dnodal_coordinates_at_knot_lin_axi_nst(), oomph::AxisymmetricQCrouzeixRaviartElement::dshape_and_dtest_eulerian_at_knot_axi_nst(), oomph::AxisymmetricQTaylorHoodElement::dshape_and_dtest_eulerian_at_knot_axi_nst(), oomph::GeneralisedNewtonianAxisymmetricQCrouzeixRaviartElement::dshape_and_dtest_eulerian_at_knot_axi_nst(), oomph::GeneralisedNewtonianAxisymmetricQTaylorHoodElement::dshape_and_dtest_eulerian_at_knot_axi_nst(), oomph::GeneralisedNewtonianQCrouzeixRaviartElement< DIM >::dshape_and_dtest_eulerian_at_knot_nst(), oomph::GeneralisedNewtonianQTaylorHoodElement< DIM >::dshape_and_dtest_eulerian_at_knot_nst(), oomph::GeneralisedNewtonianTCrouzeixRaviartElement< DIM >::dshape_and_dtest_eulerian_at_knot_nst(), oomph::GeneralisedNewtonianTTaylorHoodElement< DIM >::dshape_and_dtest_eulerian_at_knot_nst(), oomph::QCrouzeixRaviartElement< DIM >::dshape_and_dtest_eulerian_at_knot_nst(), oomph::QTaylorHoodElement< DIM >::dshape_and_dtest_eulerian_at_knot_nst(), oomph::TCrouzeixRaviartElement< DIM >::dshape_and_dtest_eulerian_at_knot_nst(), oomph::TTaylorHoodElement< DIM >::dshape_and_dtest_eulerian_at_knot_nst(), oomph::QTaylorHoodSpaceTimeElement< DIM >::dshape_and_dtest_eulerian_at_knot_nst(), Eigen::internal::eigen_lsx_shuffle_mask(), EIGEN_MATHFUNC_RETVAL(), Eigen::internal::eigen_neon_shuffle_mask(), EulerAngles< Scalar_ >::EulerAngles(), FancySpheres::FancySpheres(), oomph::FSIAxisymmetricLinearElasticityTractionElement< ELASTICITY_BULK_ELEMENT, NAVIER_STOKES_BULK_ELEMENT >::fill_in_contribution_to_residuals_axisym_fsi_traction(), oomph::FourierDecomposedTimeHarmonicLinElastLoadedByHelmholtzPressureBCElement< ELASTICITY_BULK_ELEMENT, HELMHOLTZ_BULK_ELEMENT >::fill_in_contribution_to_residuals_helmholtz_traction(), oomph::TimeHarmonicLinElastLoadedByHelmholtzPressureBCElement< ELASTICITY_BULK_ELEMENT, HELMHOLTZ_BULK_ELEMENT >::fill_in_contribution_to_residuals_helmholtz_traction(), oomph::TimeHarmonicLinElastLoadedByPMLHelmholtzPressureBCElement< ELASTICITY_BULK_ELEMENT, HELMHOLTZ_BULK_ELEMENT >::fill_in_contribution_to_residuals_helmholtz_traction(), oomph::LinearisedAxisymPoroelasticBJS_FSIElement< FLUID_BULK_ELEMENT, POROELASTICITY_BULK_ELEMENT >::fill_in_generic_residual_contribution_axisym_poroelastic_fsi(), oomph::LinearisedAxisymmetricNavierStokesEquations::get_base_flow_d_dudx_dX(), oomph::AxisymmetricNavierStokesEquations::get_dresidual_dnodal_coordinates(), oomph::RefineableAxisymmetricNavierStokesEquations::get_dresidual_dnodal_coordinates(), oomph::GeneralisedNewtonianAxisymmetricNavierStokesEquations::get_dresidual_dnodal_coordinates(), oomph::RefineableGeneralisedNewtonianAxisymmetricNavierStokesEquations::get_dresidual_dnodal_coordinates(), oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::get_dresidual_dnodal_coordinates(), oomph::RefineableGeneralisedNewtonianNavierStokesEquations< DIM >::get_dresidual_dnodal_coordinates(), oomph::NavierStokesEquations< DIM >::get_dresidual_dnodal_coordinates(), oomph::RefineableNavierStokesEquations< DIM >::get_dresidual_dnodal_coordinates(), oomph::RefineablePoissonEquations< DIM >::get_dresidual_dnodal_coordinates(), oomph::SpaceTimeNavierStokesEquations< DIM >::get_dresidual_dnodal_coordinates(), oomph::RefineableSpaceTimeNavierStokesEquations< DIM >::get_dresidual_dnodal_coordinates(), HorizontalScrew::getDistanceAndNormal(), Coil::getDistanceAndNormal(), ParabolaChute::getDistanceAndNormal(), SineWall::getDistanceAndNormal(), VChute::getDistanceAndNormal(), Screw::getDistanceAndNormalLabCoordinates(), Sintering::getMeanPlasticOverlap(), oomph::QTaylorHoodElement< 2 >::identify_load_data(), Eigen::internal::idrstabl(), oomph::AxisymmetricNavierStokesEquations::interpolated_d_dudx_dX_axi_nst(), oomph::GeneralisedNewtonianAxisymmetricNavierStokesEquations::interpolated_d_dudx_dX_axi_nst(), oomph::AxisymmetricPoroelasticityEquations::interpolated_q(), oomph::DarcyEquations< DIM >::interpolated_q(), Domain::isInNewBoundaryParticleList(), jacobi(), LaserOnLayer::LaserOnLayer(), Camera::localRotate(), main(), Eigen::JacobiRotation< Scalar >::makeGivens(), Eigen::JacobiRotation< Scalar >::makeJacobi(), Eigen::ThreadPoolTempl< Environment >::MaybeGetTask(), Eigen::internal::minimum_degree_ordering(), RenderingWidget::mouseMoveEvent(), Quaternion::multiplyQuaternions(), objectivenessTest(), oomph::PRefineableQElement< 3, INITIAL_NNODE_1D >::oc_hang_helper(), BaseParticle::oldRead(), Eigen::internal::accurate_log2< double >::operator()(), Eigen::internal::scalar_zeta_op< Scalar >::operator()(), Eigen::AngleAxis< Scalar_ >::operator=(), EulerAngles< Scalar_ >::operator=(), oomph::RankFiveTensor< T >::operator=(), oomph::RankFourTensor< T >::operator=(), oomph::LinearisedAxisymPoroelasticBJS_FSIElement< FLUID_BULK_ELEMENT, POROELASTICITY_BULK_ELEMENT >::output(), oomph::AxisymmetricPoroelasticityTractionElement< ELEMENT >::output(), oomph::PoissonEquations< 1 >::output_fct(), Eigen::internal::scalar_zeta_op< Scalar >::packetOp(), Eigen::internal::patanh_double(), oomph::TAxisymmetricPoroelasticityElement< ORDER >::pin_q_internal_value(), Eigen::internal::plog_impl_float(), LaserOnLayer::printTime(), MeltableForceLaw2SelfTest::printTime(), MeltableForceLawSelfTest::printTime(), OneParticleHeatingSelfTest::printTime(), OneParticleCoolingSelfTest::printTime(), ThermalConductionSelfTest::printTime(), Eigen::internal::psincos_double(), Eigen::internal::ptanh< Packet4f >(), Eigen::internal::ptanh_double(), Eigen::internal::ptanh_float(), Eigen::internal::ptranspose(), Eigen::internal::pzeta(), qr(), oomph::PRefineableQElement< 2, INITIAL_NNODE_1D >::quad_hang_helper(), quaternion(), randomRotationMatrix(), Eigen::internal::RandomToTypeNormal(), DPMBase::readNextDataFile(), Eigen::internal::real_2x2_jacobi_svd(), DPMBase::removeOldFiles(), Camera::rotateAroundTarget(), Eigen::internal::patan_reduced< Scalar >::run(), Eigen::internal::quat_conj< Architecture::Target, Derived, float >::run(), Eigen::internal::quat_conj< Arch, Derived, Scalar >::run(), Eigen::internal::generic_j0< T, float >::run(), Eigen::internal::generic_j0< T, double >::run(), Eigen::internal::generic_y0< T, float >::run(), Eigen::internal::generic_y0< T, double >::run(), Eigen::internal::generic_j1< T, float >::run(), Eigen::internal::generic_j1< T, double >::run(), Eigen::internal::generic_y1< T, float >::run(), Eigen::internal::generic_y1< T, double >::run(), Eigen::internal::generic_fast_erf< Scalar >::run(), Eigen::internal::tridiagonalization_inplace_selector< MatrixType, 3, false >::run(), Eigen::internal::quaternionbase_assign_impl< Other, 3, 3 >::run(), Eigen::internal::quaternionbase_assign_impl< Other, 4, 1 >::run(), Eigen::internal::digamma_impl< Scalar >::run(), Eigen::internal::zeta_impl< Scalar >::run(), Eigen::internal::svd_precondition_2x2_block_to_be_real< MatrixType, Options, true >::run(), Eigen::ThreadPoolTempl< Environment >::ScheduleWithHint(), RNG::setLaggedFibonacciGeneratorParameters(), Camera::setOrientation(), oomph::FourierDecomposedHelmholtzDtNMesh< ELEMENT >::setup_gamma(), oomph::HelmholtzDtNMesh< ELEMENT >::setup_gamma(), CubicCell::setupInitialConditions(), DPM::setupInitialConditions(), SeparateFilesSelfTest::setupInitialConditions(), Eigen::RealQZ< MatrixType_ >::splitOffTwoRows(), Eigen::RealSchur< MatrixType_ >::splitOffTwoRows(), oomph::AxisymmetricPoroelasticityEquations::switch_off_darcy(), test_basic_runqueue(), test_empty_runqueue(), test_stress_eventcount(), test_stress_runqueue(), transform_associativity2(), transform_associativity_left(), Eigen::internal::tridiagonal_qr_step(), Eigen::internal::trig_reduce_huge(), Eigen::internal::trig_reduce_small_double(), Camera::updateViewMatrix(), Eigen::internal::vec4f_swizzle1(), Eigen::internal::vec4f_swizzle2(), verify_euler(), HorizontalScrew::writeVTK(), Screw::writeVTK(), and Eigen::zeta().

x

EIGEN_DEVICE_FUNC const Scalar const Scalar & Eigen::numext::x

Initial value:

{
  return EIGEN_MATHFUNC_IMPL(polygamma, Scalar)::run(n, x)

Referenced by EIGEN_MATHFUNC_RETVAL(), Eigen::internal::erfc_double_large(), Eigen::internal::flipsign(), Eigen::internal::flipsign< double >(), Eigen::internal::flipsign< float >(), Eigen::internal::generic_ndtri_lt_exp_neg_two(), isfinite(), Eigen::internal::main_igamma_term(), Eigen::internal::erfc_impl< T >::run(), Eigen::internal::generic_fast_erf< Scalar >::run(), Eigen::internal::erf_impl< T >::run(), Eigen::internal::generic_fast_erfc< Scalar >::run(), Eigen::internal::zeta_impl_series< double >::run(), Eigen::internal::zeta_impl_series< float >::run(), Eigen::internal::igammac_cf_impl< Scalar, mode >::run(), Eigen::internal::igamma_series_impl< Scalar, mode >::run(), Eigen::internal::digamma_impl< Scalar >::run(), Eigen::internal::zeta_impl< Scalar >::run(), and sqrt().

y

EIGEN_DEVICE_FUNC const Scalar& Eigen::numext::y

Initial value:

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