IpIpoptCalculatedQuantities.hpp

Go to the documentation of this file.

// Copyright (C) 2004, 2011 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Eclipse Public License.
//
// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
 
#ifndef __IPIPOPTCALCULATEDQUANTITIES_HPP__
#define __IPIPOPTCALCULATEDQUANTITIES_HPP__
 
#include "IpSmartPtr.hpp"
#include "IpCachedResults.hpp"
#include "IpIpoptData.hpp"
#include "IpSymMatrix.hpp"
#include "IpRegOptions.hpp"
 
#include <string>
 
namespace Ipopt
{
class IpoptNLP;
class Journalist;
class OptionsList;
 
enum ENormType
{
   NORM_1 = 0,
   NORM_2,
   NORM_MAX
};
 
class IPOPTLIB_EXPORT IpoptAdditionalCq: public ReferencedObject
{
public:
 
   IpoptAdditionalCq()
   { }
 
   virtual ~IpoptAdditionalCq()
   { }
 
   virtual bool Initialize(
      const Journalist&  jnlst,
      const OptionsList& options,
      const std::string& prefix
   ) = 0;
 
private:
 
   IpoptAdditionalCq(
      const IpoptAdditionalCq&);
 
   void operator=(
      const IpoptAdditionalCq&);
};
 
class IPOPTLIB_EXPORT IpoptCalculatedQuantities: public ReferencedObject
{
public:
 
 
   IpoptCalculatedQuantities(
      const SmartPtr<IpoptNLP>&  ip_nlp,
      const SmartPtr<IpoptData>& ip_data
   );
   virtual ~IpoptCalculatedQuantities();
 
   void SetAddCq(
      SmartPtr<IpoptAdditionalCq> add_cq
   )
   {
      // cppcheck-suppress assertWithSideEffect
      DBG_ASSERT(!HaveAddCq());
      add_cq_ = add_cq;
   }
 
   bool HaveAddCq()
   {
      return IsValid(add_cq_);
   }
 
   bool Initialize(
      const Journalist&  jnlst,
      const OptionsList& options,
      const std::string& prefix
   );
 
 
   SmartPtr<const Vector> curr_slack_x_L();
   SmartPtr<const Vector> curr_slack_x_U();
   SmartPtr<const Vector> curr_slack_s_L();
   SmartPtr<const Vector> curr_slack_s_U();
   SmartPtr<const Vector> trial_slack_x_L();
   SmartPtr<const Vector> trial_slack_x_U();
   SmartPtr<const Vector> trial_slack_s_L();
   SmartPtr<const Vector> trial_slack_s_U();
   Index AdjustedTrialSlacks();
   void ResetAdjustedTrialSlacks();
 
 
   virtual Number curr_f();
   virtual Number unscaled_curr_f();
   virtual Number trial_f();
   virtual Number unscaled_trial_f();
   SmartPtr<const Vector> curr_grad_f();
   SmartPtr<const Vector> trial_grad_f();
 
 
   virtual Number curr_barrier_obj();
   virtual Number trial_barrier_obj();
 
   SmartPtr<const Vector> curr_grad_barrier_obj_x();
   SmartPtr<const Vector> curr_grad_barrier_obj_s();
 
