cbcintlinprog added

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