BranchAndBound.h

//
// Created by henri on 21/03/23.
//
 
#ifndef IDOL_BRANCHANDBOUND_H
#define IDOL_BRANCHANDBOUND_H
 
#include <memory>
#include "idol/general/optimizers/OptimizerFactory.h"
#include "Optimizers_BranchAndBound.h"
#include "idol/mixed-integer/optimizers/branch-and-bound/callbacks/BranchAndBoundCallbackFactory.h"
#include "idol/mixed-integer/optimizers/branch-and-bound/callbacks/BranchAndBoundCallback.h"
#include "idol/mixed-integer/optimizers/branch-and-bound/callbacks/CallbackAsBranchAndBoundCallback.h"
#include "idol/mixed-integer/optimizers/presolve/AbstractPresolver.h"
#include "idol/mixed-integer/optimizers/callbacks/CallbackFactory.h"
#include "idol/mixed-integer/optimizers/branch-and-bound/nodes/DefaultNodeInfo.h"
#include "idol/mixed-integer/optimizers/branch-and-bound/logs/Factory.h"
#include "idol/mixed-integer/optimizers/branch-and-bound/logs/Info.h"
 
namespace idol {
    template<class NodeT>
    class BranchAndBound;
}

template<class NodeT = idol::DefaultNodeInfo>
class idol::BranchAndBound : public OptimizerFactoryWithDefaultParameters<BranchAndBound<NodeT>> {
    std::unique_ptr<OptimizerFactory> m_relaxation_optimizer_factory;
    std::unique_ptr<BranchingRuleFactory<NodeT>> m_branching_rule_factory;
    std::unique_ptr<NodeSelectionRuleFactory<NodeT>> m_node_selection_rule_factory;
    std::unique_ptr<Logs::BranchAndBound::Factory<NodeT>> m_logger_factory;
    std::unique_ptr<NodeT> m_root_node_info;
 
    std::list<std::unique_ptr<Presolvers::AbstractPresolver>> m_presolvers;
    std::list<std::unique_ptr<BranchAndBoundCallbackFactory<NodeT>>> m_callbacks;
 
    std::optional<unsigned int> m_subtree_depth;
    std::optional<unsigned int> m_log_frequency;
protected:
    [[nodiscard]] Optimizer *create(const Model &t_model) const override;
public:
    template<class ReturnT, class T> using only_if_has_Strategy = typename std::pair<typename T::template Strategy<NodeT>, ReturnT>::second_type;

    BranchAndBound() = default;

    BranchAndBound(const BranchAndBound& t_rhs);

    BranchAndBound<NodeT>& with_node_optimizer(const OptimizerFactory& t_node_optimizer);
 
    void set_node_optimizer(const OptimizerFactory& t_node_optimizer);
 
    BranchAndBound<NodeT>& operator+=(const OptimizerFactory& t_node_optimizer);

    BranchAndBound<NodeT>& with_branching_rule(const BranchingRuleFactory<NodeT>& t_branching_rule);

    template<class BranchingRuleFactoryT>
    only_if_has_Strategy<BranchAndBound<NodeT>&, BranchingRuleFactoryT> with_branching_rule(const BranchingRuleFactoryT& t_branching_rule);

    BranchAndBound<NodeT>& with_node_selection_rule(const NodeSelectionRuleFactory<NodeT>& t_node_selection);

    template<class NodeSelectionRuleFactoryT>
    only_if_has_Strategy<BranchAndBound<NodeT>&, NodeSelectionRuleFactoryT> with_node_selection_rule(const NodeSelectionRuleFactoryT& t_node_selection_rule);
 
    BranchAndBound(BranchAndBound&&) noexcept = default;
    BranchAndBound& operator=(const BranchAndBound&) = delete;
    BranchAndBound& operator=(BranchAndBound&&) noexcept = delete;
 
    [[nodiscard]] OptimizerFactory *clone() const override;

    BranchAndBound<NodeT>& with_subtree_depth(unsigned int t_depth);
 
    BranchAndBound<NodeT>& with_logger(const Logs::BranchAndBound::Factory<NodeT>& t_log_factory);

    BranchAndBound<NodeT>& add_callback(const BranchAndBoundCallbackFactory<NodeT> & t_callback);

