You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
751 lines
31 KiB
751 lines
31 KiB
// 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
|
|
|