ldamath Namespace Reference

Functions
float	fastlog2 (float x)
float	fastlog (float x)
float	fastpow2 (float p)
float	fastexp (float p)
float	fastpow (float x, float p)
float	fastlgamma (float x)
float	fastdigamma (float x)
template<typename T , const lda_math_mode mtype>
T	lgamma (T)
template<typename T , const lda_math_mode mtype>
T	digamma (T)
template<typename T , lda_math_mode mtype>
T	exponential (T)
template<typename T , lda_math_mode mtype>
T	powf (T, T)
template<>
float	lgamma< float, USE_PRECISE > (float x)
template<>
float	digamma< float, USE_PRECISE > (float x)
template<>
float	exponential< float, USE_PRECISE > (float x)
template<>
float	powf< float, USE_PRECISE > (float x, float p)
template<>
float	lgamma< float, USE_FAST_APPROX > (float x)
template<>
float	digamma< float, USE_FAST_APPROX > (float x)
template<>
float	exponential< float, USE_FAST_APPROX > (float x)
template<>
float	powf< float, USE_FAST_APPROX > (float x, float p)
template<>
float	lgamma< float, USE_SIMD > (float x)
template<>
float	digamma< float, USE_SIMD > (float x)
template<>
float	exponential< float, USE_SIMD > (float x)
template<>
float	powf< float, USE_SIMD > (float x, float p)
template<typename T , const lda_math_mode mtype>
void	expdigammify (vw &all, T *gamma, T threshold, T initial)
template<>
void	expdigammify< float, USE_SIMD > (vw &all, float *gamma, float threshold, float)
template<typename T , const lda_math_mode mtype>
void	expdigammify_2 (vw &all, float *gamma, T *norm, const T threshold)
template<>
void	expdigammify_2< float, USE_SIMD > (vw &all, float *gamma, float *norm, const float threshold)

Function Documentation

digamma()

template<typename T , const lda_math_mode mtype>

T ldamath::digamma ( T  )

inline

Definition at line 414 of file lda_core.cc.

Referenced by digamma< float, USE_PRECISE >().

{
  BOOST_STATIC_ASSERT_MSG(true, "ldamath::digamma is not defined for this type and math mode.");
}

digamma< float, USE_FAST_APPROX >()

template<>

float ldamath::digamma< float, USE_FAST_APPROX > ( float  x )

inline

Definition at line 464 of file lda_core.cc.

References fastdigamma().

Referenced by lda::digamma(), and digamma< float, USE_SIMD >().

{
  return fastdigamma(x);
}

digamma< float, USE_PRECISE >()

template<>

float ldamath::digamma< float, USE_PRECISE > ( float  x )

inline

Definition at line 441 of file lda_core.cc.

References digamma().

Referenced by lda::digamma().

{
  return boost::math::digamma(x);
}

digamma< float, USE_SIMD >()

template<>

float ldamath::digamma< float, USE_SIMD > ( float  x )

inline

Definition at line 487 of file lda_core.cc.

References digamma< float, USE_FAST_APPROX >().

Referenced by lda::digamma().

{
  return digamma<float, USE_FAST_APPROX>(x);
}

expdigammify()

template<typename T , const lda_math_mode mtype>

void ldamath::expdigammify ( vw &  all, T *  gamma, T  threshold, T  initial  )

inline

Definition at line 503 of file lda_core.cc.

References accumulate(), and vw::lda.

{
  T sum = digamma<T, mtype>(std::accumulate(gamma, gamma + all.lda, initial));

  std::transform(gamma, gamma + all.lda, gamma,
      [sum, threshold](T g) { return fmax(threshold, exponential<T, mtype>(digamma<T, mtype>(g) - sum)); });
}

expdigammify< float, USE_SIMD >()

template<>

void ldamath::expdigammify< float, USE_SIMD > ( vw &  all, float *  gamma, float  threshold, float    )

inline

Definition at line 511 of file lda_core.cc.

Referenced by lda::expdigammify().

