SolverDataStructures.hpp

Go to the documentation of this file.

#ifndef ZONOOPT_SOLVER_DATA_STRUCUTURES_HPP_
#define ZONOOPT_SOLVER_DATA_STRUCUTURES_HPP_
 
#include <Eigen/Dense>
#include <memory>
#include <sstream>
#include <string>
 
namespace ZonoOpt
{
    struct SolverSettings
    {
        virtual ~SolverSettings() = default;
 
        virtual std::unique_ptr<SolverSettings> clone() const = 0;
 
        virtual void verify_available() const {}
 
        virtual std::string solver_name() const = 0;
    };
 
    struct OptSettings : SolverSettings
    {
        // general settings
 
        bool verbose = false;
 
        int verbosity_interval = 100;
 
        double t_max = std::numeric_limits<double>::max();
 
        // ADMM settings
 
        int k_max_admm = 5000;
 
        zono_float rho = static_cast<zono_float>(10.0);
 
        zono_float eps_dual = static_cast<zono_float>(1e-2);
 
        zono_float eps_prim = static_cast<zono_float>(1e-3);
 
        int k_inf_check = 10;
 
        bool inf_norm_conv = true;
 
        bool use_interval_contractor = true;
 
        int contractor_iter = 1;
 
        // mixed integer settings
 
        int search_mode = 0;
 
        bool polish = true;
 
        zono_float eps_dual_search = static_cast<zono_float>(1e-1);
 
        zono_float eps_prim_search = static_cast<zono_float>(1e-2);
 
        zono_float eps_r = static_cast<zono_float>(1e-2);
 
        zono_float eps_a = static_cast<zono_float>(1e-1);
 
        int k_max_bnb = static_cast<int>(1e5);
 
        int n_threads_bnb = 4;
 
        int n_threads_admm_fp = 3;
 
        bool single_threaded_admm_fp = false;
 
        int max_nodes = static_cast<int>(1e5);
 
        int contractor_tree_search_depth = 10;
 
        bool enable_perturb_admm_fp = true;
 
        bool enable_restart_admm_fp = true;
 
        int k_max_admm_fp_ph1 = 10000;
 
        int k_max_admm_fp_ph2 = 90000;
 
        int cycle_detection_buffer_size = 20;
 
        zono_float eps_perturb = static_cast<zono_float>(1e-3);
 
        int k_restart = 5000;
 
        bool enable_rng_seed = false;
 
        unsigned int rng_seed = 0;
 
        // polymorphic copy
        std::unique_ptr<SolverSettings> clone() const override
        {
            return std::make_unique<OptSettings>(*this);
        }
 
        // validity check
        bool settings_valid() const
        {
            const bool general_valid = t_max > 0 && verbosity_interval > 0;
            const bool admm_valid = (rho > 0 && k_max_admm > 0 &&
                eps_dual >= 0 && eps_prim >= 0 && k_inf_check >= 0 && contractor_iter > 0);
            const bool mi_valid = (eps_r >= 0 && eps_a >= 0 && eps_dual_search > 0 && eps_prim_search > 0 &&
                k_max_bnb > 0 && n_threads_bnb >= 0 && n_threads_admm_fp >= 0 && max_nodes > 0 &&
                contractor_tree_search_depth > 0 &&
                k_max_admm_fp_ph1 > 0 && cycle_detection_buffer_size > 0 &&
                (search_mode == 0 || search_mode == 1) &&
                eps_perturb > 0);
 
            return (general_valid && admm_valid && mi_valid);
        }
 
