IpIpoptNLP.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 Eclipse Public License.
//
// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
 
#ifndef __IPIPOPTNLP_HPP__
#define __IPIPOPTNLP_HPP__
 
#include "IpNLP.hpp"
#include "IpJournalist.hpp"
#include "IpNLPScaling.hpp"
 
namespace Ipopt
{
// forward declarations
class IteratesVector;
 
class IPOPTLIB_EXPORT IpoptNLP: public ReferencedObject
{
public:
   IpoptNLP(
      const SmartPtr<NLPScalingObject> nlp_scaling
   )
      : nlp_scaling_(nlp_scaling)
   { }
 
   virtual ~IpoptNLP()
   { }
 
   virtual bool Initialize(
      const Journalist&  jnlst,
      const OptionsList& options,
      const std::string& prefix
   )
   {
      bool ret = true;
      if( IsValid(nlp_scaling_) )
      {
         ret = nlp_scaling_->Initialize(jnlst, options, prefix);
      }
      return ret;
   }
 
 
   DECLARE_STD_EXCEPTION(Eval_Error);
 
 
   virtual bool InitializeStructures(
      SmartPtr<Vector>& x,
      bool init_x,
      SmartPtr<Vector>& y_c,
      bool init_y_c,
      SmartPtr<Vector>& y_d,
      bool init_y_d,
      SmartPtr<Vector>& z_L,
      bool init_z_L,
      SmartPtr<Vector>& z_U,
      bool init_z_U,
      SmartPtr<Vector>& v_L,
      SmartPtr<Vector>& v_U
   ) = 0;
 
   virtual bool GetWarmStartIterate(
      IteratesVector& warm_start_iterate
   ) = 0;
 
 
   virtual Number f(
      const Vector& x
   ) = 0;
 
   virtual SmartPtr<const Vector> grad_f(
      const Vector& x
   ) = 0;
 
   virtual SmartPtr<const Vector> c(
      const Vector& x
   ) = 0;
 
   virtual SmartPtr<const Matrix> jac_c(
      const Vector& x
   ) = 0;
 
   virtual SmartPtr<const Vector> d(
      const Vector& x
   ) = 0;
 
   virtual SmartPtr<const Matrix> jac_d(
      const Vector& x
   ) = 0;
 
   virtual SmartPtr<const SymMatrix> h(
      const Vector& x,
      Number        obj_factor,
      const Vector& yc,
      const Vector& yd
   ) = 0;
 
   virtual SmartPtr<const Vector> x_L() const = 0;
 
   virtual SmartPtr<const Matrix> Px_L() const = 0;
 
   virtual SmartPtr<const Vector> x_U() const = 0;
 
   virtual SmartPtr<const Matrix> Px_U() const = 0;
 
   virtual SmartPtr<const Vector> d_L() const = 0;
 
   virtual SmartPtr<const Matrix> Pd_L() const = 0;
 
   virtual SmartPtr<const Vector> d_U() const = 0;
 
   virtual SmartPtr<const Matrix> Pd_U() const = 0;
 
   virtual SmartPtr<const VectorSpace> x_space() const = 0;
 
   virtual SmartPtr<const SymMatrixSpace> HessianMatrixSpace() const = 0;
 
   virtual void GetSpaces(
      SmartPtr<const VectorSpace>& x_space,
      SmartPtr<const VectorSpace>& c_space,
      SmartPtr<const VectorSpace>& d_space,
      SmartPtr<const VectorSpace>& x_l_space,
      SmartPtr<const MatrixSpace>& px_l_space,
      SmartPtr<const VectorSpace>& x_u_space,
      SmartPtr<const MatrixSpace>& px_u_space,
      SmartPtr<const VectorSpace>& d_l_space,
      SmartPtr<const MatrixSpace>& pd_l_space,
      SmartPtr<const VectorSpace>& d_u_space,
      SmartPtr<const MatrixSpace>& pd_u_space,
      SmartPtr<const MatrixSpace>& Jac_c_space,
      SmartPtr<const MatrixSpace>& Jac_d_space,
      SmartPtr<const SymMatrixSpace>& Hess_lagrangian_space
   ) = 0;
 
   virtual void AdjustVariableBounds(
      const Vector& new_x_L,
      const Vector& new_x_U,
      const Vector& new_d_L,
      const Vector& new_d_U
   ) = 0;
 
   virtual Index f_evals() const = 0;
   virtual Index grad_f_evals() const = 0;
   virtual Index c_evals() const = 0;
   virtual Index jac_c_evals() const = 0;
   virtual Index d_evals() const = 0;
   virtual Index jac_d_evals() const = 0;
   virtual Index h_evals() const = 0;
 
 
   virtual bool objective_depends_on_mu() const
   {
      return false;
   }
 
   virtual Number f(
      const Vector& x,
      Number        mu
   ) = 0;
 
   virtual SmartPtr<const Vector> grad_f(
      const Vector& x,
      Number        mu
   ) = 0;
 
   virtual SmartPtr<const SymMatrix> h(
      const Vector& x,
      Number        obj_factor,
      const Vector& yc,
      const Vector& yd,
      Number        mu
   ) = 0;
 
   virtual SmartPtr<const SymMatrix> uninitialized_h() = 0;
 
   virtual void FinalizeSolution(
      SolverReturn               status,
      const Vector&              x,
      const Vector&              z_L,
      const Vector&              z_U,
      const Vector&              c,
      const Vector&              d,
      const Vector&              y_c,
      const Vector&              y_d,
      Number                     obj_value,
      const IpoptData*           ip_data,
      IpoptCalculatedQuantities* ip_cq
   ) = 0;
 
   virtual bool IntermediateCallBack(
      AlgorithmMode                       mode,
      Index                               iter,
      Number                              obj_value,
      Number                              inf_pr,
      Number                              inf_du,
      Number                              mu,
      Number                              d_norm,
      Number                              regularization_size,
      Number                              alpha_du,
      Number                              alpha_pr,
      Index                               ls_trials,
      SmartPtr<const IpoptData>           ip_data,
      SmartPtr<IpoptCalculatedQuantities> ip_cq
   ) = 0;
 
   SmartPtr<NLPScalingObject> NLP_scaling() const
   {
      DBG_ASSERT(IsValid(nlp_scaling_));
      return nlp_scaling_;
   }
 
private:
 
 
   IpoptNLP(
      const IpoptNLP&
   );
 
   void operator=(
      const IpoptNLP&
   );
 
   SmartPtr<NLPScalingObject> nlp_scaling_;
};
 
} // namespace Ipopt
 
#endif