main.cpp

/* Copyright (C) 2016-2019 INRA
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

#include <baryonyx/core-out>
#include <baryonyx/core-utils>

#include "main.hpp"

#include <fmt/color.h>
#include <fmt/format.h>
#include <fmt/ostream.h>

#include <chrono>
#include <fstream>
#include <iomanip>
#include <limits>
#include <sstream>
#include <string>
#include <tuple>
#include <utility>

#include <cctype>
#include <cstring>

#ifndef _WIN32
#include <unistd.h>
#else
#include <windows.h>
#endif

#ifndef _WIN32
pid_t
get_pid() noexcept
{
    return ::getpid();
}
#else
DWORD
get_pid() noexcept
{
    return ::GetCurrentProcessId();
}
#endif

static void
solver_started_cb(const baryonyx::solver_parameters& params)
{
    fmt::print("Solver starts\n");

    fmt::print(" * Global parameters:\n"
               "  - limit: {}\n"
               "  - time-limit: {:.10g}s\n"
               "  - floating-point-type: {}\n"
               "  - print-level: {}\n"
               "  - auto-tune: {}\n"
               "  - observation: {}\n",
               params.limit,
               params.time_limit,
               params.float_type,
               params.print_level,
               params.mode,
               params.observer);

    if (params.solver == baryonyx::solver_parameters::solver_type::bastert) {
        fmt::print(" * In The Middle parameters:\n"
                   "  - preprocessing: {}\n"
                   "  - constraint-order: {}\n"
                   "  - theta: {:.10g}\n"
                   "  - delta: {:.10g}\n"
                   "  - kappa: {:.10g} {:.10g} {:.10g}\n"
                   "  - alpha: {:.10g}\n"
                   "  - w: {:.10g}\n"
                   "  - norm: {}\n",
                   params.pre_order,
                   params.order,
                   params.theta,
                   params.delta,
                   params.kappa_min,
                   params.kappa_step,
                   params.kappa_max,
                   params.alpha,
                   params.w,
                   params.cost_norm);

        fmt::print(" * Pushes system parameters:\n"
                   "  - pushes-limit: {}\n"
                   "  - pushing-objective-amplifier: {:.10g}\n"
                   "  - pushing-iteration-limit: {}\n"
                   "  - pushing-k-factor: {:.10g}\n",
                   params.pushes_limit,
                   params.pushing_objective_amplifier,
                   params.pushing_iteration_limit,
                   params.pushing_k_factor);

        fmt::print(" * Solver initialization parameters:\n"
                   "  - init-policy: {}\n"
                   "  - init-policy-random: {}\n",
                   params.init_policy,
                   params.init_policy_random);

        fmt::print(" * Optimizer initialization parameters:\n"
                   "  - init-population-size: {}\n"
                   "  - init-crossover-bastert-insertion: {}\n"
                   "  - init-crossover-solution-selection-mean: {}\n"
                   "  - init-crossover-solution-selection-stddev: {}\n"
                   "  - init-mutation-variable-mean: {}\n"
                   "  - init-mutation-variable-stddev: {}\n"
                   "  - init-mutation-value-mean: {}\n"
                   "  - init-mutation-value-stddev: {}\n"
                   "  - init-kappa-improve-start: {}\n"
                   "  - init-kappa-improve-increase: {}\n"
                   "  - init-kappa-improve-stop: {}\n",
                   params.init_population_size,
                   params.init_crossover_bastert_insertion,
                   params.init_crossover_solution_selection_mean,
                   params.init_crossover_solution_selection_stddev,
                   params.init_mutation_variable_mean,
                   params.init_mutation_variable_stddev,
                   params.init_mutation_value_mean,
                   params.init_mutation_value_stddev,
                   params.init_kappa_improve_start,
                   params.init_kappa_improve_increase,
                   params.init_kappa_improve_stop);
    } else {
        fmt::print(" * Random solvers:\n"
                   "  - random: bernouilli with p=0.5\n");
    }
}

static void
solver_updated_cb(int remaining_constraints,
                  double value,
                  long int loop,
                  double duration,
                  long int reinit_number)
{
    if (remaining_constraints > 0) {
        fmt::print(
          "  - Constraints remaining: {} (loop: {} t: {}s reinit: {})\n",
          remaining_constraints,
          loop,
          duration,
          reinit_number);
    } else {
        if (loop >= 0)
            fmt::print(
              "  - Solution found: {:f} (loop: {} t: {}s reinit: {})\n",
              value,
              loop,
              duration,
              reinit_number);
        else
            fmt::print("  - Solution found via push: {:f} (loop: {} t: {}s "
                       "reinit: {})\n",
                       value,
                       -loop,
                       duration,
                       reinit_number);
    }
}

static void
solver_finished_cb(const baryonyx::result& r)
{
    fmt::print("Solver finished\n");

    switch (r.status) {
    case baryonyx::result_status::success:
        if (r.loop >= 0)
            fmt::print("Best solution found: {:.10g} in {} loop and {}s\n",
                       r.solutions.back().value,
                       r.loop,
                       r.duration);
        else
            fmt::print(
              "Best solution found via push: {:.10g} in {} loop and {}s\n",
              r.solutions.back().value,
              -r.loop,
              r.duration);
        break;
    case baryonyx::result_status::internal_error:
        fmt::print("No solution. Internal error\n");
        break;
    case baryonyx::result_status::uninitialized:
        fmt::print("No solution. Uninitialized error\n");
        break;
    case baryonyx::result_status::kappa_max_reached:
        fmt::print(
          "No solution. Constraint remaining: {}. Kappa reached in {}s.\n",
          r.remaining_constraints,
          r.duration);
        break;
    case baryonyx::result_status::time_limit_reached:
        fmt::print("No solution. Constraint remaining: {}. Time limit reached "
                   "at {}s.\n",
                   r.remaining_constraints,
                   r.duration);
        break;
    case baryonyx::result_status::limit_reached:
        fmt::print("No solution. Constraint remaining: {}. Loop limit reached "
                   "in {}s.\n",
                   r.remaining_constraints,
                   r.duration);
        break;
    case baryonyx::result_status::empty_context:
        fmt::print("Context uninitialized\n");
        break;
    }
}

/**
 * @brief Tries to split the argument between name and value.
 * @details The split consists to return left and right part arround the
 *     characters `=' or `:'.
 *
 * @param param String to split.
 * @return Return left and right part in success, otherwise only the left part
 *     if the splitting characters are not found or an empty tuple if all is
 *     empty.
 */
