OptimizerFactory.h

//
// Created by henri on 21/03/23.
//
 
#ifndef IDOL_OPTIMIZERFACTORY_H
#define IDOL_OPTIMIZERFACTORY_H
 
#include "Optimizer.h"
 
#include <optional>
#include <functional>
 
namespace idol {
    class Model;
    class OptimizerFactory;
    template<class CRTP>
    class OptimizerFactoryWithDefaultParameters;
}
 
class idol::OptimizerFactory {
public:
    virtual ~OptimizerFactory() = default;
 
    virtual Optimizer* operator()(const Model& t_model) const = 0;
 
    [[nodiscard]] virtual OptimizerFactory* clone() const = 0;
 
 
    template<class T> T& as() {
        auto* result = dynamic_cast<T*>(this);
        if (!result) {
            throw Exception("Optimizer factory could not be cast to desired type.");
        }
        return *result;
    }
 
    template<class T> const T& as() const {
        auto* result = dynamic_cast<const T*>(this);
        if (!result) {
            throw Exception("Optimizer factory could not be cast to desired type.");
        }
        return *result;
    }
 
    template<class T> [[nodiscard]] bool is() const {
        return dynamic_cast<const T*>(this);
    }
};
 
template<class CRTP>
class idol::OptimizerFactoryWithDefaultParameters : public OptimizerFactory {
    std::optional<bool> m_logs;
    std::optional<double> m_time_limit;
    std::optional<unsigned int> m_thread_limit;
    std::optional<unsigned int> m_iteration_count_limit;
    std::optional<double> m_best_bound_stop;
    std::optional<double> m_best_obj_stop;
    std::optional<double> m_relative_gap_tolerance;
    std::optional<double> m_absolute_gap_tolerance;
    std::optional<bool> m_presolve;
    std::optional<bool> m_infeasible_or_unbounded_info;
protected:
    CRTP& crtp() { return static_cast<CRTP&>(*this); }
    const CRTP& crtp() const { return static_cast<const CRTP&>(*this); }
 
    void handle_default_parameters(Optimizer* t_optimizer) const;
public:
    CRTP& with_logs(bool t_value);
 
    CRTP& with_time_limit(double t_time_limit);
 
    CRTP& with_thread_limit(unsigned int t_max_n_threads);
 
    CRTP& with_iteration_limit(unsigned int t_iteration_count_limit);
 
    CRTP& with_best_bound_stop(double t_best_bound_stop);
 
    CRTP& with_best_obj_stop(double t_user_best_obj);
 
    CRTP& with_relative_gap_tolerance(double t_relative_gap_tolerance);
 
    CRTP& with_absolute_gap_tolerance(double t_absolute_gap_tolerance);
 
    CRTP& with_presolve(bool t_value);
 
    CRTP& with_infeasible_or_unbounded_info(bool t_value);
 
    CRTP& conditional(bool t_conditional_value, const std::function<void(CRTP&)>& t_if);
 
    CRTP& conditional(bool t_conditional_value, const std::function<void(CRTP&)>& t_if, const std::function<void(CRTP&)>& t_else);
 
};
 
template<class CRTP>
CRTP &
idol::OptimizerFactoryWithDefaultParameters<CRTP>::conditional(bool t_conditional_value, const std::function<void(CRTP&)>& t_if, const std::function<void(CRTP&)>& t_else) {
    t_conditional_value ? t_if(crtp()) : t_else(crtp());
    return crtp();
}
 
template<class CRTP>
CRTP &
idol::OptimizerFactoryWithDefaultParameters<CRTP>::conditional(bool t_conditional_value, const std::function<void(CRTP&)>& t_if) {
    return conditional(t_conditional_value, t_if, [](CRTP&){});
}
 
template<class CRTP>
CRTP &idol::OptimizerFactoryWithDefaultParameters<CRTP>::with_infeasible_or_unbounded_info(bool t_value) {
 
    if (m_infeasible_or_unbounded_info.has_value()) {
        throw Exception("An infeasible-or-unbounded-info instruction has already been given.");
    }
 
    m_infeasible_or_unbounded_info = t_value;
 
    return crtp();
}
 
template<class CRTP>
CRTP &idol::OptimizerFactoryWithDefaultParameters<CRTP>::with_presolve(bool t_value) {
 
    if (m_presolve.has_value()) {
        throw Exception("A get_param_presolve instruction has already been given.");
    }
 
    m_presolve = t_value;
 
    return crtp();
}
 
