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 <sstream>
 
namespace ZonoOpt
{
 
struct OptSettings
{
    // 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 max_nodes = static_cast<int>(1e5);
 
    int contractor_tree_search_depth = 10;
 
    // 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 && max_nodes > 0 && contractor_tree_search_depth > 0 &&
               (search_mode == 0 || search_mode == 1));
 
        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 << "  max_nodes: " << max_nodes << std::endl;
        ss << "  contractor_tree_search_depth: " << contractor_tree_search_depth;
        return ss.str();
    }
};
 
struct OptSolution
{
    // general
 
    Eigen::Vector<zono_float, -1> z;
 
    zono_float J = -std::numeric_limits<zono_float>::infinity();
 
    double run_time = 0.0;
 
    double startup_time = 0.0;
 
    int iter = 0;
 
    bool converged = false;
 
    bool infeasible = false;
 
    // admm-specific
 
    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();
 
    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;
        return ss.str();
    }
};
 
 
} // end namespace ZonoOpt
 
#endif