GurobiSettings.hpp

Go to the documentation of this file.

#ifndef ZONOOPT_GUROBI_SETTINGS_HPP_
#define ZONOOPT_GUROBI_SETTINGS_HPP_
 
#include <map>
#include <optional>
#include <sstream>
#include <stdexcept>
#include <string>
 
#include "SolverDataStructures.hpp"
 
namespace ZonoOpt
{
    // Forward declarations so GurobiSettings can check availability inline without
    // pulling in GurobiSolver.hpp (which depends on this file).
    namespace detail
    {
        bool gurobi_available();
        const std::string& gurobi_unavailable_reason();
    }
 
    struct GurobiSettings : SolverSettings
    {
        // ---- Termination ----
        std::optional<double> TimeLimit;      
        std::optional<double> WorkLimit;      
        std::optional<double> MemLimit;       
        std::optional<int>    SolutionLimit;  
 
        // ---- Tolerances ----
        std::optional<double> MIPGap;         
        std::optional<double> MIPGapAbs;      
        std::optional<double> FeasibilityTol; 
        std::optional<double> OptimalityTol;  
        std::optional<double> IntFeasTol;     
 
        // ---- Algorithm selection / behavior ----
        std::optional<int>    Method;         
        std::optional<int>    Presolve;       
        std::optional<int>    Cuts;           
        std::optional<int>    MIPFocus;       
        std::optional<int>    NumericFocus;   
        std::optional<double> Heuristics;     
        std::optional<int>    Threads;        
        std::optional<int>    Seed;           
 
        // ---- Solution pool (used by mi_opt_multisol) ----
        std::optional<int>    PoolSolutions;
        std::optional<int>    PoolSearchMode;
        std::optional<double> PoolGap;
        std::optional<double> PoolGapAbs;
 
        // ---- Logging ----
        std::optional<int>         OutputFlag; 
        std::optional<int>         LogToConsole;
        std::optional<std::string> LogFile;
 
        // ---- Escape hatch for any Gurobi parameter not exposed above ----
        // Keys are the documented Gurobi parameter names, e.g.,
        //   int_params["BarIterLimit"] = 500;
        //   dbl_params["NodefileStart"] = 0.5;
        //   str_params["WLSAccessID"] = "...";
        // See https://docs.gurobi.com/projects/optimizer/en/current/reference/parameters.html
        std::map<std::string, int>         int_params;
        std::map<std::string, double>      dbl_params;
        std::map<std::string, std::string> str_params;
 
        // polymorphic copy
        std::unique_ptr<SolverSettings> clone() const override
        {
            return std::make_unique<GurobiSettings>(*this);
        }
 
        // throws if the Gurobi shared library cannot be dynamically loaded
        void verify_available() const override
        {
            if (!detail::gurobi_available())
            {
                throw std::runtime_error("GurobiSettings: " + detail::gurobi_unavailable_reason());
            }
        }
 
        std::string print() const
        {
            std::stringstream ss;
            ss << "GurobiSettings (unset fields use Gurobi 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"; };
            auto opt_str = [&](const char* n, const std::optional<std::string>& v) { if (v) ss << "  " << n << " = \"" << *v << "\"\n"; };
 
            opt_dbl("TimeLimit", TimeLimit);
            opt_dbl("WorkLimit", WorkLimit);
            opt_dbl("MemLimit", MemLimit);
            opt_int("SolutionLimit", SolutionLimit);
 
            opt_dbl("MIPGap", MIPGap);
            opt_dbl("MIPGapAbs", MIPGapAbs);
            opt_dbl("FeasibilityTol", FeasibilityTol);
            opt_dbl("OptimalityTol", OptimalityTol);
            opt_dbl("IntFeasTol", IntFeasTol);
 
            opt_int("Method", Method);
            opt_int("Presolve", Presolve);
            opt_int("Cuts", Cuts);
            opt_int("MIPFocus", MIPFocus);
            opt_int("NumericFocus", NumericFocus);
            opt_dbl("Heuristics", Heuristics);
            opt_int("Threads", Threads);
            opt_int("Seed", Seed);
 
            opt_int("PoolSolutions", PoolSolutions);
            opt_int("PoolSearchMode", PoolSearchMode);
            opt_dbl("PoolGap", PoolGap);
            opt_dbl("PoolGapAbs", PoolGapAbs);
 
            opt_int("OutputFlag", OutputFlag);
            opt_int("LogToConsole", LogToConsole);
            opt_str("LogFile", LogFile);
 
            for (const auto& kv : int_params) ss << "  [int] "  << kv.first << " = " << kv.second << "\n";
            for (const auto& kv : dbl_params) ss << "  [dbl] "  << kv.first << " = " << kv.second << "\n";
            for (const auto& kv : str_params) ss << "  [str] "  << kv.first << " = \"" << kv.second << "\"\n";
            return ss.str();
        }
 
        GurobiSettings() { verify_available(); }
 
        std::string solver_name() const override
        {
            return "Gurobi";
        }
    };
 
    struct GurobiSolverResults : ExternalSolverResults
    {
        int status = 0;
 
        double iter_count = 0.0;
 
        double node_count = 0.0;
 
        double mip_gap = 0.0;
 
        double obj_bound = 0.0;
 
        std::shared_ptr<ExternalSolverResults> clone() const override
        {
            return std::make_shared<GurobiSolverResults>(*this);
        }
 
        std::string print() const override
        {
            std::stringstream ss;
            ss << "GurobiSolverResults:\n";
            ss << "  status: " << status << "\n";
            ss << "  iter_count: " << iter_count << "\n";
            ss << "  node_count: " << node_count << "\n";
            ss << "  mip_gap: " << mip_gap << "\n";
            ss << "  obj_bound: " << obj_bound << "\n";
            return ss.str();
        }
    };
} // namespace ZonoOpt
 
#endif