constexpr static std::tuple<std::string_view, std::string_view>
split_argument(const std::string_view param)
{
    auto position = param.find_first_of(":=");

    if (position == std::string_view::npos) /* If nothing is found, return an
                                               empty tuple.*/
        return {};

    if (position + 1 >= param.size())
        return std::make_tuple(param, std::string_view{});

    return std::make_tuple(param.substr(0, position),
                           param.substr(position + 1));
}

constexpr static bool
starts_with(std::string_view str, std::string_view to_found) noexcept
{
    return !(str.find(to_found));
}

struct get_param
{
    constexpr get_param(int argc_, const char** argv_)
      : argv(argv_)
      , argc(argc_)
      , i(0)
    {}

    constexpr std::optional<std::string_view> operator()(
      int arg_position,
      const std::string_view longp,
      const std::string_view shortp) noexcept
    {
        std::string_view arg(argv[arg_position]);
        i = arg_position;

        if (starts_with(arg, longp) && arg.size() > longp.size() &&
            (arg[longp.size()] == '=' || arg[longp.size()] == ':'))
            return arg.substr(longp.size() + 1);

        if (starts_with(arg, shortp) && arg.size() > shortp.size())
            return arg.substr(shortp.size());

        if (arg_position + 1 < argc) {
            if (arg == longp) {
                i = arg_position + 1;
                return argv[i];
            }

            if (arg == shortp) {
                i = arg_position + 1;
                return argv[i];
            }
        }

        return std::nullopt;
    }

    const char** argv;
    int argc;
    int i;
};

