IpIpoptData.hpp

Go to the documentation of this file.

// Copyright (C) 2004, 2009 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 __IPIPOPTDATA_HPP__
#define __IPIPOPTDATA_HPP__
 
#include "IpSymMatrix.hpp"
#include "IpOptionsList.hpp"
#include "IpIteratesVector.hpp"
#include "IpRegOptions.hpp"
#include "IpTimingStatistics.hpp"
 
namespace Ipopt
{
 
/* Forward declaration */
class IpoptNLP;
 
class IPOPTLIB_EXPORT IpoptAdditionalData: public ReferencedObject
{
public:
 
   IpoptAdditionalData()
   { }
 
   virtual ~IpoptAdditionalData()
   { }
 
   virtual bool Initialize(
      const Journalist&  jnlst,
      const OptionsList& options,
      const std::string& prefix
   ) = 0;
 
   virtual bool InitializeDataStructures() = 0;
 
   virtual void AcceptTrialPoint() = 0;
 
private:
 
   IpoptAdditionalData(
      const IpoptAdditionalData&
   );
 
   void operator=(
      const IpoptAdditionalData&
   );
};
 
class IPOPTLIB_EXPORT IpoptData: public ReferencedObject
{
public:
 
   IpoptData(
      SmartPtr<IpoptAdditionalData> add_data = NULL,
      Number                        cpu_time_start = -1.
   );
 
   virtual ~IpoptData();
 
   bool InitializeDataStructures(
      IpoptNLP& ip_nlp,
      bool      want_x,
      bool      want_y_c,
      bool      want_y_d,
      bool      want_z_L,
      bool      want_z_U
   );
 
   bool Initialize(
      const Journalist&  jnlst,
      const OptionsList& options,
      const std::string& prefix
   );
 
 
   inline SmartPtr<const IteratesVector> curr() const;
 
   //    SmartPtr<IteratesVector> curr_container() const;
   inline SmartPtr<const IteratesVector> trial() const;
 
   //SmartPtr<IteratesVector> trial_container() const;
   inline
   void set_trial(
      SmartPtr<IteratesVector>& trial
   );
 
   void SetTrialPrimalVariablesFromStep(
      Number        alpha,
      const Vector& delta_x,
      const Vector& delta_s
   );
   void SetTrialEqMultipliersFromStep(
      Number        alpha,
      const Vector& delta_y_c,
      const Vector& delta_y_d
   );
   void SetTrialBoundMultipliersFromStep(
      Number        alpha,
      const Vector& delta_z_L,
      const Vector& delta_z_U,
      const Vector& delta_v_L,
      const Vector& delta_v_U
   );
 
   // void set_trial(const SmartPtr<IteratesVector>& trial_iterates);
   // void set_trial(SmartPtr<const IteratesVector>& trial_iterates);
   inline SmartPtr<const IteratesVector> delta() const;
 
   inline
   void set_delta(
      SmartPtr<IteratesVector>& delta
   );
 
   inline
   void set_delta(
      SmartPtr<const IteratesVector>& delta
   );
 
   inline SmartPtr<const IteratesVector> delta_aff() const;
 
   inline
   void set_delta_aff(
      SmartPtr<IteratesVector>& delta_aff
   );
 
   SmartPtr<const SymMatrix> W()
   {
      DBG_ASSERT(IsValid(W_));
      return W_;
   }
 
   void Set_W(
      SmartPtr<const SymMatrix> W
   )
   {
      W_ = W;
   }
 
 
   bool HaveDeltas() const
   {
      return have_deltas_;
   }
 
   void SetHaveDeltas(
      bool have_deltas
   )
   {
      have_deltas_ = have_deltas;
   }
 
 
   bool HaveAffineDeltas() const
   {
      return have_affine_deltas_;
   }
 
   void SetHaveAffineDeltas(
      bool have_affine_deltas
   )
   {
      have_affine_deltas_ = have_affine_deltas;
   }
 
 
   inline
   void CopyTrialToCurrent();
 
   void AcceptTrialPoint();
 
   Index iter_count() const
   {
      return iter_count_;
   }
   void Set_iter_count(
      Index iter_count
   )
   {
      iter_count_ = iter_count;
   }
 
   Number curr_mu() const
   {
      DBG_ASSERT(mu_initialized_);
      return curr_mu_;
   }
   void Set_mu(
      Number mu
   )
   {
      curr_mu_ = mu;
      mu_initialized_ = true;
   }
   bool MuInitialized() const
   {
      return mu_initialized_;
   }
 
   Number curr_tau() const
   {
      DBG_ASSERT(tau_initialized_);
      return curr_tau_;
   }
   void Set_tau(
      Number tau
   )
   {
      curr_tau_ = tau;
      tau_initialized_ = true;
   }
   bool TauInitialized() const
   {
      return tau_initialized_;
   }
 
   void SetFreeMuMode(
      bool free_mu_mode
   )
   {
      free_mu_mode_ = free_mu_mode;
   }
   bool FreeMuMode() const
   {
      return free_mu_mode_;
   }
 
