From 4b64cf486f5c999fd8167758cae27839f3b50848 Mon Sep 17 00:00:00 2001 From: Harpreet Date: Sat, 3 Sep 2016 00:34:27 +0530 Subject: Structure updated and intqpipopt files added --- .../linux/include/coin/BonAmplTMINLP.hpp | 332 +++++++++++++++++++++ 1 file changed, 332 insertions(+) create mode 100644 newstructure/thirdparty/linux/include/coin/BonAmplTMINLP.hpp (limited to 'newstructure/thirdparty/linux/include/coin/BonAmplTMINLP.hpp') diff --git a/newstructure/thirdparty/linux/include/coin/BonAmplTMINLP.hpp b/newstructure/thirdparty/linux/include/coin/BonAmplTMINLP.hpp new file mode 100644 index 0000000..0a566a2 --- /dev/null +++ b/newstructure/thirdparty/linux/include/coin/BonAmplTMINLP.hpp @@ -0,0 +1,332 @@ +// (C) Copyright International Business Machines Corporation and +// Carnegie Mellon University 2004, 2007 +// +// All Rights Reserved. +// This code is published under the Eclipse Public License. +// +// Authors : +// Carl D. Laird, Carnegie Mellon University, +// Andreas Waechter, International Business Machines Corporation +// Pierre Bonami, Carnegie Mellon University, +// +// Date : 12/01/2004 + +#ifndef __IPAMPLTMINLP_HPP__ +#define __IPAMPLTMINLP_HPP__ + +#include "BonTMINLP.hpp" +#include "IpSmartPtr.hpp" +#include "CoinPackedMatrix.hpp" +#include "OsiCuts.hpp" +#include "BonRegisteredOptions.hpp" +#include "BonTypes.hpp" + +/* non Ipopt forward declaration */ +struct ASL_pfgh; +struct SufDecl; +struct SufDesc; + + +// Declarations, so that we don't have to include the Ipopt AMPL headers +namespace Ipopt +{ + class AmplSuffixHandler; + class AmplOptionsList; + class AmplTNLP; +} + +namespace Bonmin +{ + + /** Ampl MINLP Interface. + * Ampl MINLP Interface, implemented as a TMINLP. + * This interface creates a AmplTNLP and also retrieves + * the information about the binary and integer variables + */ + class AmplTMINLP : public TMINLP + { + public: + /**@name Constructors/Destructors */ + //@{ + /** Constructor */ + AmplTMINLP(const Ipopt::SmartPtr& jnlst, + const Ipopt::SmartPtr roptions, + const Ipopt::SmartPtr options, + char**& argv, + Ipopt::AmplSuffixHandler* suffix_handler = NULL, + const std::string& appName = "bonmin", + std::string* nl_file_content = NULL); + + virtual void Initialize(const Ipopt::SmartPtr& jnlst, + const Ipopt::SmartPtr roptions, + const Ipopt::SmartPtr options, + char**& argv, + Ipopt::AmplSuffixHandler* suffix_handler =NULL, + const std::string& appName = "bonmin", + std::string* nl_file_content = NULL); + + /** read the branching priorities from ampl suffixes.*/ + void read_priorities(); + + /** read the sos constraints from ampl suffixes */ + void read_sos(); + + /** Read suffixes which indicate which constraints are convex.*/ + void read_convexities(); + + /** Read suffixes used to apply perspective in OA to some of the constraints.*/ + void read_onoff(); + + /** Read suffixes on objective functions for upper bounding*/ + void read_obj_suffixes(); + + /** Default constructor.*/ + AmplTMINLP(); + + virtual AmplTMINLP * createEmpty() + { + AmplTMINLP * tminlp = new AmplTMINLP; + return tminlp; + } + + /** destructor */ + virtual ~AmplTMINLP(); + //@} + + /** Return the ampl solver object (ASL*) */ + const ASL_pfgh* AmplSolverObject() const; + + + /**@name methods to gather information about the NLP. These + * methods are overloaded from TMINLP. See TMINLP for their more + * detailed documentation. */ + //@{ + /** returns dimensions of the nlp. Overloaded from TMINLP */ + 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); + + /** returns the vector of variable types */ + virtual bool get_variables_types(Ipopt::Index n, VariableType* var_types); + + /** return the variables linearity (linear or not)*/ + virtual bool get_variables_linearity(Ipopt::Index n, Ipopt::TNLP::LinearityType * var_types); + + /** Returns the constraint linearity. + * array should be alocated with length at least n.*/ + virtual bool get_constraints_linearity(Ipopt::Index m, + Ipopt::TNLP::LinearityType* const_types); + + /** returns bounds of the nlp. Overloaded from TMINLP */ + 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); + + /** provides a starting point for the nlp variables. Overloaded + from TMINLP */ + 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); + + /** evaluates the objective value for the nlp. Overloaded from TMINLP */ + virtual bool eval_f(Ipopt::Index n, const Ipopt::Number* x, bool new_x, + Ipopt::Number& obj_value); + + /** evaluates the gradient of the objective for the + nlp. Overloaded from TMINLP */ + virtual bool eval_grad_f(Ipopt::Index n, const Ipopt::Number* x, bool new_x, + Ipopt::Number* grad_f); + + /** evaluates the constraint residuals for the nlp. Overloaded from TMINLP */ + virtual bool eval_g(Ipopt::Index n, const Ipopt::Number* x, bool new_x, + Ipopt::Index m, Ipopt::Number* g); + + /** specifies the jacobian structure (if values is NULL) and + * evaluates the jacobian values (if values is not NULL) for the + * nlp. Overloaded from TMINLP */ + 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); + + /** specifies the structure of the hessian of the lagrangian (if + * values is NULL) and evaluates the values (if values is not + * NULL). Overloaded from TMINLP */ + 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 */ + 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); + //@} + + /** @name Solution Methods */ + //@{ + /** Called after optimizing to return results to ampl. + * Status code is put into solve_result_num according to the table below. + * + * + * + * + * + * + * + * + *
Code
Status
3 Integer optimal
220 problem is proven infeasible.
421 limit reached or user interrupt with integer feasible solution found.
410 limit reached or user interrupt without any integer feasible solution.
500 error.
Status codes for optimization.
+ * */ + virtual void finalize_solution(TMINLP::SolverReturn status, + Ipopt::Index n, const Ipopt::Number* x, Ipopt::Number obj_value); + + /** Write the solution using ampl's write_sol (called by finalize_solution).*/ + void write_solution(const std::string & message, const Ipopt::Number *x_sol); + //@} + + //@} + + + virtual const BranchingInfo * branchingInfo() const + { + return &branch_; + } + + virtual const SosInfo * sosConstraints() const + { + return &sos_; + } + + virtual const PerturbInfo* perturbInfo() const + { + return &perturb_info_; + } + + /** @name User callbacks */ + //@{ + /** Additional application specific options.*/ + virtual void fillApplicationOptions(Ipopt::AmplOptionsList* amplOptList) + {} + //@} + + + /** This methods gives the linear part of the objective function */ + virtual void getLinearPartOfObjective(double * obj); + + + /** Do we have an alternate objective for upper bounding?*/ + virtual bool hasUpperBoundingObjective() + { + return upperBoundingObj_ != -1; + } + + /** This method to returns the value of an alternative objective function for + upper bounding (if one has been declared by using the prefix UBObj).*/ + virtual bool eval_upper_bound_f(Ipopt::Index n, const Ipopt::Number* x, + Ipopt::Number& obj_value); + + /** Get accest to constraint convexities.*/ + virtual bool get_constraint_convexities(int m, TMINLP::Convexity * constraints_convexities)const + { + if (constraintsConvexities_ != NULL) { + CoinCopyN(constraintsConvexities_, m, constraints_convexities); + } + else { + CoinFillN(constraints_convexities, m, TMINLP::Convex); + } + return true; + } + /** Get dimension information on nonconvex constraints.*/ + virtual bool get_number_nonconvex(int & number_non_conv, int & number_concave) const + { + number_non_conv = numberNonConvex_; + number_concave = numberSimpleConcave_; + return true; + } + /** Get array describing the constraints marked nonconvex in the model.*/ + virtual bool get_constraint_convexities(int number_non_conv, MarkedNonConvex * non_convexes) const + { + assert(number_non_conv == numberNonConvex_); + CoinCopyN( nonConvexConstraintsAndRelaxations_, number_non_conv, non_convexes); + return true; + } + /** Fill array containing indices of simple concave constraints.*/ + virtual bool get_simple_concave_constraints(int number_concave, SimpleConcaveConstraint * simple_concave) const + { + assert(number_concave == numberSimpleConcave_); + CoinCopyN(simpleConcaves_, numberSimpleConcave_, simple_concave); + return true; + } + + /** Say if problem has a linear objective (for OA) */ + virtual bool hasLinearObjective() + { + return hasLinearObjective_; + } + + /** Access array describing onoff constraint.*/ + virtual const int * get_const_xtra_id() const{ + return c_extra_id_(); + } + 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 */ + AmplTMINLP(const AmplTMINLP&); + + /** Overloaded Equals Operator */ + void operator=(const AmplTMINLP&); + //@} + /** Name of application.*/ + std::string appName_; + + /** Index of the objective to use for upper bounding*/ + int upperBoundingObj_; + /** pointer to the internal AmplTNLP */ + Ipopt::AmplTNLP* ampl_tnlp_; + /** Journalist */ + Ipopt::SmartPtr jnlst_; + + /** Storage of branching priorities information.*/ + BranchingInfo branch_; + /** Storage of sos constraints */ + SosInfo sos_; + /** Storage for perturbation radii */ + PerturbInfo perturb_info_; + /** Store a suffix handler.*/ + Ipopt::SmartPtr suffix_handler_; + + /** Store constraints types.*/ + TMINLP::Convexity * constraintsConvexities_; + + /** Store onoff information.*/ + vector c_extra_id_; + + /** Ipopt::Number of nonConvex constraints.*/ + int numberNonConvex_; + /** Store marked non-convex constraints and their relaxations.*/ + MarkedNonConvex * nonConvexConstraintsAndRelaxations_; + /** Ipopt::Number of simpleConcave constraints.*/ + int numberSimpleConcave_; + /** Store simple concave constraints descriptions.*/ + SimpleConcaveConstraint * simpleConcaves_; + + /** Flag to indicate if objective function is linear */ + bool hasLinearObjective_; + + /** Flag to say if AMPL solution file should be written.*/ + int writeAmplSolFile_; + }; +} // namespace Ipopt + +#endif + -- cgit