- Timestamp:
- Dec 3, 2009 3:48:32 PM (11 years ago)
- Location:
- branches/sandbox/Cbc
- Files:
-
- 4 deleted
- 6 edited
Legend:
- Unmodified
- Added
- Removed
-
branches/sandbox/Cbc/MSVisualStudio/v9/libCbc/libCbc.vcproj
r1344 r1346 501 501 </File> 502 502 <File 503 RelativePath="..\..\..\src\CbcGeneralBranchingObject.cpp"504 >505 </File>506 <File507 503 RelativePath="..\..\..\src\CbcGeneralDepth.cpp" 508 504 > … … 929 925 <File 930 926 RelativePath="..\..\..\src\CbcObjectUpdateData.cpp" 931 >932 </File>933 <File934 RelativePath="..\..\..\src\CbcOneGeneralBranchingObject.cpp"935 927 > 936 928 </File> … … 1258 1250 </File> 1259 1251 <File 1260 RelativePath="..\..\..\src\CbcGeneralBranchingObject.hpp"1261 >1262 </File>1263 <File1264 1252 RelativePath="..\..\..\src\CbcGeneralDepth.hpp" 1265 1253 > … … 1367 1355 <File 1368 1356 RelativePath="..\..\..\src\CbcObjectUpdateData.hpp" 1369 >1370 </File>1371 <File1372 RelativePath="..\..\..\src\CbcOneGeneralBranchingObject.hpp"1373 1357 > 1374 1358 </File> -
branches/sandbox/Cbc/src/CbcBranchActual.hpp
r1344 r1346 24 24 #include "CbcGeneralDepth.hpp" 25 25 #include "CbcSubProblem.hpp" 26 #include "CbcGeneralBranchingObject.hpp"27 #include "CbcOneGeneralBranchingObject.hpp"28 26 #endif -
branches/sandbox/Cbc/src/CbcGeneralDepth.cpp
r1293 r1346 381 381 return branch; 382 382 } 383 384 // Default Constructor 385 CbcGeneralBranchingObject::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 398 CbcGeneralBranchingObject::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 411 CbcGeneralBranchingObject::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 429 CbcGeneralBranchingObject & 430 CbcGeneralBranchingObject::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 } 451 CbcBranchingObject * 452 CbcGeneralBranchingObject::clone() const 453 { 454 return (new CbcGeneralBranchingObject(*this)); 455 } 456 457 458 // Destructor 459 CbcGeneralBranchingObject::~CbcGeneralBranchingObject () 460 { 461 //printf("CbcGeneral %x destructor\n",this); 462 delete [] subProblems_; 463 } 464 bool doingDoneBranch = false; 465 double 466 CbcGeneralBranchingObject::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 */ 522 void 523 CbcGeneralBranchingObject::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 539 void 540 CbcGeneralBranchingObject::print() 541 { 542 //printf("CbcGeneralObject has %d subproblems\n",numberSubProblems_); 543 } 544 // Fill in current objective etc 545 void 546 CbcGeneralBranchingObject::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 */ 563 int 564 CbcGeneralBranchingObject::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 */ 578 CbcRangeCompare 579 CbcGeneralBranchingObject::compareBranchingObject 580 (const CbcBranchingObject* /*brObj*/, const bool /*replaceIfOverlap*/) 581 { 582 throw("must implement"); 583 } 584 585 // Default Constructor 586 CbcOneGeneralBranchingObject::CbcOneGeneralBranchingObject() 587 : CbcBranchingObject(), 588 object_(NULL), 589 whichOne_(-1) 590 { 591 //printf("CbcOneGeneral %x default constructor\n",this); 592 } 593 594 // Useful constructor 595 CbcOneGeneralBranchingObject::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 608 CbcOneGeneralBranchingObject::CbcOneGeneralBranchingObject ( const CbcOneGeneralBranchingObject & rhs) 609 : CbcBranchingObject(rhs), 610 object_(rhs.object_), 611 whichOne_(rhs.whichOne_) 612 { 613 } 614 615 // Assignment operator 616 CbcOneGeneralBranchingObject & 617 CbcOneGeneralBranchingObject::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 } 626 CbcBranchingObject * 627 CbcOneGeneralBranchingObject::clone() const 628 { 629 return (new CbcOneGeneralBranchingObject(*this)); 630 } 631 632 633 // Destructor 634 CbcOneGeneralBranchingObject::~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 } 645 double 646 CbcOneGeneralBranchingObject::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 */ 657 void 658 CbcOneGeneralBranchingObject::checkIsCutoff(double /*cutoff*/) 659 { 660 assert (numberBranchesLeft()); 661 } 662 // Print what would happen 663 void 664 CbcOneGeneralBranchingObject::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 */ 675 int 676 CbcOneGeneralBranchingObject::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 */ 690 CbcRangeCompare 691 CbcOneGeneralBranchingObject::compareBranchingObject 692 (const CbcBranchingObject* /*brObj*/, const bool /*replaceIfOverlap*/) 693 { 694 throw("must implement"); 695 } 383 696 #endif -
branches/sandbox/Cbc/src/CbcGeneralDepth.hpp
r1293 r1346 4 4 5 5 #include "CbcGeneral.hpp" 6 #include "CbcBranchBase.hpp" 7 #include "CbcSubProblem.hpp" 6 8 7 9 #ifdef COIN_HAS_CLP … … 88 90 mutable ClpNodeStuff * nodeInfo_; 89 91 }; 92 /** Branching object for general objects 93 94 */ 95 class CbcNode; 96 class CbcGeneralBranchingObject : public CbcBranchingObject { 97 98 public: 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 182 public: 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 */ 200 class CbcOneGeneralBranchingObject : public CbcBranchingObject { 201 202 public: 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 260 public: 261 /// data 262 /// Object 263 CbcGeneralBranchingObject * object_; 264 /// Which one 265 int whichOne_; 266 }; 90 267 #endif //COIN_HAS_CLP 91 268 #endif -
branches/sandbox/Cbc/src/Makefile.am
r1344 r1346 57 57 CbcFollowOn.cpp CbcFollowOn.hpp \ 58 58 CbcGeneral.cpp CbcGeneral.hpp \ 59 CbcGeneralBranchingObject.cpp CbcGeneralBranchingObject.hpp \60 59 CbcGeneralDepth.cpp CbcGeneralDepth.hpp \ 61 60 CbcHeuristic.cpp CbcHeuristic.hpp \ … … 85 84 CbcObject.cpp CbcObject.hpp \ 86 85 CbcObjectUpdateData.cpp CbcObjectUpdateData.hpp \ 87 CbcOneGeneralBranchingObject.cpp CbcOneGeneralBranchingObject.hpp \88 86 CbcPartialNodeInfo.cpp CbcPartialNodeInfo.hpp \ 89 87 CbcSimpleInteger.cpp CbcSimpleInteger.hpp \ … … 382 380 CbcFullNodeInfo.hpp \ 383 381 CbcGeneral.hpp \ 384 CbcGeneralBranchingObject.hpp \385 382 CbcGeneralDepth.hpp \ 386 383 CbcHeuristic.hpp \ … … 409 406 CbcObject.hpp \ 410 407 CbcObjectUpdateData.hpp \ 411 CbcOneGeneralBranchingObject.hpp \412 408 CbcPartialNodeInfo.hpp \ 413 409 CbcSimpleInteger.hpp \ -
branches/sandbox/Cbc/src/Makefile.in
r1344 r1346 174 174 CbcFixingBranchingObject.lo CbcFixVariable.lo \ 175 175 CbcFullNodeInfo.lo CbcFollowOn.lo CbcGeneral.lo \ 176 CbcGeneralBranchingObject.lo CbcGeneralDepth.lo \ 177 CbcHeuristic.lo CbcHeuristicDive.lo \ 176 CbcGeneralDepth.lo CbcHeuristic.lo CbcHeuristicDive.lo \ 178 177 CbcHeuristicDiveCoefficient.lo CbcHeuristicDiveFractional.lo \ 179 178 CbcHeuristicDiveGuided.lo CbcHeuristicDiveLineSearch.lo \ … … 186 185 CbcMessage.lo CbcModel.lo CbcNode.lo CbcNodeInfo.lo CbcNWay.lo \ 187 186 CbcNWayBranchingObject.lo CbcObject.lo CbcObjectUpdateData.lo \ 188 Cbc OneGeneralBranchingObject.lo CbcPartialNodeInfo.lo \189 CbcSimpleInteger .lo CbcSimpleIntegerDynamicPseudoCost.lo \187 CbcPartialNodeInfo.lo CbcSimpleInteger.lo \ 188 CbcSimpleIntegerDynamicPseudoCost.lo \ 190 189 CbcSimpleIntegerPseudoCost.lo CbcSOS.lo \ 191 190 CbcSOSBranchingObject.lo CbcStatistics.lo CbcStrategy.lo \ … … 560 559 CbcFollowOn.cpp CbcFollowOn.hpp \ 561 560 CbcGeneral.cpp CbcGeneral.hpp \ 562 CbcGeneralBranchingObject.cpp CbcGeneralBranchingObject.hpp \563 561 CbcGeneralDepth.cpp CbcGeneralDepth.hpp \ 564 562 CbcHeuristic.cpp CbcHeuristic.hpp \ … … 588 586 CbcObject.cpp CbcObject.hpp \ 589 587 CbcObjectUpdateData.cpp CbcObjectUpdateData.hpp \ 590 CbcOneGeneralBranchingObject.cpp CbcOneGeneralBranchingObject.hpp \591 588 CbcPartialNodeInfo.cpp CbcPartialNodeInfo.hpp \ 592 589 CbcSimpleInteger.cpp CbcSimpleInteger.hpp \ … … 748 745 CbcFullNodeInfo.hpp \ 749 746 CbcGeneral.hpp \ 750 CbcGeneralBranchingObject.hpp \751 747 CbcGeneralDepth.hpp \ 752 748 CbcHeuristic.hpp \ … … 775 771 CbcObject.hpp \ 776 772 CbcObjectUpdateData.hpp \ 777 CbcOneGeneralBranchingObject.hpp \778 773 CbcPartialNodeInfo.hpp \ 779 774 CbcSimpleInteger.hpp \ … … 944 939 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CbcGenSolvers.Po@am__quote@ 945 940 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CbcGeneral.Plo@am__quote@ 946 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CbcGeneralBranchingObject.Plo@am__quote@947 941 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CbcGeneralDepth.Plo@am__quote@ 948 942 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CbcGeneric.Po@am__quote@ … … 973 967 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CbcObject.Plo@am__quote@ 974 968 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CbcObjectUpdateData.Plo@am__quote@ 975 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CbcOneGeneralBranchingObject.Plo@am__quote@976 969 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CbcPartialNodeInfo.Plo@am__quote@ 977 970 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CbcSOS.Plo@am__quote@
Note: See TracChangeset
for help on using the changeset viewer.