IpNLP.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 __IPNLP_HPP__
#define __IPNLP_HPP__
 
#include "IpUtils.hpp"
#include "IpVector.hpp"
#include "IpSmartPtr.hpp"
#include "IpMatrix.hpp"
#include "IpSymMatrix.hpp"
#include "IpOptionsList.hpp"
#include "IpAlgTypes.hpp"
#include "IpReturnCodes.hpp"
 
namespace Ipopt
{
// forward declarations
class IpoptData;
class IpoptCalculatedQuantities;
class IteratesVector;
 
class IPOPTLIB_EXPORT NLP: public ReferencedObject
{
public:
 
   NLP()
   { }
 
   virtual ~NLP()
   { }
 
   DECLARE_STD_EXCEPTION(USER_SCALING_NOT_IMPLEMENTED);
   DECLARE_STD_EXCEPTION(INVALID_NLP);
 
 
   virtual bool ProcessOptions(
      const OptionsList& /*options*/,
      const std::string& /*prefix*/
   )
   {
      return true;
   }
 
   virtual bool 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 bool GetBoundsInformation(
      const Matrix& Px_L,
      Vector&       x_L,
      const Matrix& Px_U,
      Vector&       x_U,
      const Matrix& Pd_L,
      Vector&       d_L,
      const Matrix& Pd_U,
      Vector&       d_U
   ) = 0;
 
   // ToDo it might not make sense to ask for initial values for v_L and v_U?
   virtual bool GetStartingPoint(
      SmartPtr<Vector> x,
      bool             need_x,
      SmartPtr<Vector> y_c,
      bool             need_y_c,
      SmartPtr<Vector> y_d,
      bool             need_y_d,
      SmartPtr<Vector> z_L,
      bool             need_z_L,
      SmartPtr<Vector> z_U,
      bool             need_z_U
   ) = 0;
 
   virtual bool GetWarmStartIterate(
      IteratesVector& /*warm_start_iterate*/
   )
   {
      return false;
   }
 
   virtual bool Eval_f(
      const Vector& x,
      Number&       f
   ) = 0;
 
   virtual bool Eval_grad_f(
      const Vector& x,
      Vector&       g_f
   ) = 0;
 
   virtual bool Eval_c(
      const Vector& x,
      Vector&       c
   ) = 0;
 
   virtual bool Eval_jac_c(
      const Vector& x,
      Matrix&       jac_c
   ) = 0;
 
   virtual bool Eval_d(
      const Vector& x,
      Vector&       d
   ) = 0;
 
   virtual bool Eval_jac_d(
      const Vector& x,
      Matrix&       jac_d
   ) = 0;
 
   virtual bool Eval_h(
      const Vector& x,
      Number        obj_factor,
      const Vector& yc,
      const Vector& yd,
      SymMatrix&    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*/
   )
   { }
 
   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*/,
      const IpoptData*           /*ip_data*/,
      IpoptCalculatedQuantities* /*ip_cq*/
   )
   {
      return true;
   }
 
   virtual void GetScalingParameters(
      const SmartPtr<const VectorSpace> /*x_space*/,
      const SmartPtr<const VectorSpace> /*c_space*/,
      const SmartPtr<const VectorSpace> /*d_space*/,
      Number&                           /*obj_scaling*/,
      SmartPtr<Vector>&                 /*x_scaling*/,
      SmartPtr<Vector>&                 /*c_scaling*/,
      SmartPtr<Vector>&                 /*d_scaling*/
   ) const
   {
      THROW_EXCEPTION(USER_SCALING_NOT_IMPLEMENTED,
                      "You have set options for user provided scaling, but have not implemented GetScalingParameters in the NLP interface");
   }
 
   virtual void GetQuasiNewtonApproximationSpaces(
      SmartPtr<VectorSpace>& approx_space,
      SmartPtr<Matrix>& P_approx
   )
   {
      approx_space = NULL;
      P_approx     = NULL;
   }
 
private:
 
   NLP(
      const NLP&
   );
 
   void operator=(
      const NLP&
   );
};
 
} // namespace Ipopt
 
#endif