Eigen::internal::unary_pow Namespace Reference

Classes
struct	exponent_helper
struct	exponent_helper< ScalarExponent, true >
struct	reciprocate
struct	reciprocate< Packet, ScalarExponent, false >

Functions
template<typename Packet , typename ScalarExponent >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet	int_pow (const Packet &x, const ScalarExponent &exponent)
template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet	gen_pow (const Packet &x, const typename unpacket_traits< Packet >::type &exponent)
template<typename Packet , typename ScalarExponent >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet	handle_nonint_nonint_errors (const Packet &x, const Packet &powx, const ScalarExponent &exponent)
template<typename Packet , typename ScalarExponent , std::enable_if_t< NumTraits< typename unpacket_traits< Packet >::type >::IsSigned, bool > = true>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet	handle_negative_exponent (const Packet &x, const ScalarExponent &exponent)

Function Documentation

gen_pow()

template<typename Packet >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet Eigen::internal::unary_pow::gen_pow	(	const Packet &	x,
		const typename unpacket_traits< Packet >::type &	exponent
	)

                                                                                                           {
  const Packet exponent_packet = pset1<Packet>(exponent);
  return generic_pow_impl(x, exponent_packet);
}

References Eigen::internal::generic_pow_impl(), and plotDoE::x.

Referenced by Eigen::internal::unary_pow_impl< Packet, ScalarExponent, false, false, ExponentIsSigned >::run().

handle_negative_exponent()

template<typename Packet , typename ScalarExponent , std::enable_if_t< NumTraits< typename unpacket_traits< Packet >::type >::IsSigned, bool > = true>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet Eigen::internal::unary_pow::handle_negative_exponent	(	const Packet &	x,
		const ScalarExponent &	exponent
	)

                                                                                                                       {
  using Scalar = typename unpacket_traits<Packet>::type;
 
  // signed integer base, signed integer exponent case
 
  // This routine handles negative exponents.
  // The return value is either 0, 1, or -1.
 
  const Scalar pos_zero = Scalar(0);
  const Scalar all_ones = ptrue<Scalar>(Scalar());
  const Scalar pos_one = Scalar(1);
 
  const Packet cst_pos_one = pset1<Packet>(pos_one);
 
  const bool exponent_is_odd = exponent % ScalarExponent(2) != ScalarExponent(0);
 
  const Packet exp_is_odd = pset1<Packet>(exponent_is_odd ? all_ones : pos_zero);
 
  const Packet abs_x = pabs(x);
  const Packet abs_x_is_one = pcmp_eq(abs_x, cst_pos_one);
 
  Packet result = pselect(exp_is_odd, x, abs_x);
  result = pand(abs_x_is_one, result);
  return result;
}

References Eigen::internal::pabs(), Eigen::internal::pand(), Eigen::internal::pcmp_eq(), Eigen::internal::pselect(), and plotDoE::x.

Referenced by Eigen::internal::unary_pow_impl< Packet, ScalarExponent, true, true, true >::run().

handle_nonint_nonint_errors()

