find_min_global don't find the best minimum

[Julien-Livet]

Hello,

I write a function that I want to find the minimum value. It works for the first iteration but the second, find_min_global found a min of 2.38356e-14 with p,q,lnbetan = (117,9,4.10725) whereas the best mininum is 2.30677e-14 with p,q,lnbetan = (103, 7, 3.94938993840887).
Is there some parameter of find_min_global to tune to solve this problem?

Here is the code.

#include <iostream>
#include <chrono>
#include <cmath>

#include <dlib/optimization.h>
#include <dlib/global_optimization.h>

inline unsigned long long factorial(unsigned long long n)
{
    if (!n)
        return 1;

    return n * factorial(n - 1);
}

int main()
{
    constexpr unsigned long iMax{2};

    {
        double lnbetan_2{std::log(2)};
        double lnbetan_1{std::log(12) / 2};
        unsigned long long n_1{2};
        unsigned long long n{3};
        unsigned long long pn_1{3};
        double lnbetan{0};
        unsigned long long pn{0};

        for (unsigned long i{0}; i < iMax; ++i)
        {
            auto const lnbetan_{-lnbetan_2 + 2 * lnbetan_1};
            auto const qMin{pn_1 + 2};
            auto const pnMin{pn_1 + 2};
            auto const lnbetanMin{0.6 * lnbetan_};
            auto const qMax{factorial(pn_1)};
            auto const pnMax{2 * pn_1 + 1 + 1};
            auto const lnbetanMax{1.4 * lnbetan_};

            auto f = [n, n_1, lnbetan_1] (unsigned long long q, unsigned long long pn, double lnbetan)
            {
                if (!(pn % 2))
                    ++pn;

                return std::abs(std::log(q) + 2 * std::log(pn) + n_1 * lnbetan_1 - n * lnbetan - std::log(1. + 1. / factorial(pn - 1)));
            };

            dlib::matrix<double, 0, 1> const bound1{qMin, pnMin, lnbetanMin};
            dlib::matrix<double, 0, 1> const bound2{qMax, pnMax, lnbetanMax};
            std::vector<bool> const is_integer_variable{false, false, false};

            std::cout << "bound1 " << qMin << " " << pnMin << " " << lnbetanMin << std::endl;
            std::cout << "bound2 " << qMax << " " << pnMax << " " << lnbetanMax << std::endl;

            auto const result{dlib::find_min_global(f, bound1, bound2, is_integer_variable, std::chrono::milliseconds(100), 1e-30)};

            std::cout << "f " << result.y << std::endl;
            std::cout << "f(103, 7, 3.94938993840887) " << f(103, 7, 3.94938993840887) << std::endl;

            unsigned long long const q{result.x(0)};
            pn = (unsigned long long)result.x(1);
            lnbetan = result.x(2);

            std::cout << "q " << q << std::endl;
            std::cout << "pn " << pn << std::endl;
            std::cout << "lnbetan " << lnbetan << std::endl;

            lnbetan_2 = lnbetan_1;
            lnbetan_1 = lnbetan;
            n_1 = n;
            pn_1 = pn;
            ++n;
        }
    }

    return 0;
}

Thanks.

[davisking]

10ms isn't very long. This isn't a super fast solver. Does it work if you let it run a lot longer?

This solver isn't what I would recommend if speed is what you need.

[Julien-Livet]

It is the same result with 1s.

[arrufat]

Usually, when I am unsure of the run time, I use the overload with dlib::max_function_calls

auto const result{dlib::find_min_global(f, bound1, bound2, dlib::max_function_calls(10000))};

But I am still unable to find the result you want to find, even with 10000 calls.