casadi 3.6.4__cp312-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/include/coin/BonBabSetupBase.hpp

@@ -0,0 +1,386 @@
+// (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 : 04/12/2007
+
+#ifndef BabSetupBase_H
+#define BabSetupBase_H
+
+#include <string>
+#include <list>
+#include "CglCutGenerator.hpp"
+#include "CbcHeuristic.hpp"
+#include "OsiChooseVariable.hpp"
+#include "BonOsiTMINLPInterface.hpp"
+#include "IpSmartPtr.hpp"
+#include "BonTMINLP2OsiLP.hpp"
+
+namespace Bonmin
+{
+  /** A class to have all elements necessary to setup a branch-and-bound.*/
+  class BabSetupBase
+  {
+  public:
+    /** Type for cut generation method with its frequency and string identification. */
+    struct CuttingMethod 
+    {
+      int frequency;
+      std::string id;
+      CglCutGenerator * cgl;
+      bool atSolution;
+      bool normal;
+      bool always;
+      CuttingMethod():
+          atSolution(false),
+          normal(true),
+          always(false)
+      {}
+
+      CuttingMethod(const CuttingMethod & other):
+          frequency(other.frequency),
+          id(other.id),
+          cgl(other.cgl),
+          atSolution(other.atSolution),
+          normal(other.normal),
+          always(other.always)
+      {}
+    };
+    /** Type for heuristic method with its string identification. */
+    struct HeuristicMethod
+    {
+      std::string id;
+      CbcHeuristic* heuristic;
+      HeuristicMethod()
+      {}
+
+      HeuristicMethod(const HeuristicMethod & other):
+          id(other.id),
+          heuristic(other.heuristic)
+      {}
+    };
+    typedef std::list<CuttingMethod> CuttingMethods;
+    typedef std::list<HeuristicMethod  > HeuristicMethods;
+
+    /** Strategies for comparing the nodes on the heap. */
+    enum NodeComparison {
+      bestBound = 0 /** Best bound*/,
+      DFS /** Depth First Search*/,
+      BFS /** Best First Search */,
+      dynamic /** Dynamic strategy, see <a href="http://www.coin-or.org/Doxygen/Cbc/class_cbc_branch_dynamic_decision.html">
+      		  CbcBranchActual.hpp </a> for explanations.*/,
+      bestGuess /** Best guessed integer solution is subtree below, based on pseudo costs */
+    };
+
+    /** Strategies for traversing the tree.*/
+    enum TreeTraversal {
+      HeapOnly=0 /** Only using the heap, uses CbcTree.*/,
+      DiveFromBest /** dive from top node of the heap untill it gets to a leaf of the tree. Uses Bonmin::CbcDiver.*/,
+      ProbedDive /** Eplore two kids before following on dive.*/,
+      DfsDiveFromBest /** dive from top node of the heap with more elaborate strategy (see options doc). Uses Bonmin::CbcDfsDiver.*/,
+      DfsDiveDynamic /** Same as DfsDiveFromBest, but after a prescribed number of integer solution are found switch to best-bound and if too many node switches to depth-first. Uses Bonmin::CbcDfsDiver.*/
+    };
+
+
+    /** @name Enums for optionslist parameters */
+    enum VarSelectStra_Enum {
+      MOST_FRACTIONAL=0,
+      STRONG_BRANCHING,
+      RELIABILITY_BRANCHING,
+#ifdef BONMIN_CURVATURE_BRANCHING
+      CURVATURE_ESTIMATOR,
+#endif
+      QP_STRONG_BRANCHING,
+      LP_STRONG_BRANCHING,
+      NLP_STRONG_BRANCHING,
+      OSI_SIMPLE,
+      OSI_STRONG,
+      RANDOM
+    };
+
+    /** Parameters represented by an integer. */
+    enum IntParameter{
+      BabLogLevel = 0 /** Log level of main branch-and-bound*/,
+      BabLogInterval/** Display information every logIntervval nodes.*/,
+      MaxFailures /** Max number of failures in a branch.*/,
+      FailureBehavior /** Behavior of the algorithm in the case of a failure.*/,
+      MaxInfeasible /** Max number of consecutive infeasible problem in a branch
+            before fathoming.*/,
+      NumberStrong /** Number of candidates for strong branching.*/,
+      MinReliability /** Minimum reliability before trust pseudo-costs.*/,
+      MaxNodes /** Global node limit.*/,
+      MaxSolutions /** limit on number of integer feasible solution.*/,
+      MaxIterations /** Global iteration limit. */,
+      SpecialOption /** Spetial option in particular for Cbc. */,
+      DisableSos /** Consider or not SOS constraints.*/,
+      NumCutPasses/** Number of cut passes at nodes.*/,
+      NumCutPassesAtRoot/** Number of cut passes at nodes.*/,
+      RootLogLevel/** Log level for root relaxation.*/,
+      NumberIntParam /** Dummy end to size table*/
+    };
+
+
+    /** Parameters represented by a double.*/
+    enum DoubleParameter{
+      CutoffDecr = 0 /** Amount by which cutoff is incremented */,
+      Cutoff /** cutoff value */,
+      AllowableGap /** Stop if absolute gap is less than this. */,
+      AllowableFractionGap /** Stop if relative gap is less than this.*/,
+      IntTol /** Integer tolerance.*/,
+      MaxTime /** Global time limit. */,
+      NumberDoubleParam /** Dummy end to size table*/
+    };
+
+    /** Default constructor. */
+    BabSetupBase(const CoinMessageHandler * handler = NULL);
+
+    /** Construct from existing tminlp. */
+    BabSetupBase(Ipopt::SmartPtr<TMINLP> tminlp, const CoinMessageHandler * handler = NULL);
+    /** Construct from existing application.*/
+    BabSetupBase(Ipopt::SmartPtr<TNLPSolver> app);
+    /** Construct from existing TMINLP interface.*/
+    BabSetupBase(const OsiTMINLPInterface& nlp);
+    /** Copy but uses an other nlp.*/
+    BabSetupBase(const BabSetupBase &setup,
+                 OsiTMINLPInterface &nlp);
+
+    /** Copy but uses an other nlp.*/
+    BabSetupBase(const BabSetupBase &setup,
+                 OsiTMINLPInterface &nlp,
+                 const std::string &prefix);
+
+    /** Copy constructor. */
+    BabSetupBase(const BabSetupBase & other);
+
+    /** virtual copy constructor. */
+    virtual BabSetupBase * clone() const = 0;
+
+    /** Make a copy with solver replace by one passed .*/
+    virtual BabSetupBase *clone(OsiTMINLPInterface&nlp)const;
+    /** Virtual destructor. */
+    virtual ~BabSetupBase();
+
+    /** @name Methods to initialize algorithm with various inputs. */
+    /** @{ */
+    /** use existing TMINLP interface (containing the options).*/
+    void use(const OsiTMINLPInterface& nlp);
+    /** Read options (if not done before) and create interface using tminlp.*/
+    void use(Ipopt::SmartPtr<TMINLP> tminlp );
+    /** use specific instanciation of a TMINLP2TNLP.*/
+    void use(Ipopt::SmartPtr<TMINLP2TNLP> prob);
+    /** Set the non-linear solver used */
+    void setNonlinearSolver(OsiTMINLPInterface * s)
+    {
+      nonlinearSolver_ = s;
+    }
+    /** @} */
+
+    /** @name Methods to manipulate options. */
+    /** @{ */
+    /** Register all the options for this algorithm instance.*/
+    virtual void registerOptions();
+    /** Setup the defaults options for this algorithm. */
+    virtual void setBabDefaultOptions(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions)
+    {}
+    /** Register all the options for this algorithm instance.*/
+    static void registerAllOptions(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions);
+
+    /** Get the options from default text file (bonmin.opt) if don't already have them.*/
+    virtual void readOptionsFile()
+    {
+      if (readOptions_) return;
+      readOptionsFile("bonmin.opt");
+    }
+
+    /** Get the options from given fileName */
+    void readOptionsFile(std::string fileName);
+
+    /** Get the options from long string containing all.*/
+    void readOptionsString(std::string opt_string);
+
+    /** Get the options from stream.*/
+    void readOptionsStream(std::istream& is);
+
+    /** May print documentation of options if options print_options_documentation is set to yes.*/
+    void mayPrintDoc();
+
+
+    /** Get prefix to use for options.*/
+    const char * prefix() const {
+      return prefix_.c_str();
+    }
+
+    /** Set the value for options, output...*/
+    void setOptionsAndJournalist(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions,
+        Ipopt::SmartPtr<Ipopt::OptionsList> options,
+        Ipopt::SmartPtr<Ipopt::Journalist> journalist)
+    {
+      options_ = options;
+      roptions_ = roptions;
+      journalist_ = journalist;
+    }
+
+    /** Initialize the options and the journalist.*/
+    void initializeOptionsAndJournalist();
+    /** @} */
+
+    /** @name Elements of the branch-and-bound setup.*/
+    /** @{ */
+    /** Pointer to the non-linear solver used.*/
+    OsiTMINLPInterface * nonlinearSolver()
+    {
+      return nonlinearSolver_;
+    }
+    /** Pointer to the continuous solver to use for relaxations. */
+    OsiSolverInterface * continuousSolver()
+    {
+      return continuousSolver_;
+    }
+    /** list of cutting planes methods to apply with their frequencies. */
+    CuttingMethods& cutGenerators()
+    {
+      return cutGenerators_;
+    }
+    /** list of Heuristic methods to use. */
+    HeuristicMethods& heuristics()
+    {
+      return heuristics_;
+    }
+    /** branching method to use. */
+    OsiChooseVariable * branchingMethod()
+    {
+      return branchingMethod_;
+    }
+    /** Method used to compare nodes. */
+    NodeComparison& nodeComparisonMethod()
+    {
+      return nodeComparisonMethod_;
+    }
+    /** Method used to traverse tree.*/
+    TreeTraversal treeTraversalMethod()
+    {
+      return treeTraversalMethod_;
+    }
+    /** Return value of integer parameter. */
+    int getIntParameter(const IntParameter &p) const
+    {
+      return intParam_[p];
+    }
+    /** Return value of double parameter.*/
+    double getDoubleParameter(const DoubleParameter &p) const
+    {
+      return doubleParam_[p];
+    }
+    /** Return value of integer parameter. */
+    void setIntParameter(const IntParameter &p, const int v)
+    {
+      intParam_[p] = v;
+    }
+    /** Return value of double parameter.*/
+    void setDoubleParameter(const DoubleParameter &p, const double v)
+    {
+      doubleParam_[p] = v;
+    }
+    /** @} */
+
+    /** Get the values of base parameters from the options stored.*/
+    void gatherParametersValues()
+    {
+      gatherParametersValues(options_);
+    }
+    /** Get the values of the base parameters from the passed options.*/
+    void gatherParametersValues(Ipopt::SmartPtr<Ipopt::OptionsList> options);
+    /** Acces storage of Journalist for output */
+    Ipopt::SmartPtr<Ipopt::Journalist> journalist()
+    {
+      return journalist_;
+    }
+
+    /** Acces list of Options */
+    Ipopt::SmartPtr<Ipopt::OptionsList> options()
+    {
+      return options_;
+    }
+
+    /** Access registered Options */
+    Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions()
+    {
+      return roptions_;
+    }
+
+    /** Access to extra objects.*/
+    const vector<OsiObject *>& objects() const
+    {
+      return objects_;
+    }
+
+    /** Access to extra objects.*/
+    vector<OsiObject *>& objects()
+    {
+      return objects_;
+    }
+  
+    void addCutGenerator(CuttingMethod & cg){
+      cutGenerators_.push_back(cg);
+    }
+
+    void set_linearizer(TMINLP2OsiLP * linearizer){
+      linearizer_ = linearizer;
+    }
+
+  protected:
+    /** Set the priorities into OsiTMINLPInterface when needed.*/
+    void setPriorities();
+    /** Add SOS constraints to OsiTMINLPInterface when needed.*/
+    void addSos();
+
+    /** storage of integer parameters.*/
+    int intParam_[NumberIntParam];
+    /** default values for int parameters.*/
+    static int defaultIntParam_[NumberIntParam];
+    /** storage of double parameters. */
+    double doubleParam_[NumberDoubleParam];
+    /** default values for double parameters. */
+    static double defaultDoubleParam_[NumberDoubleParam];
+    /** Storage of the non-linear solver used.*/
+    OsiTMINLPInterface * nonlinearSolver_;
+    /** Storage of continuous solver.*/
+    OsiSolverInterface * continuousSolver_;
+    /** Method to linearize MINLPs */
+    Ipopt::SmartPtr<TMINLP2OsiLP> linearizer_;
+    /** Cut generation methods. */
+    CuttingMethods cutGenerators_;
+    /** Heuristic methods. */
+    HeuristicMethods heuristics_;
+    /** Branching method.*/
+    OsiChooseVariable * branchingMethod_;
+    /** Node comparison method.*/
+    NodeComparison nodeComparisonMethod_;
+    /** Tree traversal method.*/
+    TreeTraversal treeTraversalMethod_;
+    /** Extra object to add to Cbc (not OsiObjects).*/
+    vector<OsiObject *> objects_;
+    
+
+    /** Storage of Journalist for output */
+    Ipopt::SmartPtr<Ipopt::Journalist> journalist_;
+
+    /** List of Options */
+    Ipopt::SmartPtr<Ipopt::OptionsList> options_;
+
+    /** Registered Options */
+    Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions_;
+
+    /** flag to say if option file was read.*/
+    bool readOptions_;
+    /** separate message handler.*/
+    CoinMessageHandler * messageHandler_;
+    /** Prefix to use when reading options.*/
+    std::string prefix_;
+  };
+}/* End namespace Bonmin. */
+#endif
+

