IpTNLPAdapter.hpp

Go to the documentation of this file.

// Copyright (C) 2004, 2008 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 __IPTNLPADAPTER_HPP__
#define __IPTNLPADAPTER_HPP__
 
#include "IpNLP.hpp"
#include "IpTNLP.hpp"
#include "IpOrigIpoptNLP.hpp"
#include "IpExpansionMatrix.hpp"
#include <list>
 
namespace Ipopt
{
 
// forward declarations
class ExpansionMatrixSpace;
class IteratesVector;
class TDependencyDetector;
 
class IPOPTLIB_EXPORT TNLPAdapter : public NLP
{
public:
 
   TNLPAdapter(
      const SmartPtr<TNLP>             tnlp,
      const SmartPtr<const Journalist> jnlst = NULL
   );
 
   virtual ~TNLPAdapter();
 
   DECLARE_STD_EXCEPTION(INVALID_TNLP);
   DECLARE_STD_EXCEPTION(ERROR_IN_TNLP_DERIVATIVE_TEST);
 
   virtual bool ProcessOptions(
      const OptionsList& options,
      const std::string& prefix
   );
 
   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
   );
 
   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
   );
 
   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
   );
 
   virtual bool GetWarmStartIterate(
      IteratesVector& warm_start_iterate
   );
 
   virtual bool Eval_f(
      const Vector& x,
      Number&       f
   );
 
   virtual bool Eval_grad_f(
      const Vector& x,
      Vector&       g_f
   );
 
   virtual bool Eval_c(
      const Vector& x,
      Vector&       c
   );
 
   virtual bool Eval_jac_c(
      const Vector& x,
      Matrix&       jac_c
   );
 
   virtual bool Eval_d(
      const Vector& x,
      Vector&       d
   );
 
   virtual bool Eval_jac_d(
      const Vector& x,
      Matrix&       jac_d
   );
 
   virtual bool Eval_h(
      const Vector& x,
      Number        obj_factor,
      const Vector& yc,
      const Vector& yd,
      SymMatrix&    h
   );
 
   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;
 
   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
   );
 
   virtual void GetQuasiNewtonApproximationSpaces(
      SmartPtr<VectorSpace>& approx_space,
      SmartPtr<Matrix>&      P_approx
   );
 
   enum FixedVariableTreatmentEnum
   {
      MAKE_PARAMETER = 0,
      MAKE_PARAMETER_NODUAL,  
      MAKE_CONSTRAINT,
      RELAX_BOUNDS
   };
 
   enum DerivativeTestEnum
   {
      NO_TEST = 0,
      FIRST_ORDER_TEST,
      SECOND_ORDER_TEST,
      ONLY_SECOND_ORDER_TEST
   };
 
   enum JacobianApproxEnum
   {
      JAC_EXACT = 0,
      JAC_FINDIFF_VALUES
   };
 
   enum GradientApproxEnum
   {
      OBJGRAD_EXACT = 0,
      OBJGRAD_FINDIFF_VALUES
   };
 
   bool CheckDerivatives(
      DerivativeTestEnum deriv_test,
      Index              deriv_test_start_index
   );
 
   static void RegisterOptions(
      SmartPtr<RegisteredOptions> roptions
   );
 
   SmartPtr<TNLP> tnlp() const
   {
      return tnlp_;
   }
 
 
   void ResortX(
      const Vector& x,                   
      Number*       x_orig,              
      bool          usefixedvals = true  
   );
 
   void ResortG(
      const Vector& c,                   
      const Vector& d,                   
      Number*       g_orig,              
      bool          correctrhs = false   
   );
 
   void ResortBounds(
      const Vector& x_L,              
      Number*       x_L_orig,         
      const Vector& x_U,              
      Number*       x_U_orig          
   );
 
   IPOPT_DEPRECATED
   void ResortBnds(
      const Vector& x_L,              
      Number*       x_L_orig,         
      const Vector& x_U,              
      Number*       x_U_orig,         
      bool          clearorig = true  
   )
   {
      ResortBounds(x_L, x_L_orig, x_U, x_U_orig);
      (void) clearorig;
   }
 
   bool ResortBoundMultipliers(
      const Vector& x,                
      const Vector& y_c,              
      const Vector& y_d,              
      const Vector& z_L,              
      Number*       z_L_orig,         
      const Vector& z_U,              
      Number*       z_U_orig          
   );
 
   void GetFullDimensions(
      Index& n,  
      Index& m   
   ) const
   {
      n = n_full_x_;
      m = n_full_g_;
   }
 
   void GetFixedVariables(
      Index&  n_x_fixed,     
      Index*& x_fixed_map,   
      FixedVariableTreatmentEnum& fixed_variable_treatment  
   ) const
   {
      n_x_fixed = n_x_fixed_;
      x_fixed_map = x_fixed_map_;
      fixed_variable_treatment = fixed_variable_treatment_;
   }
 
   void GetPermutationMatrices(
      SmartPtr<const ExpansionMatrix>& P_x_full_x, 
      SmartPtr<const ExpansionMatrix>& P_x_x_L,    
      SmartPtr<const ExpansionMatrix>& P_x_x_U,    
      SmartPtr<const ExpansionMatrix>& P_c_g,      
      SmartPtr<const ExpansionMatrix>& P_d_g       
   ) const
   {
      P_x_full_x = ConstPtr(P_x_full_x_);
      P_x_x_L = ConstPtr(P_x_x_L_);
      P_x_x_U = ConstPtr(P_x_x_U_);
      P_c_g = ConstPtr(P_c_g_);
      P_d_g = ConstPtr(P_d_g_);
   }
 
   const Number* GetC_Rhs() const
   {
      return c_rhs_;
   }
 
 