   void Set_tiny_step_flag(
      bool flag
   )
   {
      tiny_step_flag_ = flag;
   }
   bool tiny_step_flag()
   {
      return tiny_step_flag_;
   }
 
 
   Number tol() const
   {
      DBG_ASSERT(initialize_called_);
      return tol_;
   }
   void Set_tol(
      Number tol
   )
   {
      tol_ = tol;
   }
 
   Number cpu_time_start() const
   {
      DBG_ASSERT(cpu_time_start_ >= 0);
      return cpu_time_start_;
   }
 
   Number info_regu_x() const
   {
      return info_regu_x_;
   }
   void Set_info_regu_x(
      Number regu_x
   )
   {
      info_regu_x_ = regu_x;
   }
   Number info_alpha_primal() const
   {
      return info_alpha_primal_;
   }
   void Set_info_alpha_primal(
      Number alpha_primal
   )
   {
      info_alpha_primal_ = alpha_primal;
   }
   char info_alpha_primal_char() const
   {
      return info_alpha_primal_char_;
   }
   void Set_info_alpha_primal_char(
      char info_alpha_primal_char
   )
   {
      info_alpha_primal_char_ = info_alpha_primal_char;
   }
   Number info_alpha_dual() const
   {
      return info_alpha_dual_;
   }
   void Set_info_alpha_dual(
      Number alpha_dual
   )
   {
      info_alpha_dual_ = alpha_dual;
   }
   Index info_ls_count() const
   {
      return info_ls_count_;
   }
   void Set_info_ls_count(
      Index ls_count
   )
   {
      info_ls_count_ = ls_count;
   }
   bool info_skip_output() const
   {
      return info_skip_output_;
   }
   void Append_info_string(
      const std::string& add_str
   )
   {
      info_string_ += add_str;
   }
   const std::string& info_string() const
   {
      return info_string_;
   }
   void Set_info_skip_output(
      bool info_skip_output
   )
   {
      info_skip_output_ = info_skip_output;
   }
 
   Number info_last_output()
   {
      return info_last_output_;
   }
   void Set_info_last_output(
      Number info_last_output
   )
   {
      info_last_output_ = info_last_output;
   }
 
   int info_iters_since_header()
   {
      return info_iters_since_header_;
   }
   void Inc_info_iters_since_header()
   {
      info_iters_since_header_++;
   }
   void Set_info_iters_since_header(
      int info_iters_since_header
   )
   {
      info_iters_since_header_ = info_iters_since_header;
   }
 
   void ResetInfo()
   {
      info_regu_x_ = 0;
      info_alpha_primal_ = 0;
      info_alpha_dual_ = 0.;
      info_alpha_primal_char_ = ' ';
      info_skip_output_ = false;
      info_string_.erase();
   }
 
   TimingStatistics& TimingStats()
   {
      return timing_statistics_;
   }
 
   void ResetCpuStartTime()
   {
      cpu_time_start_ = CpuTime();
   }
 
   bool HaveAddData()
   {
      return IsValid(add_data_);
   }
 
   IpoptAdditionalData& AdditionalData()
   {
      return *add_data_;
   }
 
   void SetAddData(
      SmartPtr<IpoptAdditionalData> add_data
   )
   {
      DBG_ASSERT(!HaveAddData());
      add_data_ = add_data;
   }
 
   void setPDPert(
      Number pd_pert_x,
      Number pd_pert_s,
      Number pd_pert_c,
      Number pd_pert_d
   )
   {
      pd_pert_x_ = pd_pert_x;
      pd_pert_s_ = pd_pert_s;
      pd_pert_c_ = pd_pert_c;
      pd_pert_d_ = pd_pert_d;
   }
 
   void getPDPert(
      Number& pd_pert_x,
      Number& pd_pert_s,
      Number& pd_pert_c,
      Number& pd_pert_d
   )
   {
      pd_pert_x = pd_pert_x_;
      pd_pert_s = pd_pert_s_;
      pd_pert_c = pd_pert_c_;
      pd_pert_d = pd_pert_d_;
   }
 
   static void RegisterOptions(
      const SmartPtr<RegisteredOptions>& roptions
   );
 
private:
 
   SmartPtr<const IteratesVector> curr_;
 
   SmartPtr<const IteratesVector> trial_;
 
   SmartPtr<const SymMatrix> W_;
 
   SmartPtr<const IteratesVector> delta_;
   bool have_deltas_;
 
   SmartPtr<const IteratesVector> delta_aff_;
   bool have_affine_deltas_;
 
   Index iter_count_;
 
   Number curr_mu_;
   bool mu_initialized_;
 
   Number curr_tau_;
   bool tau_initialized_;
 
   bool initialize_called_;
 
   bool have_prototypes_;
 
 
   Number tol_;
 
 
   bool free_mu_mode_;
   bool tiny_step_flag_;
 
 
   Number info_regu_x_;
   Number info_alpha_primal_;
   char info_alpha_primal_char_;
   Number info_alpha_dual_;
   Index info_ls_count_;
   bool info_skip_output_;
   std::string info_string_;
   Number info_last_output_;
   int info_iters_since_header_;
 
