Changeset 1346 for branches

Timestamp:

Dec 3, 2009 3:48:32 PM (12 years ago)

Author:

EdwinStraver

Message:

Combined CbcGeneralDepth?, CbcGeneralBranchingObject? and CbcOneGeneralBranchingObject?

Location:

branches/sandbox/Cbc

Files:

• MSVisualStudio/v9/libCbc/libCbc.vcproj (modified) (4 diffs)
• src/CbcBranchActual.hpp (modified) (1 diff)
• src/CbcGeneralBranchingObject.cpp (deleted)
• src/CbcGeneralBranchingObject.hpp (deleted)
• src/CbcGeneralDepth.cpp (modified) (1 diff)
• src/CbcGeneralDepth.hpp (modified) (2 diffs)
• src/CbcOneGeneralBranchingObject.cpp (deleted)
• src/CbcOneGeneralBranchingObject.hpp (deleted)
• src/Makefile.am (modified) (4 diffs)
• src/Makefile.in (modified) (8 diffs)

branches/sandbox/Cbc/MSVisualStudio/v9/libCbc/libCbc.vcproj

@@ -501 +501 @@
                         </File>
                         <File
-                                RelativePath="..\..\..\src\CbcGeneralBranchingObject.cpp"
-                                >
-                        </File>
-                        <File
                                 RelativePath="..\..\..\src\CbcGeneralDepth.cpp"
                                 >
@@ -929 +925 @@
                         <File
                                 RelativePath="..\..\..\src\CbcObjectUpdateData.cpp"
-                                >
-                        </File>
-                        <File
-                                RelativePath="..\..\..\src\CbcOneGeneralBranchingObject.cpp"
                                 >
                         </File>
@@ -1258 +1250 @@
                         </File>
                         <File
-                                RelativePath="..\..\..\src\CbcGeneralBranchingObject.hpp"
-                                >
-                        </File>
-                        <File
                                 RelativePath="..\..\..\src\CbcGeneralDepth.hpp"
                                 >
@@ -1367 +1355 @@
                         <File
                                 RelativePath="..\..\..\src\CbcObjectUpdateData.hpp"
-                                >
-                        </File>
-                        <File
-                                RelativePath="..\..\..\src\CbcOneGeneralBranchingObject.hpp"
                                 >
                         </File>

branches/sandbox/Cbc/src/CbcBranchActual.hpp

@@ -24 +24 @@
 #include "CbcGeneralDepth.hpp" 
 #include "CbcSubProblem.hpp"
-#include "CbcGeneralBranchingObject.hpp"
-#include "CbcOneGeneralBranchingObject.hpp"
 #endif

branches/sandbox/Cbc/src/CbcGeneralDepth.cpp

@@ -381 +381 @@
     return branch;
 }
