OptiOptions.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <casadi/casadi.hpp>
#include <string>
 
namespace janus {

enum class Solver {
    Ipopt,  
    Snopt,  
    QpOases 
};

inline bool solver_available(Solver solver);

inline const char *solver_name(Solver solver) {
    switch (solver) {
    case Solver::Snopt:
        return "snopt";
    case Solver::QpOases:
        return "qpoases";
    case Solver::Ipopt:
    default:
        return "ipopt";
    }
}

inline bool solver_available(Solver solver) { return casadi::has_nlpsol(solver_name(solver)); }

struct SNOPTOptions {
    int major_iterations_limit = 1000;         
    int minor_iterations_limit = 500;          
    double major_optimality_tolerance = 1e-6;  
    double major_feasibility_tolerance = 1e-6; 
    int print_level = 0;                       

    SNOPTOptions &set_major_iterations_limit(int v) {
        major_iterations_limit = v;
        return *this;
    }

    SNOPTOptions &set_minor_iterations_limit(int v) {
        minor_iterations_limit = v;
        return *this;
    }

    SNOPTOptions &set_major_optimality_tolerance(double v) {
        major_optimality_tolerance = v;
        return *this;
    }

    SNOPTOptions &set_major_feasibility_tolerance(double v) {
        major_feasibility_tolerance = v;
        return *this;
    }

    SNOPTOptions &set_print_level(int v) {
        print_level = v;
        return *this;
    }
};

struct OptiOptions {
    // Solver selection
    Solver solver = Solver::Ipopt; 
    SNOPTOptions snopt_opts;       
 
    // General solver options (used by all solvers where applicable)
    int max_iter = 1000;                  
    double max_cpu_time = 1e20;           
    double tol = 1e-8;                    
    bool verbose = true;                  
    bool jit = false;                     
    bool detect_simple_bounds = false;    
    std::string mu_strategy = "adaptive"; 

    OptiOptions &set_max_iter(int v) {
        max_iter = v;
        return *this;
    }

    OptiOptions &set_max_cpu_time(double v) {
        max_cpu_time = v;
        return *this;
    }

    OptiOptions &set_tol(double v) {
        tol = v;
        return *this;
    }

    OptiOptions &set_verbose(bool v) {
        verbose = v;
        return *this;
    }

    OptiOptions &set_jit(bool v) {
        jit = v;
        return *this;
    }

    OptiOptions &set_detect_simple_bounds(bool v) {
        detect_simple_bounds = v;
        return *this;
    }

    OptiOptions &set_mu_strategy(const std::string &v) {
        mu_strategy = v;
        return *this;
    }

    OptiOptions &set_solver(Solver v) {
        solver = v;
        return *this;
    }

    OptiOptions &set_snopt_opts(const SNOPTOptions &v) {
        snopt_opts = v;
        return *this;
    }
};
 
} // namespace janus