    BranchAndBound<NodeT>& add_callback(const CallbackFactory& t_callback);
 
    BranchAndBound<NodeT>& add_presolver(const Presolvers::AbstractPresolver& t_presolver);
 
    BranchAndBound<NodeT>& with_root_node_info(const NodeT& t_root_node_info);
};
 
template<class NodeT>
void idol::BranchAndBound<NodeT>::set_node_optimizer(const idol::OptimizerFactory &t_node_optimizer) {
    m_relaxation_optimizer_factory.reset(t_node_optimizer.clone());
}
 
template<class NodeT>
idol::BranchAndBound<NodeT> &
idol::BranchAndBound<NodeT>::with_logger(const typename idol::Logs::BranchAndBound::Factory<NodeT> &t_log_factory) {
 
    if (m_logger_factory) {
        throw Exception("Logs have already been configured.");
    }
 
    m_logger_factory.reset(t_log_factory.clone());
 
    return *this;
}
 
template<class NodeT>
idol::BranchAndBound<NodeT> &idol::BranchAndBound<NodeT>::operator+=(const idol::OptimizerFactory &t_node_optimizer) {
    return with_node_optimizer(t_node_optimizer);
}
 
template<class NodeT>
idol::BranchAndBound<NodeT> &
idol::BranchAndBound<NodeT>::add_callback(const CallbackFactory &t_callback) {
    return add_callback(CallbackAsBranchAndBoundCallback<NodeT>(t_callback));
}
 
template <class NodeT>
idol::BranchAndBound<NodeT>& idol::BranchAndBound<NodeT>::add_presolver(const Presolvers::AbstractPresolver& t_presolver) {
    m_presolvers.emplace_back(t_presolver.clone());
    return *this;
}
 
template <class NodeT>
idol::BranchAndBound<NodeT>& idol::BranchAndBound<NodeT>::with_root_node_info(const NodeT& t_root_node_info) {
 
    if (m_root_node_info) {
        throw Exception("A root node info has already been given");
    }
 
    m_root_node_info.reset(t_root_node_info.clone());
 
    return *this;
}
 
template<class NodeT>
idol::BranchAndBound<NodeT> &idol::BranchAndBound<NodeT>::add_callback(const BranchAndBoundCallbackFactory<NodeT> &t_callback) {
 
    m_callbacks.emplace_back(t_callback.clone());
 
    return *this;
}
 
template<class NodeT>
idol::BranchAndBound<NodeT> &idol::BranchAndBound<NodeT>::with_subtree_depth(unsigned int t_depth) {
 
    if (m_subtree_depth.has_value()) {
        throw Exception("A subtree depth has already been given");
    }
 
    m_subtree_depth = t_depth;
 
    return *this;
}
 
template<class NodeT>
template<class NodeSelectionRuleFactoryT>
typename idol::BranchAndBound<NodeT>::template only_if_has_Strategy<idol::BranchAndBound<NodeT>&, NodeSelectionRuleFactoryT>
idol::BranchAndBound<NodeT>::with_node_selection_rule(const NodeSelectionRuleFactoryT &t_node_selection_rule) {
    return with_node_selection_rule(typename NodeSelectionRuleFactoryT::template Strategy<NodeT>(t_node_selection_rule));
}
 
template<class NodeT>
idol::BranchAndBound<NodeT> &
idol::BranchAndBound<NodeT>::with_node_selection_rule(const NodeSelectionRuleFactory<NodeT> &t_node_selection) {
 
    if (m_node_selection_rule_factory) {
        throw Exception("A node selection rule has already been set.");
    }
 
    m_node_selection_rule_factory.reset(t_node_selection.clone());
 
    return *this;
}
 
template<class NodeT>
template<class BranchingRuleFactoryT>
typename idol::BranchAndBound<NodeT>::template only_if_has_Strategy<idol::BranchAndBound<NodeT>&, BranchingRuleFactoryT>
idol::BranchAndBound<NodeT>::with_branching_rule(const BranchingRuleFactoryT &t_branching_rule) {
    return with_branching_rule(typename BranchingRuleFactoryT::template Strategy<NodeT>(t_branching_rule));
}
 
