Changeset 2467
- Timestamp:
- Jan 3, 2019 4:26:29 PM (7 weeks ago)
- Location:
- trunk/Cbc/src
- Files:
-
- 74 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/Cbc/src/CbcBranchBase.cpp
r2465 r2467 89 89 { 90 90 //assert (solver==model_->solver()); 91 CbcObject *fudge = const_cast< CbcObject *>(this);91 CbcObject *fudge = const_cast< CbcObject * >(this); 92 92 fudge->feasibleRegion(); 93 93 return 0.0; … … 103 103 { 104 104 //assert (solver==model_->solver()); 105 CbcObject *fudge = const_cast< CbcObject *>(this);105 CbcObject *fudge = const_cast< CbcObject * >(this); 106 106 fudge->feasibleRegion(); 107 107 return 0.0; … … 118 118 { 119 119 //assert (solver==model_->solver()); 120 CbcObject *fudge = const_cast< CbcObject *>(this);120 CbcObject *fudge = const_cast< CbcObject * >(this); 121 121 return fudge->createBranch(solver, info, way); 122 122 } -
trunk/Cbc/src/CbcBranchCut.cpp
r2465 r2467 294 294 int CbcCutBranchingObject::compareOriginalObject(const CbcBranchingObject *brObj) const 295 295 { 296 const CbcCutBranchingObject *br = dynamic_cast< const CbcCutBranchingObject *>(brObj);296 const CbcCutBranchingObject *br = dynamic_cast< const CbcCutBranchingObject * >(brObj); 297 297 assert(br); 298 298 const OsiRowCut &r0 = way_ == -1 ? down_ : up_; … … 313 313 CbcCutBranchingObject::compareBranchingObject(const CbcBranchingObject *brObj, const bool replaceIfOverlap) 314 314 { 315 const CbcCutBranchingObject *br = dynamic_cast< const CbcCutBranchingObject *>(brObj);315 const CbcCutBranchingObject *br = dynamic_cast< const CbcCutBranchingObject * >(brObj); 316 316 assert(br); 317 317 OsiRowCut &r0 = way_ == -1 ? down_ : up_; -
trunk/Cbc/src/CbcBranchDefaultDecision.cpp
r2465 r2467 215 215 if (numberNext < numberUnsatisfied) { 216 216 int numberUp = numberUnsatisfied - numberInfeasibilitiesUp[i]; 217 double perUnsatisfied = changeUp[i] / static_cast< double>(numberUp);217 double perUnsatisfied = changeUp[i] / static_cast< double >(numberUp); 218 218 double estimatedObjective = objectiveValue + numberUnsatisfied * perUnsatisfied; 219 219 if (estimatedObjective < cutoff) … … 223 223 if (numberNext < numberUnsatisfied) { 224 224 int numberDown = numberUnsatisfied - numberInfeasibilitiesDown[i]; 225 double perUnsatisfied = changeDown[i] / static_cast< double>(numberDown);225 double perUnsatisfied = changeDown[i] / static_cast< double >(numberDown); 226 226 double estimatedObjective = objectiveValue + numberUnsatisfied * perUnsatisfied; 227 227 if (estimatedObjective < cutoff) … … 344 344 if (numberNext < numberUnsatisfied) { 345 345 int numberUp = numberUnsatisfied - numberInfeasibilitiesUp[i]; 346 double perUnsatisfied = changeUp[i] / static_cast< double>(numberUp);346 double perUnsatisfied = changeUp[i] / static_cast< double >(numberUp); 347 347 double estimatedObjective = objectiveValue + numberUnsatisfied * perUnsatisfied; 348 348 if (estimatedObjective < bestEstimate) { … … 355 355 if (numberNext < numberUnsatisfied) { 356 356 int numberDown = numberUnsatisfied - numberInfeasibilitiesDown[i]; 357 double perUnsatisfied = changeDown[i] / static_cast< double>(numberDown);357 double perUnsatisfied = changeDown[i] / static_cast< double >(numberDown); 358 358 double estimatedObjective = objectiveValue + numberUnsatisfied * perUnsatisfied; 359 359 if (estimatedObjective < bestEstimate) { -
trunk/Cbc/src/CbcBranchDynamic.cpp
r2465 r2467 202 202 OsiBranchingObject *obj = object->clone(); 203 203 #ifndef NDEBUG 204 CbcBranchingObject *obj2 = dynamic_cast< CbcBranchingObject *>(obj);204 CbcBranchingObject *obj2 = dynamic_cast< CbcBranchingObject * >(obj); 205 205 assert(obj2); 206 206 #if COIN_DEVELOP > 1 207 CbcDynamicPseudoCostBranchingObject *branchingObject = dynamic_cast< CbcDynamicPseudoCostBranchingObject *>(obj);207 CbcDynamicPseudoCostBranchingObject *branchingObject = dynamic_cast< CbcDynamicPseudoCostBranchingObject * >(obj); 208 208 if (!branchingObject) 209 209 printf("no dynamic branching object Dynamic Decision\n"); 210 210 #endif 211 211 #else 212 CbcBranchingObject *obj2 = static_cast< CbcBranchingObject *>(obj);212 CbcBranchingObject *obj2 = static_cast< CbcBranchingObject * >(obj); 213 213 #endif 214 214 //object_=branchingObject; … … 254 254 */ 255 255 256 CbcDynamicPseudoCostBranchingObject *branchingObject = dynamic_cast< CbcDynamicPseudoCostBranchingObject *>(object_);256 CbcDynamicPseudoCostBranchingObject *branchingObject = dynamic_cast< CbcDynamicPseudoCostBranchingObject * >(object_); 257 257 if (!branchingObject) { 258 258 delete object_; … … 312 312 #if TYPE2 == 0 313 313 object->addToSumDownCost(change / (nonZeroAmount + movement)); 314 object->setDownDynamicPseudoCost(object->sumDownCost() / static_cast< double>(object->numberTimesDown()));314 object->setDownDynamicPseudoCost(object->sumDownCost() / static_cast< double >(object->numberTimesDown())); 315 315 #elif TYPE2 == 1 316 316 object->addToSumDownCost(change); … … 358 358 #if TYPE2 == 0 359 359 object->addToSumUpCost(change / (nonZeroAmount + movement)); 360 object->setUpDynamicPseudoCost(object->sumUpCost() / static_cast< double>(object->numberTimesUp()));360 object->setUpDynamicPseudoCost(object->sumUpCost() / static_cast< double >(object->numberTimesUp())); 361 361 #elif TYPE2 == 1 362 362 object->addToSumUpCost(change); … … 479 479 distanceToCutoffC = CoinMax(distanceToCutoffC, 1.0e-12 * (1.0 + fabs(objectiveValue))); 480 480 int numberInfC = model->getContinuousInfeasibilities(); 481 double perInf = distanceToCutoffC / static_cast< double>(numberInfC);481 double perInf = distanceToCutoffC / static_cast< double >(numberInfC); 482 482 assert(perInf > 0.0); 483 483 //int numberIntegers = model->numberIntegers(); … … 543 543 // not much in it - look at unsatisfied 544 544 if (thisNumber < numberUnsatisfied || bestNumber < numberUnsatisfied) { 545 double perInteger = distance / (static_cast< double>(numberUnsatisfied));545 double perInteger = distance / (static_cast< double >(numberUnsatisfied)); 546 546 useValue += thisNumber * perInteger; 547 547 useBest += bestNumber * perInteger; … … 560 560 History hist; 561 561 { 562 CbcDynamicPseudoCostBranchingObject *branchingObject = dynamic_cast< CbcDynamicPseudoCostBranchingObject *>(thisOne);562 CbcDynamicPseudoCostBranchingObject *branchingObject = dynamic_cast< CbcDynamicPseudoCostBranchingObject * >(thisOne); 563 563 if (branchingObject) { 564 564 CbcSimpleIntegerDynamicPseudoCost *object = branchingObject->object(); … … 583 583 #endif 584 584 // maybe change better way 585 CbcDynamicPseudoCostBranchingObject *branchingObject = dynamic_cast< CbcDynamicPseudoCostBranchingObject *>(thisOne);585 CbcDynamicPseudoCostBranchingObject *branchingObject = dynamic_cast< CbcDynamicPseudoCostBranchingObject * >(thisOne); 586 586 if (branchingObject) { 587 587 CbcSimpleIntegerDynamicPseudoCost *object = branchingObject->object(); … … 752 752 info.upMovement = object_->upDynamicPseudoCost() * (ceil(value_) - value_); 753 753 info.downMovement = object_->downDynamicPseudoCost() * (value_ - floor(value_)); 754 info.numIntInfeasUp -= static_cast< int>(object_->sumUpDecrease() / (1.0e-12 + static_cast<double>(object_->numberTimesUp())));754 info.numIntInfeasUp -= static_cast< int >(object_->sumUpDecrease() / (1.0e-12 + static_cast< double >(object_->numberTimesUp()))); 755 755 info.numIntInfeasUp = CoinMax(info.numIntInfeasUp, 0); 756 756 info.numObjInfeasUp = 0; 757 757 info.finishedUp = false; 758 758 info.numItersUp = 0; 759 info.numIntInfeasDown -= static_cast< int>(object_->sumDownDecrease() / (1.0e-12 + static_cast<double>(object_->numberTimesDown())));759 info.numIntInfeasDown -= static_cast< int >(object_->sumDownDecrease() / (1.0e-12 + static_cast< double >(object_->numberTimesDown()))); 760 760 info.numIntInfeasDown = CoinMax(info.numIntInfeasDown, 0); 761 761 info.numObjInfeasDown = 0; -
trunk/Cbc/src/CbcBranchLotsize.cpp
r2465 r2467 792 792 CbcLotsizeBranchingObject::compareBranchingObject(const CbcBranchingObject *brObj, const bool replaceIfOverlap) 793 793 { 794 const CbcLotsizeBranchingObject *br = dynamic_cast< const CbcLotsizeBranchingObject *>(brObj);794 const CbcLotsizeBranchingObject *br = dynamic_cast< const CbcLotsizeBranchingObject * >(brObj); 795 795 assert(br); 796 796 double *thisBd = way_ == -1 ? down_ : up_; -
trunk/Cbc/src/CbcBranchToFixLots.cpp
r2465 r2467 129 129 double tolerance = CoinMin(1.0e-8, integerTolerance); 130 130 // How many fixed are we aiming at 131 int wantedFixed = static_cast< int>(static_cast<double>(numberIntegers) * fractionFixed_);131 int wantedFixed = static_cast< int >(static_cast< double >(numberIntegers) * fractionFixed_); 132 132 int nSort = 0; 133 133 int numberFixed = 0; … … 380 380 double tolerance = CoinMin(1.0e-8, integerTolerance); 381 381 // How many fixed are we aiming at 382 int wantedFixed = static_cast< int>(static_cast<double>(numberIntegers) * fractionFixed_);382 int wantedFixed = static_cast< int >(static_cast< double >(numberIntegers) * fractionFixed_); 383 383 if (djTolerance_ < 1.0e10) { 384 384 int nSort = 0; -
trunk/Cbc/src/CbcBranchingObject.hpp
r2465 r2467 208 208 virtual int compareOriginalObject(const CbcBranchingObject *brObj) const 209 209 { 210 const CbcBranchingObject *br = dynamic_cast< const CbcBranchingObject *>(brObj);210 const CbcBranchingObject *br = dynamic_cast< const CbcBranchingObject * >(brObj); 211 211 return variable() - br->variable(); 212 212 } -
trunk/Cbc/src/CbcClique.cpp
r2465 r2467 305 305 const int *integer = model_->integerVariable(); 306 306 //OsiSolverInterface * solver = model_->solver(); 307 CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis *>(solver->getWarmStart());307 CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver->getWarmStart()); 308 308 const double *solution = model_->testSolution(); 309 309 const double *lower = solver->getColLower(); … … 613 613 int CbcCliqueBranchingObject::compareOriginalObject(const CbcBranchingObject *brObj) const 614 614 { 615 const CbcCliqueBranchingObject *br = dynamic_cast< const CbcCliqueBranchingObject *>(brObj);615 const CbcCliqueBranchingObject *br = dynamic_cast< const CbcCliqueBranchingObject * >(brObj); 616 616 assert(br); 617 617 return CbcCompareCliques(clique_, br->clique_); … … 629 629 CbcCliqueBranchingObject::compareBranchingObject(const CbcBranchingObject *brObj, const bool /*replaceIfOverlap*/) 630 630 { 631 const CbcCliqueBranchingObject *br = dynamic_cast< const CbcCliqueBranchingObject *>(brObj);631 const CbcCliqueBranchingObject *br = dynamic_cast< const CbcCliqueBranchingObject * >(brObj); 632 632 assert(br); 633 633 unsigned int *thisMask = way_ < 0 ? upMask_ : downMask_; 634 634 const unsigned int *otherMask = br->way_ < 0 ? br->upMask_ : br->downMask_; 635 const CoinUInt64 cl0 = (static_cast< CoinUInt64>(thisMask[0]) << 32) | thisMask[1];636 const CoinUInt64 cl1 = (static_cast< CoinUInt64>(otherMask[0]) << 32) | otherMask[1];635 const CoinUInt64 cl0 = (static_cast< CoinUInt64 >(thisMask[0]) << 32) | thisMask[1]; 636 const CoinUInt64 cl1 = (static_cast< CoinUInt64 >(otherMask[0]) << 32) | otherMask[1]; 637 637 if (cl0 == cl1) { 638 638 return CbcRangeSame; … … 650 650 } 651 651 const CoinUInt64 cl_union = (cl0 | cl1); 652 thisMask[0] = static_cast< unsigned int>(cl_union >> 32);653 thisMask[1] = static_cast< unsigned int>(cl_union & 0xffffffff);652 thisMask[0] = static_cast< unsigned int >(cl_union >> 32); 653 thisMask[1] = static_cast< unsigned int >(cl_union & 0xffffffff); 654 654 return CbcRangeOverlap; 655 655 } … … 856 856 int CbcLongCliqueBranchingObject::compareOriginalObject(const CbcBranchingObject *brObj) const 857 857 { 858 const CbcLongCliqueBranchingObject *br = dynamic_cast< const CbcLongCliqueBranchingObject *>(brObj);858 const CbcLongCliqueBranchingObject *br = dynamic_cast< const CbcLongCliqueBranchingObject * >(brObj); 859 859 assert(br); 860 860 return CbcCompareCliques(clique_, br->clique_); … … 872 872 CbcLongCliqueBranchingObject::compareBranchingObject(const CbcBranchingObject *brObj, const bool /*replaceIfOverlap*/) 873 873 { 874 const CbcLongCliqueBranchingObject *br = dynamic_cast< const CbcLongCliqueBranchingObject *>(brObj);874 const CbcLongCliqueBranchingObject *br = dynamic_cast< const CbcLongCliqueBranchingObject * >(brObj); 875 875 assert(br); 876 876 const int numberMembers = clique_->numberMembers(); -
trunk/Cbc/src/CbcCompareDefault.cpp
r2465 r2467 193 193 double target = (1.0 - THRESH2) * bestPossible_ + THRESH2 * cutoff_; 194 194 double weight; 195 weight = (target - x->objectiveValue()) / static_cast< double>(x->numberUnsatisfied());195 weight = (target - x->objectiveValue()) / static_cast< double >(x->numberUnsatisfied()); 196 196 double testX = -weight; 197 weight = (target - y->objectiveValue()) / static_cast< double>(y->numberUnsatisfied());197 weight = (target - y->objectiveValue()) / static_cast< double >(y->numberUnsatisfied()); 198 198 double testY = -weight; 199 199 #elif TRY_THIS == 2 … … 229 229 return (false); // solution was got by rounding 230 230 // set to get close to this solution 231 double costPerInteger = (model->getObjValue() - objectiveAtContinuous) / static_cast< double>(numberInfeasibilitiesAtContinuous);231 double costPerInteger = (model->getObjValue() - objectiveAtContinuous) / static_cast< double >(numberInfeasibilitiesAtContinuous); 232 232 weight_ = 0.95 * costPerInteger; 233 233 saveWeight_ = 0.95 * weight_; -
trunk/Cbc/src/CbcCutGenerator.cpp
r2465 r2467 198 198 depth = 0; 199 199 int howOften = whenCutGenerator_; 200 if (dynamic_cast< CglProbing *>(generator_)) {200 if (dynamic_cast< CglProbing * >(generator_)) { 201 201 if (howOften == -100 && model_->doCutsNow(3)) { 202 202 howOften = 1; // do anyway … … 258 258 { 259 259 OsiClpSolverInterface *clpSolver 260 = dynamic_cast< OsiClpSolverInterface *>(solver);260 = dynamic_cast< OsiClpSolverInterface * >(solver); 261 261 if (clpSolver) 262 262 randomNumberGenerator = clpSolver->getModelPtr()->randomNumberGenerator(); … … 303 303 // above had &&!model_->parentModel()&&depth<2) 304 304 incrementNumberTimesEntered(); 305 CglProbing *generator = dynamic_cast< CglProbing *>(generator_);305 CglProbing *generator = dynamic_cast< CglProbing * >(generator_); 306 306 //if (!depth&&!pass) 307 307 //printf("Cut generator %s when %d\n",generatorName_,whenCutGenerator_); … … 360 360 2099999 361 361 }; 362 int n = static_cast< int>(sizeof(test) / sizeof(int));362 int n = static_cast< int >(sizeof(test) / sizeof(int)); 363 363 int saveStack = generator->getMaxLook(); 364 364 int saveNumber = generator->getMaxProbe(); … … 570 570 #ifdef COIN_HAS_CLP 571 571 OsiClpSolverInterface *clpSolver 572 = dynamic_cast< OsiClpSolverInterface *>(solver);572 = dynamic_cast< OsiClpSolverInterface * >(solver); 573 573 if (clpSolver) { 574 574 clpSolver->setLastAlgorithm(2); … … 588 588 int numberObjects = model_->numberObjects(); 589 589 for (int i = 0; i < numberObjects; i++) { 590 CbcSimpleIntegerDynamicPseudoCost *obj1 = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost *>(model_->modifiableObject(i));590 CbcSimpleIntegerDynamicPseudoCost *obj1 = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(model_->modifiableObject(i)); 591 591 if (obj1) { 592 592 int iColumn = obj1->columnNumber(); … … 1282 1282 // leave Probing every SCANCUTS_PROBING 1283 1283 howOften = howOften % 1000000; 1284 CglProbing *generator = dynamic_cast< CglProbing *>(generator_);1284 CglProbing *generator = dynamic_cast< CglProbing * >(generator_); 1285 1285 1286 1286 if (generator && howOften > SCANCUTS_PROBING) -
trunk/Cbc/src/CbcEventHandler.hpp
r2465 r2467 137 137 /*! \brief Data type for event/action pairs */ 138 138 139 typedef std::map< CbcEvent, CbcAction> eaMapPair;139 typedef std::map< CbcEvent, CbcAction > eaMapPair; 140 140 141 141 /*! \name Event Processing */ -
trunk/Cbc/src/CbcFathomDynamicProgramming.cpp
r2465 r2467 199 199 double check = COIN_INT_MAX; 200 200 for (i = 0; i < numberRows; i++) { 201 int n = static_cast< int>(floor(rhs[i] + 0.5));201 int n = static_cast< int >(floor(rhs[i] + 0.5)); 202 202 if (n) { 203 203 n++; // allow for 0,1... n … … 228 228 size_ = COIN_INT_MAX; 229 229 else 230 size_ = static_cast< int>(size);230 size_ = static_cast< int >(size); 231 231 232 232 int n01 = 0; … … 274 274 int kBit = 0; 275 275 for (i = 0; i < numberRows; i++) { 276 int n = static_cast< int>(floor(rhs[i] + 0.5));276 int n = static_cast< int >(floor(rhs[i] + 0.5)); 277 277 if (n) { 278 278 lookup_[i] = numberActive; … … 395 395 int newRow = lookup_[i]; 396 396 if (newRow >= 0) { 397 int gap = static_cast< int>(rowUpper[i] - CoinMax(0.0, rowLower[i]));397 int gap = static_cast< int >(rowUpper[i] - CoinMax(0.0, rowLower[i])); 398 398 lower2[newRow] = rhs_[newRow] - gap; 399 399 int numberBits = numberBits_[newRow]; … … 483 483 double cost = direction * objective[i]; 484 484 fixedObj += lowerValue * cost; 485 int gap = static_cast< int>(upper[i] - lowerValue);485 int gap = static_cast< int >(upper[i] - lowerValue); 486 486 CoinBigIndex start = columnStart[i]; 487 487 tryColumn(columnLength[i], row + start, element + start, cost, gap); … … 521 521 int newRow = lookup_[i]; 522 522 if (newRow >= 0) { 523 int gap = static_cast< int>(rowUpper[i] - CoinMax(0.0, rowLower[i]));523 int gap = static_cast< int >(rowUpper[i] - CoinMax(0.0, rowLower[i])); 524 524 lower[newRow] = rhs_[newRow] - gap; 525 525 int numberBits = numberBits_[newRow]; … … 574 574 int iRow = row[j]; 575 575 double value = element[j]; 576 int iValue = static_cast< int>(value);576 int iValue = static_cast< int >(value); 577 577 if (iValue != indices_[iRow]) { 578 578 good = false; … … 655 655 int iRow = rows[j]; 656 656 double value = coefficients[j]; 657 int iValue = static_cast< int>(value);657 int iValue = static_cast< int >(value); 658 658 int newRow = lookup_[iRow]; 659 659 if (newRow < 0 || iValue > rhs_[newRow]) { -
trunk/Cbc/src/CbcFollowOn.cpp
r2465 r2467 73 73 } 74 74 if (good) 75 rhs_[i] = static_cast< int>(value);75 rhs_[i] = static_cast< int >(value); 76 76 } 77 77 } … … 163 163 numberUnsatisfied++; 164 164 } else { 165 rhsValue -= static_cast< int>(value * floor(solValue + 0.5));165 rhsValue -= static_cast< int >(value * floor(solValue + 0.5)); 166 166 } 167 167 } … … 509 509 { 510 510 #ifdef JJF_ZERO //ndef NDEBUG 511 const CbcFixingBranchingObject *br = dynamic_cast< const CbcFixingBranchingObject *>(brObj);511 const CbcFixingBranchingObject *br = dynamic_cast< const CbcFixingBranchingObject * >(brObj); 512 512 assert(br); 513 513 #endif -
trunk/Cbc/src/CbcFullNodeInfo.cpp
r2465 r2467 73 73 } 74 74 75 basis_ = dynamic_cast< CoinWarmStartBasis *>(solver->getWarmStart());75 basis_ = dynamic_cast< CoinWarmStartBasis * >(solver->getWarmStart()); 76 76 } 77 77 … … 79 79 : CbcNodeInfo(rhs) 80 80 { 81 basis_ = dynamic_cast< CoinWarmStartBasis *>(rhs.basis_->clone());81 basis_ = dynamic_cast< CoinWarmStartBasis * >(rhs.basis_->clone()); 82 82 numberIntegers_ = rhs.numberIntegers_; 83 83 lower_ = NULL; … … 145 145 delete basis; 146 146 if (basis_) { 147 basis = dynamic_cast< CoinWarmStartBasis *>(basis_->clone());147 basis = dynamic_cast< CoinWarmStartBasis * >(basis_->clone()); 148 148 basis->resize(numberRows, numberColumns); 149 149 #ifdef CBC_CHECK_BASIS … … 189 189 CbcFullNodeInfo::buildRowBasis(CoinWarmStartBasis &basis) const 190 190 { 191 const unsigned int *saved = reinterpret_cast< const unsigned int *>(basis_->getArtificialStatus());192 unsigned int *now = reinterpret_cast< unsigned int *>(basis.getArtificialStatus());191 const unsigned int *saved = reinterpret_cast< const unsigned int * >(basis_->getArtificialStatus()); 192 unsigned int *now = reinterpret_cast< unsigned int * >(basis.getArtificialStatus()); 193 193 int number = basis_->getNumArtificial() >> 4; 194 194 ; -
trunk/Cbc/src/CbcGenBaB.cpp
r2465 r2467 306 306 if (action != CbcGenCtlBlk::CGOff) { 307 307 if (action == CbcGenCtlBlk::CGForceBut) { 308 CglProbing *probingGen = dynamic_cast< CglProbing *>(gen);308 CglProbing *probingGen = dynamic_cast< CglProbing * >(gen); 309 309 probingGen->setRowCuts(-3); 310 310 } … … 484 484 { 485 485 assert(param != 0); 486 CbcGenParam *genParam = dynamic_cast< CbcGenParam *>(param);486 CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(param); 487 487 assert(genParam != 0); 488 488 CbcGenCtlBlk *ctlBlk = genParam->obj(); -
trunk/Cbc/src/CbcGenCbcParamUtils.cpp
r2465 r2467 219 219 */ 220 220 for (i = first; i <= last; i++) { 221 CbcCbcParam *cbcParam = dynamic_cast< CbcCbcParam *>(paramVec[i]);221 CbcCbcParam *cbcParam = dynamic_cast< CbcCbcParam * >(paramVec[i]); 222 222 assert(cbcParam != 0); 223 223 cbcParam->setObj(obj); … … 266 266 assert(param != 0); 267 267 268 CbcCbcParam *cbcParam = dynamic_cast< CbcCbcParam *>(param);268 CbcCbcParam *cbcParam = dynamic_cast< CbcCbcParam * >(param); 269 269 assert(cbcParam != 0); 270 270 … … 335 335 assert(param != 0); 336 336 337 CbcCbcParam *cbcParam = dynamic_cast< CbcCbcParam *>(param);337 CbcCbcParam *cbcParam = dynamic_cast< CbcCbcParam * >(param); 338 338 assert(cbcParam != 0); 339 339 -
trunk/Cbc/src/CbcGenCtlBlk.cpp
r2465 r2467 260 260 probing_.proto_->setRowCuts(probing_.rowCuts_); 261 261 } 262 gen = dynamic_cast< CglCutGenerator *>(probing_.proto_);262 gen = dynamic_cast< CglCutGenerator * >(probing_.proto_); 263 263 264 264 return (probing_.action_); … … 274 274 clique_.proto_->setMinViolation(clique_.minViolation_); 275 275 } 276 gen = dynamic_cast< CglCutGenerator *>(clique_.proto_);276 gen = dynamic_cast< CglCutGenerator * >(clique_.proto_); 277 277 278 278 return (clique_.action_); … … 285 285 flow_.proto_ = new CglFlowCover(); 286 286 } 287 gen = dynamic_cast< CglCutGenerator *>(flow_.proto_);287 gen = dynamic_cast< CglCutGenerator * >(flow_.proto_); 288 288 289 289 return (flow_.action_); … … 298 298 gomory_.proto_->setLimit(gomory_.limit_); 299 299 } 300 gen = dynamic_cast< CglCutGenerator *>(gomory_.proto_);300 gen = dynamic_cast< CglCutGenerator * >(gomory_.proto_); 301 301 302 302 return (gomory_.action_); … … 309 309 knapsack_.proto_ = new CglKnapsackCover(); 310 310 } 311 gen = dynamic_cast< CglCutGenerator *>(knapsack_.proto_);311 gen = dynamic_cast< CglCutGenerator * >(knapsack_.proto_); 312 312 313 313 return (knapsack_.action_); … … 320 320 mir_.proto_ = new CglMixedIntegerRounding2(); 321 321 } 322 gen = dynamic_cast< CglCutGenerator *>(mir_.proto_);322 gen = dynamic_cast< CglCutGenerator * >(mir_.proto_); 323 323 324 324 return (mir_.action_); … … 331 331 redSplit_.proto_ = new CglRedSplit(); 332 332 } 333 gen = dynamic_cast< CglCutGenerator *>(redSplit_.proto_);333 gen = dynamic_cast< CglCutGenerator * >(redSplit_.proto_); 334 334 335 335 return (redSplit_.action_); … … 343 343 twomir_.proto_->setMaxElements(twomir_.maxElements_); 344 344 } 345 gen = dynamic_cast< CglCutGenerator *>(twomir_.proto_);345 gen = dynamic_cast< CglCutGenerator * >(twomir_.proto_); 346 346 347 347 return (twomir_.action_); … … 360 360 fpump_.proto_->setMaximumPasses(fpump_.iters_); 361 361 } 362 gen = dynamic_cast< CbcHeuristic *>(fpump_.proto_);362 gen = dynamic_cast< CbcHeuristic * >(fpump_.proto_); 363 363 364 364 return (fpump_.action_); … … 377 377 combine_.proto_->setSearchType(combine_.trySwap_); 378 378 } 379 gen = dynamic_cast< CbcHeuristic *>(combine_.proto_);379 gen = dynamic_cast< CbcHeuristic * >(combine_.proto_); 380 380 381 381 return (combine_.action_); … … 393 393 greedyCover_.proto_ = new CbcHeuristicGreedyCover(*model); 394 394 } 395 gen = dynamic_cast< CbcHeuristic *>(greedyCover_.proto_);395 gen = dynamic_cast< CbcHeuristic * >(greedyCover_.proto_); 396 396 397 397 return (greedyCover_.action_); … … 409 409 greedyEquality_.proto_ = new CbcHeuristicGreedyEquality(*model); 410 410 } 411 gen = dynamic_cast< CbcHeuristic *>(greedyEquality_.proto_);411 gen = dynamic_cast< CbcHeuristic * >(greedyEquality_.proto_); 412 412 413 413 return (greedyEquality_.action_); … … 425 425 rounding_.proto_ = new CbcRounding(*model); 426 426 } 427 gen = dynamic_cast< CbcHeuristic *>(rounding_.proto_);427 gen = dynamic_cast< CbcHeuristic * >(rounding_.proto_); 428 428 429 429 return (rounding_.action_); -
trunk/Cbc/src/CbcGenCtlBlk.hpp
r2465 r2467 684 684 /*! \brief Record of parameters changed by user command */ 685 685 686 std::vector< bool> setByUser_;686 std::vector< bool > setByUser_; 687 687 688 688 /*! \brief False if the user has made nontrivial modifications to the -
trunk/Cbc/src/CbcGenOsiParamUtils.cpp
r2465 r2467 158 158 */ 159 159 for (i = first; i <= last; i++) { 160 CbcOsiParam *osiParam = dynamic_cast< CbcOsiParam *>(paramVec[i]);160 CbcOsiParam *osiParam = dynamic_cast< CbcOsiParam * >(paramVec[i]); 161 161 assert(osiParam != 0); 162 162 osiParam->setObj(obj); … … 215 215 assert(param != 0); 216 216 217 CbcOsiParam *osiParam = dynamic_cast< CbcOsiParam *>(param);217 CbcOsiParam *osiParam = dynamic_cast< CbcOsiParam * >(param); 218 218 assert(osiParam != 0); 219 219 … … 272 272 assert(param != 0); 273 273 274 CbcOsiParam *osiParam = dynamic_cast< CbcOsiParam *>(param);274 CbcOsiParam *osiParam = dynamic_cast< CbcOsiParam * >(param); 275 275 assert(osiParam != 0); 276 276 … … 335 335 { 336 336 assert(param != 0); 337 CbcOsiParam *osiParam = dynamic_cast< CbcOsiParam *>(param);337 CbcOsiParam *osiParam = dynamic_cast< CbcOsiParam * >(param); 338 338 assert(osiParam != 0); 339 339 OsiSolverInterface *osi = osiParam->obj(); … … 400 400 { 401 401 assert(param != 0); 402 CbcOsiParam *osiParam = dynamic_cast< CbcOsiParam *>(param);402 CbcOsiParam *osiParam = dynamic_cast< CbcOsiParam * >(param); 403 403 assert(osiParam != 0); 404 404 OsiSolverInterface *osi = osiParam->obj(); … … 459 459 { 460 460 assert(param != 0); 461 CbcOsiParam *osiParam = dynamic_cast< CbcOsiParam *>(param);461 CbcOsiParam *osiParam = dynamic_cast< CbcOsiParam * >(param); 462 462 assert(osiParam != 0); 463 463 OsiSolverInterface *osi = osiParam->obj(); -
trunk/Cbc/src/CbcGenParamUtils.cpp
r2465 r2467 600 600 */ 601 601 for (i = first; i <= last; i++) { 602 CbcGenParam *genParam = dynamic_cast< CbcGenParam *>(paramVec[i]);602 CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(paramVec[i]); 603 603 assert(genParam != 0); 604 604 genParam->setObj(ctlBlk); … … 620 620 assert(param != 0); 621 621 622 CbcGenParam *genParam = dynamic_cast< CbcGenParam *>(param);622 CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(param); 623 623 assert(genParam != 0); 624 624 … … 679 679 { 680 680 assert(param != 0); 681 CbcGenParam *genParam = dynamic_cast< CbcGenParam *>(param);681 CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(param); 682 682 assert(genParam != 0); 683 683 CbcGenCtlBlk *ctlBlk = genParam->obj(); … … 705 705 { 706 706 assert(param != 0); 707 CbcGenParam *genParam = dynamic_cast< CbcGenParam *>(param);707 CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(param); 708 708 assert(genParam != 0); 709 709 CbcGenCtlBlk *ctlBlk = genParam->obj(); … … 748 748 { 749 749 assert(param != 0); 750 CbcGenParam *genParam = dynamic_cast< CbcGenParam *>(param);750 CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(param); 751 751 assert(genParam != 0); 752 752 CbcGenCtlBlk *ctlBlk = genParam->obj(); … … 785 785 { 786 786 assert(param != 0); 787 CbcGenParam *genParam = dynamic_cast< CbcGenParam *>(param);787 CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(param); 788 788 assert(genParam != 0); 789 789 CbcGenCtlBlk *ctlBlk = genParam->obj(); … … 834 834 { 835 835 assert(param != 0); 836 CbcGenParam *genParam = dynamic_cast< CbcGenParam *>(param);836 CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(param); 837 837 assert(genParam != 0); 838 838 CbcGenCtlBlk *ctlBlk = genParam->obj(); … … 927 927 { 928 928 assert(param != 0); 929 CbcGenParam *genParam = dynamic_cast< CbcGenParam *>(param);929 CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(param); 930 930 assert(genParam != 0); 931 931 CbcGenCtlBlk *ctlBlk = genParam->obj(); … … 967 967 { 968 968 assert(param != 0); 969 CbcGenParam *genParam = dynamic_cast< CbcGenParam *>(param);969 CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(param); 970 970 assert(genParam != 0); 971 971 CbcGenCtlBlk *ctlBlk = genParam->obj(); … … 1155 1155 { 1156 1156 assert(param != 0); 1157 CbcGenParam *genParam = dynamic_cast< CbcGenParam *>(param);1157 CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(param); 1158 1158 assert(genParam != 0); 1159 1159 CbcGenCtlBlk *ctlBlk = genParam->obj(); … … 1244 1244 { 1245 1245 assert(param != 0); 1246 CbcGenParam *genParam = dynamic_cast< CbcGenParam *>(param);1246 CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(param); 1247 1247 assert(genParam != 0); 1248 1248 CbcGenCtlBlk *ctlBlk = genParam->obj(); -
trunk/Cbc/src/CbcGenSolution.cpp
r2465 r2467 208 208 { 209 209 assert(param != 0); 210 CbcGenParam *genParam = dynamic_cast< CbcGenParam *>(param);210 CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(param); 211 211 assert(genParam != 0); 212 212 CbcGenCtlBlk *ctlBlk = genParam->obj(); … … 335 335 value = ceil(value - .5); 336 336 } 337 int ivalue = static_cast< int>(value);337 int ivalue = static_cast< int >(value); 338 338 fprintf(fp, "%d.0", ivalue); 339 339 if (++k == 10) { … … 509 509 { 510 510 assert(param != 0); 511 CbcGenParam *genParam = dynamic_cast< CbcGenParam *>(param);511 CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(param); 512 512 assert(genParam != 0); 513 513 CbcGenCtlBlk *ctlBlk = genParam->obj(); -
trunk/Cbc/src/CbcGenSolvers.cpp
r2465 r2467 101 101 Data types for a vector of OsiSolverInterface objects. 102 102 */ 103 typedef std::map< std::string, OsiSolverInterface *> solverMap_t;103 typedef std::map< std::string, OsiSolverInterface * > solverMap_t; 104 104 typedef solverMap_t::const_iterator solverMapIter_t; 105 105 … … 198 198 { 199 199 assert(param != 0); 200 CbcGenParam *genParam = dynamic_cast< CbcGenParam *>(param);200 CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(param); 201 201 assert(genParam != 0); 202 202 CbcGenCtlBlk *ctlBlk = genParam->obj(); -
trunk/Cbc/src/CbcGeneralDepth.cpp
r2465 r2467 159 159 OsiSolverInterface *solver = model_->solver(); 160 160 OsiClpSolverInterface *clpSolver 161 = dynamic_cast< OsiClpSolverInterface *>(solver);161 = dynamic_cast< OsiClpSolverInterface * >(solver); 162 162 if (clpSolver) { 163 163 if ((model_->moreSpecialOptions() & 33554432) == 0) { … … 170 170 int nBranches = model_->getIntParam(CbcModel::CbcNumberBranches); 171 171 if (nBranches) { 172 double average = model_->getDblParam(CbcModel::CbcSumChange) / static_cast< double>(nBranches);172 double average = model_->getDblParam(CbcModel::CbcSumChange) / static_cast< double >(nBranches); 173 173 info->smallChange_ = CoinMax(average * 1.0e-5, model_->getDblParam(CbcModel::CbcSmallestChange)); 174 174 info->smallChange_ = CoinMax(info->smallChange_, 1.0e-8); … … 220 220 for (int i = 0; i < numberIntegers; i++) { 221 221 #ifndef NDEBUG 222 CbcSimpleIntegerDynamicPseudoCost *obj = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost *>(objects[i]);222 CbcSimpleIntegerDynamicPseudoCost *obj = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(objects[i]); 223 223 assert(obj && obj->columnNumber() == integerVariable[i]); 224 224 #else 225 CbcSimpleIntegerDynamicPseudoCost *obj = static_cast< CbcSimpleIntegerDynamicPseudoCost *>(objects[i]);225 CbcSimpleIntegerDynamicPseudoCost *obj = static_cast< CbcSimpleIntegerDynamicPseudoCost * >(objects[i]); 226 226 #endif 227 227 if (info->numberUp_[i] > 0) { … … 250 250 CbcHeuristicDive *dive = NULL; 251 251 for (int i = 0; i < model_->numberHeuristics(); i++) { 252 CbcHeuristicDive *possible = dynamic_cast< CbcHeuristicDive *>(model_->heuristic(i));252 CbcHeuristicDive *possible = dynamic_cast< CbcHeuristicDive * >(model_->heuristic(i)); 253 253 if (possible && possible->maxSimplexIterations() == COIN_INT_MAX) { 254 254 // if more than one then rotate later? … … 281 281 #endif 282 282 //delete [] nodes; 283 model_->setTemporaryPointer(reinterpret_cast< void *>(nodes));283 model_->setTemporaryPointer(reinterpret_cast< void * >(nodes)); 284 284 // end try diving 285 285 } … … 338 338 //OsiSolverInterface * solver = model_->solver(); 339 339 OsiClpSolverInterface *clpSolver 340 = dynamic_cast< OsiClpSolverInterface *>(solver);340 = dynamic_cast< OsiClpSolverInterface * >(solver); 341 341 assert(clpSolver); 342 342 ClpSimplex *simplex = clpSolver->getModelPtr(); … … 422 422 } else { 423 423 // from diving 424 CbcSubProblem **nodes = reinterpret_cast< CbcSubProblem **>(model_->temporaryPointer());424 CbcSubProblem **nodes = reinterpret_cast< CbcSubProblem ** >(model_->temporaryPointer()); 425 425 assert(nodes); 426 426 int adjustDepth = info->depth_; … … 549 549 thisProb->apply(solver); 550 550 OsiClpSolverInterface *clpSolver 551 = dynamic_cast< OsiClpSolverInterface *>(solver);551 = dynamic_cast< OsiClpSolverInterface * >(solver); 552 552 assert(clpSolver); 553 553 // Move status to basis -
trunk/Cbc/src/CbcGeneric.cpp
r2465 r2467 90 90 91 91 { 92 CbcGenParam *genParam = dynamic_cast< CbcGenParam *>(param);93 CbcCbcParam *cbcParam = dynamic_cast< CbcCbcParam *>(param);94 CbcOsiParam *osiParam = dynamic_cast< CbcOsiParam *>(param);92 CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(param); 93 CbcCbcParam *cbcParam = dynamic_cast< CbcCbcParam * >(param); 94 CbcOsiParam *osiParam = dynamic_cast< CbcOsiParam * >(param); 95 95 int code = -1; 96 96 -
trunk/Cbc/src/CbcHeuristic.cpp
r2465 r2467 49 49 void CbcHeuristicNodeList::gutsOfDelete() 50 50 { 51 for (int i = (static_cast< int>(nodes_.size())) - 1; i >= 0; --i) {51 for (int i = (static_cast< int >(nodes_.size())) - 1; i >= 0; --i) { 52 52 delete nodes_[i]; 53 53 } … … 206 206 printf("nodeinfo: node %i\n", nodeInfo->nodeNumber()); 207 207 { 208 const CbcIntegerBranchingObject *brPrint = dynamic_cast< const CbcIntegerBranchingObject *>(nodeInfo->parentBranch());208 const CbcIntegerBranchingObject *brPrint = dynamic_cast< const CbcIntegerBranchingObject * >(nodeInfo->parentBranch()); 209 209 if (!brPrint) { 210 210 printf(" parentBranch: NULL\n"); … … 215 215 int way = brPrint->way(); 216 216 printf(" parentBranch: var %i downBd [%i,%i] upBd [%i,%i] way %i\n", 217 variable, static_cast< int>(downBounds[0]), static_cast<int>(downBounds[1]),218 static_cast< int>(upBounds[0]), static_cast<int>(upBounds[1]), way);217 variable, static_cast< int >(downBounds[0]), static_cast< int >(downBounds[1]), 218 static_cast< int >(upBounds[0]), static_cast< int >(upBounds[1]), way); 219 219 } 220 220 } … … 225 225 node->nodeNumber(), node->depth(), node->onTree(), node->active()); 226 226 const OsiBranchingObject *osibr = nodeInfo->owner()->branchingObject(); 227 const CbcBranchingObject *cbcbr = dynamic_cast< const CbcBranchingObject *>(osibr);228 const CbcIntegerBranchingObject *brPrint = dynamic_cast< const CbcIntegerBranchingObject *>(cbcbr);227 const CbcBranchingObject *cbcbr = dynamic_cast< const CbcBranchingObject * >(osibr); 228 const CbcIntegerBranchingObject *brPrint = dynamic_cast< const CbcIntegerBranchingObject * >(cbcbr); 229 229 if (!brPrint) { 230 230 printf(" ownerBranch: NULL\n"); … … 235 235 int way = brPrint->way(); 236 236 printf(" ownerbranch: var %i downBd [%i,%i] upBd [%i,%i] way %i\n", 237 variable, static_cast< int>(downBounds[0]), static_cast<int>(downBounds[1]),238 static_cast< int>(upBounds[0]), static_cast<int>(upBounds[1]), way);237 variable, static_cast< int >(downBounds[0]), static_cast< int >(downBounds[1]), 238 static_cast< int >(upBounds[0]), static_cast< int >(upBounds[1]), way); 239 239 } 240 240 } … … 401 401 int old = howOften_; 402 402 #endif 403 howOften_ = CoinMin(CoinMax(static_cast< int>(howOften_ * 1.1), howOften_ + 1), 1000000);403 howOften_ = CoinMin(CoinMax(static_cast< int >(howOften_ * 1.1), howOften_ + 1), 1000000); 404 404 #ifdef COIN_DEVELOP 405 405 printf("Howoften changed from %d to %d for %s\n", … … 451 451 while (time >= COIN_INT_MAX) 452 452 time *= 0.5; 453 value = static_cast< int>(time);453 value = static_cast< int >(time); 454 454 char printArray[100]; 455 455 sprintf(printArray, "using time of day seed was changed from %d to %d", … … 544 544 #ifdef COIN_HAS_CLP 545 545 OsiClpSolverInterface *clpSolver 546 = dynamic_cast< OsiClpSolverInterface *>(solver);546 = dynamic_cast< OsiClpSolverInterface * >(solver); 547 547 #endif 548 548 if ((type & 2) != 0) { … … 552 552 for (int i = 0; i < n; i++) { 553 553 const OsiObject *obj = model_->object(i); 554 const CbcSimpleInteger *thisOne = dynamic_cast< const CbcSimpleInteger *>(obj);554 const CbcSimpleInteger *thisOne = dynamic_cast< const CbcSimpleInteger * >(obj); 555 555 if (thisOne) { 556 556 int iColumn = thisOne->columnNumber(); … … 564 564 for (int i = 0; i < n; i++) { 565 565 const OsiObject *obj = model_->object(i); 566 const CbcSimpleInteger *thisOne = dynamic_cast< const CbcSimpleInteger *>(obj);566 const CbcSimpleInteger *thisOne = dynamic_cast< const CbcSimpleInteger * >(obj); 567 567 if (thisOne) { 568 568 int iColumn = thisOne->columnNumber(); … … 719 719 } 720 720 #ifdef COIN_HAS_CLP 721 OsiClpSolverInterface *clpSolver = dynamic_cast< OsiClpSolverInterface *>(solver);721 OsiClpSolverInterface *clpSolver = dynamic_cast< OsiClpSolverInterface * >(solver); 722 722 if (clpSolver && (clpSolver->specialOptions() & 65536) == 0) { 723 723 // go faster stripes … … 920 920 const OsiRowCutDebugger *debugger = solver->getRowCutDebugger(); 921 921 if (debugger) { 922 process.setApplicationData(const_cast< double *>(debugger->optimalSolution()));922 process.setApplicationData(const_cast< double * >(debugger->optimalSolution())); 923 923 } 924 924 } 925 925 #endif 926 926 #ifdef COIN_HAS_CLP 927 OsiClpSolverInterface *clpSolver = dynamic_cast< OsiClpSolverInterface *>(solver);927 OsiClpSolverInterface *clpSolver = dynamic_cast< OsiClpSolverInterface * >(solver); 928 928 // See if SOS 929 929 if (clpSolver && clpSolver->numberSOS()) { … … 939 939 int type = setInfo[i].setType(); 940 940 int n = setInfo[i].numberEntries(); 941 sosType[i] = static_cast< char>(type);941 sosType[i] = static_cast< char >(type); 942 942 nTotal += n; 943 943 sosStart[i + 1] = nTotal; … … 953 953 int k = which[j]; 954 954 sosIndices[j + base] = k; 955 sosReference[j + base] = weights ? weights[j] : static_cast< double>(j);955 sosReference[j + base] = weights ? weights[j] : static_cast< double >(j); 956 956 } 957 957 } … … 1023 1023 // redo SOS 1024 1024 OsiClpSolverInterface *clpSolver 1025 = dynamic_cast< OsiClpSolverInterface *>(model.solver());1025 = dynamic_cast< OsiClpSolverInterface * >(model.solver()); 1026 1026 if (clpSolver && clpSolver->numberSOS()) { 1027 1027 int numberColumns = clpSolver->getNumCols(); 1028 1028 const int *originalColumns = process.originalColumns(); 1029 CoinSet *setInfo = const_cast< CoinSet *>(clpSolver->setInfo());1029 CoinSet *setInfo = const_cast< CoinSet * >(clpSolver->setInfo()); 1030 1030 int numberSOS = clpSolver->numberSOS(); 1031 1031 for (int iSOS = 0; iSOS < numberSOS; iSOS++) { … … 1071 1071 double fraction = fractionSmall_ - floor(fractionSmall_); 1072 1072 if (ratio > fraction) { 1073 int type = static_cast< int>(floor(fractionSmall_ * 0.1));1074 int over = static_cast< int>(ceil(ratio - fraction));1073 int type = static_cast< int >(floor(fractionSmall_ * 0.1)); 1074 int over = static_cast< int >(ceil(ratio - fraction)); 1075 1075 int maxNodes[] = { -1, 0, 5, 10 }; 1076 1076 if (type > over) … … 1131 1131 for (int i = 0; i < model.numberCutGenerators(); i++) { 1132 1132 CbcCutGenerator *generator = model.cutGenerator(i); 1133 CglGomory *gomory = dynamic_cast< CglGomory *>(generator->generator());1133 CglGomory *gomory = dynamic_cast< CglGomory * >(generator->generator()); 1134 1134 if (gomory && gomory->originalSolver()) 1135 1135 gomory->passInOriginalSolver(model.solver()); … … 1199 1199 CbcHeuristicFPump *fpump = NULL; 1200 1200 for (int i = 0; i < model.numberHeuristics(); i++) { 1201 CbcHeuristicFPump *pump = dynamic_cast< CbcHeuristicFPump *>(model.heuristic(i));1201 CbcHeuristicFPump *pump = dynamic_cast< CbcHeuristicFPump * >(model.heuristic(i)); 1202 1202 if (pump) { 1203 1203 fpump = pump; … … 1281 1281 for (int i = 0; i < model.numberHeuristics(); i++) { 1282 1282 // reset lastNode 1283 CbcHeuristicRINS *rins = dynamic_cast< CbcHeuristicRINS *>(model.heuristic(i));1283 CbcHeuristicRINS *rins = dynamic_cast< CbcHeuristicRINS * >(model.heuristic(i)); 1284 1284 if (rins) { 1285 1285 rins->setLastNode(-1000); … … 1454 1454 generator->numberCutsActive(), 1455 1455 generator->timeInCutGenerator()); 1456 CglStored *stored = dynamic_cast< CglStored *>(generator->generator());1456 CglStored *stored = dynamic_cast< CglStored * >(generator->generator()); 1457 1457 if (stored && !generator->numberCutsInTotal()) 1458 1458 continue; 1459 1459 #ifndef CLP_INVESTIGATE 1460 CglImplication *implication = dynamic_cast< CglImplication *>(generator->generator());1460 CglImplication *implication = dynamic_cast< CglImplication * >(generator->generator()); 1461 1461 if (implication) 1462 1462 continue; … … 1483 1483 // post process 1484 1484 #ifdef COIN_HAS_CLP 1485 OsiClpSolverInterface *clpSolver = dynamic_cast< OsiClpSolverInterface *>(model.solver());1485 OsiClpSolverInterface *clpSolver = dynamic_cast< OsiClpSolverInterface * >(model.solver()); 1486 1486 if (clpSolver) { 1487 1487 ClpSimplex *lpSolver = clpSolver->getModelPtr(); … … 1682 1682 while (nodeInfo->parentBranch() != NULL) { 1683 1683 const OsiBranchingObject *br = nodeInfo->parentBranch(); 1684 const CbcBranchingObject *cbcbr = dynamic_cast< const CbcBranchingObject *>(br);1684 const CbcBranchingObject *cbcbr = dynamic_cast< const CbcBranchingObject * >(br); 1685 1685 if (!cbcbr) { 1686 1686 throw CoinError("CbcHeuristicNode can be used only with CbcBranchingObjects.\n", … … 1760 1760 const CbcBranchingObject *br1 = node->brObj_[j]; 1761 1761 #ifdef PRINT_DEBUG 1762 const CbcIntegerBranchingObject *brPrint0 = dynamic_cast< const CbcIntegerBranchingObject *>(br0);1762 const CbcIntegerBranchingObject *brPrint0 = dynamic_cast< const CbcIntegerBranchingObject * >(br0); 1763 1763 const double *downBounds = brPrint0->downBounds(); 1764 1764 const double *upBounds = brPrint0->upBounds(); … … 1766 1766 int way = brPrint0->way(); 1767 1767 printf(" br0: var %i downBd [%i,%i] upBd [%i,%i] way %i\n", 1768 variable, static_cast< int>(downBounds[0]), static_cast<int>(downBounds[1]),1769 static_cast< int>(upBounds[0]), static_cast<int>(upBounds[1]), way);1770 const CbcIntegerBranchingObject *brPrint1 = dynamic_cast< const CbcIntegerBranchingObject *>(br1);1768 variable, static_cast< int >(downBounds[0]), static_cast< int >(downBounds[1]), 1769 static_cast< int >(upBounds[0]), static_cast< int >(upBounds[1]), way); 1770 const CbcIntegerBranchingObject *brPrint1 = dynamic_cast< const CbcIntegerBranchingObject * >(br1); 1771 1771 downBounds = brPrint1->downBounds(); 1772 1772 upBounds = brPrint1->upBounds(); … … 1774 1774 way = brPrint1->way(); 1775 1775 printf(" br1: var %i downBd [%i,%i] upBd [%i,%i] way %i\n", 1776 variable, static_cast< int>(downBounds[0]), static_cast<int>(downBounds[1]),1777 static_cast< int>(upBounds[0]), static_cast<int>(upBounds[1]), way);1776 variable, static_cast< int >(downBounds[0]), static_cast< int >(downBounds[1]), 1777 static_cast< int >(upBounds[0]), static_cast< int >(upBounds[1]), way); 1778 1778 #endif 1779 1779 const int brComp = compare3BranchingObjects(br0, br1); … … 2584 2584 int start[2]; 2585 2585 int end[2]; 2586 int iRandom = static_cast< int>(randomNumber * (static_cast<double>(numberIntegers)));2586 int iRandom = static_cast< int >(randomNumber * (static_cast< double >(numberIntegers))); 2587 2587 start[0] = iRandom; 2588 2588 end[0] = numberIntegers; … … 3057 3057 // get information on solver type 3058 3058 OsiAuxInfo *auxInfo = model_->solver()->getAuxiliaryInfo(); 3059 OsiBabSolver *auxiliaryInfo = dynamic_cast< OsiBabSolver *>(auxInfo);3059 OsiBabSolver *auxiliaryInfo = dynamic_cast< OsiBabSolver * >(auxInfo); 3060 3060 if (auxiliaryInfo) { 3061 3061 return auxiliaryInfo->solution(solutionValue, betterSolution, model_->solver()->getNumCols()); -
trunk/Cbc/src/CbcHeuristic.hpp
r2465 r2467 60 60 61 61 private: 62 std::vector< CbcHeuristicNode *> nodes_;62 std::vector< CbcHeuristicNode * > nodes_; 63 63 64 64 public: … … 76 76 inline int size() const 77 77 { 78 return static_cast< int>(nodes_.size());78 return static_cast< int >(nodes_.size()); 79 79 } 80 80 }; … … 340 340 { 341 341 const OsiClpSolverInterface *clpSolver 342 = dynamic_cast< const OsiClpSolverInterface *>(solver);342 = dynamic_cast< const OsiClpSolverInterface * >(solver); 343 343 if (clpSolver) 344 344 return clpSolver->isHeuristicInteger(iColumn); -
trunk/Cbc/src/CbcHeuristicDINS.cpp
r2465 r2467 197 197 double value = bestSolution[iColumn]; 198 198 double nearest = floor(value + 0.5); 199 values_[0][i] = static_cast< int>(nearest);199 values_[0][i] = static_cast< int >(nearest); 200 200 } 201 201 numberKeptSolutions_ = CoinMin(numberKeptSolutions_ + 1, maximumKeepSolutions_); … … 246 246 valueInt = originalUpper; 247 247 } 248 int intValue = static_cast< int>(floor(valueInt + 0.5));248 int intValue = static_cast< int >(floor(valueInt + 0.5)); 249 249 double currentValue = currentSolution[iColumn]; 250 250 double currentLower = colLower[iColumn]; … … 393 393 numberTries_++; 394 394 if ((numberTries_ % 10) == 0 && numberSuccesses_ * 3 < numberTries_) 395 howOften_ += static_cast< int>(howOften_ * decayFactor_);395 howOften_ += static_cast< int >(howOften_ * decayFactor_); 396 396 } 397 397 return finalReturnCode; -
trunk/Cbc/src/CbcHeuristicDW.cpp
r2465 r2467 347 347 int logLevel = model_->messageHandler()->logLevel(); 348 348 // For moment just OsiClp 349 OsiClpSolverInterface *solver = dynamic_cast< OsiClpSolverInterface *>(solver_);349 OsiClpSolverInterface *solver = dynamic_cast< OsiClpSolverInterface * >(solver_); 350 350 ClpSimplex *simplex = solver->getModelPtr(); 351 351 double *columnLower = simplex->columnLower(); … … 851 851 } 852 852 if (numberInDj) 853 averageDj /= static_cast< double>(numberInDj);853 averageDj /= static_cast< double >(numberInDj); 854 854 if (numberInDiff) 855 averageDiff /= static_cast< double>(numberInDiff);855 averageDiff /= static_cast< double >(numberInDiff); 856 856 double ratioDiff = averageDj / averageDiff; 857 857 // downplay … … 872 872 if (phase_ == 99) 873 873 blockSort[i] -= 2.0 * averageDj * goodBlock[i]; 874 blockSort[i] /= static_cast< double>(intsInBlock_[i]);874 blockSort[i] /= static_cast< double >(intsInBlock_[i]); 875 875 //blockSort[i] /= sqrt(static_cast<double>(intsInBlock_[i])); 876 876 if (doneBlock[i]) { 877 blockSort[i] /= static_cast< double>(doneBlock[i] + 1);877 blockSort[i] /= static_cast< double >(doneBlock[i] + 1); 878 878 if (whenBlock[i] > pass_ - 10) 879 879 blockSort[i] += 1.0e2 * averageDj; … … 1435 1435 if (thisBestValue * numberRowsDone > maximumBlockSize && numberRowsDone > halfway) { 1436 1436 thisBestBreak = iRow; 1437 thisBestValue = static_cast< double>(maximumBlockSize) / static_cast<double>(numberRowsDone);1437 thisBestValue = static_cast< double >(maximumBlockSize) / static_cast< double >(numberRowsDone); 1438 1438 } 1439 1439 } … … 1792 1792 if (sum > 65535) 1793 1793 sum = 65535; 1794 unsigned short value = static_cast< unsigned short>(sum);1794 unsigned short value = static_cast< unsigned short >(sum); 1795 1795 affinity_[iBlock * numberBlocks + jBlock] = value; 1796 1796 affinity_[jBlock * numberBlocks + iBlock] = value; … … 1817 1817 } 1818 1818 sprintf(dwPrint, "Total not affinity %d - average %g%%", 1819 nTotalZero, 100.0 * (static_cast< double>(nTotalZero) / (numberBlocks * numberBlocks)));1819 nTotalZero, 100.0 * (static_cast< double >(nTotalZero) / (numberBlocks * numberBlocks))); 1820 1820 model_->messageHandler()->message(CBC_FPUMP1, model_->messages()) 1821 1821 << dwPrint … … 1864 1864 #define MAX_ADD 100000 1865 1865 CoinBigIndex *startsDW = new CoinBigIndex[numberBlocks_ + 1 + MAX_ADD]; 1866 int *rowDW = reinterpret_cast< int *>(startsDW + numberBlocks_ + 1);1866 int *rowDW = reinterpret_cast< int * >(startsDW + numberBlocks_ + 1); 1867 1867 double *elementDW = new double[MAX_ADD + 3 * numberBlocks_ + numberMasterRows_]; 1868 1868 double *newCost = elementDW + MAX_ADD; … … 2172 2172 tempColumn[numberMasterColumns++] = i; 2173 2173 } 2174 OsiClpSolverInterface *solver = dynamic_cast< OsiClpSolverInterface *>(solver_);2174 OsiClpSolverInterface *solver = dynamic_cast< OsiClpSolverInterface * >(solver_); 2175 2175 ClpSimplex *tempModel = new ClpSimplex(solver->getModelPtr(), 2176 2176 numberMasterRows, tempRow, -
trunk/Cbc/src/CbcHeuristicDive.cpp
r2465 r2467 214 214 for (int i = 0; i < numberObjects; i++) { 215 215 OsiObject *object = model_->modifiableObject(i); 216 const CbcSimpleInteger *thisOne = dynamic_cast< const CbcSimpleInteger *>(object);216 const CbcSimpleInteger *thisOne = dynamic_cast< const CbcSimpleInteger * >(object); 217 217 if (!thisOne) 218 218 continue; // Not integer … … 231 231 for (int i = 0; i < numberObjects; i++) { 232 232 OsiObject *object = model_->modifiableObject(i); 233 const CbcSimpleInteger *thisOne = dynamic_cast< const CbcSimpleInteger *>(object);233 const CbcSimpleInteger *thisOne = dynamic_cast< const CbcSimpleInteger * >(object); 234 234 if (!thisOne) 235 235 continue; // Not integer … … 237 237 assert(level < (1 << 29)); 238 238 assert(nInteger < numberIntegers); 239 priority_[nInteger].priority = static_cast< unsigned int>(level);239 priority_[nInteger].priority = static_cast< unsigned int >(level); 240 240 int direction = 0; 241 241 if (thisOne->preferredWay() < 0) … … 244 244 direction = 1 | 1; 245 245 // at present don't try other way is not used 246 priority_[nInteger++].direction = static_cast< unsigned char>(direction);246 priority_[nInteger++].direction = static_cast< unsigned char >(direction); 247 247 } 248 248 assert(nInteger == numberIntegers); … … 300 300 #ifdef COIN_HAS_CLP 301 301 OsiClpSolverInterface *clpSolver 302 = dynamic_cast< OsiClpSolverInterface *>(solver);302 = dynamic_cast< OsiClpSolverInterface * >(solver); 303 303 if (clpSolver) { 304 304 ClpSimplex *clpSimplex = clpSolver->getModelPtr(); … … 372 372 double *random = new double[numberIntegers]; 373 373 374 int maxNumberAtBoundToFix = static_cast< int>(floor(percentageToFix_ * numberIntegers));374 int maxNumberAtBoundToFix = static_cast< int >(floor(percentageToFix_ * numberIntegers)); 375 375 assert(!maxNumberAtBoundToFix || !nodes); 376 376 … … 515 515 if (binVarIndex_.size()) { 516 516 int cnt = 0; 517 int n = static_cast< int>(binVarIndex_.size());517 int n = static_cast< int >(binVarIndex_.size()); 518 518 for (int j = 0; j < n; j++) { 519 519 int iColumn1 = binVarIndex_[j]; … … 595 595 if (upper[iColumn] > lower[iColumn]) { 596 596 int j = back[iColumn]; 597 fixPriority = CoinMin(fixPriority, static_cast< int>(priority_[j].priority));597 fixPriority = CoinMin(fixPriority, static_cast< int >(priority_[j].priority)); 598 598 } 599 599 } … … 623 623 numberFree++; 624 624 if (priority_) { 625 fixPriority = CoinMin(fixPriority, static_cast< int>(priority_[i].priority));625 fixPriority = CoinMin(fixPriority, static_cast< int >(priority_[i].priority)); 626 626 } 627 627 double value = newSolution[iColumn]; … … 662 662 if (upper[iColumn] > lower[iColumn]) { 663 663 if (priority_) { 664 fixPriority = CoinMin(fixPriority, static_cast< int>(priority_[i].priority));664 fixPriority = CoinMin(fixPriority, static_cast< int >(priority_[i].priority)); 665 665 } 666 666 double value = newSolution[iColumn]; … … 687 687 if (priority_[j].priority > fixPriority) 688 688 continue; // skip - only fix ones at high priority 689 int thisRound = static_cast< int>(priority_[j].direction);689 int thisRound = static_cast< int >(priority_[j].direction); 690 690 if ((thisRound & 1) != 0) { 691 691 // for now force way … … 722 722 if (priority_[j].priority > fixPriority) 723 723 continue; // skip - only fix ones at high priority 724 int thisRound = static_cast< int>(priority_[j].direction);724 int thisRound = static_cast< int >(priority_[j].direction); 725 725 if ((thisRound & 1) != 0) { 726 726 // for now force way … … 1307 1307 } 1308 1308 } 1309 downLocks_[i] = static_cast< unsigned short>(down);1310 upLocks_[i] = static_cast< unsigned short>(up);1309 downLocks_[i] = static_cast< unsigned short >(down); 1310 upLocks_[i] = static_cast< unsigned short >(up); 1311 1311 } 1312 1312 … … 1432 1432 #ifdef COIN_HAS_CLP 1433 1433 OsiClpSolverInterface *clpSolver 1434 = dynamic_cast< OsiClpSolverInterface *>(solver);1434 = dynamic_cast< OsiClpSolverInterface * >(solver); 1435 1435 ClpSimplex *clpSimplex = NULL; 1436 1436 if (clpSolver) -
trunk/Cbc/src/CbcHeuristicDive.hpp
r2465 r2467 170 170 // Indexes of binary variables with 0 objective coefficient 171 171 // and in variable bound constraints 172 std::vector< int> binVarIndex_;172 std::vector< int > binVarIndex_; 173 173 174 174 // Indexes of variable bound rows for each binary variable 175 std::vector< int> vbRowIndex_;175 std::vector< int > vbRowIndex_; 176 176 177 177 // Percentage of integer variables to fix at bounds -
trunk/Cbc/src/CbcHeuristicDiveCoefficient.cpp
r2465 r2467 121 121 // if priorities then use 122 122 if (priority_) { 123 int thisRound = static_cast< int>(priority_[i].direction);123 int thisRound = static_cast< int >(priority_[i].direction); 124 124 if ((thisRound & 1) != 0) 125 125 round = ((thisRound & 2) == 0) ? -1 : +1; … … 127 127 nLocks = COIN_INT_MAX; 128 128 } else if (priority_[i].priority < bestPriority) { 129 bestPriority = static_cast< int>(priority_[i].priority);129 bestPriority = static_cast< int >(priority_[i].priority); 130 130 bestLocks = COIN_INT_MAX; 131 131 } -
trunk/Cbc/src/CbcHeuristicDiveFractional.cpp
r2465 r2467 105 105 // if priorities then use 106 106 if (priority_) { 107 int thisRound = static_cast< int>(priority_[i].direction);107 int thisRound = static_cast< int >(priority_[i].direction); 108 108 if ((thisRound & 1) != 0) 109 109 round = ((thisRound & 2) == 0) ? -1 : +1; … … 111 111 fraction = COIN_DBL_MAX; 112 112 } else if (priority_[i].priority < bestPriority) { 113 bestPriority = static_cast< int>(priority_[i].priority);113 bestPriority = static_cast< int >(priority_[i].priority); 114 114 bestFraction = COIN_DBL_MAX; 115 115 } -
trunk/Cbc/src/CbcHeuristicDiveGuided.cpp
r2465 r2467 115 115 // if priorities then use 116 116 if (priority_) { 117 int thisRound = static_cast< int>(priority_[i].direction);117 int thisRound = static_cast< int >(priority_[i].direction); 118 118 if ((thisRound & 1) != 0) 119 119 round = ((thisRound & 2) == 0) ? -1 : +1; … … 121 121 fraction = COIN_DBL_MAX; 122 122 } else if (priority_[i].priority < bestPriority) { 123 bestPriority = static_cast< int>(priority_[i].priority);123 bestPriority = static_cast< int >(priority_[i].priority); 124 124 bestFraction = COIN_DBL_MAX; 125 125 } -
trunk/Cbc/src/CbcHeuristicDiveLineSearch.cpp
r2465 r2467 113 113 // if priorities then use 114 114 if (priority_) { 115 int thisRound = static_cast< int>(priority_[i].direction);115 int thisRound = static_cast< int >(priority_[i].direction); 116 116 if ((thisRound & 1) != 0) 117 117 round = ((thisRound & 2) == 0) ? -1 : +1; … … 119 119 relDistance = COIN_DBL_MAX; 120 120 } else if (priority_[i].priority < bestPriority) { 121 bestPriority = static_cast< int>(priority_[i].priority);121 bestPriority = static_cast< int >(priority_[i].priority); 122 122 bestRelDistance = COIN_DBL_MAX; 123 123 } -
trunk/Cbc/src/CbcHeuristicDivePseudoCost.cpp
r2465 r2467 134 134 // if priorities then use 135 135 if (priority_) { 136 int thisRound = static_cast< int>(priority_[i].direction);136 int thisRound = static_cast< int >(priority_[i].direction); 137 137 if ((thisRound & 1) != 0) 138 138 round = ((thisRound & 2) == 0) ? -1 : +1; … … 140 140 score = COIN_DBL_MAX; 141 141 } else if (priority_[i].priority < bestPriority) { 142 bestPriority = static_cast< int>(priority_[i].priority);142 bestPriority = static_cast< int >(priority_[i].priority); 143 143 bestScore = COIN_DBL_MAX; 144 144 } … … 175 175 OsiObject **objects = model_->objects(); 176 176 for (int i = 0; i < numberInts; i++) { 177 CbcSimpleIntegerDynamicPseudoCost *obj1 = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost *>(objects[i]);177 CbcSimpleIntegerDynamicPseudoCost *obj1 = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(objects[i]); 178 178 if (obj1) { 179 179 //int iColumn = obj1->columnNumber(); -
trunk/Cbc/src/CbcHeuristicDiveVectorLength.cpp
r2465 r2467 114 114 115 115 // we want the smaller score 116 double score = objDelta / (static_cast< double>(columnLength[iColumn]) + 1.0);116 double score = objDelta / (static_cast< double >(columnLength[iColumn]) + 1.0); 117 117 118 118 // if variable is not binary, penalize it … … 122 122 // if priorities then use 123 123 if (priority_) { 124 int thisRound = static_cast< int>(priority_[i].direction);124 int thisRound = static_cast< int >(priority_[i].direction); 125 125 if ((thisRound & 1) != 0) 126 126 round = ((thisRound & 2) == 0) ? -1 : +1; … … 128 128 score = COIN_DBL_MAX; 129 129 } else if (priority_[i].priority < bestPriority) { 130 bestPriority = static_cast< int>(priority_[i].priority);130 bestPriority = static_cast< int >(priority_[i].priority); 131 131 bestScore = COIN_DBL_MAX; 132 132 } -
trunk/Cbc/src/CbcHeuristicFPump.cpp
r2465 r2467 327 327 #ifndef NDEBUG 328 328 const OsiObject *object = model_->object(i); 329 const CbcSimpleInteger *integerObject = dynamic_cast< const CbcSimpleInteger *>(object);330 const OsiSimpleInteger *integerObject2 = dynamic_cast< const OsiSimpleInteger *>(object);329 const CbcSimpleInteger *integerObject = dynamic_cast< const CbcSimpleInteger * >(object); 330 const OsiSimpleInteger *integerObject2 = dynamic_cast< const OsiSimpleInteger * >(object); 331 331 assert(integerObject || integerObject2); 332 332 #endif … … 444 444 */ 445 445 CoinWarmStartBasis saveBasis; 446 CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis *>(model_->solver()->getWarmStart());446 CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(model_->solver()->getWarmStart()); 447 447 if (basis) { 448 448 saveBasis = *basis; … … 516 516 { 517 517 OsiClpSolverInterface *clpSolver 518 = dynamic_cast< OsiClpSolverInterface *>(model_->solver());518 = dynamic_cast< OsiClpSolverInterface * >(model_->solver()); 519 519 if (clpSolver) { 520 520 if (maximumPasses == 30) { … … 565 565 { 566 566 OsiClpSolverInterface *clpSolver 567 = dynamic_cast< OsiClpSolverInterface *>(solver);567 = dynamic_cast< OsiClpSolverInterface * >(solver); 568 568 if (clpSolver) { 569 569 // better to clean up using primal? … … 722 722 } 723 723 if (scaleFactor) 724 scaleFactor = (initialWeight_ * sqrt(static_cast< double>(numberIntegers))) / sqrt(scaleFactor);724 scaleFactor = (initialWeight_ * sqrt(static_cast< double >(numberIntegers))) / sqrt(scaleFactor); 725 725 #ifdef CLP_INVESTIGATE 726 726 #ifdef COIN_DEVELOP … … 811 811 { 812 812 OsiClpSolverInterface *clpSolver 813 = dynamic_cast< OsiClpSolverInterface *>(clonedSolver);813 = dynamic_cast< OsiClpSolverInterface * >(clonedSolver); 814 814 //printf("real cutoff %g fake %g - second pass %c\n",realCutoff,cutoff, 815 815 // secondMajorPass ? 'Y' : 'N'); … … 1033 1033 if (exitNow(newSolutionValue)) 1034 1034 exitAll = true; 1035 CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis *>(solver->getWarmStart());1035 CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver->getWarmStart()); 1036 1036 if (basis) { 1037 1037 bestBasis = *basis; … … 1304 1304 if (newSolutionValue < solutionValue) { 1305 1305 memcpy(betterSolution, newSolution, numberColumns * sizeof(double)); 1306 CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis *>(solver->getWarmStart());1306 CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver->getWarmStart()); 1307 1307 solutionFound = true; 1308 1308 numberSolutions++; … … 1360 1360 if (dualPass == 1 && 2 * numberChanged < numberColumns && (numberChanged < 5000 || 6 * numberChanged < numberColumns)) { 1361 1361 // but we need to make infeasible 1362 CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis *>(solver->getWarmStart());1362 CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver->getWarmStart()); 1363 1363 if (basis) { 1364 1364 // modify … … 1466 1466 if (numberTries == 1 || secondPassOpt > 3) { 1467 1467 // save basis 1468 CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis *>(solver->getWarmStart());1468 CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver->getWarmStart()); 1469 1469 if (basis) { 1470 1470 saveBasis = *basis; … … 2181 2181 #ifdef COIN_HAS_CLP 2182 2182 OsiClpSolverInterface *clpSolver 2183 = dynamic_cast< OsiClpSolverInterface *>(newSolver);2183 = dynamic_cast< OsiClpSolverInterface * >(newSolver); 2184 2184 if (clpSolver) { 2185 2185 ClpSimplex *simplex = clpSolver->getModelPtr(); … … 2289 2289 if (exitNow(newSolutionValue)) 2290 2290 exitAll = true; 2291 CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis *>(newSolver->getWarmStart());2291 CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(newSolver->getWarmStart()); 2292 2292 if (basis) { 2293 2293 bestBasis = *basis; … … 2436 2436 printf("XXX total iterations %d ratios - %g %g %g\n", 2437 2437 totalNumberIterations, 2438 static_cast< double>(totalNumberIterations) / nrow,2439 static_cast< double>(totalNumberIterations) / ncol,2440 static_cast< double>(totalNumberIterations) / (2 * nrow + 2 * ncol));2438 static_cast< double >(totalNumberIterations) / nrow, 2439 static_cast< double >(totalNumberIterations) / ncol, 2440 static_cast< double >(totalNumberIterations) / (2 * nrow + 2 * ncol)); 2441 2441 } 2442 2442 #endif … … 2486 2486 } else { 2487 2487 general++; 2488 int up = static_cast< int>(upper[iColumn]);2489 int lo = static_cast< int>(lower[iColumn]);2490 int near = static_cast< int>(nearest);2488 int up = static_cast< int >(upper[iColumn]); 2489 int lo = static_cast< int >(lower[iColumn]); 2490 int near = static_cast< int >(nearest); 2491 2491 up = CoinMin(up, near + maxAround); 2492 2492 lo = CoinMax(lo, near - maxAround); … … 2533 2533 #endif 2534 2534 if (upper[iColumn] - lower[iColumn] > 1.000001) { 2535 int up = static_cast< int>(upper[iColumn]);2536 int lo = static_cast< int>(lower[iColumn]);2535 int up = static_cast< int >(upper[iColumn]); 2536 int lo = static_cast< int >(lower[iColumn]); 2537 2537 addLower[nAddRow] = lo; 2538 2538 addUpper[nAddRow] = lo; … … 2611 2611 int flip_down = 0; 2612 2612 double v = randomNumberGenerator_.randomDouble() * 20.0; 2613 int nn = 10 + static_cast< int>(v);2613 int nn = 10 + static_cast< int >(v); 2614 2614 int nnv = 0; 2615 2615 int *list = new int[nn]; … … 2776 2776 double *saveSolution = CoinCopyOfArray(solution, numberColumns); 2777 2777 double *tempSolution = CoinCopyOfArray(solution, numberColumns); 2778 CoinWarmStartBasis *saveBasis = dynamic_cast< CoinWarmStartBasis *>(solver->getWarmStart());2778 CoinWarmStartBasis *saveBasis = dynamic_cast< CoinWarmStartBasis * >(solver->getWarmStart()); 2779 2779 for (i = 0; i < numberIntegers; i++) { 2780 2780 int iColumn = integerVariable[i]; … … 3231 3231 if (model) { 3232 3232 osiModel_ 3233 = dynamic_cast< OsiClpSolverInterface *>(model->solver());3233 = dynamic_cast< OsiClpSolverInterface * >(model->solver()); 3234 3234 if (osiModel_) 3235 3235 setSimplex(osiModel_->getModelPtr()); … … 3289 3289 if (model) { 3290 3290 osiModel_ 3291 = dynamic_cast< OsiClpSolverInterface *>(model->solver());3291 = dynamic_cast< OsiClpSolverInterface * >(model->solver()); 3292 3292 if (osiModel_) 3293 3293 setSimplex(osiModel_->getModelPtr()); -
trunk/Cbc/src/CbcHeuristicGreedy.cpp
r2465 r2467 1715 1715 } else { 1716 1716 if (iPass == 0) { 1717 costBias = 10.0 * newSolutionValue / static_cast< double>(nAdded);1717 costBias = 10.0 * newSolutionValue / static_cast< double >(nAdded); 1718 1718 } else { 1719 1719 costBias *= 10.0; -
trunk/Cbc/src/CbcHeuristicLocal.cpp
r2465 r2467 504 504 if (value < originalUpper - 0.5) 505 505 iway |= 2; 506 way[i] = static_cast< char>(iway);506 way[i] = static_cast< char >(iway); 507 507 } 508 508 /* … … 570 570 #ifdef COIN_HAS_CLP 571 571 OsiClpSolverInterface *clpSolver 572 = dynamic_cast< OsiClpSolverInterface *>(model_->solver());572 = dynamic_cast< OsiClpSolverInterface * >(model_->solver()); 573 573 if (clpSolver) { 574 574 // take out some integers … … 850 850 if (value < originalUpper - 0.5) 851 851 iway |= 2; 852 way[goodK] = static_cast< char>(iway);852 way[goodK] = static_cast< char >(iway); 853 853 totalChange += bestChange; 854 854 } … … 915 915 // new solution 916 916 memcpy(betterSolution, newSolution, numberColumns * sizeof(double)); 917 CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis *>(solver->getWarmStart());917 CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver->getWarmStart()); 918 918 if (basis) { 919 919 model_->setBestSolutionBasis(*basis); … … 1089 1089 // clone feasibility pump 1090 1090 for (int i = 0; i < model_->numberHeuristics(); i++) { 1091 const CbcHeuristicFPump *pump = dynamic_cast< const CbcHeuristicFPump *>(model_->heuristic(i));1091 const CbcHeuristicFPump *pump = dynamic_cast< const CbcHeuristicFPump * >(model_->heuristic(i)); 1092 1092 if (pump) { 1093 1093 feasibilityPump_ = new CbcHeuristicFPump(*pump); … … 1162 1162 pumpAdded = true; 1163 1163 for (int i = 0; i < model_->numberHeuristics(); i++) { 1164 const CbcHeuristicFPump *pump = dynamic_cast< const CbcHeuristicFPump *>(model_->heuristic(i));1164 const CbcHeuristicFPump *pump = dynamic_cast< const CbcHeuristicFPump * >(model_->heuristic(i)); 1165 1165 if (pump) { 1166 1166 pumpAdded = false; … … 1209 1209 solutionValue += obj[i] * betterSolution[i]; 1210 1210 if (isHeuristicInteger(solver, i)) { 1211 int change = static_cast< int>(floor(solutionIn[i] - betterSolution[i] + 0.5));1211 int change = static_cast< int >(floor(solutionIn[i] - betterSolution[i] + 0.5)); 1212 1212 if (change > 0) { 1213 1213 numberIncrease++; … … 1345 1345 bool solutionFound = false; 1346 1346 CoinWarmStartBasis saveBasis; 1347 CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis *>(solver->getWarmStart());1347 CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver->getWarmStart()); 1348 1348 if (basis) { 1349 1349 saveBasis = *basis; -
trunk/Cbc/src/CbcHeuristicLocal.hpp
r2465 r2467 262 262 // Data 263 263 /// Attempts 264 std::vector< double> attempts_;264 std::vector< double > attempts_; 265 265 /// Random numbers to stop same search happening 266 266 double random_[10]; -
trunk/Cbc/src/CbcHeuristicPivotAndFix.cpp
r2465 r2467 107 107 108 108 OsiClpSolverInterface *clpSolverOriginal 109 = dynamic_cast< OsiClpSolverInterface *>(model_->solver());109 = dynamic_cast< OsiClpSolverInterface * >(model_->solver()); 110 110 assert(clpSolverOriginal); 111 111 OsiClpSolverInterface *clpSolver(clpSolverOriginal); -
trunk/Cbc/src/CbcHeuristicRENS.cpp
r2465 r2467 145 145 double total = 0.0; 146 146 int n = 0; 147 CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis *>(solver->getWarmStart());147 CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver->getWarmStart()); 148 148 if (basis && basis->getNumArtificial()) { 149 149 for (int iColumn = 0; iColumn < numberColumns; iColumn++) { … … 154 154 } 155 155 if (n) 156 djTolerance = (0.01 * total) / static_cast< double>(n);156 djTolerance = (0.01 * total) / static_cast< double >(n); 157 157 delete basis; 158 158 } … … 169 169 // SOS type fixing 170 170 bool fixSets = (type == 5) || (type == 7) || (type == 10) || (type == 11); 171 CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis *>(solver->getWarmStart());171 CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver->getWarmStart()); 172 172 if (basis && basis->getNumArtificial()) { 173 173 //const double * rowLower = solver->getRowLower(); … … 281 281 if (type < 10) { 282 282 std::sort(sort, sort + nSOS); 283 int last = static_cast< int>(nSOS * 0.9 * fractionSmall_);283 int last = static_cast< int >(nSOS * 0.9 * fractionSmall_); 284 284 double tolerance = sort[last]; 285 285 for (int iColumn = 0; iColumn < numberColumns; iColumn++) { … … 364 364 } 365 365 } 366 double averagePerSet = sum / static_cast< double>(numberRows);366 double averagePerSet = sum / static_cast< double >(numberRows); 367 367 // allow this extra 368 368 double factor = averagePerSet * fractionSmall_ * numberRows; … … 441 441 char *nonzero = new char[numberColumns]; 442 442 // save basis and solution 443 CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis *>(newSolver->getWarmStart());443 CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(newSolver->getWarmStart()); 444 444 assert(basis != NULL); 445 445 double *saveSolution = CoinCopyOfArray(newSolver->getColSolution(), … … 510 510 } 511 511 int nFixed = 0; 512 int numberSetsToFix = static_cast< int>(nSOS * (1.0 - proportion));512 int numberSetsToFix = static_cast< int >(nSOS * (1.0 - proportion)); 513 513 int *mixed = new int[numberRows]; 514 514 memset(mixed, 0, numberRows * sizeof(int)); … … 601 601 } 602 602 std::sort(sort, sort + numberColumns); 603 int last = static_cast< int>(numberColumns * fractionSmall_);603 int last = static_cast< int >(numberColumns * fractionSmall_); 604 604 djTolerance = CoinMax(sort[last], 1.0e-5); 605 605 delete[] sort; … … 655 655 chunk[i] = -1; 656 656 if (whichRow[i]) { 657 contribution[i] = -contribution[i] / static_cast< double>(whichRow[i]);657 contribution[i] = -contribution[i] / static_cast< double >(whichRow[i]); 658 658 } else { 659 659 contribution[i] = COIN_DBL_MAX; … … 856 856 double *sort = new double[nAtLb]; 857 857 int *which = new int[nAtLb]; 858 double threshold = CoinMax((0.01 * sumDj) / static_cast< double>(nAtLb), 1.0e-6);858 double threshold = CoinMax((0.01 * sumDj) / static_cast< double >(nAtLb), 1.0e-6); 859 859 int nFix2 = 0; 860 860 for (int iColumn = 0; iColumn < numberColumns; iColumn++) { … … 913 913 double *sort = new double[nAtLb]; 914 914 int *which = new int[nAtLb]; 915 double threshold = CoinMax((0.01 * sumDj) / static_cast< double>(nAtLb), 1.0e-6);915 double threshold = CoinMax((0.01 * sumDj) / static_cast< double >(nAtLb), 1.0e-6); 916 916 int nFix2 = 0; 917 917 for (int iColumn = 0; iColumn < numberColumns; iColumn++) { -
trunk/Cbc/src/CbcHeuristicRINS.cpp
r2465 r2467 369 369 numberTries_++; 370 370 if ((numberTries_ % 10) == 0 && numberSuccesses_ * 3 < numberTries_) 371 howOften_ += static_cast< int>(howOften_ * decayFactor_);371 howOften_ += static_cast< int >(howOften_ * decayFactor_); 372 372 delete newSolver; 373 373 } -
trunk/Cbc/src/CbcHeuristicRandRound.cpp
r2465 r2467 24 24 static inline int intRand(const int range) 25 25 { 26 return static_cast< int>(floor(CoinDrand48() * range));26 return static_cast< int >(floor(CoinDrand48() * range)); 27 27 } 28 28 … … 130 130 double primalTolerance; 131 131 solver->getDblParam(OsiPrimalTolerance, primalTolerance); 132 OsiClpSolverInterface *clpSolver = dynamic_cast< OsiClpSolverInterface *>(solver);132 OsiClpSolverInterface *clpSolver = dynamic_cast< OsiClpSolverInterface * >(solver); 133 133 assert(clpSolver); 134 134 ClpSimplex *simplex = clpSolver->getModelPtr(); … … 221 221 222 222 double *newObj = new double[numCols]; 223 srand(static_cast< unsigned int>(time(NULL) + 1));223 srand(static_cast< unsigned int >(time(NULL) + 1)); 224 224 int randNum; 225 225 … … 307 307 // rlh: use some COIN max instead of 1e30 (?) 308 308 double bestObj = 1e30; 309 std::vector< std::vector<double>> feasibles;309 std::vector< std::vector< double > > feasibles; 310 310 int numFeasibles = 0; 311 311 … … 360 360 if (feasibility) { 361 361 numFeasibles++; 362 feasibles.push_back(std::vector< double>(numCols));362 feasibles.push_back(std::vector< double >(numCols)); 363 363 for (int k = 0; k < numCols; k++) 364 364 feasibles[numFeasibles - 1][k] = cornerPoints[i][k]; … … 388 388 //------------------------------------------- 389 389 390 srand(static_cast< unsigned int>(time(NULL) + 1));390 srand(static_cast< unsigned int >(time(NULL) + 1)); 391 391 int numRandomPoints = 0; 392 392 while (numRandomPoints < 50000) { … … 458 458 printf("%.2f\n", CoinCpuTime() - start); 459 459 numFeasibles++; 460 feasibles.push_back(std::vector< double>(numCols));460 feasibles.push_back(std::vector< double >(numCols)); 461 461 for (int i = 0; i < numCols; i++) 462 462 feasibles[numFeasibles - 1][i] = roundRp[i]; -
trunk/Cbc/src/CbcHeuristicVND.cpp
r2465 r2467 284 284 numberTries_++; 285 285 if ((numberTries_ % 10) == 0 && numberSuccesses_ * 3 < numberTries_) 286 howOften_ += static_cast< int>(howOften_ * decayFactor_);286 howOften_ += static_cast< int >(howOften_ * decayFactor_); 287 287 } 288 288 -
trunk/Cbc/src/CbcLinked.cpp
r2465 r2467 145 145 temp->removeGaps(1.0e-14); 146 146 ClpMatrixBase *save = modelPtr_->clpMatrix(); 147 ClpPackedMatrix *clpMatrix = dynamic_cast< ClpPackedMatrix *>(save);147 ClpPackedMatrix *clpMatrix = dynamic_cast< ClpPackedMatrix * >(save); 148 148 assert(clpMatrix); 149 149 if (save->getNumRows() > temp->getNumRows()) { … … 238 238 CbcCutGenerator *generator = cbcModel_->cutGenerator(iGenerator); 239 239 CglCutGenerator *gen = generator->generator(); 240 CglStored *gen2 = dynamic_cast< CglStored *>(gen);240 CglStored *gen2 = dynamic_cast< CglStored * >(gen); 241 241 if (gen2) { 242 242 // add OA cut … … 311 311 temp->removeGaps(1.0e-14); 312 312 ClpMatrixBase *save = modelPtr_->clpMatrix(); 313 ClpPackedMatrix *clpMatrix = dynamic_cast< ClpPackedMatrix *>(save);313 ClpPackedMatrix *clpMatrix = dynamic_cast< ClpPackedMatrix * >(save); 314 314 assert(clpMatrix); 315 315 if (save->getNumRows() > temp->getNumRows()) { … … 435 435 // and now rest 436 436 for (i = 0; i < numberObjects_; i++) { 437 OsiBiLinear *obj = dynamic_cast< OsiBiLinear *>(object_[i]);437 OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(object_[i]); 438 438 if (obj) { 439 439 value += obj->xyCoefficient(solution); … … 447 447 bestObjectiveValue_ = value; 448 448 if (maxIts <= 10000 && cbcModel_) { 449 OsiSolverLink *solver2 = dynamic_cast< OsiSolverLink *>(cbcModel_->solver());449 OsiSolverLink *solver2 = dynamic_cast< OsiSolverLink * >(cbcModel_->solver()); 450 450 assert(solver2); 451 451 if (solver2 != this) { … … 465 465 CbcCutGenerator *generator = cbcModel_->cutGenerator(iGenerator); 466 466 CglCutGenerator *gen = generator->generator(); 467 CglStored *gen2 = dynamic_cast< CglStored *>(gen);467 CglStored *gen2 = dynamic_cast< CglStored * >(gen); 468 468 if (gen2) { 469 469 cbcModel_->lockThread(); … … 485 485 gradient[column2[i]] = element[i]; 486 486 for (i = 0; i < numberObjects_; i++) { 487 OsiBiLinear *obj = dynamic_cast< OsiBiLinear *>(object_[i]);487 OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(object_[i]); 488 488 if (obj) { 489 489 int xColumn = obj->xColumn(); … … 530 530 double gap = 0.0; 531 531 for (i = 0; i < numberObjects_; i++) { 532 OsiBiLinear *obj = dynamic_cast< OsiBiLinear *>(object_[i]);532 OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(object_[i]); 533 533 if (obj) { 534 534 if (obj->xMeshSize() < 1.0 && obj->yMeshSize() < 1.0) { … … 552 552 double newGap = 0.0; 553 553 for (i = 0; i < numberObjects_; i++) { 554 OsiBiLinear *obj = dynamic_cast< OsiBiLinear *>(object_[i]);554 OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(object_[i]); 555 555 if (obj && (obj->branchingStrategy() & 8) == 0) { 556 556 if (obj->xMeshSize() < 1.0 && obj->yMeshSize() < 1.0) { … … 657 657 CbcCutGenerator *generator = cbcModel_->cutGenerator(iGenerator); 658 658 CglCutGenerator *gen = generator->generator(); 659 CglTemporary *gen2 = dynamic_cast< CglTemporary *>(gen);659 CglTemporary *gen2 = dynamic_cast< CglTemporary * >(gen); 660 660 if (gen2) { 661 661 double *solution2 = NULL; … … 702 702 CbcCutGenerator *generator = cbcModel_->cutGenerator(iGenerator); 703 703 CglCutGenerator *gen = generator->generator(); 704 CglTemporary *gen2 = dynamic_cast< CglTemporary *>(gen);704 CglTemporary *gen2 = dynamic_cast< CglTemporary * >(gen); 705 705 if (gen2) { 706 706 const double *solution = getColSolution(); … … 731 731 gradient[column2[i]] = element[i]; 732 732 for (i = startNonLinear_[iNon]; i < startNonLinear_[iNon + 1]; i++) { 733 OsiBiLinear *obj = dynamic_cast< OsiBiLinear *>(object_[whichNonLinear_[i]]);733 OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(object_[whichNonLinear_[i]]); 734 734 assert(obj); 735 735 int xColumn = obj->xColumn(); … … 809 809 //const double * columnUpper = modelPtr_->columnUpper(); 810 810 for (i = 0; i < numberObjects_; i++) { 811 OsiBiLinear *obj = dynamic_cast< OsiBiLinear *>(object_[i]);811 OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(object_[i]); 812 812 if (obj) { 813 813 int xColumn = obj->xColumn(); … … 1221 1221 double *sort = new double[nBi]; 1222 1222 nBi = nInt; 1223 const OsiObject **justBi = const_cast< const OsiObject **>(objects + nInt);1223 const OsiObject **justBi = const_cast< const OsiObject ** >(objects + nInt); 1224 1224 for (iColumn = 0; iColumn < numberColumns; iColumn++) { 1225 1225 if (quadraticObjective) … … 1419 1419 CoinZeroN(whichRows, numberRows2); 1420 1420 for (i = 0; i < numberObjects_; i++) { 1421 OsiBiLinear *obj = dynamic_cast< OsiBiLinear *>(object_[i]);1421 OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(object_[i]); 1422 1422 if (obj) { 1423 1423 int xyRow = obj->xyRow(); … … 1452 1452 whichNonLinear_ = new int[n]; 1453 1453 for (i = 0; i < numberObjects_; i++) { 1454 OsiBiLinear *obj = dynamic_cast< OsiBiLinear *>(object_[i]);1454 OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(object_[i]); 1455 1455 if (obj) { 1456 1456 int xyRow = obj->xyRow(); … … 1476 1476 const double *rowUpper = getRowUpper(); 1477 1477 for (int iObject = 0; iObject < numberObjects_; iObject++) { 1478 OsiBiLinear *obj = dynamic_cast< OsiBiLinear *>(object_[iObject]);1478 OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(object_[iObject]); 1479 1479 if (obj) { 1480 1480 int xyRow = obj->xyRow(); … … 1551 1551 int i; 1552 1552 for (i = 0; i < numberObjects_; i++) { 1553 OsiBiLinear *obj = dynamic_cast< OsiBiLinear *>(object_[i]);1553 OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(object_[i]); 1554 1554 if (obj) { 1555 1555 //obj->setBranchingStrategy(4); // ***** temp … … 1738 1738 int i; 1739 1739 for (i = 0; i < numberObjects_; i++) { 1740 OsiBiLinear *obj = dynamic_cast< OsiBiLinear *>(object_[i]);1740 OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(object_[i]); 1741 1741 if (obj) { 1742 1742 if (obj->xMeshSize() < 1.0 && obj->yMeshSize() < 1.0) { … … 1776 1776 int i; 1777 1777 for (i = 0; i < numberObjects_; i++) { 1778 OsiBiLinear *obj = dynamic_cast< OsiBiLinear *>(object_[i]);1778 OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(object_[i]); 1779 1779 if (obj) { 1780 1780 bool change = false; … … 1812 1812 int i; 1813 1813 for (i = 0; i < numberObjects_; i++) { 1814 OsiBiLinear *obj = dynamic_cast< OsiBiLinear *>(object_[i]);1814 OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(object_[i]); 1815 1815 if (obj) { 1816 1816 if (obj->xMeshSize() < 1.0 && obj->yMeshSize() < 1.0) { … … 2510 2510 CbcModel *cbcModel = &model2; 2511 2511 OsiSolverInterface *osiModel = model2.solver(); 2512 OsiClpSolverInterface *osiclpModel = dynamic_cast< OsiClpSolverInterface *>(osiModel);2512 OsiClpSolverInterface *osiclpModel = dynamic_cast< OsiClpSolverInterface * >(osiModel); 2513 2513 ClpSimplex *clpModel = osiclpModel->getModelPtr(); 2514 2514 … … 2607 2607 cbcModel->initialSolve(); 2608 2608 cbcModel->branchAndBound(); 2609 OsiSolverLinearizedQuadratic *solver3 = dynamic_cast< OsiSolverLinearizedQuadratic *>(model2.solver());2609 OsiSolverLinearizedQuadratic *solver3 = dynamic_cast< OsiSolverLinearizedQuadratic * >(model2.solver()); 2610 2610 assert(solver3); 2611 2611 solution = solver3->bestSolution(); … … 2665 2665 const double *upper = getColUpper(); 2666 2666 for (int iObject = 0; iObject < numberObjects_; iObject++) { 2667 OsiSimpleInteger *obj = dynamic_cast< OsiSimpleInteger *>(object_[iObject]);2667 OsiSimpleInteger *obj = dynamic_cast< OsiSimpleInteger * >(object_[iObject]); 2668 2668 if (obj && (obj->priority() < biLinearPriority_ || biLinearPriority_ <= 0)) { 2669 2669 int iColumn = obj->columnNumber(); … … 2692 2692 memset(mark, 0, numberColumns); 2693 2693 for (int iObject = 0; iObject < numberObjects_; iObject++) { 2694 OsiSimpleInteger *obj = dynamic_cast< OsiSimpleInteger *>(object_[iObject]);2694 OsiSimpleInteger *obj = dynamic_cast< OsiSimpleInteger * >(object_[iObject]); 2695 2695 if (obj && obj->priority() < biLinearPriority_) { 2696 2696 int iColumn = obj->columnNumber(); … … 2700 2700 mark[iColumn] = 1; 2701 2701 } 2702 OsiBiLinear *objB = dynamic_cast< OsiBiLinear *>(object_[iObject]);2702 OsiBiLinear *objB = dynamic_cast< OsiBiLinear * >(object_[iObject]); 2703 2703 if (objB) { 2704 2704 // if one or both continuous then fix one … … 2723 2723 newSolver.loadFromCoinModel(tempModel, true); 2724 2724 for (int iObject = 0; iObject < numberObjects_; iObject++) { 2725 OsiSimpleInteger *obj = dynamic_cast< OsiSimpleInteger *>(object_[iObject]);2725 OsiSimpleInteger *obj = dynamic_cast< OsiSimpleInteger * >(object_[iObject]); 2726 2726 if (obj && obj->priority() < biLinearPriority_) { 2727 2727 int iColumn = obj->columnNumber(); … … 2731 2731 newSolver.setColUpper(iColumn, value); 2732 2732 } 2733 OsiBiLinear *objB = dynamic_cast< OsiBiLinear *>(object_[iObject]);2733 OsiBiLinear *objB = dynamic_cast< OsiBiLinear * >(object_[iObject]); 2734 2734 if (objB) { 2735 2735 // if one or both continuous then fix one … … 2752 2752 CbcModel *cbcModel = &model; 2753 2753 OsiSolverInterface *osiModel = model.solver(); 2754 OsiClpSolverInterface *osiclpModel = dynamic_cast< OsiClpSolverInterface *>(osiModel);2754 OsiClpSolverInterface *osiclpModel = dynamic_cast< OsiClpSolverInterface * >(osiModel); 2755 2755 ClpSimplex *clpModel = osiclpModel->getModelPtr(); 2756 2756 CglProbing probing; … … 2933 2933 int n = 0; 2934 2934 for (i = startNonLinear_[iNon]; i < startNonLinear_[iNon + 1]; i++) { 2935 OsiBiLinear *obj = dynamic_cast< OsiBiLinear *>(object_[whichNonLinear_[i]]);2935 OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(object_[whichNonLinear_[i]]); 2936 2936 assert(obj); 2937 2937 int xColumn = obj->xColumn(); … … 3216 3216 int numberChanged = 0; 3217 3217 for (int iObject = 0; iObject < numberObjects_; iObject++) { 3218 OsiBiLinear *obj = dynamic_cast< OsiBiLinear *>(object_[iObject]);3218 OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(object_[iObject]); 3219 3219 if (obj) { 3220 3220 numberChanged += obj->updateCoefficients(lower, upper, objective, matrix, &basis_); … … 3242 3242 int i; 3243 3243 for (i = 0; i < numberObjects_; i++) { 3244 OsiSimpleInteger *obj = dynamic_cast< OsiSimpleInteger *>(object_[i]);3244 OsiSimpleInteger *obj = dynamic_cast< OsiSimpleInteger * >(object_[i]); 3245 3245 if (obj) { 3246 3246 #ifndef NDEBUG … … 3261 3261 CoinZeroN(highPriority, numberColumns); 3262 3262 for (i = 0; i < numberObjects_; i++) { 3263 OsiSimpleInteger *obj = dynamic_cast< OsiSimpleInteger *>(object_[i]);3263 OsiSimpleInteger *obj = dynamic_cast< OsiSimpleInteger * >(object_[i]); 3264 3264 if (obj) { 3265 3265 int iColumn = obj->columnNumber(); … … 3422 3422 bool onOptimalPath = true; 3423 3423 for (i = 0; i < 7; i++) { 3424 if (static_cast< int>(upper[i]) != fake[i])3424 if (static_cast< int >(upper[i]) != fake[i]) 3425 3425 onOptimalPath = false; 3426 3426 } … … 3450 3450 CbcModel *cbcModel = &model; 3451 3451 OsiSolverInterface *osiModel = model.solver(); 3452 OsiClpSolverInterface *osiclpModel = dynamic_cast< OsiClpSolverInterface *>(osiModel);3452 OsiClpSolverInterface *osiclpModel = dynamic_cast< OsiClpSolverInterface * >(osiModel); 3453 3453 ClpSimplex *clpModel = osiclpModel->getModelPtr(); 3454 3454 CglProbing probing; … … 3589 3589 cbcModel->setMaximumSolutions(1); // just getting a solution 3590 3590 #ifdef JJF_ZERO 3591 OsiClpSolverInterface *osiclpModel = dynamic_cast< OsiClpSolverInterface *>(cbcModel->solver());3591 OsiClpSolverInterface *osiclpModel = dynamic_cast< OsiClpSolverInterface * >(cbcModel->solver()); 3592 3592 ClpSimplex *clpModel = osiclpModel->getModelPtr(); 3593 3593 const double *element = clpModel->matrix()->getMutableElements(); … … 3797 3797 } 3798 3798 boundElementAction action; 3799 action.affect = static_cast< unsigned char>(upperBoundAffected ? 1 : 0);3800 action.ubUsed = static_cast< unsigned char>(useUpperBound ? 1 : 0);3799 action.affect = static_cast< unsigned char >(upperBoundAffected ? 1 : 0); 3800 action.ubUsed = static_cast< unsigned char >(useUpperBound ? 1 : 0); 3801 3801 action.type = 2; 3802 action.affected = static_cast< short int>(whichVariable);3802 action.affected = static_cast< short int >(whichVariable); 3803 3803 action.multiplier = multiplier; 3804 3804 affected_[numberAffected_++] = action; … … 3907 3907 return 0; 3908 3908 OsiSolverLink *clpSolver 3909 = dynamic_cast< OsiSolverLink *>(model_->solver());3909 = dynamic_cast< OsiSolverLink * >(model_->solver()); 3910 3910 assert(clpSolver); 3911 3911 double newSolutionValue = clpSolver->bestObjectiveValue(); … … 4105 4105 weight /= sum; 4106 4106 valueInfeasibility = lastNonZero - firstNonZero + 1; 4107 valueInfeasibility *= 0.5 / static_cast< double>(numberMembers_);4107 valueInfeasibility *= 0.5 / static_cast< double >(numberMembers_); 4108 4108 //#define DISTANCE 4109 4109 #ifdef DISTANCE … … 4495 4495 OsiOldLinkBranchingObject::branch(OsiSolverInterface *solver) 4496 4496 { 4497 const OsiOldLink *set = dynamic_cast< const OsiOldLink *>(originalObject_);4497 const OsiOldLink *set = dynamic_cast< const OsiOldLink * >(originalObject_); 4498 4498 assert(set); 4499 4499 int way = (!branchIndex_) ? (2 * firstBranch_ - 1) : -(2 * firstBranch_ - 1); … … 4543 4543 void OsiOldLinkBranchingObject::print(const OsiSolverInterface *solver) 4544 4544 { 4545 const OsiOldLink *set = dynamic_cast< const OsiOldLink *>(originalObject_);4545 const OsiOldLink *set = dynamic_cast< const OsiOldLink * >(originalObject_); 4546 4546 assert(set); 4547 4547 int way = (!branchIndex_) ? (2 * firstBranch_ - 1) : -(2 * firstBranch_ - 1); … … 4829 4829 for (i = numberExistingObjects - 1; i >= 0; i--) { 4830 4830 const OsiObject *obj = objects[i]; 4831 const OsiBiLinear *obj2 = dynamic_cast< const OsiBiLinear *>(obj);4831 const OsiBiLinear *obj2 = dynamic_cast< const OsiBiLinear * >(obj); 4832 4832 if (obj2) { 4833 4833 if (xColumn_ == obj2->xColumn_ && !xDone) { … … 4962 4962 for (i = 0; i < nAdd; i++) { 4963 4963 CoinBigIndex iStart = starts[i]; 4964 coinModel->addRow(static_cast< int>(starts[i + 1] - iStart),4964 coinModel->addRow(static_cast< int >(starts[i + 1] - iStart), 4965 4965 index + iStart, element + iStart, 4966 4966 rowLower[i], rowUpper[i]); … … 5060 5060 for (i = 0; i < 4; i++) { 5061 5061 CoinBigIndex iStart = starts[i]; 5062 coinModel->addColumn(static_cast< int>(starts[i + 1] - iStart),5062 coinModel->addColumn(static_cast< int >(starts[i + 1] - iStart), 5063 5063 index + iStart, element + iStart, columnLower[i], 5064 5064 columnUpper[i], objective[i]); … … 5080 5080 for (i = numberExistingObjects - 1; i >= 0; i--) { 5081 5081 const OsiObject *obj = objects[i]; 5082 const OsiBiLinear *obj2 = dynamic_cast< const OsiBiLinear *>(obj);5082 const OsiBiLinear *obj2 = dynamic_cast< const OsiBiLinear * >(obj); 5083 5083 if (obj2) { 5084 5084 if (xColumn_ == obj2->xColumn_ && !xDone) { … … 6547 6547 int chosen) 6548 6548 : OsiTwoWayBranchingObject(solver, set, way, separator) 6549 , chosen_(static_cast< short int>(chosen))6549 , chosen_(static_cast< short int >(chosen)) 6550 6550 { 6551 6551 assert(chosen_ >= 0 && chosen_ < 2); … … 6582 6582 OsiBiLinearBranchingObject::branch(OsiSolverInterface *solver) 6583 6583 { 6584 const OsiBiLinear *set = dynamic_cast< const OsiBiLinear *>(originalObject_);6584 const OsiBiLinear *set = dynamic_cast< const OsiBiLinear * >(originalObject_); 6585 6585 assert(set); 6586 6586 int way = (!branchIndex_) ? (2 * firstBranch_ - 1) : -(2 * firstBranch_ - 1); … … 6593 6593 bool OsiBiLinearBranchingObject::boundBranch() const 6594 6594 { 6595 const OsiBiLinear *set = dynamic_cast< const OsiBiLinear *>(originalObject_);6595 const OsiBiLinear *set = dynamic_cast< const OsiBiLinear * >(originalObject_); 6596 6596 assert(set); 6597 6597 return (set->branchingStrategy() & 4) != 0; … … 6600 6600 void OsiBiLinearBranchingObject::print(const OsiSolverInterface * /*solver*/) 6601 6601 { 6602 const OsiBiLinear *set = dynamic_cast< const OsiBiLinear *>(originalObject_);6602 const OsiBiLinear *set = dynamic_cast< const OsiBiLinear * >(originalObject_); 6603 6603 assert(set); 6604 6604 int way = (!branchIndex_) ? (2 * firstBranch_ - 1) : -(2 * firstBranch_ - 1); … … 6648 6648 } 6649 6649 // See how many points 6650 numberPoints_ = static_cast< int>((xB[1] - xB[0] + 0.5 * xMesh) / xMesh);6650 numberPoints_ = static_cast< int >((xB[1] - xB[0] + 0.5 * xMesh) / xMesh); 6651 6651 // redo exactly 6652 xMeshSize_ = (xB[1] - xB[0]) / static_cast< double>(numberPoints_);6652 xMeshSize_ = (xB[1] - xB[0]) / static_cast< double >(numberPoints_); 6653 6653 numberPoints_++; 6654 6654 //#define KEEPXY … … 6863 6863 // new step size 6864 6864 assert(numberPoints_ > 2); 6865 step = CoinMax((1.5 * step) / static_cast< double>(numberPoints_ - 1), 0.5 * step);6865 step = CoinMax((1.5 * step) / static_cast< double >(numberPoints_ - 1), 0.5 * step); 6866 6866 xB[0] = CoinMax(xB[0], xValue - 0.5 * step); 6867 6867 xB[1] = CoinMin(xB[1], xValue + 0.5 * step); 6868 6868 // and now divide these 6869 mesh = (xB[1] - xB[0]) / static_cast< double>(numberPoints_ - 1);6869 mesh = (xB[1] - xB[0]) / static_cast< double >(numberPoints_ - 1); 6870 6870 } else { 6871 6871 // back to original … … 7042 7042 if (preferredWay_ >= 0 && !satisfied) 7043 7043 whichWay = preferredWay_; 7044 whichWay_ = static_cast< short int>(whichWay);7044 whichWay_ = static_cast< short int >(whichWay); 7045 7045 return infeasibility_; 7046 7046 } … … 7147 7147 printf("Checking quadratic model %x\n", model); 7148 7148 if (model) { 7149 ClpQuadraticObjective *quadraticObj = (dynamic_cast< ClpQuadraticObjective *>(model->objectiveAsObject()));7149 ClpQuadraticObjective *quadraticObj = (dynamic_cast< ClpQuadraticObjective * >(model->objectiveAsObject())); 7150 7150 assert(quadraticObj); 7151 7151 CoinPackedMatrix *quadraticObjective = quadraticObj->quadraticObjective(); … … 7410 7410 assert(fabs(floor(gap + 0.5) - gap) < 1.0e-5); 7411 7411 whichColumn[numJ] = iColumn; 7412 bound[numJ] = static_cast< int>(gap);7412 bound[numJ] = static_cast< int >(gap); 7413 7413 size[numJ++] = triple.value(); 7414 7414 offset += triple.value() * lowerColumn; … … 7958 7958 assert(solver_ == info->solver_); 7959 7959 // Only has to work with Clp 7960 OsiSolverInterface *solverA = const_cast< OsiSolverInterface *>(solver_);7961 OsiSolverLink *solver = dynamic_cast< OsiSolverLink *>(solverA);7960 OsiSolverInterface *solverA = const_cast< OsiSolverInterface * >(solver_); 7961 OsiSolverLink *solver = dynamic_cast< OsiSolverLink * >(solverA); 7962 7962 assert(solver); 7963 7963 int numberObjects = solver->numberObjects(); … … 7976 7976 for (i = 0; i < numberObjects; i++) { 7977 7977 OsiObject *obj = objects[i]; 7978 OsiBiLinear *objB = dynamic_cast< OsiBiLinear *>(obj);7978 OsiBiLinear *objB = dynamic_cast< OsiBiLinear * >(obj); 7979 7979 if (!objB) 7980 7980 objects[numObj++] = obj; … … 7988 7988 // See if any master objects 7989 7989 for (i = 0; i < numberObjectsToUse_; i++) { 7990 OsiUsesBiLinear *obj = dynamic_cast< OsiUsesBiLinear *>(objects[i]);7990 OsiUsesBiLinear *obj = dynamic_cast< OsiUsesBiLinear * >(objects[i]); 7991 7991 if (obj) 7992 7992 obj->addBiLinearObjects(solver); … … 8126 8126 infeasibility_ = 0.0; 8127 8127 for (int i = 0; i < numberBiLinear_; i++) { 8128 OsiBiLinear *obj = dynamic_cast< OsiBiLinear *>(objects_[i]);8128 OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(objects_[i]); 8129 8129 assert(obj); 8130 8130 //obj->getPseudoShadow(info); … … 8147 8147 if (preferredWay_ >= 0 && !satisfied) 8148 8148 whichWay = preferredWay_; 8149 whichWay_ = static_cast< short int>(whichWay);8149 whichWay_ = static_cast< short int >(whichWay); 8150 8150 return infeasibility_; 8151 8151 } … … 8197 8197 for (i = 0; i < numberObjects; i++) { 8198 8198 OsiObject *obj = objects[i]; 8199 OsiBiLinear *objB = dynamic_cast< OsiBiLinear *>(obj);8199 OsiBiLinear *objB = dynamic_cast< OsiBiLinear * >(obj); 8200 8200 if (objB) { 8201 8201 if (objB->xColumn() == columnNumber_ || objB->yColumn() == columnNumber_) … … 8208 8208 for (i = 0; i < numberObjects; i++) { 8209 8209 OsiObject *obj = objects[i]; 8210 OsiBiLinear *objB = dynamic_cast< OsiBiLinear *>(obj);8210 OsiBiLinear *objB = dynamic_cast< OsiBiLinear * >(obj); 8211 8211 if (objB) { 8212 8212 if (objB->xColumn() == columnNumber_ || objB->yColumn() == columnNumber_) -
trunk/Cbc/src/CbcMipStartIO.cpp
r2465 r2467 30 30 31 31 int readMIPStart(CbcModel *model, const char *fileName, 32 vector< pair<string, double>> &colValues,32 vector< pair< string, double > > &colValues, 33 33 double & /*solObj*/) 34 34 { … … 63 63 double value = atof(col[2]); 64 64 65 colValues.push_back(pair< string, double>(string(name), value));65 colValues.push_back(pair< string, double >(string(name), value)); 66 66 } 67 67 } 68 68 69 69 if (colValues.size()) { 70 sprintf(printLine, "MIPStart values read for %d variables.", static_cast< int>(colValues.size()));70 sprintf(printLine, "MIPStart values read for %d variables.", static_cast< int >(colValues.size())); 71 71 model->messageHandler()->message(CBC_GENERAL, model->messages()) << printLine << CoinMessageEol; 72 72 if (colValues.size() < model->getNumCols()) { 73 73 int numberColumns = model->getNumCols(); 74 74 OsiSolverInterface *solver = model->solver(); 75 vector< pair<string, double>> fullValues;75 vector< pair< string, double > > fullValues; 76 76 /* for fast search of column names */ 77 map< string, int> colIdx;77 map< string, int > colIdx; 78 78 for (int i = 0; i < numberColumns; i++) { 79 fullValues.push_back(pair< string, double>(solver->getColName(i), 0.0));79 fullValues.push_back(pair< string, double >(solver->getColName(i), 0.0)); 80 80 colIdx[solver->getColName(i)] = i; 81 81 } 82 for (int i = 0; (i < static_cast< int>(colValues.size())); ++i) {83 map< string, int>::const_iterator mIt = colIdx.find(colValues[i].first);82 for (int i = 0; (i < static_cast< int >(colValues.size())); ++i) { 83 map< string, int >::const_iterator mIt = colIdx.find(colValues[i].first); 84 84 if (mIt != colIdx.end()) { 85 85 const int idx = mIt->second; … … 101 101 102 102 int computeCompleteSolution(CbcModel *model, 103 const vector< string> colNames,104 const std::vector< std::pair<std::string, double>> &colValues,103 const vector< string > colNames, 104 const std::vector< std::pair< std::string, double > > &colValues, 105 105 double *sol, double &obj) 106 106 { … … 112 112 bool foundIntegerSol = false; 113 113 OsiSolverInterface *lp = model->solver()->clone(); 114 map< string, int> colIdx;115 assert((static_cast< int>(colNames.size())) == lp->getNumCols());114 map< string, int > colIdx; 115 assert((static_cast< int >(colNames.size())) == lp->getNumCols()); 116 116 /* for fast search of column names */ 117 for (int i = 0; (i < static_cast< int>(colNames.size())); ++i)117 for (int i = 0; (i < static_cast< int >(colNames.size())); ++i) 118 118 colIdx[colNames[i]] = i; 119 119 … … 135 135 } 136 136 #endif 137 for (int i = 0; (i < static_cast< int>(colValues.size())); ++i) {138 map< string, int>::const_iterator mIt = colIdx.find(colValues[i].first);137 for (int i = 0; (i < static_cast< int >(colValues.size())); ++i) { 138 map< string, int >::const_iterator mIt = colIdx.find(colValues[i].first); 139 139 if (mIt == colIdx.end()) { 140 140 if (!notFound) … … 167 167 } 168 168 169 if (notFound >= ((static_cast< double>(colNames.size())) * 0.5)) {169 if (notFound >= ((static_cast< double >(colNames.size())) * 0.5)) { 170 170 sprintf(printLine, "Warning: %d column names were not found (e.g. %s) while filling solution.", notFound, colNotFound); 171 171 model->messageHandler()->message(CBC_GENERAL, model->messages()) … … 195 195 int numberObjects = model->numberObjects(); 196 196 for (int i = 0; i < numberObjects; i++) { 197 const OsiSOS *object = dynamic_cast< const OsiSOS *>(model->object(i));197 const OsiSOS *object = dynamic_cast< const OsiSOS * >(model->object(i)); 198 198 if (object) { 199 199 int n = object->numberMembers(); … … 274 274 /* some additional effort is needed to provide an integer solution */ 275 275 if (lp->getFractionalIndices().size() > 0) { 276 sprintf(printLine, "MIPStart solution provided values for %d of %d integer variables, %d variables are still fractional.", fixed, lp->getNumIntegers(), static_cast< int>(lp->getFractionalIndices().size()));276 sprintf(printLine, "MIPStart solution provided values for %d of %d integer variables, %d variables are still fractional.", fixed, lp->getNumIntegers(), static_cast< int >(lp->getFractionalIndices().size())); 277 277 model->messageHandler()->message(CBC_GENERAL, model->messages()) 278 278 << printLine << CoinMessageEol; -
trunk/Cbc/src/CbcMipStartIO.hpp
r2465 r2467 14 14 1 otherwise */ 15 15 int readMIPStart(CbcModel *model, const char *fileName, 16 std::vector< std::pair<std::string, double>> &colValues,16 std::vector< std::pair< std::string, double > > &colValues, 17 17 double &solObj); 18 18 … … 20 20 remaining variable values */ 21 21 int computeCompleteSolution(CbcModel *model, 22 const std::vector< std::string> colNames,23 const std::vector< std::pair<std::string, double>> &colValues,22 const std::vector< std::string > colNames, 23 const std::vector< std::pair< std::string, double > > &colValues, 24 24 double *sol, double &obj); 25 25 -
trunk/Cbc/src/CbcModel.cpp
r2465 r2467 434 434 else if (cost != objValue) 435 435 cost = -COIN_DBL_MAX; 436 int gap = static_cast< int>(upper[iColumn] - lower[iColumn]);436 int gap = static_cast< int >(upper[iColumn] - lower[iColumn]); 437 437 if (gap > 1) { 438 438 numberGeneralIntegerObj++; … … 506 506 int highPriority = (branchOnSatisfied) ? -999 : 100; 507 507 for (int i = 0; i < numberObjects_; i++) { 508 CbcSimpleInteger *thisOne = dynamic_cast< CbcSimpleInteger *>(object_[i]);508 CbcSimpleInteger *thisOne = dynamic_cast< CbcSimpleInteger * >(object_[i]); 509 509 object_[i]->setPriority(1000); 510 510 if (thisOne) { … … 517 517 #ifdef COIN_HAS_CLP 518 518 OsiClpSolverInterface *clpSolver 519 = dynamic_cast< OsiClpSolverInterface *>(solver_);519 = dynamic_cast< OsiClpSolverInterface * >(solver_); 520 520 if (clpSolver && createFake) { 521 521 // Create artificial objective to be used when all else fixed … … 592 592 #endif 593 593 for (int i = 0; i < numberObjects_; i++) { 594 CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger *>(object_[i]);594 CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(object_[i]); 595 595 if (obj) { 596 596 int iColumn = obj->columnNumber(); … … 1015 1015 double value = objValue * multiplier; 1016 1016 if (value < 2.1e9) { 1017 int nearest = static_cast< int>(floor(value + 0.5));1017 int nearest = static_cast< int >(floor(value + 0.5)); 1018 1018 if (fabs(value - floor(value + 0.5)) > 1.0e-8) { 1019 1019 increment = 0; … … 1045 1045 if (bigIntegers) { 1046 1046 // allow for 1.0 1047 increment = gcd(increment, static_cast< int>(multiplier));1047 increment = gcd(increment, static_cast< int >(multiplier)); 1048 1048 value = increment; 1049 1049 } … … 1443 1443 #ifdef COIN_HAS_CLP 1444 1444 OsiClpSolverInterface *clpSolver 1445 = dynamic_cast< OsiClpSolverInterface *>(copy1);1445 = dynamic_cast< OsiClpSolverInterface * >(copy1); 1446 1446 if (false && clpSolver) { 1447 1447 numberRows = clpSolver->getNumRows(); … … 1645 1645 } 1646 1646 int saveMoreSpecialOptions = moreSpecialOptions_; 1647 if (dynamic_cast< CbcTreeLocal *>(tree_))1647 if (dynamic_cast< CbcTreeLocal * >(tree_)) 1648 1648 specialOptions_ |= 4096 + 8192; 1649 1649 #ifdef COIN_HAS_CLP 1650 1650 { 1651 1651 OsiClpSolverInterface *clpSolver 1652 = dynamic_cast< OsiClpSolverInterface *>(solver_);1652 = dynamic_cast< OsiClpSolverInterface * >(solver_); 1653 1653 if (clpSolver) { 1654 1654 // pass in disaster handler … … 1716 1716 nOrig = CoinMax(nOrig, originalColumns[numberColumns - 1] + 1); 1717 1717 // try and redo debugger 1718 OsiRowCutDebugger *debugger = const_cast< OsiRowCutDebugger *>(solver_->getRowCutDebuggerAlways());1718 OsiRowCutDebugger *debugger = const_cast< OsiRowCutDebugger * >(solver_->getRowCutDebuggerAlways()); 1719 1719 if (debugger) { 1720 1720 if (numberColumns <= debugger->numberColumns()) … … 1755 1755 if (temp[jColumn] >= 0) { 1756 1756 int iObject = temp[jColumn]; 1757 CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger *>(originalObject[iObject]);1757 CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(originalObject[iObject]); 1758 1758 if (obj) 1759 1759 numberOldIntegers++; … … 1789 1789 if (temp[jColumn] >= 0) { 1790 1790 int iObject = temp[jColumn]; 1791 CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger *>(originalObject[iObject]);1791 CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(originalObject[iObject]); 1792 1792 if (obj) { 1793 1793 object_[numberIntegers_] = originalObject[iObject]->clone(); … … 1809 1809 if (temp[jColumn] >= 0) { 1810 1810 int iObject = temp[jColumn]; 1811 CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger *>(originalObject[iObject]);1811 CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(originalObject[iObject]); 1812 1812 if (!obj) { 1813 1813 object_[numberObjects_] = originalObject[iObject]->clone(); 1814 1814 // redo ids etc 1815 CbcObject *obj = dynamic_cast< CbcObject *>(object_[numberObjects_]);1815 CbcObject *obj = dynamic_cast< CbcObject * >(object_[numberObjects_]); 1816 1816 assert(obj); 1817 1817 obj->redoSequenceEtc(this, numberColumns, originalColumns); … … 1828 1828 #ifdef JJF_ZERO 1829 1829 // redo ids etc 1830 CbcObject *obj = dynamic_cast< CbcObject *>(object_[numberObjects_]);1830 CbcObject *obj = dynamic_cast< CbcObject * >(object_[numberObjects_]); 1831 1831 assert(obj); 1832 1832 obj->redoSequenceEtc(this, numberColumns, originalColumns); … … 1844 1844 const int *originalColumns = process->originalColumns(); 1845 1845 // try and redo debugger 1846 OsiRowCutDebugger *debugger = const_cast< OsiRowCutDebugger *>(solver_->getRowCutDebuggerAlways());1846 OsiRowCutDebugger *debugger = const_cast< OsiRowCutDebugger * >(solver_->getRowCutDebuggerAlways()); 1847 1847 if (debugger) 1848 1848 debugger->redoSolution(numberColumns, originalColumns); … … 1957 1957 // set all unset ones 1958 1958 for (int iObject = 0; iObject < numberObjects_; iObject++) { 1959 CbcObject *obj = dynamic_cast< CbcObject *>(object_[iObject]);1959 CbcObject *obj = dynamic_cast< CbcObject * >(object_[iObject]); 1960 1960 if (obj && !obj->preferredWay()) 1961 1961 obj->setPreferredWay(preferredWay_); … … 1968 1968 synchronizeModel(); 1969 1969 if (!solverCharacteristics_) { 1970 OsiBabSolver *solverCharacteristics = dynamic_cast< OsiBabSolver *>(solver_->getAuxiliaryInfo());1970 OsiBabSolver *solverCharacteristics = dynamic_cast< OsiBabSolver * >(solver_->getAuxiliaryInfo()); 1971 1971 if (solverCharacteristics) { 1972 1972 solverCharacteristics_ = solverCharacteristics; … … 1975 1975 OsiBabSolver defaultC; 1976 1976 solver_->setAuxiliaryInfo(&defaultC); 1977 solverCharacteristics_ = dynamic_cast< OsiBabSolver *>(solver_->getAuxiliaryInfo());1977 solverCharacteristics_ = dynamic_cast< OsiBabSolver * >(solver_->getAuxiliaryInfo()); 1978 1978 } 1979 1979 } … … 1995 1995 { 1996 1996 OsiClpSolverInterface *clpSolver 1997 = dynamic_cast< OsiClpSolverInterface *>(solver_);1997 = dynamic_cast< OsiClpSolverInterface * >(solver_); 1998 1998 if (clpSolver) { 1999 1999 ClpSimplex *clpSimplex = clpSolver->getModelPtr(); … … 2026 2026 int numberOdd = 0; 2027 2027 for (int i = 0; i < numberObjects_; i++) { 2028 CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger *>(object_[i]);2028 CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(object_[i]); 2029 2029 if (!obj) 2030 2030 numberOdd++; … … 2176 2176 if (numberOriginalObjects) { 2177 2177 for (int iObject = 0; iObject < numberObjects_; iObject++) { 2178 CbcObject *obj = dynamic_cast< CbcObject *>(object_[iObject]);2178 CbcObject *obj = dynamic_cast< CbcObject * >(object_[iObject]); 2179 2179 if (obj) { 2180 CbcSimpleInteger *obj2 = dynamic_cast< CbcSimpleInteger *>(obj);2180 CbcSimpleInteger *obj2 = dynamic_cast< CbcSimpleInteger * >(obj); 2181 2181 if (obj2) { 2182 2182 // back to Osi land … … 2184 2184 delete obj; 2185 2185 } else { 2186 OsiSimpleInteger *obj3 = dynamic_cast< OsiSimpleInteger *>(obj);2186 OsiSimpleInteger *obj3 = dynamic_cast< OsiSimpleInteger * >(obj); 2187 2187 if (!obj3) { 2188 OsiSOS *obj4 = dynamic_cast< OsiSOS *>(obj);2188 OsiSOS *obj4 = dynamic_cast< OsiSOS * >(obj); 2189 2189 if (!obj4) { 2190 CbcSOS *obj5 = dynamic_cast< CbcSOS *>(obj);2190 CbcSOS *obj5 = dynamic_cast< CbcSOS * >(obj); 2191 2191 if (obj5) { 2192 2192 // back to Osi land … … 2232 2232 if (!object_[i]->canDoHeuristics()) 2233 2233 numberOdd++; 2234 CbcSOS *obj = dynamic_cast< CbcSOS *>(object_[i]);2234 CbcSOS *obj = dynamic_cast< CbcSOS * >(object_[i]); 2235 2235 if (obj) 2236 2236 numberSOS++; … … 2336 2336 #ifdef COIN_HAS_CLP 2337 2337 OsiClpSolverInterface *clpSolver 2338 = dynamic_cast< OsiClpSolverInterface *>(solver_);2338 = dynamic_cast< OsiClpSolverInterface * >(solver_); 2339 2339 if (clpSolver) { 2340 2340 int specialOptions = clpSolver->getModelPtr()->specialOptions(); … … 2421 2421 // pass tolerance and increment to solver 2422 2422 OsiClpSolverInterface *clpSolver 2423 = dynamic_cast< OsiClpSolverInterface *>(solver_);2423 = dynamic_cast< OsiClpSolverInterface * >(solver_); 2424 2424 if (clpSolver) 2425 2425 clpSolver->setStuff(getIntegerTolerance(), getCutoffIncrement()); … … 2454 2454 */ 2455 2455 CbcCompareDefault *compareActual 2456 = dynamic_cast< CbcCompareDefault *>(nodeCompare_);2456 = dynamic_cast< CbcCompareDefault * >(nodeCompare_); 2457 2457 if (compareActual) { 2458 2458 compareActual->setBestPossible(direction * solver_->getObjValue()); … … 2584 2584 for (int i = 0; i < numberHeuristics_; i++) { 2585 2585 CbcHeuristicRINS *rins 2586 = dynamic_cast< CbcHeuristicRINS *>(heuristic_[i]);2586 = dynamic_cast< CbcHeuristicRINS * >(heuristic_[i]); 2587 2587 if (rins) { 2588 2588 rins->setLastNode(-100); … … 2629 2629 while (time >= COIN_INT_MAX) 2630 2630 time *= 0.5; 2631 newSeed = static_cast< unsigned int>(time);2631 newSeed = static_cast< unsigned int >(time); 2632 2632 } else if (newSeed < 0) { 2633 2633 newSeed = 123456789; 2634 2634 #ifdef COIN_HAS_CLP 2635 2635 OsiClpSolverInterface *clpSolver 2636 = dynamic_cast< OsiClpSolverInterface *>(solver_);2636 = dynamic_cast< OsiClpSolverInterface * >(solver_); 2637 2637 if (clpSolver) { 2638 2638 newSeed += clpSolver->getModelPtr()->randomNumberGenerator()->getSeed(); … … 2640 2640 #endif 2641 2641 } 2642 CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis *>(solver_->getEmptyWarmStart());2642 CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver_->getEmptyWarmStart()); 2643 2643 for (int i = 0; i < numberModels; i++) { 2644 2644 rootModels[i] = new CbcModel(*this); … … 2659 2659 #ifdef COIN_HAS_CLP 2660 2660 OsiClpSolverInterface *clpSolver 2661 = dynamic_cast< OsiClpSolverInterface *>(rootModels[i]->solver_);2661 = dynamic_cast< OsiClpSolverInterface * >(rootModels[i]->solver_); 2662 2662 #define NEW_RANDOM_BASIS 2663 2663 #ifdef NEW_RANDOM_BASIS … … 2680 2680 for (int iThrow = 0; iThrow < throwOut; iThrow++) { 2681 2681 double random = simplex->randomNumberGenerator()->randomDouble(); 2682 int iStart = static_cast< int>(random * numberRows);2682 int iStart = static_cast< int >(random * numberRows); 2683 2683 for (int j = iStart; j < numberRows; j++) { 2684 2684 if (simplex->getRowStatus(j) != ClpSimplex::basic) { … … 2691 2691 #else 2692 2692 double random = simplex->randomNumberGenerator()->randomDouble(); 2693 int bias = static_cast< int>(random * (numberIterations / 4));2693 int bias = static_cast< int >(random * (numberIterations / 4)); 2694 2694 simplex->setMaximumIterations(numberIterations / 2 + bias); 2695 2695 simplex->primal(); … … 3031 3031 initialCuts++; 3032 3032 nRead = fread(elements, sizeof(double), numberEntries + 2, fp); 3033 if (nRead != static_cast< size_t>(numberEntries + 2))3033 if (nRead != static_cast< size_t >(numberEntries + 2)) 3034 3034 throw("Error in fread"); 3035 3035 nRead = fread(indices, sizeof(int), numberEntries, fp); 3036 if (nRead != static_cast< size_t>(numberEntries))3036 if (nRead != static_cast< size_t >(numberEntries)) 3037 3037 throw("Error in fread"); 3038 3038 if (randomNumber > threshold) { … … 3125 3125 initialCuts++; 3126 3126 nRead = fread(elements, sizeof(double), numberEntries + 2, fp); 3127 if (nRead != static_cast< size_t>(numberEntries + 2))3127 if (nRead != static_cast< size_t >(numberEntries + 2)) 3128 3128 throw("Error in fread"); 3129 3129 nRead = fread(indices, sizeof(int), numberEntries, fp); 3130 if (nRead != static_cast< size_t>(numberEntries))3130 if (nRead != static_cast< size_t >(numberEntries)) 3131 3131 throw("Error in fread"); 3132 3132 } else { … … 3168 3168 throw("Error in fwrite"); 3169 3169 nWrite = fwrite(elements, sizeof(double), n + 2, fp); 3170 if (nWrite != static_cast< size_t>(n + 2))3170 if (nWrite != static_cast< size_t >(n + 2)) 3171 3171 throw("Error in fwrite"); 3172 3172 nWrite = fwrite(indices, sizeof(int), n, fp); 3173 if (nWrite != static_cast< size_t>(n))3173 if (nWrite != static_cast< size_t >(n)) 3174 3174 throw("Error in fwrite"); 3175 3175 } … … 3277 3277 for (int i = 0; i < numberHeuristics_; i++) { 3278 3278 CbcHeuristicRINS *rins 3279 = dynamic_cast< CbcHeuristicRINS *>(heuristic_[i]);3279 = dynamic_cast< CbcHeuristicRINS * >(heuristic_[i]); 3280 3280 if (rins) { 3281 3281 rins->setLastNode(-100); … … 3349 3349 if ((moreSpecialOptions_ & 2097152) != 0 && !parentModel_ && feasible) { 3350 3350 OsiClpSolverInterface *clpSolver 3351 = dynamic_cast< OsiClpSolverInterface *>(solver_);3351 = dynamic_cast< OsiClpSolverInterface * >(solver_); 3352 3352 if (clpSolver) 3353 3353 resolveClp(clpSolver, 0); … … 3386 3386 double time1 = CoinCpuTime(); 3387 3387 OsiClpSolverInterface *clpSolver 3388 = dynamic_cast< OsiClpSolverInterface *>(solver_);3388 = dynamic_cast< OsiClpSolverInterface * >(solver_); 3389 3389 OsiCpxSolverInterface cpxSolver; 3390 3390 double direction = clpSolver->getObjSense(); … … 3533 3533 // But make sure position is correct 3534 3534 OsiObject *obj2 = object_[numberObjects_]; 3535 obj = dynamic_cast< CbcObject *>(obj2);3535 obj = dynamic_cast< CbcObject * >(obj2); 3536 3536 assert(obj); 3537 3537 obj->setPosition(numberObjects_); … … 3542 3542 if (true) { 3543 3543 OsiClpSolverInterface *clpSolver 3544 = dynamic_cast< OsiClpSolverInterface *>(solver_);3544 = dynamic_cast< OsiClpSolverInterface * >(solver_); 3545 3545 if (clpSolver && !parentModel_) { 3546 3546 ClpSimplex *clpSimplex = clpSolver->getModelPtr(); … … 3592 3592 #ifdef COIN_HAS_CLP 3593 3593 OsiClpSolverInterface *clpSolver 3594 = dynamic_cast< OsiClpSolverInterface *>(solver_);3594 = dynamic_cast< OsiClpSolverInterface * >(solver_); 3595 3595 if (clpSolver) { 3596 3596 if (getCutoff() > 1.0e20) { … … 3637 3637 const double *saveUpper = continuousSolver_->getColUpper(); 3638 3638 for (int i = 0; i < numberObjects_; i++) { 3639 const CbcSimpleInteger *thisOne = dynamic_cast< const CbcSimpleInteger *>(object_[i]);3639 const CbcSimpleInteger *thisOne = dynamic_cast< const CbcSimpleInteger * >(object_[i]); 3640 3640 if (thisOne) { 3641 3641 int iColumn = thisOne->columnNumber(); … … 3666 3666 double direction = solver->getObjSense(); 3667 3667 solver->setDblParam(OsiDualObjectiveLimit, 1.0e50 * direction); 3668 CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis *>(solver->getEmptyWarmStart());3668 CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver->getEmptyWarmStart()); 3669 3669 solver->setWarmStart(basis); 3670 3670 delete basis; … … 4055 4055 generator_[numberCutGenerators_ - 1]->setTiming(true); 4056 4056 for (int i = 0; i < numberCutGenerators_; i++) { 4057 CglKnapsackCover *cutGen = dynamic_cast< CglKnapsackCover *>(generator_[i]->generator());4057 CglKnapsackCover *cutGen = dynamic_cast< CglKnapsackCover * >(generator_[i]->generator()); 4058 4058 if (cutGen) { 4059 4059 cutGen->createCliques(*fake, 2, 200, false); … … 4107 4107 "(active only) %d\n", 4108 4108 numberRowsAtContinuous_ + numberNewCuts_ + numberOldActiveCuts_); 4109 const CoinWarmStartBasis *debugws = dynamic_cast< const CoinWarmStartBasis *>(solver_->getWarmStart());4109 const CoinWarmStartBasis *debugws = dynamic_cast< const CoinWarmStartBasis * >(solver_->getWarmStart()); 4110 4110 debugws->print(); 4111 4111 delete debugws; … … 4118 4118 if (lastws) 4119 4119 delete lastws; 4120 lastws = dynamic_cast< CoinWarmStartBasis *>(solver_->getWarmStart());4120 lastws = dynamic_cast< CoinWarmStartBasis * >(solver_->getWarmStart()); 4121 4121 } 4122 4122 /* … … 4154 4154 // save pointer to root node - so can pick up bounds 4155 4155 if (!topOfTree_) 4156 topOfTree_ = dynamic_cast< CbcFullNodeInfo *>(newNode->nodeInfo());4156 topOfTree_ = dynamic_cast< CbcFullNodeInfo * >(newNode->nodeInfo()); 4157 4157 if (statistics_) { 4158 4158 if (numberNodes2_ == maximumStatistics_) { … … 4209 4209 { 4210 4210 OsiClpSolverInterface *clpSolver 4211 = dynamic_cast< OsiClpSolverInterface *>(solver_);4211 = dynamic_cast< OsiClpSolverInterface * >(solver_); 4212 4212 if (clpSolver && !parentModel_) { 4213 4213 clpSolver->computeLargestAway(); … … 4226 4226 */ 4227 4227 if (solver_->getRowCutDebuggerAlways()) { 4228 OsiRowCutDebugger *debuggerX = const_cast< OsiRowCutDebugger *>(solver_->getRowCutDebuggerAlways());4228 OsiRowCutDebugger *debuggerX = const_cast< OsiRowCutDebugger * >(solver_->getRowCutDebuggerAlways()); 4229 4229 const OsiRowCutDebugger *debugger = solver_->getRowCutDebugger(); 4230 4230 if (!debugger) { … … 4301 4301 for (i = 0; i < numberObjects_; i++) { 4302 4302 OsiObject *object = object_[i]; 4303 CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost *>(object);4303 CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object); 4304 4304 if (dynamicObject) { 4305 4305 numberInts++; … … 4361 4361 } 4362 4362 if (numberUp) 4363 averageUp /= static_cast< double>(numberUp);4363 averageUp /= static_cast< double >(numberUp); 4364 4364 else 4365 4365 averageUp = 0.0; 4366 4366 if (numberDown) 4367 averageDown /= static_cast< double>(numberDown);4367 averageDown /= static_cast< double >(numberDown); 4368 4368 else 4369 4369 averageDown = 0.0; … … 4374 4374 neverBranchedDown, neverBranchedUp); 4375 4375 printf("down average %g times (%d infeasible) average increase %g min/max times (%d,%d)\n", 4376 static_cast< double>(numberDown2) / numberDown, infeasibleTimesDown, averageDown,4376 static_cast< double >(numberDown2) / numberDown, infeasibleTimesDown, averageDown, 4377 4377 minTimesDown, maxTimesDown); 4378 4378 printf("up average %g times (%d infeasible) average increase %g min/max times (%d,%d)\n", 4379 static_cast< double>(numberUp2) / numberUp, infeasibleTimesUp, averageUp,4379 static_cast< double >(numberUp2) / numberUp, infeasibleTimesUp, averageUp, 4380 4380 minTimesUp, maxTimesUp); 4381 4381 } … … 4406 4406 #ifdef COIN_HAS_CLP 4407 4407 OsiClpSolverInterface *clpSolver 4408 = dynamic_cast< OsiClpSolverInterface *>(solver_);4408 = dynamic_cast< OsiClpSolverInterface * >(solver_); 4409 4409 if (clpSolver && ((specialOptions_ & 131072) == 0) && true) { 4410 4410 ClpSimplex *simplex = clpSolver->getModelPtr(); … … 4614 4614 if (!parallelMode()) { 4615 4615 if (kNode == DIVE_WHEN + 1 || numberConsecutiveInfeasible > 1) { 4616 CbcCompareDefault *compare = dynamic_cast< CbcCompareDefault *>(nodeCompare_);4616 CbcCompareDefault *compare = dynamic_cast< CbcCompareDefault * >(nodeCompare_); 4617 4617 // Don't interfere if user has replaced the compare function. 4618 4618 if (compare) { … … 5075 5075 if (doStatistics == 100) { 5076 5076 for (int i = 0; i < numberObjects_; i++) { 5077 CbcSimpleIntegerDynamicPseudoCost *obj = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost *>(object_[i]);5077 CbcSimpleIntegerDynamicPseudoCost *obj = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object_[i]); 5078 5078 if (obj) 5079 5079 obj->print(); … … 5200 5200 // Now print 5201 5201 if (numberSolutions) 5202 averageSolutionDepth /= static_cast< double>(numberSolutions);5202 averageSolutionDepth /= static_cast< double >(numberSolutions); 5203 5203 int numberSolved = numberNodes2_ - numberCutoff; 5204 5204 double averageNumberIterations2 = numberIterations_ - averageNumberIterations1 5205 5205 - numberIterationsAtContinuous; 5206 5206 if (numberCutoff) { 5207 averageCutoffDepth /= static_cast< double>(numberCutoff);5208 averageNumberIterations2 /= static_cast< double>(numberCutoff);5207 averageCutoffDepth /= static_cast< double >(numberCutoff); 5208 averageNumberIterations2 /= static_cast< double >(numberCutoff); 5209 5209 } 5210 5210 if (numberNodes2_) 5211 averageValue /= static_cast< double>(numberNodes2_);5211 averageValue /= static_cast< double >(numberNodes2_); 5212 5212 if (numberSolved) { 5213 averageNumberIterations1 /= static_cast< double>(numberSolved);5214 averageSolvedDepth /= static_cast< double>(numberSolved);5213 averageNumberIterations1 /= static_cast< double >(numberSolved); 5214 averageSolvedDepth /= static_cast< double >(numberSolved); 5215 5215 } 5216 5216 printf("%d solution(s) were found (by branching) at an average depth of %g\n", … … 5223 5223 numberSolved, averageSolvedDepth, averageNumberIterations1); 5224 5224 if (numberDown) { 5225 averageInfDown /= static_cast< double>(numberDown);5226 averageObjDown /= static_cast< double>(numberDown);5225 averageInfDown /= static_cast< double >(numberDown); 5226 averageObjDown /= static_cast< double >(numberDown); 5227 5227 } 5228 5228 printf("Down %d nodes (%d first, %d second) - %d cutoff, rest decrease numinf %g increase obj %g\n", … … 5230 5230 averageInfDown, averageObjDown); 5231 5231 if (numberUp) { 5232 averageInfUp /= static_cast< double>(numberUp);5233 averageObjUp /= static_cast< double>(numberUp);5232 averageInfUp /= static_cast< double >(numberUp); 5233 averageObjUp /= static_cast< double >(numberUp); 5234 5234 } 5235 5235 printf("Up %d nodes (%d first, %d second) - %d cutoff, rest decrease numinf %g increase obj %g\n", … … 5345 5345 { 5346 5346 OsiClpSolverInterface *clpSolver 5347 = dynamic_cast< OsiClpSolverInterface *>(solver_);5347 = dynamic_cast< OsiClpSolverInterface * >(solver_); 5348 5348 if (clpSolver) { 5349 5349 // Possible restore of pivot method … … 5413 5413 { 5414 5414 OsiClpSolverInterface *clpSolver 5415 = dynamic_cast< OsiClpSolverInterface *>(solver_);5415 = dynamic_cast< OsiClpSolverInterface * >(solver_); 5416 5416 if (clpSolver) 5417 clpSolver->setFakeObjective(reinterpret_cast< double *>(NULL));5417 clpSolver->setFakeObjective(reinterpret_cast< double * >(NULL)); 5418 5418 } 5419 5419 #endif … … 5431 5431 checkModel(); 5432 5432 if (!solverCharacteristics_) { 5433 OsiBabSolver *solverCharacteristics = dynamic_cast< OsiBabSolver *>(solver_->getAuxiliaryInfo());5433 OsiBabSolver *solverCharacteristics = dynamic_cast< OsiBabSolver * >(solver_->getAuxiliaryInfo()); 5434 5434 if (solverCharacteristics) { 5435 5435 solverCharacteristics_ = solverCharacteristics; … … 5438 5438 OsiBabSolver defaultC; 5439 5439 solver_->setAuxiliaryInfo(&defaultC); 5440 solverCharacteristics_ = dynamic_cast< OsiBabSolver *>(solver_->getAuxiliaryInfo());5440 solverCharacteristics_ = dynamic_cast< OsiBabSolver * >(solver_->getAuxiliaryInfo()); 5441 5441 } 5442 5442 } … … 5482 5482 "getEmptyBasis", "CbcModel"); 5483 5483 } 5484 emptyBasis = dynamic_cast< CoinWarmStartBasis *>(solver_->getEmptyWarmStart());5484 emptyBasis = dynamic_cast< CoinWarmStartBasis * >(solver_->getEmptyWarmStart()); 5485 5485 if (emptyBasis == 0) { 5486 5486 throw CoinError( … … 5489 5489 } 5490 5490 emptyBasis->setSize(0, 0); 5491 emptyWarmStart_ = dynamic_cast< CoinWarmStart *>(emptyBasis);5491 emptyWarmStart_ = dynamic_cast< CoinWarmStart * >(emptyBasis); 5492 5492 } 5493 5493 /* 5494 5494 Clone the empty basis object, resize it as requested, and return. 5495 5495 */ 5496 emptyBasis = dynamic_cast< CoinWarmStartBasis *>(emptyWarmStart_->clone());5496 emptyBasis = dynamic_cast< CoinWarmStartBasis * >(emptyWarmStart_->clone()); 5497 5497 assert(emptyBasis); 5498 5498 if (ns != 0 || na != 0) … … 6157 6157 for (i = 0; i < numberObjects_; i++) { 6158 6158 object_[i] = (rhs.object_[i])->clone(); 6159 CbcObject *obj = dynamic_cast< CbcObject *>(object_[i]);6159 CbcObject *obj = dynamic_cast< CbcObject * >(object_[i]); 6160 6160 // Could be OsiObjects 6161 6161 if (obj) … … 6798 6798 for (int i = 0; i < numberCutGenerators_; i++) { 6799 6799 CglImplication *cutGen; 6800 cutGen = dynamic_cast< CglImplication *>(generator_[i]->generator());6800 cutGen = dynamic_cast< CglImplication * >(generator_[i]->generator()); 6801 6801 if (!cutGen) { 6802 6802 generator_[n] = generator_[i]; … … 6806 6806 cutGen->setProbingInfo(NULL); 6807 6807 delete generator_[i]; 6808 cutGen = dynamic_cast< CglImplication *>(virginGenerator_[i]->generator());6808 cutGen = dynamic_cast< CglImplication * >(virginGenerator_[i]->generator()); 6809 6809 assert(cutGen); 6810 6810 cutGen->setProbingInfo(NULL); … … 7595 7595 if (!defaultHandler) { 7596 7596 OsiClpSolverInterface *solver; 7597 solver = dynamic_cast< OsiClpSolverInterface *>(solver_);7597 solver = dynamic_cast< OsiClpSolverInterface * >(solver_); 7598 7598 if (solver) { 7599 7599 solver->passInMessageHandler(handler_); 7600 7600 solver->getModelPtr()->passInMessageHandler(handler_); 7601 7601 } 7602 solver = dynamic_cast< OsiClpSolverInterface *>(continuousSolver_);7602 solver = dynamic_cast< OsiClpSolverInterface * >(continuousSolver_); 7603 7603 if (solver) { 7604 7604 solver->passInMessageHandler(handler_); … … 7640 7640 #ifdef COIN_HAS_CLP 7641 7641 OsiClpSolverInterface *clpSolver 7642 = dynamic_cast< OsiClpSolverInterface *>(solver_);7642 = dynamic_cast< OsiClpSolverInterface * >(solver_); 7643 7643 ClpSimplex *clpSimplex = NULL; 7644 7644 if (clpSolver) … … 7770 7770 #ifdef COIN_HAS_CLP 7771 7771 OsiClpSolverInterface *clpSolver 7772 = dynamic_cast< OsiClpSolverInterface *>(solver_);7772 = dynamic_cast< OsiClpSolverInterface * >(solver_); 7773 7773 int saveClpOptions = 0; 7774 7774 if (clpSolver) … … 7986 7986 if (node && branchingMethod_) { 7987 7987 OsiBranchingObject *bobj = node->modifiableBranchingObject(); 7988 CbcBranchingObject *cbcobj = dynamic_cast< CbcBranchingObject *>(bobj);7988 CbcBranchingObject *cbcobj = dynamic_cast< CbcBranchingObject * >(bobj); 7989 7989 if (cbcobj && cbcobj->object()) { 7990 7990 CbcObject *object = cbcobj->object(); 7991 7991 CbcObjectUpdateData update = object->createUpdateInformation(solver_, node, cbcobj); 7992 7992 // have to compute object number as not saved 7993 CbcSimpleInteger *simpleObject = static_cast< CbcSimpleInteger *>(object);7993 CbcSimpleInteger *simpleObject = static_cast< CbcSimpleInteger * >(object); 7994 7994 int iObject = simpleObject->position(); 7995 7995 #ifndef NDEBUG … … 7997 7997 int jObject; 7998 7998 for (jObject = 0; jObject < numberObjects_; jObject++) { 7999 simpleObject = static_cast< CbcSimpleInteger *>(object_[jObject]);7999 simpleObject = static_cast< CbcSimpleInteger * >(object_[jObject]); 8000 8000 if (simpleObject->columnNumber() == iColumn) 8001 8001 break; … … 8012 8012 // update here 8013 8013 { 8014 CbcObject *object = dynamic_cast< CbcObject *>(update.object_);8014 CbcObject *object = dynamic_cast< CbcObject * >(update.object_); 8015 8015 if (object) 8016 8016 object->updateInformation(update); … … 8028 8028 double objectiveChange = lastObjective - objectiveValue; 8029 8029 if (objectiveChange > 1.0e-5) { 8030 CbcIntegerBranchingObject *branch = dynamic_cast< CbcIntegerBranchingObject *>(cbcobj);8030 CbcIntegerBranchingObject *branch = dynamic_cast< CbcIntegerBranchingObject * >(cbcobj); 8031 8031 assert(branch); 8032 8032 if (way < 0) { … … 8067 8067 #endif 8068 8068 } else { 8069 OsiIntegerBranchingObject *obj = dynamic_cast< OsiIntegerBranchingObject *>(bobj);8069 OsiIntegerBranchingObject *obj = dynamic_cast< OsiIntegerBranchingObject * >(bobj); 8070 8070 if (obj) { 8071 8071 const OsiObject *object = obj->originalObject(); … … 8118 8118 solver_->writeMpsNative("infeas.mps", NULL, NULL, 2); 8119 8119 solver_->getRowCutDebuggerAlways()->printOptimalSolution(*solver_); 8120 CoinWarmStartBasis *slack = dynamic_cast< CoinWarmStartBasis *>(solver_->getEmptyWarmStart());8120 CoinWarmStartBasis *slack = dynamic_cast< CoinWarmStartBasis * >(solver_->getEmptyWarmStart()); 8121 8121 solver_->setWarmStart(slack); 8122 8122 delete slack; … … 8286 8286 int numberColumns = solver_->getNumCols(); 8287 8287 CoinBigIndex maximumAdd = CoinMax(numberElements / 10, 8288 static_cast< CoinBigIndex>(2 * numberColumns))8288 static_cast< CoinBigIndex >(2 * numberColumns)) 8289 8289 + 100; 8290 8290 double *violations = new double[numberCuts]; … … 8507 8507 phase_ = 4; 8508 8508 CbcTreeLocal *tree 8509 = dynamic_cast< CbcTreeLocal *>(tree_);8509 = dynamic_cast< CbcTreeLocal * >(tree_); 8510 8510 if (tree) 8511 8511 tree->passInSolution(bestSolution_, heuristicValue); … … 8683 8683 } 8684 8684 solver_->applyRowCuts(numberToAdd, addCuts); 8685 CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis *>(solver_->getWarmStart());8685 CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver_->getWarmStart()); 8686 8686 assert(basis != NULL); // make sure not volume 8687 8687 /* dylp bug … … 8796 8796 nBadPasses++; 8797 8797 } else { 8798 goodDrop = (thisObj - cut_obj[j]) / static_cast< double>(nBadPasses + 1);8798 goodDrop = (thisObj - cut_obj[j]) / static_cast< double >(nBadPasses + 1); 8799 8799 break; 8800 8800 } … … 8808 8808 //minimumDrop = CoinMax(1.5*minimumDrop,1.0e-5*fabs(thisObj)); 8809 8809 double test = 0.1 * minimumDrop; 8810 double goodDrop = (thisObj - cut_obj[0]) / static_cast< double>(CUT_HISTORY);8810 double goodDrop = (thisObj - cut_obj[0]) / static_cast< double >(CUT_HISTORY); 8811 8811 double objValue = thisObj; 8812 8812 for (int j = CUT_HISTORY - 1; j >= 0; j--) { … … 8997 8997 int numberAdded = numberRows - numberRowsAtContinuous_; 8998 8998 if (numberAdded) { 8999 CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis *>(solver_->getWarmStart());8999 CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver_->getWarmStart()); 9000 9000 assert(basis != NULL); 9001 9001 int *added = new int[numberAdded]; … … 9111 9111 int numberRowsAdded = solver_->getNumRows() - numberRowsAtStart; 9112 9112 CoinBigIndex numberElementsAdded = solver_->getNumElements() - numberElementsAtStart; 9113 double densityOld = static_cast< double>(numberElementsAtStart) / static_cast<double>(numberRowsAtStart);9114 double densityNew = numberRowsAdded ? (static_cast< double>(numberElementsAdded)) / static_cast<double>(numberRowsAdded)9113 double densityOld = static_cast< double >(numberElementsAtStart) / static_cast< double >(numberRowsAtStart); 9114 double densityNew = numberRowsAdded ? (static_cast< double >(numberElementsAdded)) / static_cast< double >(numberRowsAdded) 9115 9115 : 0.0; 9116 9116 /* … … 9308 9308 */ 9309 9309 if (!numberNodes_) { 9310 double value = CoinMax(minimumDrop_, 0.005 * (thisObjective - startObjective) / static_cast< double>(currentPassNumber_));9310 double value = CoinMax(minimumDrop_, 0.005 * (thisObjective - startObjective) / static_cast< double >(currentPassNumber_)); 9311 9311 if (numberColumns < 200) 9312 9312 value = CoinMax(minimumDrop_, 0.1 * value); … … 9354 9354 */ 9355 9355 int iProbing = -1; 9356 double smallProblem = (0.2 * totalCuts) / static_cast< double>(numberActiveGenerators + 1.0e-100);9356 double smallProblem = (0.2 * totalCuts) / static_cast< double >(numberActiveGenerators + 1.0e-100); 9357 9357 for (i = 0; i < numberCutGenerators_; i++) { 9358 9358 int howOften = generator_[i]->howOften(); … … 9372 9372 */ 9373 9373 bool probingWasOnBut = false; 9374 CglProbing *probing = dynamic_cast< CglProbing *>(generator_[i]->generator());9374 CglProbing *probing = dynamic_cast< CglProbing * >(generator_[i]->generator()); 9375 9375 if (probing && !numberNodes_) { 9376 9376 if (generator_[i]->numberCutsInTotal()) { 9377 9377 // If large number of probing - can be biased 9378 smallProblem = (0.2 * (totalCuts - generator_[i]->numberCutsInTotal())) / static_cast< double>(numberActiveGenerators - 1 + 1.0e-100);9378 smallProblem = (0.2 * (totalCuts - generator_[i]->numberCutsInTotal())) / static_cast< double >(numberActiveGenerators - 1 + 1.0e-100); 9379 9379 } 9380 9380 iProbing = i; … … 9491 9491 */ 9492 9492 if (generator_[i]->whatDepth() < 0 || howOften != -1) { 9493 int k = static_cast< int>(sqrt(smallProblem / thisCuts));9493 int k = static_cast< int >(sqrt(smallProblem / thisCuts)); 9494 9494 /* 9495 9495 Not objective improvement, set to new frequency, otherwise turn off. … … 9580 9580 // increment cut counts 9581 9581 generator_[i]->incrementNumberCutsActive(count[i]); 9582 CglStored *stored = dynamic_cast< CglStored *>(generator_[i]->generator());9582 CglStored *stored = dynamic_cast< CglStored * >(generator_[i]->generator()); 9583 9583 if (stored && !generator_[i]->numberCutsInTotal()) 9584 9584 continue; … … 9635 9635 // probing->setRowCuts(0); 9636 9636 for (int i = 0; i < numberObjects_; i++) { 9637 CbcSimpleIntegerDynamicPseudoCost *obj = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost *>(object_[i]);9637 CbcSimpleIntegerDynamicPseudoCost *obj = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object_[i]); 9638 9638 if (obj) 9639 9639 obj->setMethod(1); … … 9671 9671 #ifdef COIN_HAS_CLP 9672 9672 OsiClpSolverInterface *clpSolver 9673 = dynamic_cast< OsiClpSolverInterface *>(solver_);9673 = dynamic_cast< OsiClpSolverInterface * >(solver_); 9674 9674 if (clpSolver) { 9675 9675 // Maybe solver might like to know only column bounds will change … … 9682 9682 #ifdef COIN_HAS_CLP 9683 9683 OsiClpSolverInterface *clpSolver 9684 = dynamic_cast< OsiClpSolverInterface *>(solver_);9684 = dynamic_cast< OsiClpSolverInterface * >(solver_); 9685 9685 if (clpSolver) { 9686 9686 // make sure factorization can't carry over … … 9694 9694 #ifdef COIN_HAS_CLP 9695 9695 OsiClpSolverInterface *clpSolver 9696 = dynamic_cast< OsiClpSolverInterface *>(solver_);9696 = dynamic_cast< OsiClpSolverInterface * >(solver_); 9697 9697 if (clpSolver) { 9698 9698 // Maybe solver might like to know only column bounds will change … … 9722 9722 #ifdef CHECK_CUT_COUNTS 9723 9723 if (feasible) { 9724 CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis *>(solver_->getWarmStart());9724 CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver_->getWarmStart()); 9725 9725 printf("solveWithCuts: Number of rows at end (only active cuts) %d\n", 9726 9726 numberRowsAtContinuous_ + numberNewCuts_ + numberOldActiveCuts_); … … 9825 9825 numberRowCutsAfter = theseCuts.sizeRowCuts(); 9826 9826 if (fullScan && generator_[i]->howOften() == 1000000 + SCANCUTS_PROBING) { 9827 CglProbing *probing = dynamic_cast< CglProbing *>(generator_[i]->generator());9827 CglProbing *probing = dynamic_cast< CglProbing * >(generator_[i]->generator()); 9828 9828 if (probing && (numberRowCutsBefore < numberRowCutsAfter || numberColumnCutsBefore < theseCuts.sizeColCuts())) { 9829 9829 // switch on … … 10085 10085 int problemStatus = -1; 10086 10086 OsiClpSolverInterface *clpSolver 10087 = dynamic_cast< OsiClpSolverInterface *>(solver_);10087 = dynamic_cast< OsiClpSolverInterface * >(solver_); 10088 10088 if (clpSolver) 10089 10089 problemStatus = clpSolver->getModelPtr()->status(); … … 10100 10100 int i; 10101 10101 int kCut = 0; 10102 ws = dynamic_cast< const CoinWarmStartBasis *>(solver_->getWarmStart());10102 ws = dynamic_cast< const CoinWarmStartBasis * >(solver_->getWarmStart()); 10103 10103 /* 10104 10104 Scan the basis entries of the old cuts generated prior to this round of cut … … 10300 10300 #ifdef COIN_HAS_CLP 10301 10301 OsiClpSolverInterface *clpSolver 10302 = dynamic_cast< OsiClpSolverInterface *>(solver_);10302 = dynamic_cast< OsiClpSolverInterface * >(solver_); 10303 10303 #endif 10304 10304 /* … … 10503 10503 value = fabs(cost) * multiplier; 10504 10504 if (value < 2.1e9) { 10505 int nearest = static_cast< int>(floor(value + 0.5));10505 int nearest = static_cast< int >(floor(value + 0.5)); 10506 10506 assert(fabs(value - floor(value + 0.5)) < 1.0e-8); 10507 10507 if (!increment) … … 10706 10706 } 10707 10707 } 10708 int iUpper = static_cast< int>(floor(upperValue + 1.0e-5));10709 int iLower = static_cast< int>(ceil(lowerValue - 1.0e-5));10708 int iUpper = static_cast< int >(floor(upperValue + 1.0e-5)); 10709 int iLower = static_cast< int >(ceil(lowerValue - 1.0e-5)); 10710 10710 /* 10711 10711 What do we have? If the row upper bound is greater than 1-numberM1, this … … 10847 10847 printf("%d cliques of average size %g found, %d P1, %d M1\n", 10848 10848 numberCliques, 10849 (static_cast< double>(totalP1 + totalM1)) / (static_cast<double>(numberCliques)),10849 (static_cast< double >(totalP1 + totalM1)) / (static_cast< double >(numberCliques)), 10850 10850 totalP1, totalM1); 10851 10851 else … … 10938 10938 // zero out 10939 10939 for (int i = 0; i < numberObjects_; i++) { 10940 CbcSimpleIntegerDynamicPseudoCost *obj1 = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost *>(object_[i]);10940 CbcSimpleIntegerDynamicPseudoCost *obj1 = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object_[i]); 10941 10941 if (obj1) { 10942 10942 //assert (obj1->downShadowPrice()>0.0); … … 11216 11216 } 11217 11217 if (numberIntegers) { 11218 double averagePrice = (0.5 * (upSum + downSum)) / static_cast< double>(numberIntegers);11218 double averagePrice = (0.5 * (upSum + downSum)) / static_cast< double >(numberIntegers); 11219 11219 //averagePrice *= 0.1; 11220 11220 averagePrice *= 100.0; … … 11229 11229 delete[] columnWeight; 11230 11230 if (numberIntegers) { 11231 double smallDown = 0.0001 * (downSum / static_cast< double>(numberIntegers));11232 double smallUp = 0.0001 * (upSum / static_cast< double>(numberIntegers));11231 double smallDown = 0.0001 * (downSum / static_cast< double >(numberIntegers)); 11232 double smallUp = 0.0001 * (upSum / static_cast< double >(numberIntegers)); 11233 11233 #define PSEUDO_FACTOR 5.0e-1 11234 11234 double pseudoFactor = PSEUDO_FACTOR; … … 11236 11236 //pseudoFactor=0.0; 11237 11237 for (int i = 0; i < numberObjects_; i++) { 11238 CbcSimpleIntegerDynamicPseudoCost *obj1 = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost *>(object_[i]);11238 CbcSimpleIntegerDynamicPseudoCost *obj1 = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object_[i]); 11239 11239 if (obj1 && obj1->upShadowPrice() >= 0.0) { 11240 11240 int iColumn = obj1->columnNumber(); … … 11325 11325 heuristic_[i]->setModel(this); 11326 11326 for (i = 0; i < numberObjects_; i++) { 11327 CbcObject *obj = dynamic_cast< CbcObject *>(object_[i]);11327 CbcObject *obj = dynamic_cast< CbcObject * >(object_[i]); 11328 11328 if (obj) { 11329 11329 obj->setModel(this); … … 11335 11335 11336 11336 if (!solverCharacteristics_) { 11337 OsiBabSolver *solverCharacteristics = dynamic_cast< OsiBabSolver *>(solver_->getAuxiliaryInfo());11337 OsiBabSolver *solverCharacteristics = dynamic_cast< OsiBabSolver * >(solver_->getAuxiliaryInfo()); 11338 11338 if (solverCharacteristics) { 11339 11339 solverCharacteristics_ = solverCharacteristics; … … 11342 11342 OsiBabSolver defaultC; 11343 11343 solver_->setAuxiliaryInfo(&defaultC); 11344 solverCharacteristics_ = dynamic_cast< OsiBabSolver *>(solver_->getAuxiliaryInfo());11344 solverCharacteristics_ = dynamic_cast< OsiBabSolver * >(solver_->getAuxiliaryInfo()); 11345 11345 } 11346 11346 } … … 11402 11402 for (iObject = 0; iObject < numberObjects_; iObject++) { 11403 11403 iPriority = CoinMax(iPriority, object_[iObject]->priority()); 11404 CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger *>(oldObject[iObject]);11404 CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(oldObject[iObject]); 11405 11405 if (obj) { 11406 11406 int iColumn = obj->columnNumber(); … … 11416 11416 if (!nObjects) { 11417 11417 OsiClpSolverInterface *clpSolver 11418 = dynamic_cast< OsiClpSolverInterface *>(solver_);11418 = dynamic_cast< OsiClpSolverInterface * >(solver_); 11419 11419 if (clpSolver && (clpSolver->numberSOS() || clpSolver->numberObjects())) { 11420 11420 // deal with sos … … 11440 11440 OsiObject **osiObjects = clpSolver->objects(); 11441 11441 for (int i = 0; i < numberObjects; i++) { 11442 OsiSOS *obj = dynamic_cast< OsiSOS *>(osiObjects[i]);11442 OsiSOS *obj = dynamic_cast< OsiSOS * >(osiObjects[i]); 11443 11443 if (obj) { 11444 11444 int type = obj->setType(); … … 11505 11505 bool allDynamic = true; 11506 11506 for (iObject = 0; iObject < numberObjects_; iObject++) { 11507 CbcSimpleInteger *obj1 = dynamic_cast< CbcSimpleInteger *>(object_[iObject]);11508 CbcSimpleIntegerPseudoCost *obj1a = dynamic_cast< CbcSimpleIntegerPseudoCost *>(object_[iObject]);11509 CbcSimpleIntegerDynamicPseudoCost *obj2 = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost *>(object_[iObject]);11507 CbcSimpleInteger *obj1 = dynamic_cast< CbcSimpleInteger * >(object_[iObject]); 11508 CbcSimpleIntegerPseudoCost *obj1a = dynamic_cast< CbcSimpleIntegerPseudoCost * >(object_[iObject]); 11509 CbcSimpleIntegerDynamicPseudoCost *obj2 = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object_[iObject]); 11510 11510 if (obj1 && !obj2) { 11511 11511 // replace … … 11535 11535 object_[iObject] = newObject; 11536 11536 } else if (!obj2) { 11537 CbcObject *obj3 = dynamic_cast< CbcObject *>(object_[iObject]);11537 CbcObject *obj3 = dynamic_cast< CbcObject * >(object_[iObject]); 11538 11538 if (!obj3 || !obj3->optionalObject()) 11539 11539 allDynamic = false; … … 11597 11597 if (columnLower[iColumn] || columnUpper[iColumn] != 1.0) 11598 11598 continue; 11599 if (!dynamic_cast< CbcSimpleInteger *>(object_[i]))11599 if (!dynamic_cast< CbcSimpleInteger * >(object_[i])) 11600 11600 continue; 11601 11601 int nAdd = 0; … … 11663 11663 sort[nAdd] = COIN_INT_MAX; 11664 11664 whichRow[nAdd] = COIN_INT_MAX; 11665 CbcSimpleIntegerDynamicPseudoCost *thisOne = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost *>(object_[i]);11665 CbcSimpleIntegerDynamicPseudoCost *thisOne = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object_[i]); 11666 11666 if (thisOne) { 11667 11667 assert(iColumn == thisOne->columnNumber()); … … 11669 11669 delete thisOne; 11670 11670 } else { 11671 CbcSimpleInteger *thisOne = dynamic_cast< CbcSimpleInteger *>(object_[i]);11671 CbcSimpleInteger *thisOne = dynamic_cast< CbcSimpleInteger * >(object_[i]); 11672 11672 assert(thisOne); 11673 11673 assert(iColumn == thisOne->columnNumber()); … … 11719 11719 if (((cMin > 0.0 && bEl < 0.0 && !rowUpper[iRow]) || (cMin < 0.0 && bEl > 0.0 && !rowLower[iRow])) && cMin * cMax > 0.0 && fabs(bEl) > largeRatio2 * largestC) { 11720 11720 // forces to zero 11721 CbcSwitchingBinary *object = dynamic_cast< CbcSwitchingBinary *>(object_[i]);11721 CbcSwitchingBinary *object = dynamic_cast< CbcSwitchingBinary * >(object_[i]); 11722 11722 if (!object) { 11723 11723 // create empty one 11724 CbcSimpleIntegerDynamicPseudoCost *thisOne = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost *>(object_[i]);11724 CbcSimpleIntegerDynamicPseudoCost *thisOne = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object_[i]); 11725 11725 if (thisOne) { 11726 11726 assert(iColumn == thisOne->columnNumber()); … … 11728 11728 delete thisOne; 11729 11729 } else { 11730 CbcSimpleInteger *thisOne = dynamic_cast< CbcSimpleInteger *>(object_[i]);11730 CbcSimpleInteger *thisOne = dynamic_cast< CbcSimpleInteger * >(object_[i]); 11731 11731 assert(thisOne); 11732 11732 assert(iColumn == thisOne->columnNumber()); … … 11773 11773 n = 0; 11774 11774 for (int i = 0; i < numberObjects_; i++) { 11775 CbcSwitchingBinary *object = dynamic_cast< CbcSwitchingBinary *>(object_[i]);11775 CbcSwitchingBinary *object = dynamic_cast< CbcSwitchingBinary * >(object_[i]); 11776 11776 if (object) { 11777 11777 n += object->setAssociatedBounds(solver, cleanBasis); … … 11798 11798 int nBetween = 0; 11799 11799 for (int i = 0; i < numberObjects_; i++) { 11800 CbcSwitchingBinary *object = dynamic_cast< CbcSwitchingBinary *>(object_[i]);11800 CbcSwitchingBinary *object = dynamic_cast< CbcSwitchingBinary * >(object_[i]); 11801 11801 if (object) { 11802 11802 int state[3]; … … 11828 11828 int iObject; 11829 11829 for (iObject = 0; iObject < numberObjects_; iObject++) { 11830 CbcSimpleIntegerDynamicPseudoCost *obj2 = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost *>(object_[iObject]);11830 CbcSimpleIntegerDynamicPseudoCost *obj2 = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object_[iObject]); 11831 11831 if (obj2) { 11832 11832 // synchronize trust … … 11871 11871 int newIntegers = 0; 11872 11872 for (i = 0; i < numberObjects; i++) { 11873 CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger *>(objects[i]);11873 CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(objects[i]); 11874 11874 if (obj) { 11875 11875 int iColumn = obj->columnNumber(); … … 11881 11881 // and existing 11882 11882 for (i = 0; i < numberObjects_; i++) { 11883 CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger *>(object_[i]);11883 CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(object_[i]); 11884 11884 if (obj) { 11885 11885 int iColumn = obj->columnNumber(); … … 11931 11931 for (i = 0; i < numberObjects_; i++) { 11932 11932 if (object_[i]) { 11933 CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger *>(object_[i]);11933 CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(object_[i]); 11934 11934 if (obj) { 11935 11935 delete object_[i]; … … 11941 11941 // and rest of new 11942 11942 for (i = 0; i < numberObjects; i++) { 11943 CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger *>(objects[i]);11943 CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(objects[i]); 11944 11944 if (!obj) { 11945 11945 temp[n] = objects[i]->clone(); 11946 CbcObject *obj = dynamic_cast< CbcObject *>(temp[n]);11946 CbcObject *obj = dynamic_cast< CbcObject * >(temp[n]); 11947 11947 if (obj) 11948 11948 obj->setModel(this); … … 11976 11976 int newIntegers = 0; 11977 11977 for (i = 0; i < numberObjects; i++) { 11978 CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger *>(objects[i]);11978 CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(objects[i]); 11979 11979 if (obj) { 11980 11980 int iColumn = obj->columnNumber(); … … 11982 11982 newIntegers++; 11983 11983 } else { 11984 OsiSimpleInteger *obj2 = dynamic_cast< OsiSimpleInteger *>(objects[i]);11984 OsiSimpleInteger *obj2 = dynamic_cast< OsiSimpleInteger * >(objects[i]); 11985 11985 if (obj2) { 11986 11986 // Osi takes precedence … … 11993 11993 // and existing 11994 11994 for (i = 0; i < numberObjects_; i++) { 11995 CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger *>(object_[i]);11995 CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(object_[i]); 11996 11996 if (obj) { 11997 11997 int iColumn = obj->columnNumber(); … … 12042 12042 for (i = 0; i < numberObjects_; i++) { 12043 12043 if (object_[i]) { 12044 CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger *>(object_[i]);12044 CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(object_[i]); 12045 12045 if (obj) { 12046 12046 delete object_[i]; … … 12052 12052 // and rest of new 12053 12053 for (i = 0; i < numberObjects; i++) { 12054 CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger *>(objects[i]);12055 OsiSimpleInteger *obj2 = dynamic_cast< OsiSimpleInteger *>(objects[i]);12054 CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(objects[i]); 12055 OsiSimpleInteger *obj2 = dynamic_cast< OsiSimpleInteger * >(objects[i]); 12056 12056 if (!obj && !obj2) { 12057 12057 temp[n] = objects[i]->clone(); 12058 CbcObject *obj = dynamic_cast< CbcObject *>(temp[n]);12058 CbcObject *obj = dynamic_cast< CbcObject * >(temp[n]); 12059 12059 if (obj) 12060 12060 obj->setModel(this); … … 12133 12133 #ifdef COIN_HAS_CLP 12134 12134 OsiClpSolverInterface *clpContinuousSolver 12135 = dynamic_cast< OsiClpSolverInterface *>(continuousSolver_);12135 = dynamic_cast< OsiClpSolverInterface * >(continuousSolver_); 12136 12136 int modifiedTolerances = 0; 12137 12137 #ifndef CBC_LEAVE_PERTURBATION_ON_CHECK_SOLUTION … … 12191 12191 solver_ = continuousSolver_; 12192 12192 // save basis and solution 12193 CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis *>(solver_->getWarmStart());12193 CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver_->getWarmStart()); 12194 12194 assert(basis != NULL); 12195 12195 double *saveSolution = CoinCopyOfArray(solver_->getColSolution(), … … 12239 12239 if ((moreSpecialOptions2_ & 4) != 0) { 12240 12240 for (int i = 0; i < numberObjects_; i++) { 12241 CbcSwitchingBinary *object = dynamic_cast< CbcSwitchingBinary *>(object_[i]);12241 CbcSwitchingBinary *object = dynamic_cast< CbcSwitchingBinary * >(object_[i]); 12242 12242 if (object) { 12243 12243 int iColumn = object->columnNumber(); … … 12412 12412 if ((moreSpecialOptions2_ & 4) != 0) { 12413 12413 for (int i = 0; i < numberObjects_; i++) { 12414 CbcSwitchingBinary *object = dynamic_cast< CbcSwitchingBinary *>(object_[i]);12414 CbcSwitchingBinary *object = dynamic_cast< CbcSwitchingBinary * >(object_[i]); 12415 12415 if (object) { 12416 12416 int iColumn = object->columnNumber(); … … 12495 12495 // If relaxed then leave bounds on basic variables 12496 12496 if (fixVariables == -1 && (specialOptions_ & 16) == 0) { 12497 CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis *>(saveSolver->getWarmStart());12497 CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(saveSolver->getWarmStart()); 12498 12498 assert(basis != NULL); 12499 12499 #ifdef JJF_ZERO //ndef CBC_OTHER_SOLVER 12500 12500 for (i = 0; i < numberObjects_; i++) { 12501 CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger *>(object_[i]);12501 CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(object_[i]); 12502 12502 if (obj) { 12503 12503 int iColumn = obj->columnNumber(); … … 12522 12522 residual influence on initialSolve(). 12523 12523 */ 12524 CoinWarmStartBasis *slack = dynamic_cast< CoinWarmStartBasis *>(solver_->getEmptyWarmStart());12524 CoinWarmStartBasis *slack = dynamic_cast< CoinWarmStartBasis * >(solver_->getEmptyWarmStart()); 12525 12525 solver_->setWarmStart(slack); 12526 12526 delete slack; … … 12552 12552 #ifdef COIN_HAS_CLP 12553 12553 OsiClpSolverInterface *clpSolver 12554 = dynamic_cast< OsiClpSolverInterface *>(solver_);12554 = dynamic_cast< OsiClpSolverInterface * >(solver_); 12555 12555 if (clpSolver) { 12556 12556 clpSolver->getModelPtr()->writeBasis("feasible.bas", true); … … 12579 12579 specialOptions_ &= ~2; 12580 12580 if (!solver_->isProvenOptimal()) { 12581 CoinWarmStartBasis *slack = dynamic_cast< CoinWarmStartBasis *>(solver_->getEmptyWarmStart());12581 CoinWarmStartBasis *slack = dynamic_cast< CoinWarmStartBasis * >(solver_->getEmptyWarmStart()); 12582 12582 solver_->setWarmStart(slack); 12583 12583 delete slack; … … 12957 12957 double newObjectiveValue = cutoff; 12958 12958 if (solverCharacteristics_->solution(newObjectiveValue, 12959 const_cast< double *>(solution),12959 const_cast< double * >(solution), 12960 12960 numberColumns)) { 12961 12961 objectiveValue = newObjectiveValue; … … 13038 13038 double saveObjectiveValue = objectiveValue; 13039 13039 // save basis 13040 CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis *>(solver_->getWarmStart());13040 CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver_->getWarmStart()); 13041 13041 assert(basis != NULL); 13042 13042 objectiveValue = checkSolution(cutoff, solution, fixVariables, objectiveValue); … … 13051 13051 // try again with basic variables with original bounds 13052 13052 // save basis 13053 CoinWarmStartBasis *basis2 = dynamic_cast< CoinWarmStartBasis *>(solver_->getWarmStart());13053 CoinWarmStartBasis *basis2 = dynamic_cast< CoinWarmStartBasis * >(solver_->getWarmStart()); 13054 13054 assert(basis2 != NULL); 13055 13055 solver_->setWarmStart(basis); … … 13091 13091 } 13092 13092 for (i = 0; i < numberObjects_; i++) { 13093 CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger *>(object_[i]);13093 CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(object_[i]); 13094 13094 if (obj) { 13095 13095 int iColumn = obj->columnNumber(); … … 13634 13634 //probingInfo_->initializeFixing(); 13635 13635 for (iGen = 0; iGen < numberCutGenerators_; iGen++) { 13636 generator = dynamic_cast< CglProbing *>(generator_[iGen]->generator());13636 generator = dynamic_cast< CglProbing * >(generator_[iGen]->generator()); 13637 13637 if (generator) 13638 13638 break; … … 14344 14344 #ifdef COIN_HAS_CLP 14345 14345 OsiClpSolverInterface *clpSolver 14346 = dynamic_cast< OsiClpSolverInterface *>(solver);14346 = dynamic_cast< OsiClpSolverInterface * >(solver); 14347 14347 #endif 14348 14348 #ifdef CLIQUE_ANALYSIS … … 14496 14496 for (int iCutGenerator = 0; iCutGenerator < numberCutGenerators_; iCutGenerator++) { 14497 14497 CglCutGenerator *generator = generator_[iCutGenerator]->generator(); 14498 CglGomory *cgl1 = dynamic_cast< CglGomory *>(generator);14498 CglGomory *cgl1 = dynamic_cast< CglGomory * >(generator); 14499 14499 if (cgl1) { 14500 14500 cgl1->setLimitAtRoot(cgl1->getLimit()); 14501 14501 } 14502 CglTwomir *cgl2 = dynamic_cast< CglTwomir *>(generator);14502 CglTwomir *cgl2 = dynamic_cast< CglTwomir * >(generator); 14503 14503 if (cgl2) { 14504 14504 generator_[iCutGenerator]->setHowOften(-100); … … 14566 14566 for (int iCutGenerator = 0; iCutGenerator < numberCutGenerators_; iCutGenerator++) { 14567 14567 CglCutGenerator *generator = generator_[iCutGenerator]->generator(); 14568 CglGomory *cgl1 = dynamic_cast< CglGomory *>(generator);14568 CglGomory *cgl1 = dynamic_cast< CglGomory * >(generator); 14569 14569 if (cgl1) { 14570 14570 cgl1->setLimitAtRoot(cgl1->getLimit()); 14571 14571 } 14572 CglTwomir *cgl2 = dynamic_cast< CglTwomir *>(generator);14572 CglTwomir *cgl2 = dynamic_cast< CglTwomir * >(generator); 14573 14573 if (cgl2) { 14574 14574 generator_[iCutGenerator]->setHowOften(-100); … … 14786 14786 #ifdef COIN_HAS_CLP 14787 14787 OsiClpSolverInterface *clpSolver 14788 = dynamic_cast< OsiClpSolverInterface *>(solver_);14788 = dynamic_cast< OsiClpSolverInterface * >(solver_); 14789 14789 if (clpSolver) { 14790 14790 ClpSimplex *clpSimplex = clpSolver->getModelPtr(); … … 14932 14932 int nBranches = intParam_[CbcNumberBranches]; 14933 14933 if (nBranches) { 14934 double average = dblParam_[CbcSumChange] / static_cast< double>(nBranches);14934 double average = dblParam_[CbcSumChange] / static_cast< double >(nBranches); 14935 14935 dblParam_[CbcSmallChange] = CoinMax(average * 1.0e-5, dblParam_[CbcSmallestChange]); 14936 14936 dblParam_[CbcSmallChange] = CoinMax(dblParam_[CbcSmallChange], 1.0e-8); … … 15002 15002 && !cuts.sizeRowCuts()) { 15003 15003 OsiClpSolverInterface *clpSolver 15004 = dynamic_cast< OsiClpSolverInterface *>(solver_);15004 = dynamic_cast< OsiClpSolverInterface * >(solver_); 15005 15005 if (clpSolver) { 15006 15006 anyAction = newNode->chooseClpBranch(this, oldNode); … … 15016 15016 int save = 0; 15017 15017 OsiClpSolverInterface *clpSolver 15018 = dynamic_cast< OsiClpSolverInterface *>(solver_);15018 = dynamic_cast< OsiClpSolverInterface * >(solver_); 15019 15019 if (clpSolver && (moreSpecialOptions_ & 4194304) != 0) { 15020 15020 ClpSimplex *clpSimplex = clpSolver->getModelPtr(); … … 15087 15087 for (int i = 0; i < numberUpdateItems_; i++) { 15088 15088 CbcObjectUpdateData *update = updateItems_ + i; 15089 CbcObject *object = dynamic_cast< CbcObject *>(update->object_);15089 CbcObject *object = dynamic_cast< CbcObject * >(update->object_); 15090 15090 #ifndef NDEBUG 15091 15091 bool found = false; … … 15206 15206 "(active only) %d\n", 15207 15207 numberRowsAtContinuous_ + numberNewCuts_ + numberOldActiveCuts_); 15208 const CoinWarmStartBasis *debugws = dynamic_cast< const CoinWarmStartBasis *>(solver_->getWarmStart());15208 const CoinWarmStartBasis *debugws = dynamic_cast< const CoinWarmStartBasis * >(solver_->getWarmStart()); 15209 15209 debugws->print(); 15210 15210 delete debugws; … … 15214 15214 { 15215 15215 OsiBranchingObject *branchingObject = newNode->modifiableBranchingObject(); 15216 CbcGeneralBranchingObject *generalBranch = dynamic_cast< CbcGeneralBranchingObject *>(branchingObject);15216 CbcGeneralBranchingObject *generalBranch = dynamic_cast< CbcGeneralBranchingObject * >(branchingObject); 15217 15217 if (generalBranch && false) { 15218 15218 int numberProblems = generalBranch->numberSubProblems(); … … 15418 15418 solution = solver_->getColSolution(); 15419 15419 // Save current basis 15420 CoinWarmStartBasis *ws = dynamic_cast< CoinWarmStartBasis *>(solver_->getWarmStart());15420 CoinWarmStartBasis *ws = dynamic_cast< CoinWarmStartBasis * >(solver_->getWarmStart()); 15421 15421 assert(ws); 15422 15422 setBestSolutionBasis(*ws); … … 15589 15589 void *argBundle); 15590 15590 parallelHeuristics(nThisTime, 15591 static_cast< int>(sizeof(argBundle)),15591 static_cast< int >(sizeof(argBundle)), 15592 15592 parameters); 15593 15593 double cutoff = heuristicValue; … … 15759 15759 if (found >= 0) { 15760 15760 CbcTreeLocal *tree 15761 = dynamic_cast< CbcTreeLocal *>(tree_);15761 = dynamic_cast< CbcTreeLocal * >(tree_); 15762 15762 if (tree) 15763 15763 tree->passInSolution(bestSolution_, heuristicValue); … … 15779 15779 // delete FPump 15780 15780 CbcHeuristicFPump *pump 15781 = dynamic_cast< CbcHeuristicFPump *>(heuristic_[i]);15781 = dynamic_cast< CbcHeuristicFPump * >(heuristic_[i]); 15782 15782 if (pump && pump->feasibilityPumpOptions() < 1000000 15783 15783 && (specialOptions_ & 33554432) == 0) { … … 15834 15834 name.c_str(), howOften); 15835 15835 // change name 15836 name[0] = static_cast< char>(toupper(name[0]));15836 name[0] = static_cast< char >(toupper(name[0])); 15837 15837 fprintf(fp, "\"%s\",%s,%s,%s,%d,%d,%d);\n", 15838 15838 name.c_str(), normal ? "true" : "false", … … 15966 15966 double &originalUpper) 15967 15967 { 15968 const CbcSimpleInteger *integerObject = dynamic_cast< const CbcSimpleInteger *>(object);15968 const CbcSimpleInteger *integerObject = dynamic_cast< const CbcSimpleInteger * >(object); 15969 15969 if (integerObject) { 15970 15970 // get original bounds … … 15972 15972 originalUpper = integerObject->originalUpperBound(); 15973 15973 } else { 15974 const OsiSimpleInteger *integerObject = dynamic_cast< const OsiSimpleInteger *>(object);15974 const OsiSimpleInteger *integerObject = dynamic_cast< const OsiSimpleInteger * >(object); 15975 15975 assert(integerObject); 15976 15976 // get original bounds … … 16111 16111 OsiBranchingObject *branch2 = node->modifiableBranchingObject(); 16112 16112 #ifndef NDEBUG 16113 CbcBranchingObject *branch = dynamic_cast< CbcBranchingObject *>(branch2);16113 CbcBranchingObject *branch = dynamic_cast< CbcBranchingObject * >(branch2); 16114 16114 assert(branch); 16115 16115 #else 16116 CbcBranchingObject *branch = static_cast< CbcBranchingObject *>(branch2);16116 CbcBranchingObject *branch = static_cast< CbcBranchingObject * >(branch2); 16117 16117 #endif 16118 16118 #if 1 … … 16198 16198 #ifdef COIN_HAS_CLP 16199 16199 OsiClpSolverInterface *clpSolver 16200 = dynamic_cast< OsiClpSolverInterface *>(solver_);16200 = dynamic_cast< OsiClpSolverInterface * >(solver_); 16201 16201 if ((clpSolver || (specialOptions_ & 16384) != 0) && fastNodeDepth_ < -1 16202 16202 && (specialOptions_ & 2048) == 0) { … … 16251 16251 int nBranches = intParam_[CbcNumberBranches]; 16252 16252 if (nBranches) { 16253 double average = dblParam_[CbcSumChange] / static_cast< double>(nBranches);16253 double average = dblParam_[CbcSumChange] / static_cast< double >(nBranches); 16254 16254 info->smallChange_ = CoinMax(average * 1.0e-5, dblParam_[CbcSmallestChange]); 16255 16255 info->smallChange_ = CoinMax(info->smallChange_, 1.0e-8); … … 16428 16428 double largest = -1.0; 16429 16429 for (int i = 0; i < numberIntegers_; i++) { 16430 CbcSimpleIntegerDynamicPseudoCost *obj = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost *>(object_[i]);16430 CbcSimpleIntegerDynamicPseudoCost *obj = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object_[i]); 16431 16431 if (!obj) 16432 16432 continue; … … 16598 16598 solver_->getRowCutDebuggerAlways()->printOptimalSolution(*solver_); 16599 16599 solver_->writeMpsNative("infeas.mps", NULL, NULL, 2); 16600 CoinWarmStartBasis *slack = dynamic_cast< CoinWarmStartBasis *>(solver_->getEmptyWarmStart());16600 CoinWarmStartBasis *slack = dynamic_cast< CoinWarmStartBasis * >(solver_->getEmptyWarmStart()); 16601 16601 solver_->setWarmStart(slack); 16602 16602 delete slack; … … 16633 16633 //const double * bounds = nodeInfo->newBounds(); 16634 16634 const OsiBranchingObject *obj = node->branchingObject(); 16635 const CbcIntegerBranchingObject *objectI = dynamic_cast< const CbcIntegerBranchingObject *>(obj);16635 const CbcIntegerBranchingObject *objectI = dynamic_cast< const CbcIntegerBranchingObject * >(obj); 16636 16636 if (objectI) { 16637 const CbcSimpleInteger *object1 = dynamic_cast< const CbcSimpleInteger *>(objectI->object());16637 const CbcSimpleInteger *object1 = dynamic_cast< const CbcSimpleInteger * >(objectI->object()); 16638 16638 int iColumn1 = -1; 16639 16639 int way1 = 0; … … 16645 16645 double originalUpper1 = object1->originalUpperBound(); 16646 16646 // Unset all bounds from parents 16647 CbcPartialNodeInfo *partial = dynamic_cast< CbcPartialNodeInfo *>(nodeInfo);16647 CbcPartialNodeInfo *partial = dynamic_cast< CbcPartialNodeInfo * >(nodeInfo); 16648 16648 touched[iColumn1] = 1; 16649 16649 if (partial) { … … 16708 16708 continue; 16709 16709 OsiBranchingObject *obj = nodeLook->modifiableBranchingObject(); 16710 CbcIntegerBranchingObject *objectI = dynamic_cast< CbcIntegerBranchingObject *>(obj);16710 CbcIntegerBranchingObject *objectI = dynamic_cast< CbcIntegerBranchingObject * >(obj); 16711 16711 //const OsiObject * object2a = obj->originalObject(); 16712 16712 //assert (object2a); 16713 const CbcSimpleInteger *object2 = dynamic_cast< const CbcSimpleInteger *>(objectI->object());16713 const CbcSimpleInteger *object2 = dynamic_cast< const CbcSimpleInteger * >(objectI->object()); 16714 16714 if (nodeInfo->numberBranchesLeft() && object2) { 16715 16715 int iColumn2 = object2->columnNumber(); … … 16967 16967 for (i = 0; i < numberUpdateItems_; i++) { 16968 16968 CbcObjectUpdateData *update = updateItems_ + i; 16969 CbcObject *object = dynamic_cast< CbcObject *>(update->object_);16969 CbcObject *object = dynamic_cast< CbcObject * >(update->object_); 16970 16970 #ifndef NDEBUG 16971 16971 bool found = false; … … 17316 17316 if (nodeLook) { 17317 17317 OsiBranchingObject *obj = nodeLook->modifiableBranchingObject(); 17318 CbcIntegerBranchingObject *objectI = dynamic_cast< CbcIntegerBranchingObject *>(obj);17318 CbcIntegerBranchingObject *objectI = dynamic_cast< CbcIntegerBranchingObject * >(obj); 17319 17319 //const OsiObject * object2 = obj->orig 17320 17320 #ifndef NDEBUG 17321 const CbcSimpleInteger *object2 = dynamic_cast< const CbcSimpleInteger *>(objectI->object());17321 const CbcSimpleInteger *object2 = dynamic_cast< const CbcSimpleInteger * >(objectI->object()); 17322 17322 assert(object2); 17323 17323 assert(iColumn == object2->columnNumber()); … … 17336 17336 if (nodeLook) { 17337 17337 const OsiBranchingObject *obj = nodeLook->branchingObject(); 17338 const CbcIntegerBranchingObject *objectI = dynamic_cast< const CbcIntegerBranchingObject *>(obj);17338 const CbcIntegerBranchingObject *objectI = dynamic_cast< const CbcIntegerBranchingObject * >(obj); 17339 17339 //const OsiObject * object2 = obj->orig 17340 const CbcSimpleInteger *object2 = dynamic_cast< const CbcSimpleInteger *>(objectI->object());17340 const CbcSimpleInteger *object2 = dynamic_cast< const CbcSimpleInteger * >(objectI->object()); 17341 17341 assert(object2); 17342 17342 int iColumn2 = object2->columnNumber(); … … 17382 17382 #endif 17383 17383 for (i = 0; i < numberObjects_; i++) { 17384 CbcSimpleIntegerDynamicPseudoCost *obj = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost *>(object_[i]);17384 CbcSimpleIntegerDynamicPseudoCost *obj = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object_[i]); 17385 17385 if (!obj) 17386 17386 continue; … … 17526 17526 int nRoot = CoinMax(40000, 8 * numberRows + 4 * numberColumns); 17527 17527 for (int i = 0; i < numberHeuristics_; i++) { 17528 CbcHeuristicDive *heuristic = dynamic_cast< CbcHeuristicDive *>(heuristic_[i]);17528 CbcHeuristicDive *heuristic = dynamic_cast< CbcHeuristicDive * >(heuristic_[i]); 17529 17529 if (heuristic && heuristic->maxSimplexIterations() != COIN_INT_MAX) { 17530 17530 heuristic->setMaxSimplexIterations(nTree); … … 17572 17572 } else if (which <= numberSavedSolutions_) { 17573 17573 double *sol = savedSolutions_[which - 1]; 17574 assert(static_cast< int>(sol[0]) == solver_->getNumCols());17574 assert(static_cast< int >(sol[0]) == solver_->getNumCols()); 17575 17575 return sol[1]; 17576 17576 } else { … … 17586 17586 } else if (which <= numberSavedSolutions_) { 17587 17587 double *sol = savedSolutions_[which - 1]; 17588 assert(static_cast< int>(sol[0]) == solver_->getNumCols());17588 assert(static_cast< int >(sol[0]) == solver_->getNumCols()); 17589 17589 return sol + 2; 17590 17590 } else { … … 17606 17606 for (k = numberSavedSolutions_ - 1; k >= 0; k--) { 17607 17607 double *sol = savedSolutions_[k]; 17608 assert(static_cast< int>(sol[0]) == n);17608 assert(static_cast< int >(sol[0]) == n); 17609 17609 if (objectiveValue > sol[1]) 17610 17610 break; … … 17669 17669 if (!savePivotMethod && !parentModel_) { 17670 17670 OsiClpSolverInterface *clpSolver 17671 = dynamic_cast< OsiClpSolverInterface *>(solver_);17671 = dynamic_cast< OsiClpSolverInterface * >(solver_); 17672 17672 if (clpSolver && numberNodes_ >= numberNodes && numberNodes_ < 2 * numberNodes && clpSolver->getNumRows() < 10000) { 17673 17673 if (numberIterations_ < (numberSolves_ + numberNodes_) * 10) { … … 17675 17675 ClpSimplex *simplex = clpSolver->getModelPtr(); 17676 17676 ClpDualRowPivot *pivotMethod = simplex->dualRowPivot(); 17677 ClpDualRowDantzig *pivot = dynamic_cast< ClpDualRowDantzig *>(pivotMethod);17677 ClpDualRowDantzig *pivot = dynamic_cast< ClpDualRowDantzig * >(pivotMethod); 17678 17678 if (!pivot) { 17679 17679 savePivotMethod = pivotMethod->clone(true); … … 17764 17764 synchronizeModel(); // make sure everything that needs solver has it 17765 17765 if (!solverCharacteristics_) { 17766 OsiBabSolver *solverCharacteristics = dynamic_cast< OsiBabSolver *>(solver_->getAuxiliaryInfo());17766 OsiBabSolver *solverCharacteristics = dynamic_cast< OsiBabSolver * >(solver_->getAuxiliaryInfo()); 17767 17767 if (solverCharacteristics) { 17768 17768 solverCharacteristics_ = solverCharacteristics; … … 17771 17771 OsiBabSolver defaultC; 17772 17772 solver_->setAuxiliaryInfo(&defaultC); 17773 solverCharacteristics_ = dynamic_cast< OsiBabSolver *>(solver_->getAuxiliaryInfo());17773 solverCharacteristics_ = dynamic_cast< OsiBabSolver * >(solver_->getAuxiliaryInfo()); 17774 17774 } 17775 17775 } … … 17866 17866 if (objective[iColumn]) { 17867 17867 double value = fabs(objective[iColumn]) * multiplier; 17868 int nearest = static_cast< int>(floor(value + 0.5));17868 int nearest = static_cast< int >(floor(value + 0.5)); 17869 17869 if (fabs(value - floor(value + 0.5)) > 1.0e-8 || value > 2.1e9) { 17870 17870 increment = 0; … … 17901 17901 // do presolve - for now just clp but easy to get osi interface 17902 17902 OsiClpSolverInterface *clpSolver 17903 = dynamic_cast< OsiClpSolverInterface *>(cleanModel);17903 = dynamic_cast< OsiClpSolverInterface * >(cleanModel); 17904 17904 if (clpSolver) { 17905 17905 ClpSimplex *clp = clpSolver->getModelPtr(); … … 18102 18102 // do presolve - for now just clp but easy to get osi interface 18103 18103 OsiClpSolverInterface *clpSolver 18104 = dynamic_cast< OsiClpSolverInterface *>(solver_);18104 = dynamic_cast< OsiClpSolverInterface * >(solver_); 18105 18105 assert(clpSolver); 18106 18106 ClpSimplex *clp = clpSolver->getModelPtr(); … … 18155 18155 #ifdef COIN_HAS_CLP 18156 18156 OsiClpSolverInterface *clpSolver 18157 = dynamic_cast< OsiClpSolverInterface *>(solver_);18157 = dynamic_cast< OsiClpSolverInterface * >(solver_); 18158 18158 if (clpSolver) 18159 18159 clpSolver->setOptionalInteger(index); … … 18222 18222 #ifdef COIN_HAS_CLP 18223 18223 OsiClpSolverInterface *clpSolver 18224 = dynamic_cast< OsiClpSolverInterface *>(solver);18224 = dynamic_cast< OsiClpSolverInterface * >(solver); 18225 18225 if (clpSolver) { 18226 18226 double *dj = clpSolver->getModelPtr()->dualColumnSolution(); … … 18289 18289 int numberSOS2 = 0; 18290 18290 for (i = 0; i < numberObjects_; i++) { 18291 CbcSOS *objSOS = dynamic_cast< CbcSOS *>(object_[i]);18291 CbcSOS *objSOS = dynamic_cast< CbcSOS * >(object_[i]); 18292 18292 if (objSOS) { 18293 18293 int type = objSOS->sosType(); … … 18302 18302 memset(prohibited, 0, numberColumns); 18303 18303 for (i = 0; i < numberObjects_; i++) { 18304 CbcSOS *objSOS = dynamic_cast< CbcSOS *>(object_[i]);18304 CbcSOS *objSOS = dynamic_cast< CbcSOS * >(object_[i]); 18305 18305 if (objSOS) { 18306 18306 int type = objSOS->sosType(); … … 18359 18359 if (temp[jColumn] >= 0) { 18360 18360 int iObject = temp[jColumn]; 18361 CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger *>(originalObject[iObject]);18361 CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(originalObject[iObject]); 18362 18362 if (obj) 18363 18363 numberOldIntegers++; … … 18393 18393 if (temp[jColumn] >= 0) { 18394 18394 int iObject = temp[jColumn]; 18395 CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger *>(originalObject[iObject]);18395 CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(originalObject[iObject]); 18396 18396 if (obj) { 18397 18397 object_[numberIntegers_] = originalObject[iObject]->clone(); … … 18413 18413 if (temp[jColumn] >= 0) { 18414 18414 int iObject = temp[jColumn]; 18415 CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger *>(originalObject[iObject]);18415 CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(originalObject[iObject]); 18416 18416 if (!obj) { 18417 18417 object_[numberObjects_] = originalObject[iObject]->clone(); 18418 18418 // redo ids etc 18419 CbcObject *obj = dynamic_cast< CbcObject *>(object_[numberObjects_]);18419 CbcObject *obj = dynamic_cast< CbcObject * >(object_[numberObjects_]); 18420 18420 assert(obj); 18421 18421 obj->redoSequenceEtc(this, numberColumns, originalColumns); … … 18430 18430 object_[numberObjects_] = originalObject[iObject]->clone(); 18431 18431 // redo ids etc 18432 CbcObject *obj = static_cast< CbcObject *>(object_[numberObjects_]);18432 CbcObject *obj = static_cast< CbcObject * >(object_[numberObjects_]); 18433 18433 assert(obj); 18434 18434 obj->redoSequenceEtc(this, numberColumns, originalColumns); … … 18645 18645 const OsiObject *object = object_[i]; 18646 18646 #ifndef NDEBUG 18647 const CbcSimpleInteger *integerObject = dynamic_cast< const CbcSimpleInteger *>(object);18647 const CbcSimpleInteger *integerObject = dynamic_cast< const CbcSimpleInteger * >(object); 18648 18648 assert(integerObject); 18649 18649 #else 18650 const CbcSimpleInteger *integerObject = static_cast< const CbcSimpleInteger *>(object);18650 const CbcSimpleInteger *integerObject = static_cast< const CbcSimpleInteger * >(object); 18651 18651 #endif 18652 18652 // get original bounds … … 18777 18777 const OsiObject *object = object_[i]; 18778 18778 #ifndef NDEBUG 18779 const CbcSimpleInteger *integerObject = dynamic_cast< const CbcSimpleInteger *>(object);18779 const CbcSimpleInteger *integerObject = dynamic_cast< const CbcSimpleInteger * >(object); 18780 18780 assert(integerObject); 18781 18781 #else 18782 const CbcSimpleInteger *integerObject = static_cast< const CbcSimpleInteger *>(object);18782 const CbcSimpleInteger *integerObject = static_cast< const CbcSimpleInteger * >(object); 18783 18783 #endif 18784 18784 // get original bounds … … 18866 18866 static void *doRootCbcThread(void *voidInfo) 18867 18867 { 18868 CbcModel *model = reinterpret_cast< CbcModel *>(voidInfo);18868 CbcModel *model = reinterpret_cast< CbcModel * >(voidInfo); 18869 18869 #ifdef COIN_HAS_CLP 18870 18870 OsiClpSolverInterface *clpSolver 18871 = dynamic_cast< OsiClpSolverInterface *>(model->solver());18871 = dynamic_cast< OsiClpSolverInterface * >(model->solver()); 18872 18872 char general[200]; 18873 18873 if (clpSolver) { … … 18907 18907 #ifdef COIN_HAS_CLP 18908 18908 const OsiClpSolverInterface *clpSolver 18909 = dynamic_cast< const OsiClpSolverInterface *>(solver);18909 = dynamic_cast< const OsiClpSolverInterface * >(solver); 18910 18910 if (clpSolver && topOfTree_) { 18911 18911 int debugMode = 0; … … 19268 19268 mipStart_.clear(); 19269 19269 for (int i = 0; (i < count); ++i) 19270 mipStart_.push_back(std::pair< std::string, double>(std::string(colNames[i]), colValues[i]));19270 mipStart_.push_back(std::pair< std::string, double >(std::string(colNames[i]), colValues[i])); 19271 19271 } 19272 19272 #ifdef COIN_HAS_NTY … … 19287 19287 #ifdef COIN_HAS_CLP 19288 19288 OsiClpSolverInterface *clpSolver 19289 = dynamic_cast< OsiClpSolverInterface *>(solver_);19289 = dynamic_cast< OsiClpSolverInterface * >(solver_); 19290 19290 if (clpSolver) { 19291 19291 int numberColumns = clpSolver->getNumCols(); … … 19295 19295 int numberSOS = 0; 19296 19296 for (int i = 0; i < numberObjects_; i++) { 19297 CbcObject *obj = dynamic_cast< CbcObject *>(object_[i]);19298 CbcSimpleInteger *thisInt = dynamic_cast< CbcSimpleInteger *>(obj);19299 OsiSOS *objSOS1 = dynamic_cast< OsiSOS *>(obj);19300 CbcSOS *objSOS2 = dynamic_cast< CbcSOS *>(obj);19297 CbcObject *obj = dynamic_cast< CbcObject * >(object_[i]); 19298 CbcSimpleInteger *thisInt = dynamic_cast< CbcSimpleInteger * >(obj); 19299 OsiSOS *objSOS1 = dynamic_cast< OsiSOS * >(obj); 19300 CbcSOS *objSOS2 = dynamic_cast< CbcSOS * >(obj); 19301 19301 if (thisInt) { 19302 19302 clpSolver->setInteger(thisInt->columnNumber()); … … 19321 19321 numberSOS = 0; 19322 19322 for (int i = 0; i < numberObjects_; i++) { 19323 CbcObject *obj = dynamic_cast< CbcObject *>(object_[i]);19324 OsiSOS *objSOS1 = dynamic_cast< OsiSOS *>(obj);19325 CbcSOS *objSOS2 = dynamic_cast< CbcSOS *>(obj);19323 CbcObject *obj = dynamic_cast< CbcObject * >(object_[i]); 19324 OsiSOS *objSOS1 = dynamic_cast< OsiSOS * >(obj); 19325 CbcSOS *objSOS2 = dynamic_cast< CbcSOS * >(obj); 19326 19326 if (objSOS1 || objSOS2) { 19327 19327 int numberMembers; … … 19366 19366 #define ZERO_ODD_TOLERANCE 1.0e-14 19367 19367 #endif 19368 OsiClpSolverInterface *osiclp = dynamic_cast< OsiClpSolverInterface *>(solver);19368 OsiClpSolverInterface *osiclp = dynamic_cast< OsiClpSolverInterface * >(solver); 19369 19369 if (osiclp && osiclp->isProvenOptimal()) { 19370 19370 int numberColumns = osiclp->getNumCols(); … … 19434 19434 CbcModel::setupCleanVariables() 19435 19435 { 19436 OsiClpSolverInterface *osiclp = dynamic_cast< OsiClpSolverInterface *>(solver_);19436 OsiClpSolverInterface *osiclp = dynamic_cast< OsiClpSolverInterface * >(solver_); 19437 19437 int numberColumns = osiclp->getNumCols(); 19438 19438 char *cleanVariables = NULL; … … 19441 19441 memset(cleanVariables, 0, numberColumns); 19442 19442 for (int i = 0; i < numberObjects_; i++) { 19443 const CbcSimpleInteger *intvar = dynamic_cast< const CbcSimpleInteger *>(object_[i]);19444 const CbcSOS *sos = dynamic_cast< const CbcSOS *>(object_[i]);19443 const CbcSimpleInteger *intvar = dynamic_cast< const CbcSimpleInteger * >(object_[i]); 19444 const CbcSOS *sos = dynamic_cast< const CbcSOS * >(object_[i]); 19445 19445 if (intvar) { 19446 19446 #ifdef CLEAN_INTEGER_VARIABLES -
trunk/Cbc/src/CbcModel.hpp
r2465 r2467 2691 2691 //@} 2692 2692 2693 void setMIPStart(const std::vector< std::pair<std::string, double>> &mips)2693 void setMIPStart(const std::vector< std::pair< std::string, double > > &mips) 2694 2694 { 2695 2695 this->mipStart_ = mips; … … 2700 2700 void setMIPStart(int count, const char **colNames, const double colValues[]); 2701 2701 2702 const std::vector< std::pair<std::string, double>> &getMIPStart()2702 const std::vector< std::pair< std::string, double > > &getMIPStart() 2703 2703 { 2704 2704 return this->mipStart_; … … 2782 2782 values for integer variables which will be converted to a complete integer initial feasible solution 2783 2783 */ 2784 std::vector< std::pair<std::string, double>> mipStart_;2784 std::vector< std::pair< std::string, double > > mipStart_; 2785 2785 /** Warm start object produced by heuristic or strong branching 2786 2786 -
trunk/Cbc/src/CbcNode.cpp
r2465 r2467 140 140 */ 141 141 bool mustDeleteBasis; 142 const CoinWarmStartBasis *ws = dynamic_cast< const CoinWarmStartBasis *>(solver->getPointerToWarmStart(mustDeleteBasis));142 const CoinWarmStartBasis *ws = dynamic_cast< const CoinWarmStartBasis * >(solver->getPointerToWarmStart(mustDeleteBasis)); 143 143 assert(ws != NULL); // make sure not volume 144 144 //int numberArtificials = lastws->getNumArtificial(); … … 159 159 and new cuts (numberNewCuts). This will become the expanded basis. 160 160 */ 161 CoinWarmStartBasis *expanded = dynamic_cast< CoinWarmStartBasis *>(ws->clone());161 CoinWarmStartBasis *expanded = dynamic_cast< CoinWarmStartBasis * >(ws->clone()); 162 162 int iCompact = numberRowsAtContinuous + numberOldActiveCuts + numberNewCuts; 163 163 // int nPartial = numberRowsAtContinuous+currentNumberCuts; … … 349 349 else { 350 350 bool mustDeleteBasis; 351 const CoinWarmStartBasis *ws = dynamic_cast< const CoinWarmStartBasis *>(solver->getPointerToWarmStart(mustDeleteBasis));351 const CoinWarmStartBasis *ws = dynamic_cast< const CoinWarmStartBasis * >(solver->getPointerToWarmStart(mustDeleteBasis)); 352 352 assert(ws != NULL); // make sure not volume 353 353 //int numberArtificials = lastws->getNumArtificial(); … … 384 384 basis. Makes me (Lou) less nervous to compare apples to apples. 385 385 */ 386 CoinWarmStartBasis *expanded = dynamic_cast< CoinWarmStartBasis *>(ws->clone());386 CoinWarmStartBasis *expanded = dynamic_cast< CoinWarmStartBasis * >(ws->clone()); 387 387 int numberRowsAtContinuous = model->numberRowsAtContinuous(); 388 388 int iFull = numberRowsAtContinuous + model->currentNumberCuts() + numberNewCuts; … … 532 532 char *cleanVariables = NULL; 533 533 #ifdef COIN_HAS_CLP 534 OsiClpSolverInterface *osiclp = dynamic_cast< OsiClpSolverInterface *>(solver);534 OsiClpSolverInterface *osiclp = dynamic_cast< OsiClpSolverInterface * >(solver); 535 535 int saveClpOptions = 0; 536 536 if (osiclp) { … … 588 588 for (int i = 0; i < numberObjects; i++) { 589 589 OsiObject *object = model->modifiableObject(i); 590 const CbcSimpleInteger *thisOne = dynamic_cast< const CbcSimpleInteger *>(object);590 const CbcSimpleInteger *thisOne = dynamic_cast< const CbcSimpleInteger * >(object); 591 591 if (thisOne) { 592 592 int iColumn = thisOne->columnNumber(); … … 634 634 */ 635 635 CbcBranchDecision *decision = model->branchingMethod(); 636 CbcDynamicPseudoCostBranchingObject *dynamicBranchingObject = dynamic_cast< CbcDynamicPseudoCostBranchingObject *>(decision);636 CbcDynamicPseudoCostBranchingObject *dynamicBranchingObject = dynamic_cast< CbcDynamicPseudoCostBranchingObject * >(decision); 637 637 if (!decision || dynamicBranchingObject) 638 638 decision = new CbcBranchDefaultDecision(); … … 694 694 if (hotstartSolution) { 695 695 // we are doing hot start 696 const CbcSimpleInteger *thisOne = dynamic_cast< const CbcSimpleInteger *>(object);696 const CbcSimpleInteger *thisOne = dynamic_cast< const CbcSimpleInteger * >(object); 697 697 if (thisOne) { 698 698 int iColumn = thisOne->columnNumber(); … … 782 782 choice[iSmallest].upMovement = infeasibility; 783 783 delete choice[iSmallest].possibleBranch; 784 CbcObject *obj = dynamic_cast< CbcObject *>(object);784 CbcObject *obj = dynamic_cast< CbcObject * >(object); 785 785 assert(obj); 786 786 choice[iSmallest].possibleBranch = obj->createCbcBranch(solver, &usefulInfo, preferredWay); … … 812 812 int k = choice[0].objectNumber; 813 813 OsiObject *object = model->modifiableObject(k); 814 const CbcSimpleInteger *thisOne = dynamic_cast< const CbcSimpleInteger *>(object);814 const CbcSimpleInteger *thisOne = dynamic_cast< const CbcSimpleInteger * >(object); 815 815 assert(thisOne); 816 816 int iColumn = thisOne->columnNumber(); … … 826 826 bool roundAgain = false; 827 827 // get basis 828 CoinWarmStartBasis *ws = dynamic_cast< CoinWarmStartBasis *>(solver->getWarmStart());828 CoinWarmStartBasis *ws = dynamic_cast< CoinWarmStartBasis * >(solver->getWarmStart()); 829 829 if (!ws) 830 830 break; … … 871 871 choice[i].numIntInfeasDown = numberUnsatisfied_; 872 872 choice[i].fix = 0; // say not fixed 873 if (!dynamic_cast< const CbcSimpleInteger *>(model->object(choice[i].objectNumber)))873 if (!dynamic_cast< const CbcSimpleInteger * >(model->object(choice[i].objectNumber))) 874 874 allNormal = false; // Something odd so lets skip clever fast branching 875 875 if (!model->object(choice[i].objectNumber)->boundBranch()) … … 957 957 int *whichColumn = new int[2 * numberColumns]; 958 958 int nBound; 959 ClpSimplex *small = static_cast< ClpSimplexOther *>(clp)->crunch(rhs, whichRow, whichColumn, nBound, true);959 ClpSimplex *small = static_cast< ClpSimplexOther * >(clp)->crunch(rhs, whichRow, whichColumn, nBound, true); 960 960 if (!small) { 961 961 anyAction = -2; … … 1000 1000 int iObject = choice[i].objectNumber; 1001 1001 const OsiObject *object = model->object(iObject); 1002 const CbcSimpleInteger *simple = static_cast< const CbcSimpleInteger *>(object);1002 const CbcSimpleInteger *simple = static_cast< const CbcSimpleInteger * >(object); 1003 1003 int iSequence = simple->columnNumber(); 1004 1004 newLower[i] = ceil(saveSolution[iSequence]); … … 1035 1035 int iObject = choice[i].objectNumber; 1036 1036 const OsiObject *object = model->object(iObject); 1037 const CbcSimpleInteger *simple = static_cast< const CbcSimpleInteger *>(object);1037 const CbcSimpleInteger *simple = static_cast< const CbcSimpleInteger * >(object); 1038 1038 int iSequence = simple->columnNumber(); 1039 1039 which[i] = iSequence; … … 1632 1632 // get information on solver type 1633 1633 const OsiAuxInfo *auxInfo = solver->getAuxiliaryInfo(); 1634 const OsiBabSolver *auxiliaryInfo = dynamic_cast< const OsiBabSolver *>(auxInfo);1634 const OsiBabSolver *auxiliaryInfo = dynamic_cast< const OsiBabSolver * >(auxInfo); 1635 1635 if (!auxiliaryInfo) { 1636 1636 // use one from CbcModel … … 1645 1645 for (int i = model->numberIntegers(); i < numberObjects; i++) { 1646 1646 OsiObject *object = model->modifiableObject(i); 1647 CbcObject *obj = dynamic_cast< CbcObject *>(object);1647 CbcObject *obj = dynamic_cast< CbcObject * >(object); 1648 1648 if (!obj || !obj->optionalObject()) { 1649 1649 double infeasibility = object->checkInfeasibility(&usefulInfo); … … 1671 1671 for (int i = 0; i < numberRows; i++) 1672 1672 sumPi += fabs(pi[i]); 1673 sumPi /= static_cast< double>(numberRows);1673 sumPi /= static_cast< double >(numberRows); 1674 1674 // and scale back 1675 1675 sumPi *= 0.01; … … 1735 1735 for (int i = 0; i < numberObjects; i++) { 1736 1736 OsiObject *object = model->modifiableObject(i); 1737 const CbcSimpleInteger *thisOne = dynamic_cast< const CbcSimpleInteger *>(object);1737 const CbcSimpleInteger *thisOne = dynamic_cast< const CbcSimpleInteger * >(object); 1738 1738 if (thisOne) { 1739 1739 int iColumn = thisOne->columnNumber(); … … 1801 1801 for (i = 0; i < numberObjects; i++) { 1802 1802 OsiObject *object = model->modifiableObject(i); 1803 CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost *>(object);1803 CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object); 1804 1804 assert(dynamicObject); 1805 1805 int numberUp2 = 0; … … 1824 1824 } 1825 1825 if (numberUp) 1826 averageUp /= static_cast< double>(numberUp);1826 averageUp /= static_cast< double >(numberUp); 1827 1827 else 1828 1828 averageUp = 1.0; 1829 1829 if (numberDown) 1830 averageDown /= static_cast< double>(numberDown);1830 averageDown /= static_cast< double >(numberDown); 1831 1831 else 1832 1832 averageDown = 1.0; … … 1842 1842 char *cleanVariables = NULL; 1843 1843 #ifdef COIN_HAS_CLP 1844 OsiClpSolverInterface *osiclp = dynamic_cast< OsiClpSolverInterface *>(solver);1844 OsiClpSolverInterface *osiclp = dynamic_cast< OsiClpSolverInterface * >(solver); 1845 1845 int saveClpOptions = 0; 1846 1846 if (osiclp) { … … 1870 1870 for (i = 0; i < numberObjects; i++) { 1871 1871 OsiObject *object = model->modifiableObject(i); 1872 CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost *>(object);1872 CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object); 1873 1873 if (dynamicObject) { 1874 1874 if (dynamicObject->numberTimesUp()) { … … 1883 1883 } 1884 1884 if (numberUp) 1885 averageUp /= static_cast< double>(numberUp);1885 averageUp /= static_cast< double >(numberUp); 1886 1886 else 1887 1887 averageUp = 1.0; 1888 1888 if (numberDown) 1889 averageDown /= static_cast< double>(numberDown);1889 averageDown /= static_cast< double >(numberDown); 1890 1890 else 1891 1891 averageDown = 1.0; 1892 1892 for (i = 0; i < numberObjects; i++) { 1893 1893 OsiObject *object = model->modifiableObject(i); 1894 CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost *>(object);1894 CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object); 1895 1895 if (dynamicObject) { 1896 1896 if (!dynamicObject->numberTimesUp()) … … 2082 2082 for (i = 0; i < numberObjects; i++) { 2083 2083 OsiObject *object = model->modifiableObject(i); 2084 CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost *>(object);2084 CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object); 2085 2085 double infeasibility = object->checkInfeasibility(&usefulInfo); 2086 2086 int priorityLevel = object->priority(); 2087 2087 if (hotstartSolution) { 2088 2088 // we are doing hot start 2089 const CbcSimpleInteger *thisOne = dynamic_cast< const CbcSimpleInteger *>(object);2089 const CbcSimpleInteger *thisOne = dynamic_cast< const CbcSimpleInteger * >(object); 2090 2090 if (thisOne) { 2091 2091 int iColumn = thisOne->columnNumber(); … … 2191 2191 } else { 2192 2192 // see if SOS 2193 CbcSOS *sosObject = dynamic_cast< CbcSOS *>(object);2193 CbcSOS *sosObject = dynamic_cast< CbcSOS * >(object); 2194 2194 if (sosObject) { 2195 2195 gotDown = false; … … 2373 2373 for (int i = 0; i < numberObjects; i++) { 2374 2374 OsiObject *object = model->modifiableObject(i); 2375 CbcSimpleIntegerDynamicPseudoCost *obj = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost *>(object);2375 CbcSimpleIntegerDynamicPseudoCost *obj = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object); 2376 2376 assert(obj); 2377 2377 int iColumn = obj->columnNumber(); … … 2397 2397 bool roundAgain = false; 2398 2398 // get basis 2399 CoinWarmStartBasis *ws = dynamic_cast< CoinWarmStartBasis *>(solver->getWarmStart());2399 CoinWarmStartBasis *ws = dynamic_cast< CoinWarmStartBasis * >(solver->getWarmStart()); 2400 2400 if (!ws) 2401 2401 break; … … 2500 2500 int preferredWay; 2501 2501 object->infeasibility(&usefulInfo, preferredWay); 2502 CbcObject *obj = dynamic_cast< CbcObject *>(object);2502 CbcObject *obj = dynamic_cast< CbcObject * >(object); 2503 2503 assert(obj); 2504 2504 branch_ = obj->createCbcBranch(solver, &usefulInfo, preferredWay); 2505 2505 { 2506 CbcBranchingObject *branchObj = dynamic_cast< CbcBranchingObject *>(branch_);2506 CbcBranchingObject *branchObj = dynamic_cast< CbcBranchingObject * >(branch_); 2507 2507 assert(branchObj); 2508 2508 branchObj->way(preferredWay); … … 2534 2534 } else if (gap < 1.0e5) { 2535 2535 // maybe allow some not needed 2536 int extra = static_cast< int>((1.0e6 - needed) / numberRows);2536 int extra = static_cast< int >((1.0e6 - needed) / numberRows); 2537 2537 int nStored = numberObjects - optionalPenalties; 2538 2538 extra = CoinMin(extra, nStored); … … 2580 2580 int iObject = whichObject[j]; 2581 2581 OsiObject *object = model->modifiableObject(iObject); 2582 CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost *>(object);2582 CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object); 2583 2583 // Use this object's numberBeforeTrust 2584 2584 int numberBeforeTrustThis = dynamicObject->numberBeforeTrust(); … … 2601 2601 sort[j] = -min1; 2602 2602 } else if (numberThisDown < numberBeforeTrustThis || numberThisUp < numberBeforeTrustThis) { 2603 double invTrust = 1.0 / static_cast< double>(numberBeforeTrustThis);2603 double invTrust = 1.0 / static_cast< double >(numberBeforeTrustThis); 2604 2604 if (numberThisDown < numberBeforeTrustThis) { 2605 2605 double fraction = numberThisDown * invTrust; … … 2935 2935 int iObject = whichObject[iDo]; 2936 2936 OsiObject *object = model->modifiableObject(iObject); 2937 CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost *>(object);2937 CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object); 2938 2938 int iColumn = dynamicObject ? dynamicObject->columnNumber() : -1; 2939 2939 if (iColumn < 0 || orbits[iColumn] >= 0) … … 2965 2965 int iObject = whichObject[iDo]; 2966 2966 OsiObject *object = model->modifiableObject(iObject); 2967 CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost *>(object);2967 CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object); 2968 2968 int iColumn = dynamicObject ? dynamicObject->columnNumber() : numberColumns + iObject; 2969 2969 int preferredWay; … … 2982 2982 } 2983 2983 #endif 2984 CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger *>(object);2984 CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(object); 2985 2985 if (obj) { 2986 2986 if (choiceObject) { … … 2991 2991 } 2992 2992 } else {