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