How to use Boost's Brent minimization algorithm with a specific tolerance rather than bits?

Question

The documentation for the brent_find_minima function is at https://www.boost.org/doc/libs/1_76_0/libs/math/doc/html/math_toolkit/brent_minima.html

template <class F, class T>
std::pair<T, T> brent_find_minima(F f, T min, T max, int bits);

template <class F, class T>
std::pair<T, T> brent_find_minima(F f, T min, T max, int bits, boost::uintmax_t& max_iter);

However I'm a bit confused on how to convert bits to a tolerance. For example I have some objective function that measures distance

double distance(double x);

which measures some value distance as paramaterized by x. I would like to be able to say that I want the solver to return me the minimum of this function to an accuracy of 0.1 which represents the accuracy I care about.

How do I convert 0.1 to bits?

Answer 1

I'm not an expert at this, but looking over the source code for Boost's Brent minimization algorithm, it looks like the bit count is used to determine a stopping condition that's based on the magnitude of the current guess. Specifically, the stopping condition is determined from the current guess x and the size of the current window containing the minimum:

|x - current-range-midpoint| ≤ 2ε|x| + ε/2 - (current-range-size) / 2

Here, ε is a small number derived from the number of bits (specifically, it's 2^{1 - bits}). Notice that, in particular, if |x| gets larger, then ε needs to get increasingly small for the bound on the left-hand side not to be a large number as the size of the current range decreases.

I will have to confess that I haven't worked out the full math here, but based on this it looks like the number of bits you're going to need is going to be the number of bits to write out the integer part of the answer, plus enough extra bits to get a value that's within 0.1 of the total. The number of bits to write out the integer part of the answer is log₂ n, and the number of bits to get to within 0.1 of the total is 4 (1 / 2⁴ = 0.06), so my best guess is that you'll need log₂ n + 4 bits if the correct answer is n. To estimate n, look at the two endpoints of the range and take whichever has the larger absolute value.

If this is incorrect, please let me know and I'll remove this answer.