Class for all IPOPT specific calculated quantities. More...

#include <IpIpoptCalculatedQuantities.hpp>

Inheritance diagram for Ipopt::IpoptCalculatedQuantities:

Public Member Functions
void	SetAddCq (SmartPtr< IpoptAdditionalCq > add_cq)
	Method for setting pointer for additional calculated quantities.

bool	HaveAddCq ()
	Method detecting if additional object for calculated quantities has already been set.

bool	Initialize (const Journalist &jnlst, const OptionsList &options, const std::string &prefix)
	This method must be called to initialize the global algorithmic parameters.

Number	curr_avrg_compl ()
	average of current values of the complementarities

Number	trial_avrg_compl ()
	average of trial values of the complementarities

Number	curr_gradBarrTDelta ()
	inner_product of current barrier obj.

Number	CalcNormOfType (ENormType NormType, std::vector< SmartPtr< const Vector > > vecs)
	Compute the norm of a specific type of a set of vectors (uncached)

Number	CalcNormOfType (ENormType NormType, const Vector &vec1, const Vector &vec2)
	Compute the norm of a specific type of two vectors (uncached)

ENormType	constr_viol_normtype () const
	Norm type used for calculating constraint violation.

bool	IsSquareProblem () const
	Method returning true if this is a square problem.

SmartPtr< IpoptNLP > &	GetIpoptNLP ()
	Method returning the IpoptNLP object.

IpoptAdditionalCq &	AdditionalCq ()

Constructors/Destructors
	IpoptCalculatedQuantities (const SmartPtr< IpoptNLP > &ip_nlp, const SmartPtr< IpoptData > &ip_data)
	Constructor.

virtual	~IpoptCalculatedQuantities ()
	Destructor.

Slacks
SmartPtr< const Vector >	curr_slack_x_L ()
	Slacks for x_L (at current iterate)

SmartPtr< const Vector >	curr_slack_x_U ()
	Slacks for x_U (at current iterate)

SmartPtr< const Vector >	curr_slack_s_L ()
	Slacks for s_L (at current iterate)

SmartPtr< const Vector >	curr_slack_s_U ()
	Slacks for s_U (at current iterate)

SmartPtr< const Vector >	trial_slack_x_L ()
	Slacks for x_L (at trial point)

SmartPtr< const Vector >	trial_slack_x_U ()
	Slacks for x_U (at trial point)

SmartPtr< const Vector >	trial_slack_s_L ()
	Slacks for s_L (at trial point)

SmartPtr< const Vector >	trial_slack_s_U ()
	Slacks for s_U (at trial point)

Index	AdjustedTrialSlacks ()
	Indicating whether or not we "fudged" the slacks.

void	ResetAdjustedTrialSlacks ()
	Reset the flags for "fudged" slacks.

Objective function
virtual Number	curr_f ()
	Value of objective function (at current point)

virtual Number	unscaled_curr_f ()
	Unscaled value of the objective function (at the current point)

virtual Number	trial_f ()
	Value of objective function (at trial point)

virtual Number	unscaled_trial_f ()
	Unscaled value of the objective function (at the trial point)

SmartPtr< const Vector >	curr_grad_f ()
	Gradient of objective function (at current point)

SmartPtr< const Vector >	trial_grad_f ()
	Gradient of objective function (at trial point)

Barrier Objective Function
virtual Number	curr_barrier_obj ()
	Barrier Objective Function Value (at current iterate with current mu)

virtual Number	trial_barrier_obj ()
	Barrier Objective Function Value (at trial point with current mu)

SmartPtr< const Vector >	curr_grad_barrier_obj_x ()
	Gradient of barrier objective function with respect to x (at current point with current mu)

SmartPtr< const Vector >	curr_grad_barrier_obj_s ()
	Gradient of barrier objective function with respect to s (at current point with current mu)

SmartPtr< const Vector >	grad_kappa_times_damping_x ()
	Gradient of the damping term with respect to x (times kappa_d)

SmartPtr< const Vector >	grad_kappa_times_damping_s ()
	Gradient of the damping term with respect to s (times kappa_d)

Constraints
SmartPtr< const Vector >	curr_c ()
	c(x) (at current point)

SmartPtr< const Vector >	unscaled_curr_c ()
	unscaled c(x) (at current point)

SmartPtr< const Vector >	trial_c ()
	c(x) (at trial point)

SmartPtr< const Vector >	unscaled_trial_c ()
	unscaled c(x) (at trial point)

SmartPtr< const Vector >	curr_d ()
	d(x) (at current point)

SmartPtr< const Vector >	unscaled_curr_d ()
	unscaled d(x) (at current point)

SmartPtr< const Vector >	trial_d ()
	d(x) (at trial point)

SmartPtr< const Vector >	curr_d_minus_s ()
	d(x) - s (at current point)

SmartPtr< const Vector >	trial_d_minus_s ()
	d(x) - s (at trial point)

SmartPtr< const Matrix >	curr_jac_c ()
	Jacobian of c (at current point)

SmartPtr< const Matrix >	trial_jac_c ()
	Jacobian of c (at trial point)

SmartPtr< const Matrix >	curr_jac_d ()
	Jacobian of d (at current point)

SmartPtr< const Matrix >	trial_jac_d ()
	Jacobian of d (at trial point)

SmartPtr< const Vector >	curr_jac_cT_times_vec (const Vector &vec)
	Product of Jacobian (evaluated at current point) of C transpose with general vector.

SmartPtr< const Vector >	trial_jac_cT_times_vec (const Vector &vec)
	Product of Jacobian (evaluated at trial point) of C transpose with general vector.

SmartPtr< const Vector >	curr_jac_dT_times_vec (const Vector &vec)
	Product of Jacobian (evaluated at current point) of D transpose with general vector.

SmartPtr< const Vector >	trial_jac_dT_times_vec (const Vector &vec)
	Product of Jacobian (evaluated at trial point) of D transpose with general vector.

SmartPtr< const Vector >	curr_jac_cT_times_curr_y_c ()
	Product of Jacobian (evaluated at current point) of C transpose with current y_c.

SmartPtr< const Vector >	trial_jac_cT_times_trial_y_c ()
	Product of Jacobian (evaluated at trial point) of C transpose with trial y_c.

SmartPtr< const Vector >	curr_jac_dT_times_curr_y_d ()
	Product of Jacobian (evaluated at current point) of D transpose with current y_d.

SmartPtr< const Vector >	trial_jac_dT_times_trial_y_d ()
	Product of Jacobian (evaluated at trial point) of D transpose with trial y_d.

SmartPtr< const Vector >	curr_jac_c_times_vec (const Vector &vec)
	Product of Jacobian (evaluated at current point) of C with general vector.

SmartPtr< const Vector >	curr_jac_d_times_vec (const Vector &vec)
	Product of Jacobian (evaluated at current point) of D with general vector.

virtual Number	curr_constraint_violation ()
	Constraint Violation (at current iterate).

virtual Number	trial_constraint_violation ()
	Constraint Violation (at trial point).