template<class NodeT>
idol::BranchAndBound<NodeT> &idol::BranchAndBound<NodeT>::with_branching_rule(const BranchingRuleFactory<NodeT> &t_branching_rule) {
 
    if (m_branching_rule_factory) {
        throw Exception("A branching rule has already been set.");
    }
 
    m_branching_rule_factory.reset(t_branching_rule.clone());
 
    return *this;
}
 
template<class NodeT>
idol::BranchAndBound<NodeT> &idol::BranchAndBound<NodeT>::with_node_optimizer(const OptimizerFactory &t_node_optimizer) {
 
    if (m_relaxation_optimizer_factory) {
        throw Exception("A node solver has already been set.");
    }
 
    m_relaxation_optimizer_factory.reset(t_node_optimizer.clone());
 
    return *this;
}
 
template<class NodeT>
idol::BranchAndBound<NodeT>::BranchAndBound(const BranchAndBound &t_rhs)
 
        : OptimizerFactoryWithDefaultParameters<BranchAndBound<NodeT>>(t_rhs),
          m_relaxation_optimizer_factory(t_rhs.m_relaxation_optimizer_factory ? t_rhs.m_relaxation_optimizer_factory->clone() : nullptr),
          m_branching_rule_factory(t_rhs.m_branching_rule_factory ? t_rhs.m_branching_rule_factory->clone() : nullptr),
          m_node_selection_rule_factory(t_rhs.m_node_selection_rule_factory ? t_rhs.m_node_selection_rule_factory->clone() : nullptr),
          m_subtree_depth(t_rhs.m_subtree_depth),
          m_logger_factory(t_rhs.m_logger_factory ? t_rhs.m_logger_factory->clone() : nullptr),
          m_root_node_info(t_rhs.m_root_node_info ? t_rhs.m_root_node_info->clone() : nullptr) {
 
    for (auto& presolve : t_rhs.m_presolvers) {
        m_presolvers.emplace_back(presolve->clone());
    }
 
    for (auto& cb : t_rhs.m_callbacks) {
        m_callbacks.emplace_back(cb->clone());
    }
 
}
 
template<class NodeT>
idol::Optimizer *idol::BranchAndBound<NodeT>::create(const Model &t_model) const {
 
    if (!m_relaxation_optimizer_factory) {
        throw Exception("No node solver has been given, please call BranchAndBound::with_node_optimizer to configure.");
    }
 
    if (!m_branching_rule_factory) {
        throw Exception("No branching rule has been given, please call BranchAndBound::with_branching_rule to configure.");
    }
 
    if (!m_node_selection_rule_factory) {
        throw Exception("No node selection rule has been given, please call BranchAndBound::with_node_selection_rule to configure.");
    }
 
    std::unique_ptr<Logs::BranchAndBound::Factory<NodeT>> default_logger_factory;
    if (!m_logger_factory) {
        default_logger_factory = std::make_unique<Logs::BranchAndBound::Info<NodeT>>();
    }
 
    auto* result = new Optimizers::BranchAndBound<NodeT>(t_model,
                                                         *m_relaxation_optimizer_factory,
                                                         *m_branching_rule_factory,
                                                         *m_node_selection_rule_factory,
                                                         new BranchAndBoundCallbackI<NodeT>(),
                                                         m_logger_factory ? *m_logger_factory : *default_logger_factory);
 
    if (m_root_node_info) {
        result->set_root_node_info(*m_root_node_info);
    }
 
    if (m_subtree_depth) {
        result->set_subtree_depth(m_subtree_depth.value());
    }
 
    for (auto& presolver : m_presolvers) {
        result->add_presolver(*presolver);
    }
 
    for (auto& cb : m_callbacks) {
        result->add_callback(cb->operator()());
    }
 
    return result;
}
 
template<class NodeT>
idol::OptimizerFactory *idol::BranchAndBound<NodeT>::clone() const {
    return new BranchAndBound(*this);
}
 
namespace idol {
    template<class NodeInfoT>
    BranchAndBound<NodeInfoT> operator+(const BranchAndBound<NodeInfoT>& t_branch_and_bound, const OptimizerFactory& t_node_optimizer) {
        BranchAndBound<NodeInfoT> result(t_branch_and_bound);
        result += t_node_optimizer;
        return result;
    }
}
 
#endif //IDOL_BRANCHANDBOUND_H