casadi/include/include/coin/BonBonminSetup.hpp

@@ -0,0 +1,95 @@
+// (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 : 04/13/2007
+#ifndef BonminSetup_H
+#define BonminSetup_H
+#include "BonBabSetupBase.hpp"
+namespace Bonmin
+{
+  /** Type of algorithms which can be used.*/
+  enum Algorithm{
+    Dummy=-1/** Dummy value before initialization.*/,
+    B_BB=0/** Bonmin's Branch-and-bound.*/,
+    B_OA=1/** Bonmin's Outer Approximation Decomposition.*/,
+    B_QG=2/** Bonmin's Quesada & Grossmann branch-and-cut.*/,
+    B_Hyb=3/** Bonmin's hybrid outer approximation.*/,
+    B_Ecp=4/** Bonmin's implemantation of ecp cuts based branch-and-cut a la FilMINT.*/,
+    B_IFP=5/** Bonmin's implemantation of iterated feasibility pump for MINLP.*/
+  };
+  /* Bonmin algorithm setup. */
+  class BonminSetup : public BabSetupBase
+  {
+  public:
+    /** Default constructor. */
+    BonminSetup(const CoinMessageHandler * handler = NULL);
+    /** Copy constructor. */
+    BonminSetup(const BonminSetup & other);
+
+    /** Copy but uses an other nlp.*/
+    BonminSetup(const BonminSetup &setup,
+                OsiTMINLPInterface &nlp);
+
+    /** Copy but uses another nlp and algorithm.*/
+    BonminSetup(const BonminSetup &setup,
+                OsiTMINLPInterface &nlp,
+                const std::string & prefix);
+    /** virtual copy constructor. */
+    virtual BabSetupBase * clone() const
+    {
+      return new BonminSetup(*this);
+    }
+    /** Make a copy with solver replace by one passed .*/
+    //    virtual BabSetupBase *clone(OsiTMINLPInterface&nlp)const{
+    //      return new BonminSetup(*this, nlp);
+    //    }
+    /** Make a copy with solver replace by one passed .*/
+    BonminSetup *clone(OsiTMINLPInterface&nlp)const{
+      return new BonminSetup(*this, nlp);
+    }
+    /** Make a copy but take options with different prefix.*/
+    BonminSetup *clone(OsiTMINLPInterface &nlp, const std::string & prefix)const{
+      return new BonminSetup(*this, nlp, prefix);
+    }
+    virtual ~BonminSetup()
+    {}
+    /** @name Methods to instantiate: Registering and retrieving options and initializing everything. */
+    /** @{ */
+    /** Register all the options for this algorithm instance.*/
+    virtual void registerOptions();
+    /** Setup the defaults options for this algorithm. */
+    virtual void setBabDefaultOptions(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions)
+    {}
+    /** @} */
+    /** Register all bonmin type executable options.*/
+    static void registerAllOptions(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions);
+    /** Initialize, read options and create appropriate bonmin setup.*/
+    void initialize(Ipopt::SmartPtr<TMINLP> tminlp, bool createContinuousSolver = true);
+    /** Initialize, read options and create appropriate bonmin setup.*/
+    void initialize(const OsiTMINLPInterface& nlpSi, bool createContinuousSolver = true);
+    /** Get the algorithm used.*/
+    Bonmin::Algorithm getAlgorithm();
+
+    void addCutGenerator(CuttingMethod & cg){
+      BabSetupBase::addCutGenerator(cg);
+    }
+  protected:
+    /** Register standard MILP cut generators. */
+    static void registerMilpCutGenerators(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions);
+    /** Add milp cut generators according to options.*/
+    void addMilpCutGenerators();
+    /** Initialize a plain branch-and-bound.*/
+    void initializeBBB();
+    /** Initialize a branch-and-cut with some OA.*/
+    void initializeBHyb(bool createContinuousSolver = false);
+  private:
+    Algorithm algo_;
+  };
+}/** end namespace Bonmin*/
+
+#endif
+

