Crocoddyl
Loading...
Searching...
No Matches
SolverKKTTpl< _Scalar > Class Template Reference
Inheritance diagram for SolverKKTTpl< _Scalar >:
SolverAbstractTpl< _Scalar >SolverBase

Public Types

typedef ShootingProblem::ActionDataAbstract ActionDataAbstract
typedef ShootingProblem::ActionModelAbstract ActionModelAbstract
typedef CallbackAbstractTpl< Scalar > CallbackAbstract
typedef MathBaseTpl< Scalar > MathBase
typedef MathBase::MatrixXs MatrixXs
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

 SolverKKTTpl (std::shared_ptr< ShootingProblem > problem)
template<typename NewScalar>
SolverKKTTpl< NewScalar > cast () const
 Cast the KKT solver to a different scalar type.
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)$.
virtual Vector3s expectedImprovement () override
 Return the expected improvement $dV_{exp}$ from a given current search direction $(\delta\mathbf{x}^k,\delta\mathbf{u}^k)$.
const std::vector< VectorXs > & get_dus () const
const std::vector< VectorXs > & get_dxs () const
const MatrixXs & get_kkt () const
const VectorXs & get_kktref () const
const std::vector< VectorXs > & get_lambdas () const
std::size_t get_ndx () const
std::size_t get_nu () const
std::size_t get_nx () const
const VectorXs & get_primaldual () const
void set_alphas (const std::vector< Scalar > &alphas)
 Modify the set of step lengths using by the line-search procedure.
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_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_grad (const Scalar th_grad)
 Modify the tolerance of the expected gradient used for testing the step.
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 regInit=1e-9) override
 Compute the optimal trajectory $\mathbf{x}^*_s,\mathbf{u}^*_s$ as lists of $T+1$ and $T$ terms.
virtual Scalar stoppingCriteria () override
 Return a positive value that quantifies the algorithm termination.
virtual Scalar tryStep (const Scalar steplength=Scalar(1.)) override
 Try a predefined step length $\alpha$ and compute its cost improvement $dV$ and merit improvement $d\Phi$.
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.
virtual bool checkAcceptance ()
 Check if we should accept or not the step.
virtual void computeCandidate (const Scalar steplength=Scalar(1.))
 Compute new candidate solution using step length.
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.
virtual void computeExpectedMeritFunctionImprovement ()
 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 ()
 Compute the merit function improvement for the current step.
Scalar computeStateFeasibility (const std::vector< VectorXs > &xs)
 Compute the state box-constraint feasibility from a given state trajectory.
virtual void decreaseRegularization ()
 Decrease the state and control regularization values by a regfactor_ factor.
virtual bool decreaseRegularizationCriteria ()
 Criteria used to decrease regularization.
 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.
virtual void increaseRegularization ()
 Increase the state and control regularization values by a regfactor_ factor.
virtual bool increaseRegularizationCriteria ()
 Criteria used to increase regularization.
virtual void resizeData ()
 Resizing the solver data.
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 updateCandidate ()
 Update the candidate solution: cost, feasibilities, and merit value.
virtual void updateMeritFunction ()
 Update the merit function value for the current guess.

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 ()
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"
virtual void resizeRunningData ()
 Resize data associated with the running models of the shooting problem.
virtual void resizeTerminalData ()
 Resize data associated with the terminal model of the shooting problem.

Protected Attributes

std::vector< Scalar > alphas_
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 dreg_
 Current dual-variable regularization value.
Vector3s DV_
 LQ approximation of the expected improvement.
Scalar dV_
 Reduction in the cost function computed by tryStep().
Scalar dVexp_
bool is_feasible_
 Label that indicates is the iteration is feasible.
std::size_t iter_
 Number of iteration performed by the solver.
Scalar preg_
 Current primal-variable regularization value.
std::shared_ptr< ShootingProblem > problem_
 optimal control problem
Scalar reg_decfactor_
Scalar reg_incfactor_
Scalar reg_max_
Scalar reg_min_
Scalar steplength_
 Current applied step length.
Scalar stop_
 Value computed by stoppingCriteria().
Scalar th_acceptstep_
 Threshold used for accepting step.
Scalar th_grad_
Scalar th_stop_
 Tolerance for stopping the algorithm.
std::vector< VectorXs > us_
 Control trajectory.
std::vector< VectorXs > us_try_
 Control trajectory computed by line-search procedure.
bool was_feasible_
std::vector< VectorXs > xs_
 State trajectory.
std::vector< VectorXs > xs_try_
 State trajectory computed by line-search procedure.
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::SolverKKTTpl< _Scalar >

Definition at line 19 of file kkt.hpp.

Member Typedef Documentation

◆ SolverAbstract

template<typename _Scalar>
typedef SolverAbstractTpl<Scalar> SolverAbstract

