MinimizeOneDim.h File Reference

Include dependency graph for MinimizeOneDim.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	Bracket_min_t< T >

Functions
template<class F , typename T >
Bracket_min_t< T >	bracket_minimum (const F &f, T initial_value, T bound_max=-1.0)
template<class F , typename T >
std::pair< T, T >	find_minimum (const F &f, Bracket_min_t< T > &bracket)

Function Documentation

bracket_minimum()

Bracket_min_t<T> bracket_minimum	(	const F &	f,
		T	initial_value,
		T	bound_max = -1.0
	)

Definition at line 43 of file MinimizeOneDim.h.

Referenced by MinTest::find_bracket(), MinTest::find_bracket_bound(), MinTest::find_min(), qmcplusplus::minimizeForPhiAtZero(), and qmcplusplus::minimizeForRc().

{
  T xa = initial_value;
  T fa = f(xa);

  T xb = xa + 0.005;
  T fb = f(xb);

  // swap a and b
  if (fb > fa)
  {
    std::swap(xa, xb);
    std::swap(fa, fb);
  }

  bool check_bound = false;
  if (bound_max > 0.0)
  {
    check_bound = true;
  }
  T best_val = xb;

  T delx = 1.61 * (xb - xa);
  T xd   = xb + delx;
  T fd   = f(xd);

  int cnt = 0;
  while (fb > fd)
  {
    T xtmp = xb;
    T ftmp = fb;
    xb     = xd;
    fb     = fd;
    xa     = xtmp;
    fa     = ftmp;
    xd += delx;
    if (check_bound && (xd < 0.0 || xd > bound_max))
    {
      // minimum occurs at the boundary of the range
      return Bracket_min_t<T>(best_val, 0.0, 0.0, false);
    }


    fd = f(xd);

    if (cnt == 50)
    {
      delx *= 5;
    }
    if (cnt == 100)
    {
      delx *= 5;
    }
    if (cnt == 1000)
    {
      delx *= 5;
    }
    if (cnt == 10000)
    {
      delx *= 5;
    }
    cnt++;
    if (cnt == 100000)
    {
      throw std::runtime_error("Failed to bracket minimum");
    }
  }
  if (xa > xd)
    std::swap(xa, xd);
  return Bracket_min_t<T>(xa, xb, xd);
}

find_minimum()

std::pair<T, T> find_minimum	(	const F &	f,
		Bracket_min_t< T > &	bracket
	)

Definition at line 120 of file MinimizeOneDim.h.

References Bracket_min_t< T >::a, qmcplusplus::abs(), Bracket_min_t< T >::b, Bracket_min_t< T >::c, and qmcplusplus::Units::charge::e.

Referenced by MinTest::find_min(), qmcplusplus::minimizeForPhiAtZero(), and qmcplusplus::minimizeForRc().

{
  // assert(bracket.success == true);
  T xa = bracket.a;
  T xb = bracket.b;
  T xd = bracket.c;
  T fb = f(xb);
  T xc = xb + 0.4 * (xd - xb);
  T fc = f(xc);

  T tol = 1e-5;
  while (std::abs(xa - xd) > tol * (std::abs(xb) + std::abs(xc)))
  {
    if (fb > fc)
    {
      xa = xb;
      xb = xa + 0.4 * (xd - xa);
      fb = f(xb);
      xc = xa + 0.6 * (xd - xa);
      fc = f(xc);
    }
    else
    {
      xd = xc;
      xb = xa + 0.4 * (xd - xa);
      fb = f(xb);
      xc = xa + 0.6 * (xd - xa);
      fc = f(xc);
    }
  }
  T final_value;
  T final_x;
  if (fb < fc)
  {
    final_x = xb;
  }
  else
  {
    final_x = xc;
  }
  final_value = f(final_x);
  return std::pair<T, T>(final_x, final_value);
}