Class upper_bound_function

dlib/global_optimization/upper_bound_function.h:28–278

// ----------------------------------------------------------------------------------------

    class upper_bound_function
    {

    public:

        upper_bound_function(
        ) = default;

        upper_bound_function(
            const double relative_noise_magnitude,
            const double solver_eps 
        ) : relative_noise_magnitude(relative_noise_magnitude), solver_eps(solver_eps)
        {
            DLIB_CASSERT(relative_noise_magnitude >= 0);
            DLIB_CASSERT(solver_eps > 0);
        }

        explicit upper_bound_function(
            const std::vector<function_evaluation>& _points,
            const double relative_noise_magnitude = 0.001,
            const double solver_eps = 0.0001
        ) : relative_noise_magnitude(relative_noise_magnitude), solver_eps(solver_eps), points(_points)
        {
            DLIB_CASSERT(relative_noise_magnitude >= 0);
            DLIB_CASSERT(solver_eps > 0);

            if (points.size() > 1)
            {
                DLIB_CASSERT(points[0].x.size() > 0, "The vectors can't be empty.");

                const long dims = points[0].x.size();
                for (auto& p : points)
                    DLIB_CASSERT(p.x.size() == dims, "All the vectors given to upper_bound_function must have the same dimensionality.");

                learn_params();
            }

        }

        void add (
            const function_evaluation& point
        )
        {
            DLIB_CASSERT(point.x.size() != 0, "The vectors can't be empty.");
            if (points.size() == 0)
            {
                points.push_back(point);
                return;
            }

            DLIB_CASSERT(point.x.size() == dimensionality(), "All the vectors given to upper_bound_function must have the same dimensionality.");

            if (points.size() < 4)
            {
                points.push_back(point);
                *this = upper_bound_function(points, relative_noise_magnitude, solver_eps);
                return;
            }