+
+// Default Constructor
+CbcGeneralBranchingObject::CbcGeneralBranchingObject()
+        : CbcBranchingObject(),
+        subProblems_(NULL),
+        node_(NULL),
+        numberSubProblems_(0),
+        numberSubLeft_(0),
+        whichNode_(-1),
+        numberRows_(0)
+{
+    //  printf("CbcGeneral %x default constructor\n",this);
+}
+
+// Useful constructor
+CbcGeneralBranchingObject::CbcGeneralBranchingObject (CbcModel * model)
+        : CbcBranchingObject(model, -1, -1, 0.5),
+        subProblems_(NULL),
+        node_(NULL),
+        numberSubProblems_(0),
+        numberSubLeft_(0),
+        whichNode_(-1),
+        numberRows_(0)
+{
+    //printf("CbcGeneral %x useful constructor\n",this);
+}
+
+// Copy constructor
+CbcGeneralBranchingObject::CbcGeneralBranchingObject ( const CbcGeneralBranchingObject & rhs)
+        : CbcBranchingObject(rhs),
+        subProblems_(NULL),
+        node_(rhs.node_),
+        numberSubProblems_(rhs.numberSubProblems_),
+        numberSubLeft_(rhs.numberSubLeft_),
+        whichNode_(rhs.whichNode_),
+        numberRows_(rhs.numberRows_)
+{
+    abort();
+    if (numberSubProblems_) {
+        subProblems_ = new CbcSubProblem[numberSubProblems_];
+        for (int i = 0; i < numberSubProblems_; i++)
+            subProblems_[i] = rhs.subProblems_[i];
+    }
+}
+
+// Assignment operator
+CbcGeneralBranchingObject &
+CbcGeneralBranchingObject::operator=( const CbcGeneralBranchingObject & rhs)
+{
+    if (this != &rhs) {
+        abort();
+        CbcBranchingObject::operator=(rhs);
+        delete [] subProblems_;
+        numberSubProblems_ = rhs.numberSubProblems_;
+        numberSubLeft_ = rhs.numberSubLeft_;
+        whichNode_ = rhs.whichNode_;
+        numberRows_ = rhs.numberRows_;
+        if (numberSubProblems_) {
+            subProblems_ = new CbcSubProblem[numberSubProblems_];
+            for (int i = 0; i < numberSubProblems_; i++)
+                subProblems_[i] = rhs.subProblems_[i];
+        } else {
+            subProblems_ = NULL;
+        }
+        node_ = rhs.node_;
+    }
+    return *this;
+}
+CbcBranchingObject *
+CbcGeneralBranchingObject::clone() const
+{
+    return (new CbcGeneralBranchingObject(*this));
+}
+
+
+// Destructor
+CbcGeneralBranchingObject::~CbcGeneralBranchingObject ()
+{
+    //printf("CbcGeneral %x destructor\n",this);
+    delete [] subProblems_;
+}
+bool doingDoneBranch = false;
+double
+CbcGeneralBranchingObject::branch()
+{
+    double cutoff = model_->getCutoff();
+    //printf("GenB %x whichNode %d numberLeft %d which %d\n",
+    // this,whichNode_,numberBranchesLeft(),branchIndex());
+    if (whichNode_ < 0) {
+        assert (node_);
+        bool applied = false;
+        while (numberBranchesLeft()) {
+            int which = branchIndex();
+            decrementNumberBranchesLeft();
+            CbcSubProblem * thisProb = subProblems_ + which;
+            if (thisProb->objectiveValue_ < cutoff) {
+                //printf("branch %x (sub %x) which now %d\n",this,
+                //     subProblems_,which);
+                OsiSolverInterface * solver = model_->solver();
+                thisProb->apply(solver);
+                OsiClpSolverInterface * clpSolver
+                = dynamic_cast<OsiClpSolverInterface *> (solver);
+                assert (clpSolver);
+                // Move status to basis
+                clpSolver->setWarmStart(NULL);
+                //ClpSimplex * simplex = clpSolver->getModelPtr();
+                node_->setObjectiveValue(thisProb->objectiveValue_);
+                node_->setSumInfeasibilities(thisProb->sumInfeasibilities_);
+                node_->setNumberUnsatisfied(thisProb->numberInfeasibilities_);
+                applied = true;
+                doingDoneBranch = true;
+                break;
+            } else if (numberBranchesLeft()) {
+                node_->nodeInfo()->branchedOn() ;
+            }
+        }
+        if (!applied) {
+            // no good one
+            node_->setObjectiveValue(cutoff + 1.0e20);
+            node_->setSumInfeasibilities(1.0);
+            node_->setNumberUnsatisfied(1);
+            assert (whichNode_ < 0);
+        }
+    } else {
+        decrementNumberBranchesLeft();
+        CbcSubProblem * thisProb = subProblems_ + whichNode_;
+        assert (thisProb->objectiveValue_ < cutoff);
+        OsiSolverInterface * solver = model_->solver();
+        thisProb->apply(solver);
+        //OsiClpSolverInterface * clpSolver
+        //= dynamic_cast<OsiClpSolverInterface *> (solver);
+        //assert (clpSolver);
+        // Move status to basis
+        //clpSolver->setWarmStart(NULL);
+    }
+    return 0.0;
+}
+/* Double checks in case node can change its mind!
+   Can change objective etc */
+void
+CbcGeneralBranchingObject::checkIsCutoff(double cutoff)
+{
+    assert (node_);
+    int first = branchIndex();
+    int last = first + numberBranchesLeft();
+    for (int which = first; which < last; which++) {
+        CbcSubProblem * thisProb = subProblems_ + which;
+        if (thisProb->objectiveValue_ < cutoff) {
+            node_->setObjectiveValue(thisProb->objectiveValue_);
+            node_->setSumInfeasibilities(thisProb->sumInfeasibilities_);
+            node_->setNumberUnsatisfied(thisProb->numberInfeasibilities_);
+            break;
+        }
+    }
+}
+// Print what would happen
+void
+CbcGeneralBranchingObject::print()
+{
+    //printf("CbcGeneralObject has %d subproblems\n",numberSubProblems_);
+}
+// Fill in current objective etc
+void
+CbcGeneralBranchingObject::state(double & objectiveValue,
+                                 double & sumInfeasibilities,
+                                 int & numberUnsatisfied, int which) const
+{
+    assert (which >= 0 && which < numberSubProblems_);
+    const CbcSubProblem * thisProb = subProblems_ + which;
+    objectiveValue = thisProb->objectiveValue_;
+    sumInfeasibilities = thisProb->sumInfeasibilities_;
+    numberUnsatisfied = thisProb->numberInfeasibilities_;
+}
+/** 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.
+*/
+int
+CbcGeneralBranchingObject::compareOriginalObject
+(const CbcBranchingObject* /*brObj*/) const
+{
+    throw("must implement");
+}
+
+/** Compare the \c this with \c brObj. \c this and \c brObj must be os 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.
+*/
+CbcRangeCompare
+CbcGeneralBranchingObject::compareBranchingObject
+(const CbcBranchingObject* /*brObj*/, const bool /*replaceIfOverlap*/)
+{
+    throw("must implement");
+}
+
+// Default Constructor
+CbcOneGeneralBranchingObject::CbcOneGeneralBranchingObject()
+        : CbcBranchingObject(),
+        object_(NULL),
+        whichOne_(-1)
+{
+    //printf("CbcOneGeneral %x default constructor\n",this);
+}
+
+// Useful constructor
+CbcOneGeneralBranchingObject::CbcOneGeneralBranchingObject (CbcModel * model,
+        CbcGeneralBranchingObject * object,
+        int whichOne)
+        : CbcBranchingObject(model, -1, -1, 0.5),
+        object_(object),
+        whichOne_(whichOne)
+{
+    //printf("CbcOneGeneral %x useful constructor object %x %d left\n",this,
+    //   object_,object_->numberSubLeft_);
+    numberBranches_ = 1;
+}
+
+// Copy constructor
+CbcOneGeneralBranchingObject::CbcOneGeneralBranchingObject ( const CbcOneGeneralBranchingObject & rhs)
+        : CbcBranchingObject(rhs),
+        object_(rhs.object_),
+        whichOne_(rhs.whichOne_)
+{
+}
+
+// Assignment operator
+CbcOneGeneralBranchingObject &
+CbcOneGeneralBranchingObject::operator=( const CbcOneGeneralBranchingObject & rhs)
+{
+    if (this != &rhs) {
+        CbcBranchingObject::operator=(rhs);
+        object_ = rhs.object_;
+        whichOne_ = rhs.whichOne_;
+    }
+    return *this;
+}
+CbcBranchingObject *
+CbcOneGeneralBranchingObject::clone() const
+{
+    return (new CbcOneGeneralBranchingObject(*this));
+}
+
+
+// Destructor
+CbcOneGeneralBranchingObject::~CbcOneGeneralBranchingObject ()
+{
+    //printf("CbcOneGeneral %x destructor object %x %d left\n",this,
+    // object_,object_->numberSubLeft_);
+    assert (object_->numberSubLeft_ > 0 &&
+            object_->numberSubLeft_ < 1000000);
+    if (!object_->decrementNumberLeft()) {
+        // printf("CbcGeneral %x yy destructor\n",object_);
+        delete object_;
+    }
+}
+double
+CbcOneGeneralBranchingObject::branch()
+{
+    assert (numberBranchesLeft());
+    decrementNumberBranchesLeft();
+    assert (!numberBranchesLeft());
+    object_->setWhichNode(whichOne_);
+    object_->branch();
+    return 0.0;
+}
+/* Double checks in case node can change its mind!
+   Can change objective etc */
+void
+CbcOneGeneralBranchingObject::checkIsCutoff(double /*cutoff*/)
+{
+    assert (numberBranchesLeft());
+}
+// Print what would happen
+void
+CbcOneGeneralBranchingObject::print()
+{
+    //printf("CbcOneGeneralObject has 1 subproblem\n");
+}
+/** 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.
+*/
+int
+CbcOneGeneralBranchingObject::compareOriginalObject
+(const CbcBranchingObject* /*brObj*/) const
+{
+    throw("must implement");
+}
+
+/** Compare the \c this with \c brObj. \c this and \c brObj must be os 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.
+*/
+CbcRangeCompare
+CbcOneGeneralBranchingObject::compareBranchingObject
+(const CbcBranchingObject* /*brObj*/, const bool /*replaceIfOverlap*/)
+{
+    throw("must implement");
+}
 #endif

