Class SolverAbstract
Defined in File solver-base.hpp
Inheritance Relationships
Derived Types
public crocoddyl::SolverIpopt(Class SolverIpopt)public crocoddyl::SolverKKT(Class SolverKKT)
Class Documentation
-
class SolverAbstract
Abstract class for optimal control solvers.
A solver resolves an optimal control solver of the form
\[\begin{split}\begin{eqnarray*} \begin{Bmatrix} \mathbf{x}^*_0,\cdots,\mathbf{x}^*_{T} \\ \mathbf{u}^*_0,\cdots,\mathbf{u}^*_{T-1} \end{Bmatrix} = \arg\min_{\mathbf{x}_s,\mathbf{u}_s} && l_T (\mathbf{x}_T) + \sum_{k=0}^{T-1} l_k(\mathbf{x}_t,\mathbf{u}_t) \\ \operatorname{subject}\,\operatorname{to} && \mathbf{x}_0 = \mathbf{\tilde{x}}_0\\ && \mathbf{x}_{k+1} = \mathbf{f}_k(\mathbf{x}_k,\mathbf{u}_k)\\ && \mathbf{x}_k\in\mathcal{X}, \mathbf{u}_k\in\mathcal{U} \end{eqnarray*}\end{split}\]where \(l_T(\mathbf{x}_T)\), \(l_k(\mathbf{x}_t,\mathbf{u}_t)\) are the terminal and running cost functions, respectively, \(\mathbf{f}_k(\mathbf{x}_k,\mathbf{u}_k)\) describes evolution of the system, and state and control admissible sets are defined by \(\mathbf{x}_k\in\mathcal{X}\), \(\mathbf{u}_k\in\mathcal{U}\). An action model, defined in the shooting problem, describes each node \(k\). Inside the action model, we specialize the cost functions, the system evolution and the admissible sets.The main routines are
computeDirection()andtryStep(). The former finds a search direction and typically computes the derivatives of each action model. The latter rollout the dynamics and cost (i.e., the action) to try the search direction found bycomputeDirection. Both functions used the current guess defined bysetCandidate(). Finally,solve()function is used to define when the search direction and length are computed in each iterate. It also describes the globalization strategy (i.e., regularization) of the numerical optimization.See also
Subclassed by crocoddyl::SolverIpopt, crocoddyl::SolverKKT
Public Functions
Initialize the solver.
- Parameters:
problem – [in] shooting problem
-
virtual ~SolverAbstract()
-
virtual bool solve(const std::vector<Eigen::VectorXd> &init_xs = DEFAULT_VECTOR, const std::vector<Eigen::VectorXd> &init_us = DEFAULT_VECTOR, const std::size_t maxiter = 100, const bool is_feasible = false, const double reg_init = NAN) = 0
Compute the optimal trajectory \(\mathbf{x}^*_s,\mathbf{u}^*_s\) as lists of \(T+1\) and \(T\) terms.
From an initial guess
init_xs,init_us(feasible or not), iterate overcomputeDirection()andtryStep()untilstoppingCriteria()is below threshold. It also describes the globalization strategy used during the numerical optimization.- Parameters:
init_xs – [in] initial guess for state trajectory with \(T+1\) elements (default [])
init_us – [in] initial guess for control trajectory with \(T\) elements (default [])
maxiter – [in] maximum allowed number of iterations (default 100)
is_feasible – [in] true if the
init_xsare obtained from integrating theinit_us(rollout) (default false)init_reg – [in] initial guess for the regularization value. Very low values are typical used with very good guess points (default 1e-9).
- Returns:
A boolean that describes if convergence was reached.
-
virtual void computeDirection(const bool recalc) = 0
Compute the search direction \((\delta\mathbf{x}^k,\delta\mathbf{u}^k)\) for the current guess \((\mathbf{x}^k_s,\mathbf{u}^k_s)\).
You must call
setCandidate()first in order to define the current guess. A current guess defines a state and control trajectory \((\mathbf{x}^k_s,\mathbf{u}^k_s)\) of \(T+1\) and \(T\) elements, respectively.- Parameters:
recalc – [in] true for recalculating the derivatives at current state and control
- Returns:
The search direction \((\delta\mathbf{x},\delta\mathbf{u})\) and the dual lambdas as lists of \(T+1\), \(T\) and \(T+1\) lengths, respectively
-
virtual double tryStep(const double steplength = 1) = 0
Try a predefined step length \(\alpha\) and compute its cost improvement \(dV\).
It uses the search direction found by
computeDirection()to try a determined step length \(\alpha\). Therefore, it assumes that we have runcomputeDirection()first. Additionally, it returns the cost improvement \(dV\) along the predefined step length \(\alpha\).- Parameters:
steplength – [in] applied step length ( \(0\leq\alpha\leq1\))
- Returns:
the cost improvement
-
virtual double stoppingCriteria() = 0
Return a positive value that quantifies the algorithm termination.
These values typically represents the gradient norm which tell us that it’s been reached the local minima. The stopping criteria strictly speaking depends on the search direction (calculated by
computeDirection()) but it could also depend on the chosen step length, tested bytryStep().
-
virtual const Eigen::Vector2d &expectedImprovement() = 0
Return the expected improvement \(dV_{exp}\) from a given current search direction \((\delta\mathbf{x}^k,\delta\mathbf{u}^k)\).
For computing the expected improvement, you need to compute the search direction first via
computeDirection().
-
virtual void resizeData()
Resizing the solver data.
If the shooting problem has changed after construction, then this function resizes all the data before starting resolve the problem.
-
double computeDynamicFeasibility()
Compute the dynamic feasibility \(\|\mathbf{f}_{\mathbf{s}}\|_{\infty,1}\) for the current guess \((\mathbf{x}^k,\mathbf{u}^k)\).
The feasibility can be computed using different norms (e.g, \(\ell_\infty\) or \(\ell_1\) norms). By default we use the \(\ell_\infty\) norm, however, we can change the type of norm using
set_feasnorm. Note that \(\mathbf{f}_{\mathbf{s}}\) are the gaps on the dynamics, which are computed at each node as \(\mathbf{x}^{'}-\mathbf{f}(\mathbf{x},\mathbf{u})\).
-
double computeInequalityFeasibility()
Compute the feasibility of the inequality constraints for the current guess.
The feasibility can be computed using different norms (e.g, \(\ell_\infty\) or \(\ell_1\) norms). By default we use the \(\ell_\infty\) norm, however, we can change the type of norm using
set_feasnorm.
-
double computeEqualityFeasibility()
Compute the feasibility of the equality constraints for the current guess.
The feasibility can be computed using different norms (e.g, \(\ell_\infty\) or \(\ell_1\) norms). By default we use the \(\ell_\infty\) norm, however, we can change the type of norm using
set_feasnorm.
-
void setCandidate(const std::vector<Eigen::VectorXd> &xs_warm = DEFAULT_VECTOR, const std::vector<Eigen::VectorXd> &us_warm = DEFAULT_VECTOR, const bool is_feasible = false)
Set the solver candidate trajectories \((\mathbf{x}_s,\mathbf{u}_s)\).
The solver candidates are defined as a state and control trajectories \((\mathbf{x}_s,\mathbf{u}_s)\) of \(T+1\) and \(T\) elements, respectively. Additionally, we need to define the dynamic feasibility of the \((\mathbf{x}_s,\mathbf{u}_s)\) pair. Note that the trajectories are feasible if \(\mathbf{x}_s\) is the resulting trajectory from the system rollout with \(\mathbf{u}_s\) inputs.
- Parameters:
xs – [in] state trajectory of \(T+1\) elements (default [])
us – [in] control trajectory of \(T\) elements (default [])
isFeasible – [in] true if the
xsare obtained from integrating theus(rollout)
Set a list of callback functions using for the solver diagnostic.
Each iteration, the solver calls these set of functions in order to allowed user the diagnostic of its performance.
- Parameters:
callbacks – set of callback functions
-
const std::vector<std::shared_ptr<CallbackAbstract>> &getCallbacks() const
Return the list of callback functions using for diagnostic.
-
const std::shared_ptr<ShootingProblem> &get_problem() const
Return the shooting problem.
-
const std::vector<Eigen::VectorXd> &get_xs() const
Return the state trajectory \(\mathbf{x}_s\).
-
const std::vector<Eigen::VectorXd> &get_us() const
Return the control trajectory \(\mathbf{u}_s\).
-
const std::vector<Eigen::VectorXd> &get_fs() const
Return the dynamic infeasibility \(\mathbf{f}_{s}\).
-
bool get_is_feasible() const
Return the feasibility status of the \((\mathbf{x}_s,\mathbf{u}_s)\) trajectory.
-
double get_cost() const
Return the cost for the current guess.
-
double get_merit() const
Return the merit for the current guess.
-
double get_stop() const
Return the stopping-criteria value computed by
stoppingCriteria()
-
const Eigen::Vector2d &get_d() const
Return the linear and quadratic terms of the expected improvement.
-
double get_dV() const
Return the reduction in the cost function \(\Delta V\).
-
double get_dPhi() const
Return the reduction in the merit function \(\Delta\Phi\).
-
double get_dVexp() const
Return the expected reduction in the cost function \(\Delta V_{exp}\).
-
double get_dPhiexp() const
Return the expected reduction in the merit function \(\Delta\Phi_{exp}\).
-
double get_dfeas() const
Return the reduction in the feasibility.
-
double get_feas() const
Return the total feasibility for the current guess.
-
double get_ffeas() const
Return the dynamic feasibility for the current guess.
-
double get_gfeas() const
Return the inequality feasibility for the current guess.
-
double get_hfeas() const
Return the equality feasibility for the current guess.
-
double get_ffeas_try() const
Return the dynamic feasibility for the current step length.
-
double get_gfeas_try() const
Return the inequality feasibility for the current step length.
-
double get_hfeas_try() const
Return the equality feasibility for the current step length.
-
double get_preg() const
Return the primal-variable regularization.
-
double get_dreg() const
Return the dual-variable regularization.
- DEPRECATED ("Use get_preg for primal-variable regularization", double get_xreg() const ;) DEPRECATED("Use get_preg for primal-variable regularization"
-
double get_ureg() const
-
double get_steplength() const
Return the step length \(\alpha\).
-
double get_th_acceptstep() const
Return the threshold used for accepting a step.
-
double get_th_stop() const
Return the tolerance for stopping the algorithm.
-
double get_th_gaptol() const
Return the threshold for accepting a gap as non-zero.
-
FeasibilityNorm get_feasnorm() const
Return the type of norm used to evaluate the dynamic and constraints feasibility.
-
std::size_t get_iter() const
Return the number of iterations performed by the solver.
-
void set_xs(const std::vector<Eigen::VectorXd> &xs)
Modify the state trajectory \(\mathbf{x}_s\).
-
void set_us(const std::vector<Eigen::VectorXd> &us)
Modify the control trajectory \(\mathbf{u}_s\).
-
void set_preg(const double preg)
Modify the primal-variable regularization value.
-
void set_dreg(const double dreg)
Modify the dual-variable regularization value.
- DEPRECATED ("Use set_preg for primal-variable regularization", void set_xreg(const double xreg);) DEPRECATED("Use set_preg for primal-variable regularization"
-
void set_ureg(const double ureg)
-
void set_th_acceptstep(const double th_acceptstep)
Modify the threshold used for accepting step.
-
void set_th_stop(const double th_stop)
Modify the tolerance for stopping the algorithm.
-
void set_th_gaptol(const double th_gaptol)
Modify the threshold for accepting a gap as non-zero.
-
void set_feasnorm(const FeasibilityNorm feas_norm)
Modify the current norm used for computed the dynamic and constraint feasibility.
Protected Functions
- DEPRECATED ("Use preg_ for primal-variable regularization", double xreg_;) DEPRECATED("Use dreg_ for primal-variable regularization"
Protected Attributes
-
std::shared_ptr<ShootingProblem> problem_
optimal control problem
-
std::vector<Eigen::VectorXd> xs_
State trajectory.
-
std::vector<Eigen::VectorXd> us_
Control trajectory.
-
std::vector<Eigen::VectorXd> fs_
Gaps/defects between shooting nodes.
-
std::vector<std::shared_ptr<CallbackAbstract>> callbacks_
Callback functions.
-
bool is_feasible_
Label that indicates is the iteration is feasible.
-
bool was_feasible_
Label that indicates in the previous iterate was feasible
-
double cost_
Cost for the current guess.
-
double merit_
Merit for the current guess.
-
double stop_
Value computed by
stoppingCriteria()
-
Eigen::Vector2d d_
LQ approximation of the expected improvement.
-
double dVexp_
Expected reduction in the cost function.
-
double dPhiexp_
Expected reduction in the merit function.
-
double dfeas_
Reduction in the feasibility.
-
double feas_
Total feasibility for the current guess.
-
double ffeas_
Feasibility of the dynamic constraints for the current guess.
-
double gfeas_
Feasibility of the inequality constraints for the current guess
-
double hfeas_
Feasibility of the equality constraints for the current guess
-
double ffeas_try_
Feasibility of the dynamic constraints evaluated for the current step length
-
double gfeas_try_
Feasibility of the inequality constraints evaluated for the current step length
-
double hfeas_try_
Feasibility of the equality constraints evaluated for the current step length
-
double preg_
Current primal-variable regularization value.
-
double dreg_
Current dual-variable regularization value.
-
double ureg_
-
double steplength_
< Current control regularization values
Current applied step length
-
double th_acceptstep_
Threshold used for accepting step.
-
double th_stop_
Tolerance for stopping the algorithm.
-
double th_gaptol_
Threshold limit to check non-zero gaps.
-
enum FeasibilityNorm feasnorm_
Type of norm used to evaluate the dynamics and constraints feasibility
-
std::size_t iter_
Number of iteration performed by the solver.
-
double tmp_feas_
Temporal variables used for computed the feasibility.
-
std::vector<Eigen::VectorXd> g_adj_
Adjusted inequality bound.