IpInexactData.hpp

Go to the documentation of this file.

// Copyright (C) 2008, 2009 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Eclipse Public License.
//
// Authors:  Andreas Waechter           IBM     2008-08-31
 
#ifndef __IPINEXACTDATA_HPP__
#define __IPINEXACTDATA_HPP__
 
#include "IpIpoptData.hpp"
 
namespace Ipopt
{
 
class InexactData: public IpoptAdditionalData
{
public:
 
   InexactData();
 
   ~InexactData();
 
 
   bool Initialize(
      const Journalist&  jnlst,
      const OptionsList& options,
      const std::string& prefix
   );
 
   bool InitializeDataStructures();
 
   void AcceptTrialPoint();
 
   void set_normal_x(
      SmartPtr<Vector>& normal_x
   )
   {
      normal_x_ = ConstPtr(normal_x);
      normal_x = NULL;
   }
 
   void set_normal_s(
      SmartPtr<Vector>& normal_s
   )
   {
      normal_s_ = ConstPtr(normal_s);
      normal_s = NULL;
   }
 
   SmartPtr<const Vector> normal_x()
   {
      return normal_x_;
   }
 
   SmartPtr<const Vector> normal_s()
   {
      return normal_s_;
   }
 
   void set_tangential_x(
      SmartPtr<const Vector>& tangential_x
   )
   {
      tangential_x_ = tangential_x;
      tangential_x = NULL;
   }
 
   void set_tangential_s(
      SmartPtr<const Vector>& tangential_s
   )
   {
      tangential_s_ = tangential_s;
      tangential_s = NULL;
   }
 
   SmartPtr<const Vector> tangential_x()
   {
      return tangential_x_;
   }
 
   SmartPtr<const Vector> tangential_s()
   {
      return tangential_s_;
   }
 
   void set_full_step_accepted(
      bool full_step_accepted
   )
   {
      full_step_accepted_ = full_step_accepted;
   }
 
   bool full_step_accepted()
   {
      return full_step_accepted_;
   }
 
   void set_curr_nu(
      Number nu
   )
   {
      curr_nu_ = nu;
   }
 
   Number curr_nu()
   {
      return curr_nu_;
   }
 
   void set_compute_normal(
      bool compute_normal
   )
   {
      compute_normal_ = compute_normal;
   }
 
   bool compute_normal()
   {
      return compute_normal_;
   }
 
   void set_next_compute_normal(
      bool next_compute_normal
   )
   {
      next_compute_normal_ = next_compute_normal;
   }
 
   bool next_compute_normal()
   {
      return next_compute_normal_;
   }
 
private:
 
   InexactData(
      const InexactData&
   );
 
   void operator=(
      const InexactData&
   );
 
   SmartPtr<const Vector> normal_x_;
   SmartPtr<const Vector> normal_s_;
 
   SmartPtr<const Vector> tangential_x_;
   SmartPtr<const Vector> tangential_s_;
 
   bool full_step_accepted_;
 
   Number curr_nu_;
 
   bool compute_normal_;
 
   bool next_compute_normal_;
};
 
} // namespace Ipopt
 
#endif