// Copyright (C) 2004, 2008 International Business Machines and others. // All Rights Reserved. // This code is published under the Common Public License. // // $Id: IpIpoptCalculatedQuantities.hpp 1586 2009-10-27 15:55:03Z andreasw $ // // Authors: Carl Laird, Andreas Waechter IBM 2004-08-13 #ifndef __IPIPOPTCALCULATEDQUANTITIES_HPP__ #define __IPIPOPTCALCULATEDQUANTITIES_HPP__ #include "IpSmartPtr.hpp" #include "IpCachedResults.hpp" #include 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& ip_nlp, const SmartPtr& ip_data); /** Default destructor */ virtual ~IpoptCalculatedQuantities(); //@} /** Method for setting pointer for additional calculated * quantities. This needs to be called before Initialized. */ void SetAddCq(SmartPtr 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 curr_slack_x_L(); /** Slacks for x_U (at current iterate) */ SmartPtr curr_slack_x_U(); /** Slacks for s_L (at current iterate) */ SmartPtr curr_slack_s_L(); /** Slacks for s_U (at current iterate) */ SmartPtr curr_slack_s_U(); /** Slacks for x_L (at trial point) */ SmartPtr trial_slack_x_L(); /** Slacks for x_U (at trial point) */ SmartPtr trial_slack_x_U(); /** Slacks for s_L (at trial point) */ SmartPtr trial_slack_s_L(); /** Slacks for s_U (at trial point) */ SmartPtr 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 curr_grad_f(); /** Gradient of objective function (at trial point) */ SmartPtr 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 curr_grad_barrier_obj_x(); /** Gradient of barrier objective function with respect to s * (at current point with current mu) */ SmartPtr curr_grad_barrier_obj_s(); /** Gradient of the damping term with respect to x (times * kappa_d) */ SmartPtr grad_kappa_times_damping_x(); /** Gradient of the damping term with respect to s (times * kappa_d) */ SmartPtr grad_kappa_times_damping_s(); //@} /** @name Constraints */ //@{ /** c(x) (at current point) */ SmartPtr curr_c(); /** unscaled c(x) (at current point) */ SmartPtr unscaled_curr_c(); /** c(x) (at trial point) */ SmartPtr trial_c(); /** d(x) (at current point) */ SmartPtr curr_d(); /** unscaled d(x) (at current point) */ SmartPtr unscaled_curr_d(); /** d(x) (at trial point) */ SmartPtr trial_d(); /** d(x) - s (at current point) */ SmartPtr curr_d_minus_s(); /** d(x) - s (at trial point) */ SmartPtr trial_d_minus_s(); /** Jacobian of c (at current point) */ SmartPtr curr_jac_c(); /** Jacobian of c (at trial point) */ SmartPtr trial_jac_c(); /** Jacobian of d (at current point) */ SmartPtr curr_jac_d(); /** Jacobian of d (at trial point) */ SmartPtr trial_jac_d(); /** Product of Jacobian (evaluated at current point) of C * transpose with general vector */ SmartPtr curr_jac_cT_times_vec(const Vector& vec); /** Product of Jacobian (evaluated at trial point) of C * transpose with general vector */ SmartPtr trial_jac_cT_times_vec(const Vector& vec); /** Product of Jacobian (evaluated at current point) of D * transpose with general vector */ SmartPtr curr_jac_dT_times_vec(const Vector& vec); /** Product of Jacobian (evaluated at trial point) of D * transpose with general vector */ SmartPtr trial_jac_dT_times_vec(const Vector& vec); /** Product of Jacobian (evaluated at current point) of C * transpose with current y_c */ SmartPtr curr_jac_cT_times_curr_y_c(); /** Product of Jacobian (evaluated at trial point) of C * transpose with trial y_c */ SmartPtr trial_jac_cT_times_trial_y_c(); /** Product of Jacobian (evaluated at current point) of D * transpose with current y_d */ SmartPtr curr_jac_dT_times_curr_y_d(); /** Product of Jacobian (evaluated at trial point) of D * transpose with trial y_d */ SmartPtr trial_jac_dT_times_trial_y_d(); /** Product of Jacobian (evaluated at current point) of C * with general vector */ SmartPtr curr_jac_c_times_vec(const Vector& vec); /** Product of Jacobian (evaluated at current point) of D * with general vector */ SmartPtr 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); //@} /** @name Hessian matrices */ //@{ /** exact Hessian at current iterate (uncached) */ SmartPtr curr_exact_hessian(); //@} /** @name primal-dual error and its components */ //@{ /** x-part of gradient of Lagrangian function (at current point) */ SmartPtr curr_grad_lag_x(); /** x-part of gradient of Lagrangian function (at trial point) */ SmartPtr trial_grad_lag_x(); /** s-part of gradient of Lagrangian function (at current point) */ SmartPtr curr_grad_lag_s(); /** s-part of gradient of Lagrangian function (at trial point) */ SmartPtr trial_grad_lag_s(); /** x-part of gradient of Lagrangian function (at current point) including linear damping term */ SmartPtr curr_grad_lag_with_damping_x(); /** s-part of gradient of Lagrangian function (at current point) including linear damping term */ SmartPtr curr_grad_lag_with_damping_s(); /** Complementarity for x_L (for current iterate) */ SmartPtr curr_compl_x_L(); /** Complementarity for x_U (for current iterate) */ SmartPtr curr_compl_x_U(); /** Complementarity for s_L (for current iterate) */ SmartPtr curr_compl_s_L(); /** Complementarity for s_U (for current iterate) */ SmartPtr curr_compl_s_U(); /** Complementarity for x_L (for trial iterate) */ SmartPtr trial_compl_x_L(); /** Complementarity for x_U (for trial iterate) */ SmartPtr trial_compl_x_U(); /** Complementarity for s_L (for trial iterate) */ SmartPtr trial_compl_s_L(); /** Complementarity for s_U (for trial iterate) */ SmartPtr trial_compl_s_U(); /** Relaxed complementarity for x_L (for current iterate and current mu) */ SmartPtr curr_relaxed_compl_x_L(); /** Relaxed complementarity for x_U (for current iterate and current mu) */ SmartPtr curr_relaxed_compl_x_U(); /** Relaxed complementarity for s_L (for current iterate and current mu) */ SmartPtr curr_relaxed_compl_s_L(); /** Relaxed complementarity for s_U (for current iterate and current mu) */ SmartPtr 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 curr_sigma_x(); SmartPtr 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 > 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& 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 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 ip_nlp_; /** Ipopt Data object */ SmartPtr ip_data_; /** Chen-Goldfarb specific calculated quantities */ SmartPtr 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_; //@} /** @name Caches for slacks */ //@{ CachedResults< SmartPtr > curr_slack_x_L_cache_; CachedResults< SmartPtr > curr_slack_x_U_cache_; CachedResults< SmartPtr > curr_slack_s_L_cache_; CachedResults< SmartPtr > curr_slack_s_U_cache_; CachedResults< SmartPtr > trial_slack_x_L_cache_; CachedResults< SmartPtr > trial_slack_x_U_cache_; CachedResults< SmartPtr > trial_slack_s_L_cache_; CachedResults< SmartPtr > 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 curr_f_cache_; CachedResults trial_f_cache_; CachedResults< SmartPtr > curr_grad_f_cache_; CachedResults< SmartPtr > trial_grad_f_cache_; //@} /** @name Caches for barrier function stuff */ //@{ CachedResults curr_barrier_obj_cache_; CachedResults trial_barrier_obj_cache_; CachedResults< SmartPtr > curr_grad_barrier_obj_x_cache_; CachedResults< SmartPtr > curr_grad_barrier_obj_s_cache_; CachedResults< SmartPtr > grad_kappa_times_damping_x_cache_; CachedResults< SmartPtr > grad_kappa_times_damping_s_cache_; //@} /** @name Caches for constraint stuff */ //@{ CachedResults< SmartPtr > curr_c_cache_; CachedResults< SmartPtr > trial_c_cache_; CachedResults< SmartPtr > curr_d_cache_; CachedResults< SmartPtr > trial_d_cache_; CachedResults< SmartPtr > curr_d_minus_s_cache_; CachedResults< SmartPtr > trial_d_minus_s_cache_; CachedResults< SmartPtr > curr_jac_c_cache_; CachedResults< SmartPtr > trial_jac_c_cache_; CachedResults< SmartPtr > curr_jac_d_cache_; CachedResults< SmartPtr > trial_jac_d_cache_; CachedResults< SmartPtr > curr_jac_cT_times_vec_cache_; CachedResults< SmartPtr > trial_jac_cT_times_vec_cache_; CachedResults< SmartPtr > curr_jac_dT_times_vec_cache_; CachedResults< SmartPtr > trial_jac_dT_times_vec_cache_; CachedResults< SmartPtr > curr_jac_c_times_vec_cache_; CachedResults< SmartPtr > curr_jac_d_times_vec_cache_; CachedResults curr_constraint_violation_cache_; CachedResults trial_constraint_violation_cache_; CachedResults curr_nlp_constraint_violation_cache_; CachedResults unscaled_curr_nlp_constraint_violation_cache_; //@} /** Cache for the exact Hessian */ CachedResults< SmartPtr > curr_exact_hessian_cache_; /** @name Components of primal-dual error */ //@{ CachedResults< SmartPtr > curr_grad_lag_x_cache_; CachedResults< SmartPtr > trial_grad_lag_x_cache_; CachedResults< SmartPtr > curr_grad_lag_s_cache_; CachedResults< SmartPtr > trial_grad_lag_s_cache_; CachedResults< SmartPtr > curr_grad_lag_with_damping_x_cache_; CachedResults< SmartPtr > curr_grad_lag_with_damping_s_cache_; CachedResults< SmartPtr > curr_compl_x_L_cache_; CachedResults< SmartPtr > curr_compl_x_U_cache_; CachedResults< SmartPtr > curr_compl_s_L_cache_; CachedResults< SmartPtr > curr_compl_s_U_cache_; CachedResults< SmartPtr > trial_compl_x_L_cache_; CachedResults< SmartPtr > trial_compl_x_U_cache_; CachedResults< SmartPtr > trial_compl_s_L_cache_; CachedResults< SmartPtr > trial_compl_s_U_cache_; CachedResults< SmartPtr > curr_relaxed_compl_x_L_cache_; CachedResults< SmartPtr > curr_relaxed_compl_x_U_cache_; CachedResults< SmartPtr > curr_relaxed_compl_s_L_cache_; CachedResults< SmartPtr > curr_relaxed_compl_s_U_cache_; CachedResults curr_primal_infeasibility_cache_; CachedResults trial_primal_infeasibility_cache_; CachedResults curr_dual_infeasibility_cache_; CachedResults trial_dual_infeasibility_cache_; CachedResults unscaled_curr_dual_infeasibility_cache_; CachedResults curr_complementarity_cache_; CachedResults trial_complementarity_cache_; CachedResults curr_centrality_measure_cache_; CachedResults curr_nlp_error_cache_; CachedResults unscaled_curr_nlp_error_cache_; CachedResults curr_barrier_error_cache_; CachedResults curr_primal_dual_system_error_cache_; CachedResults trial_primal_dual_system_error_cache_; //@} /** @name Caches for fraction to the boundary step sizes */ //@{ CachedResults primal_frac_to_the_bound_cache_; CachedResults dual_frac_to_the_bound_cache_; //@} /** @name Caches for sigma matrices */ //@{ CachedResults< SmartPtr > curr_sigma_x_cache_; CachedResults< SmartPtr > curr_sigma_s_cache_; //@} /** Cache for average of current complementarity */ CachedResults curr_avrg_compl_cache_; /** Cache for average of trial complementarity */ CachedResults trial_avrg_compl_cache_; /** Cache for grad barrier obj. fn inner product with step */ CachedResults 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 dampind_x_L_; /** Indicator vector for selecting the elements in x that have * only upper bounds. */ SmartPtr dampind_x_U_; /** Indicator vector for selecting the elements in s that have * only lower bounds. */ SmartPtr dampind_s_L_; /** Indicator vector for selecting the elements in s that have * only upper bounds. */ SmartPtr dampind_s_U_; //@} /** @name Temporary vectors for intermediate calcuations. We keep * these around to avoid unnecessarily many new allocations of * Vectors. */ //@{ SmartPtr tmp_x_; SmartPtr tmp_s_; SmartPtr tmp_c_; SmartPtr tmp_d_; SmartPtr tmp_x_L_; SmartPtr tmp_x_U_; SmartPtr tmp_s_L_; SmartPtr 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 CalcSlack_L(const Matrix& P, const Vector& x, const Vector& x_bound); /** Compute new vector containing the slack to a upper bound * (uncached) */ SmartPtr 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 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& slack, const SmartPtr& bound, const SmartPtr& curr_point, const SmartPtr& 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& dampind_x_L, SmartPtr& dampind_x_U, SmartPtr& dampind_s_L, SmartPtr& 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