model.hpp

#pragma once
 
#include <algorithm>
#include <array>
#include <filesystem>
#include <functional>
#include <optional>
#include <scip/scip.h>
#include <string>
#include <type_traits>
#include <vector>
 
#include "scippp/constant_coefficient.hpp"
#include "scippp/lin_expr.hpp"
#include "scippp/lin_ineq.hpp"
#include "scippp/param.hpp"
#include "scippp/solution.hpp"
#include "scippp/statistics.hpp"
#include "scippp/var.hpp"
#include "scippp/var_type.hpp"
 
namespace scippp {
 
enum class Sense {
    MAXIMIZE = SCIP_OBJSENSE_MAXIMIZE,
    MINIMIZE = SCIP_OBJSENSE_MINIMIZE
};
 
class Model {
    Scip* m_scip;
    bool m_weCreatedANewScipObject { false };
    std::vector<Var> m_vars {};
    std::vector<SCIP_Cons*> m_cons {};
    SCIP_Retcode m_lastReturnCode;
    std::function<void(SCIP_Retcode)> m_scipCallWrapper;
 
public:
    explicit Model(const std::string& name, SCIP* scip = nullptr, bool includeDefaultPlugins = true);
 
    ~Model();
 
    [[nodiscard]] SCIP_Retcode getLastReturnCode() const;
 
    void setScipCallWrapper(std::function<void(SCIP_Retcode)> wrapper);
 
    Var& addVar(
        const std::string& name,
        SCIP_Real coeff = 0.0,
        VarType varType = VarType::CONTINUOUS,
        std::optional<SCIP_Real> lb = 0.0,
        std::optional<SCIP_Real> ub = 1.0);
 
    template <typename CoeffType = ConstantCoefficient>
    std::vector<Var> addVars(
        const std::string& prefix,
        size_t numVars,
        const CoeffType& coeffs = COEFF_ZERO,
        VarType varType = VarType::CONTINUOUS,
        std::optional<SCIP_Real> lb = 0.0,
        std::optional<SCIP_Real> ub = 1.0)
    {
        std::vector<Var> result;
        result.reserve(numVars);
        for (size_t index { 0 }; index < numVars; index++) {
            result.push_back(addVar(prefix + std::to_string(index), coeffs[index], varType, lb, ub));
        }
        return result;
    }
 
    template <size_t NumVars, typename CoeffType = ConstantCoefficient>
    std::array<Var, NumVars> addVars(
        const std::string& prefix,
        const CoeffType& coeffs = COEFF_ZERO,
        VarType varType = VarType::CONTINUOUS,
        std::optional<SCIP_Real> lb = 0.0,
        std::optional<SCIP_Real> ub = 1.0)
    {
        std::array<Var, NumVars> result;
        auto vec { addVars(prefix, NumVars, coeffs, varType, lb, ub) };
        std::copy_n(std::make_move_iterator(vec.begin()), NumVars, result.begin());
        return result;
    }
 
    void addConstr(const LinIneq& ineq, const std::string& name);
 
    [[nodiscard]] SCIP_Real infinity() const;
 
    [[nodiscard]] SCIP_Real epsilon() const;
 
    [[nodiscard]] SCIP_Real round(SCIP_Real value) const;
 
    [[nodiscard]] bool isZero(SCIP_Real value) const;
 
    void solve();
 
    void setObjsense(Sense objsense);
 
    [[nodiscard]] SCIP_Status getStatus() const;
 
    template <typename T>
    [[nodiscard]] T getSolvingStatistic(const statistics::Statistic<T>& statistic) const
    {
        return statistic(m_scip);
    }
 
    [[nodiscard]] int getNSols() const;
 
    [[nodiscard]] Solution getBestSol() const;
 
    [[deprecated("use getSolvingStatistic with statistics::PRIMALBOUND instead")]] //
    [[nodiscard]] double
    getPrimalbound() const;
 
    template <typename T, typename PT>
    void setParam(params::Param<PT> parameter, T value)
    {
        auto ptValue { static_cast<PT>(value) };
        const auto* cName { parameter.scipName.data() };
        if constexpr (std::is_same_v<PT, int>) {
            m_scipCallWrapper(SCIPsetIntParam(m_scip, cName, ptValue));
        } else if constexpr (std::is_same_v<PT, double>) {
            m_scipCallWrapper(SCIPsetRealParam(m_scip, cName, ptValue));
        } else if constexpr (std::is_same_v<PT, char>) {
            m_scipCallWrapper(SCIPsetCharParam(m_scip, cName, value));
        } else if constexpr (std::is_same_v<PT, bool>) {
            m_scipCallWrapper(SCIPsetBoolParam(m_scip, cName, value));
        } else if constexpr (std::is_same_v<PT, SCIP_Longint>) {
            m_scipCallWrapper(SCIPsetLongintParam(m_scip, cName, value));
        } else if constexpr (std::is_same_v<PT, std::string>) {
            m_scipCallWrapper(SCIPsetStringParam(m_scip, cName, value.c_str()));
        } else {
            // make this not compile
            // https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p2593r0.html#workarounds
            static_assert(sizeof(T) == 0);
        }
    }
 
    void writeOrigProblem(const std::filesystem::directory_entry& filename, bool genericNames = false) const;
 
    void writeOrigProblem(const std::string& extension, bool genericNames = false) const;
 
    [[deprecated(R"(Use this to access the raw SCIP object.
                    That is only required for use-cases not supported by SCIP++.
                    Consider adding the feature you are using to SCIP++!)")]] [[nodiscard]] Scip*
    scip() const;
};
}