Changeset 1346


Ignore:
Timestamp:
Dec 3, 2009 3:48:32 PM (9 years ago)
Author:
EdwinStraver
Message:

Combined CbcGeneralDepth?, CbcGeneralBranchingObject? and CbcOneGeneralBranchingObject?

Location:
branches/sandbox/Cbc
Files:
4 deleted
6 edited

Legend:

Unmodified
Added
Removed
  • branches/sandbox/Cbc/MSVisualStudio/v9/libCbc/libCbc.vcproj

    r1344 r1346  
    501501                        </File>
    502502                        <File
    503                                 RelativePath="..\..\..\src\CbcGeneralBranchingObject.cpp"
    504                                 >
    505                         </File>
    506                         <File
    507503                                RelativePath="..\..\..\src\CbcGeneralDepth.cpp"
    508504                                >
     
    929925                        <File
    930926                                RelativePath="..\..\..\src\CbcObjectUpdateData.cpp"
    931                                 >
    932                         </File>
    933                         <File
    934                                 RelativePath="..\..\..\src\CbcOneGeneralBranchingObject.cpp"
    935927                                >
    936928                        </File>
     
    12581250                        </File>
    12591251                        <File
    1260                                 RelativePath="..\..\..\src\CbcGeneralBranchingObject.hpp"
    1261                                 >
    1262                         </File>
    1263                         <File
    12641252                                RelativePath="..\..\..\src\CbcGeneralDepth.hpp"
    12651253                                >
     
    13671355                        <File
    13681356                                RelativePath="..\..\..\src\CbcObjectUpdateData.hpp"
    1369                                 >
    1370                         </File>
    1371                         <File
    1372                                 RelativePath="..\..\..\src\CbcOneGeneralBranchingObject.hpp"
    13731357                                >
    13741358                        </File>
  • branches/sandbox/Cbc/src/CbcBranchActual.hpp

    r1344 r1346  
    2424#include "CbcGeneralDepth.hpp"
    2525#include "CbcSubProblem.hpp"
    26 #include "CbcGeneralBranchingObject.hpp"
    27 #include "CbcOneGeneralBranchingObject.hpp"
    2826#endif
  • branches/sandbox/Cbc/src/CbcGeneralDepth.cpp

    r1293 r1346  
    381381    return branch;
    382382}
     383
     384// Default Constructor
     385CbcGeneralBranchingObject::CbcGeneralBranchingObject()
     386        : CbcBranchingObject(),
     387        subProblems_(NULL),
     388        node_(NULL),
     389        numberSubProblems_(0),
     390        numberSubLeft_(0),
     391        whichNode_(-1),
     392        numberRows_(0)
     393{
     394    //  printf("CbcGeneral %x default constructor\n",this);
     395}
     396
     397// Useful constructor
     398CbcGeneralBranchingObject::CbcGeneralBranchingObject (CbcModel * model)
     399        : CbcBranchingObject(model, -1, -1, 0.5),
     400        subProblems_(NULL),
     401        node_(NULL),
     402        numberSubProblems_(0),
     403        numberSubLeft_(0),
     404        whichNode_(-1),
     405        numberRows_(0)
     406{
     407    //printf("CbcGeneral %x useful constructor\n",this);
     408}
     409
     410// Copy constructor
     411CbcGeneralBranchingObject::CbcGeneralBranchingObject ( const CbcGeneralBranchingObject & rhs)
     412        : CbcBranchingObject(rhs),
     413        subProblems_(NULL),
     414        node_(rhs.node_),
     415        numberSubProblems_(rhs.numberSubProblems_),
     416        numberSubLeft_(rhs.numberSubLeft_),
     417        whichNode_(rhs.whichNode_),
     418        numberRows_(rhs.numberRows_)
     419{
     420    abort();
     421    if (numberSubProblems_) {
     422        subProblems_ = new CbcSubProblem[numberSubProblems_];
     423        for (int i = 0; i < numberSubProblems_; i++)
     424            subProblems_[i] = rhs.subProblems_[i];
     425    }
     426}
     427
     428// Assignment operator
     429CbcGeneralBranchingObject &
     430CbcGeneralBranchingObject::operator=( const CbcGeneralBranchingObject & rhs)
     431{
     432    if (this != &rhs) {
     433        abort();
     434        CbcBranchingObject::operator=(rhs);
     435        delete [] subProblems_;
     436        numberSubProblems_ = rhs.numberSubProblems_;
     437        numberSubLeft_ = rhs.numberSubLeft_;
     438        whichNode_ = rhs.whichNode_;
     439        numberRows_ = rhs.numberRows_;
     440        if (numberSubProblems_) {
     441            subProblems_ = new CbcSubProblem[numberSubProblems_];
     442            for (int i = 0; i < numberSubProblems_; i++)
     443                subProblems_[i] = rhs.subProblems_[i];
     444        } else {
     445            subProblems_ = NULL;
     446        }
     447        node_ = rhs.node_;
     448    }
     449    return *this;
     450}
     451CbcBranchingObject *
     452CbcGeneralBranchingObject::clone() const
     453{
     454    return (new CbcGeneralBranchingObject(*this));
     455}
     456
     457
     458// Destructor
     459CbcGeneralBranchingObject::~CbcGeneralBranchingObject ()
     460{
     461    //printf("CbcGeneral %x destructor\n",this);
     462    delete [] subProblems_;
     463}
     464bool doingDoneBranch = false;
     465double
     466CbcGeneralBranchingObject::branch()
     467{
     468    double cutoff = model_->getCutoff();
     469    //printf("GenB %x whichNode %d numberLeft %d which %d\n",
     470    // this,whichNode_,numberBranchesLeft(),branchIndex());
     471    if (whichNode_ < 0) {
     472        assert (node_);
     473        bool applied = false;
     474        while (numberBranchesLeft()) {
     475            int which = branchIndex();
     476            decrementNumberBranchesLeft();
     477            CbcSubProblem * thisProb = subProblems_ + which;
     478            if (thisProb->objectiveValue_ < cutoff) {
     479                //printf("branch %x (sub %x) which now %d\n",this,
     480                //     subProblems_,which);
     481                OsiSolverInterface * solver = model_->solver();
     482                thisProb->apply(solver);
     483                OsiClpSolverInterface * clpSolver
     484                = dynamic_cast<OsiClpSolverInterface *> (solver);
     485                assert (clpSolver);
     486                // Move status to basis
     487                clpSolver->setWarmStart(NULL);
     488                //ClpSimplex * simplex = clpSolver->getModelPtr();
     489                node_->setObjectiveValue(thisProb->objectiveValue_);
     490                node_->setSumInfeasibilities(thisProb->sumInfeasibilities_);
     491                node_->setNumberUnsatisfied(thisProb->numberInfeasibilities_);
     492                applied = true;
     493                doingDoneBranch = true;
     494                break;
     495            } else if (numberBranchesLeft()) {
     496                node_->nodeInfo()->branchedOn() ;
     497            }
     498        }
     499        if (!applied) {
     500            // no good one
     501            node_->setObjectiveValue(cutoff + 1.0e20);
     502            node_->setSumInfeasibilities(1.0);
     503            node_->setNumberUnsatisfied(1);
     504            assert (whichNode_ < 0);
     505        }
     506    } else {
     507        decrementNumberBranchesLeft();
     508        CbcSubProblem * thisProb = subProblems_ + whichNode_;
     509        assert (thisProb->objectiveValue_ < cutoff);
     510        OsiSolverInterface * solver = model_->solver();
     511        thisProb->apply(solver);
     512        //OsiClpSolverInterface * clpSolver
     513        //= dynamic_cast<OsiClpSolverInterface *> (solver);
     514        //assert (clpSolver);
     515        // Move status to basis
     516        //clpSolver->setWarmStart(NULL);
     517    }
     518    return 0.0;
     519}
     520/* Double checks in case node can change its mind!
     521   Can change objective etc */
     522void
     523CbcGeneralBranchingObject::checkIsCutoff(double cutoff)
     524{
     525    assert (node_);
     526    int first = branchIndex();
     527    int last = first + numberBranchesLeft();
     528    for (int which = first; which < last; which++) {
     529        CbcSubProblem * thisProb = subProblems_ + which;
     530        if (thisProb->objectiveValue_ < cutoff) {
     531            node_->setObjectiveValue(thisProb->objectiveValue_);
     532            node_->setSumInfeasibilities(thisProb->sumInfeasibilities_);
     533            node_->setNumberUnsatisfied(thisProb->numberInfeasibilities_);
     534            break;
     535        }
     536    }
     537}
     538// Print what would happen
     539void
     540CbcGeneralBranchingObject::print()
     541{
     542    //printf("CbcGeneralObject has %d subproblems\n",numberSubProblems_);
     543}
     544// Fill in current objective etc
     545void
     546CbcGeneralBranchingObject::state(double & objectiveValue,
     547                                 double & sumInfeasibilities,
     548                                 int & numberUnsatisfied, int which) const
     549{
     550    assert (which >= 0 && which < numberSubProblems_);
     551    const CbcSubProblem * thisProb = subProblems_ + which;
     552    objectiveValue = thisProb->objectiveValue_;
     553    sumInfeasibilities = thisProb->sumInfeasibilities_;
     554    numberUnsatisfied = thisProb->numberInfeasibilities_;
     555}
     556/** Compare the original object of \c this with the original object of \c
     557    brObj. Assumes that there is an ordering of the original objects.
     558    This method should be invoked only if \c this and brObj are of the same
     559    type.
     560    Return negative/0/positive depending on whether \c this is
     561    smaller/same/larger than the argument.
     562*/
     563int
     564CbcGeneralBranchingObject::compareOriginalObject
     565(const CbcBranchingObject* /*brObj*/) const
     566{
     567    throw("must implement");
     568}
     569
     570/** Compare the \c this with \c brObj. \c this and \c brObj must be os the
     571    same type and must have the same original object, but they may have
     572    different feasible regions.
     573    Return the appropriate CbcRangeCompare value (first argument being the
     574    sub/superset if that's the case). In case of overlap (and if \c
     575    replaceIfOverlap is true) replace the current branching object with one
     576    whose feasible region is the overlap.
     577*/
     578CbcRangeCompare
     579CbcGeneralBranchingObject::compareBranchingObject
     580(const CbcBranchingObject* /*brObj*/, const bool /*replaceIfOverlap*/)
     581{
     582    throw("must implement");
     583}
     584
     585// Default Constructor
     586CbcOneGeneralBranchingObject::CbcOneGeneralBranchingObject()
     587        : CbcBranchingObject(),
     588        object_(NULL),
     589        whichOne_(-1)
     590{
     591    //printf("CbcOneGeneral %x default constructor\n",this);
     592}
     593
     594// Useful constructor
     595CbcOneGeneralBranchingObject::CbcOneGeneralBranchingObject (CbcModel * model,
     596        CbcGeneralBranchingObject * object,
     597        int whichOne)
     598        : CbcBranchingObject(model, -1, -1, 0.5),
     599        object_(object),
     600        whichOne_(whichOne)
     601{
     602    //printf("CbcOneGeneral %x useful constructor object %x %d left\n",this,
     603    //   object_,object_->numberSubLeft_);
     604    numberBranches_ = 1;
     605}
     606
     607// Copy constructor
     608CbcOneGeneralBranchingObject::CbcOneGeneralBranchingObject ( const CbcOneGeneralBranchingObject & rhs)
     609        : CbcBranchingObject(rhs),
     610        object_(rhs.object_),
     611        whichOne_(rhs.whichOne_)
     612{
     613}
     614
     615// Assignment operator
     616CbcOneGeneralBranchingObject &
     617CbcOneGeneralBranchingObject::operator=( const CbcOneGeneralBranchingObject & rhs)
     618{
     619    if (this != &rhs) {
     620        CbcBranchingObject::operator=(rhs);
     621        object_ = rhs.object_;
     622        whichOne_ = rhs.whichOne_;
     623    }
     624    return *this;
     625}
     626CbcBranchingObject *
     627CbcOneGeneralBranchingObject::clone() const
     628{
     629    return (new CbcOneGeneralBranchingObject(*this));
     630}
     631
     632
     633// Destructor
     634CbcOneGeneralBranchingObject::~CbcOneGeneralBranchingObject ()
     635{
     636    //printf("CbcOneGeneral %x destructor object %x %d left\n",this,
     637    // object_,object_->numberSubLeft_);
     638    assert (object_->numberSubLeft_ > 0 &&
     639            object_->numberSubLeft_ < 1000000);
     640    if (!object_->decrementNumberLeft()) {
     641        // printf("CbcGeneral %x yy destructor\n",object_);
     642        delete object_;
     643    }
     644}
     645double
     646CbcOneGeneralBranchingObject::branch()
     647{
     648    assert (numberBranchesLeft());
     649    decrementNumberBranchesLeft();
     650    assert (!numberBranchesLeft());
     651    object_->setWhichNode(whichOne_);
     652    object_->branch();
     653    return 0.0;
     654}
     655/* Double checks in case node can change its mind!
     656   Can change objective etc */
     657void
     658CbcOneGeneralBranchingObject::checkIsCutoff(double /*cutoff*/)
     659{
     660    assert (numberBranchesLeft());
     661}
     662// Print what would happen
     663void
     664CbcOneGeneralBranchingObject::print()
     665{
     666    //printf("CbcOneGeneralObject has 1 subproblem\n");
     667}
     668/** Compare the original object of \c this with the original object of \c
     669    brObj. Assumes that there is an ordering of the original objects.
     670    This method should be invoked only if \c this and brObj are of the same
     671    type.
     672    Return negative/0/positive depending on whether \c this is
     673    smaller/same/larger than the argument.
     674*/
     675int
     676CbcOneGeneralBranchingObject::compareOriginalObject
     677(const CbcBranchingObject* /*brObj*/) const
     678{
     679    throw("must implement");
     680}
     681
     682/** Compare the \c this with \c brObj. \c this and \c brObj must be os the
     683    same type and must have the same original object, but they may have
     684    different feasible regions.
     685    Return the appropriate CbcRangeCompare value (first argument being the
     686    sub/superset if that's the case). In case of overlap (and if \c
     687    replaceIfOverlap is true) replace the current branching object with one
     688    whose feasible region is the overlap.
     689*/
     690CbcRangeCompare
     691CbcOneGeneralBranchingObject::compareBranchingObject
     692(const CbcBranchingObject* /*brObj*/, const bool /*replaceIfOverlap*/)
     693{
     694    throw("must implement");
     695}
    383696#endif
  • branches/sandbox/Cbc/src/CbcGeneralDepth.hpp

    r1293 r1346  
    44
    55#include "CbcGeneral.hpp"
     6#include "CbcBranchBase.hpp"
     7#include "CbcSubProblem.hpp"
    68
    79#ifdef COIN_HAS_CLP
     
    8890    mutable ClpNodeStuff * nodeInfo_;
    8991};
     92/** Branching object for general objects
     93
     94 */
     95class CbcNode;
     96class CbcGeneralBranchingObject : public CbcBranchingObject {
     97
     98public:
     99
     100    // Default Constructor
     101    CbcGeneralBranchingObject ();
     102
     103    // Useful constructor
     104    CbcGeneralBranchingObject (CbcModel * model);
     105
     106    // Copy constructor
     107    CbcGeneralBranchingObject ( const CbcGeneralBranchingObject &);
     108
     109    // Assignment operator
     110    CbcGeneralBranchingObject & operator=( const CbcGeneralBranchingObject& rhs);
     111
     112    /// Clone
     113    virtual CbcBranchingObject * clone() const;
     114
     115    // Destructor
     116    virtual ~CbcGeneralBranchingObject ();
     117
     118    using CbcBranchingObject::branch ;
     119    /// Does next branch and updates state
     120    virtual double branch();
     121    /** Double checks in case node can change its mind!
     122        Can change objective etc */
     123    virtual void checkIsCutoff(double cutoff);
     124
     125    using CbcBranchingObject::print ;
     126    /** \brief Print something about branch - only if log level high
     127    */
     128    virtual void print();
     129    /// Fill in current objective etc
     130    void state(double & objectiveValue, double & sumInfeasibilities,
     131               int & numberUnsatisfied, int which) const;
     132    /// Set CbcNode
     133    inline void setNode(CbcNode * node) {
     134        node_ = node;
     135    }
     136    /** Return the type (an integer identifier) of \c this */
     137    virtual int type() const {
     138        return 108;
     139    }
     140
     141    /** Compare the original object of \c this with the original object of \c
     142        brObj. Assumes that there is an ordering of the original objects.
     143        This method should be invoked only if \c this and brObj are of the same
     144        type.
     145        Return negative/0/positive depending on whether \c this is
     146        smaller/same/larger than the argument.
     147    */
     148    virtual int compareOriginalObject(const CbcBranchingObject* brObj) const;
     149
     150    /** Compare the \c this with \c brObj. \c this and \c brObj must be os the
     151        same type and must have the same original object, but they may have
     152        different feasible regions.
     153        Return the appropriate CbcRangeCompare value (first argument being the
     154        sub/superset if that's the case). In case of overlap (and if \c
     155        replaceIfOverlap is true) replace the current branching object with one
     156        whose feasible region is the overlap.
     157     */
     158    virtual CbcRangeCompare compareBranchingObject
     159    (const CbcBranchingObject* brObj, const bool replaceIfOverlap = false);
     160    /// Number of subproblems
     161    inline int numberSubProblems() const {
     162        return numberSubProblems_;
     163    }
     164    /// Decrement number left and return number
     165    inline int decrementNumberLeft() {
     166        numberSubLeft_--;
     167        return numberSubLeft_;
     168    }
     169    /// Which node we want to use
     170    inline int whichNode() const {
     171        return whichNode_;
     172    }
     173    /// Set which node we want to use
     174    inline void setWhichNode(int value) {
     175        whichNode_ = value;
     176    }
     177    // Sub problem
     178    const CbcSubProblem * subProblem(int which) const {
     179        return subProblems_ + which;
     180    }
     181
     182public:
     183    /// data
     184    // Sub problems
     185    CbcSubProblem * subProblems_;
     186    /// Node
     187    CbcNode * node_;
     188    /// Number of subproblems
     189    int numberSubProblems_;
     190    /// Number of subproblems left
     191    int numberSubLeft_;
     192    /// Which node we want to use (-1 for default)
     193    int whichNode_;
     194    /// Number of rows
     195    int numberRows_;
     196};
     197/** Branching object for general objects - just one
     198
     199 */
     200class CbcOneGeneralBranchingObject : public CbcBranchingObject {
     201
     202public:
     203
     204    // Default Constructor
     205    CbcOneGeneralBranchingObject ();
     206
     207    // Useful constructor
     208    CbcOneGeneralBranchingObject (CbcModel * model,
     209                                  CbcGeneralBranchingObject * object,
     210                                  int whichOne);
     211
     212    // Copy constructor
     213    CbcOneGeneralBranchingObject ( const CbcOneGeneralBranchingObject &);
     214
     215    // Assignment operator
     216    CbcOneGeneralBranchingObject & operator=( const CbcOneGeneralBranchingObject& rhs);
     217
     218    /// Clone
     219    virtual CbcBranchingObject * clone() const;
     220
     221    // Destructor
     222    virtual ~CbcOneGeneralBranchingObject ();
     223
     224    using CbcBranchingObject::branch ;
     225    /// Does next branch and updates state
     226    virtual double branch();
     227    /** Double checks in case node can change its mind!
     228        Can change objective etc */
     229    virtual void checkIsCutoff(double cutoff);
     230
     231    using CbcBranchingObject::print ;
     232    /** \brief Print something about branch - only if log level high
     233    */
     234    virtual void print();
     235    /** Return the type (an integer identifier) of \c this */
     236    virtual int type() const {
     237        return 110;
     238    }
     239
     240    /** Compare the original object of \c this with the original object of \c
     241        brObj. Assumes that there is an ordering of the original objects.
     242        This method should be invoked only if \c this and brObj are of the same
     243        type.
     244        Return negative/0/positive depending on whether \c this is
     245        smaller/same/larger than the argument.
     246    */
     247    virtual int compareOriginalObject(const CbcBranchingObject* brObj) const;
     248
     249    /** Compare the \c this with \c brObj. \c this and \c brObj must be os the
     250        same type and must have the same original object, but they may have
     251        different feasible regions.
     252        Return the appropriate CbcRangeCompare value (first argument being the
     253        sub/superset if that's the case). In case of overlap (and if \c
     254        replaceIfOverlap is true) replace the current branching object with one
     255        whose feasible region is the overlap.
     256     */
     257    virtual CbcRangeCompare compareBranchingObject
     258    (const CbcBranchingObject* brObj, const bool replaceIfOverlap = false);
     259
     260public:
     261    /// data
     262    /// Object
     263    CbcGeneralBranchingObject * object_;
     264    /// Which one
     265    int whichOne_;
     266};
    90267#endif //COIN_HAS_CLP
    91268#endif
  • branches/sandbox/Cbc/src/Makefile.am

    r1344 r1346  
    5757        CbcFollowOn.cpp CbcFollowOn.hpp \
    5858        CbcGeneral.cpp CbcGeneral.hpp \
    59         CbcGeneralBranchingObject.cpp CbcGeneralBranchingObject.hpp \
    6059        CbcGeneralDepth.cpp CbcGeneralDepth.hpp \
    6160        CbcHeuristic.cpp CbcHeuristic.hpp \
     
    8584        CbcObject.cpp CbcObject.hpp \
    8685        CbcObjectUpdateData.cpp CbcObjectUpdateData.hpp \
    87         CbcOneGeneralBranchingObject.cpp CbcOneGeneralBranchingObject.hpp \
    8886        CbcPartialNodeInfo.cpp CbcPartialNodeInfo.hpp \
    8987        CbcSimpleInteger.cpp CbcSimpleInteger.hpp \
     
    382380        CbcFullNodeInfo.hpp \
    383381        CbcGeneral.hpp \
    384         CbcGeneralBranchingObject.hpp \
    385382        CbcGeneralDepth.hpp \
    386383        CbcHeuristic.hpp \
     
    409406        CbcObject.hpp \
    410407        CbcObjectUpdateData.hpp \
    411         CbcOneGeneralBranchingObject.hpp \
    412408        CbcPartialNodeInfo.hpp \
    413409        CbcSimpleInteger.hpp \
  • branches/sandbox/Cbc/src/Makefile.in

    r1344 r1346  
    174174        CbcFixingBranchingObject.lo CbcFixVariable.lo \
    175175        CbcFullNodeInfo.lo CbcFollowOn.lo CbcGeneral.lo \
    176         CbcGeneralBranchingObject.lo CbcGeneralDepth.lo \
    177         CbcHeuristic.lo CbcHeuristicDive.lo \
     176        CbcGeneralDepth.lo CbcHeuristic.lo CbcHeuristicDive.lo \
    178177        CbcHeuristicDiveCoefficient.lo CbcHeuristicDiveFractional.lo \
    179178        CbcHeuristicDiveGuided.lo CbcHeuristicDiveLineSearch.lo \
     
    186185        CbcMessage.lo CbcModel.lo CbcNode.lo CbcNodeInfo.lo CbcNWay.lo \
    187186        CbcNWayBranchingObject.lo CbcObject.lo CbcObjectUpdateData.lo \
    188         CbcOneGeneralBranchingObject.lo CbcPartialNodeInfo.lo \
    189         CbcSimpleInteger.lo CbcSimpleIntegerDynamicPseudoCost.lo \
     187        CbcPartialNodeInfo.lo CbcSimpleInteger.lo \
     188        CbcSimpleIntegerDynamicPseudoCost.lo \
    190189        CbcSimpleIntegerPseudoCost.lo CbcSOS.lo \
    191190        CbcSOSBranchingObject.lo CbcStatistics.lo CbcStrategy.lo \
     
    560559        CbcFollowOn.cpp CbcFollowOn.hpp \
    561560        CbcGeneral.cpp CbcGeneral.hpp \
    562         CbcGeneralBranchingObject.cpp CbcGeneralBranchingObject.hpp \
    563561        CbcGeneralDepth.cpp CbcGeneralDepth.hpp \
    564562        CbcHeuristic.cpp CbcHeuristic.hpp \
     
    588586        CbcObject.cpp CbcObject.hpp \
    589587        CbcObjectUpdateData.cpp CbcObjectUpdateData.hpp \
    590         CbcOneGeneralBranchingObject.cpp CbcOneGeneralBranchingObject.hpp \
    591588        CbcPartialNodeInfo.cpp CbcPartialNodeInfo.hpp \
    592589        CbcSimpleInteger.cpp CbcSimpleInteger.hpp \
     
    748745        CbcFullNodeInfo.hpp \
    749746        CbcGeneral.hpp \
    750         CbcGeneralBranchingObject.hpp \
    751747        CbcGeneralDepth.hpp \
    752748        CbcHeuristic.hpp \
     
    775771        CbcObject.hpp \
    776772        CbcObjectUpdateData.hpp \
    777         CbcOneGeneralBranchingObject.hpp \
    778773        CbcPartialNodeInfo.hpp \
    779774        CbcSimpleInteger.hpp \
     
    944939@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CbcGenSolvers.Po@am__quote@
    945940@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CbcGeneral.Plo@am__quote@
    946 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CbcGeneralBranchingObject.Plo@am__quote@
    947941@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CbcGeneralDepth.Plo@am__quote@
    948942@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CbcGeneric.Po@am__quote@
     
    973967@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CbcObject.Plo@am__quote@
    974968@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CbcObjectUpdateData.Plo@am__quote@
    975 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CbcOneGeneralBranchingObject.Plo@am__quote@
    976969@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CbcPartialNodeInfo.Plo@am__quote@
    977970@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CbcSOS.Plo@am__quote@
Note: See TracChangeset for help on using the changeset viewer.