Definition at line 25 of file kkt.hpp.

◆ ShootingProblem

template<typename _Scalar>
typedef ShootingProblemTpl<Scalar> ShootingProblem

Definition at line 26 of file kkt.hpp.

◆ ActionModelAbstract

template<typename _Scalar>
typedef ShootingProblem::ActionModelAbstract ActionModelAbstract

Definition at line 27 of file kkt.hpp.

◆ ActionDataAbstract

template<typename _Scalar>
typedef ShootingProblem::ActionDataAbstract ActionDataAbstract

Definition at line 28 of file kkt.hpp.

◆ CallbackAbstract

template<typename _Scalar>
typedef CallbackAbstractTpl<Scalar> CallbackAbstract

Definition at line 29 of file kkt.hpp.

◆ MathBase

template<typename _Scalar>
typedef MathBaseTpl<Scalar> MathBase

Definition at line 30 of file kkt.hpp.

◆ VectorXs

template<typename _Scalar>
typedef MathBase::VectorXs VectorXs

Definition at line 31 of file kkt.hpp.

◆ MatrixXs

template<typename _Scalar>
typedef MathBase::MatrixXs MatrixXs

Definition at line 32 of file kkt.hpp.

◆ Vector3s

template<typename _Scalar>
typedef MathBase::Vector3s Vector3s

Definition at line 33 of file kkt.hpp.

Member Function Documentation

◆ solve()

template<typename _Scalar>
virtual bool solve(const std::vector< VectorXs > &init_xs = DefaultVector< Scalar >::value,
const std::vector< VectorXs > &init_us = DefaultVector< Scalar >::value,
const std::size_tmaxiter = 100,
const boolis_feasible = false,
const Scalarreg_init = 1e-9 )
overridevirtual

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 over computeDirection() and tryStep() until stoppingCriteria() is below threshold. It also describes the globalization strategy used during the numerical optimization.

Parameters
[in]init_xsinitial guess for state trajectory with $T+1$ elements (default [])
[in]init_usinitial guess for control trajectory with $T$ elements (default [])
[in]maxitermaximum allowed number of iterations (default 100)
[in]is_feasibletrue if the init_xs are obtained from integrating the init_us (rollout) (default false)
[in]init_reginitial 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.

Reimplemented from SolverAbstractTpl< _Scalar >.

◆ computeDirection()

template<typename _Scalar>
virtual void computeDirection(const boolrecalc = 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)$.

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. When recalc is true (the default in the provided algorithms), the method refreshes the linearization by calling calcDir() before running the backward pass. Setting recalc to false reuses the most recent derivatives, which is useful when calcDir() has already been triggered explicitly. The resulting state and control variations, together with the dynamics multipliers, are stored in the solver data structures (e.g., dxs_, dus_, and lambdas_).

Parameters
[in]recalctrue to refresh the derivatives before computing the search direction

Implements SolverAbstractTpl< _Scalar >.

◆ tryStep()

template<typename _Scalar>
virtual Scalar tryStep(const Scalarsteplength = Scalar(1.))
overridevirtual

Try a predefined step length $\alpha$ and compute its cost improvement $dV$ and merit improvement $d\Phi$.

It uses the search direction found by computeDirection() to try a determined step length $\alpha$. Therefore, it assumes that we have run computeDirection() first. Additionally, it returns the cost improvement $dV$ along the predefined step length $\alpha$. Internally, it updates the cost improvement $dV$ and merit improvement $d\Phi$.

Parameters
[in]steplengthapplied step length ( $0\leq\alpha\leq1$, with 1 as default)
Returns
the cost improvement

Reimplemented from SolverAbstractTpl< _Scalar >.

◆ stoppingCriteria()

template<typename _Scalar>
virtual Scalar stoppingCriteria()
overridevirtual

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 by tryStep().

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

For computing the expected improvement, you need to compute the search direction first via computeDirection(). The quadratic improvement model is described as dV = DV_0 + DV_1 + 0.5 * DV_2, where DV_0, DV_1, and DV_2 are the constant, linear, and quadratic terms, respectively.

Implements SolverAbstractTpl< _Scalar >.

◆ cast()

template<typename _Scalar>
template<typename NewScalar>
SolverKKTTpl< NewScalar > cast()const

Cast the KKT solver to a different scalar type.

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

Template Parameters
NewScalarThe new scalar type to cast to.
Returns
SolverKKTTpl<NewScalar> A KKT solver with the new scalar type.

◆ setCandidate()

template<typename _Scalar>
virtual void setCandidate(const std::vector< VectorXs > &xs_warm = DefaultVector<Scalar>::value,
const std::vector< VectorXs > &us_warm = DefaultVector<Scalar>::value,
const boolis_feasible = false )
virtual

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. Updating the candidate invalidates any previously computed linearization; the next call to computeDirection() will therefore refresh the derivatives on demand.