   SmartPtr<IteratesVectorSpace> iterates_space_;
 
   TimingStatistics timing_statistics_;
 
   Number cpu_time_start_;
 
   SmartPtr<IpoptAdditionalData> add_data_;
 
   Number pd_pert_x_;
   Number pd_pert_s_;
   Number pd_pert_c_;
   Number pd_pert_d_;
 
 
   IpoptData(
      const IpoptData&
   );
 
   void operator=(
      const IpoptData&
   );
 
#if IPOPT_CHECKLEVEL > 0
   TaggedObject::Tag debug_curr_tag_;
   TaggedObject::Tag debug_trial_tag_;
   TaggedObject::Tag debug_delta_tag_;
   TaggedObject::Tag debug_delta_aff_tag_;
   TaggedObject::Tag debug_curr_tag_sum_;
   TaggedObject::Tag debug_trial_tag_sum_;
   TaggedObject::Tag debug_delta_tag_sum_;
   TaggedObject::Tag debug_delta_aff_tag_sum_;
#endif
 
};
 
inline SmartPtr<const IteratesVector> IpoptData::curr() const
{
   DBG_ASSERT(IsNull(curr_) || (curr_->GetTag() == debug_curr_tag_ && curr_->GetTagSum() == debug_curr_tag_sum_) );
 
   return curr_;
}
 
inline SmartPtr<const IteratesVector> IpoptData::trial() const
{
   DBG_ASSERT(IsNull(trial_) || (trial_->GetTag() == debug_trial_tag_ && trial_->GetTagSum() == debug_trial_tag_sum_) );
 
   return trial_;
}
 
inline SmartPtr<const IteratesVector> IpoptData::delta() const
{
   DBG_ASSERT(IsNull(delta_) || (delta_->GetTag() == debug_delta_tag_ && delta_->GetTagSum() == debug_delta_tag_sum_) );
 
   return delta_;
}
 
inline SmartPtr<const IteratesVector> IpoptData::delta_aff() const
{
   DBG_ASSERT(IsNull(delta_aff_) || (delta_aff_->GetTag() == debug_delta_aff_tag_ && delta_aff_->GetTagSum() == debug_delta_aff_tag_sum_) );
 
   return delta_aff_;
}
 
inline
void IpoptData::CopyTrialToCurrent()
{
   curr_ = trial_;
#if IPOPT_CHECKLEVEL > 0
 
   if (IsValid(curr_))
   {
      debug_curr_tag_ = curr_->GetTag();
      debug_curr_tag_sum_ = curr_->GetTagSum();
   }
   else
   {
      debug_curr_tag_ = 0;
      debug_curr_tag_sum_ = 0;
   }
#endif
 
}
 
inline
void IpoptData::set_trial(
   SmartPtr<IteratesVector>& trial
)
{
   trial_ = ConstPtr(trial);
 
#if IPOPT_CHECKLEVEL > 0
   // verify the correct space
   DBG_ASSERT(trial_->OwnerSpace() == (VectorSpace*)GetRawPtr(iterates_space_));
   if (IsValid(trial))
   {
      debug_trial_tag_ = trial->GetTag();
      debug_trial_tag_sum_ = trial->GetTagSum();
   }
   else
   {
      debug_trial_tag_ = 0;
      debug_trial_tag_sum_ = 0;
   }
#endif
 
   trial = NULL;
}
 
inline
void IpoptData::set_delta(
   SmartPtr<IteratesVector>& delta
)
{
   delta_ = ConstPtr(delta);
#if IPOPT_CHECKLEVEL > 0
 
   if (IsValid(delta))
   {
      debug_delta_tag_ = delta->GetTag();
      debug_delta_tag_sum_ = delta->GetTagSum();
   }
   else
   {
      debug_delta_tag_ = 0;
      debug_delta_tag_sum_ = 0;
   }
#endif
 
   delta = NULL;
}
 
inline
void IpoptData::set_delta(
   SmartPtr<const IteratesVector>& delta
)
{
   delta_ = delta;
#if IPOPT_CHECKLEVEL > 0
 
   if (IsValid(delta))
   {
      debug_delta_tag_ = delta->GetTag();
      debug_delta_tag_sum_ = delta->GetTagSum();
   }
   else
   {
      debug_delta_tag_ = 0;
      debug_delta_tag_sum_ = 0;
   }
#endif
 
   delta = NULL;
}
 
inline
void IpoptData::set_delta_aff(
   SmartPtr<IteratesVector>& delta_aff
)
{
   delta_aff_ = ConstPtr(delta_aff);
#if IPOPT_CHECKLEVEL > 0
 
   if (IsValid(delta_aff))
   {
      debug_delta_aff_tag_ = delta_aff->GetTag();
      debug_delta_aff_tag_sum_ = delta_aff->GetTagSum();
   }
   else
   {
      debug_delta_aff_tag_ = 0;
      debug_delta_aff_tag_sum_ = delta_aff->GetTagSum();
   }
#endif
 
   delta_aff = NULL;
}
 
} // namespace Ipopt
 
#endif