diff options
Diffstat (limited to 'newstructure/thirdparty/linux/include/coin/BonTMINLPLinObj.hpp')
| -rw-r--r-- | newstructure/thirdparty/linux/include/coin/BonTMINLPLinObj.hpp | 216 |
1 files changed, 216 insertions, 0 deletions
diff --git a/newstructure/thirdparty/linux/include/coin/BonTMINLPLinObj.hpp b/newstructure/thirdparty/linux/include/coin/BonTMINLPLinObj.hpp new file mode 100644 index 0000000..819bc57 --- /dev/null +++ b/newstructure/thirdparty/linux/include/coin/BonTMINLPLinObj.hpp @@ -0,0 +1,216 @@ +// (C) Copyright International Business Machines Corporation 2007 +// All Rights Reserved. +// +// Authors : +// Pierre Bonami, International Business Machines Corporation +// +// Date : 08/16/2007 + + +#ifndef TMINLPLinObj_H +#define TMINLPLinObj_H + +#include "BonTMINLP.hpp" + +namespace Bonmin { +/** From a TMINLP, this class adapts to another TMINLP where the original objective is transformed into a constraint + by adding an extra variable which is minimized. + + More precisely + \f[ + \begin{array}{l} + \min f(x)\\ + s.t\\ + g_l \leq g(x) \leq g_u\\ + x_l \leq x \leq u + \end{array} + \f] + is transformed ino + \begin{array}{l} + \min \eta\\ + s.t\\ + -\infty \leq f(x) - \eta \leq 0\\ + g_l \leq g(x) \leq g_u\\ + x_l \leq x \leq u + \end{array} + \f] + The objective is put as first constraint of the problem and the extra variable is the last one. + .*/ +class TMINLPLinObj: public Bonmin::TMINLP { + public: + /** Default constructor*/ + TMINLPLinObj(); + + /** destructor.*/ + virtual ~TMINLPLinObj(); + + /** set reference TMINLP */ + void setTminlp(Ipopt::SmartPtr<TMINLP> tminlp); + + /**@name methods to gather information about the MINLP */ + //@{ + /** Return the number of variables + * and constraints, and the number of non-zeros in the jacobian and + * the hessian. Call tminlp_ one but number of constraints and non-zeroes in the jacobian is stored internally.*/ + 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); + /** Return scaling parameters. If tminlp_ method returns true, translate + * constraint scaling (if asked). + */ + virtual bool get_scaling_parameters(Ipopt::Number& obj_scaling, + bool& use_x_scaling, Ipopt::Index n, + Ipopt::Number* x_scaling, + bool& use_g_scaling, Ipopt::Index m, + Ipopt::Number* g_scaling); + + + /** Get the variable type. Just call tminlp_'s method;. */ + virtual bool get_variables_types(Ipopt::Index n, VariableType* var_types){ + assert(IsValid(tminlp_)); + assert(n == n_); + var_types[n-1] = TMINLP::CONTINUOUS; + return tminlp_->get_variables_types(n - 1, var_types); + } + + /** Return the constraints linearity. Call tminlp_'s method and translate. + */ + virtual bool get_constraints_linearity(Ipopt::Index m, + Ipopt::TNLP::LinearityType* const_types); + + /** Return the information about the bound + * on the variables and constraints. Call tminlp_'s method and translate + * constraints bounds.*/ + 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); + + /** Return the starting point. + Have to translate z_L and z_U. + */ + 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); + + /** Return the value of the objective function. + * Just call tminlp_ method. */ + virtual bool eval_f(Ipopt::Index n, const Ipopt::Number* x, bool new_x, + Ipopt::Number& obj_value){ + assert(n == n_); + obj_value = x[n-1]; + return true;} + + /** Return the vector of the gradient of + * the objective w.r.t. x. Just call tminlp_ method. */ + virtual bool eval_grad_f(Ipopt::Index n, const Ipopt::Number* x, bool new_x, + Ipopt::Number* grad_f){ + assert(IsValid(tminlp_)); + assert(n == n_); + n--; + for(int i = 0 ; i < n ; i++){ + grad_f[i] = 0;} + grad_f[n] = 1; + return true;} + + /** Return the vector of constraint values. + * Use tminlp_ functions and use mapping to get the needed values. */ + virtual bool eval_g(Ipopt::Index n, const Ipopt::Number* x, bool new_x, + Ipopt::Index m, Ipopt::Number* g); + + /** Return the jacobian of the constraints. + * In first call nothing to change. In later just fix the values for the simple concaves + * and remove entries corresponding to nonConvex constraints. */ + 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); + + /** \brief Return the hessian of the lagrangian. + * Here we just put lambda in the correct format and call + * tminlp_'s function.*/ + 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); + /** Compute the value of a single constraint. The constraint + * number is i (starting counting from 0. */ + virtual bool eval_gi(Ipopt::Index n, const Ipopt::Number* x, bool new_x, + Ipopt::Index i, Ipopt::Number& gi); + /** Compute the structure or values of the gradient for one + * constraint. The constraint * number is i (starting counting + * from 0. Other things are like with eval_jac_g. */ + virtual bool eval_grad_gi(Ipopt::Index n, const Ipopt::Number* x, bool new_x, + Ipopt::Index i, Ipopt::Index& nele_grad_gi, Ipopt::Index* jCol, + Ipopt::Number* values); + //@} + + virtual bool get_variables_linearity(Ipopt::Index n, Ipopt::TNLP::LinearityType* c){ + assert(IsValid(tminlp_)); + assert(n == n_); + bool r_val = tminlp_->get_variables_linearity(n-1, c); + c[n - 1] = Ipopt::TNLP::LINEAR; + return r_val; + } + + + /** @name Solution Methods */ + //@{ + /** Use tminlp_ function.*/ + virtual void finalize_solution(TMINLP::SolverReturn status, + Ipopt::Index n, const Ipopt::Number* x, Ipopt::Number obj_value){ + return tminlp_->finalize_solution(status, n - 1, x, + obj_value); + } + //@} + + /** Use tminlp_ function.*/ + virtual const BranchingInfo * branchingInfo() const{ + return tminlp_->branchingInfo(); + } + + /** Use tminlp_ function. + \bug Has to translate sos information.*/ + virtual const SosInfo * sosConstraints() const{ + return tminlp_->sosConstraints(); + } + /** Use tminlp_ function.*/ + virtual const PerturbInfo* perturbInfo() const + { + return tminlp_->perturbInfo(); + } + + /** Use tminlp_ function.*/ + virtual bool hasUpperBoundingObjective(){ + assert(IsValid(tminlp_)); + return tminlp_->hasUpperBoundingObjective();} + + /** Use tminlp_ function.*/ + virtual bool eval_upper_bound_f(Ipopt::Index n, const Ipopt::Number* x, + Ipopt::Number& obj_value){ + assert(IsValid(tminlp_)); + return tminlp_->eval_upper_bound_f(n - 1, x, obj_value); } + + /** Say if problem has a linear objective (for OA) */ + virtual bool hasLinearObjective(){return true;} + /** return pointer to tminlp_.*/ + Ipopt::SmartPtr<TMINLP> tminlp(){return tminlp_;} + private: + /** Reset all data.*/ + void gutsOfDestructor(); + + /** Reference TMINLP which is to be relaxed.*/ + Ipopt::SmartPtr<TMINLP> tminlp_; + /** Ipopt::Number of constraints in the transformed MINLP.*/ + int m_; + /** Ipopt::Number of variables in the transformed MINLP.*/ + int n_; + /** number of non-zeroes in the jacobian of the transformed MINLP.*/ + int nnz_jac_; + /** offset for jacobian.*/ + int offset_; + +}; + + +}/* Ends Bonmin namepsace.*/ + +#endif + |