branches/sandbox/Cbc/src/CbcGeneralDepth.hpp

@@ -4 +4 @@
 
 #include "CbcGeneral.hpp"
+#include "CbcBranchBase.hpp"
+#include "CbcSubProblem.hpp"
 
 #ifdef COIN_HAS_CLP
@@ -88 +90 @@
     mutable ClpNodeStuff * nodeInfo_;
 };
+/** Branching object for general objects
+
+ */
+class CbcNode;
+class CbcGeneralBranchingObject : public CbcBranchingObject {
+
+public:
+
+    // Default Constructor
+    CbcGeneralBranchingObject ();
+
+    // Useful constructor
+    CbcGeneralBranchingObject (CbcModel * model);
+
+    // Copy constructor
+    CbcGeneralBranchingObject ( const CbcGeneralBranchingObject &);
+
+    // Assignment operator
+    CbcGeneralBranchingObject & operator=( const CbcGeneralBranchingObject& rhs);
+
+    /// Clone
+    virtual CbcBranchingObject * clone() const;
+
+    // Destructor
+    virtual ~CbcGeneralBranchingObject ();
+
+    using CbcBranchingObject::branch ;
+    /// Does next branch and updates state
+    virtual double branch();
+    /** Double checks in case node can change its mind!
+        Can change objective etc */
+    virtual void checkIsCutoff(double cutoff);
+
+    using CbcBranchingObject::print ;
+    /** \brief Print something about branch - only if log level high
+    */
+    virtual void print();
+    /// Fill in current objective etc
+    void state(double & objectiveValue, double & sumInfeasibilities,
+               int & numberUnsatisfied, int which) const;
+    /// Set CbcNode
+    inline void setNode(CbcNode * node) {
+        node_ = node;
+    }
+    /** Return the type (an integer identifier) of \c this */
+    virtual int type() const {
+        return 108;
+    }
+
+    /** 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;
+
+    /** Compare the \c this with \c brObj. \c this and \c brObj must be os 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);
+    /// Number of subproblems
+    inline int numberSubProblems() const {
+        return numberSubProblems_;
+    }
+    /// Decrement number left and return number
+    inline int decrementNumberLeft() {
+        numberSubLeft_--;
+        return numberSubLeft_;
+    }
+    /// Which node we want to use
+    inline int whichNode() const {
+        return whichNode_;
+    }
+    /// Set which node we want to use
+    inline void setWhichNode(int value) {
+        whichNode_ = value;
+    }
+    // Sub problem
+    const CbcSubProblem * subProblem(int which) const {
+        return subProblems_ + which;
+    }
+
+public:
+    /// data
+    // Sub problems
+    CbcSubProblem * subProblems_;
+    /// Node
+    CbcNode * node_;
+    /// Number of subproblems
+    int numberSubProblems_;
+    /// Number of subproblems left
+    int numberSubLeft_;
+    /// Which node we want to use (-1 for default)
+    int whichNode_;
+    /// Number of rows
+    int numberRows_;
+};
+/** Branching object for general objects - just one
+
+ */
+class CbcOneGeneralBranchingObject : public CbcBranchingObject {
+
+public:
+
+    // Default Constructor
+    CbcOneGeneralBranchingObject ();
+
+    // Useful constructor
+    CbcOneGeneralBranchingObject (CbcModel * model,
+                                  CbcGeneralBranchingObject * object,
+                                  int whichOne);
+
+    // Copy constructor
+    CbcOneGeneralBranchingObject ( const CbcOneGeneralBranchingObject &);
+
+    // Assignment operator
+    CbcOneGeneralBranchingObject & operator=( const CbcOneGeneralBranchingObject& rhs);
+
+    /// Clone
+    virtual CbcBranchingObject * clone() const;
+
+    // Destructor
+    virtual ~CbcOneGeneralBranchingObject ();
+
+    using CbcBranchingObject::branch ;
+    /// Does next branch and updates state
+    virtual double branch();
+    /** Double checks in case node can change its mind!
+        Can change objective etc */
+    virtual void checkIsCutoff(double cutoff);
+
+    using CbcBranchingObject::print ;
+    /** \brief Print something about branch - only if log level high
+    */
+    virtual void print();
+    /** Return the type (an integer identifier) of \c this */
+    virtual int type() const {
+        return 110;
+    }
+
+    /** 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;
+
+    /** Compare the \c this with \c brObj. \c this and \c brObj must be os 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);
+
+public:
+    /// data
+    /// Object
+    CbcGeneralBranchingObject * object_;
+    /// Which one
+    int whichOne_;
+};
 #endif //COIN_HAS_CLP
 #endif

branches/sandbox/Cbc/src/Makefile.am

@@ -57 +57 @@
         CbcFollowOn.cpp CbcFollowOn.hpp \
         CbcGeneral.cpp CbcGeneral.hpp \
-        CbcGeneralBranchingObject.cpp CbcGeneralBranchingObject.hpp \
         CbcGeneralDepth.cpp CbcGeneralDepth.hpp \
         CbcHeuristic.cpp CbcHeuristic.hpp \
@@ -85 +84 @@
         CbcObject.cpp CbcObject.hpp \
         CbcObjectUpdateData.cpp CbcObjectUpdateData.hpp \
-        CbcOneGeneralBranchingObject.cpp CbcOneGeneralBranchingObject.hpp \
         CbcPartialNodeInfo.cpp CbcPartialNodeInfo.hpp \
         CbcSimpleInteger.cpp CbcSimpleInteger.hpp \
@@ -382 +380 @@
         CbcFullNodeInfo.hpp \
         CbcGeneral.hpp \
-        CbcGeneralBranchingObject.hpp \
         CbcGeneralDepth.hpp \
         CbcHeuristic.hpp \
@@ -409 +406 @@
         CbcObject.hpp \
         CbcObjectUpdateData.hpp \
-        CbcOneGeneralBranchingObject.hpp \
         CbcPartialNodeInfo.hpp \
         CbcSimpleInteger.hpp \

branches/sandbox/Cbc/src/Makefile.in

@@ -174 +174 @@
         CbcFixingBranchingObject.lo CbcFixVariable.lo \
         CbcFullNodeInfo.lo CbcFollowOn.lo CbcGeneral.lo \
-        CbcGeneralBranchingObject.lo CbcGeneralDepth.lo \
-        CbcHeuristic.lo CbcHeuristicDive.lo \
+        CbcGeneralDepth.lo CbcHeuristic.lo CbcHeuristicDive.lo \
         CbcHeuristicDiveCoefficient.lo CbcHeuristicDiveFractional.lo \
         CbcHeuristicDiveGuided.lo CbcHeuristicDiveLineSearch.lo \
@@ -186 +185 @@
         CbcMessage.lo CbcModel.lo CbcNode.lo CbcNodeInfo.lo CbcNWay.lo \
         CbcNWayBranchingObject.lo CbcObject.lo CbcObjectUpdateData.lo \
-        CbcOneGeneralBranchingObject.lo CbcPartialNodeInfo.lo \
-        CbcSimpleInteger.lo CbcSimpleIntegerDynamicPseudoCost.lo \
+        CbcPartialNodeInfo.lo CbcSimpleInteger.lo \
+        CbcSimpleIntegerDynamicPseudoCost.lo \
         CbcSimpleIntegerPseudoCost.lo CbcSOS.lo \
         CbcSOSBranchingObject.lo CbcStatistics.lo CbcStrategy.lo \
@@ -560 +559 @@
         CbcFollowOn.cpp CbcFollowOn.hpp \
         CbcGeneral.cpp CbcGeneral.hpp \
-        CbcGeneralBranchingObject.cpp CbcGeneralBranchingObject.hpp \
         CbcGeneralDepth.cpp CbcGeneralDepth.hpp \
         CbcHeuristic.cpp CbcHeuristic.hpp \
@@ -588 +586 @@
         CbcObject.cpp CbcObject.hpp \
         CbcObjectUpdateData.cpp CbcObjectUpdateData.hpp \
-        CbcOneGeneralBranchingObject.cpp CbcOneGeneralBranchingObject.hpp \
         CbcPartialNodeInfo.cpp CbcPartialNodeInfo.hpp \
         CbcSimpleInteger.cpp CbcSimpleInteger.hpp \
@@ -748 +745 @@
         CbcFullNodeInfo.hpp \
         CbcGeneral.hpp \
-        CbcGeneralBranchingObject.hpp \
         CbcGeneralDepth.hpp \
         CbcHeuristic.hpp \
@@ -775 +771 @@
         CbcObject.hpp \
         CbcObjectUpdateData.hpp \
-        CbcOneGeneralBranchingObject.hpp \
         CbcPartialNodeInfo.hpp \
         CbcSimpleInteger.hpp \
@@ -944 +939 @@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CbcGenSolvers.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CbcGeneral.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CbcGeneralBranchingObject.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CbcGeneralDepth.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CbcGeneric.Po@am__quote@
@@ -973 +967 @@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CbcObject.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CbcObjectUpdateData.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CbcOneGeneralBranchingObject.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CbcPartialNodeInfo.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CbcSOS.Plo@am__quote@