SCIPSettings.hpp

Go to the documentation of this file.

#ifndef ZONOOPT_SCIP_SETTINGS_HPP_
#define ZONOOPT_SCIP_SETTINGS_HPP_
 
#include <map>
#include <optional>
#include <sstream>
#include <stdexcept>
#include <string>
 
#include "SolverDataStructures.hpp"
 
namespace ZonoOpt
{
    namespace detail
    {
        bool scip_available();
        const std::string& scip_unavailable_reason();
    }
 
    struct SCIPSettings : SolverSettings
    {
        // ---- Limits ----
        std::optional<double> TimeLimit;       
        std::optional<double> MemLimit;        
        std::optional<int>    SolutionLimit;   
        std::optional<int>    NodeLimit;       
 
        // ---- Tolerances ----
        std::optional<double> MIPGap;          
        std::optional<double> MIPGapAbs;       
        std::optional<double> FeasibilityTol;  
 
        // ---- Behavior ----
        std::optional<int>    Threads;         
        std::optional<int>    Seed;            
 
        // ---- Display ----
        std::optional<int>    VerbLevel;
 
        // ---- Escape-hatch maps for any SCIP parameter not exposed above ----
        // Keys are SCIP's documented parameter names (slash-separated paths),
        // e.g., real_params["numerics/dualfeastol"] = 1e-9.
        std::map<std::string, bool>         bool_params;
        std::map<std::string, int>          int_params;
        std::map<std::string, long long>    longint_params;
        std::map<std::string, double>       real_params;
        std::map<std::string, char>         char_params;
        std::map<std::string, std::string>  str_params;
 
        // ---- SolverSettings interface ------------------------------------------
        std::unique_ptr<SolverSettings> clone() const override
        {
            return std::make_unique<SCIPSettings>(*this);
        }
 
        void verify_available() const override
        {
            if (!detail::scip_available())
            {
                throw std::runtime_error("SCIPSettings: " + detail::scip_unavailable_reason());
            }
        }
 
        // ---- Debug print --------------------------------------------------------
        std::string print() const
        {
            std::stringstream ss;
            ss << "SCIPSettings (unset fields use SCIP defaults):\n";
            auto opt_int    = [&](const char* n, const std::optional<int>& v)    { if (v) ss << "  " << n << " = " << *v << "\n"; };
            auto opt_dbl    = [&](const char* n, const std::optional<double>& v) { if (v) ss << "  " << n << " = " << *v << "\n"; };
 
            opt_dbl("TimeLimit", TimeLimit);
            opt_dbl("MemLimit", MemLimit);
            opt_int("SolutionLimit", SolutionLimit);
            opt_int("NodeLimit", NodeLimit);
            opt_dbl("MIPGap", MIPGap);
            opt_dbl("MIPGapAbs", MIPGapAbs);
            opt_dbl("FeasibilityTol", FeasibilityTol);
            opt_int("Threads", Threads);
            opt_int("Seed", Seed);
            opt_int("VerbLevel", VerbLevel);
 
            for (const auto& kv : bool_params)    ss << "  [bool]    " << kv.first << " = " << (kv.second ? "true" : "false") << "\n";
            for (const auto& kv : int_params)     ss << "  [int]     " << kv.first << " = " << kv.second << "\n";
            for (const auto& kv : longint_params) ss << "  [longint] " << kv.first << " = " << kv.second << "\n";
            for (const auto& kv : real_params)    ss << "  [real]    " << kv.first << " = " << kv.second << "\n";
            for (const auto& kv : char_params)    ss << "  [char]    " << kv.first << " = '" << kv.second << "'\n";
            for (const auto& kv : str_params)     ss << "  [str]     " << kv.first << " = \"" << kv.second << "\"\n";
            return ss.str();
        }
 
        SCIPSettings() { verify_available(); }
 
        std::string solver_name() const override
        {
            return "SCIP";
        }
    };
 
    struct SCIPSolverResults : ExternalSolverResults
    {
        int status = 0;
 
        long long node_count = 0;
 
        double mip_gap = 0.0;
 
        double dual_bound = 0.0;
 
        int n_sols_pool = 0;
 
        std::shared_ptr<ExternalSolverResults> clone() const override
        {
            return std::make_shared<SCIPSolverResults>(*this);
        }
 
        std::string print() const override
        {
            std::stringstream ss;
            ss << "SCIPSolverResults:\n";
            ss << "  status: " << status << "\n";
            ss << "  node_count: " << node_count << "\n";
            ss << "  mip_gap: " << mip_gap << "\n";
            ss << "  dual_bound: " << dual_bound << "\n";
            ss << "  n_sols_pool: " << n_sols_pool << "\n";
            return ss.str();
        }
    };
} // namespace ZonoOpt
 
#endif