Parameters
[in]xsstate trajectory of $T+1$ elements (default [])
[in]uscontrol trajectory of $T$ elements (default [])
[in]isFeasibletrue if the xs are obtained from integrating the us (rollout)

Reimplemented from SolverAbstractTpl< _Scalar >.

Member Data Documentation

◆ Scalar

template<typename _Scalar>
EIGEN_MAKE_ALIGNED_OPERATOR_NEW typedef _Scalar Scalar

Definition at line 24 of file kkt.hpp.

◆ reg_incfactor_

template<typename _Scalar>
Scalar reg_incfactor_
protected

Definition at line 123 of file kkt.hpp.

◆ reg_decfactor_

template<typename _Scalar>
Scalar reg_decfactor_
protected

Definition at line 124 of file kkt.hpp.

◆ reg_min_

template<typename _Scalar>
Scalar reg_min_
protected

Definition at line 125 of file kkt.hpp.

◆ reg_max_

template<typename _Scalar>
Scalar reg_max_
protected

Definition at line 126 of file kkt.hpp.

◆ alphas_

template<typename _Scalar>
std::vector<Scalar> alphas_
protected

Definition at line 127 of file kkt.hpp.

◆ th_grad_

template<typename _Scalar>
Scalar th_grad_
protected

Definition at line 128 of file kkt.hpp.

◆ was_feasible_

template<typename _Scalar>
bool was_feasible_
protected

Definition at line 129 of file kkt.hpp.

◆ callbacks_

template<typename _Scalar>
std::vector<std::shared_ptr<CallbackAbstract> > callbacks_
protected

Callback functions.

Definition at line 700 of file solver-base.hpp.

◆ cost_

template<typename _Scalar>
Scalar cost_
protected

Cost for the current guess.

Definition at line 727 of file solver-base.hpp.

◆ cost_try_

template<typename _Scalar>
Scalar cost_try_
protected

Total cost computed by line-search procedure.

Definition at line 728 of file solver-base.hpp.

◆ dreg_

template<typename _Scalar>
Scalar dreg_
protected

Current dual-variable regularization value.

Definition at line 757 of file solver-base.hpp.

◆ DV_

template<typename _Scalar>
Vector3s DV_
protected

LQ approximation of the expected improvement.

Definition at line 732 of file solver-base.hpp.

◆ dV_

template<typename _Scalar>
Scalar dV_
protected

Reduction in the cost function computed by tryStep().

Definition at line 733 of file solver-base.hpp.

◆ dVexp_

template<typename _Scalar>
Scalar dVexp_
protected

Expected reduction in the cost function for the selected step length

Definition at line 737 of file solver-base.hpp.

◆ is_feasible_

template<typename _Scalar>
bool is_feasible_
protected

Label that indicates is the iteration is feasible.

Definition at line 724 of file solver-base.hpp.

◆ iter_

template<typename _Scalar>
std::size_t iter_
protected

Number of iteration performed by the solver.

Definition at line 731 of file solver-base.hpp.

◆ preg_

template<typename _Scalar>
Scalar preg_
protected

Current primal-variable regularization value.

Definition at line 756 of file solver-base.hpp.

◆ problem_

template<typename _Scalar>
std::shared_ptr<ShootingProblem> problem_
protected

optimal control problem

Definition at line 698 of file solver-base.hpp.

◆ steplength_

template<typename _Scalar>
Scalar steplength_
protected

Current applied step length.

Definition at line 764 of file solver-base.hpp.

◆ stop_

template<typename _Scalar>
Scalar stop_
protected

Value computed by stoppingCriteria().

Definition at line 730 of file solver-base.hpp.

◆ th_acceptstep_

template<typename _Scalar>
Scalar th_acceptstep_
protected

Threshold used for accepting step.

Definition at line 703 of file solver-base.hpp.

◆ th_stop_

template<typename _Scalar>
Scalar th_stop_
protected

Tolerance for stopping the algorithm.

Definition at line 704 of file solver-base.hpp.

◆ us_

template<typename _Scalar>
std::vector<VectorXs> us_
protected

Control trajectory.

Definition at line 714 of file solver-base.hpp.

◆ us_try_

template<typename _Scalar>
std::vector<VectorXs> us_try_
protected

Control trajectory computed by line-search procedure.

Definition at line 719 of file solver-base.hpp.

◆ xs_

template<typename _Scalar>
std::vector<VectorXs> xs_
protected

State trajectory.

Definition at line 713 of file solver-base.hpp.

◆ xs_try_

template<typename _Scalar>
std::vector<VectorXs> xs_try_
protected

State trajectory computed by line-search procedure.

Definition at line 717 of file solver-base.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/kkt.hpp