static void
help() noexcept
{
    fmt::print(
      "Baryonyx v{}.{}.{}", VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH);

    fmt::print(
      "\nGeneral options:\n"
      "  --help|-h                     This help message\n"
      "  --param|-p [name][:|=][value] Add a new parameter (name is"
      " [a-z][A-Z]_) value can be a double, an integer otherwise a"
      " string.\n"
      "  --disable-preprocessing|-np   Disable preprocessing\n"
      "  --optimize|-O                 Optimize model (default "
      "feasibility search only)\n"
      "  --auto:[manual,nlopt]|-a      Automatic parameters optimization\n"
      "  --check filename.sol          Check if the solution is correct."
      "  --random                      Use the random solver instead of "
      "bastert and wedelin\n"
      "\n"
      "  --quiet                       Remove any verbose message\n"
      "  --verbose|-v int              Set verbose level\n"
      "  --bench|-b file_name.csv      Select the bench mode and store in "
      "file_name.csv\n\n"
      "  --debug                       Enable a debug mode\n"
      "Parameter list for in the middle heuristic\n"
      " * Global parameters"
      "  - limit: integer ]-oo, +oo[ in loop number\n"
      "  - time-limit: real [0, +oo[ in seconds\n"
      "  - floating-point-type: float double longdouble\n"
      "  - observer-type: none (default), pnm, file\n"
      "  - storage-type: one bound five\n"
      "  - print-level: [0, 2]\n"
      " * In The Middle parameters\n"
      "  - preprocessing: none memory less-greater-equal (or any "
      "combination), p1, p2, p3, p4\n"
      "  - constraint-order: none reversing random-sorting "
      "infeasibility-decr infeasibility-incr lagrangian-decr lagrangian-incr "
      "pi-sign-change\n"
      "  - theta: real [0, 1]\n"
      "  - delta: real [0, +oo[\n"
      "  - kappa-min: real [0, 1[\n"
      "  - kappa-step: real [0, 1[\n"
      "  - kappa-max: real [0, 1[\n"
      "  - alpha: integer [0, 2]\n"
      "  - w: integer [0, +oo[\n"
      "  - norm: l1 l2 loo none random\n"
      " * Pushes system parameters\n"
      "  - pushes-limit: integer [0, +oo[\n"
      "  - pushing-objective-amplifier: real [0, +oo[\n"
      "  - pushing-iteration-limit: integer [0, +oo[\n"
      "  - pushing-k-factor: real [0, +oo[\n"
      " * Initialization parameters\n"
      "  - init-policy: bastert pessimistic-solve optimistic-solve cycle\n"
      "  - init-population-size: integer [5, +oo[\n"
      "  - init-crossover-bastert-insertion:real [0, 1]\n"
      "  - init-crossover-solution-selection-mean:real [0, 1]\n"
      "  - init-crossover-solution-selection-stddev:real [0, 1]\n"
      "  - init-mutation-variable-mean:real [0, 1]\n"
      "  - init-mutation-variable-stddev:real [0, 1]\n"
      "  - init-mutation-value-mean:real [0, 1]\n"
      "  - init-mutation-value-stddev:real [0, 1]\n");
}

constexpr static bool
is_equal(std::string_view name, const char* longf, char shortf = '\0')
{
    if (name.compare(0, std::string::npos, longf) == 0)
        return true;

    if (shortf != '\0' && name.size() == 2 && name[1] == shortf)
        return true;

    return false;
}

constexpr static std::optional<double>
assign_0oo(std::string_view value)
{
    auto result = ::to_double(value);

    if (result.has_value() && *result > 0)
        return *result;
    else
        return std::nullopt;
}

constexpr static std::optional<double>
assign_01(std::string_view value)
{
    auto result = ::to_double(value);

    if (result.has_value() && *result >= 0 && *result <= 1)
        return *result;
    else
        return std::nullopt;
}

constexpr static std::optional<int>
assign(std::string_view value, int mindef, int maxdef)
{
    auto result = ::to_int(value);

    if (result.has_value() && *result >= mindef && *result <= maxdef)
        return result;
    else
        return std::nullopt;
}

constexpr static std::optional<long int>
assign(std::string_view value, long int mindef, long int maxdef)
{
    auto result = ::to_long(value);

    if (result.has_value() && *result >= mindef && *result <= maxdef)
        return result;
    else
        return std::nullopt;
}

constexpr static std::optional<double>
assign_d(std::string_view value, double mindef, double maxdef)
{
    auto result = ::to_double(value);

    if (result.has_value() && *result >= mindef && *result <= maxdef)
        return *result;
    else
        return std::nullopt;
}

