diff options
Diffstat (limited to 'build/Bonmin/include/coin/IpIpoptCalculatedQuantities.hpp')
| -rw-r--r-- | build/Bonmin/include/coin/IpIpoptCalculatedQuantities.hpp | 751 |
1 files changed, 751 insertions, 0 deletions
diff --git a/build/Bonmin/include/coin/IpIpoptCalculatedQuantities.hpp b/build/Bonmin/include/coin/IpIpoptCalculatedQuantities.hpp new file mode 100644 index 0000000..3b60b16 --- /dev/null +++ b/build/Bonmin/include/coin/IpIpoptCalculatedQuantities.hpp @@ -0,0 +1,751 @@ +// 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 |