   SmartPtr<const Vector> grad_kappa_times_damping_x();
   SmartPtr<const Vector> grad_kappa_times_damping_s();
 
 
   SmartPtr<const Vector> curr_c();
   SmartPtr<const Vector> unscaled_curr_c();
   SmartPtr<const Vector> trial_c();
   SmartPtr<const Vector> unscaled_trial_c();
   SmartPtr<const Vector> curr_d();
   SmartPtr<const Vector> unscaled_curr_d();
   SmartPtr<const Vector> trial_d();
   SmartPtr<const Vector> curr_d_minus_s();
   SmartPtr<const Vector> trial_d_minus_s();
   SmartPtr<const Matrix> curr_jac_c();
   SmartPtr<const Matrix> trial_jac_c();
   SmartPtr<const Matrix> curr_jac_d();
   SmartPtr<const Matrix> trial_jac_d();
   SmartPtr<const Vector> curr_jac_cT_times_vec(
      const Vector& vec
   );
   SmartPtr<const Vector> trial_jac_cT_times_vec(
      const Vector& vec
   );
   SmartPtr<const Vector> curr_jac_dT_times_vec(
      const Vector& vec
   );
   SmartPtr<const Vector> trial_jac_dT_times_vec(
      const Vector& vec
   );
   SmartPtr<const Vector> curr_jac_cT_times_curr_y_c();
   SmartPtr<const Vector> trial_jac_cT_times_trial_y_c();
   SmartPtr<const Vector> curr_jac_dT_times_curr_y_d();
   SmartPtr<const Vector> trial_jac_dT_times_trial_y_d();
   SmartPtr<const Vector> curr_jac_c_times_vec(
      const Vector& vec
   );
   SmartPtr<const Vector> curr_jac_d_times_vec(
      const Vector& vec
   );
   virtual Number curr_constraint_violation();
   virtual Number trial_constraint_violation();
   virtual Number curr_nlp_constraint_violation(
      ENormType NormType
   );
   virtual Number unscaled_curr_nlp_constraint_violation(
      ENormType NormType
   );
   virtual Number unscaled_trial_nlp_constraint_violation(
      ENormType NormType
   );
 
 
   SmartPtr<Vector> unscaled_orig_x_L_violation(
      const Vector& x
   );
   SmartPtr<Vector> unscaled_orig_x_U_violation(
      const Vector& x
   );
   SmartPtr<const Vector> unscaled_curr_orig_x_L_violation();
   SmartPtr<const Vector> unscaled_curr_orig_x_U_violation();
   virtual Number unscaled_curr_orig_bounds_violation(
      ENormType NormType
   );
 
   SmartPtr<Vector> orig_x_L_violation(
      const Vector& x
   );
   SmartPtr<Vector> orig_x_U_violation(
      const Vector& x
   );
   SmartPtr<const Vector> curr_orig_x_L_violation();
   SmartPtr<const Vector> curr_orig_x_U_violation();
   virtual Number curr_orig_bounds_violation(
      ENormType NormType
   );
 
 
   SmartPtr<const SymMatrix> curr_exact_hessian();
 
 
   SmartPtr<const Vector> curr_grad_lag_x();
   SmartPtr<const Vector> trial_grad_lag_x();
   SmartPtr<const Vector> curr_grad_lag_s();
   SmartPtr<const Vector> trial_grad_lag_s();
   SmartPtr<const Vector> curr_grad_lag_with_damping_x();
   SmartPtr<const Vector> curr_grad_lag_with_damping_s();
   SmartPtr<const Vector> curr_compl_x_L();
   SmartPtr<const Vector> curr_compl_x_U();
   SmartPtr<const Vector> curr_compl_s_L();
   SmartPtr<const Vector> curr_compl_s_U();
   SmartPtr<const Vector> trial_compl_x_L();
   SmartPtr<const Vector> trial_compl_x_U();
   SmartPtr<const Vector> trial_compl_s_L();
   SmartPtr<const Vector> trial_compl_s_U();
   SmartPtr<const Vector> curr_relaxed_compl_x_L();
   SmartPtr<const Vector> curr_relaxed_compl_x_U();
   SmartPtr<const Vector> curr_relaxed_compl_s_L();
   SmartPtr<const Vector> curr_relaxed_compl_s_U();
 
   virtual Number curr_primal_infeasibility(
      ENormType NormType
   );
   virtual Number trial_primal_infeasibility(
      ENormType NormType
   );
 
   virtual Number curr_dual_infeasibility(
      ENormType NormType
   );
   virtual Number trial_dual_infeasibility(
      ENormType NormType
   );
   virtual Number unscaled_curr_dual_infeasibility(
      ENormType NormType
   );
 
   virtual Number curr_complementarity(
      Number    mu,
      ENormType NormType
   );
   virtual Number trial_complementarity(
      Number    mu,
      ENormType NormType
   );
   virtual Number unscaled_curr_complementarity(
      Number    mu,
      ENormType NormType
   );
 
   Number CalcCentralityMeasure(
      const Vector& compl_x_L,
      const Vector& compl_x_U,
      const Vector& compl_s_L,
      const Vector& compl_s_U
   );
   virtual Number curr_centrality_measure();
 
   virtual Number curr_nlp_error();
   virtual Number unscaled_curr_nlp_error();
 
   virtual Number curr_barrier_error();
 