enum class command_line_status
{
    success,
    unknown,
    parameter_missing,
    verbose_error,
    limit_error,
    time_limit_error,
    floating_point_type_error,
    observer_type_error,
    print_level_error,
    preprocessing_error,
    constraint_order_error,
    storage_type_error,
    theta_error,
    delta_error,
    kappa_min_error,
    kappa_step_error,
    kappa_max_error,
    alpha_error,
    w_error,
    norm_error,
    pushes_limit_error,
    pushing_objective_amplifier_error,
    pushing_iteration_limit_error,
    pushing_k_factor_error,
    init_population_size_error,
    init_policy_error,
    init_policy_random_error,
    init_crossover_bastert_insertion_error,
    init_crossover_solution_selection_mean_error,
    init_crossover_solution_selection_stddev_error,
    init_mutation_variable_mean_error,
    init_mutation_variable_stddev_error,
    init_mutation_value_mean_error,
    init_mutation_value_stddev_error,
    init_kappa_improve_start_error,
    init_kappa_improve_increase_error,
    init_kappa_improve_stop_error,
    thread_error,
    seed_error
};

constexpr const std::string_view command_line_status_string[] = {
    "success",
    "unknown",
    "parameter_missing",
    "verbose"
    "limit",
    "time_limit",
    "floating_point_type",
    "observer_type",
    "print_level",
    "preprocessing",
    "constraint_order",
    "storage_type",
    "theta",
    "delta",
    "kappa_min",
    "kappa_step",
    "kappa_max",
    "alpha",
    "w",
    "norm",
    "pushes_limit",
    "pushing_objective_amplifier",
    "pushing_iteration_limit",
    "pushing_k_factor",
    "init_population_size",
    "init_policy",
    "init_policy_random",
    "init_crossover_bastert_insertion",
    "init_crossover_solution_selection_mean",
    "init_crossover_solution_selection_stddev",
    "init_mutation_variable_mean",
    "init_mutation_variable_stddev",
    "init_mutation_value_mean",
    "init_mutation_value_stddev",
    "init_kappa_improve_start",
    "init_kappa_improve_increase",
    "init_kappa_improve_stop",
    "thread",
    "seed"
};

template<typename Integer>
constexpr typename std::make_unsigned<Integer>::type
to_unsigned(Integer value)
{
    assert(value >= 0 && "Signed to unsigned error: negative value");

    return static_cast<typename std::make_unsigned<Integer>::type>(value);
}

template<typename Integer>
constexpr typename std::make_signed<Integer>::type
to_signed(Integer value)
{
    assert(static_cast<std::uintmax_t>(value) <
             static_cast<std::uintmax_t>(
               std::numeric_limits<
                 typename std::make_signed<Integer>::type>::max()) &&
           "Unsigned to signed error: too big unsigned");

    return static_cast<typename std::make_signed<Integer>::type>(value);
}

constexpr const std::string_view
to_string(command_line_status s) noexcept
{
    auto x = static_cast<std::underlying_type<command_line_status>::type>(s);

    assert(x < to_signed(std::size(command_line_status_string)));

    return command_line_status_string[x];
}

