IpRestoIpoptNLP.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 __IPRESTOIPOPTNLP_HPP__
#define __IPRESTOIPOPTNLP_HPP__
 
#include "IpIpoptNLP.hpp"
#include "IpIpoptData.hpp"
#include "IpIpoptCalculatedQuantities.hpp"
#include "IpCompoundMatrix.hpp"
#include "IpCompoundSymMatrix.hpp"
#include "IpCompoundVector.hpp"
#include "IpIdentityMatrix.hpp"
#include "IpDiagMatrix.hpp"
#include "IpZeroMatrix.hpp"
#include "IpOrigIpoptNLP.hpp"
 
namespace Ipopt
{
 
class RestoIpoptNLP: public IpoptNLP
{
public:
   RestoIpoptNLP(
      IpoptNLP&                  orig_ip_nlp,
      IpoptData&                 orig_ip_data,
      IpoptCalculatedQuantities& orig_ip_cq
   );
 
   ~RestoIpoptNLP();
 
   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 false;
   }
 
   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 objective_depends_on_mu() const
   {
      return true;
   }
 
   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 GetRawPtr(x_L_);
   }
 
   virtual SmartPtr<const Matrix> Px_L() const
   {
      return GetRawPtr(Px_L_);
   }
 
   virtual SmartPtr<const Vector> x_U() const
   {
      return GetRawPtr(x_U_);
   }
 
   virtual SmartPtr<const Matrix> Px_U() const
   {
      return GetRawPtr(Px_U_);
   }
 
   virtual SmartPtr<const Vector> d_L() const
   {
      return GetRawPtr(d_L_);
   }
 
   virtual SmartPtr<const Matrix> Pd_L() const
   {
      return GetRawPtr(Pd_L_);
   }
 
   virtual SmartPtr<const Vector> d_U() const
   {
      return GetRawPtr(d_U_);
   }
 
   virtual SmartPtr<const Matrix> Pd_U() const
   {
      return GetRawPtr(Pd_U_);
   }
 
   virtual SmartPtr<const SymMatrixSpace> HessianMatrixSpace() const
   {
      return GetRawPtr(h_space_);
   }
 
   virtual SmartPtr<const VectorSpace> x_space() const
   {
      return GetRawPtr(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
   );
 
   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
   );
 
   IpoptNLP& OrigIpNLP() const
   {
      return *orig_ip_nlp_;
   }
 
   IpoptData& OrigIpData() const
   {
      return *orig_ip_data_;
   }
 
   IpoptCalculatedQuantities& OrigIpCq() const
   {
      return *orig_ip_cq_;
   }
 
   Number Rho() const
   {
      return rho_;
   }
 
   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_;
   }
 
   Number Eta(
      Number mu
   ) const;
 
   SmartPtr<const Vector> DR_x() const
   {
      return ConstPtr(dr_x_);
   }
 
   static void RegisterOptions(
      SmartPtr<RegisteredOptions> roptions
   );
 
private:
 
   SmartPtr<IpoptNLP> orig_ip_nlp_;
 
   SmartPtr<IpoptData> orig_ip_data_;
 
   SmartPtr<IpoptCalculatedQuantities> orig_ip_cq_;
 
   SmartPtr<CompoundVectorSpace> x_space_;
 
   SmartPtr<CompoundVectorSpace> c_space_;
 
   SmartPtr<CompoundVectorSpace> d_space_;
 
   SmartPtr<CompoundVectorSpace> x_l_space_;
 
   SmartPtr<CompoundMatrixSpace> px_l_space_;
 
   SmartPtr<CompoundVectorSpace> x_u_space_;
 
   SmartPtr<CompoundMatrixSpace> px_u_space_;
 
   SmartPtr<CompoundVectorSpace> d_l_space_;
 
   SmartPtr<CompoundMatrixSpace> pd_l_space_;
 
   SmartPtr<CompoundVectorSpace> d_u_space_;
 
   SmartPtr<CompoundMatrixSpace> pd_u_space_;
 
   SmartPtr<CompoundMatrixSpace> jac_c_space_;
 
   SmartPtr<CompoundMatrixSpace> jac_d_space_;
 
   SmartPtr<CompoundSymMatrixSpace> h_space_;
 
 
   SmartPtr<CompoundVector> x_L_;
 
   SmartPtr<CompoundMatrix> Px_L_;
 
   SmartPtr<CompoundVector> x_U_;
 
   SmartPtr<CompoundMatrix> Px_U_;
 
   SmartPtr<CompoundVector> d_L_;
 
   SmartPtr<CompoundMatrix> Pd_L_;
 
   SmartPtr<CompoundVector> d_U_;
 
   SmartPtr<CompoundMatrix> Pd_U_;
 
 
   Number rho_;
 
   Number eta_factor_;
 
   Number eta_mu_exponent_;
 
   // TODO in the following we should use pointers to CONST values
   // TODO We can get rid of one of the dr DR
   SmartPtr<Vector> dr_x_;
   SmartPtr<DiagMatrix> DR_x_;
 
   SmartPtr<Vector> x_ref_;
 
 
   RestoIpoptNLP();
 
   RestoIpoptNLP(
      const RestoIpoptNLP&
   );
 
   void operator=(
      const RestoIpoptNLP&
   );
 
 
   bool evaluate_orig_obj_at_resto_trial_;
 
   HessianApproximationType hessian_approximation_;
 
   bool initialized_;
 
   Index f_evals_;
   Index grad_f_evals_;
   Index c_evals_;
   Index jac_c_evals_;
   Index d_evals_;
   Index jac_d_evals_;
   Index h_evals_;
};
 
} // namespace Ipopt
 
#endif