template<class CRTP>
CRTP &idol::OptimizerFactoryWithDefaultParameters<CRTP>::with_absolute_gap_tolerance(double t_absolute_gap_tolerance) {
 
    if (m_absolute_gap_tolerance.has_value()) {
        throw Exception("An absolute gap tolerance count limit has already been given.");
    }
 
    m_absolute_gap_tolerance = t_absolute_gap_tolerance;
 
    return crtp();
}
 
template<class CRTP>
CRTP &idol::OptimizerFactoryWithDefaultParameters<CRTP>::with_relative_gap_tolerance(double t_relative_gap_tolerance) {
 
    if (m_relative_gap_tolerance.has_value()) {
        throw Exception("A relative gap tolerance count limit has already been given.");
    }
 
    m_relative_gap_tolerance = t_relative_gap_tolerance;
 
    return crtp();
}
 
template<class CRTP>
CRTP &idol::OptimizerFactoryWithDefaultParameters<CRTP>::with_best_obj_stop(double t_user_best_obj) {
 
    if (m_best_obj_stop.has_value()) {
        throw Exception("A user best obj count limit has already been given.");
    }
 
    m_best_obj_stop = t_user_best_obj;
 
    return crtp();
}
 
template<class CRTP>
CRTP &idol::OptimizerFactoryWithDefaultParameters<CRTP>::with_best_bound_stop(double t_user_best_bound) {
 
    if (m_best_bound_stop.has_value()) {
        throw Exception("A user best bound limit has already been given.");
    }
 
    m_best_bound_stop = t_user_best_bound;
 
    return crtp();
}
 
template<class CRTP>
CRTP &idol::OptimizerFactoryWithDefaultParameters<CRTP>::with_iteration_limit(unsigned int t_iteration_count_limit) {
 
    if (m_iteration_count_limit.has_value()) {
        throw Exception("An iteration count limit has already been given.");
    }
 
    m_iteration_count_limit = t_iteration_count_limit;
 
    return crtp();
}
 
template<class CRTP>
CRTP &idol::OptimizerFactoryWithDefaultParameters<CRTP>::with_thread_limit(unsigned int t_max_n_threads) {
 
    if (m_thread_limit.has_value()) {
        throw Exception("A thread limit has already been given.");
    }
 
    m_thread_limit = t_max_n_threads;
 
    return crtp();
}
 
template<class CRTP>
CRTP &idol::OptimizerFactoryWithDefaultParameters<CRTP>::with_time_limit(double t_time_limit) {
 
    if (m_time_limit.has_value()) {
        throw Exception("A time limit has already been given.");
    }
 
    m_time_limit = t_time_limit;
 
    return crtp();
}
 
template<class CRTP>
CRTP &idol::OptimizerFactoryWithDefaultParameters<CRTP>::with_logs(bool t_value) {
 
    if (m_logs.has_value()) {
        throw Exception("Logging settings have already been given.");
    }
 
    m_logs = t_value;
 
    return crtp();
}
 
template<class CRTP>
void idol::OptimizerFactoryWithDefaultParameters<CRTP>::handle_default_parameters(Optimizer *t_optimizer) const {
 
    if (m_logs.has_value()) {
        t_optimizer->set_param_logs(m_logs.value());
    }
 
    if (m_time_limit.has_value()) {
        t_optimizer->set_param_time_limit(m_time_limit.value());
    }
 
    if (m_thread_limit.has_value()) {
        t_optimizer->set_param_threads(m_thread_limit.value());
    }
 
    if (m_best_bound_stop.has_value()) {
        t_optimizer->set_param_best_bound_stop(m_best_bound_stop.value());
    }
 
    if (m_best_obj_stop.has_value()) {
        t_optimizer->set_param_best_obj_stop(m_best_obj_stop.value());
    }
 
    if (m_relative_gap_tolerance.has_value()) {
        t_optimizer->set_tol_mip_relative_gap(m_relative_gap_tolerance.value());
    }
 
    if (m_absolute_gap_tolerance.has_value()) {
        t_optimizer->set_tol_mip_absolute_gap(m_absolute_gap_tolerance.value());
    }
 
    if (m_iteration_count_limit.has_value()) {
        t_optimizer->set_param_iteration_limit(m_iteration_count_limit.value());
    }
 
    if (m_presolve.has_value()) {
        t_optimizer->set_param_presolve(m_presolve.value());
    }
 
    if (m_infeasible_or_unbounded_info.has_value()) {
        t_optimizer->set_param_infeasible_or_unbounded_info(m_infeasible_or_unbounded_info.value());
    }
 
}
 
#endif //IDOL_OPTIMIZERFACTORY_H