{
#if defined(HAVE_SIMD_MATHMODE)
  vexpdigammify(all, gamma, threshold);
#else
  // Do something sensible if SIMD math isn't available:
  expdigammify<float, USE_FAST_APPROX>(all, gamma, threshold, 0.0);
#endif
}

expdigammify_2()

template<typename T , const lda_math_mode mtype>

void ldamath::expdigammify_2 ( vw &  all, float *  gamma, T *  norm, const T  threshold  )

inline

Definition at line 522 of file lda_core.cc.

References vw::lda.

{
  std::transform(gamma, gamma + all.lda, norm, gamma,
      [threshold](float g, float n) { return fmax(threshold, exponential<T, mtype>(digamma<T, mtype>(g) - n)); });
}

expdigammify_2< float, USE_SIMD >()

template<>

void ldamath::expdigammify_2< float, USE_SIMD > ( vw &  all, float *  gamma, float *  norm, const float  threshold  )

inline

Definition at line 528 of file lda_core.cc.

Referenced by lda::expdigammify_2().

{
#if defined(HAVE_SIMD_MATHMODE)
  vexpdigammify_2(all, gamma, norm, threshold);
#else
  // Do something sensible if SIMD math isn't available:
  expdigammify_2<float, USE_FAST_APPROX>(all, gamma, norm, threshold);
#endif
}

exponential()

template<typename T , lda_math_mode mtype>

T ldamath::exponential ( T  )

inline

Definition at line 421 of file lda_core.cc.

{
  BOOST_STATIC_ASSERT_MSG(true, "ldamath::exponential is not defined for this type and math mode.");
}

exponential< float, USE_FAST_APPROX >()

template<>

float ldamath::exponential< float, USE_FAST_APPROX > ( float  x )

inline

Definition at line 469 of file lda_core.cc.

References fastexp().

Referenced by exponential< float, USE_SIMD >().

{
  return fastexp(x);
}

exponential< float, USE_PRECISE >()

template<>

float ldamath::exponential< float, USE_PRECISE > ( float  x )

inline

Definition at line 446 of file lda_core.cc.

References correctedExp.

{
  return correctedExp(x);
}

exponential< float, USE_SIMD >()

template<>

float ldamath::exponential< float, USE_SIMD > ( float  x )

inline

Definition at line 492 of file lda_core.cc.

References exponential< float, USE_FAST_APPROX >().

{
  return exponential<float, USE_FAST_APPROX>(x);
}

fastdigamma()

float ldamath::fastdigamma ( float  x )

inline

Definition at line 172 of file lda_core.cc.

References a, f, fastexp(), fastlog(), anonymous_namespace{lda_core.cc}::is_aligned16(), and vw::lda.

Referenced by digamma< float, USE_FAST_APPROX >().

{
  float twopx = 2.0f + x;
  float logterm = fastlog(twopx);

  return -(1.0f + 2.0f * x) / (x * (1.0f + x)) - (13.0f + 6.0f * x) / (12.0f * twopx * twopx) + logterm;
}

fastexp()

float ldamath::fastexp ( float  p )

inline

Definition at line 160 of file lda_core.cc.

References f, and fastpow2().

{ return fastpow2(1.442695040f * p); }

fastlgamma()

float ldamath::fastlgamma ( float  x )

inline

Definition at line 164 of file lda_core.cc.

References f, and fastlog().

Referenced by lgamma< float, USE_FAST_APPROX >().

{
  float logterm = fastlog(x * (1.0f + x) * (2.0f + x));
  float xp3 = 3.0f + x;

  return -2.081061466f - x + 0.0833333f / xp3 - logterm + (2.5f + x) * fastlog(xp3);
}

fastlog()

float ldamath::fastlog ( float  x )

inline

Definition at line 145 of file lda_core.cc.

References fastlog2().

Referenced by fastdigamma(), and fastlgamma().

{ return 0.69314718f * fastlog2(x); }

fastlog2()

float ldamath::fastlog2 ( float  x )

inline

Definition at line 127 of file lda_core.cc.

Referenced by fastlog(), and fastpow().