casadi/include/include/coin/BonBranchingTQP.hpp

@@ -0,0 +1,197 @@
+// (C) Copyright International Business Machines Corporation and
+// Carnegie Mellon University 2006, 2008
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Authors :
+// Andreas Waechter, International Business Machines Corporation
+//                   (derived from BonTMINLP2TNLP.hpp)            12/22/2006
+
+#ifndef __BONBRANCHINGTQP_HPP__
+#define __BONBRANCHINGTQP_HPP__
+
+#include "BonTMINLP2TNLP.hpp"
+
+namespace Bonmin
+{
+  /** This is an adapter class that converts a TMINLP2TNLP object into
+   *  a TNLP, which is now just a QP.  The QP is the linear quadratic
+   *  of the TNLP at the optimal point.  The purpose of the
+   *  BranchingTQP is that it is used in a strong-branching framework,
+   *  strong branching is only done for the QP approximation of the
+   *  TNLP, not on the TNLP itself.  The variables of the QP are the
+   *  displacement from the reference point.
+   */
+  class BranchingTQP : public Ipopt::TNLP
+  {
+  public:
+    /**@name Constructors/Destructors */
+    //@{
+    BranchingTQP(Ipopt::SmartPtr<TMINLP2TNLP> tminlp2tnlp);
+
+    /** Default destructor */
+    virtual ~BranchingTQP();
+    //@}
+
+    /**@name methods to gather information about the NLP, only those
+     *  that need to be overloaded from TNLP */
+    //@{
+    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);
+    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 n. Since this is a QP, all constraints are
+     * linear.*/
+    virtual bool get_constraints_linearity(Ipopt::Index m, LinearityType* const_types);
+    /** 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);
+
+    /** 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);
+
+    /** 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);
+    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);
+    //@}
+
+    /** Accessor Methods for QP data */
+    //@{
+    const Ipopt::Number ObjVal()
+    {
+      return obj_val_;
+    }
+    const Ipopt::Number* ObjGrad()
+    {
+      return obj_grad_;
+    }
+    const Ipopt::Number* ObjHessVals()
+    {
+      return obj_hess_;
+    }
+    const Ipopt::Index* ObjHessIRow()
+    {
+      return obj_hess_irow_;
+    }
+    const Ipopt::Index* ObjHessJCol()
+    {
+      return obj_hess_jcol_;
+    }
+    const Ipopt::Number* ConstrRhs()
+    {
+      return g_vals_;
+    }
+    const Ipopt::Number* ConstrJacVals()
+    {
+      return g_jac_;
+    }
+    const Ipopt::Index* ConstrJacIRow()
+    {
+      return g_jac_irow_;
+    }
+    const Ipopt::Index* ConstrJacJCol()
+    {
+      return g_jac_jcol_;
+    }
+    //@}
+
+  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 */
+    BranchingTQP();
+
+    /** Copy Constructor */
+    BranchingTQP(const BranchingTQP&);
+
+    /** Overloaded Equals Operator */
+    void operator=(const BranchingTQP&);
+    //@}
+
+    /** @name static information about the QP's constraints and
+     *  objective function */
+    //@{
+    Ipopt::Number obj_val_;
+    Ipopt::Number* obj_grad_;
+    Ipopt::Number* obj_hess_;
+    Ipopt::Index* obj_hess_irow_;
+    Ipopt::Index* obj_hess_jcol_;
+    Ipopt::Number* g_vals_;
+    Ipopt::Number* g_jac_;
+    Ipopt::Index* g_jac_irow_;
+    Ipopt::Index* g_jac_jcol_;
+    //@}
+
+    /** @name Data from the MINLP */
+    //@{
+    Ipopt::Index n_;
+    Ipopt::Index m_;
+    Ipopt::Index nnz_jac_g_;
+    Ipopt::Index nnz_h_lag_;
+    Ipopt::TNLP::IndexStyleEnum index_style_;
+    //@}
+
+    /** Copy of original x_sol_.  x_sol_ is changed after the first QP
+     *  has been solved once. */
+    Ipopt::Number* x_sol_copy_;
+
+    /** Copy of original duals_sol_.  duals_sol_ is changed after the
+     *  first QP has been solved once. */
+    Ipopt::Number* duals_sol_copy_;
+
+    /** Pointer to the TMINLP2TNLP model which stores the bounds
+     *  information */
+    Ipopt::SmartPtr<TMINLP2TNLP> tminlp2tnlp_;
+  };
+
+} // namespace Ipopt
+
+#endif