Feasibility-driven Differential Dynamic Programming (FDDP) solver. More...

#include <fddp.hpp>

Inheritance diagram for SolverFDDPTpl< _Scalar >:

Public Types
typedef ShootingProblem::ActionDataAbstract	ActionDataAbstract
typedef ShootingProblem::ActionModelAbstract	ActionModelAbstract
typedef CallbackAbstractTpl< Scalar >	CallbackAbstract
typedef MathBaseTpl< Scalar >	MathBase
typedef MathBase::MatrixXs	MatrixXs
typedef MathBase::MatrixXsRowMajor	MatrixXsRowMajor
typedef ShootingProblemTpl< Scalar >	ShootingProblem
typedef SolverAbstractTpl< Scalar >	SolverAbstract
typedef MathBase::Vector3s	Vector3s
typedef MathBase::VectorXs	VectorXs
Public Types inherited from SolverAbstractTpl< _Scalar >
typedef ShootingProblem::ActionDataAbstract	ActionDataAbstract
typedef ShootingProblem::ActionModelAbstract	ActionModelAbstract
typedef CallbackAbstractTpl< Scalar >	CallbackAbstract
typedef MathBaseTpl< Scalar >	MathBase
typedef ShootingProblemTpl< Scalar >	ShootingProblem
typedef MathBase::Vector3s	Vector3s
typedef MathBase::VectorXs	VectorXs

Public Member Functions
	SolverFDDPTpl (std::shared_ptr< ShootingProblem > problem, const DynamicsSolverType dyn_solver=FeasShoot, const EqualitySolverType term_solver=LuNull)
	Initialize the FDDP solver.
virtual void	backwardPass ()
	Run the backward pass (Riccati sweep).
void	batchPass ()
	Run the batch pass to account for its constraints.
template<typename NewScalar>
SolverFDDPTpl< NewScalar >	cast () const
	Cast the FDDP solver to a different scalar type.
virtual bool	checkAcceptance () override
	Check if we should accept or not the step.
virtual void	computeActionValueFunction (const std::size_t t, const std::shared_ptr< ActionModelAbstract > &model, const std::shared_ptr< ActionDataAbstract > &data)
	Compute the linear-quadratic approximation of the control action-value function.
virtual void	computeBatchActionValueFunction (const std::size_t t, const std::shared_ptr< ActionDataAbstract > &data)
	Compute the linear-quadratic approximation of the control action-value function associated to the batch's constraints.
virtual void	computeBatchPolicy (const std::size_t t)
	Compute the feedforward and feedback terms (control policy) associated to the batch's constraints.
virtual void	computeBatchValueFunction (const std::size_t t)
	Compute the linear-quadratic approximation of the value function associated to the batch's constraints.
virtual void	computeCandidate (const Scalar step_length=Scalar(1.)) override
	Compute new candidate solution using step length.
virtual void	computeDirection (const bool recalc=true) override
	Compute the search direction $(\delta\mathbf{x}^k,\delta\mathbf{u}^k)$ for the current guess $(\mathbf{x}^k_s,\mathbf{u}^k_s)$ .
Scalar	computeDynamicFeasibility ()
	Compute the dynamic feasibility $\\|\mathbf{f}_{\mathbf{s}}\\|_{\infty,1}$ for the current guess $(\mathbf{x}^k,\mathbf{u}^k)$ .
Scalar	computeEqualityFeasibility ()
	Compute the feasibility of the equality constraints for the current guess.
virtual void	computeExpectedMeritFunctionImprovement () override
	Compute the expected merit function improvement for the current step.
Scalar	computeFeasibility (const std::vector< VectorXs > &fs)
	Compute the feasibility from a given residual vector.
Scalar	computeInequalityFeasibility ()
	Compute the feasibility of the inequality constraints for the current guess.
virtual void	computeMeritFunctionImprovement () override
	Compute the merit function improvement for the current step.
virtual void	computePolicy (const std::size_t t)
	Compute the feedforward and feedback terms (control policy) computed via a Cholesky decomposition.
virtual void	computeValueFunction (const std::size_t t, const std::shared_ptr< ActionModelAbstract > &model)
	Compute the linear-quadratic approximation of the value function.
void	decreaseRegularization () override
	Decrease the state and control regularization values by a regfactor_ factor.
bool	decreaseRegularizationCriteria () override
	Criteria used to decrease regularization.
virtual Vector3s	expectedImprovement () override
	Return the expected improvement $dV_{exp}$ from a given current search direction $(\delta\mathbf{x}^k,\delta\mathbf{u}^k)$ .
virtual void	feasShootForwardPass (const Scalar steplength)
	Run the feasibility-driven nonlinear rollout.
void	forwardPass (const Scalar steplength=Scalar(1.))
	Perform a forward pass with a predefined step length.
const VectorXs &	get_beta_plus () const
	Return the next terminal-constraint multiplier $\boldsymbol{\beta}^+$ .
const MatrixXs &	get_dHc () const
	Return the Jacobian of the terminal constraint gains $\delta\mathbf{H}_{c}$ .
const std::vector< MatrixXs > &	get_dUc () const
	Return the linear update in $\delta\mathbf{U}_{c_s}$ .
const std::vector< MatrixXs > &	get_dXc () const
	Return the linear update in $\delta\mathbf{X}_{c_s}$ .
DynamicsSolverType	get_dynamics_solver () const
	Return the type of solver used for handling the dynamics constraints.
const VectorXs &	get_hc () const
	Return the bias term of the terminal constraint gains $\mathbf{h}_{c}$ .
const std::vector< MatrixXsRowMajor > &	get_K () const
	Return the feedback gains $\mathbf{K}_{s}$ .
const std::vector< VectorXs > &	get_k () const
	Return the feedforward gains $\mathbf{k}_{s}$ .
const std::vector< MatrixXs > &	get_Kc () const
	Return the feedforward gains $\mathbf{K}_{c_s}$ .
const std::vector< VectorXs > &	get_Qu () const
	Return the Jacobian of the Hamiltonian function $\mathbf{Q}_{\mathbf{u}_s}$ .
const std::vector< MatrixXs > &	get_Quc () const
	Return the Hessian of the Hamiltonian function $\mathbf{Q}_{\mathbf{uc}_s}$ .
const std::vector< MatrixXs > &	get_Quu () const
	Return the Hessian of the Hamiltonian function $\mathbf{Q}_{\mathbf{uu}_s}$ .
const std::vector< VectorXs > &	get_Qx () const
	Return the Jacobian of the Hamiltonian function $\mathbf{Q}_{\mathbf{x}_s}$ .
const std::vector< MatrixXs > &	get_Qxc () const
	Return the Hessian of the Hamiltonian function $\mathbf{Q}_{\mathbf{xc}_s}$ .
const std::vector< MatrixXs > &	get_Qxu () const
	Return the Hessian of the Hamiltonian function $\mathbf{Q}_{\mathbf{xu}_s}$ .
const std::vector< MatrixXs > &	get_Qxx () const
	Return the Hessian of the Hamiltonian function $\mathbf{Q}_{\mathbf{xx}_s}$ .
Scalar	get_reg_decfactor () const
	Return the regularization factor used to decrease the damping value.
