initial add

1 files changed, 236 insertions, 0 deletions

diff --git a/build/Bonmin/include/coin/CbcBranchingObject.hpp b/build/Bonmin/include/coin/CbcBranchingObject.hpp
new file mode 100644
index 0000000..803108d
--- /dev/null
+++ b/build/Bonmin/include/coin/CbcBranchingObject.hpp
@@ -0,0 +1,236 @@
+// $Id: CbcBranchingObject.hpp 1899 2013-04-09 18:12:08Z stefan $
+// Copyright (C) 2002, International Business Machines
+// Corporation and others.  All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+// Edwin 11/12/2009 carved from CbcBranchBase
+
+#ifndef CbcBranchingObject_H
+#define CbcBranchingObject_H
+
+#include <string>
+#include <vector>
+#include "CbcBranchBase.hpp"
+#include "OsiBranchingObject.hpp"
+
+
+// The types of objects that will be derived from this class.
+enum CbcBranchObjType
+  {
+    SimpleIntegerBranchObj = 100,
+    SimpleIntegerDynamicPseudoCostBranchObj = 101,
+    CliqueBranchObj = 102,
+    LongCliqueBranchObj = 103,
+    SoSBranchObj = 104,
+    NWayBranchObj = 105,
+    FollowOnBranchObj = 106,
+    DummyBranchObj = 107,
+    GeneralDepthBranchObj = 108,
+    OneGeneralBranchingObj = 110,
+    CutBranchingObj = 200,
+    LotsizeBranchObj = 300,
+    DynamicPseudoCostBranchObj = 400
+  };
+
+/** \brief Abstract branching object base class
+    Now just difference with OsiBranchingObject
+
+  In the abstract, an CbcBranchingObject contains instructions for how to
+  branch. We want an abstract class so that we can describe how to branch on
+  simple objects (<i>e.g.</i>, integers) and more exotic objects
+  (<i>e.g.</i>, cliques or hyperplanes).
+
+  The #branch() method is the crucial routine: it is expected to be able to
+  step through a set of branch arms, executing the actions required to create
+  each subproblem in turn. The base class is primarily virtual to allow for
+  a wide range of problem modifications.
+
+  See CbcObject for an overview of the three classes (CbcObject,
+  CbcBranchingObject, and CbcBranchDecision) which make up cbc's branching
+  model.
+*/
+
+class CbcBranchingObject : public OsiBranchingObject {
+
+public:
+
+    /// Default Constructor
+    CbcBranchingObject ();
+
+    /// Constructor
+    CbcBranchingObject (CbcModel * model, int variable, int way , double value);
+
+    /// Copy constructor
+    CbcBranchingObject ( const CbcBranchingObject &);
+
+    /// Assignment operator
+    CbcBranchingObject & operator=( const CbcBranchingObject& rhs);
+
+    /// Clone
+    virtual CbcBranchingObject * clone() const = 0;
+
+    /// Destructor
+    virtual ~CbcBranchingObject ();
+
+    /** Some branchingObjects may claim to be able to skip
+        strong branching.  If so they have to fill in CbcStrongInfo.
+        The object mention in incoming CbcStrongInfo must match.
+        Returns nonzero if skip is wanted */
+    virtual int fillStrongInfo( CbcStrongInfo & ) {
+        return 0;
+    }
+    /// Reset number of branches left to original
+    inline void resetNumberBranchesLeft() {
+        branchIndex_ = 0;
+    }
+    /// Set number of branches to do
+    inline void setNumberBranches(int value) {
+        branchIndex_ = 0;
+        numberBranches_ = value;
+    }
+
+    /** \brief Execute the actions required to branch, as specified by the
+           current state of the branching object, and advance the object's
+           state.  Mainly for diagnostics, whether it is true branch or
+           strong branching is also passed.
+           Returns change in guessed objective on next branch
+    */
+    virtual double branch() = 0;
+    /** \brief Execute the actions required to branch, as specified by the
+           current state of the branching object, and advance the object's
+           state.  Mainly for diagnostics, whether it is true branch or
+           strong branching is also passed.
+           Returns change in guessed objective on next branch
+    */
+    virtual double branch(OsiSolverInterface * ) {
+        return branch();
+    }
+    /** Update bounds in solver as in 'branch' and update given bounds.
+        branchState is -1 for 'down' +1 for 'up' */
+    virtual void fix(OsiSolverInterface * ,
+                     double * , double * ,
+                     int ) const {}
+
+    /** Change (tighten) bounds in object to reflect bounds in solver.
+	Return true if now fixed */
+    virtual bool tighten(OsiSolverInterface * ) {return false;}
+
+    /** Reset every information so that the branching object appears to point to
+        the previous child. This method does not need to modify anything in any
+        solver. */
+    virtual void previousBranch() {
+        assert(branchIndex_ > 0);
+        branchIndex_--;
+        way_ = -way_;
+    }
+
+    using OsiBranchingObject::print ;
+    /** \brief Print something about branch - only if log level high
+    */
+    virtual void print() const {}
+
+    /** \brief Index identifying the associated CbcObject within its class.
+
+      The name is misleading, and typically the index will <i>not</i> refer
+      directly to a variable.
+      Rather, it identifies an CbcObject within the class of similar
+      CbcObjects
+
+      <i>E.g.</i>, for an CbcSimpleInteger, variable() is the index of the
+      integer variable in the set of integer variables (<i>not</i> the index of
+      the variable in the set of all variables).
+    */
+    inline int variable() const {
+        return variable_;
+    }
+
+    /** Get the state of the branching object
+
+      Returns a code indicating the active arm of the branching object.
+      The precise meaning is defined in the derived class.
+
+      \sa #way_
+    */
+    inline int way() const {
+        return way_;
+    }
+
+    /** Set the state of the branching object.
+
+      See #way()
+    */
+    inline void way(int way) {
+        way_ = way;
+    }
+
+    /// update model
+    inline void setModel(CbcModel * model) {
+        model_ = model;
+    }
+    /// Return model
+    inline CbcModel * model() const {
+        return  model_;
+    }
+
+    /// Return pointer back to object which created
+    inline CbcObject * object() const {
+        return  originalCbcObject_;
+    }
+    /// Set pointer back to object which created
+    inline void setOriginalObject(CbcObject * object) {
+        originalCbcObject_ = object;
+    }
+
+    // Methods used in heuristics
+
+    /** Return the type (an integer identifier) of \c this.
+        See definition of CbcBranchObjType above for possibilities
+    */
+    
+    virtual CbcBranchObjType type() const = 0;
+
+    /** Compare the original object of \c this with the original object of \c
+        brObj. Assumes that there is an ordering of the original objects.
+        This method should be invoked only if \c this and brObj are of the same
+        type.
+        Return negative/0/positive depending on whether \c this is
+        smaller/same/larger than the argument.
+    */
+    virtual int compareOriginalObject(const CbcBranchingObject* brObj) const {
+        const CbcBranchingObject* br = dynamic_cast<const CbcBranchingObject*>(brObj);
+        return variable() - br->variable();
+    }
+
+    /** Compare the \c this with \c brObj. \c this and \c brObj must be of the
+        same type and must have the same original object, but they may have
+        different feasible regions.
+        Return the appropriate CbcRangeCompare value (first argument being the
+        sub/superset if that's the case). In case of overlap (and if \c
+        replaceIfOverlap is true) replace the current branching object with one
+        whose feasible region is the overlap.
+     */
+    virtual CbcRangeCompare compareBranchingObject
+    (const CbcBranchingObject* brObj, const bool replaceIfOverlap = false) = 0;
+
+protected:
+
+    /// The model that owns this branching object
+    CbcModel * model_;
+    /// Pointer back to object which created
+    CbcObject * originalCbcObject_;
+
+    /// Branching variable (0 is first integer)
+    int variable_;
+    // was - Way to branch - -1 down (first), 1 up, -2 down (second), 2 up (second)
+    /** The state of the branching object.
+
+      Specifies the active arm of the branching object. Coded as -1 to take
+      the `down' arm, +1 for the `up' arm. `Down' and `up' are defined based on
+      the natural meaning (floor and ceiling, respectively) for a simple integer.
+      The precise meaning is defined in the derived class.
+    */
+    int way_;
+
+};
+#endif
+