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.
//
// $Id: IpInexactData.hpp 1861 2010-12-21 21:34:47Z andreasw $
//
// 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