constexpr static command_line_status
assign_parameter(baryonyx::solver_parameters& params,
                 std::string_view name,
                 std::string_view value)
{
    if (is_equal(name, "limit", 'l')) {
        if (auto v = assign(value, -1L, std::numeric_limits<long int>::max());
            !v)
            return command_line_status::limit_error;
        else
            params.limit = *v;

    } else if (is_equal(name, "time-limit")) {
        if (auto v = to_double(value); !v)
            return command_line_status::time_limit_error;
        else
            params.time_limit = *v <= 0.0 ? -1.0 : *v;

    } else if (is_equal(name, "floating-point-type")) {
        if (value == "float")
            params.float_type =
              baryonyx::solver_parameters::floating_point_type::float_type;
        else if (value == "double")
            params.float_type =
              baryonyx::solver_parameters::floating_point_type::double_type;
        else if (value == "longdouble")
            params.float_type = baryonyx::solver_parameters::
              floating_point_type::longdouble_type;
        else
            return command_line_status::floating_point_type_error;

    } else if (is_equal(name, "observer-type")) {
        if (value == "none")
            params.observer = baryonyx::solver_parameters::observer_type::none;
        else if (value == "pnm")
            params.observer = baryonyx::solver_parameters::observer_type::pnm;
        else if (value == "file")
            params.observer = baryonyx::solver_parameters::observer_type::file;
        else
            return command_line_status::observer_type_error;

    } else if (is_equal(name, "print-level")) {
        if (auto v = assign(value, 0, 2); !v)
            return command_line_status::print_level_error;
        else
            params.print_level = *v;

    } else if (is_equal(name, "preprocessing")) {
        if (value == "none")
            params.pre_order =
              baryonyx::solver_parameters::pre_constraint_order::none;
        else if (value == "memory")
            params.pre_order =
              baryonyx::solver_parameters::pre_constraint_order::memory;
        else if (value == "p1")
            params.pre_order =
              baryonyx::solver_parameters::pre_constraint_order::p1;
        else if (value == "p2")
            params.pre_order =
              baryonyx::solver_parameters::pre_constraint_order::p2;
        else if (value == "p3")
            params.pre_order =
              baryonyx::solver_parameters::pre_constraint_order::p3;
        else if (value == "p4")
            params.pre_order =
              baryonyx::solver_parameters::pre_constraint_order::p4;
        else if (value == "less-greater-equal")
            params.pre_order = baryonyx::solver_parameters::
              pre_constraint_order::less_greater_equal;
        else if (value == "less-equal-greater")
            params.pre_order = baryonyx::solver_parameters::
              pre_constraint_order::less_equal_greater;
        else if (value == "greater-less-equal")
            params.pre_order = baryonyx::solver_parameters::
              pre_constraint_order::greater_less_equal;
        else if (value == "greater-equal-less")
            params.pre_order = baryonyx::solver_parameters::
              pre_constraint_order::greater_equal_less;
        else if (value == "equal-less-greater")
            params.pre_order = baryonyx::solver_parameters::
              pre_constraint_order::equal_less_greater;
        else if (value == "equal-greater-less")
            params.pre_order = baryonyx::solver_parameters::
              pre_constraint_order::equal_greater_less;
        else
            return command_line_status::preprocessing_error;

    } else if (is_equal(name, "constraint-order")) {
        if (value == "none")
            params.order = baryonyx::solver_parameters::constraint_order::none;
        else if (value == "reversing")
            params.order =
              baryonyx::solver_parameters::constraint_order::reversing;
        else if (value == "random-sorting")
            params.order =
              baryonyx::solver_parameters::constraint_order::random_sorting;
        else if (value == "infeasibility-decr")
            params.order = baryonyx::solver_parameters::constraint_order::
              infeasibility_decr;
        else if (value == "infeasibility-incr")
            params.order = baryonyx::solver_parameters::constraint_order::
              infeasibility_incr;
        else if (value == "lagrangian-decr")
            params.order =
              baryonyx::solver_parameters::constraint_order::lagrangian_decr;
        else if (value == "lagrangian-incr")
            params.order =
              baryonyx::solver_parameters::constraint_order::lagrangian_incr;
        else if (value == "pi-sign-change")
            params.order =
              baryonyx::solver_parameters::constraint_order::pi_sign_change;
        else if (value == "cycle")
            params.order =
              baryonyx::solver_parameters::constraint_order::cycle;
        else
            return command_line_status::constraint_order_error;

    } else if (is_equal(name, "storage-type")) {
        if (value == "five")
            params.storage = baryonyx::solver_parameters::storage_type::five;
        else if (value == "bound")
            params.storage = baryonyx::solver_parameters::storage_type::bound;
        else if (value == "one")
            params.storage = baryonyx::solver_parameters::storage_type::one;
        else
            return command_line_status::storage_type_error;

    } else if (is_equal(name, "theta")) {
        if (auto v = assign_01(value); !v)
            return command_line_status::theta_error;
        else
            params.theta = *v;

    } else if (is_equal(name, "delta")) {
        if (auto v = assign_0oo(value); !v)
            return command_line_status::delta_error;
        else
            params.delta = *v;

    } else if (is_equal(name, "kappa-min")) {
        if (auto v = assign_01(value); !v)
            return command_line_status::kappa_min_error;
        else
            params.kappa_min = *v;

    } else if (is_equal(name, "kappa-step")) {
        if (auto v = assign_01(value); !v)
            return command_line_status::kappa_step_error;
        else
            params.kappa_step = *v;

    } else if (is_equal(name, "kappa-max")) {
        if (auto v = assign_01(value); !v)
            return command_line_status::kappa_max_error;
        else
            params.kappa_max = *v;

    } else if (is_equal(name, "alpha")) {
        if (auto v = assign_d(value, 0, 2); !v)
            return command_line_status::alpha_error;
        else
            params.alpha = *v;

    } else if (is_equal(name, "w")) {
        if (auto v = assign_d(value, 0.0, std::numeric_limits<double>::max());
            !v)
            return command_line_status::w_error;
        else
            params.w = *v;

    } else if (is_equal(name, "norm")) {
        if (value == "none")
            params.cost_norm =
              baryonyx::solver_parameters::cost_norm_type::none;
        else if (value == "random")
            params.cost_norm =
              baryonyx::solver_parameters::cost_norm_type::random;
        else if (value == "l1")
            params.cost_norm = baryonyx::solver_parameters::cost_norm_type::l1;
        else if (value == "l2")
            params.cost_norm = baryonyx::solver_parameters::cost_norm_type::l2;
        else if (value == "loo")
            params.cost_norm =
              baryonyx::solver_parameters::cost_norm_type::loo;
        else
            return command_line_status::norm_error;

    } else if (is_equal(name, "pushes-limit")) {
        if (auto v = assign(value, 0, std::numeric_limits<int>::max()); !v)
            return command_line_status::pushes_limit_error;
        else
            params.pushes_limit = *v;

    } else if (is_equal(name, "pushing-objective-amplifier")) {
        if (auto v = assign_0oo(value); !v)
            return command_line_status::pushing_objective_amplifier_error;
        else
            params.pushing_objective_amplifier = *v;

    } else if (is_equal(name, "pushing-iteration-limit")) {
        if (auto v = assign(value, 0, std::numeric_limits<int>::max()); !v)
            return command_line_status::pushing_iteration_limit_error;
        else
            params.pushing_iteration_limit = *v;

    } else if (is_equal(name, "pushing-k-factor")) {
        if (auto v = assign_0oo(value); !v)
            return command_line_status::pushing_k_factor_error;
        else
            params.pushing_k_factor = *v;

    } else if (is_equal(name, "init-population-size")) {
        if (auto v = assign(value, 5, std::numeric_limits<int>::max()); !v)
            return command_line_status::init_population_size_error;
        else
            params.init_population_size = *v;

    } else if (is_equal(name, "init-crossover-bastert-insertion")) {
        if (auto v = assign_01(value); !v)
            return command_line_status::init_crossover_bastert_insertion_error;
        else
            params.init_crossover_bastert_insertion = *v;

    } else if (is_equal(name, "init-crossover-solution-selection-mean")) {
        if (auto v = assign_01(value); !v)
            return command_line_status::
              init_crossover_solution_selection_mean_error;
        else
            params.init_crossover_solution_selection_mean = *v;

    } else if (is_equal(name, "init-crossover-solution-selection-stddev")) {
        if (auto v = assign_01(value); !v)
            return command_line_status::
              init_crossover_solution_selection_stddev_error;
        else
            params.init_crossover_solution_selection_stddev = *v;

    } else if (is_equal(name, "init-mutation-variable-mean")) {
        if (auto v = assign_01(value); !v)
            return command_line_status::init_mutation_variable_mean_error;
        else
            params.init_mutation_variable_mean = *v;

    } else if (is_equal(name, "init-mutation-variable-stddev")) {
        if (auto v = assign_01(value); !v)
            return command_line_status::init_mutation_variable_stddev_error;
        else
            params.init_mutation_variable_stddev = *v;

    } else if (is_equal(name, "init-mutation-value-mean")) {
        if (auto v = assign_01(value); !v)
            return command_line_status::init_mutation_value_mean_error;
        else
            params.init_mutation_value_mean = *v;

    } else if (is_equal(name, "init-mutation-value-stddev")) {
        if (auto v = assign_01(value); !v)
            return command_line_status::init_mutation_value_stddev_error;
        else
            params.init_mutation_value_stddev = *v;

    } else if (is_equal(name, "init-kappa-improve-start")) {
        if (auto v = assign_01(value); !v)
            return command_line_status::init_kappa_improve_start_error;
        else
            params.init_kappa_improve_start = *v;

    } else if (is_equal(name, "init-kappa-improve-increase")) {
        if (auto v = assign_01(value); !v)
            return command_line_status::init_kappa_improve_increase_error;
        else
            params.init_kappa_improve_increase = *v;

    } else if (is_equal(name, "init-kappa-improve-stop")) {
        if (auto v = assign_01(value); !v)
            return command_line_status::init_kappa_improve_stop_error;
        else
            params.init_kappa_improve_stop = *v;

    } else if (is_equal(name, "init-policy")) {
        if (value == "bastert")
            params.init_policy =
              baryonyx::solver_parameters::init_policy_type::bastert;
        else if (value == "pessimistic-solve")
            params.init_policy =
              baryonyx::solver_parameters::init_policy_type::pessimistic_solve;
        else if (value == "optimistic-solve")
            params.init_policy =
              baryonyx::solver_parameters::init_policy_type::optimistic_solve;
        else
            return command_line_status::init_policy_error;

    } else if (is_equal(name, "init-policy-random")) {
        if (auto v = assign_01(value); !v)
            return command_line_status::init_policy_random_error;
        else
            params.init_policy_random = *v;

    } else if (is_equal(name, "thread")) {
        if (auto v = assign(value, 0, std::numeric_limits<int>::max()); !v)
            return command_line_status::thread_error;
        else
            params.thread = *v;

    } else if (is_equal(name, "seed")) {
        if (auto v = assign(value, 0, std::numeric_limits<int>::max()); !v)
            return command_line_status::seed_error;
        else
            params.seed = *v;

    } else
        return command_line_status::unknown;

    return command_line_status::success;
}

