// Copyright (C) 2004, 2006 International Business Machines and others. // All Rights Reserved. // This code is published under the Common Public License. // // $Id: IpNLP.hpp 1327 2008-09-18 19:01:17Z andreasw $ // // Authors: Carl Laird, Andreas Waechter IBM 2004-08-13 #ifndef __IPNLP_HPP__ #define __IPNLP_HPP__ #include "IpUtils.hpp" #include "IpVector.hpp" #include "IpSmartPtr.hpp" #include "IpMatrix.hpp" #include "IpSymMatrix.hpp" #include "IpOptionsList.hpp" #include "IpAlgTypes.hpp" #include "IpReturnCodes.hpp" namespace Ipopt { // forward declarations class IpoptData; class IpoptCalculatedQuantities; class IteratesVector; /** Brief Class Description. * Detailed Class Description. */ class NLP : public ReferencedObject { public: /**@name Constructors/Destructors */ //@{ /** Default constructor */ NLP() {} /** Default destructor */ virtual ~NLP() {} //@} /** Exceptions */ //@{ DECLARE_STD_EXCEPTION(USER_SCALING_NOT_IMPLEMENTED); DECLARE_STD_EXCEPTION(INVALID_NLP); //@} /** @name NLP Initialization (overload in * derived classes).*/ //@{ /** Overload if you want the chance to process options or parameters that * may be specific to the NLP */ virtual bool ProcessOptions(const OptionsList& options, const std::string& prefix) { return true; } /** Method for creating the derived vector / matrix types. The * Hess_lagrangian_space pointer can be NULL if a quasi-Newton * options is chosen. */ virtual bool GetSpaces(SmartPtr& x_space, SmartPtr& c_space, SmartPtr& d_space, SmartPtr& x_l_space, SmartPtr& px_l_space, SmartPtr& x_u_space, SmartPtr& px_u_space, SmartPtr& d_l_space, SmartPtr& pd_l_space, SmartPtr& d_u_space, SmartPtr& pd_u_space, SmartPtr& Jac_c_space, SmartPtr& Jac_d_space, SmartPtr& Hess_lagrangian_space)=0; /** Method for obtaining the bounds information */ 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)=0; /** Method for obtaining the starting point for all the * iterates. ToDo it might not make sense to ask for initial * values for v_L and v_U? */ virtual bool GetStartingPoint( SmartPtr x, bool need_x, SmartPtr y_c, bool need_y_c, SmartPtr y_d, bool need_y_d, SmartPtr z_L, bool need_z_L, SmartPtr z_U, bool need_z_U )=0; /** Method for obtaining an entire iterate as a warmstart point. * The incoming IteratesVector has to be filled. The default * dummy implementation returns false. */ virtual bool GetWarmStartIterate(IteratesVector& warm_start_iterate) { return false; } //@} /** @name NLP evaluation routines (overload * in derived classes. */ //@{ virtual bool Eval_f(const Vector& x, Number& f) = 0; virtual bool Eval_grad_f(const Vector& x, Vector& g_f) = 0; virtual bool Eval_c(const Vector& x, Vector& c) = 0; virtual bool Eval_jac_c(const Vector& x, Matrix& jac_c) = 0; virtual bool Eval_d(const Vector& x, Vector& d) = 0; virtual bool Eval_jac_d(const Vector& x, Matrix& jac_d) = 0; virtual bool Eval_h(const Vector& x, Number obj_factor, const Vector& yc, const Vector& yd, SymMatrix& h) = 0; //@} /** @name NLP solution routines. Have default dummy * implementations that can be overloaded. */ //@{ /** This method is called at the very end of the optimization. It * provides the final iterate to the user, so that it can be * stored as the solution. The status flag indicates the outcome * of the optimization, where SolverReturn is defined in * IpAlgTypes.hpp. */ 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) {} /** This method is called once per iteration, after the iteration * summary output has been printed. It provides the current * information to the user to do with it anything she wants. It * also allows the user to ask for a premature termination of the * optimization by returning false, in which case Ipopt will * terminate with a corresponding return status. The basic * information provided in the argument list has the quantities * values printed in the iteration summary line. If more * information is required, a user can obtain it from the IpData * and IpCalculatedQuantities objects. However, note that the * provided quantities are all for the problem that Ipopt sees, * i.e., the quantities might be scaled, fixed variables might be * sorted out, etc. The status indicates things like whether the * algorithm is in the restoration phase... In the restoration * phase, the dual variables are probably not not changing. */ 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) { return true; } //@} /** Routines to get the scaling parameters. These do not need to * be overloaded unless the options are set for User scaling */ //@{ virtual void GetScalingParameters( const SmartPtr x_space, const SmartPtr c_space, const SmartPtr d_space, Number& obj_scaling, SmartPtr& x_scaling, SmartPtr& c_scaling, SmartPtr& d_scaling) const { THROW_EXCEPTION(USER_SCALING_NOT_IMPLEMENTED, "You have set options for user provided scaling, but have" " not implemented GetScalingParameters in the NLP interface"); } //@} /** Method for obtaining the subspace in which the limited-memory * Hessian approximation should be done. This is only called if * the limited-memory Hessian approximation is chosen. Since the * Hessian is zero in the space of all variables that appear in * the problem functions only linearly, this allows the user to * provide a VectorSpace for all nonlinear variables, and an * ExpansionMatrix to lift from this VectorSpace to the * VectorSpace of the primal variables x. If the returned values * are NULL, it is assumed that the Hessian is to be approximated * in the space of all x variables. The default instantiation of * this method returns NULL, and a user only has to overwrite * this method if the approximation is to be done only in a * subspace. */ virtual void GetQuasiNewtonApproximationSpaces(SmartPtr& approx_space, SmartPtr& P_approx) { approx_space = NULL; P_approx = NULL; } private: /**@name Default Compiler Generated Methods * (Hidden to avoid implicit creation/calling). * These methods are not implemented and * we do not want the compiler to implement * them for us, so we declare them private * and do not define them. This ensures that * they will not be implicitly created/called. */ //@{ /** Copy Constructor */ NLP(const NLP&); /** Overloaded Equals Operator */ void operator=(const NLP&); //@} }; } // namespace Ipopt #endif