private:
 
   TNLPAdapter(
      const TNLPAdapter&
   );
 
   void operator=(
      const TNLPAdapter&
   );
 
   bool DetermineDependentConstraints(
      Index             n_x_var,
      const Index*      x_not_fixed_map,
      const Number*     x_l,
      const Number*     x_u,
      const Number*     g_l,
      const Number*     g_u,
      Index             n_c,
      const Index*      c_map,
      std::list<Index>& c_deps);
 
   SmartPtr<TNLP> tnlp_;
 
   SmartPtr<const Journalist> jnlst_;
 
   SmartPtr<TDependencyDetector> dependency_detector_;
 
 
   Number nlp_lower_bound_inf_;
   Number nlp_upper_bound_inf_;
   FixedVariableTreatmentEnum fixed_variable_treatment_;
   Number bound_relax_factor_;
   /* Took this out:  Number max_onesided_bound_slack_; */
   DerivativeTestEnum derivative_test_;
   Number derivative_test_perturbation_;
   Number derivative_test_tol_;
   bool derivative_test_print_all_;
   Index derivative_test_first_index_;
   bool warm_start_same_structure_;
   HessianApproximationType hessian_approximation_;
   Index num_linear_variables_;
   JacobianApproxEnum jacobian_approximation_;
   GradientApproxEnum gradient_approximation_;
   Number findiff_perturbation_;
   Number point_perturbation_radius_;
   bool dependency_detection_with_rhs_;
 
   Number tol_;
 
 
   Index n_full_x_;
   Index n_full_g_;
   Index nz_jac_c_;
   Index nz_jac_c_no_extra_;
   Index nz_jac_d_;
   Index nz_full_jac_g_;
   Index nz_full_h_;
   Index nz_h_;
   Index n_x_fixed_;
 
   TNLP::IndexStyleEnum index_style_;
 
   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_;
 
   Number* full_x_; 
   Number* full_lambda_; 
   Number* full_g_; 
   Number* jac_g_; 
   Number* c_rhs_; 
 
   TaggedObject::Tag x_tag_for_iterates_;
   TaggedObject::Tag y_c_tag_for_iterates_;
   TaggedObject::Tag y_d_tag_for_iterates_;
   TaggedObject::Tag x_tag_for_g_;
   TaggedObject::Tag x_tag_for_jac_g_;
 
   bool update_local_x(const Vector& x);
   bool update_local_lambda(const Vector& y_c, const Vector& y_d);
 
   bool internal_eval_g(bool new_x);
   bool internal_eval_jac_g(bool new_x);
 
 
   void initialize_findiff_jac(const Index* iRow, const Index* jCol);
 
 
   SmartPtr<ExpansionMatrix> P_x_full_x_;
   SmartPtr<ExpansionMatrixSpace> P_x_full_x_space_;
 
   SmartPtr<ExpansionMatrix> P_x_x_L_;
   SmartPtr<ExpansionMatrixSpace> P_x_x_L_space_;
 
   SmartPtr<ExpansionMatrix> P_x_x_U_;
   SmartPtr<ExpansionMatrixSpace> P_x_x_U_space_;
 
   SmartPtr<ExpansionMatrixSpace> P_c_g_space_;
   SmartPtr<ExpansionMatrix> P_c_g_;
 
   SmartPtr<ExpansionMatrixSpace> P_d_g_space_;
   SmartPtr<ExpansionMatrix> P_d_g_;
 
   Index* jac_idx_map_;
   Index* h_idx_map_;
 
   Index* x_fixed_map_;
 
   std::vector<Index> jac_fixed_idx_map_;
   std::vector<Index> jac_fixed_iRow_;
   std::vector<Index> jac_fixed_jCol_;
 
 
   Index findiff_jac_nnz_;
   Index* findiff_jac_ia_;
   Index* findiff_jac_ja_;
   Index* findiff_jac_postriplet_;
   Number* findiff_x_l_;
   Number* findiff_x_u_;
};
 
} // namespace Ipopt
 
#endif