Scalar	get_reg_incfactor () const
	Return the regularization factor used to increase the damping value.
Scalar	get_rho () const
	Return the rho parameter used in the merit function.
EqualitySolverType	get_terminal_solver () const
	Return the type of solver used for handling the terminal constraints.
Scalar	get_th_acceptminstep () const
	Return the threshold used for accepting minimum steps.
Scalar	get_th_acceptnegstep () const
	Return the threshold used for accepting step along ascent direction.
Scalar	get_th_grad () const
	Return the tolerance of the expected gradient used for testing the step.
Scalar	get_th_minfeas () const
	Return the threshold for switching to feasibility.
Scalar	get_th_minimprove () const
	Return the minimum improvement threshold used to increase regularization.
Scalar	get_th_stepdec () const
	Return the step-length threshold used to decrease regularization.
Scalar	get_th_stepinc () const
	Return the step-length threshold used to increase regularization.
const std::vector< std::size_t > &	get_Ts () const
	Return the hybrid shooting intervals.
Scalar	get_upsilon () const
	Return the estimated penalty parameter that balances relative contribution of the cost function and equality constraints.
Scalar	get_upsilon_decfactor () const
	Return the upsilon decresing factor used to estimate to balance optimality and feasibility.
const std::vector< VectorXs > &	get_Vx () const
	Return the Hessian of the Value function $V_{\mathbf{x}_s}$ .
const std::vector< MatrixXs > &	get_Vxc () const
	Return the Hessian of the Value function $V_{\mathbf{xc}_s}$ .
const std::vector< MatrixXs > &	get_Vxx () const
	Return the Hessian of the Value function $V_{\mathbf{xx}_s}$ .
bool	get_zero_upsilon () const
	Return the zero-upsilon label.
virtual void	hybridShootForwardPass (const Scalar steplength)
	Run the multiple-shooting rollout with intervals of feasibility-driven search.
void	increaseRegularization () override
	Increase the state and control regularization values by a regfactor_ factor.
bool	increaseRegularizationCriteria () override
	Criteria used to increase regularization.
void	linearRollout ()
	Perform a linear rollout give the current control policy.
virtual void	multiShootForwardPass (const Scalar steplength)
	Run the multiple-shooting rollout.
virtual void	resizeData ()
	Resizing the solver data.
void	set_dynamics_solver (const DynamicsSolverType type, const std::size_t Tshoot=0)
	Set the dynamic solver used for handling the dynamics constraints.
void	set_reg_decfactor (const Scalar reg_factor)
	Modify the regularization factor used to decrease the damping value.
void	set_reg_incfactor (const Scalar reg_factor)
	Modify the regularization factor used to increase the damping value.
void	set_rho (const Scalar rho)
	Modify the rho parameter used in the merit function.
void	set_terminal_solver (const EqualitySolverType type)
	Set the type of solver used for handling the terminal constraints.
void	set_th_acceptminstep (const Scalar th_acceptminstep)
	Modify the threshold used for accepting minimum steps.
void	set_th_acceptnegstep (const Scalar th_acceptnegstep)
	Modify the threshold used for accepting step along ascent direction.
void	set_th_grad (const Scalar th_grad)
	Modify the tolerance of the expected gradient used for testing the step.
void	set_th_minfeas (const Scalar th_minfeas)
	Modify the threshold for switching to feasibility.
void	set_th_minimprove (const Scalar th_step)
	Modify the minimum improvement threshold used to increase regularization.
void	set_th_noimprovement (const Scalar th_noimprovement)
	Modify the threshold used to accept steps that cannot be be improved due to numerical errors the th noimprovement object.
void	set_th_stepdec (const Scalar th_step)
	Modify the step-length threshold used to decrease regularization.
void	set_th_stepinc (const Scalar th_step)
	Modify the step-length threshold used to increase regularization.
void	set_upsilon_decfactor (const Scalar th_step)
	Modify the upsilon decresing factor used to estimate to balance optimality and feasibility.
void	set_zero_upsilon (const bool zero_upsilon)
	Modify the zero-upsilon label.
virtual void	singleShootForwardPass (const Scalar steplength)
	Run the classical nonlinear rollout.
virtual Scalar	stoppingCriteria () override
	Return a positive value that quantifies the algorithm termination.
void	updateCandidate () override
	Update the candidate solution: cost, feasibilities, and merit value.
void	updateDir ()
	Update search direction associated with the batch's constraints.
virtual void	updateDualsAndSlacks (const Scalar stepLength=Scalar(1.))
	Update the dual and slack variables with a predefined step length.
virtual void	updateMeritFunction () override
	Update the merit function value for the current guess.
Public Member Functions inherited from SolverAbstractTpl< _Scalar >
	SolverAbstractTpl (std::shared_ptr< ShootingProblem > problem)
	Initialize the solver.
virtual void	calcDir ()
	Refresh the linearization of the optimal control problem around the current candidate.
Scalar	computeControlFeasibility (const std::vector< VectorXs > &us)
	Compute the control box-constraint feasibility from a given control trajectory.
Scalar	computeDynamicFeasibility ()
	Compute the dynamic feasibility $\\|\mathbf{f}_{\mathbf{s}}\\|_{\infty,1}$ for the current guess $(\mathbf{x}^k,\mathbf{u}^k)$ .
Scalar	computeEqualityFeasibility ()
	Compute the feasibility of the equality constraints for the current guess.
Scalar	computeFeasibility (const std::vector< VectorXs > &fs)
	Compute the feasibility from a given residual vector.
Scalar	computeInequalityFeasibility ()
	Compute the feasibility of the inequality constraints for the current guess.
