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.
//
// $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;

  enum ENormType {
    NORM_1=0,
    NORM_2,
    NORM_MAX
  };

  class 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 IpoptCalculatedQuantities : public ReferencedObject
  {
  public:

    IpoptCalculatedQuantities(const SmartPtr<IpoptNLP>& ip_nlp,
                              const SmartPtr<IpoptData>& ip_data);
    virtual ~IpoptCalculatedQuantities();

    void SetAddCq(SmartPtr<IpoptAdditionalCq> add_cq)
    {
      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<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<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);

    bool in_restoration_phase();

  };

} // namespace Ipopt

#endif