   virtual Number curr_primal_dual_system_error(
      Number mu
   );
   virtual Number trial_primal_dual_system_error(
      Number mu
   );
 
 
   Number primal_frac_to_the_bound(
      Number        tau,
      const Vector& delta_x,
      const Vector& delta_s
   );
   Number curr_primal_frac_to_the_bound(
      Number tau
   );
   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
   );
   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
   );
   Number curr_dual_frac_to_the_bound(
      Number tau
   );
   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
   );
 
   SmartPtr<const Vector> curr_sigma_x();
   SmartPtr<const Vector> curr_sigma_s();
 
   Number curr_avrg_compl();
   Number trial_avrg_compl();
 
   Number curr_gradBarrTDelta();
 
   Number
   CalcNormOfType(
      ENormType                            NormType,
      std::vector<SmartPtr<const Vector> > vecs
   );
 
   Number
   CalcNormOfType(
      ENormType     NormType,
      const Vector& vec1,
      const Vector& vec2
   );
 
   ENormType constr_viol_normtype() const
   {
      return constr_viol_normtype_;
   }
 
   bool IsSquareProblem() const;
 
   SmartPtr<IpoptNLP>& GetIpoptNLP()
   {
      return ip_nlp_;
   }
 
   IpoptAdditionalCq& AdditionalCq()
   {
      DBG_ASSERT(IsValid(add_cq_));
      return *add_cq_;
   }
 
   static void RegisterOptions(
      SmartPtr<RegisteredOptions> roptions
   );
 
private:
 
   IpoptCalculatedQuantities();
 
   IpoptCalculatedQuantities(
      const IpoptCalculatedQuantities&
   );
 
   void operator=(
      const IpoptCalculatedQuantities&
   );
 
 
   SmartPtr<IpoptNLP> ip_nlp_;
   SmartPtr<IpoptData> ip_data_;
   SmartPtr<IpoptAdditionalCq> add_cq_;
 
 
   Number s_max_;
   Number kappa_d_;
   Number slack_move_;
   ENormType constr_viol_normtype_;
   bool warm_start_same_structure_;
   Number mu_target_;
 
   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_;
 
   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_;
 
   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_;
 
   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_;
 
   CachedResults<SmartPtr<const SymMatrix> > curr_exact_hessian_cache_;
 
   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_;
 
   CachedResults<std::pair<SmartPtr<Vector>, SmartPtr<Vector> > > unscaled_curr_orig_x_LU_viol_cache_;
   CachedResults<Number> unscaled_curr_orig_bounds_viol_cache_;
   CachedResults<SmartPtr<Vector> > curr_orig_x_L_viol_cache_;
   CachedResults<SmartPtr<Vector> > curr_orig_x_U_viol_cache_;
   CachedResults<Number> curr_orig_bounds_viol_cache_;
 
   CachedResults<Number> primal_frac_to_the_bound_cache_;
   CachedResults<Number> dual_frac_to_the_bound_cache_;
 
   CachedResults<SmartPtr<const Vector> > curr_sigma_x_cache_;
   CachedResults<SmartPtr<const Vector> > curr_sigma_s_cache_;
 
   CachedResults<Number> curr_avrg_compl_cache_;
   CachedResults<Number> trial_avrg_compl_cache_;
 
   CachedResults<Number> curr_gradBarrTDelta_cache_;
 
 
   SmartPtr<Vector> dampind_x_L_;
   SmartPtr<Vector> dampind_x_U_;
   SmartPtr<Vector> dampind_s_L_;
   SmartPtr<Vector> dampind_s_U_;
 
   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_;
 
   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();
 
   bool initialize_called_;
 
 
   SmartPtr<Vector> CalcSlack_L(
      const Matrix& P,
      const Vector& x,
      const Vector& x_bound
   );
   SmartPtr<Vector> CalcSlack_U(
      const Matrix& P,
      const Vector& x,
      const Vector& x_bound
   );
   Number CalcBarrierTerm(
      Number        mu,
      const Vector& slack_x_L,
      const Vector& slack_x_U,
      const Vector& slack_s_L,
      const Vector& slack_s_U
   );
 
   SmartPtr<const Vector> CalcCompl(
      const Vector& slack,
      const Vector& mult
   );
 
   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
   );
 
   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
   );
 
   Index CalculateSafeSlack(
      SmartPtr<Vector>&             slack,
      const SmartPtr<const Vector>& bound,
      const SmartPtr<const Vector>& curr_point,
      const SmartPtr<const Vector>& multiplier
   );
 
   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
   );
 
};
 
} // namespace Ipopt
 
#endif