Scalar	computeStateFeasibility (const std::vector< VectorXs > &xs)
	Compute the state box-constraint feasibility from a given state trajectory.
	DEPRECATED ("Do not use this threshold. It is not needed by our solvers", Scalar get_th_gaptol() const { return th_gaptol_;}) FeasibilityNorm get_feasnorm() const
	Return the threshold for accepting a gap as non-zero.
	DEPRECATED ("Do not use this threshold. It is not needed by our solvers", void set_th_gaptol(const Scalar th_gaptol);) void set_feasnorm(const FeasibilityNorm feas_norm)
	Modify the threshold for accepting a gap as non-zero.
	DEPRECATED ("Use get_preg for primal-variable regularization", Scalar get_xreg() const { return preg_;}) DEPRECATED("Use get_preg for primal-variable regularization"
	DEPRECATED ("Use set_preg for primal-variable regularization", void set_xreg(const Scalar xreg) { if(xreg< Scalar(0.)) { throw_pretty("Invalid argument: "<< "xreg value has to be positive.");} xreg_=xreg;preg_=xreg;}) DEPRECATED("Use set_preg for primal-variable regularization"
const std::vector< Scalar > &	get_alphas () const
	Return the set of step lengths using by the line-search procedure.
Scalar	get_cost () const
	Return the cost for the current guess.
Scalar	get_dfeas () const
	Return the reduction in the feasibility.
Scalar	get_dPhi () const
	Return the reduction in the merit function $\Delta\Phi$ .
Scalar	get_dPhiexp () const
	Return the expected reduction in the merit function $\Delta\Phi_{exp}$ .
Scalar	get_dreg () const
	Return the dual-variable regularization.
const std::vector< VectorXs > &	get_dus () const
	Return the feedforward gains $\delta\mathbf{u}_s$ .
const Vector3s &	get_DV () const
	Return the constant, linear, and quadratic terms of the expected improvement.
Scalar	get_dV () const
	Return the reduction in the cost function $\Delta V$ .
Scalar	get_dVexp () const
	Return the expected reduction in the cost function $\Delta V_{exp}$ .
const std::vector< VectorXs > &	get_dxs () const
	Return the linear update in $\delta\mathbf{x}_s$ .
Scalar	get_feas () const
	Return the total feasibility for the current guess.
Scalar	get_ffeas () const
	Return the dynamic feasibility for the current guess.
Scalar	get_ffeas_try () const
	Return the dynamic feasibility for the current step length.
const std::vector< VectorXs > &	get_fs () const
	Return the dynamic infeasibility $\mathbf{f}_{s}$ .
const std::vector< VectorXs > &	get_fs_try () const
	Return the trail dynamic infeasibility $\mathbf{f}_{s}$ .
Scalar	get_gfeas () const
	Return the inequality feasibility for the current guess.
Scalar	get_gfeas_try () const
	Return the inequality feasibility for the current step length.
Scalar	get_hfeas () const
	Return the equality feasibility for the current guess.
Scalar	get_hfeas_try () const
	Return the equality feasibility for the current step length.
bool	get_is_feasible () const
	Return the feasibility status of the $(\mathbf{x}_s,\mathbf{u}_s)$ trajectory.
std::size_t	get_iter () const
	Return the number of iterations performed by the solver.
Scalar	get_merit () const
	Return the merit for the current guess.
Scalar	get_preg () const
	Return the primal-variable regularization.
const std::shared_ptr< ShootingProblem > &	get_problem () const
	Return the shooting problem.
Scalar	get_reg_max () const
	Return the maximum regularization value.
Scalar	get_reg_min () const
	Return the minimum regularization value.
Scalar	get_steplength () const
	Return the step length $\alpha$ .
Scalar	get_stop () const
	Return the stopping-criteria value computed by stoppingCriteria().
Scalar	get_th_acceptstep () const
	Return the threshold used for accepting a step.
Scalar	get_th_stop () const
	Return the tolerance for stopping the algorithm.
Scalar	get_ureg () const
const std::vector< VectorXs > &	get_us () const
	Return the control trajectory $\mathbf{u}_s$ .
const std::vector< VectorXs > &	get_us_try () const
	Return the trial control trajectory $\mathbf{u}_s$ .
const std::vector< VectorXs > &	get_xs () const
	Return the state trajectory $\mathbf{x}_s$ .
const std::vector< VectorXs > &	get_xs_try () const
	Return the trial state trajectory $\mathbf{x}_s$ .
const std::vector< std::shared_ptr< CallbackAbstract > > &	getCallbacks () const
	Return the list of callback functions using for diagnostic.
void	set_alphas (const std::vector< Scalar > &alphas)
	Modify the set of step lengths using by the line-search procedure.
void	set_dreg (const Scalar dreg)
	Modify the dual-variable regularization value.
void	set_preg (const Scalar preg)
	Modify the primal-variable regularization value.
void	set_reg_max (const Scalar regmax)
	Modify the maximum regularization value.
void	set_reg_min (const Scalar regmin)
	Modify the minimum regularization value.
void	set_th_acceptstep (const Scalar th_acceptstep)
	Modify the threshold used for accepting step.
void	set_th_stop (const Scalar th_stop)
	Modify the tolerance for stopping the algorithm.
void	set_ureg (const Scalar ureg)
void	set_us (const std::vector< VectorXs > &us)
	Modify the control trajectory $\mathbf{u}_s$ .
void	set_xs (const std::vector< VectorXs > &xs)
	Modify the state trajectory $\mathbf{x}_s$ .
void	setCallbacks (const std::vector< std::shared_ptr< CallbackAbstract > > &callbacks)
	Set a list of callback functions using for the solver diagnostic.
virtual void	setCandidate (const std::vector< VectorXs > &xs_warm=DefaultVector< Scalar >::value, const std::vector< VectorXs > &us_warm=DefaultVector< Scalar >::value, const bool is_feasible=false)
	Set the solver candidate trajectories $(\mathbf{x}_s,\mathbf{u}_s)$ .
virtual bool	solve (const std::vector< VectorXs > &init_xs=DefaultVector< Scalar >::value, const std::vector< VectorXs > &init_us=DefaultVector< Scalar >::value, const std::size_t maxiter=100, const bool is_feasible=false, const Scalar reg_init=std::numeric_limits< Scalar >::quiet_NaN())
	Compute the optimal trajectory $\mathbf{x}^_s,\mathbf{u}^_s$ as lists of and terms.
virtual Scalar	tryStep (const Scalar steplength=Scalar(1.))
	Try a predefined step length $\alpha$ and compute its cost improvement and merit improvement $d\Phi$ .

Public Attributes
EIGEN_MAKE_ALIGNED_OPERATOR_NEW typedef _Scalar	Scalar
Public Attributes inherited from SolverAbstractTpl< _Scalar >
EIGEN_MAKE_ALIGNED_OPERATOR_NEW typedef _Scalar	Scalar

Protected Member Functions
void	allocateData ()
	Allocate all the internal data needed for the solver.
void	computeNullTerminalMultiplier ()
	compute the multiplier associated to the terminal constraint
virtual void	resizeRunningData () override
	Resize data associated with the running models of the shooting problem.
virtual void	resizeTerminalData () override
	Resize data associated with the terminal model of the shooting problem.
Protected Member Functions inherited from SolverAbstractTpl< _Scalar >
void	allocateData ()
	Allocate all the basic data needed in solvers.
	DEPRECATED ("Do not use this threshold. It is not needed by our solvers", Scalar th_gaptol_;) enum FeasibilityNorm feasnorm_
	DEPRECATED ("Use preg_ for primal-variable regularization", Scalar xreg_;) DEPRECATED("Use dreg_ for primal-variable regularization"

Protected Attributes
std::vector< VectorXs >	dx_
	State error during the roll-out/forward-pass (size T).
DynamicsSolverType	dyn_solver_
	Type of dynamics solver.
VectorXs	fTVxx_p_
std::vector< MatrixXsRowMajor >	FuTVxx_p_
std::vector< MatrixXsRowMajor >	FxTVxx_p_
std::vector< MatrixXsRowMajor >	K_
	Feedback gains $\mathbf{K}$ .
std::vector< VectorXs >	k_
	Feed-forward terms $\mathbf{l}$ .
std::vector< VectorXs >	Luu_du_
std::vector< VectorXs >	Lxu_du_
std::vector< VectorXs >	Lxx_dx_
std::vector< VectorXs >	Qu_
	Gradient of the Hamiltonian $\mathbf{Q_u}$ .
std::vector< MatrixXs >	Quu_
	Hessian of the Hamiltonian $\mathbf{Q_{uu}}$ .
std::vector< Eigen::LLT< MatrixXs > >	Quu_llt_
	Cholesky LLT solver.
std::vector< VectorXs >	Qx_
	Gradient of the Hamiltonian $\mathbf{Q_x}$ .
std::vector< MatrixXs >	Qxu_
	Hessian of the Hamiltonian $\mathbf{Q_{xu}}$ .
std::vector< MatrixXs >	Qxx_
	Hessian of the Hamiltonian $\mathbf{Q_{xx}}$ .
Scalar	reg_decfactor_
Scalar	reg_incfactor_
Scalar	rho_
EqualitySolverType	term_solver_
	Type of terminal solver.
Scalar	th_acceptminstep_
Scalar	th_acceptnegstep_
Scalar	th_grad_
Scalar	th_minfeas_
	Threshold for switching to feasibility.
Scalar	th_minimprove_
Scalar	th_noimprovement_
Scalar	th_stepdec_
	Step-length threshold used to decrease regularization.
Scalar	th_stepinc_
	Step-length threshold used to increase regularization.
std::vector< std::size_t >	Ts_
	Index that describes the hybrid shoots.
Scalar	upsilon_
Scalar	upsilon_decfactor_
std::vector< VectorXs >	Vx_
	Gradient of the Value function $\mathbf{V_x}$ .
std::vector< MatrixXs >	Vxx_
	Hessian of the Value function $\mathbf{V_{xx}}$ .
std::vector< VectorXs >	Vxx_f_
MatrixXs	Vxx_tmp_
	Temporary variable for ensuring symmetry of Vxx.
bool	zero_upsilon_
Protected Attributes inherited from SolverAbstractTpl< _Scalar >
bool	acceptstep_
std::vector< Scalar >	alphas_
	Set of step lengths using by the line-search procedure.
std::vector< std::shared_ptr< CallbackAbstract > >	callbacks_
	Callback functions.
Scalar	cost_
	Cost for the current guess.
Scalar	cost_try_
	Total cost computed by line-search procedure.
Scalar	dfeas_
	Reduction in the feasibility.
Scalar	dImpr_
Scalar	dPhi_
	Reduction in the merit function computed by tryStep().
Scalar	dPhiexp_
Scalar	dreg_
	Current dual-variable regularization value.
std::vector< VectorXs >	dus_
	Linear control direction (size T).
Vector3s	DV_
	LQ approximation of the expected improvement.
Scalar	dV_
	Reduction in the cost function computed by tryStep().
Scalar	dVexp_
Scalar	dVexp_full_
std::vector< VectorXs >	dxs_
	Linear state direction (size T + 1).
Scalar	feas_
	Total feasibility for the current guess.
Scalar	ffeas_
	Feasibility of the dynamic constraints for the current guess.
Scalar	ffeas_try_
std::vector< VectorXs >	fs_
	Dynamics gaps in each node.
std::vector< VectorXs >	fs_try_
std::vector< VectorXs >	g_adj_
	Adjusted inequality bound.
Scalar	gfeas_
Scalar	gfeas_try_
Scalar	hfeas_
Scalar	hfeas_try_
bool	is_feasible_
	Label that indicates is the iteration is feasible.
std::size_t	iter_
	Number of iteration performed by the solver.
Scalar	merit_
	Merit for the current guess.
std::size_t	ng_T_
	Dimension of termianl inequality constraints.
std::size_t	nh_T_
	Dimension of terminal equality constraints.
Scalar	preg_
	Current primal-variable regularization value.
std::shared_ptr< ShootingProblem >	problem_
	optimal control problem
bool	recalcdir_
Scalar	reg_max_
	Maximum allowed regularization value.
Scalar	reg_min_
	< Current control regularization values
Scalar	steplength_
	Current applied step length.
Scalar	stop_
	Value computed by stoppingCriteria().
Scalar	th_acceptstep_
	Threshold used for accepting step.
Scalar	th_stop_
	Tolerance for stopping the algorithm.
Scalar	tmp_feas_
	Temporal variables used for computed the feasibility.
std::vector< VectorXs >	u_adj_
	Adjusted control bound.
Scalar	ureg_
std::vector< VectorXs >	us_
	Control trajectory.
std::vector< VectorXs >	us_try_
	Control trajectory computed by line-search procedure.
bool	was_feasible_
std::vector< VectorXs >	x_adj_
	Adjusted state bound.
std::vector< VectorXs >	xs_
	State trajectory.
std::vector< VectorXs >	xs_try_
	State trajectory computed by line-search procedure.

Detailed Description

template<typename _Scalar>
class crocoddyl::SolverFDDPTpl< _Scalar >

Feasibility-driven Differential Dynamic Programming (FDDP) solver.

The FDDP solver computes an optimal trajectory and control commands by iterates running backwardPass() and forwardPass(). The backward pass accepts infeasible guess as described in the SolverFDDP::backwardPass(). Additionally, the forward pass handles infeasibility simulations that resembles the numerical behaviour of a multiple-shooting formulation, i.e.:

$\begin{eqnarray} \mathbf{\hat{x}}_0 &=& \mathbf{\tilde{x}}_0 - (1 - \alpha)\mathbf{\bar{f}}_0,\\ \mathbf{\hat{u}}_k &=& \mathbf{u}_k + \alpha\mathbf{k}_k + \mathbf{K}_k(\mathbf{\hat{x}}_k-\mathbf{x}_k),\\ \mathbf{\hat{x}}_{k+1} &=& \mathbf{f}_k(\mathbf{\hat{x}}_k,\mathbf{\hat{u}}_k) - (1 - \alpha)\mathbf{\bar{f}}_{k+1}. \end{eqnarray}$

Note that the forward pass keeps the gaps $\mathbf{\bar{f}}_s$ open according to the step length $\alpha$ that has been accepted. This solver has shown empirically greater globalization strategy. Additionally, the expected improvement computation considers the gaps in the dynamics:

$\begin{equation} \Delta J(\alpha) = \Delta_1\alpha + \frac{1}{2}\Delta_2\alpha^2, \end{equation}$

with

$\begin{eqnarray} \Delta_1 = \sum_{k=0}^{N-1} \mathbf{k}_k^\top\mathbf{Q}_{\mathbf{u}_k} +\mathbf{\bar{f}}_k^\top(V_{\mathbf{x}_k} - V_{\mathbf{xx}_k}\mathbf{x}_k),\nonumber\\ \Delta_2 = \sum_{k=0}^{N-1} \mathbf{k}_k^\top\mathbf{Q}_{\mathbf{uu}_k}\mathbf{k}_k + \mathbf{\bar{f}}_k^\top(2 V_{\mathbf{xx}_k}\mathbf{x}_k - V_{\mathbf{xx}_k}\mathbf{\bar{f}}_k). \end{eqnarray}$

For more details about the feasibility-driven differential dynamic programming algorithm see:

@inproceedings{mastalli-icra20,
author = {Mastalli, C. and Budhiraja, R. and Merkt, W. and Saurel, G. and Hammoud, B. and Naveau, M. and Carpentier, J. and Righetti, L. and Vijayakumar, S. and Mansard, N.},
title = {{Crocoddyl: An Efficient and Versatile Framework for Multi-Contact Optimal Control}},
booktitle = {IEEE International Conference on Robotics and Automation (ICRA)},
year = {2020}
}

See also: SolverAbstract(), backwardPass(), forwardPass(), and expectedImprovement().

Definition at line 70 of file fddp.hpp.

Member Typedef Documentation

◆ SolverAbstract

template<typename _Scalar>

typedef SolverAbstractTpl<Scalar> SolverAbstract

Definition at line 76 of file fddp.hpp.

◆ ShootingProblem

template<typename _Scalar>

typedef ShootingProblemTpl<Scalar> ShootingProblem

Definition at line 77 of file fddp.hpp.

◆ ActionModelAbstract

template<typename _Scalar>

typedef ShootingProblem::ActionModelAbstract ActionModelAbstract

Definition at line 78 of file fddp.hpp.

◆ ActionDataAbstract

template<typename _Scalar>

typedef ShootingProblem::ActionDataAbstract ActionDataAbstract

Definition at line 79 of file fddp.hpp.

◆ CallbackAbstract

template<typename _Scalar>

typedef CallbackAbstractTpl<Scalar> CallbackAbstract

Definition at line 80 of file fddp.hpp.

◆ MathBase

template<typename _Scalar>

typedef MathBaseTpl<Scalar> MathBase

Definition at line 81 of file fddp.hpp.

◆ VectorXs

template<typename _Scalar>

typedef MathBase::VectorXs VectorXs

Definition at line 82 of file fddp.hpp.

◆ Vector3s

template<typename _Scalar>

typedef MathBase::Vector3s Vector3s

Definition at line 83 of file fddp.hpp.

◆ MatrixXs

template<typename _Scalar>

typedef MathBase::MatrixXs MatrixXs

Definition at line 84 of file fddp.hpp.

◆ MatrixXsRowMajor

template<typename _Scalar>

typedef MathBase::MatrixXsRowMajor MatrixXsRowMajor

Definition at line 85 of file fddp.hpp.

Constructor & Destructor Documentation

◆ SolverFDDPTpl()

template<typename _Scalar>

SolverFDDPTpl	(	std::shared_ptr< ShootingProblem >	problem,
		const DynamicsSolverType	dyn_solver = FeasShoot,
		const EqualitySolverType	term_solver = LuNull )

explicit

Initialize the FDDP solver.

Parameters

[in]	problem	Shooting problem
[in]	dyn_solver	Type of dynamic solver
[in]	term_solver	Type of terminal solver

Member Function Documentation

◆ computeDirection()

template<typename _Scalar>

virtual void computeDirection ( const bool recalc = true )

overridevirtual

Compute the search direction $(\delta\mathbf{x}^k,\delta\mathbf{u}^k)$ for the current guess $(\mathbf{x}^k_s,\mathbf{u}^k_s)$ .

Implements SolverAbstractTpl< _Scalar >.

Reimplemented in SolverIntroTpl< _Scalar >, and SolverIntroTpl< double >.

◆ computeCandidate()

template<typename _Scalar>

virtual void computeCandidate ( const Scalar step_length = Scalar(1.) )

overridevirtual

Compute new candidate solution using step length.

Reimplemented from SolverAbstractTpl< _Scalar >.

◆ forwardPass()

template<typename _Scalar>

void forwardPass ( const Scalar steplength = Scalar(1.) )

Perform a forward pass with a predefined step length.

Our solver supports fourth type of forward passes: feasiblility-driven (FeasShoot), multiple shooting (MultiShoot), hybrid shooting (HybridShoot), and single shooting (SingleShoot). The feasibility-driven shooting decreases monotonocally the dynamics feasibility based on the applied step length. The hybrid shooting combines both feasibility-driven and multiple shooting approaches. Instead, the single shooting is the traditional approach implemented in DDP. The type of dynamics solver can be defined via set_dynamics_solver.

Parameters

[in] steplength applied step length ( $0\leq\alpha\leq1$ )

◆ updateDualsAndSlacks()

template<typename _Scalar>

virtual void updateDualsAndSlacks ( const Scalar stepLength = Scalar(1.) )

virtual

Update the dual and slack variables with a predefined step length.

Parameters

[in] steplength applied step length ( $0\leq\alpha\leq1$ )

◆ stoppingCriteria()

template<typename _Scalar>

virtual Scalar stoppingCriteria ( )

overridevirtual

Return a positive value that quantifies the algorithm termination.

Implements SolverAbstractTpl< _Scalar >.

◆ expectedImprovement()

template<typename _Scalar>

virtual Vector3s expectedImprovement ( )

overridevirtual

Return the expected improvement $dV_{exp}$ from a given current search direction $(\delta\mathbf{x}^k,\delta\mathbf{u}^k)$ .

The expected improvement computation considers the gaps in the dynamics:

$\begin{equation} \Delta J(\alpha) = \Delta_1\alpha + \frac{1}{2}\Delta_2\alpha^2, \end{equation}$

with

$\begin{eqnarray} \Delta_1 = \sum_{k=0}^{N-1} \mathbf{k}_k^\top\mathbf{Q}_{\mathbf{u}_k} +\mathbf{\bar{f}}_k^\top(V_{\mathbf{x}_k} - V_{\mathbf{xx}_k}\mathbf{x}_k),\nonumber\\ \Delta_2 = \sum_{k=0}^{N-1} \mathbf{k}_k^\top\mathbf{Q}_{\mathbf{uu}_k}\mathbf{k}_k + \mathbf{\bar{f}}_k^\top(2 V_{\mathbf{xx}_k}\mathbf{x}_k - V_{\mathbf{xx}_k}\mathbf{\bar{f}}_k). \end{eqnarray}$

Implements SolverAbstractTpl< _Scalar >.

◆ computeMeritFunctionImprovement()

template<typename _Scalar>

virtual void computeMeritFunctionImprovement ( )

overridevirtual

Compute the merit function improvement for the current step.

Reimplemented from SolverAbstractTpl< _Scalar >.

◆ computeExpectedMeritFunctionImprovement()

template<typename _Scalar>

virtual void computeExpectedMeritFunctionImprovement ( )

overridevirtual

Compute the expected merit function improvement for the current step.

Reimplemented from SolverAbstractTpl< _Scalar >.

◆ updateMeritFunction()

template<typename _Scalar>

virtual void updateMeritFunction ( )

overridevirtual

Update the merit function value for the current guess.

Reimplemented from SolverAbstractTpl< _Scalar >.

◆ checkAcceptance()

template<typename _Scalar>

virtual bool checkAcceptance ( )

overridevirtual

Check if we should accept or not the step.

Returns: True if we should accept the step. False otherwise

Reimplemented from SolverAbstractTpl< _Scalar >.

◆ backwardPass()

template<typename _Scalar>

virtual void backwardPass ( )

virtual

Run the backward pass (Riccati sweep).

It assumes that the Jacobian and Hessians of the optimal control problem have been compute (i.e., calcDir()). The backward pass handles infeasible guess through a modified Riccati sweep:

$\begin{eqnarray*} \mathbf{Q}_{\mathbf{x}_k} &=& \mathbf{l}_{\mathbf{x}_k} + \mathbf{f}^\top_{\mathbf{x}_k} (V_{\mathbf{x}_{k+1}} + V_{\mathbf{xx}_{k+1}}\mathbf{\bar{f}}_{k+1}),\\ \mathbf{Q}_{\mathbf{u}_k} &=& \mathbf{l}_{\mathbf{u}_k} + \mathbf{f}^\top_{\mathbf{u}_k} (V_{\mathbf{x}_{k+1}} + V_{\mathbf{xx}_{k+1}}\mathbf{\bar{f}}_{k+1}),\\ \mathbf{Q}_{\mathbf{xx}_k} &=& \mathbf{l}_{\mathbf{xx}_k} + \mathbf{f}^\top_{\mathbf{x}_k} V_{\mathbf{xx}_{k+1}} \mathbf{f}_{\mathbf{x}_k},\\ \mathbf{Q}_{\mathbf{xu}_k} &=& \mathbf{l}_{\mathbf{xu}_k} + \mathbf{f}^\top_{\mathbf{x}_k} V_{\mathbf{xx}_{k+1}} \mathbf{f}_{\mathbf{u}_k},\\ \mathbf{Q}_{\mathbf{uu}_k} &=& \mathbf{l}_{\mathbf{uu}_k} + \mathbf{f}^\top_{\mathbf{u}_k} V_{\mathbf{xx}_{k+1}} \mathbf{f}_{\mathbf{u}_k}, \end{eqnarray*}$

where $\mathbf{l}_{\mathbf{x}_k}$ , $\mathbf{l}_{\mathbf{u}_k}$ , $\mathbf{f}_{\mathbf{x}_k}$ and $\mathbf{f}_{\mathbf{u}_k}$ are the Jacobians of the cost function and dynamics, $\mathbf{l}_{\mathbf{xx}_k}$ , $\mathbf{l}_{\mathbf{xu}_k}$ and $\mathbf{l}_{\mathbf{uu}_k}$ are the Hessians of the cost function, $V_{\mathbf{x}_{k+1}}$ and $V_{\mathbf{xx}_{k+1}}$ defines the linear-quadratic approximation of the Value function, and $\mathbf{\bar{f}}_{k+1}$ describes the gaps of the dynamics.

◆ batchPass()

template<typename _Scalar>

void batchPass ( )

Run the batch pass to account for its constraints.

Update the direction and feed-forward term to account for the terminal constraint. To do so, we first compute the unscaled search direction accounting for the terminal constraint.

◆ computeActionValueFunction()

template<typename _Scalar>

virtual void computeActionValueFunction	(	const std::size_t	t,
		const std::shared_ptr< ActionModelAbstract > &	model,
		const std::shared_ptr< ActionDataAbstract > &	data )

virtual

Compute the linear-quadratic approximation of the control action-value function.

Parameters

[in]	t	Time instance
[in]	model	Action model in the given time instance
[in]	data	Action data in the given time instance

◆ computeBatchActionValueFunction()

template<typename _Scalar>

virtual void computeBatchActionValueFunction	(	const std::size_t	t,
		const std::shared_ptr< ActionDataAbstract > &	data )

virtual

Compute the linear-quadratic approximation of the control action-value function associated to the batch's constraints.

Parameters

[in]	t	Time instance
[in]	data	Action data in the given time instance

◆ computePolicy()

template<typename _Scalar>

virtual void computePolicy ( const std::size_t t )

virtual

Compute the feedforward and feedback terms (control policy) computed via a Cholesky decomposition.

To compute the feedforward $\mathbf{k}_k$ and feedback $\mathbf{K}_k$ terms, we use a Cholesky decomposition to solve $\mathbf{Q}_{\mathbf{uu}_k}^{-1}$ term:

$\begin{eqnarray}\mathbf{k}_k &=& \mathbf{Q}_{\mathbf{uu}_k}^{-1}\mathbf{Q}_{\mathbf{u}},\\ \mathbf{K}_k &=& \mathbf{Q}_{\mathbf{uu}_k}^{-1}\mathbf{Q}_{\mathbf{ux}}. \end{eqnarray}$

Note that if the Cholesky decomposition fails, then we re-start the backward pass and increase the state and control regularization values.

Reimplemented in SolverBoxFDDPTpl< _Scalar >, SolverBoxFDDPTpl< double >, SolverIntroTpl< _Scalar >, and SolverIntroTpl< double >.

◆ computeBatchPolicy()

template<typename _Scalar>

virtual void computeBatchPolicy ( const std::size_t t )

virtual

Compute the feedforward and feedback terms (control policy) associated to the batch's constraints.

Note that if the Cholesky decomposition fails, then we re-start the backward pass and increase the state and control regularization values.

Reimplemented in SolverIntroTpl< _Scalar >, and SolverIntroTpl< double >.

◆ computeValueFunction()

template<typename _Scalar>

virtual void computeValueFunction	(	const std::size_t	t,
		const std::shared_ptr< ActionModelAbstract > &	model )

virtual

Compute the linear-quadratic approximation of the value function.

This function is called in the backward pass after updating the local action-value and policy functions.

Parameters

[in]	t	Time instance
[in]	model	Action model in the given time instance

Reimplemented in SolverIntroTpl< _Scalar >, and SolverIntroTpl< double >.

◆ computeBatchValueFunction()

template<typename _Scalar>

virtual void computeBatchValueFunction ( const std::size_t t )

virtual

Compute the linear-quadratic approximation of the value function associated to the batch's constraints.

This function is called in the backward pass after updating the local action-value and policy functions.

Parameters

[in] t Time instance

Reimplemented in SolverIntroTpl< _Scalar >, and SolverIntroTpl< double >.

◆ linearRollout()

template<typename _Scalar>

void linearRollout ( )

Perform a linear rollout give the current control policy.

The results of this linear rollout are stored in dxs and dus.

◆ feasShootForwardPass()

template<typename _Scalar>

virtual void feasShootForwardPass ( const Scalar steplength )

virtual

Run the feasibility-driven nonlinear rollout.

It rollouts the action model given the feasibility-driven approach described in "Crocoddyl: An Efficient and Versatile Framework for Multi-Contact Optimal Control"

Parameters

[in] steplength applied step length ( $0\leq\alpha\leq1$ )

◆ multiShootForwardPass()

template<typename _Scalar>

virtual void multiShootForwardPass ( const Scalar steplength )

virtual

Run the multiple-shooting rollout.

It rollouts the action model given the multiple-shooting approach described in (TODO: add paper title)

Parameters

[in] steplength applied step length ( $0\leq\alpha\leq1$ )

◆ hybridShootForwardPass()

template<typename _Scalar>

virtual void hybridShootForwardPass ( const Scalar steplength )

virtual

Run the multiple-shooting rollout with intervals of feasibility-driven search.

It rollouts the action model given the hybrid-shooting approach described in (TODO: add paper title)

Parameters

[in] steplength applied step length ( $0\leq\alpha\leq1$ )

◆ singleShootForwardPass()

template<typename _Scalar>

virtual void singleShootForwardPass ( const Scalar steplength )

virtual

Run the classical nonlinear rollout.

It rollouts the action model given the classical approach in DDP. You can find details in "A second-order gradient method for determining optimal trajectories of non-linear discrete-time systems"

Parameters

[in] steplength applied step length ( $0\leq\alpha\leq1$ )

◆ updateCandidate()

template<typename _Scalar>

void updateCandidate ( )

overridevirtual

Update the candidate solution: cost, feasibilities, and merit value.

Reimplemented from SolverAbstractTpl< _Scalar >.

◆ decreaseRegularizationCriteria()

template<typename _Scalar>

bool decreaseRegularizationCriteria ( )

overridevirtual

Criteria used to decrease regularization.

Reimplemented from SolverAbstractTpl< _Scalar >.

◆ increaseRegularizationCriteria()

template<typename _Scalar>

bool increaseRegularizationCriteria ( )

overridevirtual

Criteria used to increase regularization.

Reimplemented from SolverAbstractTpl< _Scalar >.

◆ increaseRegularization()

template<typename _Scalar>

void increaseRegularization ( )

overridevirtual

Increase the state and control regularization values by a regfactor_ factor.

Reimplemented from SolverAbstractTpl< _Scalar >.

◆ decreaseRegularization()

template<typename _Scalar>

void decreaseRegularization ( )

overridevirtual

Decrease the state and control regularization values by a regfactor_ factor.

Reimplemented from SolverAbstractTpl< _Scalar >.

◆ cast()

template<typename _Scalar>

template<typename NewScalar>

SolverFDDPTpl< NewScalar > cast ( ) const

Cast the FDDP solver to a different scalar type.

It is useful for operations requiring different precision or scalar types.

Template Parameters

NewScalar The new scalar type to cast to.

Returns: SolverFDDPTpl<NewScalar> A FDDP solver with the new scalar type.

◆ get_zero_upsilon()

template<typename _Scalar>

bool get_zero_upsilon ( ) const

Return the zero-upsilon label.

True if we set the estimated penalty parameter (upsilon) to zero when solve is called.

◆ set_dynamics_solver()

template<typename _Scalar>

void set_dynamics_solver	(	const DynamicsSolverType	type,
		const std::size_t	Tshoot = 0 )

Set the dynamic solver used for handling the dynamics constraints.

It is worth noting that the default solver is the Feasibility-Driven DDP. When we enable parallelization, this strategy is not necessarily the faster one for medium to large systems.

Parameters

[in]	type	Type of dynamics solver
[in]	Tshoot	Number of nodes per each shooting interval

◆ set_terminal_solver()

template<typename _Scalar>

void set_terminal_solver ( const EqualitySolverType type )

Set the type of solver used for handling the terminal constraints.

Parameters

[in] type Type of terminal solver

◆ set_zero_upsilon()

template<typename _Scalar>

void set_zero_upsilon ( const bool zero_upsilon )

Modify the zero-upsilon label.

Parameters

zero_upsilon True if we set estimated penalty parameter (upsilon) to zero when solve is called.

◆ resizeRunningData()

template<typename _Scalar>

virtual void resizeRunningData ( )

overrideprotectedvirtual

Resize data associated with the running models of the shooting problem.

Reimplemented from SolverAbstractTpl< _Scalar >.

Reimplemented in SolverBoxFDDPTpl< _Scalar >, and SolverBoxFDDPTpl< double >.

◆ resizeTerminalData()

template<typename _Scalar>

virtual void resizeTerminalData ( )

overrideprotectedvirtual

Resize data associated with the terminal model of the shooting problem.

Reimplemented from SolverAbstractTpl< _Scalar >.

◆ computeDynamicFeasibility()

template<typename _Scalar>

Scalar 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})$ .

◆ computeEqualityFeasibility()

template<typename _Scalar>

Scalar 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.

◆ computeFeasibility()

template<typename _Scalar>

Scalar computeFeasibility ( const std::vector< VectorXs > & fs )

Compute the feasibility from a given residual vector.

As in the computeDynamicFeasibility, computeInequalityFeasibility or computeEqualityFeasibility, we can compute the feasibility 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.

Parameters

[in] fs Vector of residual vectors which we wish to compute the feasibility

Returns: the residuals' feasibility

◆ computeInequalityFeasibility()

template<typename _Scalar>

Scalar 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.

◆ resizeData()

template<typename _Scalar>

virtual void resizeData ( )

virtual

Resizing the solver data.

If the shooting problem has changed after construction, then this function resizes all the data before starting resolve the problem.

Reimplemented from SolverAbstractTpl< _Scalar >.

Member Data Documentation

◆ Scalar

template<typename _Scalar>

EIGEN_MAKE_ALIGNED_OPERATOR_NEW typedef _Scalar Scalar

Definition at line 75 of file fddp.hpp.

◆ dyn_solver_

template<typename _Scalar>

DynamicsSolverType dyn_solver_

protected

Type of dynamics solver.

Definition at line 685 of file fddp.hpp.

◆ term_solver_

template<typename _Scalar>

EqualitySolverType term_solver_

protected

Type of terminal solver.

Definition at line 686 of file fddp.hpp.

◆ reg_incfactor_

template<typename _Scalar>

Scalar reg_incfactor_

protected

Regularization factor used to increase the damping value

Definition at line 687 of file fddp.hpp.

◆ reg_decfactor_

template<typename _Scalar>

Scalar reg_decfactor_

protected

Regularization factor used to decrease the damping value

Definition at line 689 of file fddp.hpp.

◆ th_grad_

template<typename _Scalar>

Scalar th_grad_

protected

Tolerance of the expected gradient used for testing the step

Definition at line 691 of file fddp.hpp.

◆ th_noimprovement_

template<typename _Scalar>

Scalar th_noimprovement_

protected

Threshold used to accept steps that cannot be be improved due to numerical errors

Definition at line 693 of file fddp.hpp.

◆ th_stepdec_

template<typename _Scalar>

Scalar th_stepdec_

protected

Step-length threshold used to decrease regularization.

Definition at line 696 of file fddp.hpp.

◆ th_stepinc_

template<typename _Scalar>

Scalar th_stepinc_

protected

Step-length threshold used to increase regularization.

Definition at line 698 of file fddp.hpp.

◆ th_minimprove_

template<typename _Scalar>

Scalar th_minimprove_

protected

Minimum improvement threshold used in the regularization scheme

Definition at line 699 of file fddp.hpp.

◆ th_acceptnegstep_

template<typename _Scalar>

Scalar th_acceptnegstep_

protected

Threshold used for accepting step along ascent direction

Definition at line 701 of file fddp.hpp.

◆ th_acceptminstep_

template<typename _Scalar>

Scalar th_acceptminstep_

protected

Threshold used for accepting step along with a minimum length

Definition at line 703 of file fddp.hpp.

◆ rho_

template<typename _Scalar>

Scalar rho_

protected

Parameter used in the merit function to predict the expected reduction

Definition at line 705 of file fddp.hpp.

◆ th_minfeas_

template<typename _Scalar>

Scalar th_minfeas_

protected

Threshold for switching to feasibility.

Definition at line 707 of file fddp.hpp.

◆ upsilon_

template<typename _Scalar>

Scalar upsilon_

protected

Estimated penalty parameter that balances relative contribution of the cost function and equality constraints

Definition at line 709 of file fddp.hpp.

◆ upsilon_decfactor_

template<typename _Scalar>

Scalar upsilon_decfactor_

protected

Estimated penalty parameter factor used to decrease its value

Definition at line 711 of file fddp.hpp.

◆ zero_upsilon_

template<typename _Scalar>

bool zero_upsilon_

protected

True if we wish to set estimated penalty parameter (upsilon) to zero when solve is called.

Definition at line 713 of file fddp.hpp.

◆ Ts_

template<typename _Scalar>

std::vector<std::size_t> Ts_

protected

Index that describes the hybrid shoots.

Definition at line 715 of file fddp.hpp.

◆ Vxx_tmp_

template<typename _Scalar>

MatrixXs Vxx_tmp_

protected

Temporary variable for ensuring symmetry of Vxx.

Definition at line 718 of file fddp.hpp.

◆ Vxx_

template<typename _Scalar>

std::vector<MatrixXs> Vxx_

protected

Hessian of the Value function $\mathbf{V_{xx}}$ .

Definition at line 720 of file fddp.hpp.

◆ Vxx_f_

template<typename _Scalar>

std::vector<VectorXs> Vxx_f_

protected

Hessian of the Value function times the gap $\mathbf{V_{xx} \bar{f}}$

Definition at line 722 of file fddp.hpp.

◆ Vx_

template<typename _Scalar>

std::vector<VectorXs> Vx_

protected

Gradient of the Value function $\mathbf{V_x}$ .

Definition at line 725 of file fddp.hpp.

◆ Lxx_dx_

template<typename _Scalar>

std::vector<VectorXs> Lxx_dx_

protected

Second-order change of the cost function $\boldsymbol{\ell}_{\mathbf{{xx}}}\delta\mathbf{x}$

Definition at line 727 of file fddp.hpp.

◆ Luu_du_

template<typename _Scalar>

std::vector<VectorXs> Luu_du_

protected

Second-order change of the cost function $\boldsymbol{\ell}_{\mathbf{{uu}}}\delta\mathbf{u}$

Definition at line 730 of file fddp.hpp.

◆ Lxu_du_

template<typename _Scalar>

std::vector<VectorXs> Lxu_du_

protected

Second-order change of the cost function $\boldsymbol{\ell}_{\mathbf{{xu}}}\delta\mathbf{u}$

Definition at line 733 of file fddp.hpp.

◆ Qxx_

template<typename _Scalar>

std::vector<MatrixXs> Qxx_

protected

Hessian of the Hamiltonian $\mathbf{Q_{xx}}$ .

Definition at line 736 of file fddp.hpp.

◆ Qxu_

template<typename _Scalar>

std::vector<MatrixXs> Qxu_

protected

Hessian of the Hamiltonian $\mathbf{Q_{xu}}$ .

Definition at line 738 of file fddp.hpp.

◆ Quu_

template<typename _Scalar>

std::vector<MatrixXs> Quu_

protected

Hessian of the Hamiltonian $\mathbf{Q_{uu}}$ .

Definition at line 740 of file fddp.hpp.

◆ Qx_

template<typename _Scalar>

std::vector<VectorXs> Qx_

protected

Gradient of the Hamiltonian $\mathbf{Q_x}$ .

Definition at line 742 of file fddp.hpp.

◆ Qu_

template<typename _Scalar>

std::vector<VectorXs> Qu_

protected

Gradient of the Hamiltonian $\mathbf{Q_u}$ .

Definition at line 744 of file fddp.hpp.

◆ K_

template<typename _Scalar>

std::vector<MatrixXsRowMajor> K_

protected

Feedback gains $\mathbf{K}$ .

Definition at line 745 of file fddp.hpp.

◆ k_

template<typename _Scalar>

std::vector<VectorXs> k_

protected

Feed-forward terms $\mathbf{l}$ .

Definition at line 746 of file fddp.hpp.

◆ dx_

template<typename _Scalar>

std::vector<VectorXs> dx_

protected

State error during the roll-out/forward-pass (size T).

Definition at line 748 of file fddp.hpp.

◆ FxTVxx_p_

template<typename _Scalar>

std::vector<MatrixXsRowMajor> FxTVxx_p_

protected

Store the value of $\mathbf{f_x}^T\mathbf{V_{xx}}^{'}$

Definition at line 750 of file fddp.hpp.

◆ FuTVxx_p_

template<typename _Scalar>

std::vector<MatrixXsRowMajor> FuTVxx_p_

protected

Store the values of $\mathbf{f_u}^T\mathbf{V_{xx}}^{'}$ per each running node

Definition at line 753 of file fddp.hpp.

◆ fTVxx_p_

template<typename _Scalar>

VectorXs fTVxx_p_

protected

Store the value of $\mathbf{\bar{f}}^T\mathbf{V_{xx}}^{'}$

Definition at line 756 of file fddp.hpp.

◆ Quu_llt_

template<typename _Scalar>

std::vector<Eigen::LLT<MatrixXs> > Quu_llt_

protected

Cholesky LLT solver.

Definition at line 758 of file fddp.hpp.

The documentation for this class was generated from the following files:

/build/source/include/crocoddyl/core/fwd.hpp
/build/source/include/crocoddyl/core/solvers/fddp.hpp

Public Types

Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Detailed Description

Member Typedef Documentation

◆ SolverAbstract

◆ ShootingProblem

◆ ActionModelAbstract

◆ ActionDataAbstract

◆ CallbackAbstract

◆ MathBase

◆ VectorXs

◆ Vector3s

◆ MatrixXs

◆ MatrixXsRowMajor

Constructor & Destructor Documentation

◆ SolverFDDPTpl()

Member Function Documentation

◆ computeDirection()

◆ computeCandidate()

◆ forwardPass()

◆ updateDualsAndSlacks()

◆ stoppingCriteria()

◆ expectedImprovement()

◆ computeMeritFunctionImprovement()

◆ computeExpectedMeritFunctionImprovement()

◆ updateMeritFunction()

◆ checkAcceptance()

◆ backwardPass()

◆ batchPass()

◆ computeActionValueFunction()

◆ computeBatchActionValueFunction()

◆ computePolicy()

◆ computeBatchPolicy()

◆ computeValueFunction()

◆ computeBatchValueFunction()

◆ linearRollout()

◆ feasShootForwardPass()

◆ multiShootForwardPass()

◆ hybridShootForwardPass()

◆ singleShootForwardPass()

◆ updateCandidate()

◆ decreaseRegularizationCriteria()

◆ increaseRegularizationCriteria()

◆ increaseRegularization()

◆ decreaseRegularization()

◆ cast()

◆ get_zero_upsilon()

◆ set_dynamics_solver()

◆ set_terminal_solver()

◆ set_zero_upsilon()

◆ resizeRunningData()

◆ resizeTerminalData()

◆ computeDynamicFeasibility()

◆ computeEqualityFeasibility()

◆ computeFeasibility()

◆ computeInequalityFeasibility()

◆ resizeData()

Member Data Documentation

◆ Scalar

◆ dyn_solver_

◆ term_solver_

◆ reg_incfactor_

◆ reg_decfactor_

◆ th_grad_

◆ th_noimprovement_

◆ th_stepdec_

◆ th_stepinc_

◆ th_minimprove_

◆ th_acceptnegstep_

◆ th_acceptminstep_

◆ rho_

◆ th_minfeas_

◆ upsilon_

◆ upsilon_decfactor_

◆ zero_upsilon_

◆ Ts_

◆ Vxx_tmp_