struct main_parameters
{
    baryonyx::solver_parameters parameters;
    std::vector<std::string> filenames;
    std::string check_filename;
    std::string bench_name;
    int verbose = 6;
    int parse_arg = 0;
    bool check = false;
    bool optimize = false;
    bool quiet = false;
    bool bench = false;
    command_line_status parse_status = command_line_status::success;
};

static main_parameters
parse(int argc, const char* argv[])
{
    main_parameters ret;
    get_param get(argc, argv);

    for (int i = 1; i < argc; ++i) {
        std::string_view arg(argv[i]);

        ret.parse_arg = i;

        if (arg == "--help" || arg == "-h") {
            ::help();
            continue;
        }

        if (arg == "--quiet" || arg == "-q") {
            ret.quiet = true;
            continue;
        }

        if (arg == "--optimize" || arg == "-O") {
            ret.optimize = true;
            continue;
        }

        if (auto opt = get(i, "--bench", "-b"); opt) {
            ret.bench = true;
            ret.bench_name = *opt;
            i = get.i;
            continue;
        }

        if (arg == "--disable-preprocessing" || arg == "-np") {
            ret.parameters.preprocessor =
              baryonyx::solver_parameters::preprocessor_options::none;
            continue;
        }

        if (auto opt = get(i, "--auto", "-a"); opt) {
            if (*opt == "manual")
                ret.parameters.mode =
                  baryonyx::solver_parameters::mode_type::manual;
            else if (*opt == "nlopt")
                ret.parameters.mode =
                  baryonyx::solver_parameters::mode_type::nlopt;
            else if (*opt == "branch")
                ret.parameters.mode =
                  baryonyx::solver_parameters::mode_type::branch;
            else if (*opt == "branch-manual")
                ret.parameters.mode =
                  baryonyx::solver_parameters::mode_type::manual |
                  baryonyx::solver_parameters::mode_type::branch;
            else if (*opt == "branch-nlopt")
                ret.parameters.mode =
                  baryonyx::solver_parameters::mode_type::nlopt |
                  baryonyx::solver_parameters::mode_type::branch;
            else
                ret.parameters.mode =
                  baryonyx::solver_parameters::mode_type::none;

            i = get.i;
            continue;
        }

        if (auto opt = get(i, "--verbose", "-v"); opt) {
            if (auto v = ::assign(*opt, 0, 6); v) {
                ret.verbose = *v;
            } else {
                ret.parse_status = command_line_status::verbose_error;
                return ret;
            }
        }

        if (auto opt = get(i, "--check", "-C"); opt) {
            ret.check_filename = *opt;
            i = get.i;
            continue;
        }

        if (auto opt = get(i, "--param", "-p"); opt) {
            auto [name, value] = split_argument(*opt);

            if (name.empty() || value.empty()) {
                ret.parse_status = command_line_status::parameter_missing;
                return ret;
            }

            if (auto v = assign_parameter(ret.parameters, name, value);
                v != command_line_status::success) {
                ret.parse_status = v;
                return ret;
            }

            i = get.i;
            continue;
        }

        if (arg == "--random") {
            ret.parameters.solver =
              baryonyx::solver_parameters::solver_type::random;
            continue;
        }

        if (arg == "--debug") {
            ret.parameters.debug = true;
            continue;
        }

        ret.filenames.emplace_back(argv[i]);
    }

    return ret;
}

static void
resume(const baryonyx::raw_problem& pb) noexcept