IpTNLP.hpp

Go to the documentation of this file.

// Copyright (C) 2004, 2009 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 __IPTNLP_HPP__
#define __IPTNLP_HPP__
 
#include "IpoptConfig.h"
#include "IpUtils.hpp"
#include "IpReferenced.hpp"
#include "IpException.hpp"
#include "IpAlgTypes.hpp"
#include "IpReturnCodes.hpp"
 
#include <map>
 
namespace Ipopt
{
// forward declarations
class IpoptData;
class IpoptCalculatedQuantities;
class IteratesVector;
 
class IPOPTLIB_EXPORT TNLP : public ReferencedObject
{
public:
 
   enum LinearityType
   {
      LINEAR,    
      NON_LINEAR 
   };
 
   TNLP()
   { }
 
   virtual ~TNLP()
   { }
 
   DECLARE_STD_EXCEPTION(INVALID_TNLP);
 
   typedef std::map<std::string, std::vector<std::string> > StringMetaDataMapType;
   typedef std::map<std::string, std::vector<Index> > IntegerMetaDataMapType;
   typedef std::map<std::string, std::vector<Number> > NumericMetaDataMapType;
 
   enum IndexStyleEnum
   {
      C_STYLE       = 0,
      FORTRAN_STYLE = 1
   };
 
 
   // [TNLP_get_nlp_info]
   virtual bool get_nlp_info(
      Index&          n,
      Index&          m,
      Index&          nnz_jac_g,
      Index&          nnz_h_lag,
      IndexStyleEnum& index_style
   ) = 0;
   // [TNLP_get_nlp_info]
 
   // [TNLP_get_var_con_metadata]
   virtual bool get_var_con_metadata(
      Index                   n,
      StringMetaDataMapType&  var_string_md,
      IntegerMetaDataMapType& var_integer_md,
      NumericMetaDataMapType& var_numeric_md,
      Index                   m,
      StringMetaDataMapType&  con_string_md,
      IntegerMetaDataMapType& con_integer_md,
      NumericMetaDataMapType& con_numeric_md
   )
   // [TNLP_get_var_con_metadata]
   {
      (void) n;
      (void) var_string_md;
      (void) var_integer_md;
      (void) var_numeric_md;
      (void) m;
      (void) con_string_md;
      (void) con_integer_md;
      (void) con_numeric_md;
      return false;
   }
 
   // [TNLP_get_bounds_info]
   virtual bool get_bounds_info(
      Index   n,
      Number* x_l,
      Number* x_u,
      Index   m,
      Number* g_l,
      Number* g_u
   ) = 0;
   // [TNLP_get_bounds_info]
 
   // [TNLP_get_scaling_parameters]
   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
   )
   // [TNLP_get_scaling_parameters]
   {
      (void) obj_scaling;
      (void) use_x_scaling;
      (void) n;
      (void) x_scaling;
      (void) use_g_scaling;
      (void) m;
      (void) g_scaling;
      return false;
   }
 
   // [TNLP_get_variables_linearity]
   virtual bool get_variables_linearity(
      Index          n,
      LinearityType* var_types
   )
   // [TNLP_get_variables_linearity]
   {
      (void) n;
      (void) var_types;
      return false;
   }
 
   // [TNLP_get_constraints_linearity]
   virtual bool get_constraints_linearity(
      Index          m,
      LinearityType* const_types
   )
   // [TNLP_get_constraints_linearity]
   {
      (void) m;
      (void) const_types;
      return false;
   }
 
   // [TNLP_get_starting_point]
   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
   ) = 0;
   // [TNLP_get_starting_point]
 
   // [TNLP_get_warm_start_iterate]
   virtual bool get_warm_start_iterate(
      IteratesVector& warm_start_iterate 
   )
   {
      (void) warm_start_iterate;
      return false;
   }
   // [TNLP_get_warm_start_iterate]
 
   // [TNLP_eval_f]
   virtual bool eval_f(
      Index         n,
      const Number* x,
      bool          new_x,
      Number&       obj_value
   ) = 0;
   // [TNLP_eval_f]
 
   // [TNLP_eval_grad_f]
   virtual bool eval_grad_f(
      Index         n,
      const Number* x,
      bool          new_x,
      Number*       grad_f
   ) = 0;
   // [TNLP_eval_grad_f]
 
   // [TNLP_eval_g]
   virtual bool eval_g(
      Index         n,
      const Number* x,
      bool          new_x,
      Index         m,
      Number*       g
   ) = 0;
   // [TNLP_eval_g]
 
   // [TNLP_eval_jac_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
   ) = 0;
   // [TNLP_eval_jac_g]
 
   // [TNLP_eval_h]
   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
   )
   // [TNLP_eval_h]
   {
      (void) n;
      (void) x;
      (void) new_x;
      (void) obj_factor;
      (void) m;
      (void) lambda;
      (void) new_lambda;
      (void) nele_hess;
      (void) iRow;
      (void) jCol;
      (void) values;
      return false;
   }
 
   // [TNLP_get_number_of_nonlinear_variables]
   virtual Index get_number_of_nonlinear_variables()
   // [TNLP_get_number_of_nonlinear_variables]
   {
      return -1;
   }
 
   // [TNLP_get_list_of_nonlinear_variables]
   virtual bool get_list_of_nonlinear_variables(
      Index  num_nonlin_vars,
      Index* pos_nonlin_vars
   )
   // [TNLP_get_list_of_nonlinear_variables]
   {
      (void) num_nonlin_vars;
      (void) pos_nonlin_vars;
      return false;
   }
 
 
   // [TNLP_finalize_solution]
   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
   ) = 0;
   // [TNLP_finalize_solution]
 
   // [TNLP_finalize_metadata]
   virtual void finalize_metadata(
      Index                         n,
      const StringMetaDataMapType&  var_string_md,
      const IntegerMetaDataMapType& var_integer_md,
      const NumericMetaDataMapType& var_numeric_md,
      Index                         m,
      const StringMetaDataMapType&  con_string_md,
      const IntegerMetaDataMapType& con_integer_md,
      const NumericMetaDataMapType& con_numeric_md
   )
   // [TNLP_finalize_metadata]
   {
      (void) n;
      (void) var_string_md;
      (void) var_integer_md;
      (void) var_numeric_md;
      (void) m;
      (void) con_string_md;
      (void) con_integer_md;
      (void) con_numeric_md;
   }
 
   // [TNLP_intermediate_callback]
   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
   )
   // [TNLP_intermediate_callback]
   {
      (void) mode;
      (void) iter;
      (void) obj_value;
      (void) inf_pr;
      (void) inf_du;
      (void) mu;
      (void) d_norm;
      (void) regularization_size;
      (void) alpha_du;
      (void) alpha_pr;
      (void) ls_trials;
      (void) ip_data;
      (void) ip_cq;
      return true;
   }
 
 
   // [TNLP_get_curr_iterate]
   bool get_curr_iterate(
      const IpoptData*           ip_data,
      IpoptCalculatedQuantities* ip_cq,
      bool                       scaled,
      Index                      n,
      Number*                    x,
      Number*                    z_L,
      Number*                    z_U,
      Index                      m,
      Number*                    g,
      Number*                    lambda
   ) const;
   // [TNLP_get_curr_iterate]
 
   // [TNLP_get_curr_violations]
   bool get_curr_violations(
      const IpoptData*           ip_data,
      IpoptCalculatedQuantities* ip_cq,
      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;
   // [TNLP_get_curr_violations]
 
private:
 
   TNLP(
      const TNLP&
   );
 
   void operator=(
      const TNLP&
   );
};
 
} // namespace Ipopt
 
#endif