virtual Number	curr_nlp_constraint_violation (ENormType NormType)
	Real constraint violation in a given norm (at current iterate).

virtual Number	unscaled_curr_nlp_constraint_violation (ENormType NormType)
	Unscaled real constraint violation in a given norm (at current iterate).

virtual Number	unscaled_trial_nlp_constraint_violation (ENormType NormType)
	Unscaled real constraint violation in a given norm (at trial iterate).

Variable bounds
Since 3.14.0
SmartPtr< Vector >	unscaled_orig_x_L_violation (const Vector &x)
	Violation of original variable lower bounds x_L.

SmartPtr< Vector >	unscaled_orig_x_U_violation (const Vector &x)
	Violation of original variable upper bounds x_U.

SmartPtr< const Vector >	unscaled_curr_orig_x_L_violation ()
	Violation of original variable lower bounds x_L.

SmartPtr< const Vector >	unscaled_curr_orig_x_U_violation ()
	Violation of original variable upper bounds x_U.

virtual Number	unscaled_curr_orig_bounds_violation (ENormType NormType)
	Violation of (unscaled) original variable bounds.

SmartPtr< Vector >	orig_x_L_violation (const Vector &x)
	Violation of scaled original variable lower bounds x_L.

SmartPtr< Vector >	orig_x_U_violation (const Vector &x)
	Violation of scaled original variable upper bounds x_U.

SmartPtr< const Vector >	curr_orig_x_L_violation ()
	Violation of scaled original variable lower bounds x_L.

SmartPtr< const Vector >	curr_orig_x_U_violation ()
	Violation of scaled original variable upper bounds x_U.

virtual Number	curr_orig_bounds_violation (ENormType NormType)
	Violation of scaled original variable bounds.

Hessian matrices
SmartPtr< const SymMatrix >	curr_exact_hessian ()
	exact Hessian at current iterate (uncached)

primal-dual error and its components
SmartPtr< const Vector >	curr_grad_lag_x ()
	x-part of gradient of Lagrangian function (at current point)

SmartPtr< const Vector >	trial_grad_lag_x ()
	x-part of gradient of Lagrangian function (at trial point)

SmartPtr< const Vector >	curr_grad_lag_s ()
	s-part of gradient of Lagrangian function (at current point)

SmartPtr< const Vector >	trial_grad_lag_s ()
	s-part of gradient of Lagrangian function (at trial point)

SmartPtr< const Vector >	curr_grad_lag_with_damping_x ()
	x-part of gradient of Lagrangian function (at current point) including linear damping term

SmartPtr< const Vector >	curr_grad_lag_with_damping_s ()
	s-part of gradient of Lagrangian function (at current point) including linear damping term

SmartPtr< const Vector >	curr_compl_x_L ()
	Complementarity for x_L (for current iterate)

SmartPtr< const Vector >	curr_compl_x_U ()
	Complementarity for x_U (for current iterate)

SmartPtr< const Vector >	curr_compl_s_L ()
	Complementarity for s_L (for current iterate)

SmartPtr< const Vector >	curr_compl_s_U ()
	Complementarity for s_U (for current iterate)

SmartPtr< const Vector >	trial_compl_x_L ()
	Complementarity for x_L (for trial iterate)

SmartPtr< const Vector >	trial_compl_x_U ()
	Complementarity for x_U (for trial iterate)

SmartPtr< const Vector >	trial_compl_s_L ()
	Complementarity for s_L (for trial iterate)

SmartPtr< const Vector >	trial_compl_s_U ()
	Complementarity for s_U (for trial iterate)

SmartPtr< const Vector >	curr_relaxed_compl_x_L ()
	Relaxed complementarity for x_L (for current iterate and current mu)

SmartPtr< const Vector >	curr_relaxed_compl_x_U ()
	Relaxed complementarity for x_U (for current iterate and current mu)

SmartPtr< const Vector >	curr_relaxed_compl_s_L ()
	Relaxed complementarity for s_L (for current iterate and current mu)

SmartPtr< const Vector >	curr_relaxed_compl_s_U ()
	Relaxed complementarity for s_U (for current iterate and current mu)

virtual Number	curr_primal_infeasibility (ENormType NormType)
	Primal infeasibility in a given norm (at current iterate).

virtual Number	trial_primal_infeasibility (ENormType NormType)
	Primal infeasibility in a given norm (at trial point)

virtual Number	curr_dual_infeasibility (ENormType NormType)
	Dual infeasibility in a given norm (at current iterate)

virtual Number	trial_dual_infeasibility (ENormType NormType)
	Dual infeasibility in a given norm (at trial iterate)

virtual Number	unscaled_curr_dual_infeasibility (ENormType NormType)
	Unscaled dual infeasibility in a given norm (at current iterate)

virtual Number	curr_complementarity (Number mu, ENormType NormType)
	Complementarity (for all complementarity conditions together) in a given norm (at current iterate)

virtual Number	trial_complementarity (Number mu, ENormType NormType)
	Complementarity (for all complementarity conditions together) in a given norm (at trial iterate)

virtual Number	unscaled_curr_complementarity (Number mu, ENormType NormType)
	Complementarity (for all complementarity conditions together) in a given norm (at current iterate) without NLP scaling.

