Eigen::internal::generic_fast_erf< Scalar > Struct Template Reference

#include <SpecialFunctionsImpl.h>

Public Member Functions
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T	run (const T &x)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T	run (const T &x)

Static Public Member Functions
template<typename T >
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T	run (const T &x_in)

Member Function Documentation

run() [1/3]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T Eigen::internal::generic_fast_erf< float >::run

(

const T &

x

)

Returns

the error function of a (coeff-wise) This uses a 11/10-degree rational interpolantand is accurate to 3 ulp for normalized floats.

This implementation works on both scalars and SIMD "packets".

                                                                               {
  // The monomial coefficients of the numerator polynomial (odd).
  constexpr float alpha[] = {2.123732201653183437883853912353515625e-06f, 2.861979592125862836837768554687500000e-04f,
                             3.658048342913389205932617187500000000e-03f, 5.243302136659622192382812500000000000e-02f,
                             1.874160766601562500000000000000000000e-01f, 1.128379106521606445312500000000000000e+00f};
 
  // The monomial coefficients of the denominator polynomial (even).
  constexpr float beta[] = {3.89185734093189239501953125000e-05f, 1.14329601638019084930419921875e-03f,
                            1.47520881146192550659179687500e-02f, 1.12945675849914550781250000000e-01f,
                            4.99425798654556274414062500000e-01f, 1.0f};
 
  // Since the polynomials are odd/even, we need x^2.
  // Since erf(4) == 1 in float, we clamp x^2 to 16 to avoid
  // computing Inf/Inf below.
  const T x2 = pmin(pset1<T>(16.0f), pmul(x, x));
 
  // Evaluate the numerator polynomial p.
  T p = ppolevl<T, 5>::run(x2, alpha);
  p = pmul(x, p);
 
  // Evaluate the denominator polynomial p.
  T q = ppolevl<T, 5>::run(x2, beta);
  const T r = pdiv(p, q);
 
  // Clamp to [-1:1].
  return pmax(pmin(r, pset1<T>(1.0f)), pset1<T>(-1.0f));
}

References alpha, beta, p, Eigen::internal::pdiv(), Eigen::internal::pmax(), Eigen::internal::pmin(), Eigen::internal::pmul(), Eigen::numext::q, UniformPSDSelfTest::r, Eigen::internal::ppolevl< Packet, N >::run(), Eigen::numext::x, and Global_parameters::x2().

run() [2/3]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T Eigen::internal::generic_fast_erf< double >::run

(

const T &

x

)

                                                                                {
  T x2 = pmul(x, x);
  T erf_small = pmul(x, erf_over_x_double_small(x2));
 
  // Return early if we don't need the more expensive approximation for any
  // entry in a.
  const T one = pset1<T>(1.0);
  const T x_abs_gt_one_mask = pcmp_lt(one, x2);
  if (!predux_any(x_abs_gt_one_mask)) return erf_small;
 
  // For |x| > 1, use erf(x) = 1 - erfc(x).
  const T erf_large = psub(one, erfc_double_large(x, x2));
  return pselect(x_abs_gt_one_mask, erf_large, erf_small);
}

References Eigen::internal::erf_over_x_double_small(), Eigen::internal::erfc_double_large(), Eigen::internal::pcmp_lt(), Eigen::internal::pmul(), Eigen::internal::predux_any(), Eigen::internal::pselect(), Eigen::internal::psub(), Eigen::numext::x, and Global_parameters::x2().

run() [3/3]

template<typename Scalar >

template<typename T >

static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T Eigen::internal::generic_fast_erf< Scalar >::run ( const T &  x_in )

static

Referenced by Eigen::internal::erf_impl< T >::run().

---

The documentation for this struct was generated from the following file:

• SpecialFunctionsImpl.h