template<typename Packet , typename ScalarExponent >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet Eigen::internal::unary_pow::handle_nonint_nonint_errors	(	const Packet &	x,
		const Packet &	powx,
		const ScalarExponent &	exponent
	)

                                                                                                         {
  using Scalar = typename unpacket_traits<Packet>::type;
 
  // non-integer base and exponent case
 
  const Scalar pos_zero = Scalar(0);
  const Scalar all_ones = ptrue<Scalar>(Scalar());
  const Scalar pos_one = Scalar(1);
  const Scalar pos_inf = NumTraits<Scalar>::infinity();
 
  const Packet cst_pos_zero = pzero(x);
  const Packet cst_pos_one = pset1<Packet>(pos_one);
  const Packet cst_pos_inf = pset1<Packet>(pos_inf);
 
  const bool exponent_is_not_fin = !(numext::isfinite)(exponent);
  const bool exponent_is_neg = exponent < ScalarExponent(0);
  const bool exponent_is_pos = exponent > ScalarExponent(0);
 
  const Packet exp_is_not_fin = pset1<Packet>(exponent_is_not_fin ? all_ones : pos_zero);
  const Packet exp_is_neg = pset1<Packet>(exponent_is_neg ? all_ones : pos_zero);
  const Packet exp_is_pos = pset1<Packet>(exponent_is_pos ? all_ones : pos_zero);
  const Packet exp_is_inf = pand(exp_is_not_fin, por(exp_is_neg, exp_is_pos));
  const Packet exp_is_nan = pandnot(exp_is_not_fin, por(exp_is_neg, exp_is_pos));
 
  const Packet x_is_le_zero = pcmp_le(x, cst_pos_zero);
  const Packet x_is_ge_zero = pcmp_le(cst_pos_zero, x);
  const Packet x_is_zero = pand(x_is_le_zero, x_is_ge_zero);
 
  const Packet abs_x = pabs(x);
  const Packet abs_x_is_le_one = pcmp_le(abs_x, cst_pos_one);
  const Packet abs_x_is_ge_one = pcmp_le(cst_pos_one, abs_x);
  const Packet abs_x_is_inf = pcmp_eq(abs_x, cst_pos_inf);
  const Packet abs_x_is_one = pand(abs_x_is_le_one, abs_x_is_ge_one);
 
  Packet pow_is_inf_if_exp_is_neg = por(x_is_zero, pand(abs_x_is_le_one, exp_is_inf));
  Packet pow_is_inf_if_exp_is_pos = por(abs_x_is_inf, pand(abs_x_is_ge_one, exp_is_inf));
  Packet pow_is_one = pand(abs_x_is_one, por(exp_is_inf, x_is_ge_zero));
 
  Packet result = powx;
  result = por(x_is_le_zero, result);
  result = pselect(pow_is_inf_if_exp_is_neg, pand(cst_pos_inf, exp_is_neg), result);
  result = pselect(pow_is_inf_if_exp_is_pos, pand(cst_pos_inf, exp_is_pos), result);
  result = por(exp_is_nan, result);
  result = pselect(pow_is_one, cst_pos_one, result);
  return result;
}

References Eigen::numext::isfinite(), Eigen::internal::pabs(), Eigen::internal::pand(), Eigen::internal::pandnot(), Eigen::internal::pcmp_eq(), Eigen::internal::pcmp_le(), Eigen::internal::por(), Eigen::internal::pselect(), Eigen::internal::pzero(), and plotDoE::x.

Referenced by Eigen::internal::unary_pow_impl< Packet, ScalarExponent, false, false, ExponentIsSigned >::run().

int_pow()

template<typename Packet , typename ScalarExponent >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet Eigen::internal::unary_pow::int_pow	(	const Packet &	x,
		const ScalarExponent &	exponent
	)

                                                                                                      {
  using Scalar = typename unpacket_traits<Packet>::type;
  using ExponentHelper = exponent_helper<ScalarExponent>;
  using AbsExponentType = typename ExponentHelper::safe_abs_type;
  const Packet cst_pos_one = pset1<Packet>(Scalar(1));
  if (exponent == ScalarExponent(0)) return cst_pos_one;
 
  Packet result = reciprocate<Packet, ScalarExponent>::run(x, exponent);
  Packet y = cst_pos_one;
  AbsExponentType m = ExponentHelper::safe_abs(exponent);
 
  while (m > 1) {
    bool odd = ExponentHelper::is_odd(m);
    if (odd) y = pmul(y, result);
    result = pmul(result, result);
    m = ExponentHelper::floor_div_two(m);
  }
 
  return pmul(y, result);
}

References is_odd(), m, Eigen::internal::pmul(), Eigen::internal::unary_pow::reciprocate< Packet, ScalarExponent, ReciprocateIfExponentIsNegative >::run(), plotDoE::x, and Eigen::internal::y.

Referenced by Eigen::internal::unary_pow_impl< Packet, ScalarExponent, false, false, ExponentIsSigned >::run(), Eigen::internal::unary_pow_impl< Packet, ScalarExponent, false, true, ExponentIsSigned >::run(), Eigen::internal::unary_pow_impl< Packet, ScalarExponent, true, true, true >::run(), and Eigen::internal::unary_pow_impl< Packet, ScalarExponent, true, true, false >::run().