{
  uint32_t mx;
  memcpy(&mx, &x, sizeof(uint32_t));
  mx = (mx & 0x007FFFFF) | (0x7e << 23);

  float mx_f;
  memcpy(&mx_f, &mx, sizeof(float));

  uint32_t vx;
  memcpy(&vx, &x, sizeof(uint32_t));

  float y = static_cast<float>(vx);
  y *= 1.0f / (float)(1 << 23);

  return y - 124.22544637f - 1.498030302f * mx_f - 1.72587999f / (0.3520887068f + mx_f);
}

fastpow()

float ldamath::fastpow ( float  x, float  p  )

inline

Definition at line 162 of file lda_core.cc.

References fastlog2(), and fastpow2().

Referenced by powf< float, USE_FAST_APPROX >().

{ return fastpow2(p * fastlog2(x)); }

fastpow2()

float ldamath::fastpow2 ( float  p )

inline

Definition at line 147 of file lda_core.cc.

References f.

{
  float offset = (p < 0) * 1.0f;
  float clipp = (p < -126.0) ? -126.0f : p;
  int w = (int)clipp;
  float z = clipp - w + offset;
  uint32_t approx = (uint32_t)((1 << 23) * (clipp + 121.2740838f + 27.7280233f / (4.84252568f - z) - 1.49012907f * z));

  float v;
  memcpy(&v, &approx, sizeof(uint32_t));
  return v;
}

lgamma()

template<typename T , const lda_math_mode mtype>

T ldamath::lgamma ( T  )

inline

Definition at line 407 of file lda_core.cc.

Referenced by lgamma< float, USE_PRECISE >().

{
  BOOST_STATIC_ASSERT_MSG(true, "ldamath::lgamma is not defined for this type and math mode.");
}

lgamma< float, USE_FAST_APPROX >()

template<>

float ldamath::lgamma< float, USE_FAST_APPROX > ( float  x )

inline

Definition at line 459 of file lda_core.cc.

References fastlgamma().

Referenced by lda::lgamma(), and lgamma< float, USE_SIMD >().

{
  return fastlgamma(x);
}

lgamma< float, USE_PRECISE >()

template<>

float ldamath::lgamma< float, USE_PRECISE > ( float  x )

inline

Definition at line 436 of file lda_core.cc.

References lgamma().

Referenced by lda::lgamma().

{
  return boost::math::lgamma(x);
}

lgamma< float, USE_SIMD >()

template<>

float ldamath::lgamma< float, USE_SIMD > ( float  x )

inline

Definition at line 482 of file lda_core.cc.

References lgamma< float, USE_FAST_APPROX >().

Referenced by lda::lgamma().

{
  return lgamma<float, USE_FAST_APPROX>(x);
}

powf()

template<typename T , lda_math_mode mtype>

T ldamath::powf ( T  , T    )

inline

Definition at line 428 of file lda_core.cc.

Referenced by GD::average_update(), GD::compute_rate_decay(), gd_mf_setup(), GD::get_scale(), mf_train(), parseFloat(), GD::pred_per_update_feature(), Search::random_policy(), and GD::setup().

{
  BOOST_STATIC_ASSERT_MSG(true, "ldamath::powf is not defined for this type and math mode.");
}

powf< float, USE_FAST_APPROX >()

template<>

float ldamath::powf< float, USE_FAST_APPROX > ( float  x, float  p  )

inline

Definition at line 474 of file lda_core.cc.

References fastpow().

Referenced by lda::powf(), and powf< float, USE_SIMD >().

{
  return fastpow(x, p);
}

powf< float, USE_PRECISE >()

template<>

float ldamath::powf< float, USE_PRECISE > ( float  x, float  p  )

inline

Definition at line 451 of file lda_core.cc.

Referenced by lda::powf().

{
  return std::pow(x, p);
}

powf< float, USE_SIMD >()

template<>

float ldamath::powf< float, USE_SIMD > ( float  x, float  p  )

inline

Definition at line 497 of file lda_core.cc.

References powf< float, USE_FAST_APPROX >().

Referenced by lda::powf().

{
  return powf<float, USE_FAST_APPROX>(x, p);
}