IpStdInterfaceTNLP.hpp

Go to the documentation of this file.

// Copyright (C) 2004, 2010 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 __IPSTDINTERFACETNLP_HPP__
#define __IPSTDINTERFACETNLP_HPP__
 
#include "IpUtils.hpp"
#include "IpTNLP.hpp"
#include "IpJournalist.hpp"
#include "IpException.hpp"
#include "IpStdCInterface.h"
#include "IpSmartPtr.hpp"
 
namespace Ipopt
{
DECLARE_STD_EXCEPTION(INVALID_STDINTERFACE_NLP);
 
class StdInterfaceTNLP : public TNLP
{
public:
 
   StdInterfaceTNLP(
      Index           n_var,
      const Number*   x_L,
      const Number*   x_U,
      Index           n_con,
      const Number*   g_L,
      const Number*   g_U,
      Index           nele_jac,
      Index           nele_hess,
      Index           index_style,
      const Number*   start_x,
      const Number*   start_lam,
      const Number*   start_z_L,
      const Number*   start_z_U,
      Eval_F_CB       eval_f,
      Eval_G_CB       eval_g,
      Eval_Grad_F_CB  eval_grad_f,
      Eval_Jac_G_CB   eval_jac_g,
      Eval_H_CB       eval_h,
      Intermediate_CB intermediate_cb,
      Number*         x_sol,
      Number*         z_L_sol,
      Number*         z_U_sol,
      Number*         g_sol,
      Number*         lam_sol,
      Number*         obj_sol,
      UserDataPtr     user_data,
      Number          obj_scaling = 1,
      const Number*   x_scaling = NULL,
      const Number*   g_scaling = NULL
   );
 
   virtual ~StdInterfaceTNLP();
 
   virtual bool get_nlp_info(
      Index&          n,
      Index&          m,
      Index&          nnz_jac_g,
      Index&          nnz_h_lag,
      IndexStyleEnum& index_style
   );
 
   virtual bool get_bounds_info(
      Index   n,
      Number* x_l,
      Number* x_u,
      Index   m,
      Number* g_l,
      Number* g_u
   );
 
   virtual bool get_scaling_parameters(
      Number& obj_scaling,
      bool&   use_x_scaling,
      Index   n,
      Number* x_scaling,
      bool&   use_g_scaling,
      Index   m,
      Number* g_scaling
   );
 
   virtual bool get_starting_point(
      Index   n,
      bool    init_x,
      Number* x,
      bool    init_z,
      Number* z_L,
      Number* z_U,
      Index   m,
      bool    init_lambda,
      Number* lambda
   );
 
   virtual bool eval_f(
      Index         n,
      const Number* x,
      bool          new_x,
      Number&       obj_value
   );
 
   virtual bool eval_grad_f(
      Index         n,
      const Number* x,
      bool          new_x,
      Number*       grad_f
   );
 
   virtual bool eval_g(
      Index         n,
      const Number* x,
      bool          new_x,
      Index         m,
      Number*       g
   );
 
   virtual bool eval_jac_g(
      Index         n,
      const Number* x,
      bool          new_x,
      Index         m,
      Index         nele_jac,
      Index*        iRow,
      Index*        jCol,
      Number*       values
   );
 
   virtual bool eval_h(
      Index         n,
      const Number* x,
      bool          new_x,
      Number        obj_factor,
      Index         m,
      const Number* lambda,
      bool          new_lambda,
      Index         nele_hess,
      Index*        iRow,
      Index*        jCol,
      Number*       values
   );
 
   virtual bool intermediate_callback(
      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
   );
 
   virtual void finalize_solution(
      SolverReturn               status,
      Index                      n,
      const Number*              x,
      const Number*              z_L,
      const Number*              z_U,
      Index                      m,
      const Number*              g,
      const Number*              lambda,
      Number                     obj_value,
      const IpoptData*           ip_data,
      IpoptCalculatedQuantities* ip_cq
   );
 
   bool get_curr_iterate(
      Bool                       scaled,
      Index                      n,
      Number*                    x,
      Number*                    z_L,
      Number*                    z_U,
      Index                      m,
      Number*                    g,
      Number*                    lambda
   ) const
   {
      return TNLP::get_curr_iterate(ip_data_, ip_cq_, scaled, n, x, z_L, z_U, m, g, lambda);
   }
 
   bool get_curr_violations(
      bool                       scaled,
      Index                      n,
      Number*                    x_L_violation,
      Number*                    x_U_violation,
      Number*                    compl_x_L,
      Number*                    compl_x_U,
      Number*                    grad_lag_x,
      Index                      m,
      Number*                    nlp_constraint_violation,
      Number*                    compl_g
   ) const
   {
      return TNLP::get_curr_violations(ip_data_, ip_cq_, scaled, n, x_L_violation, x_U_violation, compl_x_L, compl_x_U, grad_lag_x, m, nlp_constraint_violation, compl_g);
   }
 
private:
   SmartPtr<const Journalist> jnlst_;
 
 
   const Index n_var_;
   const Index n_con_;
   const Number* x_L_;
   const Number* x_U_;
   const Number* g_L_;
   const Number* g_U_;
   const Index nele_jac_;
   const Index nele_hess_;
   const Index index_style_;
   const Number* start_x_;
   const Number* start_lam_;
   const Number* start_z_L_;
   const Number* start_z_U_;
   Eval_F_CB eval_f_;
   Eval_G_CB eval_g_;
   Eval_Grad_F_CB eval_grad_f_;
   Eval_Jac_G_CB eval_jac_g_;
   Eval_H_CB eval_h_;
   Intermediate_CB intermediate_cb_;
   UserDataPtr user_data_;
   Number obj_scaling_;
   const Number* x_scaling_;
   const Number* g_scaling_;
 
   Number* non_const_x_;
 
   Number* x_sol_;
   Number* z_L_sol_;
   Number* z_U_sol_;
   Number* g_sol_;
   Number* lambda_sol_;
   Number* obj_sol_;
 
   const IpoptData*           ip_data_;
   IpoptCalculatedQuantities* ip_cq_;
 
   void apply_new_x(
      bool          new_x,
      Index         n,
      const Number* x
   );
 
 
   StdInterfaceTNLP();
 
   StdInterfaceTNLP(
      const StdInterfaceTNLP&
   );
 
   void operator=(
      const StdInterfaceTNLP&
   );
 
};
 
} // namespace Ipopt
 
#endif