IpIpoptData.hpp

Go to the documentation of this file.

// Copyright (C) 2004, 2006 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Common Public License.
//
// $Id: IpIpoptData.hpp 759 2006-07-07 03:07:08Z andreasw $
//
// 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 IpoptData : public ReferencedObject
  {
  public:
    IpoptData();

    ~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);

    SmartPtr<const IteratesVector> curr() const;

    //    SmartPtr<IteratesVector> curr_container() const;

    SmartPtr<const IteratesVector> trial() const;

    //SmartPtr<IteratesVector> trial_container() const;

    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);

    SmartPtr<const IteratesVector> delta() const;

    void set_delta(SmartPtr<IteratesVector>& delta);

    SmartPtr<const IteratesVector> delta_aff() const;

    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;
    }


    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 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;
    }

    void ResetInfo()
    {
      info_regu_x_ = 0;
      info_alpha_primal_ = 0;
      info_alpha_dual_ = 0.;
      info_alpha_primal_char_ = ' ';
      info_ls_count_ = 0;
      info_skip_output_ = false;
      info_string_.clear();
    }

    TimingStatistics& TimingStats()
    {
      return timing_statistics_;
    }

    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_;

    SmartPtr<IteratesVectorSpace> iterates_space_;

    TimingStatistics timing_statistics_;

    IpoptData(const IpoptData&);

    void operator=(const IpoptData&);

#ifdef IP_DEBUG

    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
  {
#ifdef IP_DEBUG
    DBG_ASSERT(IsNull(curr_) || (curr_->GetTag() == debug_curr_tag_ && curr_->GetTagSum() == debug_curr_tag_sum_) );
#endif

    return curr_;
  }

  inline
  SmartPtr<const IteratesVector> IpoptData::trial() const
  {
#ifdef IP_DEBUG
    DBG_ASSERT(IsNull(trial_) || (trial_->GetTag() == debug_trial_tag_ && trial_->GetTagSum() == debug_trial_tag_sum_) );
#endif

    return trial_;
  }

  inline
  SmartPtr<const IteratesVector> IpoptData::delta() const
  {
#   ifdef IP_DEBUG
    DBG_ASSERT(IsNull(delta_) || (delta_->GetTag() == debug_delta_tag_ && delta_->GetTagSum() == debug_delta_tag_sum_) );
#   endif

    return delta_;
  }

  inline
  SmartPtr<const IteratesVector> IpoptData::delta_aff() const
  {
#   ifdef IP_DEBUG
    DBG_ASSERT(IsNull(delta_aff_) || (delta_aff_->GetTag() == debug_delta_aff_tag_ && delta_aff_->GetTagSum() == debug_delta_aff_tag_sum_) );
#   endif

    return delta_aff_;
  }

  inline
  void IpoptData::CopyTrialToCurrent()
  {
    curr_ = trial_;
#ifdef IP_DEBUG

    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);

#ifdef IP_DEBUG
    // 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);
#ifdef IP_DEBUG

    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);
#ifdef IP_DEBUG

    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