// Copyright (C) 2004, 2011 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Eclipse Public License.
//
// $Id: IpIpoptCalculatedQuantities.hpp 2020 2011-06-16 20:46:16Z andreasw $
//
// Authors: Carl Laird, Andreas Waechter IBM 2004-08-13
#ifndef __IPIPOPTCALCULATEDQUANTITIES_HPP__
#define __IPIPOPTCALCULATEDQUANTITIES_HPP__
#include "IpSmartPtr.hpp"
#include "IpCachedResults.hpp"
#include <string>
namespace Ipopt
{
class IpoptNLP;
class IpoptData;
class Vector;
class Matrix;
class SymMatrix;
class Journalist;
class OptionsList;
class RegisteredOptions;
/** Norm types */
enum ENormType {
NORM_1=0,
NORM_2,
NORM_MAX
};
/** Base class for additional calculated quantities that is special
* to a particular type of algorithm, such as the CG penalty
* function, or using iterative linear solvers. The regular
* IpoptCalculatedQuantities object should be given a derivation of
* this base class when it is created. */
class IpoptAdditionalCq : public ReferencedObject
{
public:
/**@name Constructors/Destructors */
//@{
/** Default Constructor */
IpoptAdditionalCq()
{}
/** Default destructor */
virtual ~IpoptAdditionalCq()
{}
//@}
/** This method is called to initialize the global algorithmic
* parameters. The parameters are taken from the OptionsList
* object. */
virtual bool Initialize(const Journalist& jnlst,
const OptionsList& options,
const std::string& prefix) = 0;
private:
/**@name 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. */
//@{
/** Copy Constructor */
IpoptAdditionalCq(const IpoptAdditionalCq&);
/** Overloaded Equals Operator */
void operator=(const IpoptAdditionalCq&);
//@}
};
/** Class for all IPOPT specific calculated quantities.
*
*/
class IpoptCalculatedQuantities : public ReferencedObject
{
public:
/**@name Constructors/Destructors */
//@{
/** Constructor */
IpoptCalculatedQuantities(const SmartPtr<IpoptNLP>& ip_nlp,
const SmartPtr<IpoptData>& ip_data);
/** Default destructor */
virtual ~IpoptCalculatedQuantities();
//@}
/** Method for setting pointer for additional calculated
* quantities. This needs to be called before Initialized. */
void SetAddCq(SmartPtr<IpoptAdditionalCq> add_cq)
{
DBG_ASSERT(!HaveAddCq());
add_cq_ = add_cq;
}
/** Method detecting if additional object for calculated
* quantities has already been set */
bool HaveAddCq()
{
return IsValid(add_cq_);
}
/** This method must be called to initialize the global
* algorithmic parameters. The parameters are taken from the
* OptionsList object. */
bool Initialize(const Journalist& jnlst,
const OptionsList& options,
const std::string& prefix);
/** @name Slacks */
//@{
/** Slacks for x_L (at current iterate) */
SmartPtr<const Vector> curr_slack_x_L();
/** Slacks for x_U (at current iterate) */
SmartPtr<const Vector> curr_slack_x_U();
/** Slacks for s_L (at current iterate) */
SmartPtr<const Vector> curr_slack_s_L();
/** Slacks for s_U (at current iterate) */
SmartPtr<const Vector> curr_slack_s_U();
/** Slacks for x_L (at trial point) */
SmartPtr<const Vector> trial_slack_x_L();
/** Slacks for x_U (at trial point) */
SmartPtr<const Vector> trial_slack_x_U();
/** Slacks for s_L (at trial point) */
SmartPtr<const Vector> trial_slack_s_L();
/** Slacks for s_U (at trial point) */
SmartPtr<const Vector> trial_slack_s_U();
/** Indicating whether or not we "fudged" the slacks */
Index AdjustedTrialSlacks();
/** Reset the flags for "fudged" slacks */
void ResetAdjustedTrialSlacks();
//@}
/** @name Objective function */
//@{
/** Value of objective function (at current point) */
virtual Number curr_f();
/** Unscaled value of the objective function (at the current point) */
virtual Number unscaled_curr_f();
/** Value of objective function (at trial point) */
virtual Number trial_f();
/** Unscaled value of the objective function (at the trial point) */
virtual Number unscaled_trial_f();
/** Gradient of objective function (at current point) */
SmartPtr<const Vector> curr_grad_f();
/** Gradient of objective function (at trial point) */
SmartPtr<const Vector> trial_grad_f();
//@}
/** @name Barrier Objective Function */
//@{
/** Barrier Objective Function Value
* (at current iterate with current mu)
*/
virtual Number curr_barrier_obj();
/** Barrier Objective Function Value
* (at trial point with current mu)
*/
virtual Number trial_barrier_obj();
/** Gradient of barrier objective function with respect to x
* (at current point with current mu) */
SmartPtr<const Vector> curr_grad_barrier_obj_x();
/** Gradient of barrier objective function with respect to s
* (at current point with current mu) */
SmartPtr<const Vector> curr_grad_barrier_obj_s();
/** Gradient of the damping term with respect to x (times
* kappa_d) */
SmartPtr<const Vector> grad_kappa_times_damping_x();
/** Gradient of the damping term with respect to s (times
* kappa_d) */
SmartPtr<const Vector> grad_kappa_times_damping_s();
//@}
/** @name Constraints */
//@{
/** c(x) (at current point) */
SmartPtr<const Vector> curr_c();
/** unscaled c(x) (at current point) */
SmartPtr<const Vector> unscaled_curr_c();
/** c(x) (at trial point) */
SmartPtr<const Vector> trial_c();
/** unscaled c(x) (at trial point) */
SmartPtr<const Vector> unscaled_trial_c();
/** d(x) (at current point) */
SmartPtr<const Vector> curr_d();
/** unscaled d(x) (at current point) */
SmartPtr<const Vector> unscaled_curr_d();
/** d(x) (at trial point) */
SmartPtr<const Vector> trial_d();
/** d(x) - s (at current point) */
SmartPtr<const Vector> curr_d_minus_s();
/** d(x) - s (at trial point) */
SmartPtr<const Vector> trial_d_minus_s();
/** Jacobian of c (at current point) */
SmartPtr<const Matrix> curr_jac_c();
/** Jacobian of c (at trial point) */
SmartPtr<const Matrix> trial_jac_c();
/** Jacobian of d (at current point) */
SmartPtr<const Matrix> curr_jac_d();
/** Jacobian of d (at trial point) */
SmartPtr<const Matrix> trial_jac_d();
/** Product of Jacobian (evaluated at current point) of C
* transpose with general vector */
SmartPtr<const Vector> curr_jac_cT_times_vec(const Vector& vec);
/** Product of Jacobian (evaluated at trial point) of C
* transpose with general vector */
SmartPtr<const Vector> trial_jac_cT_times_vec(const Vector& vec);
/** Product of Jacobian (evaluated at current point) of D
* transpose with general vector */
SmartPtr<const Vector> curr_jac_dT_times_vec(const Vector& vec);
/** Product of Jacobian (evaluated at trial point) of D
* transpose with general vector */
SmartPtr<const Vector> trial_jac_dT_times_vec(const Vector& vec);
/** Product of Jacobian (evaluated at current point) of C
* transpose with current y_c */
SmartPtr<const Vector> curr_jac_cT_times_curr_y_c();
/** Product of Jacobian (evaluated at trial point) of C
* transpose with trial y_c */
SmartPtr<const Vector> trial_jac_cT_times_trial_y_c();
/** Product of Jacobian (evaluated at current point) of D
* transpose with current y_d */
SmartPtr<const Vector> curr_jac_dT_times_curr_y_d();
/** Product of Jacobian (evaluated at trial point) of D
* transpose with trial y_d */
SmartPtr<const Vector> trial_jac_dT_times_trial_y_d();
/** Product of Jacobian (evaluated at current point) of C
* with general vector */
SmartPtr<const Vector> curr_jac_c_times_vec(const Vector& vec);
/** Product of Jacobian (evaluated at current point) of D
* with general vector */
SmartPtr<const Vector> curr_jac_d_times_vec(const Vector& vec);
/** Constraint Violation (at current iterate). This value should
* be used in the line search, and not curr_primal_infeasibility().
* What type of norm is used depends on constr_viol_normtype */
virtual Number curr_constraint_violation();
/** Constraint Violation (at trial point). This value should
* be used in the line search, and not curr_primal_infeasibility().
* What type of norm is used depends on constr_viol_normtype */
virtual Number trial_constraint_violation();
/** Real constraint violation in a given norm (at current
* iterate). This considers the inequality constraints without
* slacks. */
virtual Number curr_nlp_constraint_violation(ENormType NormType);
/** Unscaled real constraint violation in a given norm (at current
* iterate). This considers the inequality constraints without
* slacks. */
virtual Number unscaled_curr_nlp_constraint_violation(ENormType NormType);
/** Unscaled real constraint violation in a given norm (at trial
* iterate). This considers the inequality constraints without
* slacks. */
virtual Number unscaled_trial_nlp_constraint_violation(ENormType NormType);
//@}
/** @name Hessian matrices */
//@{
/** exact Hessian at current iterate (uncached) */
SmartPtr<const SymMatrix> curr_exact_hessian();
//@}
/** @name primal-dual error and its components */
//@{
/** x-part of gradient of Lagrangian function (at current point) */
SmartPtr<const Vector> curr_grad_lag_x();
/** x-part of gradient of Lagrangian function (at trial point) */
SmartPtr<const Vector> trial_grad_lag_x();
/** s-part of gradient of Lagrangian function (at current point) */
SmartPtr<const Vector> curr_grad_lag_s();
/** s-part of gradient of Lagrangian function (at trial point) */
SmartPtr<const Vector> trial_grad_lag_s();
/** x-part of gradient of Lagrangian function (at current point)
including linear damping term */
SmartPtr<const Vector> curr_grad_lag_with_damping_x();
/** s-part of gradient of Lagrangian function (at current point)
including linear damping term */
SmartPtr<const Vector> curr_grad_lag_with_damping_s();
/** Complementarity for x_L (for current iterate) */
SmartPtr<const Vector> curr_compl_x_L();
/** Complementarity for x_U (for current iterate) */
SmartPtr<const Vector> curr_compl_x_U();
/** Complementarity for s_L (for current iterate) */
SmartPtr<const Vector> curr_compl_s_L();
/** Complementarity for s_U (for current iterate) */
SmartPtr<const Vector> curr_compl_s_U();
/** Complementarity for x_L (for trial iterate) */
SmartPtr<const Vector> trial_compl_x_L();
/** Complementarity for x_U (for trial iterate) */
SmartPtr<const Vector> trial_compl_x_U();
/** Complementarity for s_L (for trial iterate) */
SmartPtr<const Vector> trial_compl_s_L();
/** Complementarity for s_U (for trial iterate) */
SmartPtr<const Vector> trial_compl_s_U();
/** Relaxed complementarity for x_L (for current iterate and current mu) */
SmartPtr<const Vector> curr_relaxed_compl_x_L();
/** Relaxed complementarity for x_U (for current iterate and current mu) */
SmartPtr<const Vector> curr_relaxed_compl_x_U();
/** Relaxed complementarity for s_L (for current iterate and current mu) */
SmartPtr<const Vector> curr_relaxed_compl_s_L();
/** Relaxed complementarity for s_U (for current iterate and current mu) */
SmartPtr<const Vector> curr_relaxed_compl_s_U();
/** Primal infeasibility in a given norm (at current iterate). */
virtual Number curr_primal_infeasibility(ENormType NormType);
/** Primal infeasibility in a given norm (at trial point) */
virtual Number trial_primal_infeasibility(ENormType NormType);
/** Dual infeasibility in a given norm (at current iterate) */
virtual Number curr_dual_infeasibility(ENormType NormType);
/** Dual infeasibility in a given norm (at trial iterate) */
virtual Number trial_dual_infeasibility(ENormType NormType);
/** Unscaled dual infeasibility in a given norm (at current iterate) */
virtual Number unscaled_curr_dual_infeasibility(ENormType NormType);
/** Complementarity (for all complementarity conditions together)
* 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 trial iterate) */
virtual Number trial_complementarity(Number mu, ENormType NormType);
/** Complementarity (for all complementarity conditions together)
* in a given norm (at current iterate) without NLP scaling. */
virtual Number unscaled_curr_complementarity(Number mu, ENormType NormType);
/** Centrality measure (in spirit of the -infinity-neighborhood. */
Number CalcCentralityMeasure(const Vector& compl_x_L,
const Vector& compl_x_U,
const Vector& compl_s_L,
const Vector& compl_s_U);
/** Centrality measure at current point */
virtual Number curr_centrality_measure();
/** 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) */
virtual Number 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. Note that here the constraint violation
* is measured without slacks (nlp_constraint_violation) */
virtual Number unscaled_curr_nlp_error();
/** Total optimality error for the barrier problem at the
* current iterate, using scaling factors based on multipliers. */
virtual Number curr_barrier_error();
/** 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.
*/
virtual Number curr_primal_dual_system_error(Number mu);
/** 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.
*/
virtual Number trial_primal_dual_system_error(Number mu);
//@}
/** @name Computing fraction-to-the-boundary step sizes */
//@{
/** Fraction to the boundary from (current) primal variables x and s
* for a given step */
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 internal (current) step */
Number curr_primal_frac_to_the_bound(Number tau);
/** Fraction to the boundary from (current) dual variables z and v
* for a given 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, without caching */
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 internal (current) step */
Number curr_dual_frac_to_the_bound(Number tau);
/** 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. */
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);
//@}
/** @name Sigma matrices */
//@{
SmartPtr<const Vector> curr_sigma_x();
SmartPtr<const Vector> curr_sigma_s();
//@}
/** average of current values of the complementarities */
Number curr_avrg_compl();
/** average of trial values of the complementarities */
Number trial_avrg_compl();
/** inner_product of current barrier obj. fn. gradient with
* current search direction */
Number curr_gradBarrTDelta();
/** Compute the norm of a specific type of a set of vectors (uncached) */
Number
CalcNormOfType(ENormType NormType,
std::vector<SmartPtr<const Vector> > vecs);
/** Compute the norm of a specific type of two vectors (uncached) */
Number
CalcNormOfType(ENormType NormType,
const Vector& vec1, const Vector& vec2);
/** Norm type used for calculating constraint violation */
ENormType constr_viol_normtype() const
{
return constr_viol_normtype_;
}
/** Method returning true if this is a square problem */
bool IsSquareProblem() const;
/** Method returning the IpoptNLP object. This should only be
* used with care! */
SmartPtr<IpoptNLP>& GetIpoptNLP()
{
return ip_nlp_;
}
IpoptAdditionalCq& AdditionalCq()
{
DBG_ASSERT(IsValid(add_cq_));
return *add_cq_;
}
/** Methods for IpoptType */
//@{
/** Called by IpoptType to register the options */
static void RegisterOptions(SmartPtr<RegisteredOptions> roptions);
//@}
private:
/**@name 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. */
//@{
/** Default Constructor */
IpoptCalculatedQuantities();
/** Copy Constructor */
IpoptCalculatedQuantities(const IpoptCalculatedQuantities&);
/** Overloaded Equals Operator */
void operator=(const IpoptCalculatedQuantities&);
//@}
/** @name Pointers for easy access to data and NLP information */
//@{
/** Ipopt NLP object */
SmartPtr<IpoptNLP> ip_nlp_;
/** Ipopt Data object */
SmartPtr<IpoptData> ip_data_;
/** Chen-Goldfarb specific calculated quantities */
SmartPtr<IpoptAdditionalCq> add_cq_;
//@}
/** @name Algorithmic Parameters that can be set throught the
* options list. Those parameters are initialize by calling the
* Initialize method.*/
//@{
/** Parameter in formula for computing overall primal-dual
* optimality error */
Number s_max_;
/** Weighting factor for the linear damping term added to the
* barrier objective funciton. */
Number kappa_d_;
/** fractional movement allowed in bounds */
Number slack_move_;
/** Norm type to be used when calculating the constraint violation */
ENormType constr_viol_normtype_;
/** Flag indicating whether the TNLP with identical structure has
* already been solved before. */
bool warm_start_same_structure_;
/** Desired value of the barrier parameter */
Number mu_target_;
//@}
/** @name 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_;
//@}
/** @name 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_;
//@}
/** @name 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_;
//@}
/** @name 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_;
//@}
/** Cache for the exact Hessian */
CachedResults< SmartPtr<const SymMatrix> > curr_exact_hessian_cache_;
/** @name 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_;
//@}
/** @name Caches for fraction to the boundary step sizes */
//@{
CachedResults<Number> primal_frac_to_the_bound_cache_;
CachedResults<Number> dual_frac_to_the_bound_cache_;
//@}
/** @name Caches for sigma matrices */
//@{
CachedResults< SmartPtr<const Vector> > curr_sigma_x_cache_;
CachedResults< SmartPtr<const Vector> > curr_sigma_s_cache_;
//@}
/** Cache for average of current complementarity */
CachedResults<Number> curr_avrg_compl_cache_;
/** Cache for average of trial complementarity */
CachedResults<Number> trial_avrg_compl_cache_;
/** Cache for grad barrier obj. fn inner product with step */
CachedResults<Number> curr_gradBarrTDelta_cache_;
/** @name Indicator vectors required for the linear damping terms
* to handle unbounded solution sets. */
//@{
/** Indicator vector for selecting the elements in x that have
* only lower bounds. */
SmartPtr<Vector> dampind_x_L_;
/** Indicator vector for selecting the elements in x that have
* only upper bounds. */
SmartPtr<Vector> dampind_x_U_;
/** Indicator vector for selecting the elements in s that have
* only lower bounds. */
SmartPtr<Vector> dampind_s_L_;
/** Indicator vector for selecting the elements in s that have
* only upper bounds. */
SmartPtr<Vector> dampind_s_U_;
//@}
/** @name Temporary vectors for intermediate calcuations. 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_;
/** Accessor methods for the temporary vectors */
Vector& Tmp_x();
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();
//@}
/** flag indicating if Initialize method has been called (for
* debugging) */
bool initialize_called_;
/** @name Auxiliary functions */
//@{
/** Compute new vector containing the slack to a lower bound
* (uncached)
*/
SmartPtr<Vector> CalcSlack_L(const Matrix& P,
const Vector& x,
const Vector& x_bound);
/** Compute new vector containing the slack to a upper bound
* (uncached)
*/
SmartPtr<Vector> CalcSlack_U(const Matrix& P,
const Vector& x,
const Vector& x_bound);
/** Compute barrier term at given point
* (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 complementarity for slack / multiplier pair */
SmartPtr<const Vector> CalcCompl(const Vector& slack,
const Vector& mult);
/** Compute fraction to the boundary parameter for lower and upper bounds */
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 the scaling factors for the optimality error. */
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);
/** Check if slacks are becoming too small. If slacks are
* becoming too small, they are change. The return value is the
* number of corrected slacks. */
Index CalculateSafeSlack(SmartPtr<Vector>& slack,
const SmartPtr<const Vector>& bound,
const SmartPtr<const Vector>& curr_point,
const SmartPtr<const Vector>& multiplier);
/** 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. */
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);
/** Check if we are in the restoration phase. Returns true, if the
* ip_nlp is of the type RestoIpoptNLP. ToDo: We probably want to
* handle this more elegant and don't have an explicit dependency
* here. Now I added this because otherwise the caching doesn't
* work properly since the restoration phase objective function
* depends on the current barrier parameter. */
bool in_restoration_phase();
//@}
};
} // namespace Ipopt
#endif