StabilizedQpToQp::StabilizedQpToQp(const std::vector<Sparsity> &st) : StabilizedQpSolverInternal(st) { addOption("qp_solver", OT_STRING, GenericType(), "The QP solver used to solve the stabilized QPs."); addOption("qp_solver_options", OT_DICTIONARY, GenericType(), "Options to be passed to the QP solver instance"); }
DirectSingleShootingInternal::DirectSingleShootingInternal(const FX& ffcn, const FX& mfcn, const FX& cfcn, const FX& rfcn) : OCPSolverInternal(ffcn, mfcn, cfcn, rfcn){ addOption("parallelization", OT_STRING, GenericType(), "Passed on to CasADi::Parallelizer"); addOption("nlp_solver", OT_NLPSOLVER, GenericType(), "An NLPSolver creator function"); addOption("nlp_solver_options", OT_DICTIONARY, GenericType(), "Options to be passed to the NLP Solver"); addOption("integrator", OT_INTEGRATOR, GenericType(), "An integrator creator function"); addOption("integrator_options", OT_DICTIONARY, GenericType(), "Options to be passed to the integrator"); }
DirectCollocationInternal::DirectCollocationInternal(const FX& ffcn, const FX& mfcn, const FX& cfcn, const FX& rfcn) : OCPSolverInternal(ffcn, mfcn, cfcn, rfcn){ addOption("nlp_solver", OT_NLPSOLVER, GenericType(), "An NLPSolver creator function"); addOption("nlp_solver_options", OT_DICTIONARY, GenericType(), "Options to be passed to the NLP Solver"); addOption("interpolation_order", OT_INTEGER, 3, "Order of the interpolating polynomials"); addOption("collocation_scheme", OT_STRING, "radau", "Collocation scheme","radau|legendre"); casadi_warning("CasADi::DirectCollocation is still experimental"); }
ImplicitFixedStepIntegratorInternal::ImplicitFixedStepIntegratorInternal(const Function& f, const Function& g) : FixedStepIntegratorInternal(f, g) { addOption("implicit_solver", OT_STRING, GenericType(), "An implicit function solver"); addOption("implicit_solver_options", OT_DICTIONARY, GenericType(), "Options to be passed to the NLP Solver"); }
QCQPQPInternal::QCQPQPInternal(const std::vector<Sparsity> &st) : QpSolverInternal(st) { addOption("qcqp_solver", OT_STRING, GenericType(), "The QcqpSolver used to solve the QPs."); addOption("qcqp_solver_options", OT_DICTIONARY, GenericType(), "Options to be passed to the QCQPSOlver"); }
DpleToDle::DpleToDle( const DleStructure& st, const std::vector<int> &Hs) : DleInternal(st, Hs) { // set default options setOption("name", "unnamed_dple_to_dle"); // name of the function addOption("dple_solver", OT_STRING, GenericType(), "User-defined DPLE solver class."); addOption("dple", OT_DICT, GenericType(), "Options to be passed to the DPLE solver."); }
SimpleIndefDpleInternal::SimpleIndefDpleInternal( const DpleStructure& st, const std::vector< std::vector<int> > &Hs) : DpleInternal(st, Hs) { // set default options setOption("name", "unnamed_simple_indef_dple_solver"); // name of the function addOption("linear_solver", OT_STRING, GenericType(), "User-defined linear solver class. Needed for sensitivities."); addOption("linear_solver_options", OT_DICTIONARY, GenericType(), "Options to be passed to the linear solver."); }
DirectMultipleShootingInternal::DirectMultipleShootingInternal(const Function& ffcn, const Function& mfcn, const Function& cfcn, const Function& rfcn) : OCPSolverInternal(ffcn, mfcn, cfcn, rfcn) { addOption("parallelization", OT_STRING, GenericType(), "Passed on to casadi::Parallelizer"); addOption("nlp_solver", OT_STRING, GenericType(), "An NlpSolver creator function"); addOption("nlp_solver_options", OT_DICTIONARY, GenericType(), "Options to be passed to the NLP Solver"); addOption("integrator", OT_STRING, GenericType(), "An integrator creator function"); addOption("integrator_options", OT_DICTIONARY, GenericType(), "Options to be passed to the integrator"); }
ImplicitFunctionInternal::ImplicitFunctionInternal(const Function& f, const Function& jac, const LinearSolver& linsol) : f_(f), jac_(jac), linsol_(linsol) { addOption("linear_solver", OT_STRING, GenericType(), "User-defined linear solver class. Needed for sensitivities."); addOption("linear_solver_options", OT_DICTIONARY, GenericType(), "Options to be passed to the linear solver."); addOption("constraints", OT_INTEGERVECTOR, GenericType(), "Constrain the unknowns. 0 (default): no constraint on ui, " "1: ui >= 0.0, -1: ui <= 0.0, 2: ui > 0.0, -2: ui < 0.0."); addOption("implicit_input", OT_INTEGER, 0, "Index of the input that corresponds to the actual root-finding"); addOption("implicit_output", OT_INTEGER, 0, "Index of the output that corresponds to the actual root-finding"); }
SimpleIndefDleInternal::SimpleIndefDleInternal( const DleStructure& st, const std::vector<int> &Hs) : DleInternal(st,Hs) { // set default options setOption("name", "unnamed_simple_indef_dle_solver"); // name of the function addOption("compressed_solve", OT_BOOLEAN, true, "When a system with sparse rhs arises, compress to" "a smaller system with dense rhs."); addOption("linear_solver", OT_STRING, GenericType(), "User-defined linear solver class. Needed for sensitivities."); addOption("linear_solver_options", OT_DICT, GenericType(), "Options to be passed to the linear solver."); }
ShellCompiler::ShellCompiler(const std::string& name) : CompilerInternal(name) { addOption("compiler", OT_STRING, "gcc", "Compiler command"); addOption("compiler_setup", OT_STRING, "-fPIC -shared", "Compiler setup command"); addOption("flags", OT_STRINGVECTOR, GenericType(), "Compile flags for the JIT compiler. Default: None"); }
GenericType OptionsFunctionalityNode::getOption(const string &name) const{ // Locate the option Dictionary::const_iterator it = dictionary_.find(name); // Check if found if(it == dictionary_.end()){ stringstream ss; if (allowed_options.find(name)!=allowed_options.end()) { ss << "Option: '" << name << "' has not been set." << endl; printOption(name,ss); } else { ss << "Option: '" << name << "' does not exist." << endl << endl; std::vector<std::string> suggestions; getBestMatches(name,suggestions,5); ss << "Did you mean one of the following?" << endl; for (int i=0;i<suggestions.size();++i) printOption(suggestions[i],ss); ss << "Use printOptions() to get a full list of options." << endl; } casadi_error(ss.str()); } // Return the option return GenericType(it->second); }
// Constructor SocpSolverInternal::SocpSolverInternal(const std::vector<Sparsity> &st) : st_(st) { addOption("ni", OT_INTEGERVECTOR, GenericType(), "Provide the size of each SOC constraint. Must sum up to N."); addOption("print_problem", OT_BOOLEAN, false, "Print out problem statement for debugging."); input_.scheme = SCHEME_SOCPInput; output_.scheme = SCHEME_SOCPOutput; }
SimulatorInternal::SimulatorInternal(const Integrator& integrator, const Function& output_fcn, const vector<double>& grid) : integrator_(integrator), output_fcn_(output_fcn), grid_(grid) { setOption("name", "unnamed simulator"); addOption("monitor", OT_STRINGVECTOR, GenericType(), "", "initial|step", true); input_.scheme = SCHEME_IntegratorInput; }
void ConversionDiagnoseInfTgt( // DIAGNOSE TARGET CONVERSION void ) { if( cnv_type_tgt != NULL ) { if( NULL == GenericType( cnv_type_tgt ) ) { infMsgType( INF_TGT_CNV_TYPE, cnv_type_tgt ); } } ConversionInfDisable(); }
SQPInternal::SQPInternal(const FX& F, const FX& G, const FX& H, const FX& J) : NLPSolverInternal(F,G,H,J){ casadi_warning("The SQP method is under development"); addOption("qp_solver", OT_QPSOLVER, GenericType(), "The QP solver to be used by the SQP method"); addOption("qp_solver_options", OT_DICTIONARY, GenericType(), "Options to be passed to the QP solver"); addOption("hessian_approximation", OT_STRING, "limited-memory", "limited-memory|exact"); addOption("maxiter", OT_INTEGER, 50, "Maximum number of SQP iterations"); addOption("maxiter_ls", OT_INTEGER, 3, "Maximum number of linesearch iterations"); addOption("tol_pr", OT_REAL, 1e-6, "Stopping criterion for primal infeasibility"); addOption("tol_du", OT_REAL, 1e-6, "Stopping criterion for dual infeasability"); addOption("c1", OT_REAL, 1E-4, "Armijo condition, coefficient of decrease in merit"); addOption("beta", OT_REAL, 0.8, "Line-search parameter, restoration factor of stepsize"); addOption("merit_memory", OT_INTEGER, 4, "Size of memory to store history of merit function values"); addOption("lbfgs_memory", OT_INTEGER, 10, "Size of L-BFGS memory."); addOption("regularize", OT_BOOLEAN, false, "Automatic regularization of Lagrange Hessian."); addOption("print_header", OT_BOOLEAN, true, "Print the header with problem statistics"); // Monitors addOption("monitor", OT_STRINGVECTOR, GenericType(), "", "eval_f|eval_g|eval_jac_g|eval_grad_f|eval_h|qp|dx", true); }
Newton::Newton(const Function& f) : ImplicitFunctionInternal(f) { addOption("abstol", OT_REAL, 1e-12, "Stopping criterion tolerance on max(|F|)"); addOption("abstolStep", OT_REAL, 1e-12, "Stopping criterion tolerance on step size"); addOption("max_iter", OT_INTEGER, 1000, "Maximum number of Newton iterations to perform before returning."); addOption("monitor", OT_STRINGVECTOR, GenericType(), "", "step|stepsize|J|F|normF", true); addOption("print_iteration", OT_BOOLEAN, false, "Print information about each iteration"); }
LiftedSQPInternal::LiftedSQPInternal(const Function& F, const Function& G) : NlpSolverInternal(Function(),F,G){ casadi_warning("casadi::LiftedSQP has been replaced by casadi::SCPgen. This class will be deleted."); addOption("qp_solver", OT_QPSOLVER, GenericType(), "The QP solver to be used by the SQP method"); addOption("qp_solver_options", OT_DICTIONARY, GenericType(), "Options to be passed to the QP solver"); addOption("max_iter", OT_INTEGER, 100, "Maximum number of SQP iterations"); addOption("max_iter_ls", OT_INTEGER, 100, "Maximum number of linesearch iterations"); addOption("toldx", OT_REAL , 1e-12, "Stopping criterion for the stepsize"); addOption("tolgl", OT_REAL , 1e-12, "Stopping criterion for the Lagrangian gradient"); addOption("sigma", OT_REAL , 1.0, "Linesearch parameter"); addOption("rho", OT_REAL , 0.5, "Linesearch parameter"); addOption("mu_safety", OT_REAL , 1.1, "Safety factor for linesearch mu"); addOption("eta", OT_REAL , 0.0001, "Linesearch parameter: See Nocedal 3.4"); addOption("tau", OT_REAL , 0.2, "Linesearch parameter"); addOption("hessian_approximation", OT_STRING, "BFGS", "BFGS|exact"); addOption("num_lifted", OT_INTEGER, 0, "Number of variables to lift"); // Monitors addOption("monitor", OT_STRINGVECTOR, GenericType(), "", "eval_f|eval_g|eval_jac_g|eval_grad_f|eval_h|qp", true); // Set default options setOption("generate_jacobian", false); }
Sqpmethod::Sqpmethod(const Function& nlp) : NlpSolverInternal(nlp) { casadi_warning("The SQP method is under development"); addOption("qp_solver", OT_STRING, GenericType(), "The QP solver to be used by the SQP method"); addOption("qp_solver_options", OT_DICT, GenericType(), "Options to be passed to the QP solver"); addOption("hessian_approximation", OT_STRING, "exact", "limited-memory|exact"); addOption("max_iter", OT_INTEGER, 50, "Maximum number of SQP iterations"); addOption("max_iter_ls", OT_INTEGER, 3, "Maximum number of linesearch iterations"); addOption("tol_pr", OT_REAL, 1e-6, "Stopping criterion for primal infeasibility"); addOption("tol_du", OT_REAL, 1e-6, "Stopping criterion for dual infeasability"); addOption("c1", OT_REAL, 1E-4, "Armijo condition, coefficient of decrease in merit"); addOption("beta", OT_REAL, 0.8, "Line-search parameter, restoration factor of stepsize"); addOption("merit_memory", OT_INTEGER, 4, "Size of memory to store history of merit function values"); addOption("lbfgs_memory", OT_INTEGER, 10, "Size of L-BFGS memory."); addOption("regularize", OT_BOOLEAN, false, "Automatic regularization of Lagrange Hessian."); addOption("print_header", OT_BOOLEAN, true, "Print the header with problem statistics"); addOption("min_step_size", OT_REAL, 1e-10, "The size (inf-norm) of the step size should not become smaller than this."); // Monitors addOption("monitor", OT_STRINGVECTOR, GenericType(), "", "eval_f|eval_g|eval_jac_g|eval_grad_f|eval_h|qp|dx|bfgs", true); addOption("print_time", OT_BOOLEAN, true, "Print information about execution time"); }
CollocationIntegratorInternal::CollocationIntegratorInternal(const FX& f, const FX& g) : IntegratorInternal(f,g){ addOption("number_of_finite_elements", OT_INTEGER, 20, "Number of finite elements"); addOption("interpolation_order", OT_INTEGER, 3, "Order of the interpolating polynomials"); addOption("collocation_scheme", OT_STRING, "radau", "Collocation scheme","radau|legendre"); addOption("implicit_solver", OT_IMPLICITFUNCTION, GenericType(), "An implicit function solver"); addOption("implicit_solver_options", OT_DICTIONARY, GenericType(), "Options to be passed to the NLP Solver"); addOption("expand_f", OT_BOOLEAN, false, "Expand the ODE/DAE residual function in an SX graph"); addOption("expand_q", OT_BOOLEAN, false, "Expand the quadrature function in an SX graph"); addOption("hotstart", OT_BOOLEAN, true, "Initialize the trajectory at the previous solution"); addOption("quadrature_solver", OT_LINEARSOLVER, GenericType(), "An linear solver to solver the quadrature equations"); addOption("quadrature_solver_options", OT_DICTIONARY, GenericType(), "Options to be passed to the quadrature solver"); addOption("startup_integrator", OT_INTEGRATOR, GenericType(), "An ODE/DAE integrator that can be used to generate a startup trajectory"); addOption("startup_integrator_options", OT_DICTIONARY, GenericType(), "Options to be passed to the startup integrator"); setOption("name","unnamed_collocation_integrator"); }
const std::vector<std::string> &dictionary, std::vector<std::string> &suggestions, int amount = 5); /** \brief Get th ebest suggestions of option names */ double getBestMatches(const std::string & name, std::vector<std::string> &suggestions, int amount = 5) const; /** \brief A distance metric between two words */ static double wordDistance(const std::string &a, const std::string &b); void addOption( const std::string &str, const opt_type& type, const GenericType &def_val=GenericType(), const std::string& desc="n/a", const std::vector<GenericType> &allowed_vals = std::vector<GenericType>(), bool inherit = false, std::vector<int> enum_values= std::vector<int>(), std::vector<std::string> enum_descr= std::vector<std::string>()); /** \brief Add an option * * allowed_vals can take multiple forms: * "foo|bar" -> specifies that the values "foo" and "bar" are allowed * "foo:5|bar:6" -> specifies that the values "foo" and "bar" are allowed and map * to 5 and 6 respectively * "foo:5:description_foo|bar:6:description_bar|" -> same as above, but specifies documentation * **/ void addOption(const std::string &str, const opt_type& type, const GenericType &def_val, const std::string& desc, const std::string &allowed_vals, bool inherit = false);
SDPSDQPInternal::SDPSDQPInternal(const std::vector<Sparsity> &st) : SdqpSolverInternal(st) { addOption("sdp_solver", OT_STRING, GenericType(), "The SdpSolver used to solve the SDQPs."); addOption("sdp_solver_options", OT_DICTIONARY, GenericType(), "Options to be passed to the SDPSOlver"); }
GenericType OptionsFunctionalityNode::getOptionDefault(const std::string &name) const { assert_exists(name); Dictionary::const_iterator it = defaults_.find(name); if (it!=defaults_.end()) return it->second; return GenericType(); }
ImplicitFunctionInternal::ImplicitFunctionInternal(const FX& f, int nrhs) : f_(f), nrhs_(nrhs){ addOption("linear_solver", OT_LINEARSOLVER, GenericType(), "User-defined linear solver class. Needed for sensitivities."); addOption("linear_solver_options", OT_DICTIONARY, GenericType(), "Options to be passed to the linear solver."); }
// Constructor StabilizedQpSolverInternal:: StabilizedQpSolverInternal(const std::map<std::string, Sparsity> &st) { st_.resize(QP_STRUCT_NUM); for (std::map<std::string, Sparsity>::const_iterator i=st.begin(); i!=st.end(); ++i) { if (i->first=="a") { st_[QP_STRUCT_A]=i->second; } else if (i->first=="h") { st_[QP_STRUCT_H]=i->second; } else { casadi_error("Unrecognized field in QP structure: " << i->first); } } // Get structure const Sparsity& A = st_[QP_STRUCT_A]; const Sparsity& H = st_[QP_STRUCT_H]; // Dimensions n_ = H.size2(); nc_ = A.isNull() ? 0 : A.size1(); addOption("defaults_recipes", OT_STRINGVECTOR, GenericType(), "", "qp", true); // Check consistency casadi_assert_message(A.isNull() || A.size2()==n_, "Got incompatible dimensions. min x'Hx + G'x s.t. LBA <= Ax <= UBA :" << std::endl << "H: " << H.dimString() << " - A: " << A.dimString() << std::endl << "We need: H.size2()==A.size2()" << std::endl); casadi_assert_message(H.issymmetric(), "Got incompatible dimensions. min x'Hx + G'x" << std::endl << "H: " << H.dimString() << "We need H square & symmetric" << std::endl); // IO sparsities Sparsity x_sparsity = Sparsity::dense(n_, 1); Sparsity a_sparsity = Sparsity::dense(nc_, 1); // Input arguments ibuf_.resize(STABILIZED_QP_SOLVER_NUM_IN); input(STABILIZED_QP_SOLVER_X0) = DMatrix::zeros(x_sparsity); input(STABILIZED_QP_SOLVER_H) = DMatrix::zeros(H); input(STABILIZED_QP_SOLVER_G) = DMatrix::zeros(x_sparsity); input(STABILIZED_QP_SOLVER_A) = DMatrix::zeros(A); input(STABILIZED_QP_SOLVER_LBA) = -DMatrix::inf(a_sparsity); input(STABILIZED_QP_SOLVER_UBA) = DMatrix::inf(a_sparsity); input(STABILIZED_QP_SOLVER_LBX) = -DMatrix::inf(x_sparsity); input(STABILIZED_QP_SOLVER_UBX) = DMatrix::inf(x_sparsity); input(STABILIZED_QP_SOLVER_MUR) = 0.0; input(STABILIZED_QP_SOLVER_MUE) = DMatrix::zeros(a_sparsity); input(STABILIZED_QP_SOLVER_MU) = DMatrix::zeros(a_sparsity); // Output arguments obuf_.resize(QP_SOLVER_NUM_OUT); output(QP_SOLVER_X) = DMatrix::zeros(x_sparsity); output(QP_SOLVER_COST) = 0.0; output(QP_SOLVER_LAM_X) = DMatrix::zeros(x_sparsity); output(QP_SOLVER_LAM_A) = DMatrix::zeros(a_sparsity); // IO scheme ischeme_ = IOScheme(SCHEME_StabilizedQpSolverInput); oscheme_ = IOScheme(SCHEME_QpSolverOutput); }
WorhpInternal::WorhpInternal(const Function& nlp) : NLPSolverInternal(nlp){ // Monitors addOption("monitor", OT_STRINGVECTOR, GenericType(), "Monitor functions", "eval_f|eval_g|eval_jac_g|eval_grad_f|eval_h", true); addOption("print_time", OT_BOOLEAN, true, "Print information about execution time"); int status; InitParams(&status, &worhp_p_); std::stringstream ss; ss << "Armijo recovery strategies. Vector of size " << NAres; std::vector<int> ares(NAres); std::copy(worhp_p_.Ares,worhp_p_.Ares+NAres,ares.begin()); addOption("Ares",OT_INTEGERVECTOR,ares,ss.str()); for (int i=0;i<WorhpGetParamCount();++i) { WorhpType type = WorhpGetParamType(i+1); const char* name = WorhpGetParamName(i+1); if (strcmp(name,"Ares")==0) continue; switch(type) { case WORHP_BOOL_T: bool default_bool; WorhpGetBoolParam(&worhp_p_, name, &default_bool); addOption(WorhpGetParamName(i+1),OT_BOOLEAN,default_bool,WorhpGetParamDescription(i+1)); break; case WORHP_DOUBLE_T: double default_double; WorhpGetDoubleParam(&worhp_p_, name, &default_double); addOption(WorhpGetParamName(i+1),OT_REAL,default_double,WorhpGetParamDescription(i+1)); break; case WORHP_INT_T: int default_int; WorhpGetIntParam(&worhp_p_, name, &default_int); addOption(WorhpGetParamName(i+1),OT_INTEGER,default_int,WorhpGetParamDescription(i+1)); break; default: break;// do nothing } } addOption("qp_ipBarrier",OT_REAL,worhp_p_.qp.ipBarrier,"IP barrier parameter."); addOption("qp_ipComTol",OT_REAL,worhp_p_.qp.ipComTol,"IP complementarity tolerance."); addOption("qp_ipFracBound",OT_REAL,worhp_p_.qp.ipFracBound,"IP fraction-to-the-boundary parameter."); addOption("qp_ipLsMethod",OT_STRING,GenericType(),"Select the direct linear solver used by the IP method.","LAPACK::0|MA57: only available if provided by the user:1|SuperLU::2|PARDISO: only available if provided by the user, subject to license availability:3|MUMPS: currently Linux platforms only:5|WSMP: subject to license availability:6|MA86: experimental, only available if provided by the user:7|MA97:experimental, only available if provided by the user:8"); setOptionByEnumValue("qp_ipLsMethod",worhp_p_.qp.ipLsMethod); addOption("qp_ipMinAlpha",OT_REAL,worhp_p_.qp.ipMinAlpha,"IP line search minimum step size."); addOption("qp_ipTryRelax",OT_BOOLEAN,worhp_p_.qp.ipTryRelax,"Enable relaxation strategy when encountering an error."); addOption("qp_ipRelaxDiv",OT_REAL,worhp_p_.qp.ipRelaxDiv,"The relaxation term is divided by this value if successful."); addOption("qp_ipRelaxMult",OT_REAL,worhp_p_.qp.ipRelaxMult,"The relaxation term is multiplied by this value if unsuccessful."); addOption("qp_ipRelaxMax",OT_REAL,worhp_p_.qp.ipRelaxMax,"Maximum relaxation value."); addOption("qp_ipRelaxMin",OT_REAL,worhp_p_.qp.ipRelaxMin,"Mimimum relaxation value."); addOption("qp_ipResTol",OT_REAL,worhp_p_.qp.ipResTol,"IP residuals tolerance."); addOption("qp_lsItMaxIter",OT_INTEGER,worhp_p_.qp.lsItMaxIter,"Maximum number of iterations of the iterative linear solvers."); addOption("qp_lsItMethod",OT_STRING,GenericType(),"Select the iterative linear solver.","none:Deactivate; use a direct linear solver.:0|CGNR::1|CGNE::2|CGS::3|BiCGSTAB::4"); setOptionByEnumValue("qp_lsItMethod",worhp_p_.qp.lsItMethod); addOption("qp_lsItPrecondMethod",OT_STRING,GenericType(),"Select preconditioner for the iterative linear solver.","none:No preconditioner.:0|static:Static preconditioner (KKT-matrix with constant lower-right block).:1|full:Full KKT-matrix.:2"); setOptionByEnumValue("qp_lsItPrecondMethod",worhp_p_.qp.lsItPrecondMethod); addOption("qp_lsRefineMaxIter",OT_INTEGER,worhp_p_.qp.lsRefineMaxIter,"Maximum number of iterative refinement steps of the direct linear solvers."); addOption("qp_lsScale",OT_BOOLEAN,worhp_p_.qp.lsScale,"Enables scaling on linear solver level."); addOption("qp_lsTrySimple",OT_BOOLEAN,worhp_p_.qp.lsTrySimple,"Some matrices can be solved without calling a linear equation solver.Currently only diagonal matrices are supported. Non-diagonal matrices will besolved with the chosen linear equation solver."); addOption("qp_lsTol",OT_REAL,worhp_p_.qp.lsTol,"Tolerance for the linear solver."); addOption("qp_maxIter",OT_INTEGER,worhp_p_.qp.maxIter,"Imposes an upper limit on the number of minor solver iterations, i.e. for thequadratic subproblem solver. If the limit is reached before convergence,WORHP will activate QP recovery strategies to prevent a solver breakdown."); addOption("qp_method",OT_STRING,GenericType(),"Select the solution method used by the QP solver.","ip:Interior-Point method.:1|nsn:Nonsmooth-Newton method.:2|automatic: Prefer IP and fall back to NSN on error.:12"); setOptionByEnumValue("qp_method",worhp_p_.qp.method); addOption("qp_nsnBeta",OT_REAL,worhp_p_.qp.nsnBeta,"NSN stepsize decrease factor."); addOption("qp_nsnGradStep",OT_BOOLEAN,worhp_p_.qp.nsnGradStep,"Enable gradient steps in the NSN method."); addOption("qp_nsnKKT",OT_REAL,worhp_p_.qp.nsnKKT,"NSN KKT tolerance."); addOption("qp_nsnLsMethod",OT_STRING,GenericType(),"Select the direct linear solver used by the NSN method.","SuperLU::2|MA48: only available if provided by the user:4"); setOptionByEnumValue("qp_nsnLsMethod",worhp_p_.qp.nsnLsMethod); addOption("qp_nsnMinAlpha",OT_REAL,worhp_p_.qp.nsnMinAlpha,"NSN line search minimum step size."); addOption("qp_nsnSigma",OT_REAL,worhp_p_.qp.nsnSigma,"NSN line search slope parameter."); addOption("qp_printLevel",OT_STRING,GenericType(),"Controls the amount of QP solver output.","none:No output.:0|warn:Print warnings and errors.:1|iterations:Print iterations.:2"); setOptionByEnumValue("qp_printLevel",worhp_p_.qp.printLevel); addOption("qp_scaleIntern",OT_BOOLEAN,worhp_p_.qp.scaleIntern,"Enable scaling on QP level."); addOption("qp_strict",OT_BOOLEAN,worhp_p_.qp.strict,"Use strict termination criteria in IP method."); worhp_o_.initialised = false; worhp_w_.initialised = false; worhp_p_.initialised = false; worhp_c_.initialised = false; // WORKAROUND: Bug in scaling, set to false by default // FIXME setOption("ScaledObj",false); // WORKAROUND: Why is this needed? // FIXME setOption("ScaleConIter",true); }
GslInternal::GslInternal(const Function& f, const Function& q) : IntegratorInternal(f,q){ is_init = false; addOption("monitor", OT_STRINGVECTOR, GenericType(), "", "reset", true); std::cout << "Warning: GslIntegrator is highly experimental" << std::endl; }
QpoasesInterface::QpoasesInterface(const std::vector<Sparsity>& st) : QpSolverInternal(st) { addOption("nWSR", OT_INTEGER, GenericType(), "The maximum number of working set recalculations to be performed during " "the initial homotopy. Default is 5(nx + nc)"); addOption("CPUtime", OT_REAL, GenericType(), "The maximum allowed CPU time in seconds for the whole initialisation" " (and the actually required one on output). Disabled if unset."); // Temporary object qpOASES::Options ops; ops.setToDefault(); addOption("printLevel", OT_STRING, PrintLevel_to_string(ops.printLevel), "Defines the amount of text output during QP solution, " "see Section 5.7", "none|low|medium|high"); addOption("enableRamping", OT_BOOLEAN, BooleanType_to_bool(ops.enableRamping), "Enables ramping."); addOption("enableFarBounds", OT_BOOLEAN, BooleanType_to_bool(ops.enableFarBounds), "Enables the use of far bounds."); addOption("enableFlippingBounds", OT_BOOLEAN, BooleanType_to_bool(ops.enableFlippingBounds), "Enables the use of flipping bounds."); addOption("enableRegularisation", OT_BOOLEAN, BooleanType_to_bool(ops.enableRegularisation), "Enables automatic Hessian regularisation."); addOption("enableFullLITests", OT_BOOLEAN, BooleanType_to_bool(ops.enableFullLITests), "Enables condition-hardened (but more expensive) LI test."); addOption("enableNZCTests", OT_BOOLEAN, BooleanType_to_bool(ops.enableNZCTests), "Enables nonzero curvature tests."); addOption("enableDriftCorrection", OT_INTEGER, static_cast<int>(ops.enableDriftCorrection), "Specifies the frequency of drift corrections: 0: turns them off."); addOption("enableCholeskyRefactorisation", OT_INTEGER, static_cast<int>(ops.enableCholeskyRefactorisation), "Specifies the frequency of a full re-factorisation of projected " "Hessian matrix: 0: turns them off, 1: uses them at each iteration etc."); addOption("enableEqualities", OT_BOOLEAN, BooleanType_to_bool(ops.enableEqualities), "Specifies whether equalities should be treated as always active " "(True) or not (False)"); addOption("terminationTolerance", OT_REAL, static_cast<double>(ops.terminationTolerance), "Relative termination tolerance to stop homotopy."); addOption("boundTolerance", OT_REAL, static_cast<double>(ops.boundTolerance), "If upper and lower bounds differ less than this tolerance, they are regarded " "equal, i.e. as equality constraint."); addOption("boundRelaxation", OT_REAL, static_cast<double>(ops.boundRelaxation), "Initial relaxation of bounds to start homotopy and initial value for far bounds."); addOption("epsNum", OT_REAL, static_cast<double>(ops.epsNum), "Numerator tolerance for ratio tests."); addOption("epsDen", OT_REAL, static_cast<double>(ops.epsDen), "Denominator tolerance for ratio tests."); addOption("maxPrimalJump", OT_REAL, static_cast<double>(ops.maxPrimalJump), "Maximum allowed jump in primal variables in nonzero curvature tests."); addOption("maxDualJump", OT_REAL, static_cast<double>(ops.maxDualJump), "Maximum allowed jump in dual variables in linear independence tests."); addOption("initialRamping", OT_REAL, static_cast<double>(ops.initialRamping), "Start value for ramping strategy."); addOption("finalRamping", OT_REAL, static_cast<double>(ops.finalRamping), "Final value for ramping strategy."); addOption("initialFarBounds", OT_REAL, static_cast<double>(ops.initialFarBounds), "Initial size for far bounds."); addOption("growFarBounds", OT_REAL, static_cast<double>(ops.growFarBounds), "Factor to grow far bounds."); addOption("initialStatusBounds", OT_STRING, SubjectToStatus_to_string(ops.initialStatusBounds), "Initial status of bounds at first iteration.", "inactive::all bounds inactive|lower::all bounds active at their " "lower bound|upper::all bounds active at their upper bound"); addOption("epsFlipping", OT_REAL, static_cast<double>(ops.epsFlipping), "Tolerance of squared Cholesky diagonal factor which triggers flipping bound."); addOption("numRegularisationSteps", OT_INTEGER, static_cast<int>(ops.numRegularisationSteps), "Maximum number of successive regularisation steps."); addOption("epsRegularisation", OT_REAL, static_cast<double>(ops.epsRegularisation), "Scaling factor of identity matrix used for Hessian regularisation."); addOption("numRefinementSteps", OT_INTEGER, static_cast<int>(ops.numRefinementSteps), "Maximum number of iterative refinement steps."); addOption("epsIterRef", OT_REAL, static_cast<double>(ops.epsIterRef), "Early termination tolerance for iterative refinement."); addOption("epsLITests", OT_REAL, static_cast<double>(ops.epsLITests), "Tolerance for linear independence tests."); addOption("epsNZCTests", OT_REAL, static_cast<double>(ops.epsNZCTests), "Tolerance for nonzero curvature tests."); called_once_ = false; qp_ = 0; }
IpoptInternal::IpoptInternal(const Function& nlp) : NLPSolverInternal(nlp){ addOption("pass_nonlinear_variables", OT_BOOLEAN, false); addOption("print_time", OT_BOOLEAN, true, "print information about execution time"); // Monitors addOption("monitor", OT_STRINGVECTOR, GenericType(), "", "eval_f|eval_g|eval_jac_g|eval_grad_f|eval_h", true); // For passing metadata to IPOPT addOption("var_string_md", OT_DICTIONARY, GenericType(), "String metadata (a dictionary with lists of strings) about variables to be passed to IPOPT"); addOption("var_integer_md", OT_DICTIONARY, GenericType(), "Integer metadata (a dictionary with lists of integers) about variables to be passed to IPOPT"); addOption("var_numeric_md", OT_DICTIONARY, GenericType(), "Numeric metadata (a dictionary with lists of reals) about variables to be passed to IPOPT"); addOption("con_string_md", OT_DICTIONARY, GenericType(), "String metadata (a dictionary with lists of strings) about constraints to be passed to IPOPT"); addOption("con_integer_md", OT_DICTIONARY, GenericType(), "Integer metadata (a dictionary with lists of integers) about constraints to be passed to IPOPT"); addOption("con_numeric_md", OT_DICTIONARY, GenericType(), "Numeric metadata (a dictionary with lists of reals) about constraints to be passed to IPOPT"); // Set pointers to zero app_ = 0; userclass_ = 0; #ifdef WITH_SIPOPT app_sens_ = 0; #endif // WITH_SIPOPT // Start an application (temporarily) Ipopt::IpoptApplication temp_app; // Start a sensitivity application (temporarily) #ifdef WITH_SIPOPT Ipopt::SensApplication temp_sens_app(temp_app.Jnlst(),temp_app.Options(),temp_app.RegOptions()); // Register sIPOPT options Ipopt::RegisterOptions_sIPOPT(temp_app.RegOptions()); temp_app.Options()->SetRegisteredOptions(temp_app.RegOptions()); #endif // WITH_SIPOPT // Get all options available in (s)IPOPT map<string, Ipopt::SmartPtr<Ipopt::RegisteredOption> > regops = temp_app.RegOptions()->RegisteredOptionsList(); for(map<string, Ipopt::SmartPtr<Ipopt::RegisteredOption> >::const_iterator it=regops.begin(); it!=regops.end(); ++it){ // Option identifier string opt_name = it->first; // Short description goes here, even though we do have a longer description string opt_desc = it->second->ShortDescription() + " (see IPOPT documentation)"; // Get the type Ipopt::RegisteredOptionType ipopt_type = it->second->Type(); opt_type casadi_type; // Map Ipopt option category to a CasADi options type switch(ipopt_type){ case Ipopt::OT_Number: casadi_type = OT_REAL; break; case Ipopt::OT_Integer: casadi_type = OT_INTEGER; break; case Ipopt::OT_String: casadi_type = OT_STRING; break; case Ipopt::OT_Unknown: continue; // NOTE: No mechanism to handle OT_Unknown options default: continue; // NOTE: Unknown Ipopt options category } addOption(opt_name, casadi_type, GenericType(), opt_desc); // Set default values of IPOPT options if (casadi_type == OT_REAL) { setDefault(opt_name,it->second->DefaultNumber()); } else if (casadi_type == OT_INTEGER) { setDefault(opt_name,it->second->DefaultInteger()); } else if (casadi_type == OT_STRING) { setDefault(opt_name,it->second->DefaultString()); }; // Save to map containing IPOPT specific options ops_[opt_name] = casadi_type; } }