casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/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
+

casadi/include/coin/BonTMatrix.hpp

@@ -0,0 +1,167 @@
+// (C) Copyright International Business Machines Corporation 2007
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Authors :
+// Pierre Bonami, International Business Machines Corporation
+//
+// Date : 10/06/2007
+
+#ifndef BonTMatrix_H
+#define BonTMatrix_H
+
+#include "CoinPackedMatrix.hpp"
+#include "BonArraysHelpers.hpp"
+#include <vector>
+#include <list>
+#include <algorithm> 
+#include "BonQuadCut.hpp"
+
+namespace Bonmin {
+
+struct TMat{
+  int * iRow_;
+  int * jCol_;
+  double * value_;
+  int nnz_;
+  int capacity_;
+
+
+ /** Storage for non empty rows.
+     first is row number and second is first element in row.*/
+ typedef vector< std::pair< int, int> > RowS;
+
+  /** Default constructor.*/
+  TMat(): iRow_(NULL), jCol_(NULL), value_(NULL), nnz_(0),
+               capacity_(0)
+  {}
+
+
+  void freeSpace(){
+     delete [] iRow_;
+     delete [] jCol_;
+     delete [] value_;
+  } 
+
+  /** Copy constructor.*/
+  TMat(const TMat &other);
+
+  /** Construct from a CoinPackedMatrix*/
+  TMat(const CoinPackedMatrix &M,  MatrixStorageType T);
+
+  /** Assignment operator.*/
+  TMat& operator=(const TMat &rhs);
+
+  /** Assignment from a CoinPackedMatrix.*/
+  TMat & operator=(const CoinPackedMatrix &M);
+
+  void resize(int nnz){
+    Bonmin::resizeAndCopyArray(iRow_, nnz_, nnz);
+    Bonmin::resizeAndCopyArray(jCol_, nnz_, nnz);
+    Bonmin::resizeAndCopyArray(value_, nnz_, nnz);
+    nnz_ = nnz;
+  }
+
+  ~TMat();
+
+ /** Get number of non empty rows.*/
+ int numNonEmptyRows();
+
+ /** Get the list of non empty row.*/
+ const RowS & nonEmptyRows() const {
+    return nonEmptyRows_;}
+
+ /** Get number of non empty cols.*/
+ int numNonEmptyCols();
+
+ /** Get the list of non empty row.*/
+ const RowS & nonEmptyCols() const {
+    return nonEmptyCols_;}
+
+ private:
+ /** Structure for ordering matrix.*/
+ struct TMatOrdering{
+   TMat * M_;
+   TMatOrdering(TMat *M):
+     M_(M){}
+ };
+
+ /** Structure for ordering matrix by columns.*/ 
+ struct ColumnOrder : public TMatOrdering {
+   ColumnOrder(TMat *M):
+     TMatOrdering(M){}
+
+   bool operator()(const int& i, const int& j){
+      if (M_->jCol_[i] < M_->jCol_[j])
+        return true;
+      if (M_->jCol_[i] == M_->jCol_[j] && M_->iRow_[i] < M_->iRow_[j])
+        return true;
+     return false;
+   }
+ };
+
+
+ /** Structure for ordering matrix by columns.*/ 
+ struct RowOrder : public TMatOrdering {
+   RowOrder(TMat *M):
+     TMatOrdering(M){}
+   bool operator()(const int& i, const int& j){
+      if (M_->iRow_[i]< M_->iRow_[j])
+        return true;
+      if (M_->iRow_[i] == M_->iRow_[j] && M_->jCol_[i] < M_->jCol_[j])
+        return true;
+     return false;
+   }
+ };
+ public:
+ /** Orders current matrix by columns. */
+ const vector<int>& orderByColumns(){
+    resizeOrdering(columnOrdering_, nnz_);
+    std::sort(columnOrdering_.begin(), columnOrdering_.end(),ColumnOrder(this));
+    return columnOrdering_;
+ }
+ /** Orders current matrix by rows.*/
+ const vector<int>& orderByRows(){
+    resizeOrdering(rowOrdering_, nnz_);
+    std::sort(rowOrdering_.begin(), rowOrdering_.end(), RowOrder(this));
+    return rowOrdering_;
+ }
+
+ /** Remove the duplicated entries.*/
+ void removeDuplicates();
+
+ /** Assuming that this is representing a quadratic form. Produce equivalent
+     quadratic form with only upper triange stored.*/
+ void makeQuadUpperDiag();
+
+ void resizeOrdering(vector<int> &ordering, unsigned int newSize){
+        size_t oldSize = ordering.size();
+        ordering.resize(newSize);
+        for(size_t i = oldSize ; i < newSize ; i++)
+           ordering[i] = static_cast<int>(i);
+   }
+
+   /** Create the TMat from M.*/
+   void create(const CoinPackedMatrix &M);
+ 
+   vector<int> columnOrdering_;
+ 
+   vector<int> rowOrdering_;
+
+   void make_upper_triangular(const MatrixStorageType &T);
+
+   void make_lower_to_be_upper();
+
+   void make_full_upper_triangular();
+
+   // Stores non empty rows for computing jacobian structure
+   RowS nonEmptyRows_;
+
+   // Stores non empty cols for computing jacobian structure
+   RowS nonEmptyCols_;
+ };
+
+}//Ends Bonmin namespace
+
+#endif
+

