IpOrigIpoptNLP.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 __IPORIGIPOPTNLP_HPP__
#define __IPORIGIPOPTNLP_HPP__
 
#include "IpIpoptNLP.hpp"
#include "IpException.hpp"
#include "IpTimingStatistics.hpp"
 
namespace Ipopt
{
 
enum HessianApproximationType
{
   EXACT = 0,
   LIMITED_MEMORY
};
 
enum HessianApproximationSpace
{
   NONLINEAR_VARS = 0,
   ALL_VARS
};
 
class IPOPTLIB_EXPORT OrigIpoptNLP: public IpoptNLP
{
public:
 
   OrigIpoptNLP(
      const SmartPtr<const Journalist>& jnlst,             
      const SmartPtr<NLP>&              nlp,               
      const SmartPtr<NLPScalingObject>& nlp_scaling,       
      TimingStatistics&                 timing_statistics  
   );
 
   virtual ~OrigIpoptNLP();
 
   virtual bool Initialize(
      const Journalist&  jnlst,
      const OptionsList& options,
      const std::string& prefix
   );
 
   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
   );
 
   virtual bool GetWarmStartIterate(
      IteratesVector& warm_start_iterate
   )
   {
      return nlp_->GetWarmStartIterate(warm_start_iterate);
   }
 
 
   virtual Number f(
      const Vector& x
   );
 
   virtual Number f(
      const Vector& x,
      Number mu
   );
 
   virtual SmartPtr<const Vector> grad_f(
      const Vector& x
   );
 
   virtual SmartPtr<const Vector> grad_f(
      const Vector& x,
      Number        mu
   );
 
   virtual SmartPtr<const Vector> c(
      const Vector& x
   );
 
   virtual SmartPtr<const Matrix> jac_c(
      const Vector& x
   );
 
   virtual SmartPtr<const Vector> d(
      const Vector& x
   );
 
   virtual SmartPtr<const Matrix> jac_d(
      const Vector& x
   );
 
   virtual SmartPtr<const SymMatrix> h(
      const Vector& x,
      Number        obj_factor,
      const Vector& yc,
      const Vector& yd
   );
 
   virtual SmartPtr<const SymMatrix> h(
      const Vector& x,
      Number        obj_factor,
      const Vector& yc,
      const Vector& yd,
      Number        mu
   );
 
   virtual SmartPtr<const SymMatrix> uninitialized_h();
 
   virtual SmartPtr<const Vector> x_L() const
   {
      return x_L_;
   }
 
   virtual SmartPtr<const Matrix> Px_L() const
   {
      return Px_L_;
   }
 
   virtual SmartPtr<const Vector> orig_x_L() const
   {
      return orig_x_L_;
   }
 
   virtual SmartPtr<const Vector> x_U() const
   {
      return x_U_;
   }
 
   virtual SmartPtr<const Matrix> Px_U() const
   {
      return Px_U_;
   }
 
   virtual SmartPtr<const Vector> orig_x_U() const
   {
      return orig_x_U_;
   }
 
   virtual SmartPtr<const Vector> d_L() const
   {
      return d_L_;
   }
 
   virtual SmartPtr<const Matrix> Pd_L() const
   {
      return Pd_L_;
   }
 
   virtual SmartPtr<const Vector> orig_d_L() const
   {
      return orig_d_L_;
   }
 
   virtual SmartPtr<const Vector> d_U() const
   {
      return d_U_;
   }
 
   virtual SmartPtr<const Matrix> Pd_U() const
   {
      return Pd_U_;
   }
 
   virtual SmartPtr<const Vector> orig_d_U() const
   {
      return orig_d_U_;
   }
 
   virtual SmartPtr<const SymMatrixSpace> HessianMatrixSpace() const
   {
      return h_space_;
   }
 
   virtual SmartPtr<const VectorSpace> x_space() const
   {
      return x_space_;
   }
 
   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
   );
 
   virtual void AdjustVariableBounds(
      const Vector& new_x_L,
      const Vector& new_x_U,
      const Vector& new_d_L,
      const Vector& new_d_U
   );
 
   virtual Index f_evals() const
   {
      return f_evals_;
   }
   virtual Index grad_f_evals() const
   {
      return grad_f_evals_;
   }
   virtual Index c_evals() const
   {
      return c_evals_;
   }
   virtual Index jac_c_evals() const
   {
      return jac_c_evals_;
   }
   virtual Index d_evals() const
   {
      return d_evals_;
   }
   virtual Index jac_d_evals() const
   {
      return jac_d_evals_;
   }
   virtual Index h_evals() const
   {
      return h_evals_;
   }
 
   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
   );
 
   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
   );
 
   static void RegisterOptions(
      SmartPtr<RegisteredOptions> roptions
   );
 
   SmartPtr<NLP> nlp()
   {
      return nlp_;
   }
 
private:
   SmartPtr<const Journalist> jnlst_;
 
   SmartPtr<NLP> nlp_;
 
   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> h_space_;
 
   SmartPtr<const MatrixSpace> scaled_jac_c_space_;
   SmartPtr<const MatrixSpace> scaled_jac_d_space_;
   SmartPtr<const SymMatrixSpace> scaled_h_space_;
 
 
   CachedResults<Number> f_cache_;
 
   CachedResults<SmartPtr<const Vector> > grad_f_cache_;
 
   CachedResults<SmartPtr<const Vector> > c_cache_;
 
   CachedResults<SmartPtr<const Matrix> > jac_c_cache_;
 
   CachedResults<SmartPtr<const Vector> > d_cache_;
 
   CachedResults<SmartPtr<const Matrix> > jac_d_cache_;
 
   CachedResults<SmartPtr<const SymMatrix> > h_cache_;
 
   CachedResults<SmartPtr<const Vector> > unscaled_x_cache_;
 
   SmartPtr<const Vector> x_L_;
 
   SmartPtr<const Matrix> Px_L_;
 
   SmartPtr<const Vector> x_U_;
 
   SmartPtr<const Matrix> Px_U_;
 
   SmartPtr<const Vector> d_L_;
 
   SmartPtr<const Matrix> Pd_L_;
 
   SmartPtr<const Vector> d_U_;
 
   SmartPtr<const Matrix> Pd_U_;
 
   SmartPtr<const Vector> orig_x_L_;
 
   SmartPtr<const Vector> orig_x_U_;
 
   SmartPtr<const Vector> orig_d_L_;
 
   SmartPtr<const Vector> orig_d_U_;
 
 
   OrigIpoptNLP();
 
   OrigIpoptNLP(
      const OrigIpoptNLP&
   );
 
   void operator=(
      const OrigIpoptNLP&
   );
 
 
   void relax_bounds(
      Number  bound_relax_factor,
      Vector& bounds
   );
 
   SmartPtr<const Vector> get_unscaled_x(
      const Vector& x
   );
 
 
   Number bound_relax_factor_;
 
   Number constr_viol_tol_;
 
   bool honor_original_bounds_;
 
   bool warm_start_same_structure_;
 
   HessianApproximationType hessian_approximation_;
 
   HessianApproximationSpace hessian_approximation_space_;
 
   bool check_derivatives_for_naninf_;
 
   bool grad_f_constant_;
 
   bool jac_c_constant_;
 
   bool jac_d_constant_;
 
   bool hessian_constant_;
 
   Index f_evals_;
   Index grad_f_evals_;
   Index c_evals_;
   Index jac_c_evals_;
   Index d_evals_;
   Index jac_d_evals_;
   Index h_evals_;
 
   bool initialized_;
 
   TimingStatistics& timing_statistics_;
};
 
} // namespace Ipopt
 
#endif