cbcintlinprog added

1 files changed, 244 insertions, 0 deletions

diff --git a/thirdparty/linux/include/coin/BonCutStrengthener.hpp b/thirdparty/linux/include/coin/BonCutStrengthener.hpp
new file mode 100644
index 0000000..7e2b92f
--- /dev/null
+++ b/thirdparty/linux/include/coin/BonCutStrengthener.hpp
@@ -0,0 +1,244 @@
+// Copyright (C) 2007 International Business Machines and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// $Id: BonCutStrengthener.hpp 2106 2015-01-20 10:33:55Z stefan $
+//
+// Author:   Andreas Waechter                 IBM    2007-03-29
+
+#ifndef __BONCUTSTRENGTHENER_HPP__
+#define __BONCUTSTRENGTHENER_HPP__
+
+#include "BonTMINLP.hpp"
+#include "CoinPackedVector.hpp"
+#include "BonTNLPSolver.hpp"
+
+namespace Bonmin
+{
+  enum CutStrengtheningType{
+    CS_None=0,
+    CS_StrengthenedGlobal=1,
+    CS_UnstrengthenedGlobal_StrengthenedLocal=2,
+    CS_StrengthenedGlobal_StrengthenedLocal=3
+  };
+
+  enum DisjunctiveCutType{
+    DC_None=0,
+    DC_MostFractional=1
+  };
+
+  /** Class for strengthening OA cuts, and generating additional ones.
+   */
+  class CutStrengthener: public Ipopt::ReferencedObject
+  {
+    /** Class implementing the TNLP for strengthening one cut.  We
+     *  assume that the cut has a lower bound. */
+    class StrengtheningTNLP: public Ipopt::TNLP {
+    public:
+      /** Contructor */
+      StrengtheningTNLP(Ipopt::SmartPtr<TMINLP> tminlp,
+			const CoinPackedVector& cut,
+			bool lower_bound,
+			Ipopt::Index n,
+			const Ipopt::Number* starting_point,
+			const double* x_l_orig,
+			const double* x_u_orig,
+			Ipopt::Index constr_index,
+			Ipopt::Index nvar_constr /** Ipopt::Number of variables in constraint */,
+			const Ipopt::Index* jCol);
+
+      /** Destructor */
+      ~StrengtheningTNLP();
+
+      /**@name Overloaded from TNLP */
+      //@{
+      /** Method to return some info about the nlp */
+      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);
+
+      /** Method to return the bounds for my problem */
+      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);
+
+      /** Method to return the starting point for the algorithm */
+      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 to return the objective value */
+      virtual bool eval_f(Ipopt::Index n, const Ipopt::Number* x, bool new_x, Ipopt::Number& obj_value);
+
+      /** Method to return the gradient of the objective */
+      virtual bool eval_grad_f(Ipopt::Index n, const Ipopt::Number* x, bool new_x, Ipopt::Number* grad_f);
+
+      /** Method to return the constraint residuals */
+      virtual bool eval_g(Ipopt::Index n, const Ipopt::Number* x, bool new_x, Ipopt::Index m, Ipopt::Number* g);
+
+      /** Method to return:
+       *   1) The structure of the jacobian (if "values" is NULL)
+       *   2) The values of the jacobian (if "values" is not 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);
+
+      /** Method to return:
+       *   1) The structure of the hessian of the lagrangian (if "values" is NULL)
+       *   2) The values of the hessian of the lagrangian (if "values" is not NULL)
+       */
+      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);
+      //@}
+
+      /** Method for asking for the strengthened bound. */
+      Ipopt::Number StrengthenedBound() const;
+      
+    private:
+      /**@name Methods to block default compiler methods. */
+      //@{
+      StrengtheningTNLP();
+      StrengtheningTNLP(const StrengtheningTNLP&);
+      StrengtheningTNLP& operator=(const StrengtheningTNLP&);
+      //@}
+
+      /** TMINLP (with current bounds) for which the cut it to be
+       *  generated */
+      const Ipopt::SmartPtr<TMINLP> tminlp_;
+
+      /** Gradient of the (linear) objective function */
+      Ipopt::Number* obj_grad_;
+
+      /** Dimension of original problem */
+      const Ipopt::Index n_orig_;
+
+      /** Ipopt::Number of constraints in original problem */
+      Ipopt::Index m_orig_;
+
+      /** Starting point */
+      Ipopt::Number* starting_point_;
+
+      /** Full dimentional x which is used to call the TMINLP
+       *  evaluation routines */
+      Ipopt::Number* x_full_;
+
+      /** Lower bounds for constraint variables */
+      Ipopt::Number* x_l_;
+
+      /** Upper bounds for constraint variables */
+      Ipopt::Number* x_u_;
+
+      /** Ipopt::Index of the constraint */
+      const Ipopt::Index constr_index_;
+
+      /** Ipopt::Number of variables appearing in the constraint */
+      const Ipopt::Index nvar_constr_;
+
+      /** List of variables appearing on the constraints */
+      Ipopt::Index* var_indices_;
+
+      /** Flag indicating if the cut has a lower or upper bound */
+      bool lower_bound_;
+
+      /** Flag indicating if we TNLP has been solved successfully */
+      bool have_final_bound_;
+
+      /** Final strengthened bound */
+      Ipopt::Number strengthened_bound_;
+
+      /** space for original gradient if objective function is handled */
+      Ipopt::Number* grad_f_;
+
+      /** Auxilliary method for updating the full x variable */
+      void update_x_full(const Ipopt::Number *x);
+    };
+
+  public:
+    /** @name Constructor/Destructor */
+    //@{
+    /** Constructor.  It is given a TNLP solver to solve the internal
+     *  NLPs. */
+    CutStrengthener(Ipopt::SmartPtr<TNLPSolver> tnlp_solver,
+		    Ipopt::SmartPtr<Ipopt::OptionsList> options);
+
+    /** Destructor */
+    virtual ~CutStrengthener();
+    //@}
+
+    /** Method for generating and strenghtening all desired cuts */
+    bool ComputeCuts(OsiCuts &cs,
+		     TMINLP* tminlp,
+		     TMINLP2TNLP* problem,
+		     const int gindex, CoinPackedVector& cut,
+		     double& cut_lb, double& cut_ub,
+		     const double g_val, const double g_lb,
+		     const double g_ub,
+		     int n, const double* x,
+		     double infty);
+
+  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 */
+    CutStrengthener();
+
+    /** Copy Constructor */
+    CutStrengthener(const CutStrengthener&);
+
+    /** Overloaded Equals Operator */
+    void operator=(const CutStrengthener&);
+    //@}
+
+    /** Method for strengthening one cut. */
+    bool StrengthenCut(Ipopt::SmartPtr<TMINLP> tminlp /** current TMINLP */,
+		       int constr_index /** Ipopt::Index number of the constraint to be strengthened, -1 means objective function */,
+		       const CoinPackedVector& row /** Cut to be strengthened */,
+		       int n /** Ipopt::Number of variables */,
+		       const double* x /** solution from node */,
+		       const double* x_l /** Lower bounds for x in which should be valid. */,
+		       const double* x_u /** Upper bounds for x in which should be valid. */,
+		       double& lb,
+		       double& ub);
+
+    /** Method for generating one type of cut (strengthened or disjunctive) */
+    bool HandleOneCut(bool is_tight, TMINLP* tminlp,
+		      TMINLP2TNLP* problem,
+		      const double* minlp_lb,
+		      const double* minlp_ub,
+		      const int gindex, CoinPackedVector& cut,
+		      double& cut_lb, double& cut_ub,
+		      int n, const double* x,
+		      double infty);
+
+    /** Object for solving the TNLPs */
+    Ipopt::SmartPtr<TNLPSolver> tnlp_solver_;
+
+    /** Type of OA cut strengthener */
+    int cut_strengthening_type_;
+    /** What kind of disjuntion should be done */
+    int disjunctive_cut_type_;
+    /** verbosity level for OA-related output */
+    int oa_log_level_;
+  };
+
+} // namespace Ipopt
+#endif