diff options
Diffstat (limited to 'newstructure/thirdparty/linux/include/coin/BonTMINLP2TNLP.hpp')
| -rw-r--r-- | newstructure/thirdparty/linux/include/coin/BonTMINLP2TNLP.hpp | 509 |
1 files changed, 509 insertions, 0 deletions
diff --git a/newstructure/thirdparty/linux/include/coin/BonTMINLP2TNLP.hpp b/newstructure/thirdparty/linux/include/coin/BonTMINLP2TNLP.hpp new file mode 100644 index 0000000..7523fc1 --- /dev/null +++ b/newstructure/thirdparty/linux/include/coin/BonTMINLP2TNLP.hpp @@ -0,0 +1,509 @@ +// (C) Copyright International Business Machines Corporation and Carnegie Mellon University 2004, 2006 +// All Rights Reserved. +// This code is published under the Eclipse Public License. +// +// Authors : +// Pierre Bonami, Carnegie Mellon University, +// Carl D. Laird, Carnegie Mellon University, +// Andreas Waechter, International Business Machines Corporation +// +// Date : 12/01/2004 + +#ifndef __TMINLP2TNLP_HPP__ +#define __TMINLP2TNLP_HPP__ + +#include "IpTNLP.hpp" +#include "BonTMINLP.hpp" +#include "IpSmartPtr.hpp" +#include "IpIpoptApplication.hpp" +#include "IpOptionsList.hpp" +#include "BonTypes.hpp" + +namespace Bonmin +{ + class IpoptInteriorWarmStarter; + + /** This is an adapter class that converts a TMINLP to + * a TNLP to be solved by Ipopt. It allows an external + * caller to modify the bounds of variables, allowing + * the treatment of binary and integer variables as + * relaxed, or fixed + */ + class TMINLP2TNLP : public Ipopt::TNLP + { + public: + /**@name Constructors/Destructors */ + //@{ + TMINLP2TNLP(const Ipopt::SmartPtr<TMINLP> tminlp +#ifdef WARM_STARTER + , + const OptionsList& options +#endif + ); + + /** Copy Constructor + * \warning source and copy point to the same tminlp_. + */ + TMINLP2TNLP(const TMINLP2TNLP&); + + /** virtual copy .*/ + virtual TMINLP2TNLP * clone() const{ + return new TMINLP2TNLP(*this);} + + /** Default destructor */ + virtual ~TMINLP2TNLP(); + //@} + + /**@name Methods to modify the MINLP and form the NLP */ + //@{ + + /** Get the number of variables */ + inline Ipopt::Index num_variables() const + { + assert(x_l_.size() == x_u_.size()); + return static_cast<int>(x_l_.size()); + } + + /** Get the number of constraints */ + inline Ipopt::Index num_constraints() const + { + assert(g_l_.size() == g_u_.size()); + return static_cast<int>(g_l_.size()); + } + /** Get the nomber of nz in hessian */ + Ipopt::Index nnz_h_lag() + { + return nnz_h_lag_; + } + /** Get the variable types */ + const TMINLP::VariableType* var_types() + { + return &var_types_[0]; + } + + /** Get the current values for the lower bounds */ + const Ipopt::Number* x_l() + { + return &x_l_[0]; + } + /** Get the current values for the upper bounds */ + const Ipopt::Number* x_u() + { + return &x_u_[0]; + } + + /** Get the original values for the lower bounds */ + const Ipopt::Number* orig_x_l() const + { + return &orig_x_l_[0]; + } + /** Get the original values for the upper bounds */ + const Ipopt::Number* orig_x_u() const + { + return orig_x_u_(); + } + + /** Get the current values for constraints lower bounds */ + const Ipopt::Number* g_l() + { + return g_l_(); + } + /** Get the current values for constraints upper bounds */ + const Ipopt::Number* g_u() + { + return g_u_(); + } + + /** get the starting primal point */ + const Ipopt::Number * x_init() const + { + return x_init_(); + } + + /** get the user provided starting primal point */ + const Ipopt::Number * x_init_user() const + { + return x_init_user_(); + } + + /** get the starting dual point */ + const Ipopt::Number * duals_init() const + { + return duals_init_; + } + + /** get the solution values */ + const Ipopt::Number* x_sol() const + { + return x_sol_(); + } + + /** get the g solution (activities) */ + const Ipopt::Number* g_sol() const + { + return g_sol_(); + } + + /** get the dual values */ + const Ipopt::Number* duals_sol() const + { + return duals_sol_(); + } + + /** Get Optimization status */ + Ipopt::SolverReturn optimization_status() const + { + return return_status_; + } + + /** Get the objective value */ + Ipopt::Number obj_value() const + { + return obj_value_; + } + + /** Manually set objective value. */ + void set_obj_value(Ipopt::Number value) + { + obj_value_ = value; + } + + /** force solution to be fractionnal.*/ + void force_fractionnal_sol(); + + /** Change the bounds on the variables */ + void SetVariablesBounds(Ipopt::Index n, + const Ipopt::Number * x_l, + const Ipopt::Number * x_u); + + /** Change the lower bound on the variables */ + void SetVariablesLowerBounds(Ipopt::Index n, + const Ipopt::Number * x_l); + + /** Change the upper bound on the variable */ + void SetVariablesUpperBounds(Ipopt::Index n, + const Ipopt::Number * x_u); + + /** Change the bounds on the variable */ + void SetVariableBounds(Ipopt::Index var_no, Ipopt::Number x_l, Ipopt::Number x_u); + + /** Change the lower bound on the variable */ + void SetVariableLowerBound(Ipopt::Index var_no, Ipopt::Number x_l); + + /** Change the upper bound on the variable */ + void SetVariableUpperBound(Ipopt::Index var_no, Ipopt::Number x_u); + + /** reset the starting point to original one. */ + void resetStartingPoint(); + + /** set the starting point to x_init */ + void setxInit(Ipopt::Index n,const Ipopt::Number* x_init); + + /** set the dual starting point to duals_init */ + void setDualsInit(Ipopt::Index n, const Ipopt::Number* duals_init); + + /** xInit has been set? + * \return 0 if not, 1 if only primal 2 if primal dual.*/ + int has_x_init(){ + if(x_init_.empty()) return 0; + if(duals_init_) return 2; + return 1; + } + /** Set the contiuous solution */ + void Set_x_sol(Ipopt::Index n, const Ipopt::Number* x_sol); + + /** Set the contiuous dual solution */ + void Set_dual_sol(Ipopt::Index n, const Ipopt::Number* dual_sol); + + /** Change the type of the variable */ + void SetVariableType(Ipopt::Index n, TMINLP::VariableType type); + //@} + /** Procedure to ouptut relevant informations to reproduce a sub-problem. + Compare the current problem to the problem to solve + and writes files with bounds which have changed and current starting point. + */ + void outputDiffs(const std::string& probName, const std::string* varNames); + + /**@name methods to gather information about the NLP */ + //@{ + /** This call is just passed onto the TMINLP object */ + virtual bool get_nlp_info(Ipopt::Index& n, Ipopt::Index& m, Ipopt::Index& nnz_jac_g, + Ipopt::Index& nnz_h_lag, + TNLP::IndexStyleEnum& index_style); + + /** The caller is allowed to modify the bounds, so this + * method returns the internal bounds information + */ + 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 m..*/ + virtual bool get_constraints_linearity(Ipopt::Index m, LinearityType* const_types) + { + return tminlp_->get_constraints_linearity(m, const_types); + } + + /** Returns the variables linearity. + * array should be alocated with length at least n..*/ + virtual bool get_variables_linearity(Ipopt::Index n, LinearityType* var_types) + { + return tminlp_->get_variables_linearity(n, var_types); + } + + /** returns true if objective is linear.*/ + virtual bool hasLinearObjective(){return tminlp_->hasLinearObjective();} + /** 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); + + /** Method that returns scaling parameters. + */ + 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); + + + /** Methat that returns an Ipopt IteratesVector that has the + * starting point for all internal varibles. */ + virtual bool get_warm_start_iterate(Ipopt::IteratesVector& warm_start_iterate); + + /** 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); + + /** compute the value of a single constraint */ + 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 */ + 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); + + /** 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); + //@} + + /** @name Solution Methods */ + //@{ + /** This method is called when the algorithm is complete so the TNLP can store/write the solution */ + 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); + /** Intermediate Callback method for the user. Providing dummy + * default implementation. For details see IntermediateCallBack + * in IpNLP.hpp. */ + virtual bool intermediate_callback(Ipopt::AlgorithmMode mode, + Ipopt::Index iter, Ipopt::Number obj_value, + Ipopt::Number inf_pr, Ipopt::Number inf_du, + Ipopt::Number mu, Ipopt::Number d_norm, + Ipopt::Number regularization_size, + Ipopt::Number alpha_du, Ipopt::Number alpha_pr, + Ipopt::Index ls_trials, + const Ipopt::IpoptData* ip_data, + Ipopt::IpoptCalculatedQuantities* ip_cq); + //@} + + /** Method called to check wether a problem has still some variable not fixed. If there are no more + unfixed vars, checks wether the solution given by the bounds is feasible.*/ + + /** @name Methods for setting and getting the warm starter */ + //@{ + void SetWarmStarter(Ipopt::SmartPtr<IpoptInteriorWarmStarter> warm_starter); + + Ipopt::SmartPtr<IpoptInteriorWarmStarter> GetWarmStarter(); + + //@} + + /** Say if has a specific function to compute upper bounds*/ + virtual bool hasUpperBoundingObjective(){ + return tminlp_->hasUpperBoundingObjective();} + + /** Evaluate the upper bounding function at given point and store the result.*/ + double evaluateUpperBoundingFunction(const double * x); + + /** \name Cuts management. */ + /** Methods are not implemented at this point. But I need the interface.*/ + //@{ + + + /** Add some linear cuts to the problem formulation (not implemented yet in base class).*/ + virtual void addCuts(unsigned int numberCuts, const OsiRowCut ** cuts){ + if(numberCuts > 0) + throw CoinError("BonTMINLP2TNLP", "addCuts", "Not implemented");} + + + /** Add some cuts to the problem formulaiton (handles Quadratics).*/ + virtual void addCuts(const OsiCuts &cuts){ + if(cuts.sizeRowCuts() > 0 || cuts.sizeColCuts() > 0) + throw CoinError("BonTMINLP2TNLP", "addCuts", "Not implemented");} + + /** Remove some cuts to the formulation */ + virtual void removeCuts(unsigned int number ,const int * toRemove){ + if(number > 0) + throw CoinError("BonTMINLP2TNLP", "removeCuts", "Not implemented");} + + //@} + + + /** Access array describing constraint to which perspectives should be applied.*/ + virtual const int * get_const_xtra_id() const{ + return tminlp_->get_const_xtra_id(); + } + + /** Round and check the current solution, return norm inf of constraint violation.*/ + double check_solution(OsiObject ** objects = 0, int nObjects = -1); + protected: + /** \name These should be modified in derived class to always maintain there correctness. + They are directly queried by OsiTMINLPInterface without virtual function for + speed.*/ + /** @{ */ + /// Types of the variable (TMINLP::CONTINUOUS, TMINLP::INTEGER, TMINLP::BINARY). + vector<TMINLP::VariableType> var_types_; + /// Current lower bounds on variables + vector<Ipopt::Number> x_l_; + /// Current upper bounds on variables + vector<Ipopt::Number> x_u_; + /// Original lower bounds on variables + vector<Ipopt::Number> orig_x_l_; + /// Original upper bounds on variables + vector<Ipopt::Number> orig_x_u_; + /// Lower bounds on constraints values + vector<Ipopt::Number> g_l_; + /// Upper bounds on constraints values + vector<Ipopt::Number> g_u_; + /// Initial primal point + vector<Ipopt::Number> x_init_; + /** Initial values for all dual multipliers (constraints then lower bounds then upper bounds) */ + Ipopt::Number * duals_init_; + /// User-provideed initial prmal point + vector<Ipopt::Number> x_init_user_; + /// Optimal solution + vector<Ipopt::Number> x_sol_; + /// Activities of constraint g( x_sol_) + vector<Ipopt::Number> g_sol_; + /** Dual multipliers of constraints and bounds*/ + vector<Ipopt::Number> duals_sol_; + /** @} */ + + /** Access number of entries in tminlp_ hessian*/ + Ipopt::Index nnz_h_lag() const{ + return nnz_h_lag_;} + /** Access number of entries in tminlp_ hessian*/ + Ipopt::Index nnz_jac_g() const{ + return nnz_jac_g_;} + + /** Acces index_style.*/ + TNLP::IndexStyleEnum index_style() const{ + return index_style_;} + 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 */ + TMINLP2TNLP(); + + /** Overloaded Equals Operator */ + TMINLP2TNLP& operator=(const TMINLP2TNLP&); + //@} + + /** pointer to the tminlp that is being adapted */ + Ipopt::SmartPtr<TMINLP> tminlp_; + + /** @name Internal copies of data allowing caller to modify the MINLP */ + //@{ + /// Number of non-zeroes in the constraints jacobian. + Ipopt::Index nnz_jac_g_; + /// Number of non-zeroes in the lagrangian hessian + Ipopt::Index nnz_h_lag_; + /**index style (fortran or C)*/ + TNLP::IndexStyleEnum index_style_; + + /** Return status of the optimization process*/ + Ipopt::SolverReturn return_status_; + /** Value of the optimal solution found by Ipopt */ + Ipopt::Number obj_value_; + //@} + + /** @name Warmstart object and related data */ + //@{ + /** Pointer to object that holds warmstart information */ + Ipopt::SmartPtr<IpoptInteriorWarmStarter> curr_warm_starter_; + /** Value for a lower bound that denotes -infinity */ + Ipopt::Number nlp_lower_bound_inf_; + /** Value for a upper bound that denotes infinity */ + Ipopt::Number nlp_upper_bound_inf_; + /** Option from Ipopt - we currently use it to see if we want to + * use some clever warm start or just the last iterate from the + * previous run */ + bool warm_start_entire_iterate_; + /** Do we need a new warm starter object */ + bool need_new_warm_starter_; + //@} + + + /** Private method that throws an exception if the variable bounds + * are not consistent with the variable type */ + void throw_exception_on_bad_variable_bound(Ipopt::Index i); + + private: + // Delete all arrays + void gutsOfDelete(); + + /** Copies all the arrays. + \warning this and other should be two instances of the same problem + \warning AW: I am trying to mimic a copy construction for Cbc + use with great care not safe. + */ + void gutsOfCopy(const TMINLP2TNLP &source); + }; + +} // namespace Ipopt + +#endif |