diff options
Diffstat (limited to 'newstructure/thirdparty/linux/include/coin/BonBranchingTQP.hpp')
| -rw-r--r-- | newstructure/thirdparty/linux/include/coin/BonBranchingTQP.hpp | 197 |
1 files changed, 197 insertions, 0 deletions
diff --git a/newstructure/thirdparty/linux/include/coin/BonBranchingTQP.hpp b/newstructure/thirdparty/linux/include/coin/BonBranchingTQP.hpp new file mode 100644 index 0000000..f718419 --- /dev/null +++ b/newstructure/thirdparty/linux/include/coin/BonBranchingTQP.hpp @@ -0,0 +1,197 @@ +// (C) Copyright International Business Machines Corporation and +// Carnegie Mellon University 2006, 2008 +// All Rights Reserved. +// This code is published under the Eclipse Public License. +// +// Authors : +// Andreas Waechter, International Business Machines Corporation +// (derived from BonTMINLP2TNLP.hpp) 12/22/2006 + +#ifndef __BONBRANCHINGTQP_HPP__ +#define __BONBRANCHINGTQP_HPP__ + +#include "BonTMINLP2TNLP.hpp" + +namespace Bonmin +{ + /** This is an adapter class that converts a TMINLP2TNLP object into + * a TNLP, which is now just a QP. The QP is the linear quadratic + * of the TNLP at the optimal point. The purpose of the + * BranchingTQP is that it is used in a strong-branching framework, + * strong branching is only done for the QP approximation of the + * TNLP, not on the TNLP itself. The variables of the QP are the + * displacement from the reference point. + */ + class BranchingTQP : public Ipopt::TNLP + { + public: + /**@name Constructors/Destructors */ + //@{ + BranchingTQP(Ipopt::SmartPtr<TMINLP2TNLP> tminlp2tnlp); + + /** Default destructor */ + virtual ~BranchingTQP(); + //@} + + /**@name methods to gather information about the NLP, only those + * that need to be overloaded from TNLP */ + //@{ + virtual bool get_nlp_info(Ipopt::Index& n, Ipopt::Index& m, Ipopt::Index& nnz_jac_g, + Ipopt::Index& nnz_h_lag, Ipopt::TNLP::IndexStyleEnum& index_style); + virtual bool get_bounds_info(Ipopt::Index n, Ipopt::Number* x_l, Ipopt::Number* x_u, + Ipopt::Index m, Ipopt::Number* g_l, Ipopt::Number* g_u); + /** Returns the constraint linearity. array should be alocated + * with length at least n. Since this is a QP, all constraints are + * linear.*/ + virtual bool get_constraints_linearity(Ipopt::Index m, LinearityType* const_types); + /** Method called by Ipopt to get the starting point. The bools + * init_x and init_lambda are both inputs and outputs. As inputs, + * they indicate whether or not the algorithm wants you to + * initialize x and lambda respectively. If, for some reason, the + * algorithm wants you to initialize these and you cannot, set + * the respective bool to false. + */ + virtual bool get_starting_point(Ipopt::Index n, bool init_x, Ipopt::Number* x, + bool init_z, Ipopt::Number* z_L, Ipopt::Number* z_U, + Ipopt::Index m, bool init_lambda, + Ipopt::Number* lambda); + + /** Returns the value of the objective function in x*/ + virtual bool eval_f(Ipopt::Index n, const Ipopt::Number* x, bool new_x, + Ipopt::Number& obj_value); + + /** Returns the vector of the gradient of + * the objective w.r.t. x */ + virtual bool eval_grad_f(Ipopt::Index n, const Ipopt::Number* x, bool new_x, + Ipopt::Number* grad_f); + + /** Returns the vector of constraint values in x*/ + virtual bool eval_g(Ipopt::Index n, const Ipopt::Number* x, bool new_x, + Ipopt::Index m, Ipopt::Number* g); + + /** Returns the jacobian of the + * constraints. The vectors iRow and jCol only need to be set + * once. The first call is used to set the structure only (iRow + * and jCol will be non-NULL, and values will be NULL) For + * subsequent calls, iRow and jCol will be NULL. */ + virtual bool eval_jac_g(Ipopt::Index n, const Ipopt::Number* x, bool new_x, + Ipopt::Index m, Ipopt::Index nele_jac, Ipopt::Index* iRow, + Ipopt::Index *jCol, Ipopt::Number* values); + + /** Return the hessian of the + * lagrangian. The vectors iRow and jCol only need to be set once + * (during the first call). The first call is used to set the + * structure only (iRow and jCol will be non-NULL, and values + * will be NULL) For subsequent calls, iRow and jCol will be + * NULL. This matrix is symmetric - specify the lower diagonal + * only */ + virtual bool eval_h(Ipopt::Index n, const Ipopt::Number* x, bool new_x, + Ipopt::Number obj_factor, Ipopt::Index m, const Ipopt::Number* lambda, + bool new_lambda, Ipopt::Index nele_hess, + Ipopt::Index* iRow, Ipopt::Index* jCol, Ipopt::Number* values); + virtual void finalize_solution(Ipopt::SolverReturn status, + Ipopt::Index n, const Ipopt::Number* x, const Ipopt::Number* z_L, const Ipopt::Number* z_U, + Ipopt::Index m, const Ipopt::Number* g, const Ipopt::Number* lambda, + Ipopt::Number obj_value, + const Ipopt::IpoptData* ip_data, + Ipopt::IpoptCalculatedQuantities* ip_cq); + //@} + + /** Accessor Methods for QP data */ + //@{ + const Ipopt::Number ObjVal() + { + return obj_val_; + } + const Ipopt::Number* ObjGrad() + { + return obj_grad_; + } + const Ipopt::Number* ObjHessVals() + { + return obj_hess_; + } + const Ipopt::Index* ObjHessIRow() + { + return obj_hess_irow_; + } + const Ipopt::Index* ObjHessJCol() + { + return obj_hess_jcol_; + } + const Ipopt::Number* ConstrRhs() + { + return g_vals_; + } + const Ipopt::Number* ConstrJacVals() + { + return g_jac_; + } + const Ipopt::Index* ConstrJacIRow() + { + return g_jac_irow_; + } + const Ipopt::Index* ConstrJacJCol() + { + return g_jac_jcol_; + } + //@} + + 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. */ + //@{ + /** Default Constructor */ + BranchingTQP(); + + /** Copy Constructor */ + BranchingTQP(const BranchingTQP&); + + /** Overloaded Equals Operator */ + void operator=(const BranchingTQP&); + //@} + + /** @name static information about the QP's constraints and + * objective function */ + //@{ + Ipopt::Number obj_val_; + Ipopt::Number* obj_grad_; + Ipopt::Number* obj_hess_; + Ipopt::Index* obj_hess_irow_; + Ipopt::Index* obj_hess_jcol_; + Ipopt::Number* g_vals_; + Ipopt::Number* g_jac_; + Ipopt::Index* g_jac_irow_; + Ipopt::Index* g_jac_jcol_; + //@} + + /** @name Data from the MINLP */ + //@{ + Ipopt::Index n_; + Ipopt::Index m_; + Ipopt::Index nnz_jac_g_; + Ipopt::Index nnz_h_lag_; + Ipopt::TNLP::IndexStyleEnum index_style_; + //@} + + /** Copy of original x_sol_. x_sol_ is changed after the first QP + * has been solved once. */ + Ipopt::Number* x_sol_copy_; + + /** Copy of original duals_sol_. duals_sol_ is changed after the + * first QP has been solved once. */ + Ipopt::Number* duals_sol_copy_; + + /** Pointer to the TMINLP2TNLP model which stores the bounds + * information */ + Ipopt::SmartPtr<TMINLP2TNLP> tminlp2tnlp_; + }; + +} // namespace Ipopt + +#endif |