casadi/include/coin/BonTNLP2FPNLP.hpp

@@ -0,0 +1,264 @@
+// Copyright (C) 2004, International Business Machines and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+//
+// Authors:  Pierre Bonami 06/10/2005
+
+#ifndef _TNLP2FPNLP_HPP_
+#define _TNLP2FPNLP_HPP_
+
+#include "IpTNLP.hpp"
+#include "BonTMINLP.hpp"
+#include "IpSmartPtr.hpp"
+#include "BonTypes.hpp"
+
+namespace Bonmin
+{
+  /** This is an adapter class to convert an NLP to a Feasibility Pump NLP
+   *  by changing the objective function to the (2-norm) distance to a point.
+   * The extra function is set_dist_to_point_obj(size_t n, const double *, const int *)
+   */
+  class TNLP2FPNLP : public Ipopt::TNLP
+  {
+  public:
+    /**@name Constructors/Destructors */
+    //@{
+    /** Build using tnlp as source problem.*/
+    TNLP2FPNLP(const Ipopt::SmartPtr<Ipopt::TNLP> tnlp, double objectiveScalingFactor = 100);
+
+    /** Build using tnlp as source problem and using other for all other parameters..*/
+    TNLP2FPNLP(const Ipopt::SmartPtr<TNLP> tnlp, const Ipopt::SmartPtr<TNLP2FPNLP> other);
+
+    /** Default destructor */
+    virtual ~TNLP2FPNLP();
+    //@}
+    void use(Ipopt::SmartPtr<TNLP> tnlp){
+      tnlp_ = GetRawPtr(tnlp);}
+    /**@name Methods to select the objective function and extra constraints*/
+    //@{
+    /// Flag to indicate that we want to use the feasibility pump objective
+    void set_use_feasibility_pump_objective(bool use_feasibility_pump_objective) 
+    { use_feasibility_pump_objective_ = use_feasibility_pump_objective; }
+
+    /** Flag to indicate that we want to use a cutoff constraint
+     *	This constraint has the form f(x) <= (1-epsilon) f(x') */ 
+    void set_use_cutoff_constraint(bool use_cutoff_constraint)
+    { use_cutoff_constraint_ = use_cutoff_constraint; }
+
+    /// Flag to indicate that we want to use a local branching constraint
+    void set_use_local_branching_constraint(bool use_local_branching_constraint)
+    { use_local_branching_constraint_ = use_local_branching_constraint; }
+    //@}
+
+    /**@name Methods to provide the rhs of the extra constraints*/
+    //@{
+    /// Set the cutoff value to use in the cutoff constraint
+    void set_cutoff(Ipopt::Number cutoff);
+
+    /// Set the rhs of the local branching constraint
+    void set_rhs_local_branching_constraint(double rhs_local_branching_constraint)
+    { assert(rhs_local_branching_constraint >= 0);
+      rhs_local_branching_constraint_ = rhs_local_branching_constraint; }
+    //@}
+
+    /**@name Methods to change the objective function*/
+    //@{
+    /** \brief Set the point to which distance is minimized.
+    * The distance is minimize in a subspace define by a subset of coordinates
+     * \param n number of coordinates on which distance is minimized
+     * \param inds indices of the coordinates on which distance is minimized
+     * \param vals values of the point for coordinates in ind
+     */
+    void set_dist_to_point_obj(size_t n, const Ipopt::Number * vals, const Ipopt::Index * inds);
+
+     /** Set the value for sigma */
+     void setSigma(double sigma){
+       assert(sigma >= 0.);
+       sigma_ = sigma;}
+     /** Set the value for lambda*/
+     void setLambda(double lambda){
+       assert(lambda >= 0. && lambda <= 1.);
+       lambda_ = lambda;}
+     /** Set the value for simgma */
+     void setNorm(int norm){
+       assert(norm >0 && norm < 3);
+       norm_ = norm;}
+    //@}
+
+    /**@name methods to gather information about the NLP */
+    //@{
+    /** get info from nlp_ and add hessian information */
+    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);
+
+    /** This call is just passed onto tnlp_
+     */
+    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);
+
+    /** Passed onto tnlp_
+     */
+    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)
+    {
+      int m2 = m;
+      if(use_cutoff_constraint_) {
+        m2--;
+        if(lambda!=NULL)lambda[m2] = 0;
+      }
+      if(use_local_branching_constraint_) {
+        m2--;
+        if(lambda!= NULL)lambda[m2] = 0;
+      }
+      int ret_code = tnlp_->get_starting_point(n, init_x, x,
+          init_z, z_L, z_U, m2, init_lambda, lambda);
+      return ret_code;
+    }
+
+    /** overloaded to return the value of the objective function */
+    virtual bool eval_f(Ipopt::Index n, const Ipopt::Number* x, bool new_x,
+        Ipopt::Number& obj_value);
+
+    /** overload this method to return 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);
+
+    /** overload to return the values of the left-hand side of the
+        constraints */
+    virtual bool eval_g(Ipopt::Index n, const Ipopt::Number* x, bool new_x,
+			Ipopt::Index m, Ipopt::Number* g);
+
+    /** overload to return the jacobian of g */
+    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);
+
+    /** Evaluate the modified Hessian of the Lagrangian*/
+    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);
+    //@}
+
+    virtual bool get_variables_linearity(Ipopt::Index n, LinearityType* var_types)
+    {
+      return tnlp_->get_variables_linearity(n, var_types);;
+    }
+
+    /** overload this method to return the constraint linearity.
+     * array should be alocated with length at least n. (default implementation
+     *  just return false and does not fill the array).*/
+    virtual bool get_constraints_linearity(Ipopt::Index m, LinearityType* const_types)
+    {
+      int m2 = m;
+      if(use_cutoff_constraint_) {
+        m2--;
+        const_types[m2] = Ipopt::TNLP::NON_LINEAR;
+      } 
+      if(use_local_branching_constraint_) {
+        m2--;
+        const_types[m2] = Ipopt::TNLP::LINEAR;
+      }
+      return tnlp_->get_constraints_linearity(m2, const_types);
+    }
+    /** @name Scaling of the objective function */
+    //@{
+    void setObjectiveScaling(double value)
+    {
+      objectiveScalingFactor_ = value;
+    }
+    double getObjectiveScaling() const
+    {
+      return objectiveScalingFactor_;
+    }
+
+  private:
+    /** @name Internal methods to help compute the distance, its gradient and hessian */
+    //@{
+    /** Compute the norm-2 distance to the current point to which distance is minimized. */
+    double dist_to_point(const Ipopt::Number *x);
+    //@}
+    /**@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 */
+    TNLP2FPNLP();
+
+    /** Copy Constructor */
+    TNLP2FPNLP(const TNLP2FPNLP&);
+
+    /** Overloaded Equals Operator */
+    void operator=(const TNLP2FPNLP&);
+    //@}
+
+    /** pointer to the tminlp that is being adapted */
+    Ipopt::SmartPtr<TNLP> tnlp_;
+
+    /** @name Data for storing the point the distance to which is minimized */
+    //@{
+    /// Indices of the variables for which distance is minimized (i.e. indices of integer variables in a feasibility pump setting)
+    vector<Ipopt::Index> inds_;
+    /// Values of the point to which we separate (if x is the point vals_[i] should be x[inds_[i]] )
+    vector<Ipopt::Number> vals_;
+    /** value for the convex combination to take between original objective and distance function.
+      * ( take lambda_ * distance + (1-lambda) sigma f(x).*/
+    double lambda_;
+    /** Scaling for the original objective.*/
+    double sigma_;
+   /** Norm to use (L_1 or L_2).*/
+   int norm_;
+    //@}
+
+    /// Scaling factor for the objective
+    double objectiveScalingFactor_;
+
+    /**@name Flags to  select the objective function and extra constraints*/
+    //@{
+    /// Flag to indicate that we want to use the feasibility pump objective
+    bool use_feasibility_pump_objective_;
+
+    /** Flag to indicate that we want to use a cutoff constraint
+     *	This constraint has the form f(x) <= (1-epsilon) f(x') */ 
+    bool use_cutoff_constraint_;    
+
+    /// Flag to indicate that we want to use a local branching constraint
+    bool use_local_branching_constraint_;
+    //@}
+
+    /**@name Data for storing the rhs of the extra constraints*/
+    //@{
+    /// Value of best solution known
+    double cutoff_;
+
+    /// RHS of local branching constraint
+    double rhs_local_branching_constraint_;
+    //@}
+
+    /// Ipopt::Index style (C++ or Fortran)
+    Ipopt::TNLP::IndexStyleEnum index_style_;
+
+  };
+
+} // namespace Ipopt
+
+#endif /*_TNLP2FPNLP_HPP_*/