Number	CalcCentralityMeasure (const Vector &compl_x_L, const Vector &compl_x_U, const Vector &compl_s_L, const Vector &compl_s_U)
	Centrality measure (in spirit of the -infinity-neighborhood.

virtual Number	curr_centrality_measure ()
	Centrality measure at current point.

virtual Number	curr_nlp_error ()
	Total optimality error for the original NLP at the current iterate, using scaling factors based on multipliers.

virtual Number	unscaled_curr_nlp_error ()
	Total optimality error for the original NLP at the current iterate, but using no scaling based on multipliers, and no scaling for the NLP.

virtual Number	curr_barrier_error ()
	Total optimality error for the barrier problem at the current iterate, using scaling factors based on multipliers.

virtual Number	curr_primal_dual_system_error (Number mu)
	Norm of the primal-dual system for a given mu (at current iterate).

virtual Number	trial_primal_dual_system_error (Number mu)
	Norm of the primal-dual system for a given mu (at trial iterate).

Computing fraction-to-the-boundary step sizes
Number	primal_frac_to_the_bound (Number tau, const Vector &delta_x, const Vector &delta_s)
	Fraction to the boundary from (current) primal variables x and s for a given step.

Number	curr_primal_frac_to_the_bound (Number tau)
	Fraction to the boundary from (current) primal variables x and s for internal (current) step.

Number	dual_frac_to_the_bound (Number tau, const Vector &delta_z_L, const Vector &delta_z_U, const Vector &delta_v_L, const Vector &delta_v_U)
	Fraction to the boundary from (current) dual variables z and v for a given step.

Number	uncached_dual_frac_to_the_bound (Number tau, const Vector &delta_z_L, const Vector &delta_z_U, const Vector &delta_v_L, const Vector &delta_v_U)
	Fraction to the boundary from (current) dual variables z and v for a given step, without caching.

Number	curr_dual_frac_to_the_bound (Number tau)
	Fraction to the boundary from (current) dual variables z and v for internal (current) step.

Number	uncached_slack_frac_to_the_bound (Number tau, const Vector &delta_x_L, const Vector &delta_x_U, const Vector &delta_s_L, const Vector &delta_s_U)
	Fraction to the boundary from (current) slacks for a given step in the slacks.

Sigma matrices
SmartPtr< const Vector >	curr_sigma_x ()

SmartPtr< const Vector >	curr_sigma_s ()

Public Member Functions inherited from Ipopt::ReferencedObject
	ReferencedObject ()

virtual	~ReferencedObject ()

Index	ReferenceCount () const

void	AddRef (const Referencer *referencer) const

void	ReleaseRef (const Referencer *referencer) const

Static Public Member Functions
static void	RegisterOptions (SmartPtr< RegisteredOptions > roptions)
	Called by IpoptType to register the options.

Private Member Functions
Default Compiler Generated Methods
(Hidden to avoid implicit creation/calling). These methods are not implemented and we do not want the compiler to implement them for us, so we declare them private and do not define them. This ensures that they will not be implicitly created/called.
	IpoptCalculatedQuantities ()
	Default Constructor.

	IpoptCalculatedQuantities (const IpoptCalculatedQuantities &)
	Copy Constructor.

void	operator= (const IpoptCalculatedQuantities &)
	Default Assignment Operator.

Auxiliary functions
SmartPtr< Vector >	CalcSlack_L (const Matrix &P, const Vector &x, const Vector &x_bound)
	Compute new vector containing the slack to a lower bound (uncached)

SmartPtr< Vector >	CalcSlack_U (const Matrix &P, const Vector &x, const Vector &x_bound)
	Compute new vector containing the slack to a upper bound (uncached)

Number	CalcBarrierTerm (Number mu, const Vector &slack_x_L, const Vector &slack_x_U, const Vector &slack_s_L, const Vector &slack_s_U)
	Compute barrier term at given point (uncached)

SmartPtr< const Vector >	CalcCompl (const Vector &slack, const Vector &mult)
	Compute complementarity for slack / multiplier pair.

Number	CalcFracToBound (const Vector &slack_L, Vector &tmp_L, const Matrix &P_L, const Vector &slack_U, Vector &tmp_U, const Matrix &P_U, const Vector &delta, Number tau)
	Compute fraction to the boundary parameter for lower and upper bounds.

void	ComputeOptimalityErrorScaling (const Vector &y_c, const Vector &y_d, const Vector &z_L, const Vector &z_U, const Vector &v_L, const Vector &v_U, Number s_max, Number &s_d, Number &s_c)
	Compute the scaling factors for the optimality error.

Index	CalculateSafeSlack (SmartPtr< Vector > &slack, const SmartPtr< const Vector > &bound, const SmartPtr< const Vector > &curr_point, const SmartPtr< const Vector > &multiplier)
	Check if slacks are becoming too small.

void	ComputeDampingIndicators (SmartPtr< const Vector > &dampind_x_L, SmartPtr< const Vector > &dampind_x_U, SmartPtr< const Vector > &dampind_s_L, SmartPtr< const Vector > &dampind_s_U)
	Computes the indicator vectors that can be used to filter out those entries in the slack_... variables, that correspond to variables with only lower and upper bounds.

Private Attributes
CachedResults< SmartPtr< const SymMatrix > >	curr_exact_hessian_cache_
	Cache for the exact Hessian.

CachedResults< Number >	curr_avrg_compl_cache_
	Cache for average of current complementarity.

CachedResults< Number >	trial_avrg_compl_cache_
	Cache for average of trial complementarity.

CachedResults< Number >	curr_gradBarrTDelta_cache_
	Cache for grad barrier obj.

bool	initialize_called_
	flag indicating if Initialize method has been called (for debugging)

Pointers for easy access to data and NLP information
SmartPtr< IpoptNLP >	ip_nlp_
	Ipopt NLP object.

SmartPtr< IpoptData >	ip_data_
	Ipopt Data object.

SmartPtr< IpoptAdditionalCq >	add_cq_
	Chen-Goldfarb specific calculated quantities.

Algorithmic Parameters that can be set through the
options list. Those parameters are initialize by calling the Initialize method.
Number	s_max_
	Parameter in formula for computing overall primal-dual optimality error.

Number	kappa_d_
	Weighting factor for the linear damping term added to the barrier objective function.

Number	slack_move_
	fractional movement allowed in bounds

ENormType	constr_viol_normtype_
	Norm type to be used when calculating the constraint violation.

bool	warm_start_same_structure_
	Flag indicating whether the TNLP with identical structure has already been solved before.

Number	mu_target_
	Desired value of the barrier parameter.

Caches for slacks
CachedResults< SmartPtr< Vector > >	curr_slack_x_L_cache_

CachedResults< SmartPtr< Vector > >	curr_slack_x_U_cache_

CachedResults< SmartPtr< Vector > >	curr_slack_s_L_cache_

CachedResults< SmartPtr< Vector > >	curr_slack_s_U_cache_

CachedResults< SmartPtr< Vector > >	trial_slack_x_L_cache_

CachedResults< SmartPtr< Vector > >	trial_slack_x_U_cache_

CachedResults< SmartPtr< Vector > >	trial_slack_s_L_cache_

CachedResults< SmartPtr< Vector > >	trial_slack_s_U_cache_

Index	num_adjusted_slack_x_L_

Index	num_adjusted_slack_x_U_

Index	num_adjusted_slack_s_L_

Index	num_adjusted_slack_s_U_

Cached for objective function stuff
CachedResults< Number >	curr_f_cache_

CachedResults< Number >	trial_f_cache_

CachedResults< SmartPtr< const Vector > >	curr_grad_f_cache_

CachedResults< SmartPtr< const Vector > >	trial_grad_f_cache_

Caches for barrier function stuff
CachedResults< Number >	curr_barrier_obj_cache_

CachedResults< Number >	trial_barrier_obj_cache_

CachedResults< SmartPtr< const Vector > >	curr_grad_barrier_obj_x_cache_

CachedResults< SmartPtr< const Vector > >	curr_grad_barrier_obj_s_cache_

CachedResults< SmartPtr< const Vector > >	grad_kappa_times_damping_x_cache_

CachedResults< SmartPtr< const Vector > >	grad_kappa_times_damping_s_cache_

Caches for constraint stuff
CachedResults< SmartPtr< const Vector > >	curr_c_cache_

CachedResults< SmartPtr< const Vector > >	trial_c_cache_

CachedResults< SmartPtr< const Vector > >	curr_d_cache_

CachedResults< SmartPtr< const Vector > >	trial_d_cache_

CachedResults< SmartPtr< const Vector > >	curr_d_minus_s_cache_

CachedResults< SmartPtr< const Vector > >	trial_d_minus_s_cache_

CachedResults< SmartPtr< const Matrix > >	curr_jac_c_cache_

CachedResults< SmartPtr< const Matrix > >	trial_jac_c_cache_

CachedResults< SmartPtr< const Matrix > >	curr_jac_d_cache_

CachedResults< SmartPtr< const Matrix > >	trial_jac_d_cache_

CachedResults< SmartPtr< const Vector > >	curr_jac_cT_times_vec_cache_

CachedResults< SmartPtr< const Vector > >	trial_jac_cT_times_vec_cache_

CachedResults< SmartPtr< const Vector > >	curr_jac_dT_times_vec_cache_

CachedResults< SmartPtr< const Vector > >	trial_jac_dT_times_vec_cache_

CachedResults< SmartPtr< const Vector > >	curr_jac_c_times_vec_cache_

CachedResults< SmartPtr< const Vector > >	curr_jac_d_times_vec_cache_

CachedResults< Number >	curr_constraint_violation_cache_

CachedResults< Number >	trial_constraint_violation_cache_

CachedResults< Number >	curr_nlp_constraint_violation_cache_

CachedResults< Number >	unscaled_curr_nlp_constraint_violation_cache_

CachedResults< Number >	unscaled_trial_nlp_constraint_violation_cache_

Components of primal-dual error
CachedResults< SmartPtr< const Vector > >	curr_grad_lag_x_cache_

CachedResults< SmartPtr< const Vector > >	trial_grad_lag_x_cache_

CachedResults< SmartPtr< const Vector > >	curr_grad_lag_s_cache_

CachedResults< SmartPtr< const Vector > >	trial_grad_lag_s_cache_

CachedResults< SmartPtr< const Vector > >	curr_grad_lag_with_damping_x_cache_

CachedResults< SmartPtr< const Vector > >	curr_grad_lag_with_damping_s_cache_

CachedResults< SmartPtr< const Vector > >	curr_compl_x_L_cache_

CachedResults< SmartPtr< const Vector > >	curr_compl_x_U_cache_

CachedResults< SmartPtr< const Vector > >	curr_compl_s_L_cache_

CachedResults< SmartPtr< const Vector > >	curr_compl_s_U_cache_

CachedResults< SmartPtr< const Vector > >	trial_compl_x_L_cache_

CachedResults< SmartPtr< const Vector > >	trial_compl_x_U_cache_

CachedResults< SmartPtr< const Vector > >	trial_compl_s_L_cache_

CachedResults< SmartPtr< const Vector > >	trial_compl_s_U_cache_

CachedResults< SmartPtr< const Vector > >	curr_relaxed_compl_x_L_cache_

CachedResults< SmartPtr< const Vector > >	curr_relaxed_compl_x_U_cache_

CachedResults< SmartPtr< const Vector > >	curr_relaxed_compl_s_L_cache_

CachedResults< SmartPtr< const Vector > >	curr_relaxed_compl_s_U_cache_

CachedResults< Number >	curr_primal_infeasibility_cache_

CachedResults< Number >	trial_primal_infeasibility_cache_

CachedResults< Number >	curr_dual_infeasibility_cache_

CachedResults< Number >	trial_dual_infeasibility_cache_

CachedResults< Number >	unscaled_curr_dual_infeasibility_cache_

CachedResults< Number >	curr_complementarity_cache_

CachedResults< Number >	trial_complementarity_cache_

CachedResults< Number >	curr_centrality_measure_cache_

CachedResults< Number >	curr_nlp_error_cache_

CachedResults< Number >	unscaled_curr_nlp_error_cache_

CachedResults< Number >	curr_barrier_error_cache_

CachedResults< Number >	curr_primal_dual_system_error_cache_

CachedResults< Number >	trial_primal_dual_system_error_cache_

Caches for violation of original bounds
CachedResults< std::pair< SmartPtr< Vector >, SmartPtr< Vector > > >	unscaled_curr_orig_x_LU_viol_cache_

CachedResults< Number >	unscaled_curr_orig_bounds_viol_cache_

CachedResults< SmartPtr< Vector > >	curr_orig_x_L_viol_cache_

CachedResults< SmartPtr< Vector > >	curr_orig_x_U_viol_cache_

CachedResults< Number >	curr_orig_bounds_viol_cache_

Caches for fraction to the boundary step sizes
CachedResults< Number >	primal_frac_to_the_bound_cache_

CachedResults< Number >	dual_frac_to_the_bound_cache_

Caches for sigma matrices
CachedResults< SmartPtr< const Vector > >	curr_sigma_x_cache_

CachedResults< SmartPtr< const Vector > >	curr_sigma_s_cache_

Indicator vectors required for the linear damping terms
to handle unbounded solution sets.
SmartPtr< Vector >	dampind_x_L_
	Indicator vector for selecting the elements in x that have only lower bounds.

SmartPtr< Vector >	dampind_x_U_
	Indicator vector for selecting the elements in x that have only upper bounds.

SmartPtr< Vector >	dampind_s_L_
	Indicator vector for selecting the elements in s that have only lower bounds.

SmartPtr< Vector >	dampind_s_U_
	Indicator vector for selecting the elements in s that have only upper bounds.

Temporary vectors for intermediate calculations.
We keep these around to avoid unnecessarily many new allocations of Vectors.
SmartPtr< Vector >	tmp_x_

SmartPtr< Vector >	tmp_s_

SmartPtr< Vector >	tmp_c_

SmartPtr< Vector >	tmp_d_

SmartPtr< Vector >	tmp_x_L_

SmartPtr< Vector >	tmp_x_U_

SmartPtr< Vector >	tmp_s_L_

SmartPtr< Vector >	tmp_s_U_

Vector &	Tmp_x ()
	Accessor methods for the temporary vectors.

Vector &	Tmp_s ()

Vector &	Tmp_c ()

Vector &	Tmp_d ()

Vector &	Tmp_x_L ()

Vector &	Tmp_x_U ()

Vector &	Tmp_s_L ()

Vector &	Tmp_s_U ()

Detailed Description

Class for all IPOPT specific calculated quantities.

Definition at line 86 of file IpIpoptCalculatedQuantities.hpp.

Constructor & Destructor Documentation

◆ IpoptCalculatedQuantities() [1/3]

Ipopt::IpoptCalculatedQuantities::IpoptCalculatedQuantities	(	const SmartPtr< IpoptNLP > &	ip_nlp,
		const SmartPtr< IpoptData > &	ip_data
	)

Constructor.

◆ ~IpoptCalculatedQuantities()

virtual Ipopt::IpoptCalculatedQuantities::~IpoptCalculatedQuantities ( )

virtual

Destructor.

◆ IpoptCalculatedQuantities() [2/3]

Ipopt::IpoptCalculatedQuantities::IpoptCalculatedQuantities ( )

private

Default Constructor.

◆ IpoptCalculatedQuantities() [3/3]

Ipopt::IpoptCalculatedQuantities::IpoptCalculatedQuantities ( const IpoptCalculatedQuantities & )

private

Copy Constructor.

Member Function Documentation

◆ SetAddCq()

void Ipopt::IpoptCalculatedQuantities::SetAddCq ( SmartPtr< IpoptAdditionalCq > add_cq )

inline

Method for setting pointer for additional calculated quantities.

This needs to be called before Initialized.

Definition at line 106 of file IpIpoptCalculatedQuantities.hpp.

◆ HaveAddCq()

bool Ipopt::IpoptCalculatedQuantities::HaveAddCq ( )

inline

Method detecting if additional object for calculated quantities has already been set.

Definition at line 118 of file IpIpoptCalculatedQuantities.hpp.

◆ Initialize()

bool Ipopt::IpoptCalculatedQuantities::Initialize	(	const Journalist &	jnlst,
		const OptionsList &	options,
		const std::string &	prefix
	)

This method must be called to initialize the global algorithmic parameters.

The parameters are taken from the OptionsList object.

◆ curr_slack_x_L()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::curr_slack_x_L ( )

Slacks for x_L (at current iterate)

◆ curr_slack_x_U()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::curr_slack_x_U ( )

Slacks for x_U (at current iterate)

◆ curr_slack_s_L()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::curr_slack_s_L ( )

Slacks for s_L (at current iterate)

◆ curr_slack_s_U()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::curr_slack_s_U ( )

Slacks for s_U (at current iterate)

◆ trial_slack_x_L()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::trial_slack_x_L ( )

Slacks for x_L (at trial point)

◆ trial_slack_x_U()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::trial_slack_x_U ( )

Slacks for x_U (at trial point)

◆ trial_slack_s_L()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::trial_slack_s_L ( )

Slacks for s_L (at trial point)

◆ trial_slack_s_U()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::trial_slack_s_U ( )

Slacks for s_U (at trial point)

◆ AdjustedTrialSlacks()

Index Ipopt::IpoptCalculatedQuantities::AdjustedTrialSlacks ( )

Indicating whether or not we "fudged" the slacks.

◆ ResetAdjustedTrialSlacks()

void Ipopt::IpoptCalculatedQuantities::ResetAdjustedTrialSlacks ( )

Reset the flags for "fudged" slacks.

◆ curr_f()

virtual Number Ipopt::IpoptCalculatedQuantities::curr_f ( )

virtual

Value of objective function (at current point)

◆ unscaled_curr_f()

virtual Number Ipopt::IpoptCalculatedQuantities::unscaled_curr_f ( )

virtual

Unscaled value of the objective function (at the current point)

◆ trial_f()

virtual Number Ipopt::IpoptCalculatedQuantities::trial_f ( )

virtual

Value of objective function (at trial point)

◆ unscaled_trial_f()

virtual Number Ipopt::IpoptCalculatedQuantities::unscaled_trial_f ( )

virtual

Unscaled value of the objective function (at the trial point)

◆ curr_grad_f()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::curr_grad_f ( )

Gradient of objective function (at current point)

◆ trial_grad_f()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::trial_grad_f ( )

Gradient of objective function (at trial point)

◆ curr_barrier_obj()

virtual Number Ipopt::IpoptCalculatedQuantities::curr_barrier_obj ( )

virtual

Barrier Objective Function Value (at current iterate with current mu)

◆ trial_barrier_obj()

virtual Number Ipopt::IpoptCalculatedQuantities::trial_barrier_obj ( )

virtual

Barrier Objective Function Value (at trial point with current mu)

◆ curr_grad_barrier_obj_x()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::curr_grad_barrier_obj_x ( )

Gradient of barrier objective function with respect to x (at current point with current mu)

◆ curr_grad_barrier_obj_s()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::curr_grad_barrier_obj_s ( )

Gradient of barrier objective function with respect to s (at current point with current mu)

◆ grad_kappa_times_damping_x()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::grad_kappa_times_damping_x ( )

Gradient of the damping term with respect to x (times kappa_d)

◆ grad_kappa_times_damping_s()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::grad_kappa_times_damping_s ( )

Gradient of the damping term with respect to s (times kappa_d)

◆ curr_c()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::curr_c ( )

c(x) (at current point)

◆ unscaled_curr_c()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::unscaled_curr_c ( )

unscaled c(x) (at current point)

◆ trial_c()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::trial_c ( )

c(x) (at trial point)

◆ unscaled_trial_c()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::unscaled_trial_c ( )

unscaled c(x) (at trial point)

◆ curr_d()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::curr_d ( )

d(x) (at current point)

◆ unscaled_curr_d()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::unscaled_curr_d ( )

unscaled d(x) (at current point)

◆ trial_d()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::trial_d ( )

d(x) (at trial point)

◆ curr_d_minus_s()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::curr_d_minus_s ( )

d(x) - s (at current point)

◆ trial_d_minus_s()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::trial_d_minus_s ( )

d(x) - s (at trial point)

◆ curr_jac_c()

SmartPtr< const Matrix > Ipopt::IpoptCalculatedQuantities::curr_jac_c ( )

Jacobian of c (at current point)

◆ trial_jac_c()

SmartPtr< const Matrix > Ipopt::IpoptCalculatedQuantities::trial_jac_c ( )

Jacobian of c (at trial point)

◆ curr_jac_d()

SmartPtr< const Matrix > Ipopt::IpoptCalculatedQuantities::curr_jac_d ( )

Jacobian of d (at current point)

◆ trial_jac_d()

SmartPtr< const Matrix > Ipopt::IpoptCalculatedQuantities::trial_jac_d ( )

Jacobian of d (at trial point)

◆ curr_jac_cT_times_vec()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::curr_jac_cT_times_vec ( const Vector & vec )

Product of Jacobian (evaluated at current point) of C transpose with general vector.

◆ trial_jac_cT_times_vec()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::trial_jac_cT_times_vec ( const Vector & vec )

Product of Jacobian (evaluated at trial point) of C transpose with general vector.

◆ curr_jac_dT_times_vec()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::curr_jac_dT_times_vec ( const Vector & vec )

Product of Jacobian (evaluated at current point) of D transpose with general vector.

◆ trial_jac_dT_times_vec()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::trial_jac_dT_times_vec ( const Vector & vec )

Product of Jacobian (evaluated at trial point) of D transpose with general vector.

◆ curr_jac_cT_times_curr_y_c()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::curr_jac_cT_times_curr_y_c ( )

Product of Jacobian (evaluated at current point) of C transpose with current y_c.

◆ trial_jac_cT_times_trial_y_c()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::trial_jac_cT_times_trial_y_c ( )

Product of Jacobian (evaluated at trial point) of C transpose with trial y_c.

◆ curr_jac_dT_times_curr_y_d()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::curr_jac_dT_times_curr_y_d ( )

Product of Jacobian (evaluated at current point) of D transpose with current y_d.

◆ trial_jac_dT_times_trial_y_d()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::trial_jac_dT_times_trial_y_d ( )

Product of Jacobian (evaluated at trial point) of D transpose with trial y_d.

◆ curr_jac_c_times_vec()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::curr_jac_c_times_vec ( const Vector & vec )

Product of Jacobian (evaluated at current point) of C with general vector.

◆ curr_jac_d_times_vec()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::curr_jac_d_times_vec ( const Vector & vec )

Product of Jacobian (evaluated at current point) of D with general vector.

◆ curr_constraint_violation()

virtual Number Ipopt::IpoptCalculatedQuantities::curr_constraint_violation ( )

virtual

Constraint Violation (at current iterate).

This considers the inequality constraints with slacks, i.e., the violation of c(x) = 0, d(x) - s = 0,

This value should be used in the line search instead of curr_primal_infeasibility(). What type of norm is used depends on constr_viol_normtype

◆ trial_constraint_violation()

virtual Number Ipopt::IpoptCalculatedQuantities::trial_constraint_violation ( )

virtual

Constraint Violation (at trial point).

This considers the inequality constraints with slacks, i.e., the violation of c(x) = 0, d(x) - s = 0,

This value should be used in the line search instead of curr_primal_infeasibility(). What type of norm is used depends on constr_viol_normtype

◆ curr_nlp_constraint_violation()

virtual Number Ipopt::IpoptCalculatedQuantities::curr_nlp_constraint_violation ( ENormType NormType )

virtual

Real constraint violation in a given norm (at current iterate).

This considers the inequality constraints without slacks, i.e., the violation of c(x) = 0, d_L <= d(x) <= d_U, with scaling applied.

◆ unscaled_curr_nlp_constraint_violation()

virtual Number Ipopt::IpoptCalculatedQuantities::unscaled_curr_nlp_constraint_violation ( ENormType NormType )

virtual

Unscaled real constraint violation in a given norm (at current iterate).

This considers the inequality constraints without slacks, i.e., the violation of c(x) = 0, d_L <= d(x) <= d_U, without scaling applied.

◆ unscaled_trial_nlp_constraint_violation()

virtual Number Ipopt::IpoptCalculatedQuantities::unscaled_trial_nlp_constraint_violation ( ENormType NormType )

virtual

Unscaled real constraint violation in a given norm (at trial iterate).

This considers the inequality constraints without slacks, i.e., the violation of c(x) = 0, d_L <= d(x) <= d_U, with scaling applied.

◆ unscaled_orig_x_L_violation()

SmartPtr< Vector > Ipopt::IpoptCalculatedQuantities::unscaled_orig_x_L_violation ( const Vector & x )

Violation of original variable lower bounds x_L.

Computes violation of given unscaled solution w.r.t. OrigIpoptNLP::orig_x_L() if current NLP is a OrigIpoptNLP. If current NLP is not an original OrigIpoptNLP, returns zero vector.

Since: 3.14.0

◆ unscaled_orig_x_U_violation()

SmartPtr< Vector > Ipopt::IpoptCalculatedQuantities::unscaled_orig_x_U_violation ( const Vector & x )

Violation of original variable upper bounds x_U.

Computes violation of given unscaled solution w.r.t. OrigIpoptNLP::orig_x_U() if current NLP is a OrigIpoptNLP. If current NLP is not an original OrigIpoptNLP, returns zero vector.

Since: 3.14.0

◆ unscaled_curr_orig_x_L_violation()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::unscaled_curr_orig_x_L_violation ( )

Violation of original variable lower bounds x_L.

Computes violation of current (unscaled) solution w.r.t. OrigIpoptNLP::orig_x_L() if current NLP is a OrigIpoptNLP. If current NLP is not an original OrigIpoptNLP, returns zero vector.

Since: 3.14.0

◆ unscaled_curr_orig_x_U_violation()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::unscaled_curr_orig_x_U_violation ( )

Violation of original variable upper bounds x_U.

Computes violation of current (unscaled) solution w.r.t. OrigIpoptNLP::orig_x_U() if current NLP is a OrigIpoptNLP. If current NLP is not an original OrigIpoptNLP, returns zero vector.

Since: 3.14.0

◆ unscaled_curr_orig_bounds_violation()

virtual Number Ipopt::IpoptCalculatedQuantities::unscaled_curr_orig_bounds_violation ( ENormType NormType )

virtual

Violation of (unscaled) original variable bounds.

Norm of unscaled_curr_violation_x_L() and unscaled_curr_violation_x_U().

Since: 3.14.0

◆ orig_x_L_violation()

SmartPtr< Vector > Ipopt::IpoptCalculatedQuantities::orig_x_L_violation ( const Vector & x )

Violation of scaled original variable lower bounds x_L.

Computes violation of given scaled solution w.r.t. OrigIpoptNLP::orig_x_L() if current NLP is a OrigIpoptNLP. If current NLP is not an original OrigIpoptNLP, returns zero vector.

Since: 3.14.0

◆ orig_x_U_violation()

SmartPtr< Vector > Ipopt::IpoptCalculatedQuantities::orig_x_U_violation ( const Vector & x )

Violation of scaled original variable upper bounds x_U.

Computes violation of given scaled solution w.r.t. OrigIpoptNLP::orig_x_U() if current NLP is a OrigIpoptNLP. If current NLP is not an original OrigIpoptNLP, returns zero vector.

Since: 3.14.0

◆ curr_orig_x_L_violation()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::curr_orig_x_L_violation ( )

Violation of scaled original variable lower bounds x_L.

Computes violation of current (scaled) solution w.r.t. OrigIpoptNLP::orig_x_L() if current NLP is a OrigIpoptNLP. If current NLP is not an original OrigIpoptNLP, returns zero vector.

Since: 3.14.0

◆ curr_orig_x_U_violation()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::curr_orig_x_U_violation ( )

Violation of scaled original variable upper bounds x_U.

Computes violation of current (scaled) solution w.r.t. OrigIpoptNLP::orig_x_U() if current NLP is a OrigIpoptNLP. If current NLP is not an original OrigIpoptNLP, returns zero vector.

Since: 3.14.0

◆ curr_orig_bounds_violation()

virtual Number Ipopt::IpoptCalculatedQuantities::curr_orig_bounds_violation ( ENormType NormType )

virtual

Violation of scaled original variable bounds.

Norm of curr_violation_x_L() and curr_violation_x_U().

Since: 3.14.0

◆ curr_exact_hessian()

SmartPtr< const SymMatrix > Ipopt::IpoptCalculatedQuantities::curr_exact_hessian ( )

exact Hessian at current iterate (uncached)

◆ curr_grad_lag_x()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::curr_grad_lag_x ( )

x-part of gradient of Lagrangian function (at current point)

◆ trial_grad_lag_x()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::trial_grad_lag_x ( )

x-part of gradient of Lagrangian function (at trial point)

◆ curr_grad_lag_s()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::curr_grad_lag_s ( )

s-part of gradient of Lagrangian function (at current point)

◆ trial_grad_lag_s()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::trial_grad_lag_s ( )

s-part of gradient of Lagrangian function (at trial point)

◆ curr_grad_lag_with_damping_x()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::curr_grad_lag_with_damping_x ( )

x-part of gradient of Lagrangian function (at current point) including linear damping term

◆ curr_grad_lag_with_damping_s()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::curr_grad_lag_with_damping_s ( )

s-part of gradient of Lagrangian function (at current point) including linear damping term

◆ curr_compl_x_L()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::curr_compl_x_L ( )

Complementarity for x_L (for current iterate)

◆ curr_compl_x_U()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::curr_compl_x_U ( )

Complementarity for x_U (for current iterate)

◆ curr_compl_s_L()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::curr_compl_s_L ( )

Complementarity for s_L (for current iterate)

◆ curr_compl_s_U()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::curr_compl_s_U ( )

Complementarity for s_U (for current iterate)

◆ trial_compl_x_L()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::trial_compl_x_L ( )

Complementarity for x_L (for trial iterate)

◆ trial_compl_x_U()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::trial_compl_x_U ( )

Complementarity for x_U (for trial iterate)

◆ trial_compl_s_L()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::trial_compl_s_L ( )

Complementarity for s_L (for trial iterate)

◆ trial_compl_s_U()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::trial_compl_s_U ( )

Complementarity for s_U (for trial iterate)

◆ curr_relaxed_compl_x_L()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::curr_relaxed_compl_x_L ( )

Relaxed complementarity for x_L (for current iterate and current mu)

◆ curr_relaxed_compl_x_U()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::curr_relaxed_compl_x_U ( )

Relaxed complementarity for x_U (for current iterate and current mu)

◆ curr_relaxed_compl_s_L()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::curr_relaxed_compl_s_L ( )

Relaxed complementarity for s_L (for current iterate and current mu)

◆ curr_relaxed_compl_s_U()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::curr_relaxed_compl_s_U ( )

Relaxed complementarity for s_U (for current iterate and current mu)

◆ curr_primal_infeasibility()

virtual Number Ipopt::IpoptCalculatedQuantities::curr_primal_infeasibility ( ENormType NormType )

virtual

Primal infeasibility in a given norm (at current iterate).

◆ trial_primal_infeasibility()

virtual Number Ipopt::IpoptCalculatedQuantities::trial_primal_infeasibility ( ENormType NormType )

virtual

Primal infeasibility in a given norm (at trial point)

◆ curr_dual_infeasibility()

virtual Number Ipopt::IpoptCalculatedQuantities::curr_dual_infeasibility ( ENormType NormType )

virtual

Dual infeasibility in a given norm (at current iterate)

◆ trial_dual_infeasibility()

virtual Number Ipopt::IpoptCalculatedQuantities::trial_dual_infeasibility ( ENormType NormType )

virtual

Dual infeasibility in a given norm (at trial iterate)

◆ unscaled_curr_dual_infeasibility()

virtual Number Ipopt::IpoptCalculatedQuantities::unscaled_curr_dual_infeasibility ( ENormType NormType )

virtual

Unscaled dual infeasibility in a given norm (at current iterate)

◆ curr_complementarity()

virtual Number Ipopt::IpoptCalculatedQuantities::curr_complementarity	(	Number	mu,
		ENormType	NormType
	)

virtual

Complementarity (for all complementarity conditions together) in a given norm (at current iterate)

◆ trial_complementarity()

virtual Number Ipopt::IpoptCalculatedQuantities::trial_complementarity	(	Number	mu,
		ENormType	NormType
	)

virtual

Complementarity (for all complementarity conditions together) in a given norm (at trial iterate)

◆ unscaled_curr_complementarity()

virtual Number Ipopt::IpoptCalculatedQuantities::unscaled_curr_complementarity	(	Number	mu,
		ENormType	NormType
	)

virtual

Complementarity (for all complementarity conditions together) in a given norm (at current iterate) without NLP scaling.

◆ CalcCentralityMeasure()

Number Ipopt::IpoptCalculatedQuantities::CalcCentralityMeasure	(	const Vector &	compl_x_L,
		const Vector &	compl_x_U,
		const Vector &	compl_s_L,
		const Vector &	compl_s_U
	)

Centrality measure (in spirit of the -infinity-neighborhood.

◆ curr_centrality_measure()

virtual Number Ipopt::IpoptCalculatedQuantities::curr_centrality_measure ( )

virtual

Centrality measure at current point.

◆ curr_nlp_error()

virtual Number Ipopt::IpoptCalculatedQuantities::curr_nlp_error ( )

virtual

Total optimality error for the original NLP at the current iterate, using scaling factors based on multipliers.

Note that here the constraint violation is measured without slacks (nlp_constraint_violation)

◆ unscaled_curr_nlp_error()

virtual Number Ipopt::IpoptCalculatedQuantities::unscaled_curr_nlp_error ( )

virtual

Total optimality error for the original NLP at the current iterate, but using no scaling based on multipliers, and no scaling for the NLP.

Note that here the constraint violation is measured without slacks (nlp_constraint_violation)

◆ curr_barrier_error()

virtual Number Ipopt::IpoptCalculatedQuantities::curr_barrier_error ( )

virtual

Total optimality error for the barrier problem at the current iterate, using scaling factors based on multipliers.

◆ curr_primal_dual_system_error()

virtual Number Ipopt::IpoptCalculatedQuantities::curr_primal_dual_system_error ( Number mu )

virtual

Norm of the primal-dual system for a given mu (at current iterate).

The norm is defined as the sum of the 1-norms of dual infeasibiliy, primal infeasibility, and complementarity, all divided by the number of elements of the vectors of which the norm is taken.

◆ trial_primal_dual_system_error()

virtual Number Ipopt::IpoptCalculatedQuantities::trial_primal_dual_system_error ( Number mu )

virtual

Norm of the primal-dual system for a given mu (at trial iterate).

The norm is defined as the sum of the 1-norms of dual infeasibiliy, primal infeasibility, and complementarity, all divided by the number of elements of the vectors of which the norm is taken.

◆ primal_frac_to_the_bound()

Number Ipopt::IpoptCalculatedQuantities::primal_frac_to_the_bound	(	Number	tau,
		const Vector &	delta_x,
		const Vector &	delta_s
	)

Fraction to the boundary from (current) primal variables x and s for a given step.

◆ curr_primal_frac_to_the_bound()

Number Ipopt::IpoptCalculatedQuantities::curr_primal_frac_to_the_bound ( Number tau )

Fraction to the boundary from (current) primal variables x and s for internal (current) step.

◆ dual_frac_to_the_bound()

Number Ipopt::IpoptCalculatedQuantities::dual_frac_to_the_bound	(	Number	tau,
		const Vector &	delta_z_L,
		const Vector &	delta_z_U,
		const Vector &	delta_v_L,
		const Vector &	delta_v_U
	)

Fraction to the boundary from (current) dual variables z and v for a given step.

◆ uncached_dual_frac_to_the_bound()

Number Ipopt::IpoptCalculatedQuantities::uncached_dual_frac_to_the_bound	(	Number	tau,
		const Vector &	delta_z_L,
		const Vector &	delta_z_U,
		const Vector &	delta_v_L,
		const Vector &	delta_v_U
	)

Fraction to the boundary from (current) dual variables z and v for a given step, without caching.

◆ curr_dual_frac_to_the_bound()

Number Ipopt::IpoptCalculatedQuantities::curr_dual_frac_to_the_bound ( Number tau )

Fraction to the boundary from (current) dual variables z and v for internal (current) step.

◆ uncached_slack_frac_to_the_bound()

Number Ipopt::IpoptCalculatedQuantities::uncached_slack_frac_to_the_bound	(	Number	tau,
		const Vector &	delta_x_L,
		const Vector &	delta_x_U,
		const Vector &	delta_s_L,
		const Vector &	delta_s_U
	)

Fraction to the boundary from (current) slacks for a given step in the slacks.

Usually, one will use the primal_frac_to_the_bound method to compute the primal fraction to the boundary step size, but if it is cheaper to provide the steps in the slacks directly (e.g. when the primal step sizes are only temporary), the this method is more efficient. This method does not cache computations.

◆ curr_sigma_x()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::curr_sigma_x ( )

◆ curr_sigma_s()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::curr_sigma_s ( )

◆ curr_avrg_compl()

Number Ipopt::IpoptCalculatedQuantities::curr_avrg_compl ( )

average of current values of the complementarities

◆ trial_avrg_compl()

Number Ipopt::IpoptCalculatedQuantities::trial_avrg_compl ( )

average of trial values of the complementarities

◆ curr_gradBarrTDelta()

Number Ipopt::IpoptCalculatedQuantities::curr_gradBarrTDelta ( )

inner_product of current barrier obj.

fn. gradient with current search direction

◆ CalcNormOfType() [1/2]

Number Ipopt::IpoptCalculatedQuantities::CalcNormOfType	(	ENormType	NormType,
		std::vector< SmartPtr< const Vector > >	vecs
	)

Compute the norm of a specific type of a set of vectors (uncached)

◆ CalcNormOfType() [2/2]

Number Ipopt::IpoptCalculatedQuantities::CalcNormOfType	(	ENormType	NormType,
		const Vector &	vec1,
		const Vector &	vec2
	)

Compute the norm of a specific type of two vectors (uncached)

◆ constr_viol_normtype()

ENormType Ipopt::IpoptCalculatedQuantities::constr_viol_normtype ( ) const

inline

Norm type used for calculating constraint violation.

Definition at line 650 of file IpIpoptCalculatedQuantities.hpp.

◆ IsSquareProblem()

bool Ipopt::IpoptCalculatedQuantities::IsSquareProblem ( ) const

Method returning true if this is a square problem.

◆ GetIpoptNLP()

SmartPtr< IpoptNLP > & Ipopt::IpoptCalculatedQuantities::GetIpoptNLP ( )

inline

Method returning the IpoptNLP object.

This should only be used with care!

Definition at line 662 of file IpIpoptCalculatedQuantities.hpp.

◆ AdditionalCq()

IpoptAdditionalCq & Ipopt::IpoptCalculatedQuantities::AdditionalCq ( )

inline

Definition at line 667 of file IpIpoptCalculatedQuantities.hpp.

◆ RegisterOptions()

static void Ipopt::IpoptCalculatedQuantities::RegisterOptions ( SmartPtr< RegisteredOptions > roptions )

static

Called by IpoptType to register the options.

◆ operator=()

void Ipopt::IpoptCalculatedQuantities::operator= ( const IpoptCalculatedQuantities & )

private

Default Assignment Operator.

◆ Tmp_x()

Vector & Ipopt::IpoptCalculatedQuantities::Tmp_x ( )

private

Accessor methods for the temporary vectors.

◆ Tmp_s()

Vector & Ipopt::IpoptCalculatedQuantities::Tmp_s ( )

private

◆ Tmp_c()

Vector & Ipopt::IpoptCalculatedQuantities::Tmp_c ( )

private

◆ Tmp_d()

Vector & Ipopt::IpoptCalculatedQuantities::Tmp_d ( )

private

◆ Tmp_x_L()

Vector & Ipopt::IpoptCalculatedQuantities::Tmp_x_L ( )

private

◆ Tmp_x_U()

Vector & Ipopt::IpoptCalculatedQuantities::Tmp_x_U ( )

private

◆ Tmp_s_L()

Vector & Ipopt::IpoptCalculatedQuantities::Tmp_s_L ( )

private

◆ Tmp_s_U()

Vector & Ipopt::IpoptCalculatedQuantities::Tmp_s_U ( )

private

◆ CalcSlack_L()

SmartPtr< Vector > Ipopt::IpoptCalculatedQuantities::CalcSlack_L	(	const Matrix &	P,
		const Vector &	x,
		const Vector &	x_bound
	)

private

Compute new vector containing the slack to a lower bound (uncached)

◆ CalcSlack_U()

SmartPtr< Vector > Ipopt::IpoptCalculatedQuantities::CalcSlack_U	(	const Matrix &	P,
		const Vector &	x,
		const Vector &	x_bound
	)

private

Compute new vector containing the slack to a upper bound (uncached)

◆ CalcBarrierTerm()

Number Ipopt::IpoptCalculatedQuantities::CalcBarrierTerm	(	Number	mu,
		const Vector &	slack_x_L,
		const Vector &	slack_x_U,
		const Vector &	slack_s_L,
		const Vector &	slack_s_U
	)

private

Compute barrier term at given point (uncached)

◆ CalcCompl()

SmartPtr< const Vector > Ipopt::IpoptCalculatedQuantities::CalcCompl	(	const Vector &	slack,
		const Vector &	mult
	)

private

Compute complementarity for slack / multiplier pair.

◆ CalcFracToBound()

Number Ipopt::IpoptCalculatedQuantities::CalcFracToBound	(	const Vector &	slack_L,
		Vector &	tmp_L,
		const Matrix &	P_L,
		const Vector &	slack_U,
		Vector &	tmp_U,
		const Matrix &	P_U,
		const Vector &	delta,
		Number	tau
	)

private

Compute fraction to the boundary parameter for lower and upper bounds.

◆ ComputeOptimalityErrorScaling()

void Ipopt::IpoptCalculatedQuantities::ComputeOptimalityErrorScaling	(	const Vector &	y_c,
		const Vector &	y_d,
		const Vector &	z_L,
		const Vector &	z_U,
		const Vector &	v_L,
		const Vector &	v_U,
		Number	s_max,
		Number &	s_d,
		Number &	s_c
	)

private

Compute the scaling factors for the optimality error.

◆ CalculateSafeSlack()

Index Ipopt::IpoptCalculatedQuantities::CalculateSafeSlack	(	SmartPtr< Vector > &	slack,
		const SmartPtr< const Vector > &	bound,
		const SmartPtr< const Vector > &	curr_point,
		const SmartPtr< const Vector > &	multiplier
	)

private

Check if slacks are becoming too small.

If slacks are becoming too small, they are changed.

Returns: number of corrected slacks

◆ ComputeDampingIndicators()

void Ipopt::IpoptCalculatedQuantities::ComputeDampingIndicators	(	SmartPtr< const Vector > &	dampind_x_L,
		SmartPtr< const Vector > &	dampind_x_U,
		SmartPtr< const Vector > &	dampind_s_L,
		SmartPtr< const Vector > &	dampind_s_U
	)

private

Computes the indicator vectors that can be used to filter out those entries in the slack_... variables, that correspond to variables with only lower and upper bounds.

This is required for the linear damping term in the barrier objective function to handle unbounded solution sets.