        std::string print() const
        {
            std::stringstream ss;
            ss << "OptSettings structure: " << std::endl;
            ss << "  verbose: " << (verbose ? "true" : "false") << std::endl;
            ss << "  verbosity_interval: " << verbosity_interval << std::endl;
            ss << "  t_max: " << t_max << std::endl;
            ss << "  k_max_admm: " << k_max_admm << std::endl;
            ss << "  rho: " << rho << std::endl;
            ss << "  eps_dual: " << eps_dual << std::endl;
            ss << "  eps_prim: " << eps_prim << std::endl;
            ss << "  k_inf_check: " << k_inf_check << std::endl;
            ss << "  inf_norm_conv: " << (inf_norm_conv ? "true" : "false") << std::endl;
            ss << "  use_interval_contractor: " << (use_interval_contractor ? "true" : "false") << std::endl;
            ss << "  contractor_iter: " << contractor_iter << std::endl;
            ss << "  search_mode: " << search_mode << std::endl;
            ss << "  polish: " << polish << std::endl;
            ss << "  eps_dual_search: " << eps_dual_search << std::endl;
            ss << "  eps_prim_search: " << eps_prim_search << std::endl;
            ss << "  eps_r: " << eps_r << std::endl;
            ss << "  eps_a: " << eps_a << std::endl;
            ss << "  k_max_bnb: " << k_max_bnb << std::endl;
            ss << "  n_threads_bnb: " << n_threads_bnb << std::endl;
            ss << "  n_threads_admm_fp: " << n_threads_admm_fp << std::endl;
            ss << "  single_threaded_admm_fp: " << (single_threaded_admm_fp ? "true" : "false") << std::endl;
            ss << "  max_nodes: " << max_nodes << std::endl;
            ss << "  contractor_tree_search_depth: " << contractor_tree_search_depth << std::endl;
            ss << "  enable_perturb_admm_fp: " << (enable_perturb_admm_fp ? "true" : "false") << std::endl;
            ss << "  k_max_admm_fp_ph1: " << k_max_admm_fp_ph1 << std::endl;
            ss << "  k_max_admm_fp_ph2: " << k_max_admm_fp_ph2 << std::endl;
            ss << "  cycle_detection_buffer_size: " << cycle_detection_buffer_size << std::endl;
            ss << "  eps_perturb: " << eps_perturb << std::endl;
            ss << "  k_restart: " << k_restart << std::endl;
            ss << "  enable_rng_seed: " << (enable_rng_seed ? "true" : "false") << std::endl;
            ss << "  rng_seed: " << rng_seed << std::endl;
            ss << "  enable_restart_admm_fp: " << (enable_restart_admm_fp ? "true" : "false") << std::endl;
            return ss.str();
        }
 
        std::string solver_name() const override
        {
            return "ZonoOpt";
        }
 
        OptSettings() = default;
    };
 
    struct ExternalSolverResults
    {
        virtual ~ExternalSolverResults() = default;
 
        virtual std::shared_ptr<ExternalSolverResults> clone() const = 0;
 
        virtual std::string print() const { return "ExternalSolverResults"; }
    };
 
    struct OptSolution
    {
        // general — always populated
 
        Eigen::Vector<zono_float, -1> z;
 
        zono_float J = -std::numeric_limits<zono_float>::infinity();
 
        double run_time = 0.0;
 
        bool converged = false;
 
        bool infeasible = false;
 
        // admm-specific — meaningful only when the internal solver was used.
 
        double startup_time = 0.0;
 
        int iter = 0;
 
        Eigen::Vector<zono_float, -1> x;
 
        Eigen::Vector<zono_float, -1> u;
 
        zono_float primal_residual = std::numeric_limits<zono_float>::infinity();
 
        zono_float dual_residual = std::numeric_limits<zono_float>::infinity();
 
        // external-solver-specific — populated only when an external solver was used.
 
        std::shared_ptr<ExternalSolverResults> external_results;
 
        std::string print() const
        {
            std::stringstream ss;
            ss << "OptSolution structure:" << std::endl;
            ss << "  z: vector of length " << z.size() << std::endl;
            ss << "  J: " << J << std::endl;
            ss << "  run_time: " << run_time << std::endl;
            ss << "  startup_time: " << startup_time << std::endl;
            ss << "  iter: " << iter << std::endl;
            ss << "  converged: " << (converged ? "true" : "false") << std::endl;
            ss << "  infeasible: " << (infeasible ? "true" : "false") << std::endl;
            ss << "  x: vector of length " << x.size() << std::endl;
            ss << "  u: vector of length " << u.size() << std::endl;
            ss << "  primal_residual: " << primal_residual << std::endl;
            ss << "  dual_residual: " << dual_residual << std::endl;
            if (external_results)
                ss << "  external_results: " << external_results->print() << std::endl;
            return ss.str();
        }
    };
 
    // ---- Program-wide default solver settings -------------------------------
    //
    // ZonoOpt's optimization methods take a SolverSettings argument whose default
    // is whatever set_default_solver_settings() last installed. This lets a user
    // switch the entire library to (e.g.) Gurobi by calling
    //     set_default_solver_settings(GurobiSettings{});
    // once at program startup, instead of passing GurobiSettings to every call.
    //
    // Initial default is OptSettings() (internal ADMM/branch-and-bound).
    //
    // Not thread-safe: set_default_solver_settings should be called from a single
    // thread at startup before parallel optimization begins. Existing const
    // SolverSettings& references obtained from get_default_solver_settings() are
    // invalidated by a subsequent set_default_solver_settings() call.
 
    namespace detail
    {
        inline std::unique_ptr<SolverSettings>& default_settings_storage()
        {
            static std::unique_ptr<SolverSettings> p = std::make_unique<OptSettings>();
            return p;
        }
    } // namespace detail
 
    inline const SolverSettings& get_default_solver_settings()
    {
        return *detail::default_settings_storage();
    }
 
    inline void set_default_solver_settings(const SolverSettings& settings)
    {
        settings.verify_available();
        detail::default_settings_storage() = settings.clone();
    }
} // end namespace ZonoOpt
 
#endif