/home/coin/SVN-release/CoinAll-1.1.0/Ipopt/src/contrib/CGPenalty/IpCGPenaltyData.hpp

Go to the documentation of this file.

// Copyright (C) 2007 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Common Public License.
//
// $Id: IpIpoptData.hpp 988 2007-06-01 21:57:27Z andreasw $
//
// Authors:  Andreas Waechter           IBM     2007-06-04
//                   based on IpIpoptData.hpp

#ifndef __IPCGPENALTYDATA_HPP__
#define __IPCGPENALTYDATA_HPP__

#include "IpIteratesVector.hpp"
#include "IpOptionsList.hpp"

namespace Ipopt
{

  class CGPenaltyData : public ReferencedObject
  {
  public:
    CGPenaltyData();

    ~CGPenaltyData();

    bool Initialize(const Journalist& jnlst,
                    const OptionsList& options,
                    const std::string& prefix);

    bool InitializeDataStructures();

    SmartPtr<const IteratesVector> delta_cgpen() const;

    void set_delta_cgpen(SmartPtr<IteratesVector>& delta_pen);

    void set_delta_cgpen(SmartPtr<const IteratesVector>& delta_pen);

    SmartPtr<const IteratesVector> delta_cgfast() const;

    void set_delta_cgfast(SmartPtr<IteratesVector>& delta_fast);

    bool HaveCgPenDeltas() const
    {
      return have_cgpen_deltas_;
    }
    void SetHaveCgPenDeltas(bool have_cgpen_deltas)
    {
      have_cgpen_deltas_ = have_cgpen_deltas;
    }

    bool HaveCgFastDeltas() const
    {
      return have_cgfast_deltas_;
    }
    void SetHaveCgFastDeltas(bool have_cgfast_deltas)
    {
      have_cgfast_deltas_ = have_cgfast_deltas;
    }

    void AcceptTrialPoint();

    Number CurrPenaltyPert()
    {
      return curr_penalty_pert_;
    }
    void SetCurrPenaltyPert(Number curr_penalty_pert)
    {
      curr_penalty_pert_ = curr_penalty_pert;
    }

    void SetNeverTryPureNewton(bool never_try_pure_Newton)
    {
      never_try_pure_Newton_ = never_try_pure_Newton;
    }
    Index NeverTryPureNewton()
    {
      return never_try_pure_Newton_;
    }

    Index restor_iter()
    {
      return restor_iter_;
    }

    void SetRestorIter(Index restor_iter)
    {
      restor_iter_ = restor_iter;
    }
    Number restor_counter()
    {
      return restor_counter_;
    }
    void SetRestorCounter(Number restor_counter)
    {
      restor_counter_ = restor_counter;
    }

    void SetPrimalStepSize(Number max_alpha_x)
    {
      max_alpha_x_ = max_alpha_x;
    }
    Number PrimalStepSize()
    {
      return max_alpha_x_;
    }

    Number curr_penalty() const
    {
      DBG_ASSERT(penalty_initialized_);
      return curr_penalty_;
    }
    void Set_penalty(Number penalty)
    {
      curr_penalty_ = penalty;
      penalty_initialized_ = true;
    }
    void SetPenaltyUninitialized()
    {
      penalty_initialized_ = false;
    }
    bool PenaltyInitialized() const
    {
      return penalty_initialized_;
    }
    Number curr_kkt_penalty() const
    {
      DBG_ASSERT(kkt_penalty_initialized_);
      return curr_kkt_penalty_;
    }
    void Set_kkt_penalty(Number kkt_penalty)
    {
      curr_kkt_penalty_ = kkt_penalty;
      kkt_penalty_initialized_ = true;
    }
    void SetKKTPenaltyUninitialized()
    {
      kkt_penalty_initialized_ = false;
    }
    bool KKTPenaltyInitialized() const
    {
      return kkt_penalty_initialized_;
    }


  private:

    SmartPtr<const IteratesVector> delta_cgpen_;
    bool have_cgpen_deltas_;

    SmartPtr<const IteratesVector> delta_cgfast_;
    bool have_cgfast_deltas_;

    bool never_try_pure_Newton_;

    Index restor_iter_;
    Number restor_counter_;

    Number curr_penalty_;
    bool penalty_initialized_;
    Number curr_kkt_penalty_;
    bool kkt_penalty_initialized_;
    Number curr_penalty_pert_;
    Number max_alpha_x_;

    bool initialize_called_;

    CGPenaltyData(const CGPenaltyData&);

    void operator=(const CGPenaltyData&);

#if COIN_IPOPT_CHECKLEVEL > 0

    TaggedObject::Tag debug_delta_cgpen_tag_;
    TaggedObject::Tag debug_delta_cgfast_tag_;
    TaggedObject::Tag debug_delta_cgpen_tag_sum_;
    TaggedObject::Tag debug_delta_cgfast_tag_sum_;
#endif

  };

  inline
  SmartPtr<const IteratesVector> CGPenaltyData::delta_cgpen() const
  {
    DBG_ASSERT(IsNull(delta_cgpen_) || (delta_cgpen_->GetTag() == debug_delta_cgpen_tag_ && delta_cgpen_->GetTagSum() == debug_delta_cgpen_tag_sum_) );

    return delta_cgpen_;
  }

  inline
  SmartPtr<const IteratesVector> CGPenaltyData::delta_cgfast() const
  {
    DBG_ASSERT(IsNull(delta_cgfast_) || (delta_cgfast_->GetTag() == debug_delta_cgfast_tag_ && delta_cgfast_->GetTagSum() == debug_delta_cgfast_tag_sum_) );

    return delta_cgfast_;
  }

  inline
  void CGPenaltyData::set_delta_cgpen(SmartPtr<IteratesVector>& delta_cgpen)
  {
    delta_cgpen_ = ConstPtr(delta_cgpen);
#if COIN_IPOPT_CHECKLEVEL > 0

    if (IsValid(delta_cgpen)) {
      debug_delta_cgpen_tag_ = delta_cgpen->GetTag();
      debug_delta_cgpen_tag_sum_ = delta_cgpen->GetTagSum();
    }
    else {
      debug_delta_cgpen_tag_ = 0;
      debug_delta_cgpen_tag_sum_ = delta_cgpen->GetTagSum();
    }
#endif

    delta_cgpen = NULL;
  }

  inline
  void CGPenaltyData::set_delta_cgpen(SmartPtr<const IteratesVector>& delta_cgpen)
  {
    delta_cgpen_ = delta_cgpen;
#if COIN_IPOPT_CHECKLEVEL > 0

    if (IsValid(delta_cgpen)) {
      debug_delta_cgpen_tag_ = delta_cgpen->GetTag();
      debug_delta_cgpen_tag_sum_ = delta_cgpen->GetTagSum();
    }
    else {
      debug_delta_cgpen_tag_ = 0;
      debug_delta_cgpen_tag_sum_ = delta_cgpen->GetTagSum();
    }
#endif

    delta_cgpen = NULL;
  }

  inline
  void CGPenaltyData::set_delta_cgfast(SmartPtr<IteratesVector>& delta_cgfast)
  {
    delta_cgfast_ = ConstPtr(delta_cgfast);
#if COIN_IPOPT_CHECKLEVEL > 0

    if (IsValid(delta_cgfast)) {
      debug_delta_cgfast_tag_ = delta_cgfast->GetTag();
      debug_delta_cgfast_tag_sum_ = delta_cgfast->GetTagSum();
    }
    else {
      debug_delta_cgfast_tag_ = 0;
      debug_delta_cgfast_tag_sum_ = delta_cgfast->GetTagSum();
    }
#endif

    delta_cgfast = NULL;
  }

} // namespace Ipopt

#endif

---