summaryrefslogtreecommitdiff
path: root/thirdparty/windows/include/coin/IpIpoptCalculatedQuantities.hpp
diff options
context:
space:
mode:
Diffstat (limited to 'thirdparty/windows/include/coin/IpIpoptCalculatedQuantities.hpp')
-rw-r--r--thirdparty/windows/include/coin/IpIpoptCalculatedQuantities.hpp1493
1 files changed, 751 insertions, 742 deletions
diff --git a/thirdparty/windows/include/coin/IpIpoptCalculatedQuantities.hpp b/thirdparty/windows/include/coin/IpIpoptCalculatedQuantities.hpp
index 986a299..e102308 100644
--- a/thirdparty/windows/include/coin/IpIpoptCalculatedQuantities.hpp
+++ b/thirdparty/windows/include/coin/IpIpoptCalculatedQuantities.hpp
@@ -1,742 +1,751 @@
-// 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 <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();
- /** 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);
- //@}
-
- /** @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_;
- //@}
-
- /** @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_;
- //@}
-
- /** 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
+// 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
generated by cgit (git 2.34.1) at 2024-12-22 22:14:52 +0000