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

#include <SpecialFunctionsImpl.h>

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

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]

template<typename Scalar >

template<typename T >

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

static

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

run() [2/3]

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

(

const T &

x_in

)

                                                                                   {
  constexpr float kClamp = 11.0f;
  const T x = pmin(pmax(x_in, pset1<T>(-kClamp)), pset1<T>(kClamp));
 
  // erfc(x) = 1 + x * S(x^2), |x| <= 1.
  //
  // Coefficients for S and T generated with Rminimax command:
  // ./ratapprox --function="erfc(x)-1" --dom='[-1,1]' --type=[11,0] --num="odd"
  //   --numF="[SG]" --denF="[SG]" --log --dispCoeff="dec"
  constexpr float alpha[] = {5.61802298761904239654541015625e-04, -4.91381669417023658752441406250e-03,
                             2.67075151205062866210937500000e-02, -1.12800106406211853027343750000e-01,
                             3.76122951507568359375000000000e-01, -1.12837910652160644531250000000e+00};
  const T x2 = pmul(x, x);
  const T one = pset1<T>(1.0f);
  const T erfc_small = pmadd(x, ppolevl<T, 5>::run(x2, alpha), one);
 
  // Return early if we don't need the more expensive approximation for any
  // entry in a.
  const T x_abs_gt_one_mask = pcmp_lt(one, x2);
  if (!predux_any(x_abs_gt_one_mask)) return erfc_small;
 
  // erfc(x) = exp(-x^2) * 1/x * P(1/x^2) / Q(1/x^2), 1 < x < 9.
  //
  // Coefficients for P and Q generated with Rminimax command:
  //   ./ratapprox --function="erfc(1/sqrt(x))*exp(1/x)/sqrt(x)"
  //     --dom='[0.01,1]' --type=[3,4] --numF="[SG]" --denF="[SG]" --log
  //     --dispCoeff="dec"
  constexpr float gamma[] = {1.0208116471767425537109375e-01f, 4.2920666933059692382812500e-01f,
                             3.2379078865051269531250000e-01f, 5.3971976041793823242187500e-02f};
  constexpr float delta[] = {1.7251677811145782470703125e-02f, 3.9137163758277893066406250e-01f,
                             1.0000000000000000000000000e+00f, 6.2173241376876831054687500e-01f,
                             9.5662862062454223632812500e-02f};
  const T x2_lo = twoprod_low(x, x, x2);
  // Here we use that
  //   exp(-x^2) = exp(-(x2+x2_lo)^2) ~= exp(-x2)*exp(-x2_lo) ~= exp(-x2)*(1-x2_lo)
  // since x2_lo < kClamp * eps << 1 in the region we care about. This trick reduces the max error
  // from 34 ulps to below 5 ulps.
  const T exp2_hi = pexp(pnegate(x2));
  const T z = pnmadd(exp2_hi, x2_lo, exp2_hi);
  const T q2 = preciprocal(x2);
  const T num = ppolevl<T, 3>::run(q2, gamma);
  const T denom = pmul(x, ppolevl<T, 4>::run(q2, delta));
  const T r = pdiv(num, denom);
  const T maybe_two = pand(pcmp_lt(x, pset1<T>(0.0)), pset1<T>(2.0));
  const T erfc_large = pmadd(z, r, maybe_two);
  return pselect(x_abs_gt_one_mask, erfc_large, erfc_small);
}

References alpha, MultiOpt::delta, mathsFunc::gamma(), Eigen::internal::pand(), Eigen::internal::pcmp_lt(), Eigen::internal::pdiv(), Eigen::internal::pexp(), Eigen::internal::pmadd(), Eigen::internal::pmax(), Eigen::internal::pmin(), Eigen::internal::pmul(), Eigen::internal::pnegate(), Eigen::internal::pnmadd(), Eigen::internal::preciprocal(), Eigen::internal::predux_any(), Eigen::internal::pselect(), UniformPSDSelfTest::r, Eigen::internal::ppolevl< Packet, N >::run(), Eigen::internal::twoprod_low(), Eigen::numext::x, and Global_parameters::x2().

run() [3/3]

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

(

const T &

x_in

)

                                                                                    {
  // Clamp x to [-28:28] beyond which erfc(x) is either two or zero (below the underflow threshold).
  // This avoids having to deal with twoprod(x,x) producing NaN for sufficiently large x.
  constexpr double kClamp = 28.0;
  const T x = pmin(pmax(x_in, pset1<T>(-kClamp)), pset1<T>(kClamp));
 
  // For |x| < 1, we use erfc(x) = 1 - erf(x).
  const T x2 = pmul(x, x);
  const T one = pset1<T>(1.0);
  const T erfc_small = pnmadd(x, erf_over_x_double_small(x2), one);
 
  // Return early if we don't need the more expensive approximation for any
  // entry in a.
  const T x_abs_gt_one_mask = pcmp_lt(one, x2);
  if (!predux_any(x_abs_gt_one_mask)) return erfc_small;
 
  const T erfc_large = erfc_double_large(x, x2);
  return pselect(x_abs_gt_one_mask, erfc_large, erfc_small);
}

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

---

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

• SpecialFunctionsImpl.h