Changeset 2467

Timestamp:

Jan 3, 2019 4:26:29 PM (4 months ago)

Author:

unxusr

Message:

spaces after angles

Location:

trunk/Cbc/src

Files:

• CbcBranchBase.cpp (modified) (3 diffs)
• CbcBranchCut.cpp (modified) (2 diffs)
• CbcBranchDefaultDecision.cpp (modified) (4 diffs)
• CbcBranchDynamic.cpp (modified) (9 diffs)
• CbcBranchLotsize.cpp (modified) (1 diff)
• CbcBranchToFixLots.cpp (modified) (2 diffs)
• CbcBranchingObject.hpp (modified) (1 diff)
• CbcClique.cpp (modified) (6 diffs)
• CbcCompareDefault.cpp (modified) (2 diffs)
• CbcCutGenerator.cpp (modified) (7 diffs)
• CbcEventHandler.hpp (modified) (1 diff)
• CbcFathomDynamicProgramming.cpp (modified) (8 diffs)
• CbcFollowOn.cpp (modified) (3 diffs)
• CbcFullNodeInfo.cpp (modified) (4 diffs)
• CbcGenBaB.cpp (modified) (2 diffs)
• CbcGenCbcParamUtils.cpp (modified) (3 diffs)
• CbcGenCtlBlk.cpp (modified) (13 diffs)
• CbcGenCtlBlk.hpp (modified) (1 diff)
• CbcGenOsiParamUtils.cpp (modified) (6 diffs)
• CbcGenParamUtils.cpp (modified) (11 diffs)
• CbcGenSolution.cpp (modified) (3 diffs)
• CbcGenSolvers.cpp (modified) (2 diffs)
• CbcGeneralDepth.cpp (modified) (8 diffs)
• CbcGeneric.cpp (modified) (1 diff)
• CbcHeuristic.cpp (modified) (27 diffs)
• CbcHeuristic.hpp (modified) (3 diffs)
• CbcHeuristicDINS.cpp (modified) (3 diffs)
• CbcHeuristicDW.cpp (modified) (8 diffs)
• CbcHeuristicDive.cpp (modified) (14 diffs)
• CbcHeuristicDive.hpp (modified) (1 diff)
• CbcHeuristicDiveCoefficient.cpp (modified) (2 diffs)
• CbcHeuristicDiveFractional.cpp (modified) (2 diffs)
• CbcHeuristicDiveGuided.cpp (modified) (2 diffs)
• CbcHeuristicDiveLineSearch.cpp (modified) (2 diffs)
• CbcHeuristicDivePseudoCost.cpp (modified) (3 diffs)
• CbcHeuristicDiveVectorLength.cpp (modified) (3 diffs)
• CbcHeuristicFPump.cpp (modified) (19 diffs)
• CbcHeuristicGreedy.cpp (modified) (1 diff)
• CbcHeuristicLocal.cpp (modified) (8 diffs)
• CbcHeuristicLocal.hpp (modified) (1 diff)
• CbcHeuristicPivotAndFix.cpp (modified) (1 diff)
• CbcHeuristicRENS.cpp (modified) (11 diffs)
• CbcHeuristicRINS.cpp (modified) (1 diff)
• CbcHeuristicRandRound.cpp (modified) (7 diffs)
• CbcHeuristicVND.cpp (modified) (1 diff)
• CbcLinked.cpp (modified) (61 diffs)
• CbcMipStartIO.cpp (modified) (8 diffs)
• CbcMipStartIO.hpp (modified) (2 diffs)
• CbcModel.cpp (modified) (200 diffs)
• CbcModel.hpp (modified) (3 diffs)
• CbcNode.cpp (modified) (74 diffs)
• CbcObject.cpp (modified) (3 diffs)
• CbcParam.hpp (modified) (1 diff)
• CbcPartialNodeInfo.cpp (modified) (3 diffs)
• CbcSOS.cpp (modified) (4 diffs)
• CbcSimpleInteger.cpp (modified) (3 diffs)
• CbcSimpleIntegerDynamicPseudoCost.cpp (modified) (21 diffs)
• CbcSolver.cpp (modified) (157 diffs)
• CbcSolverExpandKnapsack.cpp (modified) (2 diffs)
• CbcSolverHeuristics.cpp (modified) (9 diffs)
• CbcStatistics.cpp (modified) (2 diffs)
• CbcStrategy.cpp (modified) (32 diffs)
• CbcSubProblem.cpp (modified) (3 diffs)
• CbcSymmetry.cpp (modified) (10 diffs)
• CbcSymmetry.hpp (modified) (5 diffs)
• CbcThread.cpp (modified) (23 diffs)
• CbcTree.cpp (modified) (14 diffs)
• CbcTree.hpp (modified) (3 diffs)
• CbcTreeLocal.cpp (modified) (6 diffs)
• Cbc_C_Interface.cpp (modified) (8 diffs)
• Cbc_ampl.cpp (modified) (6 diffs)
• CoinSolve.cpp (modified) (1 diff)
• unitTest.cpp (modified) (6 diffs)
• unitTestClp.cpp (modified) (8 diffs)

trunk/Cbc/src/CbcBranchBase.cpp

@@ -89 +89 @@
 {
   //assert (solver==model_->solver());
-  CbcObject *fudge = const_cast<CbcObject *>(this);
+  CbcObject *fudge = const_cast< CbcObject * >(this);
   fudge->feasibleRegion();
   return 0.0;
@@ -103 +103 @@
 {
   //assert (solver==model_->solver());
-  CbcObject *fudge = const_cast<CbcObject *>(this);
+  CbcObject *fudge = const_cast< CbcObject * >(this);
   fudge->feasibleRegion();
   return 0.0;
@@ -118 +118 @@
 {
   //assert (solver==model_->solver());
-  CbcObject *fudge = const_cast<CbcObject *>(this);
+  CbcObject *fudge = const_cast< CbcObject * >(this);
   return fudge->createBranch(solver, info, way);
 }

trunk/Cbc/src/CbcBranchCut.cpp

@@ -294 +294 @@
 int CbcCutBranchingObject::compareOriginalObject(const CbcBranchingObject *brObj) const
 {
-  const CbcCutBranchingObject *br = dynamic_cast<const CbcCutBranchingObject *>(brObj);
+  const CbcCutBranchingObject *br = dynamic_cast< const CbcCutBranchingObject * >(brObj);
   assert(br);
   const OsiRowCut &r0 = way_ == -1 ? down_ : up_;
@@ -313 +313 @@
 CbcCutBranchingObject::compareBranchingObject(const CbcBranchingObject *brObj, const bool replaceIfOverlap)
 {
-  const CbcCutBranchingObject *br = dynamic_cast<const CbcCutBranchingObject *>(brObj);
+  const CbcCutBranchingObject *br = dynamic_cast< const CbcCutBranchingObject * >(brObj);
   assert(br);
   OsiRowCut &r0 = way_ == -1 ? down_ : up_;

trunk/Cbc/src/CbcBranchDefaultDecision.cpp

@@ -215 +215 @@
           if (numberNext < numberUnsatisfied) {
             int numberUp = numberUnsatisfied - numberInfeasibilitiesUp[i];
-            double perUnsatisfied = changeUp[i] / static_cast<double>(numberUp);
+            double perUnsatisfied = changeUp[i] / static_cast< double >(numberUp);
             double estimatedObjective = objectiveValue + numberUnsatisfied * perUnsatisfied;
             if (estimatedObjective < cutoff)
@@ -223 +223 @@
           if (numberNext < numberUnsatisfied) {
             int numberDown = numberUnsatisfied - numberInfeasibilitiesDown[i];
-            double perUnsatisfied = changeDown[i] / static_cast<double>(numberDown);
+            double perUnsatisfied = changeDown[i] / static_cast< double >(numberDown);
             double estimatedObjective = objectiveValue + numberUnsatisfied * perUnsatisfied;
             if (estimatedObjective < cutoff)
@@ -344 +344 @@
         if (numberNext < numberUnsatisfied) {
           int numberUp = numberUnsatisfied - numberInfeasibilitiesUp[i];
-          double perUnsatisfied = changeUp[i] / static_cast<double>(numberUp);
+          double perUnsatisfied = changeUp[i] / static_cast< double >(numberUp);
           double estimatedObjective = objectiveValue + numberUnsatisfied * perUnsatisfied;
           if (estimatedObjective < bestEstimate) {
@@ -355 +355 @@
         if (numberNext < numberUnsatisfied) {
           int numberDown = numberUnsatisfied - numberInfeasibilitiesDown[i];
-          double perUnsatisfied = changeDown[i] / static_cast<double>(numberDown);
+          double perUnsatisfied = changeDown[i] / static_cast< double >(numberDown);
           double estimatedObjective = objectiveValue + numberUnsatisfied * perUnsatisfied;
           if (estimatedObjective < bestEstimate) {

trunk/Cbc/src/CbcBranchDynamic.cpp

@@ -202 +202 @@
   OsiBranchingObject *obj = object->clone();
 #ifndef NDEBUG
-  CbcBranchingObject *obj2 = dynamic_cast<CbcBranchingObject *>(obj);
+  CbcBranchingObject *obj2 = dynamic_cast< CbcBranchingObject * >(obj);
   assert(obj2);
 #if COIN_DEVELOP > 1
-  CbcDynamicPseudoCostBranchingObject *branchingObject = dynamic_cast<CbcDynamicPseudoCostBranchingObject *>(obj);
+  CbcDynamicPseudoCostBranchingObject *branchingObject = dynamic_cast< CbcDynamicPseudoCostBranchingObject * >(obj);
   if (!branchingObject)
     printf("no dynamic branching object Dynamic Decision\n");
 #endif
 #else
-  CbcBranchingObject *obj2 = static_cast<CbcBranchingObject *>(obj);
+  CbcBranchingObject *obj2 = static_cast< CbcBranchingObject * >(obj);
 #endif
   //object_=branchingObject;
@@ -254 +254 @@
         */
 
-  CbcDynamicPseudoCostBranchingObject *branchingObject = dynamic_cast<CbcDynamicPseudoCostBranchingObject *>(object_);
+  CbcDynamicPseudoCostBranchingObject *branchingObject = dynamic_cast< CbcDynamicPseudoCostBranchingObject * >(object_);
   if (!branchingObject) {
     delete object_;
@@ -312 +312 @@
 #if TYPE2 == 0
       object->addToSumDownCost(change / (nonZeroAmount + movement));
-      object->setDownDynamicPseudoCost(object->sumDownCost() / static_cast<double>(object->numberTimesDown()));
+      object->setDownDynamicPseudoCost(object->sumDownCost() / static_cast< double >(object->numberTimesDown()));
 #elif TYPE2 == 1
       object->addToSumDownCost(change);
@@ -358 +358 @@
 #if TYPE2 == 0
       object->addToSumUpCost(change / (nonZeroAmount + movement));
-      object->setUpDynamicPseudoCost(object->sumUpCost() / static_cast<double>(object->numberTimesUp()));
+      object->setUpDynamicPseudoCost(object->sumUpCost() / static_cast< double >(object->numberTimesUp()));
 #elif TYPE2 == 1
       object->addToSumUpCost(change);
@@ -479 +479 @@
     distanceToCutoffC = CoinMax(distanceToCutoffC, 1.0e-12 * (1.0 + fabs(objectiveValue)));
     int numberInfC = model->getContinuousInfeasibilities();
-    double perInf = distanceToCutoffC / static_cast<double>(numberInfC);
+    double perInf = distanceToCutoffC / static_cast< double >(numberInfC);
     assert(perInf > 0.0);
     //int numberIntegers = model->numberIntegers();
@@ -543 +543 @@
       // not much in it - look at unsatisfied
       if (thisNumber < numberUnsatisfied || bestNumber < numberUnsatisfied) {
-        double perInteger = distance / (static_cast<double>(numberUnsatisfied));
+        double perInteger = distance / (static_cast< double >(numberUnsatisfied));
         useValue += thisNumber * perInteger;
         useBest += bestNumber * perInteger;
@@ -560 +560 @@
   History hist;
   {
-    CbcDynamicPseudoCostBranchingObject *branchingObject = dynamic_cast<CbcDynamicPseudoCostBranchingObject *>(thisOne);
+    CbcDynamicPseudoCostBranchingObject *branchingObject = dynamic_cast< CbcDynamicPseudoCostBranchingObject * >(thisOne);
     if (branchingObject) {
       CbcSimpleIntegerDynamicPseudoCost *object = branchingObject->object();
@@ -583 +583 @@
 #endif
     // maybe change better way
-    CbcDynamicPseudoCostBranchingObject *branchingObject = dynamic_cast<CbcDynamicPseudoCostBranchingObject *>(thisOne);
+    CbcDynamicPseudoCostBranchingObject *branchingObject = dynamic_cast< CbcDynamicPseudoCostBranchingObject * >(thisOne);
     if (branchingObject) {
       CbcSimpleIntegerDynamicPseudoCost *object = branchingObject->object();
@@ -752 +752 @@
   info.upMovement = object_->upDynamicPseudoCost() * (ceil(value_) - value_);
   info.downMovement = object_->downDynamicPseudoCost() * (value_ - floor(value_));
-  info.numIntInfeasUp -= static_cast<int>(object_->sumUpDecrease() / (1.0e-12 + static_cast<double>(object_->numberTimesUp())));
+  info.numIntInfeasUp -= static_cast< int >(object_->sumUpDecrease() / (1.0e-12 + static_cast< double >(object_->numberTimesUp())));
   info.numIntInfeasUp = CoinMax(info.numIntInfeasUp, 0);
   info.numObjInfeasUp = 0;
   info.finishedUp = false;
   info.numItersUp = 0;
-  info.numIntInfeasDown -= static_cast<int>(object_->sumDownDecrease() / (1.0e-12 + static_cast<double>(object_->numberTimesDown())));
+  info.numIntInfeasDown -= static_cast< int >(object_->sumDownDecrease() / (1.0e-12 + static_cast< double >(object_->numberTimesDown())));
   info.numIntInfeasDown = CoinMax(info.numIntInfeasDown, 0);
   info.numObjInfeasDown = 0;

trunk/Cbc/src/CbcBranchLotsize.cpp

@@ -792 +792 @@
 CbcLotsizeBranchingObject::compareBranchingObject(const CbcBranchingObject *brObj, const bool replaceIfOverlap)
 {
-  const CbcLotsizeBranchingObject *br = dynamic_cast<const CbcLotsizeBranchingObject *>(brObj);
+  const CbcLotsizeBranchingObject *br = dynamic_cast< const CbcLotsizeBranchingObject * >(brObj);
   assert(br);
   double *thisBd = way_ == -1 ? down_ : up_;

trunk/Cbc/src/CbcBranchToFixLots.cpp

@@ -129 +129 @@
   double tolerance = CoinMin(1.0e-8, integerTolerance);
   // How many fixed are we aiming at
-  int wantedFixed = static_cast<int>(static_cast<double>(numberIntegers) * fractionFixed_);
+  int wantedFixed = static_cast< int >(static_cast< double >(numberIntegers) * fractionFixed_);
   int nSort = 0;
   int numberFixed = 0;
@@ -380 +380 @@
   double tolerance = CoinMin(1.0e-8, integerTolerance);
   // How many fixed are we aiming at
-  int wantedFixed = static_cast<int>(static_cast<double>(numberIntegers) * fractionFixed_);
+  int wantedFixed = static_cast< int >(static_cast< double >(numberIntegers) * fractionFixed_);
   if (djTolerance_ < 1.0e10) {
     int nSort = 0;

trunk/Cbc/src/CbcBranchingObject.hpp

@@ -208 +208 @@
   virtual int compareOriginalObject(const CbcBranchingObject *brObj) const
   {
-    const CbcBranchingObject *br = dynamic_cast<const CbcBranchingObject *>(brObj);
+    const CbcBranchingObject *br = dynamic_cast< const CbcBranchingObject * >(brObj);
     return variable() - br->variable();
   }

trunk/Cbc/src/CbcClique.cpp

@@ -305 +305 @@
   const int *integer = model_->integerVariable();
   //OsiSolverInterface * solver = model_->solver();
-  CoinWarmStartBasis *basis = dynamic_cast<CoinWarmStartBasis *>(solver->getWarmStart());
+  CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver->getWarmStart());
   const double *solution = model_->testSolution();
   const double *lower = solver->getColLower();
@@ -613 +613 @@
 int CbcCliqueBranchingObject::compareOriginalObject(const CbcBranchingObject *brObj) const
 {
-  const CbcCliqueBranchingObject *br = dynamic_cast<const CbcCliqueBranchingObject *>(brObj);
+  const CbcCliqueBranchingObject *br = dynamic_cast< const CbcCliqueBranchingObject * >(brObj);
   assert(br);
   return CbcCompareCliques(clique_, br->clique_);
@@ -629 +629 @@
 CbcCliqueBranchingObject::compareBranchingObject(const CbcBranchingObject *brObj, const bool /*replaceIfOverlap*/)
 {
-  const CbcCliqueBranchingObject *br = dynamic_cast<const CbcCliqueBranchingObject *>(brObj);
+  const CbcCliqueBranchingObject *br = dynamic_cast< const CbcCliqueBranchingObject * >(brObj);
   assert(br);
   unsigned int *thisMask = way_ < 0 ? upMask_ : downMask_;
   const unsigned int *otherMask = br->way_ < 0 ? br->upMask_ : br->downMask_;
-  const CoinUInt64 cl0 = (static_cast<CoinUInt64>(thisMask[0]) << 32) | thisMask[1];
-  const CoinUInt64 cl1 = (static_cast<CoinUInt64>(otherMask[0]) << 32) | otherMask[1];
+  const CoinUInt64 cl0 = (static_cast< CoinUInt64 >(thisMask[0]) << 32) | thisMask[1];
+  const CoinUInt64 cl1 = (static_cast< CoinUInt64 >(otherMask[0]) << 32) | otherMask[1];
   if (cl0 == cl1) {
     return CbcRangeSame;
@@ -650 +650 @@
   }
   const CoinUInt64 cl_union = (cl0 | cl1);
-  thisMask[0] = static_cast<unsigned int>(cl_union >> 32);
-  thisMask[1] = static_cast<unsigned int>(cl_union & 0xffffffff);
+  thisMask[0] = static_cast< unsigned int >(cl_union >> 32);
+  thisMask[1] = static_cast< unsigned int >(cl_union & 0xffffffff);
   return CbcRangeOverlap;
 }
@@ -856 +856 @@
 int CbcLongCliqueBranchingObject::compareOriginalObject(const CbcBranchingObject *brObj) const
 {
-  const CbcLongCliqueBranchingObject *br = dynamic_cast<const CbcLongCliqueBranchingObject *>(brObj);
+  const CbcLongCliqueBranchingObject *br = dynamic_cast< const CbcLongCliqueBranchingObject * >(brObj);
   assert(br);
   return CbcCompareCliques(clique_, br->clique_);
@@ -872 +872 @@
 CbcLongCliqueBranchingObject::compareBranchingObject(const CbcBranchingObject *brObj, const bool /*replaceIfOverlap*/)
 {
-  const CbcLongCliqueBranchingObject *br = dynamic_cast<const CbcLongCliqueBranchingObject *>(brObj);
+  const CbcLongCliqueBranchingObject *br = dynamic_cast< const CbcLongCliqueBranchingObject * >(brObj);
   assert(br);
   const int numberMembers = clique_->numberMembers();

trunk/Cbc/src/CbcCompareDefault.cpp

@@ -193 +193 @@
     double target = (1.0 - THRESH2) * bestPossible_ + THRESH2 * cutoff_;
     double weight;
-    weight = (target - x->objectiveValue()) / static_cast<double>(x->numberUnsatisfied());
+    weight = (target - x->objectiveValue()) / static_cast< double >(x->numberUnsatisfied());
     double testX = -weight;
-    weight = (target - y->objectiveValue()) / static_cast<double>(y->numberUnsatisfied());
+    weight = (target - y->objectiveValue()) / static_cast< double >(y->numberUnsatisfied());
     double testY = -weight;
 #elif TRY_THIS == 2
@@ -229 +229 @@
     return (false); // solution was got by rounding
   // set to get close to this solution
-  double costPerInteger = (model->getObjValue() - objectiveAtContinuous) / static_cast<double>(numberInfeasibilitiesAtContinuous);
+  double costPerInteger = (model->getObjValue() - objectiveAtContinuous) / static_cast< double >(numberInfeasibilitiesAtContinuous);
   weight_ = 0.95 * costPerInteger;
   saveWeight_ = 0.95 * weight_;

trunk/Cbc/src/CbcCutGenerator.cpp

@@ -198 +198 @@
     depth = 0;
   int howOften = whenCutGenerator_;
-  if (dynamic_cast<CglProbing *>(generator_)) {
+  if (dynamic_cast< CglProbing * >(generator_)) {
     if (howOften == -100 && model_->doCutsNow(3)) {
       howOften = 1; // do anyway
@@ -258 +258 @@
     {
       OsiClpSolverInterface *clpSolver
-        = dynamic_cast<OsiClpSolverInterface *>(solver);
+        = dynamic_cast< OsiClpSolverInterface * >(solver);
       if (clpSolver)
         randomNumberGenerator = clpSolver->getModelPtr()->randomNumberGenerator();
@@ -303 +303 @@
     // above had &&!model_->parentModel()&&depth<2)
     incrementNumberTimesEntered();
-    CglProbing *generator = dynamic_cast<CglProbing *>(generator_);
+    CglProbing *generator = dynamic_cast< CglProbing * >(generator_);
     //if (!depth&&!pass)
     //printf("Cut generator %s when %d\n",generatorName_,whenCutGenerator_);
@@ -360 +360 @@
             2099999
           };
-          int n = static_cast<int>(sizeof(test) / sizeof(int));
+          int n = static_cast< int >(sizeof(test) / sizeof(int));
           int saveStack = generator->getMaxLook();
           int saveNumber = generator->getMaxProbe();
@@ -570 +570 @@
 #ifdef COIN_HAS_CLP
         OsiClpSolverInterface *clpSolver
-          = dynamic_cast<OsiClpSolverInterface *>(solver);
+          = dynamic_cast< OsiClpSolverInterface * >(solver);
         if (clpSolver) {
           clpSolver->setLastAlgorithm(2);
@@ -588 +588 @@
       int numberObjects = model_->numberObjects();
       for (int i = 0; i < numberObjects; i++) {
-        CbcSimpleIntegerDynamicPseudoCost *obj1 = dynamic_cast<CbcSimpleIntegerDynamicPseudoCost *>(model_->modifiableObject(i));
+        CbcSimpleIntegerDynamicPseudoCost *obj1 = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(model_->modifiableObject(i));
         if (obj1) {
           int iColumn = obj1->columnNumber();
@@ -1282 +1282 @@
     // leave Probing every SCANCUTS_PROBING
     howOften = howOften % 1000000;
-    CglProbing *generator = dynamic_cast<CglProbing *>(generator_);
+    CglProbing *generator = dynamic_cast< CglProbing * >(generator_);
 
     if (generator && howOften > SCANCUTS_PROBING)

trunk/Cbc/src/CbcEventHandler.hpp

@@ -137 +137 @@
   /*! \brief Data type for event/action pairs */
 
-  typedef std::map<CbcEvent, CbcAction> eaMapPair;
+  typedef std::map< CbcEvent, CbcAction > eaMapPair;
 
   /*! \name Event Processing */

trunk/Cbc/src/CbcFathomDynamicProgramming.cpp

@@ -199 +199 @@
   double check = COIN_INT_MAX;
   for (i = 0; i < numberRows; i++) {
-    int n = static_cast<int>(floor(rhs[i] + 0.5));
+    int n = static_cast< int >(floor(rhs[i] + 0.5));
     if (n) {
       n++; // allow for 0,1... n
@@ -228 +228 @@
     size_ = COIN_INT_MAX;
   else
-    size_ = static_cast<int>(size);
+    size_ = static_cast< int >(size);
 
   int n01 = 0;
@@ -274 +274 @@
     int kBit = 0;
     for (i = 0; i < numberRows; i++) {
-      int n = static_cast<int>(floor(rhs[i] + 0.5));
+      int n = static_cast< int >(floor(rhs[i] + 0.5));
       if (n) {
         lookup_[i] = numberActive;
@@ -395 +395 @@
         int newRow = lookup_[i];
         if (newRow >= 0) {
-          int gap = static_cast<int>(rowUpper[i] - CoinMax(0.0, rowLower[i]));
+          int gap = static_cast< int >(rowUpper[i] - CoinMax(0.0, rowLower[i]));
           lower2[newRow] = rhs_[newRow] - gap;
           int numberBits = numberBits_[newRow];
@@ -483 +483 @@
       double cost = direction * objective[i];
       fixedObj += lowerValue * cost;
-      int gap = static_cast<int>(upper[i] - lowerValue);
+      int gap = static_cast< int >(upper[i] - lowerValue);
       CoinBigIndex start = columnStart[i];
       tryColumn(columnLength[i], row + start, element + start, cost, gap);
@@ -521 +521 @@
         int newRow = lookup_[i];
         if (newRow >= 0) {
-          int gap = static_cast<int>(rowUpper[i] - CoinMax(0.0, rowLower[i]));
+          int gap = static_cast< int >(rowUpper[i] - CoinMax(0.0, rowLower[i]));
           lower[newRow] = rhs_[newRow] - gap;
           int numberBits = numberBits_[newRow];
@@ -574 +574 @@
                 int iRow = row[j];
                 double value = element[j];
-                int iValue = static_cast<int>(value);
+                int iValue = static_cast< int >(value);
                 if (iValue != indices_[iRow]) {
                   good = false;
@@ -655 +655 @@
       int iRow = rows[j];
       double value = coefficients[j];
-      int iValue = static_cast<int>(value);
+      int iValue = static_cast< int >(value);
       int newRow = lookup_[iRow];
       if (newRow < 0 || iValue > rhs_[newRow]) {

trunk/Cbc/src/CbcFollowOn.cpp

@@ -73 +73 @@
         }
         if (good)
-          rhs_[i] = static_cast<int>(value);
+          rhs_[i] = static_cast< int >(value);
       }
     }
@@ -163 +163 @@
             numberUnsatisfied++;
         } else {
-          rhsValue -= static_cast<int>(value * floor(solValue + 0.5));
+          rhsValue -= static_cast< int >(value * floor(solValue + 0.5));
         }
       }
@@ -509 +509 @@
 {
 #ifdef JJF_ZERO //ndef NDEBUG
-  const CbcFixingBranchingObject *br = dynamic_cast<const CbcFixingBranchingObject *>(brObj);
+  const CbcFixingBranchingObject *br = dynamic_cast< const CbcFixingBranchingObject * >(brObj);
   assert(br);
 #endif

trunk/Cbc/src/CbcFullNodeInfo.cpp

@@ -73 +73 @@
   }
 
-  basis_ = dynamic_cast<CoinWarmStartBasis *>(solver->getWarmStart());
+  basis_ = dynamic_cast< CoinWarmStartBasis * >(solver->getWarmStart());
 }
 
@@ -79 +79 @@
   : CbcNodeInfo(rhs)
 {
-  basis_ = dynamic_cast<CoinWarmStartBasis *>(rhs.basis_->clone());
+  basis_ = dynamic_cast< CoinWarmStartBasis * >(rhs.basis_->clone());
   numberIntegers_ = rhs.numberIntegers_;
   lower_ = NULL;
@@ -145 +145 @@
     delete basis;
     if (basis_) {
-      basis = dynamic_cast<CoinWarmStartBasis *>(basis_->clone());
+      basis = dynamic_cast< CoinWarmStartBasis * >(basis_->clone());
       basis->resize(numberRows, numberColumns);
 #ifdef CBC_CHECK_BASIS
@@ -189 +189 @@
 CbcFullNodeInfo::buildRowBasis(CoinWarmStartBasis &basis) const
 {
-  const unsigned int *saved = reinterpret_cast<const unsigned int *>(basis_->getArtificialStatus());
-  unsigned int *now = reinterpret_cast<unsigned int *>(basis.getArtificialStatus());
+  const unsigned int *saved = reinterpret_cast< const unsigned int * >(basis_->getArtificialStatus());
+  unsigned int *now = reinterpret_cast< unsigned int * >(basis.getArtificialStatus());
   int number = basis_->getNumArtificial() >> 4;
   ;

trunk/Cbc/src/CbcGenBaB.cpp

@@ -306 +306 @@
   if (action != CbcGenCtlBlk::CGOff) {
     if (action == CbcGenCtlBlk::CGForceBut) {
-      CglProbing *probingGen = dynamic_cast<CglProbing *>(gen);
+      CglProbing *probingGen = dynamic_cast< CglProbing * >(gen);
       probingGen->setRowCuts(-3);
     }
@@ -484 +484 @@
 {
   assert(param != 0);
-  CbcGenParam *genParam = dynamic_cast<CbcGenParam *>(param);
+  CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(param);
   assert(genParam != 0);
   CbcGenCtlBlk *ctlBlk = genParam->obj();

trunk/Cbc/src/CbcGenCbcParamUtils.cpp

@@ -219 +219 @@
     */
   for (i = first; i <= last; i++) {
-    CbcCbcParam *cbcParam = dynamic_cast<CbcCbcParam *>(paramVec[i]);
+    CbcCbcParam *cbcParam = dynamic_cast< CbcCbcParam * >(paramVec[i]);
     assert(cbcParam != 0);
     cbcParam->setObj(obj);
@@ -266 +266 @@
   assert(param != 0);
 
-  CbcCbcParam *cbcParam = dynamic_cast<CbcCbcParam *>(param);
+  CbcCbcParam *cbcParam = dynamic_cast< CbcCbcParam * >(param);
   assert(cbcParam != 0);
 
@@ -335 +335 @@
   assert(param != 0);
 
-  CbcCbcParam *cbcParam = dynamic_cast<CbcCbcParam *>(param);
+  CbcCbcParam *cbcParam = dynamic_cast< CbcCbcParam * >(param);
   assert(cbcParam != 0);
 

trunk/Cbc/src/CbcGenCtlBlk.cpp

@@ -260 +260 @@
     probing_.proto_->setRowCuts(probing_.rowCuts_);
   }
-  gen = dynamic_cast<CglCutGenerator *>(probing_.proto_);
+  gen = dynamic_cast< CglCutGenerator * >(probing_.proto_);
 
   return (probing_.action_);
@@ -274 +274 @@
     clique_.proto_->setMinViolation(clique_.minViolation_);
   }
-  gen = dynamic_cast<CglCutGenerator *>(clique_.proto_);
+  gen = dynamic_cast< CglCutGenerator * >(clique_.proto_);
 
   return (clique_.action_);
@@ -285 +285 @@
     flow_.proto_ = new CglFlowCover();
   }
-  gen = dynamic_cast<CglCutGenerator *>(flow_.proto_);
+  gen = dynamic_cast< CglCutGenerator * >(flow_.proto_);
 
   return (flow_.action_);
@@ -298 +298 @@
     gomory_.proto_->setLimit(gomory_.limit_);
   }
-  gen = dynamic_cast<CglCutGenerator *>(gomory_.proto_);
+  gen = dynamic_cast< CglCutGenerator * >(gomory_.proto_);
 
   return (gomory_.action_);
@@ -309 +309 @@
     knapsack_.proto_ = new CglKnapsackCover();
   }
-  gen = dynamic_cast<CglCutGenerator *>(knapsack_.proto_);
+  gen = dynamic_cast< CglCutGenerator * >(knapsack_.proto_);
 
   return (knapsack_.action_);
@@ -320 +320 @@
     mir_.proto_ = new CglMixedIntegerRounding2();
   }
-  gen = dynamic_cast<CglCutGenerator *>(mir_.proto_);
+  gen = dynamic_cast< CglCutGenerator * >(mir_.proto_);
 
   return (mir_.action_);
@@ -331 +331 @@
     redSplit_.proto_ = new CglRedSplit();
   }
-  gen = dynamic_cast<CglCutGenerator *>(redSplit_.proto_);
+  gen = dynamic_cast< CglCutGenerator * >(redSplit_.proto_);
 
   return (redSplit_.action_);
@@ -343 +343 @@
     twomir_.proto_->setMaxElements(twomir_.maxElements_);
   }
-  gen = dynamic_cast<CglCutGenerator *>(twomir_.proto_);
+  gen = dynamic_cast< CglCutGenerator * >(twomir_.proto_);
 
   return (twomir_.action_);
@@ -360 +360 @@
     fpump_.proto_->setMaximumPasses(fpump_.iters_);
   }
-  gen = dynamic_cast<CbcHeuristic *>(fpump_.proto_);
+  gen = dynamic_cast< CbcHeuristic * >(fpump_.proto_);
 
   return (fpump_.action_);
@@ -377 +377 @@
     combine_.proto_->setSearchType(combine_.trySwap_);
   }
-  gen = dynamic_cast<CbcHeuristic *>(combine_.proto_);
+  gen = dynamic_cast< CbcHeuristic * >(combine_.proto_);
 
   return (combine_.action_);
@@ -393 +393 @@
     greedyCover_.proto_ = new CbcHeuristicGreedyCover(*model);
   }
-  gen = dynamic_cast<CbcHeuristic *>(greedyCover_.proto_);
+  gen = dynamic_cast< CbcHeuristic * >(greedyCover_.proto_);
 
   return (greedyCover_.action_);
@@ -409 +409 @@
     greedyEquality_.proto_ = new CbcHeuristicGreedyEquality(*model);
   }
-  gen = dynamic_cast<CbcHeuristic *>(greedyEquality_.proto_);
+  gen = dynamic_cast< CbcHeuristic * >(greedyEquality_.proto_);
 
   return (greedyEquality_.action_);
@@ -425 +425 @@
     rounding_.proto_ = new CbcRounding(*model);
   }
-  gen = dynamic_cast<CbcHeuristic *>(rounding_.proto_);
+  gen = dynamic_cast< CbcHeuristic * >(rounding_.proto_);
 
   return (rounding_.action_);

trunk/Cbc/src/CbcGenCtlBlk.hpp

@@ -684 +684 @@
   /*! \brief Record of parameters changed by user command */
 
-  std::vector<bool> setByUser_;
+  std::vector< bool > setByUser_;
 
   /*! \brief False if the user has made nontrivial modifications to the

trunk/Cbc/src/CbcGenOsiParamUtils.cpp

@@ -158 +158 @@
     */
   for (i = first; i <= last; i++) {
-    CbcOsiParam *osiParam = dynamic_cast<CbcOsiParam *>(paramVec[i]);
+    CbcOsiParam *osiParam = dynamic_cast< CbcOsiParam * >(paramVec[i]);
     assert(osiParam != 0);
     osiParam->setObj(obj);
@@ -215 +215 @@
   assert(param != 0);
 
-  CbcOsiParam *osiParam = dynamic_cast<CbcOsiParam *>(param);
+  CbcOsiParam *osiParam = dynamic_cast< CbcOsiParam * >(param);
   assert(osiParam != 0);
 
@@ -272 +272 @@
   assert(param != 0);
 
-  CbcOsiParam *osiParam = dynamic_cast<CbcOsiParam *>(param);
+  CbcOsiParam *osiParam = dynamic_cast< CbcOsiParam * >(param);
   assert(osiParam != 0);
 
@@ -335 +335 @@
 {
   assert(param != 0);
-  CbcOsiParam *osiParam = dynamic_cast<CbcOsiParam *>(param);
+  CbcOsiParam *osiParam = dynamic_cast< CbcOsiParam * >(param);
   assert(osiParam != 0);
   OsiSolverInterface *osi = osiParam->obj();
@@ -400 +400 @@
 {
   assert(param != 0);
-  CbcOsiParam *osiParam = dynamic_cast<CbcOsiParam *>(param);
+  CbcOsiParam *osiParam = dynamic_cast< CbcOsiParam * >(param);
   assert(osiParam != 0);
   OsiSolverInterface *osi = osiParam->obj();
@@ -459 +459 @@
 {
   assert(param != 0);
-  CbcOsiParam *osiParam = dynamic_cast<CbcOsiParam *>(param);
+  CbcOsiParam *osiParam = dynamic_cast< CbcOsiParam * >(param);
   assert(osiParam != 0);
   OsiSolverInterface *osi = osiParam->obj();

trunk/Cbc/src/CbcGenParamUtils.cpp

@@ -600 +600 @@
     */
   for (i = first; i <= last; i++) {
-    CbcGenParam *genParam = dynamic_cast<CbcGenParam *>(paramVec[i]);
+    CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(paramVec[i]);
     assert(genParam != 0);
     genParam->setObj(ctlBlk);
@@ -620 +620 @@
   assert(param != 0);
 
-  CbcGenParam *genParam = dynamic_cast<CbcGenParam *>(param);
+  CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(param);
   assert(genParam != 0);
 
@@ -679 +679 @@
 {
   assert(param != 0);
-  CbcGenParam *genParam = dynamic_cast<CbcGenParam *>(param);
+  CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(param);
   assert(genParam != 0);
   CbcGenCtlBlk *ctlBlk = genParam->obj();
@@ -705 +705 @@
 {
   assert(param != 0);
-  CbcGenParam *genParam = dynamic_cast<CbcGenParam *>(param);
+  CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(param);
   assert(genParam != 0);
   CbcGenCtlBlk *ctlBlk = genParam->obj();
@@ -748 +748 @@
 {
   assert(param != 0);
-  CbcGenParam *genParam = dynamic_cast<CbcGenParam *>(param);
+  CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(param);
   assert(genParam != 0);
   CbcGenCtlBlk *ctlBlk = genParam->obj();
@@ -785 +785 @@
 {
   assert(param != 0);
-  CbcGenParam *genParam = dynamic_cast<CbcGenParam *>(param);
+  CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(param);
   assert(genParam != 0);
   CbcGenCtlBlk *ctlBlk = genParam->obj();
@@ -834 +834 @@
 {
   assert(param != 0);
-  CbcGenParam *genParam = dynamic_cast<CbcGenParam *>(param);
+  CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(param);
   assert(genParam != 0);
   CbcGenCtlBlk *ctlBlk = genParam->obj();
@@ -927 +927 @@
 {
   assert(param != 0);
-  CbcGenParam *genParam = dynamic_cast<CbcGenParam *>(param);
+  CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(param);
   assert(genParam != 0);
   CbcGenCtlBlk *ctlBlk = genParam->obj();
@@ -967 +967 @@
 {
   assert(param != 0);
-  CbcGenParam *genParam = dynamic_cast<CbcGenParam *>(param);
+  CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(param);
   assert(genParam != 0);
   CbcGenCtlBlk *ctlBlk = genParam->obj();
@@ -1155 +1155 @@
 {
   assert(param != 0);
-  CbcGenParam *genParam = dynamic_cast<CbcGenParam *>(param);
+  CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(param);
   assert(genParam != 0);
   CbcGenCtlBlk *ctlBlk = genParam->obj();
@@ -1244 +1244 @@
 {
   assert(param != 0);
-  CbcGenParam *genParam = dynamic_cast<CbcGenParam *>(param);
+  CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(param);
   assert(genParam != 0);
   CbcGenCtlBlk *ctlBlk = genParam->obj();

trunk/Cbc/src/CbcGenSolution.cpp

@@ -208 +208 @@
 {
   assert(param != 0);
-  CbcGenParam *genParam = dynamic_cast<CbcGenParam *>(param);
+  CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(param);
   assert(genParam != 0);
   CbcGenCtlBlk *ctlBlk = genParam->obj();
@@ -335 +335 @@
           value = ceil(value - .5);
         }
-        int ivalue = static_cast<int>(value);
+        int ivalue = static_cast< int >(value);
         fprintf(fp, "%d.0", ivalue);
         if (++k == 10) {
@@ -509 +509 @@
 {
   assert(param != 0);
-  CbcGenParam *genParam = dynamic_cast<CbcGenParam *>(param);
+  CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(param);
   assert(genParam != 0);
   CbcGenCtlBlk *ctlBlk = genParam->obj();

trunk/Cbc/src/CbcGenSolvers.cpp

@@ -101 +101 @@
   Data types for a vector of OsiSolverInterface objects.
 */
-typedef std::map<std::string, OsiSolverInterface *> solverMap_t;
+typedef std::map< std::string, OsiSolverInterface * > solverMap_t;
 typedef solverMap_t::const_iterator solverMapIter_t;
 
@@ -198 +198 @@
 {
   assert(param != 0);
-  CbcGenParam *genParam = dynamic_cast<CbcGenParam *>(param);
+  CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(param);
   assert(genParam != 0);
   CbcGenCtlBlk *ctlBlk = genParam->obj();

trunk/Cbc/src/CbcGeneralDepth.cpp

@@ -159 +159 @@
     OsiSolverInterface *solver = model_->solver();
     OsiClpSolverInterface *clpSolver
-      = dynamic_cast<OsiClpSolverInterface *>(solver);
+      = dynamic_cast< OsiClpSolverInterface * >(solver);
     if (clpSolver) {
       if ((model_->moreSpecialOptions() & 33554432) == 0) {
@@ -170 +170 @@
         int nBranches = model_->getIntParam(CbcModel::CbcNumberBranches);
         if (nBranches) {
-          double average = model_->getDblParam(CbcModel::CbcSumChange) / static_cast<double>(nBranches);
+          double average = model_->getDblParam(CbcModel::CbcSumChange) / static_cast< double >(nBranches);
           info->smallChange_ = CoinMax(average * 1.0e-5, model_->getDblParam(CbcModel::CbcSmallestChange));
           info->smallChange_ = CoinMax(info->smallChange_, 1.0e-8);
@@ -220 +220 @@
         for (int i = 0; i < numberIntegers; i++) {
 #ifndef NDEBUG
-          CbcSimpleIntegerDynamicPseudoCost *obj = dynamic_cast<CbcSimpleIntegerDynamicPseudoCost *>(objects[i]);
+          CbcSimpleIntegerDynamicPseudoCost *obj = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(objects[i]);
           assert(obj && obj->columnNumber() == integerVariable[i]);
 #else
-          CbcSimpleIntegerDynamicPseudoCost *obj = static_cast<CbcSimpleIntegerDynamicPseudoCost *>(objects[i]);
+          CbcSimpleIntegerDynamicPseudoCost *obj = static_cast< CbcSimpleIntegerDynamicPseudoCost * >(objects[i]);
 #endif
           if (info->numberUp_[i] > 0) {
@@ -250 +250 @@
         CbcHeuristicDive *dive = NULL;
         for (int i = 0; i < model_->numberHeuristics(); i++) {
-          CbcHeuristicDive *possible = dynamic_cast<CbcHeuristicDive *>(model_->heuristic(i));
+          CbcHeuristicDive *possible = dynamic_cast< CbcHeuristicDive * >(model_->heuristic(i));
           if (possible && possible->maxSimplexIterations() == COIN_INT_MAX) {
             // if more than one then rotate later?
@@ -281 +281 @@
 #endif
         //delete [] nodes;
-        model_->setTemporaryPointer(reinterpret_cast<void *>(nodes));
+        model_->setTemporaryPointer(reinterpret_cast< void * >(nodes));
         // end try diving
       }
@@ -338 +338 @@
   //OsiSolverInterface * solver = model_->solver();
   OsiClpSolverInterface *clpSolver
-    = dynamic_cast<OsiClpSolverInterface *>(solver);
+    = dynamic_cast< OsiClpSolverInterface * >(solver);
   assert(clpSolver);
   ClpSimplex *simplex = clpSolver->getModelPtr();
@@ -422 +422 @@
   } else {
     // from diving
-    CbcSubProblem **nodes = reinterpret_cast<CbcSubProblem **>(model_->temporaryPointer());
+    CbcSubProblem **nodes = reinterpret_cast< CbcSubProblem ** >(model_->temporaryPointer());
     assert(nodes);
     int adjustDepth = info->depth_;
@@ -549 +549 @@
         thisProb->apply(solver);
         OsiClpSolverInterface *clpSolver
-          = dynamic_cast<OsiClpSolverInterface *>(solver);
+          = dynamic_cast< OsiClpSolverInterface * >(solver);
         assert(clpSolver);
         // Move status to basis

trunk/Cbc/src/CbcGeneric.cpp

@@ -90 +90 @@
 
 {
-  CbcGenParam *genParam = dynamic_cast<CbcGenParam *>(param);
-  CbcCbcParam *cbcParam = dynamic_cast<CbcCbcParam *>(param);
-  CbcOsiParam *osiParam = dynamic_cast<CbcOsiParam *>(param);
+  CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(param);
+  CbcCbcParam *cbcParam = dynamic_cast< CbcCbcParam * >(param);
+  CbcOsiParam *osiParam = dynamic_cast< CbcOsiParam * >(param);
   int code = -1;
 

trunk/Cbc/src/CbcHeuristic.cpp

@@ -49 +49 @@
 void CbcHeuristicNodeList::gutsOfDelete()
 {
-  for (int i = (static_cast<int>(nodes_.size())) - 1; i >= 0; --i) {
+  for (int i = (static_cast< int >(nodes_.size())) - 1; i >= 0; --i) {
     delete nodes_[i];
   }
@@ -206 +206 @@
     printf("nodeinfo: node %i\n", nodeInfo->nodeNumber());
     {
-      const CbcIntegerBranchingObject *brPrint = dynamic_cast<const CbcIntegerBranchingObject *>(nodeInfo->parentBranch());
+      const CbcIntegerBranchingObject *brPrint = dynamic_cast< const CbcIntegerBranchingObject * >(nodeInfo->parentBranch());
       if (!brPrint) {
         printf("    parentBranch: NULL\n");
@@ -215 +215 @@
         int way = brPrint->way();
         printf("   parentBranch: var %i downBd [%i,%i] upBd [%i,%i] way %i\n",
-          variable, static_cast<int>(downBounds[0]), static_cast<int>(downBounds[1]),
-          static_cast<int>(upBounds[0]), static_cast<int>(upBounds[1]), way);
+          variable, static_cast< int >(downBounds[0]), static_cast< int >(downBounds[1]),
+          static_cast< int >(upBounds[0]), static_cast< int >(upBounds[1]), way);
       }
     }
@@ -225 +225 @@
         node->nodeNumber(), node->depth(), node->onTree(), node->active());
       const OsiBranchingObject *osibr = nodeInfo->owner()->branchingObject();
-      const CbcBranchingObject *cbcbr = dynamic_cast<const CbcBranchingObject *>(osibr);
-      const CbcIntegerBranchingObject *brPrint = dynamic_cast<const CbcIntegerBranchingObject *>(cbcbr);
+      const CbcBranchingObject *cbcbr = dynamic_cast< const CbcBranchingObject * >(osibr);
+      const CbcIntegerBranchingObject *brPrint = dynamic_cast< const CbcIntegerBranchingObject * >(cbcbr);
       if (!brPrint) {
         printf("        ownerBranch: NULL\n");
@@ -235 +235 @@
         int way = brPrint->way();
         printf("        ownerbranch: var %i downBd [%i,%i] upBd [%i,%i] way %i\n",
-          variable, static_cast<int>(downBounds[0]), static_cast<int>(downBounds[1]),
-          static_cast<int>(upBounds[0]), static_cast<int>(upBounds[1]), way);
+          variable, static_cast< int >(downBounds[0]), static_cast< int >(downBounds[1]),
+          static_cast< int >(upBounds[0]), static_cast< int >(upBounds[1]), way);
       }
     }
@@ -401 +401 @@
             int old = howOften_;
 #endif
-            howOften_ = CoinMin(CoinMax(static_cast<int>(howOften_ * 1.1), howOften_ + 1), 1000000);
+            howOften_ = CoinMin(CoinMax(static_cast< int >(howOften_ * 1.1), howOften_ + 1), 1000000);
 #ifdef COIN_DEVELOP
             printf("Howoften changed from %d to %d for %s\n",
@@ -451 +451 @@
     while (time >= COIN_INT_MAX)
       time *= 0.5;
-    value = static_cast<int>(time);
+    value = static_cast< int >(time);
     char printArray[100];
     sprintf(printArray, "using time of day seed was changed from %d to %d",
@@ -544 +544 @@
 #ifdef COIN_HAS_CLP
   OsiClpSolverInterface *clpSolver
-    = dynamic_cast<OsiClpSolverInterface *>(solver);
+    = dynamic_cast< OsiClpSolverInterface * >(solver);
 #endif
   if ((type & 2) != 0) {
@@ -552 +552 @@
       for (int i = 0; i < n; i++) {
         const OsiObject *obj = model_->object(i);
-        const CbcSimpleInteger *thisOne = dynamic_cast<const CbcSimpleInteger *>(obj);
+        const CbcSimpleInteger *thisOne = dynamic_cast< const CbcSimpleInteger * >(obj);
         if (thisOne) {
           int iColumn = thisOne->columnNumber();
@@ -564 +564 @@
       for (int i = 0; i < n; i++) {
         const OsiObject *obj = model_->object(i);
-        const CbcSimpleInteger *thisOne = dynamic_cast<const CbcSimpleInteger *>(obj);
+        const CbcSimpleInteger *thisOne = dynamic_cast< const CbcSimpleInteger * >(obj);
         if (thisOne) {
           int iColumn = thisOne->columnNumber();
@@ -719 +719 @@
   }
 #ifdef COIN_HAS_CLP
-  OsiClpSolverInterface *clpSolver = dynamic_cast<OsiClpSolverInterface *>(solver);
+  OsiClpSolverInterface *clpSolver = dynamic_cast< OsiClpSolverInterface * >(solver);
   if (clpSolver && (clpSolver->specialOptions() & 65536) == 0) {
     // go faster stripes
@@ -920 +920 @@
       const OsiRowCutDebugger *debugger = solver->getRowCutDebugger();
       if (debugger) {
-        process.setApplicationData(const_cast<double *>(debugger->optimalSolution()));
+        process.setApplicationData(const_cast< double * >(debugger->optimalSolution()));
       }
     }
 #endif
 #ifdef COIN_HAS_CLP
-    OsiClpSolverInterface *clpSolver = dynamic_cast<OsiClpSolverInterface *>(solver);
+    OsiClpSolverInterface *clpSolver = dynamic_cast< OsiClpSolverInterface * >(solver);
     // See if SOS
     if (clpSolver && clpSolver->numberSOS()) {
@@ -939 +939 @@
         int type = setInfo[i].setType();
         int n = setInfo[i].numberEntries();
-        sosType[i] = static_cast<char>(type);
+        sosType[i] = static_cast< char >(type);
         nTotal += n;
         sosStart[i + 1] = nTotal;
@@ -953 +953 @@
           int k = which[j];
           sosIndices[j + base] = k;
-          sosReference[j + base] = weights ? weights[j] : static_cast<double>(j);
+          sosReference[j + base] = weights ? weights[j] : static_cast< double >(j);
         }
       }
@@ -1023 +1023 @@
         // redo SOS
         OsiClpSolverInterface *clpSolver
-          = dynamic_cast<OsiClpSolverInterface *>(model.solver());
+          = dynamic_cast< OsiClpSolverInterface * >(model.solver());
         if (clpSolver && clpSolver->numberSOS()) {
           int numberColumns = clpSolver->getNumCols();
           const int *originalColumns = process.originalColumns();
-          CoinSet *setInfo = const_cast<CoinSet *>(clpSolver->setInfo());
+          CoinSet *setInfo = const_cast< CoinSet * >(clpSolver->setInfo());
           int numberSOS = clpSolver->numberSOS();
           for (int iSOS = 0; iSOS < numberSOS; iSOS++) {
@@ -1071 +1071 @@
             double fraction = fractionSmall_ - floor(fractionSmall_);
             if (ratio > fraction) {
-              int type = static_cast<int>(floor(fractionSmall_ * 0.1));
-              int over = static_cast<int>(ceil(ratio - fraction));
+              int type = static_cast< int >(floor(fractionSmall_ * 0.1));
+              int over = static_cast< int >(ceil(ratio - fraction));
               int maxNodes[] = { -1, 0, 5, 10 };
               if (type > over)
@@ -1131 +1131 @@
           for (int i = 0; i < model.numberCutGenerators(); i++) {
             CbcCutGenerator *generator = model.cutGenerator(i);
-            CglGomory *gomory = dynamic_cast<CglGomory *>(generator->generator());
+            CglGomory *gomory = dynamic_cast< CglGomory * >(generator->generator());
             if (gomory && gomory->originalSolver())
               gomory->passInOriginalSolver(model.solver());
@@ -1199 +1199 @@
           CbcHeuristicFPump *fpump = NULL;
           for (int i = 0; i < model.numberHeuristics(); i++) {
-            CbcHeuristicFPump *pump = dynamic_cast<CbcHeuristicFPump *>(model.heuristic(i));
+            CbcHeuristicFPump *pump = dynamic_cast< CbcHeuristicFPump * >(model.heuristic(i));
             if (pump) {
               fpump = pump;
@@ -1281 +1281 @@
         for (int i = 0; i < model.numberHeuristics(); i++) {
           // reset lastNode
-          CbcHeuristicRINS *rins = dynamic_cast<CbcHeuristicRINS *>(model.heuristic(i));
+          CbcHeuristicRINS *rins = dynamic_cast< CbcHeuristicRINS * >(model.heuristic(i));
           if (rins) {
             rins->setLastNode(-1000);
@@ -1454 +1454 @@
                 generator->numberCutsActive(),
                 generator->timeInCutGenerator());
-              CglStored *stored = dynamic_cast<CglStored *>(generator->generator());
+              CglStored *stored = dynamic_cast< CglStored * >(generator->generator());
               if (stored && !generator->numberCutsInTotal())
                 continue;
 #ifndef CLP_INVESTIGATE
-              CglImplication *implication = dynamic_cast<CglImplication *>(generator->generator());
+              CglImplication *implication = dynamic_cast< CglImplication * >(generator->generator());
               if (implication)
                 continue;
@@ -1483 +1483 @@
             // post process
 #ifdef COIN_HAS_CLP
-          OsiClpSolverInterface *clpSolver = dynamic_cast<OsiClpSolverInterface *>(model.solver());
+          OsiClpSolverInterface *clpSolver = dynamic_cast< OsiClpSolverInterface * >(model.solver());
           if (clpSolver) {
             ClpSimplex *lpSolver = clpSolver->getModelPtr();
@@ -1682 +1682 @@
   while (nodeInfo->parentBranch() != NULL) {
     const OsiBranchingObject *br = nodeInfo->parentBranch();
-    const CbcBranchingObject *cbcbr = dynamic_cast<const CbcBranchingObject *>(br);
+    const CbcBranchingObject *cbcbr = dynamic_cast< const CbcBranchingObject * >(br);
     if (!cbcbr) {
       throw CoinError("CbcHeuristicNode can be used only with CbcBranchingObjects.\n",
@@ -1760 +1760 @@
     const CbcBranchingObject *br1 = node->brObj_[j];
 #ifdef PRINT_DEBUG
-    const CbcIntegerBranchingObject *brPrint0 = dynamic_cast<const CbcIntegerBranchingObject *>(br0);
+    const CbcIntegerBranchingObject *brPrint0 = dynamic_cast< const CbcIntegerBranchingObject * >(br0);
     const double *downBounds = brPrint0->downBounds();
     const double *upBounds = brPrint0->upBounds();
@@ -1766 +1766 @@
     int way = brPrint0->way();
     printf("   br0: var %i downBd [%i,%i] upBd [%i,%i] way %i\n",
-      variable, static_cast<int>(downBounds[0]), static_cast<int>(downBounds[1]),
-      static_cast<int>(upBounds[0]), static_cast<int>(upBounds[1]), way);
-    const CbcIntegerBranchingObject *brPrint1 = dynamic_cast<const CbcIntegerBranchingObject *>(br1);
+      variable, static_cast< int >(downBounds[0]), static_cast< int >(downBounds[1]),
+      static_cast< int >(upBounds[0]), static_cast< int >(upBounds[1]), way);
+    const CbcIntegerBranchingObject *brPrint1 = dynamic_cast< const CbcIntegerBranchingObject * >(br1);
     downBounds = brPrint1->downBounds();
     upBounds = brPrint1->upBounds();
@@ -1774 +1774 @@
     way = brPrint1->way();
     printf("   br1: var %i downBd [%i,%i] upBd [%i,%i] way %i\n",
-      variable, static_cast<int>(downBounds[0]), static_cast<int>(downBounds[1]),
-      static_cast<int>(upBounds[0]), static_cast<int>(upBounds[1]), way);
+      variable, static_cast< int >(downBounds[0]), static_cast< int >(downBounds[1]),
+      static_cast< int >(upBounds[0]), static_cast< int >(upBounds[1]), way);
 #endif
     const int brComp = compare3BranchingObjects(br0, br1);
@@ -2584 +2584 @@
     int start[2];
     int end[2];
-    int iRandom = static_cast<int>(randomNumber * (static_cast<double>(numberIntegers)));
+    int iRandom = static_cast< int >(randomNumber * (static_cast< double >(numberIntegers)));
     start[0] = iRandom;
     end[0] = numberIntegers;
@@ -3057 +3057 @@
     // get information on solver type
     OsiAuxInfo *auxInfo = model_->solver()->getAuxiliaryInfo();
-    OsiBabSolver *auxiliaryInfo = dynamic_cast<OsiBabSolver *>(auxInfo);
+    OsiBabSolver *auxiliaryInfo = dynamic_cast< OsiBabSolver * >(auxInfo);
     if (auxiliaryInfo) {
       return auxiliaryInfo->solution(solutionValue, betterSolution, model_->solver()->getNumCols());

trunk/Cbc/src/CbcHeuristic.hpp

@@ -60 +60 @@
 
 private:
-  std::vector<CbcHeuristicNode *> nodes_;
+  std::vector< CbcHeuristicNode * > nodes_;
 
 public:
@@ -76 +76 @@
   inline int size() const
   {
-    return static_cast<int>(nodes_.size());
+    return static_cast< int >(nodes_.size());
   }
 };
@@ -340 +340 @@
   {
     const OsiClpSolverInterface *clpSolver
-      = dynamic_cast<const OsiClpSolverInterface *>(solver);
+      = dynamic_cast< const OsiClpSolverInterface * >(solver);
     if (clpSolver)
       return clpSolver->isHeuristicInteger(iColumn);

trunk/Cbc/src/CbcHeuristicDINS.cpp

@@ -197 +197 @@
       double value = bestSolution[iColumn];
       double nearest = floor(value + 0.5);
-      values_[0][i] = static_cast<int>(nearest);
+      values_[0][i] = static_cast< int >(nearest);
     }
     numberKeptSolutions_ = CoinMin(numberKeptSolutions_ + 1, maximumKeepSolutions_);
@@ -246 +246 @@
           valueInt = originalUpper;
         }
-        int intValue = static_cast<int>(floor(valueInt + 0.5));
+        int intValue = static_cast< int >(floor(valueInt + 0.5));
         double currentValue = currentSolution[iColumn];
         double currentLower = colLower[iColumn];
@@ -393 +393 @@
     numberTries_++;
     if ((numberTries_ % 10) == 0 && numberSuccesses_ * 3 < numberTries_)
-      howOften_ += static_cast<int>(howOften_ * decayFactor_);
+      howOften_ += static_cast< int >(howOften_ * decayFactor_);
   }
   return finalReturnCode;

trunk/Cbc/src/CbcHeuristicDW.cpp

@@ -347 +347 @@
   int logLevel = model_->messageHandler()->logLevel();
   // For moment just OsiClp
-  OsiClpSolverInterface *solver = dynamic_cast<OsiClpSolverInterface *>(solver_);
+  OsiClpSolverInterface *solver = dynamic_cast< OsiClpSolverInterface * >(solver_);
   ClpSimplex *simplex = solver->getModelPtr();
   double *columnLower = simplex->columnLower();
@@ -851 +851 @@
     }
     if (numberInDj)
-      averageDj /= static_cast<double>(numberInDj);
+      averageDj /= static_cast< double >(numberInDj);
     if (numberInDiff)
-      averageDiff /= static_cast<double>(numberInDiff);
+      averageDiff /= static_cast< double >(numberInDiff);
     double ratioDiff = averageDj / averageDiff;
     // downplay
@@ -872 +872 @@
       if (phase_ == 99)
         blockSort[i] -= 2.0 * averageDj * goodBlock[i];
-      blockSort[i] /= static_cast<double>(intsInBlock_[i]);
+      blockSort[i] /= static_cast< double >(intsInBlock_[i]);
       //blockSort[i] /= sqrt(static_cast<double>(intsInBlock_[i]));
       if (doneBlock[i]) {
-        blockSort[i] /= static_cast<double>(doneBlock[i] + 1);
+        blockSort[i] /= static_cast< double >(doneBlock[i] + 1);
         if (whenBlock[i] > pass_ - 10)
           blockSort[i] += 1.0e2 * averageDj;
@@ -1435 +1435 @@
       if (thisBestValue * numberRowsDone > maximumBlockSize && numberRowsDone > halfway) {
         thisBestBreak = iRow;
-        thisBestValue = static_cast<double>(maximumBlockSize) / static_cast<double>(numberRowsDone);
+        thisBestValue = static_cast< double >(maximumBlockSize) / static_cast< double >(numberRowsDone);
       }
     }
@@ -1792 +1792 @@
           if (sum > 65535)
             sum = 65535;
-          unsigned short value = static_cast<unsigned short>(sum);
+          unsigned short value = static_cast< unsigned short >(sum);
           affinity_[iBlock * numberBlocks + jBlock] = value;
           affinity_[jBlock * numberBlocks + iBlock] = value;
@@ -1817 +1817 @@
       }
       sprintf(dwPrint, "Total not affinity %d - average %g%%",
-        nTotalZero, 100.0 * (static_cast<double>(nTotalZero) / (numberBlocks * numberBlocks)));
+        nTotalZero, 100.0 * (static_cast< double >(nTotalZero) / (numberBlocks * numberBlocks)));
       model_->messageHandler()->message(CBC_FPUMP1, model_->messages())
         << dwPrint
@@ -1864 +1864 @@
 #define MAX_ADD 100000
   CoinBigIndex *startsDW = new CoinBigIndex[numberBlocks_ + 1 + MAX_ADD];
-  int *rowDW = reinterpret_cast<int *>(startsDW + numberBlocks_ + 1);
+  int *rowDW = reinterpret_cast< int * >(startsDW + numberBlocks_ + 1);
   double *elementDW = new double[MAX_ADD + 3 * numberBlocks_ + numberMasterRows_];
   double *newCost = elementDW + MAX_ADD;
@@ -2172 +2172 @@
       tempColumn[numberMasterColumns++] = i;
   }
-  OsiClpSolverInterface *solver = dynamic_cast<OsiClpSolverInterface *>(solver_);
+  OsiClpSolverInterface *solver = dynamic_cast< OsiClpSolverInterface * >(solver_);
   ClpSimplex *tempModel = new ClpSimplex(solver->getModelPtr(),
     numberMasterRows, tempRow,

trunk/Cbc/src/CbcHeuristicDive.cpp

@@ -214 +214 @@
   for (int i = 0; i < numberObjects; i++) {
     OsiObject *object = model_->modifiableObject(i);
-    const CbcSimpleInteger *thisOne = dynamic_cast<const CbcSimpleInteger *>(object);
+    const CbcSimpleInteger *thisOne = dynamic_cast< const CbcSimpleInteger * >(object);
     if (!thisOne)
       continue; // Not integer
@@ -231 +231 @@
     for (int i = 0; i < numberObjects; i++) {
       OsiObject *object = model_->modifiableObject(i);
-      const CbcSimpleInteger *thisOne = dynamic_cast<const CbcSimpleInteger *>(object);
+      const CbcSimpleInteger *thisOne = dynamic_cast< const CbcSimpleInteger * >(object);
       if (!thisOne)
         continue; // Not integer
@@ -237 +237 @@
       assert(level < (1 << 29));
       assert(nInteger < numberIntegers);
-      priority_[nInteger].priority = static_cast<unsigned int>(level);
+      priority_[nInteger].priority = static_cast< unsigned int >(level);
       int direction = 0;
       if (thisOne->preferredWay() < 0)
@@ -244 +244 @@
         direction = 1 | 1;
       // at present don't try other way is not used
-      priority_[nInteger++].direction = static_cast<unsigned char>(direction);
+      priority_[nInteger++].direction = static_cast< unsigned char >(direction);
     }
     assert(nInteger == numberIntegers);
@@ -300 +300 @@
 #ifdef COIN_HAS_CLP
   OsiClpSolverInterface *clpSolver
-    = dynamic_cast<OsiClpSolverInterface *>(solver);
+    = dynamic_cast< OsiClpSolverInterface * >(solver);
   if (clpSolver) {
     ClpSimplex *clpSimplex = clpSolver->getModelPtr();
@@ -372 +372 @@
   double *random = new double[numberIntegers];
 
-  int maxNumberAtBoundToFix = static_cast<int>(floor(percentageToFix_ * numberIntegers));
+  int maxNumberAtBoundToFix = static_cast< int >(floor(percentageToFix_ * numberIntegers));
   assert(!maxNumberAtBoundToFix || !nodes);
 
@@ -515 +515 @@
     if (binVarIndex_.size()) {
       int cnt = 0;
-      int n = static_cast<int>(binVarIndex_.size());
+      int n = static_cast< int >(binVarIndex_.size());
       for (int j = 0; j < n; j++) {
         int iColumn1 = binVarIndex_[j];
@@ -595 +595 @@
           if (upper[iColumn] > lower[iColumn]) {
             int j = back[iColumn];
-            fixPriority = CoinMin(fixPriority, static_cast<int>(priority_[j].priority));
+            fixPriority = CoinMin(fixPriority, static_cast< int >(priority_[j].priority));
           }
         }
@@ -623 +623 @@
           numberFree++;
           if (priority_) {
-            fixPriority = CoinMin(fixPriority, static_cast<int>(priority_[i].priority));
+            fixPriority = CoinMin(fixPriority, static_cast< int >(priority_[i].priority));
           }
           double value = newSolution[iColumn];
@@ -662 +662 @@
         if (upper[iColumn] > lower[iColumn]) {
           if (priority_) {
-            fixPriority = CoinMin(fixPriority, static_cast<int>(priority_[i].priority));
+            fixPriority = CoinMin(fixPriority, static_cast< int >(priority_[i].priority));
           }
           double value = newSolution[iColumn];
@@ -687 +687 @@
               if (priority_[j].priority > fixPriority)
                 continue; // skip - only fix ones at high priority
-              int thisRound = static_cast<int>(priority_[j].direction);
+              int thisRound = static_cast< int >(priority_[j].direction);
               if ((thisRound & 1) != 0) {
                 // for now force way
@@ -722 +722 @@
               if (priority_[j].priority > fixPriority)
                 continue; // skip - only fix ones at high priority
-              int thisRound = static_cast<int>(priority_[j].direction);
+              int thisRound = static_cast< int >(priority_[j].direction);
               if ((thisRound & 1) != 0) {
                 // for now force way
@@ -1307 +1307 @@
       }
     }
-    downLocks_[i] = static_cast<unsigned short>(down);
-    upLocks_[i] = static_cast<unsigned short>(up);
+    downLocks_[i] = static_cast< unsigned short >(down);
+    upLocks_[i] = static_cast< unsigned short >(up);
   }
 
@@ -1432 +1432 @@
 #ifdef COIN_HAS_CLP
   OsiClpSolverInterface *clpSolver
-    = dynamic_cast<OsiClpSolverInterface *>(solver);
+    = dynamic_cast< OsiClpSolverInterface * >(solver);
   ClpSimplex *clpSimplex = NULL;
   if (clpSolver)

trunk/Cbc/src/CbcHeuristicDive.hpp

@@ -170 +170 @@
   // Indexes of binary variables with 0 objective coefficient
   // and in variable bound constraints
-  std::vector<int> binVarIndex_;
+  std::vector< int > binVarIndex_;
 
   // Indexes of variable bound rows for each binary variable
-  std::vector<int> vbRowIndex_;
+  std::vector< int > vbRowIndex_;
 
   // Percentage of integer variables to fix at bounds

trunk/Cbc/src/CbcHeuristicDiveCoefficient.cpp

@@ -121 +121 @@
         // if priorities then use
         if (priority_) {
-          int thisRound = static_cast<int>(priority_[i].direction);
+          int thisRound = static_cast< int >(priority_[i].direction);
           if ((thisRound & 1) != 0)
             round = ((thisRound & 2) == 0) ? -1 : +1;
@@ -127 +127 @@
             nLocks = COIN_INT_MAX;
           } else if (priority_[i].priority < bestPriority) {
-            bestPriority = static_cast<int>(priority_[i].priority);
+            bestPriority = static_cast< int >(priority_[i].priority);
             bestLocks = COIN_INT_MAX;
           }

trunk/Cbc/src/CbcHeuristicDiveFractional.cpp

@@ -105 +105 @@
         // if priorities then use
         if (priority_) {
-          int thisRound = static_cast<int>(priority_[i].direction);
+          int thisRound = static_cast< int >(priority_[i].direction);
           if ((thisRound & 1) != 0)
             round = ((thisRound & 2) == 0) ? -1 : +1;
@@ -111 +111 @@
             fraction = COIN_DBL_MAX;
           } else if (priority_[i].priority < bestPriority) {
-            bestPriority = static_cast<int>(priority_[i].priority);
+            bestPriority = static_cast< int >(priority_[i].priority);
             bestFraction = COIN_DBL_MAX;
           }

trunk/Cbc/src/CbcHeuristicDiveGuided.cpp

@@ -115 +115 @@
         // if priorities then use
         if (priority_) {
-          int thisRound = static_cast<int>(priority_[i].direction);
+          int thisRound = static_cast< int >(priority_[i].direction);
           if ((thisRound & 1) != 0)
             round = ((thisRound & 2) == 0) ? -1 : +1;
@@ -121 +121 @@
             fraction = COIN_DBL_MAX;
           } else if (priority_[i].priority < bestPriority) {
-            bestPriority = static_cast<int>(priority_[i].priority);
+            bestPriority = static_cast< int >(priority_[i].priority);
             bestFraction = COIN_DBL_MAX;
           }

trunk/Cbc/src/CbcHeuristicDiveLineSearch.cpp

@@ -113 +113 @@
         // if priorities then use
         if (priority_) {
-          int thisRound = static_cast<int>(priority_[i].direction);
+          int thisRound = static_cast< int >(priority_[i].direction);
           if ((thisRound & 1) != 0)
             round = ((thisRound & 2) == 0) ? -1 : +1;
@@ -119 +119 @@
             relDistance = COIN_DBL_MAX;
           } else if (priority_[i].priority < bestPriority) {
-            bestPriority = static_cast<int>(priority_[i].priority);
+            bestPriority = static_cast< int >(priority_[i].priority);
             bestRelDistance = COIN_DBL_MAX;
           }

trunk/Cbc/src/CbcHeuristicDivePseudoCost.cpp

@@ -134 +134 @@
         // if priorities then use
         if (priority_) {
-          int thisRound = static_cast<int>(priority_[i].direction);
+          int thisRound = static_cast< int >(priority_[i].direction);
           if ((thisRound & 1) != 0)
             round = ((thisRound & 2) == 0) ? -1 : +1;
@@ -140 +140 @@
             score = COIN_DBL_MAX;
           } else if (priority_[i].priority < bestPriority) {
-            bestPriority = static_cast<int>(priority_[i].priority);
+            bestPriority = static_cast< int >(priority_[i].priority);
             bestScore = COIN_DBL_MAX;
           }
@@ -175 +175 @@
     OsiObject **objects = model_->objects();
     for (int i = 0; i < numberInts; i++) {
-      CbcSimpleIntegerDynamicPseudoCost *obj1 = dynamic_cast<CbcSimpleIntegerDynamicPseudoCost *>(objects[i]);
+      CbcSimpleIntegerDynamicPseudoCost *obj1 = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(objects[i]);
       if (obj1) {
         //int iColumn = obj1->columnNumber();

trunk/Cbc/src/CbcHeuristicDiveVectorLength.cpp

@@ -114 +114 @@
 
         // we want the smaller score
-        double score = objDelta / (static_cast<double>(columnLength[iColumn]) + 1.0);
+        double score = objDelta / (static_cast< double >(columnLength[iColumn]) + 1.0);
 
         // if variable is not binary, penalize it
@@ -122 +122 @@
         // if priorities then use
         if (priority_) {
-          int thisRound = static_cast<int>(priority_[i].direction);
+          int thisRound = static_cast< int >(priority_[i].direction);
           if ((thisRound & 1) != 0)
             round = ((thisRound & 2) == 0) ? -1 : +1;
@@ -128 +128 @@
             score = COIN_DBL_MAX;
           } else if (priority_[i].priority < bestPriority) {
-            bestPriority = static_cast<int>(priority_[i].priority);
+            bestPriority = static_cast< int >(priority_[i].priority);
             bestScore = COIN_DBL_MAX;
           }

trunk/Cbc/src/CbcHeuristicFPump.cpp

@@ -327 +327 @@
 #ifndef NDEBUG
     const OsiObject *object = model_->object(i);
-    const CbcSimpleInteger *integerObject = dynamic_cast<const CbcSimpleInteger *>(object);
-    const OsiSimpleInteger *integerObject2 = dynamic_cast<const OsiSimpleInteger *>(object);
+    const CbcSimpleInteger *integerObject = dynamic_cast< const CbcSimpleInteger * >(object);
+    const OsiSimpleInteger *integerObject2 = dynamic_cast< const OsiSimpleInteger * >(object);
     assert(integerObject || integerObject2);
 #endif
@@ -444 +444 @@
 */
   CoinWarmStartBasis saveBasis;
-  CoinWarmStartBasis *basis = dynamic_cast<CoinWarmStartBasis *>(model_->solver()->getWarmStart());
+  CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(model_->solver()->getWarmStart());
   if (basis) {
     saveBasis = *basis;
@@ -516 +516 @@
   {
     OsiClpSolverInterface *clpSolver
-      = dynamic_cast<OsiClpSolverInterface *>(model_->solver());
+      = dynamic_cast< OsiClpSolverInterface * >(model_->solver());
     if (clpSolver) {
       if (maximumPasses == 30) {
@@ -565 +565 @@
     {
       OsiClpSolverInterface *clpSolver
-        = dynamic_cast<OsiClpSolverInterface *>(solver);
+        = dynamic_cast< OsiClpSolverInterface * >(solver);
       if (clpSolver) {
         // better to clean up using primal?
@@ -722 +722 @@
     }
     if (scaleFactor)
-      scaleFactor = (initialWeight_ * sqrt(static_cast<double>(numberIntegers))) / sqrt(scaleFactor);
+      scaleFactor = (initialWeight_ * sqrt(static_cast< double >(numberIntegers))) / sqrt(scaleFactor);
 #ifdef CLP_INVESTIGATE
 #ifdef COIN_DEVELOP
@@ -811 +811 @@
       {
         OsiClpSolverInterface *clpSolver
-          = dynamic_cast<OsiClpSolverInterface *>(clonedSolver);
+          = dynamic_cast< OsiClpSolverInterface * >(clonedSolver);
         //printf("real cutoff %g fake %g - second pass %c\n",realCutoff,cutoff,
         //     secondMajorPass ? 'Y' : 'N');
@@ -1033 +1033 @@
             if (exitNow(newSolutionValue))
               exitAll = true;
-            CoinWarmStartBasis *basis = dynamic_cast<CoinWarmStartBasis *>(solver->getWarmStart());
+            CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver->getWarmStart());
             if (basis) {
               bestBasis = *basis;
@@ -1304 +1304 @@
             if (newSolutionValue < solutionValue) {
               memcpy(betterSolution, newSolution, numberColumns * sizeof(double));
-              CoinWarmStartBasis *basis = dynamic_cast<CoinWarmStartBasis *>(solver->getWarmStart());
+              CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver->getWarmStart());
               solutionFound = true;
               numberSolutions++;
@@ -1360 +1360 @@
             if (dualPass == 1 && 2 * numberChanged < numberColumns && (numberChanged < 5000 || 6 * numberChanged < numberColumns)) {
               // but we need to make infeasible
-              CoinWarmStartBasis *basis = dynamic_cast<CoinWarmStartBasis *>(solver->getWarmStart());
+              CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver->getWarmStart());
               if (basis) {
                 // modify
@@ -1466 +1466 @@
               if (numberTries == 1 || secondPassOpt > 3) {
                 // save basis
-                CoinWarmStartBasis *basis = dynamic_cast<CoinWarmStartBasis *>(solver->getWarmStart());
+                CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver->getWarmStart());
                 if (basis) {
                   saveBasis = *basis;
@@ -2181 +2181 @@
 #ifdef COIN_HAS_CLP
             OsiClpSolverInterface *clpSolver
-              = dynamic_cast<OsiClpSolverInterface *>(newSolver);
+              = dynamic_cast< OsiClpSolverInterface * >(newSolver);
             if (clpSolver) {
               ClpSimplex *simplex = clpSolver->getModelPtr();
@@ -2289 +2289 @@
           if (exitNow(newSolutionValue))
             exitAll = true;
-          CoinWarmStartBasis *basis = dynamic_cast<CoinWarmStartBasis *>(newSolver->getWarmStart());
+          CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(newSolver->getWarmStart());
           if (basis) {
             bestBasis = *basis;
@@ -2436 +2436 @@
     printf("XXX total iterations %d ratios - %g %g %g\n",
       totalNumberIterations,
-      static_cast<double>(totalNumberIterations) / nrow,
-      static_cast<double>(totalNumberIterations) / ncol,
-      static_cast<double>(totalNumberIterations) / (2 * nrow + 2 * ncol));
+      static_cast< double >(totalNumberIterations) / nrow,
+      static_cast< double >(totalNumberIterations) / ncol,
+      static_cast< double >(totalNumberIterations) / (2 * nrow + 2 * ncol));
   }
 #endif
@@ -2486 +2486 @@
         } else {
           general++;
-          int up = static_cast<int>(upper[iColumn]);
-          int lo = static_cast<int>(lower[iColumn]);
-          int near = static_cast<int>(nearest);
+          int up = static_cast< int >(upper[iColumn]);
+          int lo = static_cast< int >(lower[iColumn]);
+          int near = static_cast< int >(nearest);
           up = CoinMin(up, near + maxAround);
           lo = CoinMax(lo, near - maxAround);
@@ -2533 +2533 @@
 #endif
         if (upper[iColumn] - lower[iColumn] > 1.000001) {
-          int up = static_cast<int>(upper[iColumn]);
-          int lo = static_cast<int>(lower[iColumn]);
+          int up = static_cast< int >(upper[iColumn]);
+          int lo = static_cast< int >(lower[iColumn]);
           addLower[nAddRow] = lo;
           addUpper[nAddRow] = lo;
@@ -2611 +2611 @@
   int flip_down = 0;
   double v = randomNumberGenerator_.randomDouble() * 20.0;
-  int nn = 10 + static_cast<int>(v);
+  int nn = 10 + static_cast< int >(v);
   int nnv = 0;
   int *list = new int[nn];
@@ -2776 +2776 @@
     double *saveSolution = CoinCopyOfArray(solution, numberColumns);
     double *tempSolution = CoinCopyOfArray(solution, numberColumns);
-    CoinWarmStartBasis *saveBasis = dynamic_cast<CoinWarmStartBasis *>(solver->getWarmStart());
+    CoinWarmStartBasis *saveBasis = dynamic_cast< CoinWarmStartBasis * >(solver->getWarmStart());
     for (i = 0; i < numberIntegers; i++) {
       int iColumn = integerVariable[i];
@@ -3231 +3231 @@
   if (model) {
     osiModel_
-      = dynamic_cast<OsiClpSolverInterface *>(model->solver());
+      = dynamic_cast< OsiClpSolverInterface * >(model->solver());
     if (osiModel_)
       setSimplex(osiModel_->getModelPtr());
@@ -3289 +3289 @@
   if (model) {
     osiModel_
-      = dynamic_cast<OsiClpSolverInterface *>(model->solver());
+      = dynamic_cast< OsiClpSolverInterface * >(model->solver());
     if (osiModel_)
       setSimplex(osiModel_->getModelPtr());

trunk/Cbc/src/CbcHeuristicGreedy.cpp

@@ -1715 +1715 @@
     } else {
       if (iPass == 0) {
-        costBias = 10.0 * newSolutionValue / static_cast<double>(nAdded);
+        costBias = 10.0 * newSolutionValue / static_cast< double >(nAdded);
       } else {
         costBias *= 10.0;

trunk/Cbc/src/CbcHeuristicLocal.cpp

@@ -504 +504 @@
     if (value < originalUpper - 0.5)
       iway |= 2;
-    way[i] = static_cast<char>(iway);
+    way[i] = static_cast< char >(iway);
   }
   /*
@@ -570 +570 @@
 #ifdef COIN_HAS_CLP
     OsiClpSolverInterface *clpSolver
-      = dynamic_cast<OsiClpSolverInterface *>(model_->solver());
+      = dynamic_cast< OsiClpSolverInterface * >(model_->solver());
     if (clpSolver) {
       // take out some integers
@@ -850 +850 @@
         if (value < originalUpper - 0.5)
           iway |= 2;
-        way[goodK] = static_cast<char>(iway);
+        way[goodK] = static_cast< char >(iway);
         totalChange += bestChange;
       }
@@ -915 +915 @@
         // new solution
         memcpy(betterSolution, newSolution, numberColumns * sizeof(double));
-        CoinWarmStartBasis *basis = dynamic_cast<CoinWarmStartBasis *>(solver->getWarmStart());
+        CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver->getWarmStart());
         if (basis) {
           model_->setBestSolutionBasis(*basis);
@@ -1089 +1089 @@
     // clone feasibility pump
     for (int i = 0; i < model_->numberHeuristics(); i++) {
-      const CbcHeuristicFPump *pump = dynamic_cast<const CbcHeuristicFPump *>(model_->heuristic(i));
+      const CbcHeuristicFPump *pump = dynamic_cast< const CbcHeuristicFPump * >(model_->heuristic(i));
       if (pump) {
         feasibilityPump_ = new CbcHeuristicFPump(*pump);
@@ -1162 +1162 @@
     pumpAdded = true;
     for (int i = 0; i < model_->numberHeuristics(); i++) {
-      const CbcHeuristicFPump *pump = dynamic_cast<const CbcHeuristicFPump *>(model_->heuristic(i));
+      const CbcHeuristicFPump *pump = dynamic_cast< const CbcHeuristicFPump * >(model_->heuristic(i));
       if (pump) {
         pumpAdded = false;
@@ -1209 +1209 @@
       solutionValue += obj[i] * betterSolution[i];
       if (isHeuristicInteger(solver, i)) {
-        int change = static_cast<int>(floor(solutionIn[i] - betterSolution[i] + 0.5));
+        int change = static_cast< int >(floor(solutionIn[i] - betterSolution[i] + 0.5));
         if (change > 0) {
           numberIncrease++;
@@ -1345 +1345 @@
   bool solutionFound = false;
   CoinWarmStartBasis saveBasis;
-  CoinWarmStartBasis *basis = dynamic_cast<CoinWarmStartBasis *>(solver->getWarmStart());
+  CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver->getWarmStart());
   if (basis) {
     saveBasis = *basis;

trunk/Cbc/src/CbcHeuristicLocal.hpp

@@ -262 +262 @@
   // Data
   /// Attempts
-  std::vector<double> attempts_;
+  std::vector< double > attempts_;
   /// Random numbers to stop same search happening
   double random_[10];

trunk/Cbc/src/CbcHeuristicPivotAndFix.cpp

@@ -107 +107 @@
 
   OsiClpSolverInterface *clpSolverOriginal
-    = dynamic_cast<OsiClpSolverInterface *>(model_->solver());
+    = dynamic_cast< OsiClpSolverInterface * >(model_->solver());
   assert(clpSolverOriginal);
   OsiClpSolverInterface *clpSolver(clpSolverOriginal);

trunk/Cbc/src/CbcHeuristicRENS.cpp

@@ -145 +145 @@
     double total = 0.0;
     int n = 0;
-    CoinWarmStartBasis *basis = dynamic_cast<CoinWarmStartBasis *>(solver->getWarmStart());
+    CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver->getWarmStart());
     if (basis && basis->getNumArtificial()) {
       for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
@@ -154 +154 @@
       }
       if (n)
-        djTolerance = (0.01 * total) / static_cast<double>(n);
+        djTolerance = (0.01 * total) / static_cast< double >(n);
       delete basis;
     }
@@ -169 +169 @@
     // SOS type fixing
     bool fixSets = (type == 5) || (type == 7) || (type == 10) || (type == 11);
-    CoinWarmStartBasis *basis = dynamic_cast<CoinWarmStartBasis *>(solver->getWarmStart());
+    CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver->getWarmStart());
     if (basis && basis->getNumArtificial()) {
       //const double * rowLower = solver->getRowLower();
@@ -281 +281 @@
         if (type < 10) {
           std::sort(sort, sort + nSOS);
-          int last = static_cast<int>(nSOS * 0.9 * fractionSmall_);
+          int last = static_cast< int >(nSOS * 0.9 * fractionSmall_);
           double tolerance = sort[last];
           for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
@@ -364 +364 @@
             }
           }
-          double averagePerSet = sum / static_cast<double>(numberRows);
+          double averagePerSet = sum / static_cast< double >(numberRows);
           // allow this extra
           double factor = averagePerSet * fractionSmall_ * numberRows;
@@ -441 +441 @@
           char *nonzero = new char[numberColumns];
           // save basis and solution
-          CoinWarmStartBasis *basis = dynamic_cast<CoinWarmStartBasis *>(newSolver->getWarmStart());
+          CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(newSolver->getWarmStart());
           assert(basis != NULL);
           double *saveSolution = CoinCopyOfArray(newSolver->getColSolution(),
@@ -510 +510 @@
           }
           int nFixed = 0;
-          int numberSetsToFix = static_cast<int>(nSOS * (1.0 - proportion));
+          int numberSetsToFix = static_cast< int >(nSOS * (1.0 - proportion));
           int *mixed = new int[numberRows];
           memset(mixed, 0, numberRows * sizeof(int));
@@ -601 +601 @@
     }
     std::sort(sort, sort + numberColumns);
-    int last = static_cast<int>(numberColumns * fractionSmall_);
+    int last = static_cast< int >(numberColumns * fractionSmall_);
     djTolerance = CoinMax(sort[last], 1.0e-5);
     delete[] sort;
@@ -655 +655 @@
       chunk[i] = -1;
       if (whichRow[i]) {
-        contribution[i] = -contribution[i] / static_cast<double>(whichRow[i]);
+        contribution[i] = -contribution[i] / static_cast< double >(whichRow[i]);
       } else {
         contribution[i] = COIN_DBL_MAX;
@@ -856 +856 @@
         double *sort = new double[nAtLb];
         int *which = new int[nAtLb];
-        double threshold = CoinMax((0.01 * sumDj) / static_cast<double>(nAtLb), 1.0e-6);
+        double threshold = CoinMax((0.01 * sumDj) / static_cast< double >(nAtLb), 1.0e-6);
         int nFix2 = 0;
         for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
@@ -913 +913 @@
           double *sort = new double[nAtLb];
           int *which = new int[nAtLb];
-          double threshold = CoinMax((0.01 * sumDj) / static_cast<double>(nAtLb), 1.0e-6);
+          double threshold = CoinMax((0.01 * sumDj) / static_cast< double >(nAtLb), 1.0e-6);
           int nFix2 = 0;
           for (int iColumn = 0; iColumn < numberColumns; iColumn++) {

trunk/Cbc/src/CbcHeuristicRINS.cpp

@@ -369 +369 @@
     numberTries_++;
     if ((numberTries_ % 10) == 0 && numberSuccesses_ * 3 < numberTries_)
-      howOften_ += static_cast<int>(howOften_ * decayFactor_);
+      howOften_ += static_cast< int >(howOften_ * decayFactor_);
     delete newSolver;
   }

trunk/Cbc/src/CbcHeuristicRandRound.cpp

@@ -24 +24 @@
 static inline int intRand(const int range)
 {
-  return static_cast<int>(floor(CoinDrand48() * range));
+  return static_cast< int >(floor(CoinDrand48() * range));
 }
 
@@ -130 +130 @@
   double primalTolerance;
   solver->getDblParam(OsiPrimalTolerance, primalTolerance);
-  OsiClpSolverInterface *clpSolver = dynamic_cast<OsiClpSolverInterface *>(solver);
+  OsiClpSolverInterface *clpSolver = dynamic_cast< OsiClpSolverInterface * >(solver);
   assert(clpSolver);
   ClpSimplex *simplex = clpSolver->getModelPtr();
@@ -221 +221 @@
 
   double *newObj = new double[numCols];
-  srand(static_cast<unsigned int>(time(NULL) + 1));
+  srand(static_cast< unsigned int >(time(NULL) + 1));
   int randNum;
 
@@ -307 +307 @@
   // rlh: use some COIN max instead of 1e30 (?)
   double bestObj = 1e30;
-  std::vector<std::vector<double>> feasibles;
+  std::vector< std::vector< double > > feasibles;
   int numFeasibles = 0;
 
@@ -360 +360 @@
       if (feasibility) {
         numFeasibles++;
-        feasibles.push_back(std::vector<double>(numCols));
+        feasibles.push_back(std::vector< double >(numCols));
         for (int k = 0; k < numCols; k++)
           feasibles[numFeasibles - 1][k] = cornerPoints[i][k];
@@ -388 +388 @@
   //-------------------------------------------
 
-  srand(static_cast<unsigned int>(time(NULL) + 1));
+  srand(static_cast< unsigned int >(time(NULL) + 1));
   int numRandomPoints = 0;
   while (numRandomPoints < 50000) {
@@ -458 +458 @@
         printf("%.2f\n", CoinCpuTime() - start);
         numFeasibles++;
-        feasibles.push_back(std::vector<double>(numCols));
+        feasibles.push_back(std::vector< double >(numCols));
         for (int i = 0; i < numCols; i++)
           feasibles[numFeasibles - 1][i] = roundRp[i];

trunk/Cbc/src/CbcHeuristicVND.cpp

@@ -284 +284 @@
       numberTries_++;
       if ((numberTries_ % 10) == 0 && numberSuccesses_ * 3 < numberTries_)
-        howOften_ += static_cast<int>(howOften_ * decayFactor_);
+        howOften_ += static_cast< int >(howOften_ * decayFactor_);
     }
 

trunk/Cbc/src/CbcLinked.cpp

@@ -145 +145 @@
       temp->removeGaps(1.0e-14);
       ClpMatrixBase *save = modelPtr_->clpMatrix();
-      ClpPackedMatrix *clpMatrix = dynamic_cast<ClpPackedMatrix *>(save);
+      ClpPackedMatrix *clpMatrix = dynamic_cast< ClpPackedMatrix * >(save);
       assert(clpMatrix);
       if (save->getNumRows() > temp->getNumRows()) {
@@ -238 +238 @@
             CbcCutGenerator *generator = cbcModel_->cutGenerator(iGenerator);
             CglCutGenerator *gen = generator->generator();
-            CglStored *gen2 = dynamic_cast<CglStored *>(gen);
+            CglStored *gen2 = dynamic_cast< CglStored * >(gen);
             if (gen2) {
               // add OA cut
@@ -311 +311 @@
       temp->removeGaps(1.0e-14);
       ClpMatrixBase *save = modelPtr_->clpMatrix();
-      ClpPackedMatrix *clpMatrix = dynamic_cast<ClpPackedMatrix *>(save);
+      ClpPackedMatrix *clpMatrix = dynamic_cast< ClpPackedMatrix * >(save);
       assert(clpMatrix);
       if (save->getNumRows() > temp->getNumRows()) {
@@ -435 +435 @@
         // and now rest
         for (i = 0; i < numberObjects_; i++) {
-          OsiBiLinear *obj = dynamic_cast<OsiBiLinear *>(object_[i]);
+          OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(object_[i]);
           if (obj) {
             value += obj->xyCoefficient(solution);
@@ -447 +447 @@
           bestObjectiveValue_ = value;
           if (maxIts <= 10000 && cbcModel_) {
-            OsiSolverLink *solver2 = dynamic_cast<OsiSolverLink *>(cbcModel_->solver());
+            OsiSolverLink *solver2 = dynamic_cast< OsiSolverLink * >(cbcModel_->solver());
             assert(solver2);
             if (solver2 != this) {
@@ -465 +465 @@
               CbcCutGenerator *generator = cbcModel_->cutGenerator(iGenerator);
               CglCutGenerator *gen = generator->generator();
-              CglStored *gen2 = dynamic_cast<CglStored *>(gen);
+              CglStored *gen2 = dynamic_cast< CglStored * >(gen);
               if (gen2) {
                 cbcModel_->lockThread();
@@ -485 +485 @@
                   gradient[column2[i]] = element[i];
                 for (i = 0; i < numberObjects_; i++) {
-                  OsiBiLinear *obj = dynamic_cast<OsiBiLinear *>(object_[i]);
+                  OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(object_[i]);
                   if (obj) {
                     int xColumn = obj->xColumn();
@@ -530 +530 @@
         double gap = 0.0;
         for (i = 0; i < numberObjects_; i++) {
-          OsiBiLinear *obj = dynamic_cast<OsiBiLinear *>(object_[i]);
+          OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(object_[i]);
           if (obj) {
             if (obj->xMeshSize() < 1.0 && obj->yMeshSize() < 1.0) {
@@ -552 +552 @@
             double newGap = 0.0;
             for (i = 0; i < numberObjects_; i++) {
-              OsiBiLinear *obj = dynamic_cast<OsiBiLinear *>(object_[i]);
+              OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(object_[i]);
               if (obj && (obj->branchingStrategy() & 8) == 0) {
                 if (obj->xMeshSize() < 1.0 && obj->yMeshSize() < 1.0) {
@@ -657 +657 @@
             CbcCutGenerator *generator = cbcModel_->cutGenerator(iGenerator);
             CglCutGenerator *gen = generator->generator();
-            CglTemporary *gen2 = dynamic_cast<CglTemporary *>(gen);
+            CglTemporary *gen2 = dynamic_cast< CglTemporary * >(gen);
             if (gen2) {
               double *solution2 = NULL;
@@ -702 +702 @@
           CbcCutGenerator *generator = cbcModel_->cutGenerator(iGenerator);
           CglCutGenerator *gen = generator->generator();
-          CglTemporary *gen2 = dynamic_cast<CglTemporary *>(gen);
+          CglTemporary *gen2 = dynamic_cast< CglTemporary * >(gen);
           if (gen2) {
             const double *solution = getColSolution();
@@ -731 +731 @@
                 gradient[column2[i]] = element[i];
               for (i = startNonLinear_[iNon]; i < startNonLinear_[iNon + 1]; i++) {
-                OsiBiLinear *obj = dynamic_cast<OsiBiLinear *>(object_[whichNonLinear_[i]]);
+                OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(object_[whichNonLinear_[i]]);
                 assert(obj);
                 int xColumn = obj->xColumn();
@@ -809 +809 @@
   //const double * columnUpper = modelPtr_->columnUpper();
   for (i = 0; i < numberObjects_; i++) {
-    OsiBiLinear *obj = dynamic_cast<OsiBiLinear *>(object_[i]);
+    OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(object_[i]);
     if (obj) {
       int xColumn = obj->xColumn();
@@ -1221 +1221 @@
     double *sort = new double[nBi];
     nBi = nInt;
-    const OsiObject **justBi = const_cast<const OsiObject **>(objects + nInt);
+    const OsiObject **justBi = const_cast< const OsiObject ** >(objects + nInt);
     for (iColumn = 0; iColumn < numberColumns; iColumn++) {
       if (quadraticObjective)
@@ -1419 +1419 @@
       CoinZeroN(whichRows, numberRows2);
       for (i = 0; i < numberObjects_; i++) {
-        OsiBiLinear *obj = dynamic_cast<OsiBiLinear *>(object_[i]);
+        OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(object_[i]);
         if (obj) {
           int xyRow = obj->xyRow();
@@ -1452 +1452 @@
       whichNonLinear_ = new int[n];
       for (i = 0; i < numberObjects_; i++) {
-        OsiBiLinear *obj = dynamic_cast<OsiBiLinear *>(object_[i]);
+        OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(object_[i]);
         if (obj) {
           int xyRow = obj->xyRow();
@@ -1476 +1476 @@
   const double *rowUpper = getRowUpper();
   for (int iObject = 0; iObject < numberObjects_; iObject++) {
-    OsiBiLinear *obj = dynamic_cast<OsiBiLinear *>(object_[iObject]);
+    OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(object_[iObject]);
     if (obj) {
       int xyRow = obj->xyRow();
@@ -1551 +1551 @@
   int i;
   for (i = 0; i < numberObjects_; i++) {
-    OsiBiLinear *obj = dynamic_cast<OsiBiLinear *>(object_[i]);
+    OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(object_[i]);
     if (obj) {
       //obj->setBranchingStrategy(4); // ***** temp
@@ -1738 +1738 @@
   int i;
   for (i = 0; i < numberObjects_; i++) {
-    OsiBiLinear *obj = dynamic_cast<OsiBiLinear *>(object_[i]);
+    OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(object_[i]);
     if (obj) {
       if (obj->xMeshSize() < 1.0 && obj->yMeshSize() < 1.0) {
@@ -1776 +1776 @@
   int i;
   for (i = 0; i < numberObjects_; i++) {
-    OsiBiLinear *obj = dynamic_cast<OsiBiLinear *>(object_[i]);
+    OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(object_[i]);
     if (obj) {
       bool change = false;
@@ -1812 +1812 @@
   int i;
   for (i = 0; i < numberObjects_; i++) {
-    OsiBiLinear *obj = dynamic_cast<OsiBiLinear *>(object_[i]);
+    OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(object_[i]);
     if (obj) {
       if (obj->xMeshSize() < 1.0 && obj->yMeshSize() < 1.0) {
@@ -2510 +2510 @@
     CbcModel *cbcModel = &model2;
     OsiSolverInterface *osiModel = model2.solver();
-    OsiClpSolverInterface *osiclpModel = dynamic_cast<OsiClpSolverInterface *>(osiModel);
+    OsiClpSolverInterface *osiclpModel = dynamic_cast< OsiClpSolverInterface * >(osiModel);
     ClpSimplex *clpModel = osiclpModel->getModelPtr();
 
@@ -2607 +2607 @@
     cbcModel->initialSolve();
     cbcModel->branchAndBound();
-    OsiSolverLinearizedQuadratic *solver3 = dynamic_cast<OsiSolverLinearizedQuadratic *>(model2.solver());
+    OsiSolverLinearizedQuadratic *solver3 = dynamic_cast< OsiSolverLinearizedQuadratic * >(model2.solver());
     assert(solver3);
     solution = solver3->bestSolution();
@@ -2665 +2665 @@
     const double *upper = getColUpper();
     for (int iObject = 0; iObject < numberObjects_; iObject++) {
-      OsiSimpleInteger *obj = dynamic_cast<OsiSimpleInteger *>(object_[iObject]);
+      OsiSimpleInteger *obj = dynamic_cast< OsiSimpleInteger * >(object_[iObject]);
       if (obj && (obj->priority() < biLinearPriority_ || biLinearPriority_ <= 0)) {
         int iColumn = obj->columnNumber();
@@ -2692 +2692 @@
     memset(mark, 0, numberColumns);
     for (int iObject = 0; iObject < numberObjects_; iObject++) {
-      OsiSimpleInteger *obj = dynamic_cast<OsiSimpleInteger *>(object_[iObject]);
+      OsiSimpleInteger *obj = dynamic_cast< OsiSimpleInteger * >(object_[iObject]);
       if (obj && obj->priority() < biLinearPriority_) {
         int iColumn = obj->columnNumber();
@@ -2700 +2700 @@
         mark[iColumn] = 1;
       }
-      OsiBiLinear *objB = dynamic_cast<OsiBiLinear *>(object_[iObject]);
+      OsiBiLinear *objB = dynamic_cast< OsiBiLinear * >(object_[iObject]);
       if (objB) {
         // if one or both continuous then fix one
@@ -2723 +2723 @@
     newSolver.loadFromCoinModel(tempModel, true);
     for (int iObject = 0; iObject < numberObjects_; iObject++) {
-      OsiSimpleInteger *obj = dynamic_cast<OsiSimpleInteger *>(object_[iObject]);
+      OsiSimpleInteger *obj = dynamic_cast< OsiSimpleInteger * >(object_[iObject]);
       if (obj && obj->priority() < biLinearPriority_) {
         int iColumn = obj->columnNumber();
@@ -2731 +2731 @@
         newSolver.setColUpper(iColumn, value);
       }
-      OsiBiLinear *objB = dynamic_cast<OsiBiLinear *>(object_[iObject]);
+      OsiBiLinear *objB = dynamic_cast< OsiBiLinear * >(object_[iObject]);
       if (objB) {
         // if one or both continuous then fix one
@@ -2752 +2752 @@
   CbcModel *cbcModel = &model;
   OsiSolverInterface *osiModel = model.solver();
-  OsiClpSolverInterface *osiclpModel = dynamic_cast<OsiClpSolverInterface *>(osiModel);
+  OsiClpSolverInterface *osiclpModel = dynamic_cast< OsiClpSolverInterface * >(osiModel);
   ClpSimplex *clpModel = osiclpModel->getModelPtr();
   CglProbing probing;
@@ -2933 +2933 @@
     int n = 0;
     for (i = startNonLinear_[iNon]; i < startNonLinear_[iNon + 1]; i++) {
-      OsiBiLinear *obj = dynamic_cast<OsiBiLinear *>(object_[whichNonLinear_[i]]);
+      OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(object_[whichNonLinear_[i]]);
       assert(obj);
       int xColumn = obj->xColumn();
@@ -3216 +3216 @@
   int numberChanged = 0;
   for (int iObject = 0; iObject < numberObjects_; iObject++) {
-    OsiBiLinear *obj = dynamic_cast<OsiBiLinear *>(object_[iObject]);
+    OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(object_[iObject]);
     if (obj) {
       numberChanged += obj->updateCoefficients(lower, upper, objective, matrix, &basis_);
@@ -3242 +3242 @@
   int i;
   for (i = 0; i < numberObjects_; i++) {
-    OsiSimpleInteger *obj = dynamic_cast<OsiSimpleInteger *>(object_[i]);
+    OsiSimpleInteger *obj = dynamic_cast< OsiSimpleInteger * >(object_[i]);
     if (obj) {
 #ifndef NDEBUG
@@ -3261 +3261 @@
     CoinZeroN(highPriority, numberColumns);
     for (i = 0; i < numberObjects_; i++) {
-      OsiSimpleInteger *obj = dynamic_cast<OsiSimpleInteger *>(object_[i]);
+      OsiSimpleInteger *obj = dynamic_cast< OsiSimpleInteger * >(object_[i]);
       if (obj) {
         int iColumn = obj->columnNumber();
@@ -3422 +3422 @@
     bool onOptimalPath = true;
     for (i = 0; i < 7; i++) {
-      if (static_cast<int>(upper[i]) != fake[i])
+      if (static_cast< int >(upper[i]) != fake[i])
         onOptimalPath = false;
     }
@@ -3450 +3450 @@
     CbcModel *cbcModel = &model;
     OsiSolverInterface *osiModel = model.solver();
-    OsiClpSolverInterface *osiclpModel = dynamic_cast<OsiClpSolverInterface *>(osiModel);
+    OsiClpSolverInterface *osiclpModel = dynamic_cast< OsiClpSolverInterface * >(osiModel);
     ClpSimplex *clpModel = osiclpModel->getModelPtr();
     CglProbing probing;
@@ -3589 +3589 @@
           cbcModel->setMaximumSolutions(1); // just getting a solution
 #ifdef JJF_ZERO
-          OsiClpSolverInterface *osiclpModel = dynamic_cast<OsiClpSolverInterface *>(cbcModel->solver());
+          OsiClpSolverInterface *osiclpModel = dynamic_cast< OsiClpSolverInterface * >(cbcModel->solver());
           ClpSimplex *clpModel = osiclpModel->getModelPtr();
           const double *element = clpModel->matrix()->getMutableElements();
@@ -3797 +3797 @@
   }
   boundElementAction action;
-  action.affect = static_cast<unsigned char>(upperBoundAffected ? 1 : 0);
-  action.ubUsed = static_cast<unsigned char>(useUpperBound ? 1 : 0);
+  action.affect = static_cast< unsigned char >(upperBoundAffected ? 1 : 0);
+  action.ubUsed = static_cast< unsigned char >(useUpperBound ? 1 : 0);
   action.type = 2;
-  action.affected = static_cast<short int>(whichVariable);
+  action.affected = static_cast< short int >(whichVariable);
   action.multiplier = multiplier;
   affected_[numberAffected_++] = action;
@@ -3907 +3907 @@
     return 0;
   OsiSolverLink *clpSolver
-    = dynamic_cast<OsiSolverLink *>(model_->solver());
+    = dynamic_cast< OsiSolverLink * >(model_->solver());
   assert(clpSolver);
   double newSolutionValue = clpSolver->bestObjectiveValue();
@@ -4105 +4105 @@
     weight /= sum;
     valueInfeasibility = lastNonZero - firstNonZero + 1;
-    valueInfeasibility *= 0.5 / static_cast<double>(numberMembers_);
+    valueInfeasibility *= 0.5 / static_cast< double >(numberMembers_);
     //#define DISTANCE
 #ifdef DISTANCE
@@ -4495 +4495 @@
 OsiOldLinkBranchingObject::branch(OsiSolverInterface *solver)
 {
-  const OsiOldLink *set = dynamic_cast<const OsiOldLink *>(originalObject_);
+  const OsiOldLink *set = dynamic_cast< const OsiOldLink * >(originalObject_);
   assert(set);
   int way = (!branchIndex_) ? (2 * firstBranch_ - 1) : -(2 * firstBranch_ - 1);
@@ -4543 +4543 @@
 void OsiOldLinkBranchingObject::print(const OsiSolverInterface *solver)
 {
-  const OsiOldLink *set = dynamic_cast<const OsiOldLink *>(originalObject_);
+  const OsiOldLink *set = dynamic_cast< const OsiOldLink * >(originalObject_);
   assert(set);
   int way = (!branchIndex_) ? (2 * firstBranch_ - 1) : -(2 * firstBranch_ - 1);
@@ -4829 +4829 @@
   for (i = numberExistingObjects - 1; i >= 0; i--) {
     const OsiObject *obj = objects[i];
-    const OsiBiLinear *obj2 = dynamic_cast<const OsiBiLinear *>(obj);
+    const OsiBiLinear *obj2 = dynamic_cast< const OsiBiLinear * >(obj);
     if (obj2) {
       if (xColumn_ == obj2->xColumn_ && !xDone) {
@@ -4962 +4962 @@
   for (i = 0; i < nAdd; i++) {
     CoinBigIndex iStart = starts[i];
-    coinModel->addRow(static_cast<int>(starts[i + 1] - iStart),
+    coinModel->addRow(static_cast< int >(starts[i + 1] - iStart),
       index + iStart, element + iStart,
       rowLower[i], rowUpper[i]);
@@ -5060 +5060 @@
   for (i = 0; i < 4; i++) {
     CoinBigIndex iStart = starts[i];
-    coinModel->addColumn(static_cast<int>(starts[i + 1] - iStart),
+    coinModel->addColumn(static_cast< int >(starts[i + 1] - iStart),
       index + iStart, element + iStart, columnLower[i],
       columnUpper[i], objective[i]);
@@ -5080 +5080 @@
   for (i = numberExistingObjects - 1; i >= 0; i--) {
     const OsiObject *obj = objects[i];
-    const OsiBiLinear *obj2 = dynamic_cast<const OsiBiLinear *>(obj);
+    const OsiBiLinear *obj2 = dynamic_cast< const OsiBiLinear * >(obj);
     if (obj2) {
       if (xColumn_ == obj2->xColumn_ && !xDone) {
@@ -6547 +6547 @@
   int chosen)
   : OsiTwoWayBranchingObject(solver, set, way, separator)
-  , chosen_(static_cast<short int>(chosen))
+  , chosen_(static_cast< short int >(chosen))
 {
   assert(chosen_ >= 0 && chosen_ < 2);
@@ -6582 +6582 @@
 OsiBiLinearBranchingObject::branch(OsiSolverInterface *solver)
 {
-  const OsiBiLinear *set = dynamic_cast<const OsiBiLinear *>(originalObject_);
+  const OsiBiLinear *set = dynamic_cast< const OsiBiLinear * >(originalObject_);
   assert(set);
   int way = (!branchIndex_) ? (2 * firstBranch_ - 1) : -(2 * firstBranch_ - 1);
@@ -6593 +6593 @@
 bool OsiBiLinearBranchingObject::boundBranch() const
 {
-  const OsiBiLinear *set = dynamic_cast<const OsiBiLinear *>(originalObject_);
+  const OsiBiLinear *set = dynamic_cast< const OsiBiLinear * >(originalObject_);
   assert(set);
   return (set->branchingStrategy() & 4) != 0;
@@ -6600 +6600 @@
 void OsiBiLinearBranchingObject::print(const OsiSolverInterface * /*solver*/)
 {
-  const OsiBiLinear *set = dynamic_cast<const OsiBiLinear *>(originalObject_);
+  const OsiBiLinear *set = dynamic_cast< const OsiBiLinear * >(originalObject_);
   assert(set);
   int way = (!branchIndex_) ? (2 * firstBranch_ - 1) : -(2 * firstBranch_ - 1);
@@ -6648 +6648 @@
   }
   // See how many points
-  numberPoints_ = static_cast<int>((xB[1] - xB[0] + 0.5 * xMesh) / xMesh);
+  numberPoints_ = static_cast< int >((xB[1] - xB[0] + 0.5 * xMesh) / xMesh);
   // redo exactly
-  xMeshSize_ = (xB[1] - xB[0]) / static_cast<double>(numberPoints_);
+  xMeshSize_ = (xB[1] - xB[0]) / static_cast< double >(numberPoints_);
   numberPoints_++;
   //#define KEEPXY
@@ -6863 +6863 @@
     // new step size
     assert(numberPoints_ > 2);
-    step = CoinMax((1.5 * step) / static_cast<double>(numberPoints_ - 1), 0.5 * step);
+    step = CoinMax((1.5 * step) / static_cast< double >(numberPoints_ - 1), 0.5 * step);
     xB[0] = CoinMax(xB[0], xValue - 0.5 * step);
     xB[1] = CoinMin(xB[1], xValue + 0.5 * step);
     // and now divide these
-    mesh = (xB[1] - xB[0]) / static_cast<double>(numberPoints_ - 1);
+    mesh = (xB[1] - xB[0]) / static_cast< double >(numberPoints_ - 1);
   } else {
     // back to original
@@ -7042 +7042 @@
   if (preferredWay_ >= 0 && !satisfied)
     whichWay = preferredWay_;
-  whichWay_ = static_cast<short int>(whichWay);
+  whichWay_ = static_cast< short int >(whichWay);
   return infeasibility_;
 }
@@ -7147 +7147 @@
   printf("Checking quadratic model %x\n", model);
   if (model) {
-    ClpQuadraticObjective *quadraticObj = (dynamic_cast<ClpQuadraticObjective *>(model->objectiveAsObject()));
+    ClpQuadraticObjective *quadraticObj = (dynamic_cast< ClpQuadraticObjective * >(model->objectiveAsObject()));
     assert(quadraticObj);
     CoinPackedMatrix *quadraticObjective = quadraticObj->quadraticObjective();
@@ -7410 +7410 @@
     assert(fabs(floor(gap + 0.5) - gap) < 1.0e-5);
     whichColumn[numJ] = iColumn;
-    bound[numJ] = static_cast<int>(gap);
+    bound[numJ] = static_cast< int >(gap);
     size[numJ++] = triple.value();
     offset += triple.value() * lowerColumn;
@@ -7958 +7958 @@
   assert(solver_ == info->solver_);
   // Only has to work with Clp
-  OsiSolverInterface *solverA = const_cast<OsiSolverInterface *>(solver_);
-  OsiSolverLink *solver = dynamic_cast<OsiSolverLink *>(solverA);
+  OsiSolverInterface *solverA = const_cast< OsiSolverInterface * >(solver_);
+  OsiSolverLink *solver = dynamic_cast< OsiSolverLink * >(solverA);
   assert(solver);
   int numberObjects = solver->numberObjects();
@@ -7976 +7976 @@
     for (i = 0; i < numberObjects; i++) {
       OsiObject *obj = objects[i];
-      OsiBiLinear *objB = dynamic_cast<OsiBiLinear *>(obj);
+      OsiBiLinear *objB = dynamic_cast< OsiBiLinear * >(obj);
       if (!objB)
         objects[numObj++] = obj;
@@ -7988 +7988 @@
     // See if any master objects
     for (i = 0; i < numberObjectsToUse_; i++) {
-      OsiUsesBiLinear *obj = dynamic_cast<OsiUsesBiLinear *>(objects[i]);
+      OsiUsesBiLinear *obj = dynamic_cast< OsiUsesBiLinear * >(objects[i]);
       if (obj)
         obj->addBiLinearObjects(solver);
@@ -8126 +8126 @@
   infeasibility_ = 0.0;
   for (int i = 0; i < numberBiLinear_; i++) {
-    OsiBiLinear *obj = dynamic_cast<OsiBiLinear *>(objects_[i]);
+    OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(objects_[i]);
     assert(obj);
     //obj->getPseudoShadow(info);
@@ -8147 +8147 @@
   if (preferredWay_ >= 0 && !satisfied)
     whichWay = preferredWay_;
-  whichWay_ = static_cast<short int>(whichWay);
+  whichWay_ = static_cast< short int >(whichWay);
   return infeasibility_;
 }
@@ -8197 +8197 @@
   for (i = 0; i < numberObjects; i++) {
     OsiObject *obj = objects[i];
-    OsiBiLinear *objB = dynamic_cast<OsiBiLinear *>(obj);
+    OsiBiLinear *objB = dynamic_cast< OsiBiLinear * >(obj);
     if (objB) {
       if (objB->xColumn() == columnNumber_ || objB->yColumn() == columnNumber_)
@@ -8208 +8208 @@
     for (i = 0; i < numberObjects; i++) {
       OsiObject *obj = objects[i];
-      OsiBiLinear *objB = dynamic_cast<OsiBiLinear *>(obj);
+      OsiBiLinear *objB = dynamic_cast< OsiBiLinear * >(obj);
       if (objB) {
         if (objB->xColumn() == columnNumber_ || objB->yColumn() == columnNumber_)

trunk/Cbc/src/CbcMipStartIO.cpp

@@ -30 +30 @@
 
 int readMIPStart(CbcModel *model, const char *fileName,
-  vector<pair<string, double>> &colValues,
+  vector< pair< string, double > > &colValues,
   double & /*solObj*/)
 {
@@ -63 +63 @@
       double value = atof(col[2]);
 
-      colValues.push_back(pair<string, double>(string(name), value));
+      colValues.push_back(pair< string, double >(string(name), value));
     }
   }
 
   if (colValues.size()) {
-    sprintf(printLine, "MIPStart values read for %d variables.", static_cast<int>(colValues.size()));
+    sprintf(printLine, "MIPStart values read for %d variables.", static_cast< int >(colValues.size()));
     model->messageHandler()->message(CBC_GENERAL, model->messages()) << printLine << CoinMessageEol;
     if (colValues.size() < model->getNumCols()) {
       int numberColumns = model->getNumCols();
       OsiSolverInterface *solver = model->solver();
-      vector<pair<string, double>> fullValues;
+      vector< pair< string, double > > fullValues;
       /* for fast search of column names */
-      map<string, int> colIdx;
+      map< string, int > colIdx;
       for (int i = 0; i < numberColumns; i++) {
-        fullValues.push_back(pair<string, double>(solver->getColName(i), 0.0));
+        fullValues.push_back(pair< string, double >(solver->getColName(i), 0.0));
         colIdx[solver->getColName(i)] = i;
       }
-      for (int i = 0; (i < static_cast<int>(colValues.size())); ++i) {
-        map<string, int>::const_iterator mIt = colIdx.find(colValues[i].first);
+      for (int i = 0; (i < static_cast< int >(colValues.size())); ++i) {
+        map< string, int >::const_iterator mIt = colIdx.find(colValues[i].first);
         if (mIt != colIdx.end()) {
           const int idx = mIt->second;
@@ -101 +101 @@
 
 int computeCompleteSolution(CbcModel *model,
-  const vector<string> colNames,
-  const std::vector<std::pair<std::string, double>> &colValues,
+  const vector< string > colNames,
+  const std::vector< std::pair< std::string, double > > &colValues,
   double *sol, double &obj)
 {
@@ -112 +112 @@
   bool foundIntegerSol = false;
   OsiSolverInterface *lp = model->solver()->clone();
-  map<string, int> colIdx;
-  assert((static_cast<int>(colNames.size())) == lp->getNumCols());
+  map< string, int > colIdx;
+  assert((static_cast< int >(colNames.size())) == lp->getNumCols());
   /* for fast search of column names */
-  for (int i = 0; (i < static_cast<int>(colNames.size())); ++i)
+  for (int i = 0; (i < static_cast< int >(colNames.size())); ++i)
     colIdx[colNames[i]] = i;
 
@@ -135 +135 @@
   }
 #endif
-  for (int i = 0; (i < static_cast<int>(colValues.size())); ++i) {
-    map<string, int>::const_iterator mIt = colIdx.find(colValues[i].first);
+  for (int i = 0; (i < static_cast< int >(colValues.size())); ++i) {
+    map< string, int >::const_iterator mIt = colIdx.find(colValues[i].first);
     if (mIt == colIdx.end()) {
       if (!notFound)
@@ -167 +167 @@
   }
 
-  if (notFound >= ((static_cast<double>(colNames.size())) * 0.5)) {
+  if (notFound >= ((static_cast< double >(colNames.size())) * 0.5)) {
     sprintf(printLine, "Warning: %d column names were not found (e.g. %s) while filling solution.", notFound, colNotFound);
     model->messageHandler()->message(CBC_GENERAL, model->messages())
@@ -195 +195 @@
       int numberObjects = model->numberObjects();
       for (int i = 0; i < numberObjects; i++) {
-        const OsiSOS *object = dynamic_cast<const OsiSOS *>(model->object(i));
+        const OsiSOS *object = dynamic_cast< const OsiSOS * >(model->object(i));
         if (object) {
           int n = object->numberMembers();
@@ -274 +274 @@
   /* some additional effort is needed to provide an integer solution */
   if (lp->getFractionalIndices().size() > 0) {
-    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()));
+    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()));
     model->messageHandler()->message(CBC_GENERAL, model->messages())
       << printLine << CoinMessageEol;

trunk/Cbc/src/CbcMipStartIO.hpp

@@ -14 +14 @@
    1 otherwise */
 int readMIPStart(CbcModel *model, const char *fileName,
-  std::vector<std::pair<std::string, double>> &colValues,
+  std::vector< std::pair< std::string, double > > &colValues,
   double &solObj);
 
@@ -20 +20 @@
    remaining variable values */
 int computeCompleteSolution(CbcModel *model,
-  const std::vector<std::string> colNames,
-  const std::vector<std::pair<std::string, double>> &colValues,
+  const std::vector< std::string > colNames,
+  const std::vector< std::pair< std::string, double > > &colValues,
   double *sol, double &obj);
 

trunk/Cbc/src/CbcModel.cpp

@@ -434 +434 @@
             else if (cost != objValue)
               cost = -COIN_DBL_MAX;
-            int gap = static_cast<int>(upper[iColumn] - lower[iColumn]);
+            int gap = static_cast< int >(upper[iColumn] - lower[iColumn]);
             if (gap > 1) {
               numberGeneralIntegerObj++;
@@ -506 +506 @@
         int highPriority = (branchOnSatisfied) ? -999 : 100;
         for (int i = 0; i < numberObjects_; i++) {
-          CbcSimpleInteger *thisOne = dynamic_cast<CbcSimpleInteger *>(object_[i]);
+          CbcSimpleInteger *thisOne = dynamic_cast< CbcSimpleInteger * >(object_[i]);
           object_[i]->setPriority(1000);
           if (thisOne) {
@@ -517 +517 @@
 #ifdef COIN_HAS_CLP
       OsiClpSolverInterface *clpSolver
-        = dynamic_cast<OsiClpSolverInterface *>(solver_);
+        = dynamic_cast< OsiClpSolverInterface * >(solver_);
       if (clpSolver && createFake) {
         // Create artificial objective to be used when all else fixed
@@ -592 +592 @@
 #endif
         for (int i = 0; i < numberObjects_; i++) {
-          CbcSimpleInteger *obj = dynamic_cast<CbcSimpleInteger *>(object_[i]);
+          CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(object_[i]);
           if (obj) {
             int iColumn = obj->columnNumber();
@@ -1015 +1015 @@
           double value = objValue * multiplier;
           if (value < 2.1e9) {
-            int nearest = static_cast<int>(floor(value + 0.5));
+            int nearest = static_cast< int >(floor(value + 0.5));
             if (fabs(value - floor(value + 0.5)) > 1.0e-8) {
               increment = 0;
@@ -1045 +1045 @@
       if (bigIntegers) {
         // allow for 1.0
-        increment = gcd(increment, static_cast<int>(multiplier));
+        increment = gcd(increment, static_cast< int >(multiplier));
         value = increment;
       }
@@ -1443 +1443 @@
 #ifdef COIN_HAS_CLP
     OsiClpSolverInterface *clpSolver
-      = dynamic_cast<OsiClpSolverInterface *>(copy1);
+      = dynamic_cast< OsiClpSolverInterface * >(copy1);
     if (false && clpSolver) {
       numberRows = clpSolver->getNumRows();
@@ -1645 +1645 @@
   }
   int saveMoreSpecialOptions = moreSpecialOptions_;
-  if (dynamic_cast<CbcTreeLocal *>(tree_))
+  if (dynamic_cast< CbcTreeLocal * >(tree_))
     specialOptions_ |= 4096 + 8192;
 #ifdef COIN_HAS_CLP
   {
     OsiClpSolverInterface *clpSolver
-      = dynamic_cast<OsiClpSolverInterface *>(solver_);
+      = dynamic_cast< OsiClpSolverInterface * >(solver_);
     if (clpSolver) {
       // pass in disaster handler
@@ -1716 +1716 @@
         nOrig = CoinMax(nOrig, originalColumns[numberColumns - 1] + 1);
         // try and redo debugger
-        OsiRowCutDebugger *debugger = const_cast<OsiRowCutDebugger *>(solver_->getRowCutDebuggerAlways());
+        OsiRowCutDebugger *debugger = const_cast< OsiRowCutDebugger * >(solver_->getRowCutDebuggerAlways());
         if (debugger) {
           if (numberColumns <= debugger->numberColumns())
@@ -1755 +1755 @@
           if (temp[jColumn] >= 0) {
             int iObject = temp[jColumn];
-            CbcSimpleInteger *obj = dynamic_cast<CbcSimpleInteger *>(originalObject[iObject]);
+            CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(originalObject[iObject]);
             if (obj)
               numberOldIntegers++;
@@ -1789 +1789 @@
           if (temp[jColumn] >= 0) {
             int iObject = temp[jColumn];
-            CbcSimpleInteger *obj = dynamic_cast<CbcSimpleInteger *>(originalObject[iObject]);
+            CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(originalObject[iObject]);
             if (obj) {
               object_[numberIntegers_] = originalObject[iObject]->clone();
@@ -1809 +1809 @@
           if (temp[jColumn] >= 0) {
             int iObject = temp[jColumn];
-            CbcSimpleInteger *obj = dynamic_cast<CbcSimpleInteger *>(originalObject[iObject]);
+            CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(originalObject[iObject]);
             if (!obj) {
               object_[numberObjects_] = originalObject[iObject]->clone();
               // redo ids etc
-              CbcObject *obj = dynamic_cast<CbcObject *>(object_[numberObjects_]);
+              CbcObject *obj = dynamic_cast< CbcObject * >(object_[numberObjects_]);
               assert(obj);
               obj->redoSequenceEtc(this, numberColumns, originalColumns);
@@ -1828 +1828 @@
 #ifdef JJF_ZERO
             // redo ids etc
-            CbcObject *obj = dynamic_cast<CbcObject *>(object_[numberObjects_]);
+            CbcObject *obj = dynamic_cast< CbcObject * >(object_[numberObjects_]);
             assert(obj);
             obj->redoSequenceEtc(this, numberColumns, originalColumns);
@@ -1844 +1844 @@
         const int *originalColumns = process->originalColumns();
         // try and redo debugger
-        OsiRowCutDebugger *debugger = const_cast<OsiRowCutDebugger *>(solver_->getRowCutDebuggerAlways());
+        OsiRowCutDebugger *debugger = const_cast< OsiRowCutDebugger * >(solver_->getRowCutDebuggerAlways());
         if (debugger)
           debugger->redoSolution(numberColumns, originalColumns);
@@ -1957 +1957 @@
     // set all unset ones
     for (int iObject = 0; iObject < numberObjects_; iObject++) {
-      CbcObject *obj = dynamic_cast<CbcObject *>(object_[iObject]);
+      CbcObject *obj = dynamic_cast< CbcObject * >(object_[iObject]);
       if (obj && !obj->preferredWay())
         obj->setPreferredWay(preferredWay_);
@@ -1968 +1968 @@
   synchronizeModel();
   if (!solverCharacteristics_) {
-    OsiBabSolver *solverCharacteristics = dynamic_cast<OsiBabSolver *>(solver_->getAuxiliaryInfo());
+    OsiBabSolver *solverCharacteristics = dynamic_cast< OsiBabSolver * >(solver_->getAuxiliaryInfo());
     if (solverCharacteristics) {
       solverCharacteristics_ = solverCharacteristics;
@@ -1975 +1975 @@
       OsiBabSolver defaultC;
       solver_->setAuxiliaryInfo(&defaultC);
-      solverCharacteristics_ = dynamic_cast<OsiBabSolver *>(solver_->getAuxiliaryInfo());
+      solverCharacteristics_ = dynamic_cast< OsiBabSolver * >(solver_->getAuxiliaryInfo());
     }
   }
@@ -1995 +1995 @@
   {
     OsiClpSolverInterface *clpSolver
-      = dynamic_cast<OsiClpSolverInterface *>(solver_);
+      = dynamic_cast< OsiClpSolverInterface * >(solver_);
     if (clpSolver) {
       ClpSimplex *clpSimplex = clpSolver->getModelPtr();
@@ -2026 +2026 @@
     int numberOdd = 0;
     for (int i = 0; i < numberObjects_; i++) {
-      CbcSimpleInteger *obj = dynamic_cast<CbcSimpleInteger *>(object_[i]);
+      CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(object_[i]);
       if (!obj)
         numberOdd++;
@@ -2176 +2176 @@
     if (numberOriginalObjects) {
       for (int iObject = 0; iObject < numberObjects_; iObject++) {
-        CbcObject *obj = dynamic_cast<CbcObject *>(object_[iObject]);
+        CbcObject *obj = dynamic_cast< CbcObject * >(object_[iObject]);
         if (obj) {
-          CbcSimpleInteger *obj2 = dynamic_cast<CbcSimpleInteger *>(obj);
+          CbcSimpleInteger *obj2 = dynamic_cast< CbcSimpleInteger * >(obj);
           if (obj2) {
             // back to Osi land
@@ -2184 +2184 @@
             delete obj;
           } else {
-            OsiSimpleInteger *obj3 = dynamic_cast<OsiSimpleInteger *>(obj);
+            OsiSimpleInteger *obj3 = dynamic_cast< OsiSimpleInteger * >(obj);
             if (!obj3) {
-              OsiSOS *obj4 = dynamic_cast<OsiSOS *>(obj);
+              OsiSOS *obj4 = dynamic_cast< OsiSOS * >(obj);
               if (!obj4) {
-                CbcSOS *obj5 = dynamic_cast<CbcSOS *>(obj);
+                CbcSOS *obj5 = dynamic_cast< CbcSOS * >(obj);
                 if (obj5) {
                   // back to Osi land
@@ -2232 +2232 @@
       if (!object_[i]->canDoHeuristics())
         numberOdd++;
-      CbcSOS *obj = dynamic_cast<CbcSOS *>(object_[i]);
+      CbcSOS *obj = dynamic_cast< CbcSOS * >(object_[i]);
       if (obj)
         numberSOS++;
@@ -2336 +2336 @@
 #ifdef COIN_HAS_CLP
     OsiClpSolverInterface *clpSolver
-      = dynamic_cast<OsiClpSolverInterface *>(solver_);
+      = dynamic_cast< OsiClpSolverInterface * >(solver_);
     if (clpSolver) {
       int specialOptions = clpSolver->getModelPtr()->specialOptions();
@@ -2421 +2421 @@
     // pass tolerance and increment to solver
     OsiClpSolverInterface *clpSolver
-      = dynamic_cast<OsiClpSolverInterface *>(solver_);
+      = dynamic_cast< OsiClpSolverInterface * >(solver_);
     if (clpSolver)
       clpSolver->setStuff(getIntegerTolerance(), getCutoffIncrement());
@@ -2454 +2454 @@
     */
   CbcCompareDefault *compareActual
-    = dynamic_cast<CbcCompareDefault *>(nodeCompare_);
+    = dynamic_cast< CbcCompareDefault * >(nodeCompare_);
   if (compareActual) {
     compareActual->setBestPossible(direction * solver_->getObjValue());
@@ -2584 +2584 @@
         for (int i = 0; i < numberHeuristics_; i++) {
           CbcHeuristicRINS *rins
-            = dynamic_cast<CbcHeuristicRINS *>(heuristic_[i]);
+            = dynamic_cast< CbcHeuristicRINS * >(heuristic_[i]);
           if (rins) {
             rins->setLastNode(-100);
@@ -2629 +2629 @@
       while (time >= COIN_INT_MAX)
         time *= 0.5;
-      newSeed = static_cast<unsigned int>(time);
+      newSeed = static_cast< unsigned int >(time);
     } else if (newSeed < 0) {
       newSeed = 123456789;
 #ifdef COIN_HAS_CLP
       OsiClpSolverInterface *clpSolver
-        = dynamic_cast<OsiClpSolverInterface *>(solver_);
+        = dynamic_cast< OsiClpSolverInterface * >(solver_);
       if (clpSolver) {
         newSeed += clpSolver->getModelPtr()->randomNumberGenerator()->getSeed();
@@ -2640 +2640 @@
 #endif
     }
-    CoinWarmStartBasis *basis = dynamic_cast<CoinWarmStartBasis *>(solver_->getEmptyWarmStart());
+    CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver_->getEmptyWarmStart());
     for (int i = 0; i < numberModels; i++) {
       rootModels[i] = new CbcModel(*this);
@@ -2659 +2659 @@
 #ifdef COIN_HAS_CLP
       OsiClpSolverInterface *clpSolver
-        = dynamic_cast<OsiClpSolverInterface *>(rootModels[i]->solver_);
+        = dynamic_cast< OsiClpSolverInterface * >(rootModels[i]->solver_);
 #define NEW_RANDOM_BASIS
 #ifdef NEW_RANDOM_BASIS
@@ -2680 +2680 @@
           for (int iThrow = 0; iThrow < throwOut; iThrow++) {
             double random = simplex->randomNumberGenerator()->randomDouble();
-            int iStart = static_cast<int>(random * numberRows);
+            int iStart = static_cast< int >(random * numberRows);
             for (int j = iStart; j < numberRows; j++) {
               if (simplex->getRowStatus(j) != ClpSimplex::basic) {
@@ -2691 +2691 @@
 #else
             double random = simplex->randomNumberGenerator()->randomDouble();
-            int bias = static_cast<int>(random * (numberIterations / 4));
+            int bias = static_cast< int >(random * (numberIterations / 4));
             simplex->setMaximumIterations(numberIterations / 2 + bias);
             simplex->primal();
@@ -3031 +3031 @@
                   initialCuts++;
                   nRead = fread(elements, sizeof(double), numberEntries + 2, fp);
-                  if (nRead != static_cast<size_t>(numberEntries + 2))
+                  if (nRead != static_cast< size_t >(numberEntries + 2))
                     throw("Error in fread");
                   nRead = fread(indices, sizeof(int), numberEntries, fp);
-                  if (nRead != static_cast<size_t>(numberEntries))
+                  if (nRead != static_cast< size_t >(numberEntries))
                     throw("Error in fread");
                   if (randomNumber > threshold) {
@@ -3125 +3125 @@
                 initialCuts++;
                 nRead = fread(elements, sizeof(double), numberEntries + 2, fp);
-                if (nRead != static_cast<size_t>(numberEntries + 2))
+                if (nRead != static_cast< size_t >(numberEntries + 2))
                   throw("Error in fread");
                 nRead = fread(indices, sizeof(int), numberEntries, fp);
-                if (nRead != static_cast<size_t>(numberEntries))
+                if (nRead != static_cast< size_t >(numberEntries))
                   throw("Error in fread");
               } else {
@@ -3168 +3168 @@
               throw("Error in fwrite");
             nWrite = fwrite(elements, sizeof(double), n + 2, fp);
-            if (nWrite != static_cast<size_t>(n + 2))
+            if (nWrite != static_cast< size_t >(n + 2))
               throw("Error in fwrite");
             nWrite = fwrite(indices, sizeof(int), n, fp);
-            if (nWrite != static_cast<size_t>(n))
+            if (nWrite != static_cast< size_t >(n))
               throw("Error in fwrite");
           }
@@ -3277 +3277 @@
               for (int i = 0; i < numberHeuristics_; i++) {
                 CbcHeuristicRINS *rins
-                  = dynamic_cast<CbcHeuristicRINS *>(heuristic_[i]);
+                  = dynamic_cast< CbcHeuristicRINS * >(heuristic_[i]);
                 if (rins) {
                   rins->setLastNode(-100);
@@ -3349 +3349 @@
   if ((moreSpecialOptions_ & 2097152) != 0 && !parentModel_ && feasible) {
     OsiClpSolverInterface *clpSolver
-      = dynamic_cast<OsiClpSolverInterface *>(solver_);
+      = dynamic_cast< OsiClpSolverInterface * >(solver_);
     if (clpSolver)
       resolveClp(clpSolver, 0);
@@ -3386 +3386 @@
     double time1 = CoinCpuTime();
     OsiClpSolverInterface *clpSolver
-      = dynamic_cast<OsiClpSolverInterface *>(solver_);
+      = dynamic_cast< OsiClpSolverInterface * >(solver_);
     OsiCpxSolverInterface cpxSolver;
     double direction = clpSolver->getObjSense();
@@ -3533 +3533 @@
       // But make sure position is correct
       OsiObject *obj2 = object_[numberObjects_];
-      obj = dynamic_cast<CbcObject *>(obj2);
+      obj = dynamic_cast< CbcObject * >(obj2);
       assert(obj);
       obj->setPosition(numberObjects_);
@@ -3542 +3542 @@
   if (true) {
     OsiClpSolverInterface *clpSolver
-      = dynamic_cast<OsiClpSolverInterface *>(solver_);
+      = dynamic_cast< OsiClpSolverInterface * >(solver_);
     if (clpSolver && !parentModel_) {
       ClpSimplex *clpSimplex = clpSolver->getModelPtr();
@@ -3592 +3592 @@
 #ifdef COIN_HAS_CLP
     OsiClpSolverInterface *clpSolver
-      = dynamic_cast<OsiClpSolverInterface *>(solver_);
+      = dynamic_cast< OsiClpSolverInterface * >(solver_);
     if (clpSolver) {
       if (getCutoff() > 1.0e20) {
@@ -3637 +3637 @@
       const double *saveUpper = continuousSolver_->getColUpper();
       for (int i = 0; i < numberObjects_; i++) {
-        const CbcSimpleInteger *thisOne = dynamic_cast<const CbcSimpleInteger *>(object_[i]);
+        const CbcSimpleInteger *thisOne = dynamic_cast< const CbcSimpleInteger * >(object_[i]);
         if (thisOne) {
           int iColumn = thisOne->columnNumber();
@@ -3666 +3666 @@
         double direction = solver->getObjSense();
         solver->setDblParam(OsiDualObjectiveLimit, 1.0e50 * direction);
-        CoinWarmStartBasis *basis = dynamic_cast<CoinWarmStartBasis *>(solver->getEmptyWarmStart());
+        CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver->getEmptyWarmStart());
         solver->setWarmStart(basis);
         delete basis;
@@ -4055 +4055 @@
           generator_[numberCutGenerators_ - 1]->setTiming(true);
           for (int i = 0; i < numberCutGenerators_; i++) {
-            CglKnapsackCover *cutGen = dynamic_cast<CglKnapsackCover *>(generator_[i]->generator());
+            CglKnapsackCover *cutGen = dynamic_cast< CglKnapsackCover * >(generator_[i]->generator());
             if (cutGen) {
               cutGen->createCliques(*fake, 2, 200, false);
@@ -4107 +4107 @@
                "(active only) %d\n",
           numberRowsAtContinuous_ + numberNewCuts_ + numberOldActiveCuts_);
-        const CoinWarmStartBasis *debugws = dynamic_cast<const CoinWarmStartBasis *>(solver_->getWarmStart());
+        const CoinWarmStartBasis *debugws = dynamic_cast< const CoinWarmStartBasis * >(solver_->getWarmStart());
         debugws->print();
         delete debugws;
@@ -4118 +4118 @@
     if (lastws)
       delete lastws;
-    lastws = dynamic_cast<CoinWarmStartBasis *>(solver_->getWarmStart());
+    lastws = dynamic_cast< CoinWarmStartBasis * >(solver_->getWarmStart());
   }
   /*
@@ -4154 +4154 @@
       // save pointer to root node - so can pick up bounds
       if (!topOfTree_)
-        topOfTree_ = dynamic_cast<CbcFullNodeInfo *>(newNode->nodeInfo());
+        topOfTree_ = dynamic_cast< CbcFullNodeInfo * >(newNode->nodeInfo());
       if (statistics_) {
         if (numberNodes2_ == maximumStatistics_) {
@@ -4209 +4209 @@
   {
     OsiClpSolverInterface *clpSolver
-      = dynamic_cast<OsiClpSolverInterface *>(solver_);
+      = dynamic_cast< OsiClpSolverInterface * >(solver_);
     if (clpSolver && !parentModel_) {
       clpSolver->computeLargestAway();
@@ -4226 +4226 @@
     */
   if (solver_->getRowCutDebuggerAlways()) {
-    OsiRowCutDebugger *debuggerX = const_cast<OsiRowCutDebugger *>(solver_->getRowCutDebuggerAlways());
+    OsiRowCutDebugger *debuggerX = const_cast< OsiRowCutDebugger * >(solver_->getRowCutDebuggerAlways());
     const OsiRowCutDebugger *debugger = solver_->getRowCutDebugger();
     if (!debugger) {
@@ -4301 +4301 @@
       for (i = 0; i < numberObjects_; i++) {
         OsiObject *object = object_[i];
-        CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast<CbcSimpleIntegerDynamicPseudoCost *>(object);
+        CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object);
         if (dynamicObject) {
           numberInts++;
@@ -4361 +4361 @@
       }
       if (numberUp)
-        averageUp /= static_cast<double>(numberUp);
+        averageUp /= static_cast< double >(numberUp);
       else
         averageUp = 0.0;
       if (numberDown)
-        averageDown /= static_cast<double>(numberDown);
+        averageDown /= static_cast< double >(numberDown);
       else
         averageDown = 0.0;
@@ -4374 +4374 @@
           neverBranchedDown, neverBranchedUp);
       printf("down average %g times (%d infeasible) average increase %g min/max times (%d,%d)\n",
-        static_cast<double>(numberDown2) / numberDown, infeasibleTimesDown, averageDown,
+        static_cast< double >(numberDown2) / numberDown, infeasibleTimesDown, averageDown,
         minTimesDown, maxTimesDown);
       printf("up average %g times (%d infeasible) average increase %g min/max times (%d,%d)\n",
-        static_cast<double>(numberUp2) / numberUp, infeasibleTimesUp, averageUp,
+        static_cast< double >(numberUp2) / numberUp, infeasibleTimesUp, averageUp,
         minTimesUp, maxTimesUp);
     }
@@ -4406 +4406 @@
 #ifdef COIN_HAS_CLP
       OsiClpSolverInterface *clpSolver
-        = dynamic_cast<OsiClpSolverInterface *>(solver_);
+        = dynamic_cast< OsiClpSolverInterface * >(solver_);
       if (clpSolver && ((specialOptions_ & 131072) == 0) && true) {
         ClpSimplex *simplex = clpSolver->getModelPtr();
@@ -4614 +4614 @@
       if (!parallelMode()) {
         if (kNode == DIVE_WHEN + 1 || numberConsecutiveInfeasible > 1) {
-          CbcCompareDefault *compare = dynamic_cast<CbcCompareDefault *>(nodeCompare_);
+          CbcCompareDefault *compare = dynamic_cast< CbcCompareDefault * >(nodeCompare_);
           // Don't interfere if user has replaced the compare function.
           if (compare) {
@@ -5075 +5075 @@
   if (doStatistics == 100) {
     for (int i = 0; i < numberObjects_; i++) {
-      CbcSimpleIntegerDynamicPseudoCost *obj = dynamic_cast<CbcSimpleIntegerDynamicPseudoCost *>(object_[i]);
+      CbcSimpleIntegerDynamicPseudoCost *obj = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object_[i]);
       if (obj)
         obj->print();
@@ -5200 +5200 @@
     // Now print
     if (numberSolutions)
-      averageSolutionDepth /= static_cast<double>(numberSolutions);
+      averageSolutionDepth /= static_cast< double >(numberSolutions);
     int numberSolved = numberNodes2_ - numberCutoff;
     double averageNumberIterations2 = numberIterations_ - averageNumberIterations1
       - numberIterationsAtContinuous;
     if (numberCutoff) {
-      averageCutoffDepth /= static_cast<double>(numberCutoff);
-      averageNumberIterations2 /= static_cast<double>(numberCutoff);
+      averageCutoffDepth /= static_cast< double >(numberCutoff);
+      averageNumberIterations2 /= static_cast< double >(numberCutoff);
     }
     if (numberNodes2_)
-      averageValue /= static_cast<double>(numberNodes2_);
+      averageValue /= static_cast< double >(numberNodes2_);
     if (numberSolved) {
-      averageNumberIterations1 /= static_cast<double>(numberSolved);
-      averageSolvedDepth /= static_cast<double>(numberSolved);
+      averageNumberIterations1 /= static_cast< double >(numberSolved);
+      averageSolvedDepth /= static_cast< double >(numberSolved);
     }
     printf("%d solution(s) were found (by branching) at an average depth of %g\n",
@@ -5223 +5223 @@
       numberSolved, averageSolvedDepth, averageNumberIterations1);
     if (numberDown) {
-      averageInfDown /= static_cast<double>(numberDown);
-      averageObjDown /= static_cast<double>(numberDown);
+      averageInfDown /= static_cast< double >(numberDown);
+      averageObjDown /= static_cast< double >(numberDown);
     }
     printf("Down %d nodes (%d first, %d second) - %d cutoff, rest decrease numinf %g increase obj %g\n",
@@ -5230 +5230 @@
       averageInfDown, averageObjDown);
     if (numberUp) {
-      averageInfUp /= static_cast<double>(numberUp);
-      averageObjUp /= static_cast<double>(numberUp);
+      averageInfUp /= static_cast< double >(numberUp);
+      averageObjUp /= static_cast< double >(numberUp);
     }
     printf("Up %d nodes (%d first, %d second) - %d cutoff, rest decrease numinf %g increase obj %g\n",
@@ -5345 +5345 @@
   {
     OsiClpSolverInterface *clpSolver
-      = dynamic_cast<OsiClpSolverInterface *>(solver_);
+      = dynamic_cast< OsiClpSolverInterface * >(solver_);
     if (clpSolver) {
       // Possible restore of pivot method
@@ -5413 +5413 @@
   {
     OsiClpSolverInterface *clpSolver
-      = dynamic_cast<OsiClpSolverInterface *>(solver_);
+      = dynamic_cast< OsiClpSolverInterface * >(solver_);
     if (clpSolver)
-      clpSolver->setFakeObjective(reinterpret_cast<double *>(NULL));
+      clpSolver->setFakeObjective(reinterpret_cast< double * >(NULL));
   }
 #endif
@@ -5431 +5431 @@
   checkModel();
   if (!solverCharacteristics_) {
-    OsiBabSolver *solverCharacteristics = dynamic_cast<OsiBabSolver *>(solver_->getAuxiliaryInfo());
+    OsiBabSolver *solverCharacteristics = dynamic_cast< OsiBabSolver * >(solver_->getAuxiliaryInfo());
     if (solverCharacteristics) {
       solverCharacteristics_ = solverCharacteristics;
@@ -5438 +5438 @@
       OsiBabSolver defaultC;
       solver_->setAuxiliaryInfo(&defaultC);
-      solverCharacteristics_ = dynamic_cast<OsiBabSolver *>(solver_->getAuxiliaryInfo());
+      solverCharacteristics_ = dynamic_cast< OsiBabSolver * >(solver_->getAuxiliaryInfo());
     }
   }
@@ -5482 +5482 @@
         "getEmptyBasis", "CbcModel");
     }
-    emptyBasis = dynamic_cast<CoinWarmStartBasis *>(solver_->getEmptyWarmStart());
+    emptyBasis = dynamic_cast< CoinWarmStartBasis * >(solver_->getEmptyWarmStart());
     if (emptyBasis == 0) {
       throw CoinError(
@@ -5489 +5489 @@
     }
     emptyBasis->setSize(0, 0);
-    emptyWarmStart_ = dynamic_cast<CoinWarmStart *>(emptyBasis);
+    emptyWarmStart_ = dynamic_cast< CoinWarmStart * >(emptyBasis);
   }
   /*
       Clone the empty basis object, resize it as requested, and return.
     */
-  emptyBasis = dynamic_cast<CoinWarmStartBasis *>(emptyWarmStart_->clone());
+  emptyBasis = dynamic_cast< CoinWarmStartBasis * >(emptyWarmStart_->clone());
   assert(emptyBasis);
   if (ns != 0 || na != 0)
@@ -6157 +6157 @@
       for (i = 0; i < numberObjects_; i++) {
         object_[i] = (rhs.object_[i])->clone();
-        CbcObject *obj = dynamic_cast<CbcObject *>(object_[i]);
+        CbcObject *obj = dynamic_cast< CbcObject * >(object_[i]);
         // Could be OsiObjects
         if (obj)
@@ -6798 +6798 @@
     for (int i = 0; i < numberCutGenerators_; i++) {
       CglImplication *cutGen;
-      cutGen = dynamic_cast<CglImplication *>(generator_[i]->generator());
+      cutGen = dynamic_cast< CglImplication * >(generator_[i]->generator());
       if (!cutGen) {
         generator_[n] = generator_[i];
@@ -6806 +6806 @@
         cutGen->setProbingInfo(NULL);
         delete generator_[i];
-        cutGen = dynamic_cast<CglImplication *>(virginGenerator_[i]->generator());
+        cutGen = dynamic_cast< CglImplication * >(virginGenerator_[i]->generator());
         assert(cutGen);
         cutGen->setProbingInfo(NULL);
@@ -7595 +7595 @@
   if (!defaultHandler) {
     OsiClpSolverInterface *solver;
-    solver = dynamic_cast<OsiClpSolverInterface *>(solver_);
+    solver = dynamic_cast< OsiClpSolverInterface * >(solver_);
     if (solver) {
       solver->passInMessageHandler(handler_);
       solver->getModelPtr()->passInMessageHandler(handler_);
     }
-    solver = dynamic_cast<OsiClpSolverInterface *>(continuousSolver_);
+    solver = dynamic_cast< OsiClpSolverInterface * >(continuousSolver_);
     if (solver) {
       solver->passInMessageHandler(handler_);
@@ -7640 +7640 @@
 #ifdef COIN_HAS_CLP
   OsiClpSolverInterface *clpSolver
-    = dynamic_cast<OsiClpSolverInterface *>(solver_);
+    = dynamic_cast< OsiClpSolverInterface * >(solver_);
   ClpSimplex *clpSimplex = NULL;
   if (clpSolver)
@@ -7770 +7770 @@
 #ifdef COIN_HAS_CLP
   OsiClpSolverInterface *clpSolver
-    = dynamic_cast<OsiClpSolverInterface *>(solver_);
+    = dynamic_cast< OsiClpSolverInterface * >(solver_);
   int saveClpOptions = 0;
   if (clpSolver)
@@ -7986 +7986 @@
   if (node && branchingMethod_) {
     OsiBranchingObject *bobj = node->modifiableBranchingObject();
-    CbcBranchingObject *cbcobj = dynamic_cast<CbcBranchingObject *>(bobj);
+    CbcBranchingObject *cbcobj = dynamic_cast< CbcBranchingObject * >(bobj);
     if (cbcobj && cbcobj->object()) {
       CbcObject *object = cbcobj->object();
       CbcObjectUpdateData update = object->createUpdateInformation(solver_, node, cbcobj);
       // have to compute object number as not saved
-      CbcSimpleInteger *simpleObject = static_cast<CbcSimpleInteger *>(object);
+      CbcSimpleInteger *simpleObject = static_cast< CbcSimpleInteger * >(object);
       int iObject = simpleObject->position();
 #ifndef NDEBUG
@@ -7997 +7997 @@
       int jObject;
       for (jObject = 0; jObject < numberObjects_; jObject++) {
-        simpleObject = static_cast<CbcSimpleInteger *>(object_[jObject]);
+        simpleObject = static_cast< CbcSimpleInteger * >(object_[jObject]);
         if (simpleObject->columnNumber() == iColumn)
           break;
@@ -8012 +8012 @@
       // update here
       {
-        CbcObject *object = dynamic_cast<CbcObject *>(update.object_);
+        CbcObject *object = dynamic_cast< CbcObject * >(update.object_);
         if (object)
           object->updateInformation(update);
@@ -8028 +8028 @@
         double objectiveChange = lastObjective - objectiveValue;
         if (objectiveChange > 1.0e-5) {
-          CbcIntegerBranchingObject *branch = dynamic_cast<CbcIntegerBranchingObject *>(cbcobj);
+          CbcIntegerBranchingObject *branch = dynamic_cast< CbcIntegerBranchingObject * >(cbcobj);
           assert(branch);
           if (way < 0) {
@@ -8067 +8067 @@
 #endif
     } else {
-      OsiIntegerBranchingObject *obj = dynamic_cast<OsiIntegerBranchingObject *>(bobj);
+      OsiIntegerBranchingObject *obj = dynamic_cast< OsiIntegerBranchingObject * >(bobj);
       if (obj) {
         const OsiObject *object = obj->originalObject();
@@ -8118 +8118 @@
         solver_->writeMpsNative("infeas.mps", NULL, NULL, 2);
         solver_->getRowCutDebuggerAlways()->printOptimalSolution(*solver_);
-        CoinWarmStartBasis *slack = dynamic_cast<CoinWarmStartBasis *>(solver_->getEmptyWarmStart());
+        CoinWarmStartBasis *slack = dynamic_cast< CoinWarmStartBasis * >(solver_->getEmptyWarmStart());
         solver_->setWarmStart(slack);
         delete slack;
@@ -8286 +8286 @@
         int numberColumns = solver_->getNumCols();
         CoinBigIndex maximumAdd = CoinMax(numberElements / 10,
-                                    static_cast<CoinBigIndex>(2 * numberColumns))
+                                    static_cast< CoinBigIndex >(2 * numberColumns))
           + 100;
         double *violations = new double[numberCuts];
@@ -8507 +8507 @@
         phase_ = 4;
         CbcTreeLocal *tree
-          = dynamic_cast<CbcTreeLocal *>(tree_);
+          = dynamic_cast< CbcTreeLocal * >(tree_);
         if (tree)
           tree->passInSolution(bestSolution_, heuristicValue);
@@ -8683 +8683 @@
         }
         solver_->applyRowCuts(numberToAdd, addCuts);
-        CoinWarmStartBasis *basis = dynamic_cast<CoinWarmStartBasis *>(solver_->getWarmStart());
+        CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver_->getWarmStart());
         assert(basis != NULL); // make sure not volume
         /* dylp bug
@@ -8796 +8796 @@
                 nBadPasses++;
               } else {
-                goodDrop = (thisObj - cut_obj[j]) / static_cast<double>(nBadPasses + 1);
+                goodDrop = (thisObj - cut_obj[j]) / static_cast< double >(nBadPasses + 1);
                 break;
               }
@@ -8808 +8808 @@
             //minimumDrop = CoinMax(1.5*minimumDrop,1.0e-5*fabs(thisObj));
             double test = 0.1 * minimumDrop;
-            double goodDrop = (thisObj - cut_obj[0]) / static_cast<double>(CUT_HISTORY);
+            double goodDrop = (thisObj - cut_obj[0]) / static_cast< double >(CUT_HISTORY);
             double objValue = thisObj;
             for (int j = CUT_HISTORY - 1; j >= 0; j--) {
@@ -8997 +8997 @@
     int numberAdded = numberRows - numberRowsAtContinuous_;
     if (numberAdded) {
-      CoinWarmStartBasis *basis = dynamic_cast<CoinWarmStartBasis *>(solver_->getWarmStart());
+      CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver_->getWarmStart());
       assert(basis != NULL);
       int *added = new int[numberAdded];
@@ -9111 +9111 @@
     int numberRowsAdded = solver_->getNumRows() - numberRowsAtStart;
     CoinBigIndex numberElementsAdded = solver_->getNumElements() - numberElementsAtStart;
-    double densityOld = static_cast<double>(numberElementsAtStart) / static_cast<double>(numberRowsAtStart);
-    double densityNew = numberRowsAdded ? (static_cast<double>(numberElementsAdded)) / static_cast<double>(numberRowsAdded)
+    double densityOld = static_cast< double >(numberElementsAtStart) / static_cast< double >(numberRowsAtStart);
+    double densityNew = numberRowsAdded ? (static_cast< double >(numberElementsAdded)) / static_cast< double >(numberRowsAdded)
                                         : 0.0;
     /*
@@ -9308 +9308 @@
         */
     if (!numberNodes_) {
-      double value = CoinMax(minimumDrop_, 0.005 * (thisObjective - startObjective) / static_cast<double>(currentPassNumber_));
+      double value = CoinMax(minimumDrop_, 0.005 * (thisObjective - startObjective) / static_cast< double >(currentPassNumber_));
       if (numberColumns < 200)
         value = CoinMax(minimumDrop_, 0.1 * value);
@@ -9354 +9354 @@
         */
     int iProbing = -1;
-    double smallProblem = (0.2 * totalCuts) / static_cast<double>(numberActiveGenerators + 1.0e-100);
+    double smallProblem = (0.2 * totalCuts) / static_cast< double >(numberActiveGenerators + 1.0e-100);
     for (i = 0; i < numberCutGenerators_; i++) {
       int howOften = generator_[i]->howOften();
@@ -9372 +9372 @@
             */
       bool probingWasOnBut = false;
-      CglProbing *probing = dynamic_cast<CglProbing *>(generator_[i]->generator());
+      CglProbing *probing = dynamic_cast< CglProbing * >(generator_[i]->generator());
       if (probing && !numberNodes_) {
         if (generator_[i]->numberCutsInTotal()) {
           // If large number of probing - can be biased
-          smallProblem = (0.2 * (totalCuts - generator_[i]->numberCutsInTotal())) / static_cast<double>(numberActiveGenerators - 1 + 1.0e-100);
+          smallProblem = (0.2 * (totalCuts - generator_[i]->numberCutsInTotal())) / static_cast< double >(numberActiveGenerators - 1 + 1.0e-100);
         }
         iProbing = i;
@@ -9491 +9491 @@
                             */
               if (generator_[i]->whatDepth() < 0 || howOften != -1) {
-                int k = static_cast<int>(sqrt(smallProblem / thisCuts));
+                int k = static_cast< int >(sqrt(smallProblem / thisCuts));
                 /*
                                   Not objective improvement, set to new frequency, otherwise turn off.
@@ -9580 +9580 @@
       // increment cut counts
       generator_[i]->incrementNumberCutsActive(count[i]);
-      CglStored *stored = dynamic_cast<CglStored *>(generator_[i]->generator());
+      CglStored *stored = dynamic_cast< CglStored * >(generator_[i]->generator());
       if (stored && !generator_[i]->numberCutsInTotal())
         continue;
@@ -9635 +9635 @@
         // probing->setRowCuts(0);
         for (int i = 0; i < numberObjects_; i++) {
-          CbcSimpleIntegerDynamicPseudoCost *obj = dynamic_cast<CbcSimpleIntegerDynamicPseudoCost *>(object_[i]);
+          CbcSimpleIntegerDynamicPseudoCost *obj = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object_[i]);
           if (obj)
             obj->setMethod(1);
@@ -9671 +9671 @@
 #ifdef COIN_HAS_CLP
         OsiClpSolverInterface *clpSolver
-          = dynamic_cast<OsiClpSolverInterface *>(solver_);
+          = dynamic_cast< OsiClpSolverInterface * >(solver_);
         if (clpSolver) {
           // Maybe solver might like to know only column bounds will change
@@ -9682 +9682 @@
 #ifdef COIN_HAS_CLP
         OsiClpSolverInterface *clpSolver
-          = dynamic_cast<OsiClpSolverInterface *>(solver_);
+          = dynamic_cast< OsiClpSolverInterface * >(solver_);
         if (clpSolver) {
           // make sure factorization can't carry over
@@ -9694 +9694 @@
 #ifdef COIN_HAS_CLP
     OsiClpSolverInterface *clpSolver
-      = dynamic_cast<OsiClpSolverInterface *>(solver_);
+      = dynamic_cast< OsiClpSolverInterface * >(solver_);
     if (clpSolver) {
       // Maybe solver might like to know only column bounds will change
@@ -9722 +9722 @@
 #ifdef CHECK_CUT_COUNTS
   if (feasible) {
-    CoinWarmStartBasis *basis = dynamic_cast<CoinWarmStartBasis *>(solver_->getWarmStart());
+    CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver_->getWarmStart());
     printf("solveWithCuts: Number of rows at end (only active cuts) %d\n",
       numberRowsAtContinuous_ + numberNewCuts_ + numberOldActiveCuts_);
@@ -9825 +9825 @@
       numberRowCutsAfter = theseCuts.sizeRowCuts();
       if (fullScan && generator_[i]->howOften() == 1000000 + SCANCUTS_PROBING) {
-        CglProbing *probing = dynamic_cast<CglProbing *>(generator_[i]->generator());
+        CglProbing *probing = dynamic_cast< CglProbing * >(generator_[i]->generator());
         if (probing && (numberRowCutsBefore < numberRowCutsAfter || numberColumnCutsBefore < theseCuts.sizeColCuts())) {
           // switch on
@@ -10085 +10085 @@
   int problemStatus = -1;
   OsiClpSolverInterface *clpSolver
-    = dynamic_cast<OsiClpSolverInterface *>(solver_);
+    = dynamic_cast< OsiClpSolverInterface * >(solver_);
   if (clpSolver)
     problemStatus = clpSolver->getModelPtr()->status();
@@ -10100 +10100 @@
     int i;
     int kCut = 0;
-    ws = dynamic_cast<const CoinWarmStartBasis *>(solver_->getWarmStart());
+    ws = dynamic_cast< const CoinWarmStartBasis * >(solver_->getWarmStart());
     /*
           Scan the basis entries of the old cuts generated prior to this round of cut
@@ -10300 +10300 @@
 #ifdef COIN_HAS_CLP
   OsiClpSolverInterface *clpSolver
-    = dynamic_cast<OsiClpSolverInterface *>(solver_);
+    = dynamic_cast< OsiClpSolverInterface * >(solver_);
 #endif
   /*
@@ -10503 +10503 @@
             value = fabs(cost) * multiplier;
             if (value < 2.1e9) {
-              int nearest = static_cast<int>(floor(value + 0.5));
+              int nearest = static_cast< int >(floor(value + 0.5));
               assert(fabs(value - floor(value + 0.5)) < 1.0e-8);
               if (!increment)
@@ -10706 +10706 @@
       }
     }
-    int iUpper = static_cast<int>(floor(upperValue + 1.0e-5));
-    int iLower = static_cast<int>(ceil(lowerValue - 1.0e-5));
+    int iUpper = static_cast< int >(floor(upperValue + 1.0e-5));
+    int iLower = static_cast< int >(ceil(lowerValue - 1.0e-5));
     /*
           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",
         numberCliques,
-        (static_cast<double>(totalP1 + totalM1)) / (static_cast<double>(numberCliques)),
+        (static_cast< double >(totalP1 + totalM1)) / (static_cast< double >(numberCliques)),
         totalP1, totalM1);
     else
@@ -10938 +10938 @@
       // zero out
       for (int i = 0; i < numberObjects_; i++) {
-        CbcSimpleIntegerDynamicPseudoCost *obj1 = dynamic_cast<CbcSimpleIntegerDynamicPseudoCost *>(object_[i]);
+        CbcSimpleIntegerDynamicPseudoCost *obj1 = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object_[i]);
         if (obj1) {
           //assert (obj1->downShadowPrice()>0.0);
@@ -11216 +11216 @@
     }
     if (numberIntegers) {
-      double averagePrice = (0.5 * (upSum + downSum)) / static_cast<double>(numberIntegers);
+      double averagePrice = (0.5 * (upSum + downSum)) / static_cast< double >(numberIntegers);
       //averagePrice *= 0.1;
       averagePrice *= 100.0;
@@ -11229 +11229 @@
   delete[] columnWeight;
   if (numberIntegers) {
-    double smallDown = 0.0001 * (downSum / static_cast<double>(numberIntegers));
-    double smallUp = 0.0001 * (upSum / static_cast<double>(numberIntegers));
+    double smallDown = 0.0001 * (downSum / static_cast< double >(numberIntegers));
+    double smallUp = 0.0001 * (upSum / static_cast< double >(numberIntegers));
 #define PSEUDO_FACTOR 5.0e-1
     double pseudoFactor = PSEUDO_FACTOR;
@@ -11236 +11236 @@
     //pseudoFactor=0.0;
     for (int i = 0; i < numberObjects_; i++) {
-      CbcSimpleIntegerDynamicPseudoCost *obj1 = dynamic_cast<CbcSimpleIntegerDynamicPseudoCost *>(object_[i]);
+      CbcSimpleIntegerDynamicPseudoCost *obj1 = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object_[i]);
       if (obj1 && obj1->upShadowPrice() >= 0.0) {
         int iColumn = obj1->columnNumber();
@@ -11325 +11325 @@
     heuristic_[i]->setModel(this);
   for (i = 0; i < numberObjects_; i++) {
-    CbcObject *obj = dynamic_cast<CbcObject *>(object_[i]);
+    CbcObject *obj = dynamic_cast< CbcObject * >(object_[i]);
     if (obj) {
       obj->setModel(this);
@@ -11335 +11335 @@
 
   if (!solverCharacteristics_) {
-    OsiBabSolver *solverCharacteristics = dynamic_cast<OsiBabSolver *>(solver_->getAuxiliaryInfo());
+    OsiBabSolver *solverCharacteristics = dynamic_cast< OsiBabSolver * >(solver_->getAuxiliaryInfo());
     if (solverCharacteristics) {
       solverCharacteristics_ = solverCharacteristics;
@@ -11342 +11342 @@
       OsiBabSolver defaultC;
       solver_->setAuxiliaryInfo(&defaultC);
-      solverCharacteristics_ = dynamic_cast<OsiBabSolver *>(solver_->getAuxiliaryInfo());
+      solverCharacteristics_ = dynamic_cast< OsiBabSolver * >(solver_->getAuxiliaryInfo());
     }
   }
@@ -11402 +11402 @@
   for (iObject = 0; iObject < numberObjects_; iObject++) {
     iPriority = CoinMax(iPriority, object_[iObject]->priority());
-    CbcSimpleInteger *obj = dynamic_cast<CbcSimpleInteger *>(oldObject[iObject]);
+    CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(oldObject[iObject]);
     if (obj) {
       int iColumn = obj->columnNumber();
@@ -11416 +11416 @@
   if (!nObjects) {
     OsiClpSolverInterface *clpSolver
-      = dynamic_cast<OsiClpSolverInterface *>(solver_);
+      = dynamic_cast< OsiClpSolverInterface * >(solver_);
     if (clpSolver && (clpSolver->numberSOS() || clpSolver->numberObjects())) {
       // deal with sos
@@ -11440 +11440 @@
         OsiObject **osiObjects = clpSolver->objects();
         for (int i = 0; i < numberObjects; i++) {
-          OsiSOS *obj = dynamic_cast<OsiSOS *>(osiObjects[i]);
+          OsiSOS *obj = dynamic_cast< OsiSOS * >(osiObjects[i]);
           if (obj) {
             int type = obj->setType();
@@ -11505 +11505 @@
   bool allDynamic = true;
   for (iObject = 0; iObject < numberObjects_; iObject++) {
-    CbcSimpleInteger *obj1 = dynamic_cast<CbcSimpleInteger *>(object_[iObject]);
-    CbcSimpleIntegerPseudoCost *obj1a = dynamic_cast<CbcSimpleIntegerPseudoCost *>(object_[iObject]);
-    CbcSimpleIntegerDynamicPseudoCost *obj2 = dynamic_cast<CbcSimpleIntegerDynamicPseudoCost *>(object_[iObject]);
+    CbcSimpleInteger *obj1 = dynamic_cast< CbcSimpleInteger * >(object_[iObject]);
+    CbcSimpleIntegerPseudoCost *obj1a = dynamic_cast< CbcSimpleIntegerPseudoCost * >(object_[iObject]);
+    CbcSimpleIntegerDynamicPseudoCost *obj2 = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object_[iObject]);
     if (obj1 && !obj2) {
       // replace
@@ -11535 +11535 @@
       object_[iObject] = newObject;
     } else if (!obj2) {
-      CbcObject *obj3 = dynamic_cast<CbcObject *>(object_[iObject]);
+      CbcObject *obj3 = dynamic_cast< CbcObject * >(object_[iObject]);
       if (!obj3 || !obj3->optionalObject())
         allDynamic = false;
@@ -11597 +11597 @@
     if (columnLower[iColumn] || columnUpper[iColumn] != 1.0)
       continue;
-    if (!dynamic_cast<CbcSimpleInteger *>(object_[i]))
+    if (!dynamic_cast< CbcSimpleInteger * >(object_[i]))
       continue;
     int nAdd = 0;
@@ -11663 +11663 @@
         sort[nAdd] = COIN_INT_MAX;
         whichRow[nAdd] = COIN_INT_MAX;
-        CbcSimpleIntegerDynamicPseudoCost *thisOne = dynamic_cast<CbcSimpleIntegerDynamicPseudoCost *>(object_[i]);
+        CbcSimpleIntegerDynamicPseudoCost *thisOne = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object_[i]);
         if (thisOne) {
           assert(iColumn == thisOne->columnNumber());
@@ -11669 +11669 @@
           delete thisOne;
         } else {
-          CbcSimpleInteger *thisOne = dynamic_cast<CbcSimpleInteger *>(object_[i]);
+          CbcSimpleInteger *thisOne = dynamic_cast< CbcSimpleInteger * >(object_[i]);
           assert(thisOne);
           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) {
         // forces to zero
-        CbcSwitchingBinary *object = dynamic_cast<CbcSwitchingBinary *>(object_[i]);
+        CbcSwitchingBinary *object = dynamic_cast< CbcSwitchingBinary * >(object_[i]);
         if (!object) {
           // create empty one
-          CbcSimpleIntegerDynamicPseudoCost *thisOne = dynamic_cast<CbcSimpleIntegerDynamicPseudoCost *>(object_[i]);
+          CbcSimpleIntegerDynamicPseudoCost *thisOne = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object_[i]);
           if (thisOne) {
             assert(iColumn == thisOne->columnNumber());
@@ -11728 +11728 @@
             delete thisOne;
           } else {
-            CbcSimpleInteger *thisOne = dynamic_cast<CbcSimpleInteger *>(object_[i]);
+            CbcSimpleInteger *thisOne = dynamic_cast< CbcSimpleInteger * >(object_[i]);
             assert(thisOne);
             assert(iColumn == thisOne->columnNumber());
@@ -11773 +11773 @@
       n = 0;
       for (int i = 0; i < numberObjects_; i++) {
-        CbcSwitchingBinary *object = dynamic_cast<CbcSwitchingBinary *>(object_[i]);
+        CbcSwitchingBinary *object = dynamic_cast< CbcSwitchingBinary * >(object_[i]);
         if (object) {
           n += object->setAssociatedBounds(solver, cleanBasis);
@@ -11798 +11798 @@
     int nBetween = 0;
     for (int i = 0; i < numberObjects_; i++) {
-      CbcSwitchingBinary *object = dynamic_cast<CbcSwitchingBinary *>(object_[i]);
+      CbcSwitchingBinary *object = dynamic_cast< CbcSwitchingBinary * >(object_[i]);
       if (object) {
         int state[3];
@@ -11828 +11828 @@
   int iObject;
   for (iObject = 0; iObject < numberObjects_; iObject++) {
-    CbcSimpleIntegerDynamicPseudoCost *obj2 = dynamic_cast<CbcSimpleIntegerDynamicPseudoCost *>(object_[iObject]);
+    CbcSimpleIntegerDynamicPseudoCost *obj2 = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object_[iObject]);
     if (obj2) {
       // synchronize trust
@@ -11871 +11871 @@
   int newIntegers = 0;
   for (i = 0; i < numberObjects; i++) {
-    CbcSimpleInteger *obj = dynamic_cast<CbcSimpleInteger *>(objects[i]);
+    CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(objects[i]);
     if (obj) {
       int iColumn = obj->columnNumber();
@@ -11881 +11881 @@
   // and existing
   for (i = 0; i < numberObjects_; i++) {
-    CbcSimpleInteger *obj = dynamic_cast<CbcSimpleInteger *>(object_[i]);
+    CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(object_[i]);
     if (obj) {
       int iColumn = obj->columnNumber();
@@ -11931 +11931 @@
   for (i = 0; i < numberObjects_; i++) {
     if (object_[i]) {
-      CbcSimpleInteger *obj = dynamic_cast<CbcSimpleInteger *>(object_[i]);
+      CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(object_[i]);
       if (obj) {
         delete object_[i];
@@ -11941 +11941 @@
   // and rest of new
   for (i = 0; i < numberObjects; i++) {
-    CbcSimpleInteger *obj = dynamic_cast<CbcSimpleInteger *>(objects[i]);
+    CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(objects[i]);
     if (!obj) {
       temp[n] = objects[i]->clone();
-      CbcObject *obj = dynamic_cast<CbcObject *>(temp[n]);
+      CbcObject *obj = dynamic_cast< CbcObject * >(temp[n]);
       if (obj)
         obj->setModel(this);
@@ -11976 +11976 @@
   int newIntegers = 0;
   for (i = 0; i < numberObjects; i++) {
-    CbcSimpleInteger *obj = dynamic_cast<CbcSimpleInteger *>(objects[i]);
+    CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(objects[i]);
     if (obj) {
       int iColumn = obj->columnNumber();
@@ -11982 +11982 @@
       newIntegers++;
     } else {
-      OsiSimpleInteger *obj2 = dynamic_cast<OsiSimpleInteger *>(objects[i]);
+      OsiSimpleInteger *obj2 = dynamic_cast< OsiSimpleInteger * >(objects[i]);
       if (obj2) {
         // Osi takes precedence
@@ -11993 +11993 @@
   // and existing
   for (i = 0; i < numberObjects_; i++) {
-    CbcSimpleInteger *obj = dynamic_cast<CbcSimpleInteger *>(object_[i]);
+    CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(object_[i]);
     if (obj) {
       int iColumn = obj->columnNumber();
@@ -12042 +12042 @@
   for (i = 0; i < numberObjects_; i++) {
     if (object_[i]) {
-      CbcSimpleInteger *obj = dynamic_cast<CbcSimpleInteger *>(object_[i]);
+      CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(object_[i]);
       if (obj) {
         delete object_[i];
@@ -12052 +12052 @@
   // and rest of new
   for (i = 0; i < numberObjects; i++) {
-    CbcSimpleInteger *obj = dynamic_cast<CbcSimpleInteger *>(objects[i]);
-    OsiSimpleInteger *obj2 = dynamic_cast<OsiSimpleInteger *>(objects[i]);
+    CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(objects[i]);
+    OsiSimpleInteger *obj2 = dynamic_cast< OsiSimpleInteger * >(objects[i]);
     if (!obj && !obj2) {
       temp[n] = objects[i]->clone();
-      CbcObject *obj = dynamic_cast<CbcObject *>(temp[n]);
+      CbcObject *obj = dynamic_cast< CbcObject * >(temp[n]);
       if (obj)
         obj->setModel(this);
@@ -12133 +12133 @@
 #ifdef COIN_HAS_CLP
     OsiClpSolverInterface *clpContinuousSolver
-      = dynamic_cast<OsiClpSolverInterface *>(continuousSolver_);
+      = dynamic_cast< OsiClpSolverInterface * >(continuousSolver_);
     int modifiedTolerances = 0;
 #ifndef CBC_LEAVE_PERTURBATION_ON_CHECK_SOLUTION
@@ -12191 +12191 @@
       solver_ = continuousSolver_;
     // save basis and solution
-    CoinWarmStartBasis *basis = dynamic_cast<CoinWarmStartBasis *>(solver_->getWarmStart());
+    CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver_->getWarmStart());
     assert(basis != NULL);
     double *saveSolution = CoinCopyOfArray(solver_->getColSolution(),
@@ -12239 +12239 @@
       if ((moreSpecialOptions2_ & 4) != 0) {
         for (int i = 0; i < numberObjects_; i++) {
-          CbcSwitchingBinary *object = dynamic_cast<CbcSwitchingBinary *>(object_[i]);
+          CbcSwitchingBinary *object = dynamic_cast< CbcSwitchingBinary * >(object_[i]);
           if (object) {
             int iColumn = object->columnNumber();
@@ -12412 +12412 @@
       if ((moreSpecialOptions2_ & 4) != 0) {
         for (int i = 0; i < numberObjects_; i++) {
-          CbcSwitchingBinary *object = dynamic_cast<CbcSwitchingBinary *>(object_[i]);
+          CbcSwitchingBinary *object = dynamic_cast< CbcSwitchingBinary * >(object_[i]);
           if (object) {
             int iColumn = object->columnNumber();
@@ -12495 +12495 @@
     // If relaxed then leave bounds on basic variables
     if (fixVariables == -1 && (specialOptions_ & 16) == 0) {
-      CoinWarmStartBasis *basis = dynamic_cast<CoinWarmStartBasis *>(saveSolver->getWarmStart());
+      CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(saveSolver->getWarmStart());
       assert(basis != NULL);
 #ifdef JJF_ZERO //ndef CBC_OTHER_SOLVER
       for (i = 0; i < numberObjects_; i++) {
-        CbcSimpleInteger *obj = dynamic_cast<CbcSimpleInteger *>(object_[i]);
+        CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(object_[i]);
         if (obj) {
           int iColumn = obj->columnNumber();
@@ -12522 +12522 @@
                   residual influence on initialSolve().
                 */
-        CoinWarmStartBasis *slack = dynamic_cast<CoinWarmStartBasis *>(solver_->getEmptyWarmStart());
+        CoinWarmStartBasis *slack = dynamic_cast< CoinWarmStartBasis * >(solver_->getEmptyWarmStart());
         solver_->setWarmStart(slack);
         delete slack;
@@ -12552 +12552 @@
 #ifdef COIN_HAS_CLP
         OsiClpSolverInterface *clpSolver
-          = dynamic_cast<OsiClpSolverInterface *>(solver_);
+          = dynamic_cast< OsiClpSolverInterface * >(solver_);
         if (clpSolver) {
           clpSolver->getModelPtr()->writeBasis("feasible.bas", true);
@@ -12579 +12579 @@
         specialOptions_ &= ~2;
         if (!solver_->isProvenOptimal()) {
-          CoinWarmStartBasis *slack = dynamic_cast<CoinWarmStartBasis *>(solver_->getEmptyWarmStart());
+          CoinWarmStartBasis *slack = dynamic_cast< CoinWarmStartBasis * >(solver_->getEmptyWarmStart());
           solver_->setWarmStart(slack);
           delete slack;
@@ -12957 +12957 @@
     double newObjectiveValue = cutoff;
     if (solverCharacteristics_->solution(newObjectiveValue,
-          const_cast<double *>(solution),
+          const_cast< double * >(solution),
           numberColumns)) {
       objectiveValue = newObjectiveValue;
@@ -13038 +13038 @@
     double saveObjectiveValue = objectiveValue;
     // save basis
-    CoinWarmStartBasis *basis = dynamic_cast<CoinWarmStartBasis *>(solver_->getWarmStart());
+    CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver_->getWarmStart());
     assert(basis != NULL);
     objectiveValue = checkSolution(cutoff, solution, fixVariables, objectiveValue);
@@ -13051 +13051 @@
       // try again with basic variables with original bounds
       // save basis
-      CoinWarmStartBasis *basis2 = dynamic_cast<CoinWarmStartBasis *>(solver_->getWarmStart());
+      CoinWarmStartBasis *basis2 = dynamic_cast< CoinWarmStartBasis * >(solver_->getWarmStart());
       assert(basis2 != NULL);
       solver_->setWarmStart(basis);
@@ -13091 +13091 @@
         }
         for (i = 0; i < numberObjects_; i++) {
-          CbcSimpleInteger *obj = dynamic_cast<CbcSimpleInteger *>(object_[i]);
+          CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(object_[i]);
           if (obj) {
             int iColumn = obj->columnNumber();
@@ -13634 +13634 @@
   //probingInfo_->initializeFixing();
   for (iGen = 0; iGen < numberCutGenerators_; iGen++) {
-    generator = dynamic_cast<CglProbing *>(generator_[iGen]->generator());
+    generator = dynamic_cast< CglProbing * >(generator_[iGen]->generator());
     if (generator)
       break;
@@ -14344 +14344 @@
 #ifdef COIN_HAS_CLP
   OsiClpSolverInterface *clpSolver
-    = dynamic_cast<OsiClpSolverInterface *>(solver);
+    = dynamic_cast< OsiClpSolverInterface * >(solver);
 #endif
 #ifdef CLIQUE_ANALYSIS
@@ -14496 +14496 @@
         for (int iCutGenerator = 0; iCutGenerator < numberCutGenerators_; iCutGenerator++) {
           CglCutGenerator *generator = generator_[iCutGenerator]->generator();
-          CglGomory *cgl1 = dynamic_cast<CglGomory *>(generator);
+          CglGomory *cgl1 = dynamic_cast< CglGomory * >(generator);
           if (cgl1) {
             cgl1->setLimitAtRoot(cgl1->getLimit());
           }
-          CglTwomir *cgl2 = dynamic_cast<CglTwomir *>(generator);
+          CglTwomir *cgl2 = dynamic_cast< CglTwomir * >(generator);
           if (cgl2) {
             generator_[iCutGenerator]->setHowOften(-100);
@@ -14566 +14566 @@
       for (int iCutGenerator = 0; iCutGenerator < numberCutGenerators_; iCutGenerator++) {
         CglCutGenerator *generator = generator_[iCutGenerator]->generator();
-        CglGomory *cgl1 = dynamic_cast<CglGomory *>(generator);
+        CglGomory *cgl1 = dynamic_cast< CglGomory * >(generator);
         if (cgl1) {
           cgl1->setLimitAtRoot(cgl1->getLimit());
         }
-        CglTwomir *cgl2 = dynamic_cast<CglTwomir *>(generator);
+        CglTwomir *cgl2 = dynamic_cast< CglTwomir * >(generator);
         if (cgl2) {
           generator_[iCutGenerator]->setHowOften(-100);
@@ -14786 +14786 @@
 #ifdef COIN_HAS_CLP
     OsiClpSolverInterface *clpSolver
-      = dynamic_cast<OsiClpSolverInterface *>(solver_);
+      = dynamic_cast< OsiClpSolverInterface * >(solver_);
     if (clpSolver) {
       ClpSimplex *clpSimplex = clpSolver->getModelPtr();
@@ -14932 +14932 @@
   int nBranches = intParam_[CbcNumberBranches];
   if (nBranches) {
-    double average = dblParam_[CbcSumChange] / static_cast<double>(nBranches);
+    double average = dblParam_[CbcSumChange] / static_cast< double >(nBranches);
     dblParam_[CbcSmallChange] = CoinMax(average * 1.0e-5, dblParam_[CbcSmallestChange]);
     dblParam_[CbcSmallChange] = CoinMax(dblParam_[CbcSmallChange], 1.0e-8);
@@ -15002 +15002 @@
         && !cuts.sizeRowCuts()) {
         OsiClpSolverInterface *clpSolver
-          = dynamic_cast<OsiClpSolverInterface *>(solver_);
+          = dynamic_cast< OsiClpSolverInterface * >(solver_);
         if (clpSolver) {
           anyAction = newNode->chooseClpBranch(this, oldNode);
@@ -15016 +15016 @@
       int save = 0;
       OsiClpSolverInterface *clpSolver
-        = dynamic_cast<OsiClpSolverInterface *>(solver_);
+        = dynamic_cast< OsiClpSolverInterface * >(solver_);
       if (clpSolver && (moreSpecialOptions_ & 4194304) != 0) {
         ClpSimplex *clpSimplex = clpSolver->getModelPtr();
@@ -15087 +15087 @@
         for (int i = 0; i < numberUpdateItems_; i++) {
           CbcObjectUpdateData *update = updateItems_ + i;
-          CbcObject *object = dynamic_cast<CbcObject *>(update->object_);
+          CbcObject *object = dynamic_cast< CbcObject * >(update->object_);
 #ifndef NDEBUG
           bool found = false;
@@ -15206 +15206 @@
                "(active only) %d\n",
           numberRowsAtContinuous_ + numberNewCuts_ + numberOldActiveCuts_);
-        const CoinWarmStartBasis *debugws = dynamic_cast<const CoinWarmStartBasis *>(solver_->getWarmStart());
+        const CoinWarmStartBasis *debugws = dynamic_cast< const CoinWarmStartBasis * >(solver_->getWarmStart());
         debugws->print();
         delete debugws;
@@ -15214 +15214 @@
     {
       OsiBranchingObject *branchingObject = newNode->modifiableBranchingObject();
-      CbcGeneralBranchingObject *generalBranch = dynamic_cast<CbcGeneralBranchingObject *>(branchingObject);
+      CbcGeneralBranchingObject *generalBranch = dynamic_cast< CbcGeneralBranchingObject * >(branchingObject);
       if (generalBranch && false) {
         int numberProblems = generalBranch->numberSubProblems();
@@ -15418 +15418 @@
       solution = solver_->getColSolution();
       // Save current basis
-      CoinWarmStartBasis *ws = dynamic_cast<CoinWarmStartBasis *>(solver_->getWarmStart());
+      CoinWarmStartBasis *ws = dynamic_cast< CoinWarmStartBasis * >(solver_->getWarmStart());
       assert(ws);
       setBestSolutionBasis(*ws);
@@ -15589 +15589 @@
               void *argBundle);
             parallelHeuristics(nThisTime,
-              static_cast<int>(sizeof(argBundle)),
+              static_cast< int >(sizeof(argBundle)),
               parameters);
             double cutoff = heuristicValue;
@@ -15759 +15759 @@
     if (found >= 0) {
       CbcTreeLocal *tree
-        = dynamic_cast<CbcTreeLocal *>(tree_);
+        = dynamic_cast< CbcTreeLocal * >(tree_);
       if (tree)
         tree->passInSolution(bestSolution_, heuristicValue);
@@ -15779 +15779 @@
       // delete FPump
       CbcHeuristicFPump *pump
-        = dynamic_cast<CbcHeuristicFPump *>(heuristic_[i]);
+        = dynamic_cast< CbcHeuristicFPump * >(heuristic_[i]);
       if (pump && pump->feasibilityPumpOptions() < 1000000
         && (specialOptions_ & 33554432) == 0) {
@@ -15834 +15834 @@
       name.c_str(), howOften);
     // change name
-    name[0] = static_cast<char>(toupper(name[0]));
+    name[0] = static_cast< char >(toupper(name[0]));
     fprintf(fp, "\"%s\",%s,%s,%s,%d,%d,%d);\n",
       name.c_str(), normal ? "true" : "false",
@@ -15966 +15966 @@
   double &originalUpper)
 {
-  const CbcSimpleInteger *integerObject = dynamic_cast<const CbcSimpleInteger *>(object);
+  const CbcSimpleInteger *integerObject = dynamic_cast< const CbcSimpleInteger * >(object);
   if (integerObject) {
     // get original bounds
@@ -15972 +15972 @@
     originalUpper = integerObject->originalUpperBound();
   } else {
-    const OsiSimpleInteger *integerObject = dynamic_cast<const OsiSimpleInteger *>(object);
+    const OsiSimpleInteger *integerObject = dynamic_cast< const OsiSimpleInteger * >(object);
     assert(integerObject);
     // get original bounds
@@ -16111 +16111 @@
       OsiBranchingObject *branch2 = node->modifiableBranchingObject();
 #ifndef NDEBUG
-      CbcBranchingObject *branch = dynamic_cast<CbcBranchingObject *>(branch2);
+      CbcBranchingObject *branch = dynamic_cast< CbcBranchingObject * >(branch2);
       assert(branch);
 #else
-      CbcBranchingObject *branch = static_cast<CbcBranchingObject *>(branch2);
+      CbcBranchingObject *branch = static_cast< CbcBranchingObject * >(branch2);
 #endif
 #if 1
@@ -16198 +16198 @@
 #ifdef COIN_HAS_CLP
       OsiClpSolverInterface *clpSolver
-        = dynamic_cast<OsiClpSolverInterface *>(solver_);
+        = dynamic_cast< OsiClpSolverInterface * >(solver_);
       if ((clpSolver || (specialOptions_ & 16384) != 0) && fastNodeDepth_ < -1
         && (specialOptions_ & 2048) == 0) {
@@ -16251 +16251 @@
             int nBranches = intParam_[CbcNumberBranches];
             if (nBranches) {
-              double average = dblParam_[CbcSumChange] / static_cast<double>(nBranches);
+              double average = dblParam_[CbcSumChange] / static_cast< double >(nBranches);
               info->smallChange_ = CoinMax(average * 1.0e-5, dblParam_[CbcSmallestChange]);
               info->smallChange_ = CoinMax(info->smallChange_, 1.0e-8);
@@ -16428 +16428 @@
               double largest = -1.0;
               for (int i = 0; i < numberIntegers_; i++) {
-                CbcSimpleIntegerDynamicPseudoCost *obj = dynamic_cast<CbcSimpleIntegerDynamicPseudoCost *>(object_[i]);
+                CbcSimpleIntegerDynamicPseudoCost *obj = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object_[i]);
                 if (!obj)
                   continue;
@@ -16598 +16598 @@
           solver_->getRowCutDebuggerAlways()->printOptimalSolution(*solver_);
           solver_->writeMpsNative("infeas.mps", NULL, NULL, 2);
-          CoinWarmStartBasis *slack = dynamic_cast<CoinWarmStartBasis *>(solver_->getEmptyWarmStart());
+          CoinWarmStartBasis *slack = dynamic_cast< CoinWarmStartBasis * >(solver_->getEmptyWarmStart());
           solver_->setWarmStart(slack);
           delete slack;
@@ -16633 +16633 @@
           //const double * bounds = nodeInfo->newBounds();
           const OsiBranchingObject *obj = node->branchingObject();
-          const CbcIntegerBranchingObject *objectI = dynamic_cast<const CbcIntegerBranchingObject *>(obj);
+          const CbcIntegerBranchingObject *objectI = dynamic_cast< const CbcIntegerBranchingObject * >(obj);
           if (objectI) {
-            const CbcSimpleInteger *object1 = dynamic_cast<const CbcSimpleInteger *>(objectI->object());
+            const CbcSimpleInteger *object1 = dynamic_cast< const CbcSimpleInteger * >(objectI->object());
             int iColumn1 = -1;
             int way1 = 0;
@@ -16645 +16645 @@
               double originalUpper1 = object1->originalUpperBound();
               // Unset all bounds from parents
-              CbcPartialNodeInfo *partial = dynamic_cast<CbcPartialNodeInfo *>(nodeInfo);
+              CbcPartialNodeInfo *partial = dynamic_cast< CbcPartialNodeInfo * >(nodeInfo);
               touched[iColumn1] = 1;
               if (partial) {
@@ -16708 +16708 @@
                 continue;
               OsiBranchingObject *obj = nodeLook->modifiableBranchingObject();
-              CbcIntegerBranchingObject *objectI = dynamic_cast<CbcIntegerBranchingObject *>(obj);
+              CbcIntegerBranchingObject *objectI = dynamic_cast< CbcIntegerBranchingObject * >(obj);
               //const OsiObject * object2a = obj->originalObject();
               //assert (object2a);
-              const CbcSimpleInteger *object2 = dynamic_cast<const CbcSimpleInteger *>(objectI->object());
+              const CbcSimpleInteger *object2 = dynamic_cast< const CbcSimpleInteger * >(objectI->object());
               if (nodeInfo->numberBranchesLeft() && object2) {
                 int iColumn2 = object2->columnNumber();
@@ -16967 +16967 @@
         for (i = 0; i < numberUpdateItems_; i++) {
           CbcObjectUpdateData *update = updateItems_ + i;
-          CbcObject *object = dynamic_cast<CbcObject *>(update->object_);
+          CbcObject *object = dynamic_cast< CbcObject * >(update->object_);
 #ifndef NDEBUG
           bool found = false;
@@ -17316 +17316 @@
   if (nodeLook) {
     OsiBranchingObject *obj = nodeLook->modifiableBranchingObject();
-    CbcIntegerBranchingObject *objectI = dynamic_cast<CbcIntegerBranchingObject *>(obj);
+    CbcIntegerBranchingObject *objectI = dynamic_cast< CbcIntegerBranchingObject * >(obj);
     //const OsiObject * object2 = obj->orig
 #ifndef NDEBUG
-    const CbcSimpleInteger *object2 = dynamic_cast<const CbcSimpleInteger *>(objectI->object());
+    const CbcSimpleInteger *object2 = dynamic_cast< const CbcSimpleInteger * >(objectI->object());
     assert(object2);
     assert(iColumn == object2->columnNumber());
@@ -17336 +17336 @@
     if (nodeLook) {
       const OsiBranchingObject *obj = nodeLook->branchingObject();
-      const CbcIntegerBranchingObject *objectI = dynamic_cast<const CbcIntegerBranchingObject *>(obj);
+      const CbcIntegerBranchingObject *objectI = dynamic_cast< const CbcIntegerBranchingObject * >(obj);
       //const OsiObject * object2 = obj->orig
-      const CbcSimpleInteger *object2 = dynamic_cast<const CbcSimpleInteger *>(objectI->object());
+      const CbcSimpleInteger *object2 = dynamic_cast< const CbcSimpleInteger * >(objectI->object());
       assert(object2);
       int iColumn2 = object2->columnNumber();
@@ -17382 +17382 @@
 #endif
   for (i = 0; i < numberObjects_; i++) {
-    CbcSimpleIntegerDynamicPseudoCost *obj = dynamic_cast<CbcSimpleIntegerDynamicPseudoCost *>(object_[i]);
+    CbcSimpleIntegerDynamicPseudoCost *obj = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object_[i]);
     if (!obj)
       continue;
@@ -17526 +17526 @@
   int nRoot = CoinMax(40000, 8 * numberRows + 4 * numberColumns);
   for (int i = 0; i < numberHeuristics_; i++) {
-    CbcHeuristicDive *heuristic = dynamic_cast<CbcHeuristicDive *>(heuristic_[i]);
+    CbcHeuristicDive *heuristic = dynamic_cast< CbcHeuristicDive * >(heuristic_[i]);
     if (heuristic && heuristic->maxSimplexIterations() != COIN_INT_MAX) {
       heuristic->setMaxSimplexIterations(nTree);
@@ -17572 +17572 @@
   } else if (which <= numberSavedSolutions_) {
     double *sol = savedSolutions_[which - 1];
-    assert(static_cast<int>(sol[0]) == solver_->getNumCols());
+    assert(static_cast< int >(sol[0]) == solver_->getNumCols());
     return sol[1];
   } else {
@@ -17586 +17586 @@
   } else if (which <= numberSavedSolutions_) {
     double *sol = savedSolutions_[which - 1];
-    assert(static_cast<int>(sol[0]) == solver_->getNumCols());
+    assert(static_cast< int >(sol[0]) == solver_->getNumCols());
     return sol + 2;
   } else {
@@ -17606 +17606 @@
     for (k = numberSavedSolutions_ - 1; k >= 0; k--) {
       double *sol = savedSolutions_[k];
-      assert(static_cast<int>(sol[0]) == n);
+      assert(static_cast< int >(sol[0]) == n);
       if (objectiveValue > sol[1])
         break;
@@ -17669 +17669 @@
   if (!savePivotMethod && !parentModel_) {
     OsiClpSolverInterface *clpSolver
-      = dynamic_cast<OsiClpSolverInterface *>(solver_);
+      = dynamic_cast< OsiClpSolverInterface * >(solver_);
     if (clpSolver && numberNodes_ >= numberNodes && numberNodes_ < 2 * numberNodes && clpSolver->getNumRows() < 10000) {
       if (numberIterations_ < (numberSolves_ + numberNodes_) * 10) {
@@ -17675 +17675 @@
         ClpSimplex *simplex = clpSolver->getModelPtr();
         ClpDualRowPivot *pivotMethod = simplex->dualRowPivot();
-        ClpDualRowDantzig *pivot = dynamic_cast<ClpDualRowDantzig *>(pivotMethod);
+        ClpDualRowDantzig *pivot = dynamic_cast< ClpDualRowDantzig * >(pivotMethod);
         if (!pivot) {
           savePivotMethod = pivotMethod->clone(true);
@@ -17764 +17764 @@
   synchronizeModel(); // make sure everything that needs solver has it
   if (!solverCharacteristics_) {
-    OsiBabSolver *solverCharacteristics = dynamic_cast<OsiBabSolver *>(solver_->getAuxiliaryInfo());
+    OsiBabSolver *solverCharacteristics = dynamic_cast< OsiBabSolver * >(solver_->getAuxiliaryInfo());
     if (solverCharacteristics) {
       solverCharacteristics_ = solverCharacteristics;
@@ -17771 +17771 @@
       OsiBabSolver defaultC;
       solver_->setAuxiliaryInfo(&defaultC);
-      solverCharacteristics_ = dynamic_cast<OsiBabSolver *>(solver_->getAuxiliaryInfo());
+      solverCharacteristics_ = dynamic_cast< OsiBabSolver * >(solver_->getAuxiliaryInfo());
     }
   }
@@ -17866 +17866 @@
             if (objective[iColumn]) {
               double value = fabs(objective[iColumn]) * multiplier;
-              int nearest = static_cast<int>(floor(value + 0.5));
+              int nearest = static_cast< int >(floor(value + 0.5));
               if (fabs(value - floor(value + 0.5)) > 1.0e-8 || value > 2.1e9) {
                 increment = 0;
@@ -17901 +17901 @@
     // do presolve - for now just clp but easy to get osi interface
     OsiClpSolverInterface *clpSolver
-      = dynamic_cast<OsiClpSolverInterface *>(cleanModel);
+      = dynamic_cast< OsiClpSolverInterface * >(cleanModel);
     if (clpSolver) {
       ClpSimplex *clp = clpSolver->getModelPtr();
@@ -18102 +18102 @@
     // do presolve - for now just clp but easy to get osi interface
     OsiClpSolverInterface *clpSolver
-      = dynamic_cast<OsiClpSolverInterface *>(solver_);
+      = dynamic_cast< OsiClpSolverInterface * >(solver_);
     assert(clpSolver);
     ClpSimplex *clp = clpSolver->getModelPtr();
@@ -18155 +18155 @@
 #ifdef COIN_HAS_CLP
   OsiClpSolverInterface *clpSolver
-    = dynamic_cast<OsiClpSolverInterface *>(solver_);
+    = dynamic_cast< OsiClpSolverInterface * >(solver_);
   if (clpSolver)
     clpSolver->setOptionalInteger(index);
@@ -18222 +18222 @@
 #ifdef COIN_HAS_CLP
     OsiClpSolverInterface *clpSolver
-      = dynamic_cast<OsiClpSolverInterface *>(solver);
+      = dynamic_cast< OsiClpSolverInterface * >(solver);
     if (clpSolver) {
       double *dj = clpSolver->getModelPtr()->dualColumnSolution();
@@ -18289 +18289 @@
   int numberSOS2 = 0;
   for (i = 0; i < numberObjects_; i++) {
-    CbcSOS *objSOS = dynamic_cast<CbcSOS *>(object_[i]);
+    CbcSOS *objSOS = dynamic_cast< CbcSOS * >(object_[i]);
     if (objSOS) {
       int type = objSOS->sosType();
@@ -18302 +18302 @@
     memset(prohibited, 0, numberColumns);
     for (i = 0; i < numberObjects_; i++) {
-      CbcSOS *objSOS = dynamic_cast<CbcSOS *>(object_[i]);
+      CbcSOS *objSOS = dynamic_cast< CbcSOS * >(object_[i]);
       if (objSOS) {
         int type = objSOS->sosType();
@@ -18359 +18359 @@
       if (temp[jColumn] >= 0) {
         int iObject = temp[jColumn];
-        CbcSimpleInteger *obj = dynamic_cast<CbcSimpleInteger *>(originalObject[iObject]);
+        CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(originalObject[iObject]);
         if (obj)
           numberOldIntegers++;
@@ -18393 +18393 @@
       if (temp[jColumn] >= 0) {
         int iObject = temp[jColumn];
-        CbcSimpleInteger *obj = dynamic_cast<CbcSimpleInteger *>(originalObject[iObject]);
+        CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(originalObject[iObject]);
         if (obj) {
           object_[numberIntegers_] = originalObject[iObject]->clone();
@@ -18413 +18413 @@
       if (temp[jColumn] >= 0) {
         int iObject = temp[jColumn];
-        CbcSimpleInteger *obj = dynamic_cast<CbcSimpleInteger *>(originalObject[iObject]);
+        CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(originalObject[iObject]);
         if (!obj) {
           object_[numberObjects_] = originalObject[iObject]->clone();
           // redo ids etc
-          CbcObject *obj = dynamic_cast<CbcObject *>(object_[numberObjects_]);
+          CbcObject *obj = dynamic_cast< CbcObject * >(object_[numberObjects_]);
           assert(obj);
           obj->redoSequenceEtc(this, numberColumns, originalColumns);
@@ -18430 +18430 @@
         object_[numberObjects_] = originalObject[iObject]->clone();
         // redo ids etc
-        CbcObject *obj = static_cast<CbcObject *>(object_[numberObjects_]);
+        CbcObject *obj = static_cast< CbcObject * >(object_[numberObjects_]);
         assert(obj);
         obj->redoSequenceEtc(this, numberColumns, originalColumns);
@@ -18645 +18645 @@
     const OsiObject *object = object_[i];
 #ifndef NDEBUG
-    const CbcSimpleInteger *integerObject = dynamic_cast<const CbcSimpleInteger *>(object);
+    const CbcSimpleInteger *integerObject = dynamic_cast< const CbcSimpleInteger * >(object);
     assert(integerObject);
 #else
-      const CbcSimpleInteger *integerObject = static_cast<const CbcSimpleInteger *>(object);
+      const CbcSimpleInteger *integerObject = static_cast< const CbcSimpleInteger * >(object);
 #endif
     // get original bounds
@@ -18777 +18777 @@
     const OsiObject *object = object_[i];
 #ifndef NDEBUG
-    const CbcSimpleInteger *integerObject = dynamic_cast<const CbcSimpleInteger *>(object);
+    const CbcSimpleInteger *integerObject = dynamic_cast< const CbcSimpleInteger * >(object);
     assert(integerObject);
 #else
-      const CbcSimpleInteger *integerObject = static_cast<const CbcSimpleInteger *>(object);
+      const CbcSimpleInteger *integerObject = static_cast< const CbcSimpleInteger * >(object);
 #endif
     // get original bounds
@@ -18866 +18866 @@
 static void *doRootCbcThread(void *voidInfo)
 {
-  CbcModel *model = reinterpret_cast<CbcModel *>(voidInfo);
+  CbcModel *model = reinterpret_cast< CbcModel * >(voidInfo);
 #ifdef COIN_HAS_CLP
   OsiClpSolverInterface *clpSolver
-    = dynamic_cast<OsiClpSolverInterface *>(model->solver());
+    = dynamic_cast< OsiClpSolverInterface * >(model->solver());
   char general[200];
   if (clpSolver) {
@@ -18907 +18907 @@
 #ifdef COIN_HAS_CLP
   const OsiClpSolverInterface *clpSolver
-    = dynamic_cast<const OsiClpSolverInterface *>(solver);
+    = dynamic_cast< const OsiClpSolverInterface * >(solver);
   if (clpSolver && topOfTree_) {
     int debugMode = 0;
@@ -19268 +19268 @@
   mipStart_.clear();
   for (int i = 0; (i < count); ++i)
-    mipStart_.push_back(std::pair<std::string, double>(std::string(colNames[i]), colValues[i]));
+    mipStart_.push_back(std::pair< std::string, double >(std::string(colNames[i]), colValues[i]));
 }
 #ifdef COIN_HAS_NTY
@@ -19287 +19287 @@
 #ifdef COIN_HAS_CLP
   OsiClpSolverInterface *clpSolver
-    = dynamic_cast<OsiClpSolverInterface *>(solver_);
+    = dynamic_cast< OsiClpSolverInterface * >(solver_);
   if (clpSolver) {
     int numberColumns = clpSolver->getNumCols();
@@ -19295 +19295 @@
     int numberSOS = 0;
     for (int i = 0; i < numberObjects_; i++) {
-      CbcObject *obj = dynamic_cast<CbcObject *>(object_[i]);
-      CbcSimpleInteger *thisInt = dynamic_cast<CbcSimpleInteger *>(obj);
-      OsiSOS *objSOS1 = dynamic_cast<OsiSOS *>(obj);
-      CbcSOS *objSOS2 = dynamic_cast<CbcSOS *>(obj);
+      CbcObject *obj = dynamic_cast< CbcObject * >(object_[i]);
+      CbcSimpleInteger *thisInt = dynamic_cast< CbcSimpleInteger * >(obj);
+      OsiSOS *objSOS1 = dynamic_cast< OsiSOS * >(obj);
+      CbcSOS *objSOS2 = dynamic_cast< CbcSOS * >(obj);
       if (thisInt) {
         clpSolver->setInteger(thisInt->columnNumber());
@@ -19321 +19321 @@
       numberSOS = 0;
       for (int i = 0; i < numberObjects_; i++) {
-        CbcObject *obj = dynamic_cast<CbcObject *>(object_[i]);
-        OsiSOS *objSOS1 = dynamic_cast<OsiSOS *>(obj);
-        CbcSOS *objSOS2 = dynamic_cast<CbcSOS *>(obj);
+        CbcObject *obj = dynamic_cast< CbcObject * >(object_[i]);
+        OsiSOS *objSOS1 = dynamic_cast< OsiSOS * >(obj);
+        CbcSOS *objSOS2 = dynamic_cast< CbcSOS * >(obj);
         if (objSOS1 || objSOS2) {
           int numberMembers;
@@ -19366 +19366 @@
 #define ZERO_ODD_TOLERANCE 1.0e-14
 #endif
-  OsiClpSolverInterface *osiclp = dynamic_cast<OsiClpSolverInterface *>(solver);
+  OsiClpSolverInterface *osiclp = dynamic_cast< OsiClpSolverInterface * >(solver);
   if (osiclp && osiclp->isProvenOptimal()) {
     int numberColumns = osiclp->getNumCols();
@@ -19434 +19434 @@
 CbcModel::setupCleanVariables()
 {
-  OsiClpSolverInterface *osiclp = dynamic_cast<OsiClpSolverInterface *>(solver_);
+  OsiClpSolverInterface *osiclp = dynamic_cast< OsiClpSolverInterface * >(solver_);
   int numberColumns = osiclp->getNumCols();
   char *cleanVariables = NULL;
@@ -19441 +19441 @@
     memset(cleanVariables, 0, numberColumns);
     for (int i = 0; i < numberObjects_; i++) {
-      const CbcSimpleInteger *intvar = dynamic_cast<const CbcSimpleInteger *>(object_[i]);
-      const CbcSOS *sos = dynamic_cast<const CbcSOS *>(object_[i]);
+      const CbcSimpleInteger *intvar = dynamic_cast< const CbcSimpleInteger * >(object_[i]);
+      const CbcSOS *sos = dynamic_cast< const CbcSOS * >(object_[i]);
       if (intvar) {
 #ifdef CLEAN_INTEGER_VARIABLES

trunk/Cbc/src/CbcModel.hpp

@@ -2691 +2691 @@
   //@}
 
-  void setMIPStart(const std::vector<std::pair<std::string, double>> &mips)
+  void setMIPStart(const std::vector< std::pair< std::string, double > > &mips)
   {
     this->mipStart_ = mips;
@@ -2700 +2700 @@
   void setMIPStart(int count, const char **colNames, const double colValues[]);
 
-  const std::vector<std::pair<std::string, double>> &getMIPStart()
+  const std::vector< std::pair< std::string, double > > &getMIPStart()
   {
     return this->mipStart_;
@@ -2782 +2782 @@
       values for integer variables which will be converted to a complete integer initial feasible solution
     */
-  std::vector<std::pair<std::string, double>> mipStart_;
+  std::vector< std::pair< std::string, double > > mipStart_;
   /** Warm start object produced by heuristic or strong branching
 

trunk/Cbc/src/CbcNode.cpp

@@ -140 +140 @@
         */
     bool mustDeleteBasis;
-    const CoinWarmStartBasis *ws = dynamic_cast<const CoinWarmStartBasis *>(solver->getPointerToWarmStart(mustDeleteBasis));
+    const CoinWarmStartBasis *ws = dynamic_cast< const CoinWarmStartBasis * >(solver->getPointerToWarmStart(mustDeleteBasis));
     assert(ws != NULL); // make sure not volume
     //int numberArtificials = lastws->getNumArtificial();
@@ -159 +159 @@
           and new cuts (numberNewCuts). This will become the expanded basis.
         */
-    CoinWarmStartBasis *expanded = dynamic_cast<CoinWarmStartBasis *>(ws->clone());
+    CoinWarmStartBasis *expanded = dynamic_cast< CoinWarmStartBasis * >(ws->clone());
     int iCompact = numberRowsAtContinuous + numberOldActiveCuts + numberNewCuts;
     // int nPartial = numberRowsAtContinuous+currentNumberCuts;
@@ -349 +349 @@
   else {
     bool mustDeleteBasis;
-    const CoinWarmStartBasis *ws = dynamic_cast<const CoinWarmStartBasis *>(solver->getPointerToWarmStart(mustDeleteBasis));
+    const CoinWarmStartBasis *ws = dynamic_cast< const CoinWarmStartBasis * >(solver->getPointerToWarmStart(mustDeleteBasis));
     assert(ws != NULL); // make sure not volume
     //int numberArtificials = lastws->getNumArtificial();
@@ -384 +384 @@
         basis. Makes me (Lou) less nervous to compare apples to apples.
         */
-    CoinWarmStartBasis *expanded = dynamic_cast<CoinWarmStartBasis *>(ws->clone());
+    CoinWarmStartBasis *expanded = dynamic_cast< CoinWarmStartBasis * >(ws->clone());
     int numberRowsAtContinuous = model->numberRowsAtContinuous();
     int iFull = numberRowsAtContinuous + model->currentNumberCuts() + numberNewCuts;
@@ -532 +532 @@
   char *cleanVariables = NULL;
 #ifdef COIN_HAS_CLP
-  OsiClpSolverInterface *osiclp = dynamic_cast<OsiClpSolverInterface *>(solver);
+  OsiClpSolverInterface *osiclp = dynamic_cast< OsiClpSolverInterface * >(solver);
   int saveClpOptions = 0;
   if (osiclp) {
@@ -588 +588 @@
       for (int i = 0; i < numberObjects; i++) {
         OsiObject *object = model->modifiableObject(i);
-        const CbcSimpleInteger *thisOne = dynamic_cast<const CbcSimpleInteger *>(object);
+        const CbcSimpleInteger *thisOne = dynamic_cast< const CbcSimpleInteger * >(object);
         if (thisOne) {
           int iColumn = thisOne->columnNumber();
@@ -634 +634 @@
     */
   CbcBranchDecision *decision = model->branchingMethod();
-  CbcDynamicPseudoCostBranchingObject *dynamicBranchingObject = dynamic_cast<CbcDynamicPseudoCostBranchingObject *>(decision);
+  CbcDynamicPseudoCostBranchingObject *dynamicBranchingObject = dynamic_cast< CbcDynamicPseudoCostBranchingObject * >(decision);
   if (!decision || dynamicBranchingObject)
     decision = new CbcBranchDefaultDecision();
@@ -694 +694 @@
         if (hotstartSolution) {
           // we are doing hot start
-          const CbcSimpleInteger *thisOne = dynamic_cast<const CbcSimpleInteger *>(object);
+          const CbcSimpleInteger *thisOne = dynamic_cast< const CbcSimpleInteger * >(object);
           if (thisOne) {
             int iColumn = thisOne->columnNumber();
@@ -782 +782 @@
             choice[iSmallest].upMovement = infeasibility;
             delete choice[iSmallest].possibleBranch;
-            CbcObject *obj = dynamic_cast<CbcObject *>(object);
+            CbcObject *obj = dynamic_cast< CbcObject * >(object);
             assert(obj);
             choice[iSmallest].possibleBranch = obj->createCbcBranch(solver, &usefulInfo, preferredWay);
@@ -812 +812 @@
           int k = choice[0].objectNumber;
           OsiObject *object = model->modifiableObject(k);
-          const CbcSimpleInteger *thisOne = dynamic_cast<const CbcSimpleInteger *>(object);
+          const CbcSimpleInteger *thisOne = dynamic_cast< const CbcSimpleInteger * >(object);
           assert(thisOne);
           int iColumn = thisOne->columnNumber();
@@ -826 +826 @@
         bool roundAgain = false;
         // get basis
-        CoinWarmStartBasis *ws = dynamic_cast<CoinWarmStartBasis *>(solver->getWarmStart());
+        CoinWarmStartBasis *ws = dynamic_cast< CoinWarmStartBasis * >(solver->getWarmStart());
         if (!ws)
           break;
@@ -871 +871 @@
       choice[i].numIntInfeasDown = numberUnsatisfied_;
       choice[i].fix = 0; // say not fixed
-      if (!dynamic_cast<const CbcSimpleInteger *>(model->object(choice[i].objectNumber)))
+      if (!dynamic_cast< const CbcSimpleInteger * >(model->object(choice[i].objectNumber)))
         allNormal = false; // Something odd so lets skip clever fast branching
       if (!model->object(choice[i].objectNumber)->boundBranch())
@@ -957 +957 @@
         int *whichColumn = new int[2 * numberColumns];
         int nBound;
-        ClpSimplex *small = static_cast<ClpSimplexOther *>(clp)->crunch(rhs, whichRow, whichColumn, nBound, true);
+        ClpSimplex *small = static_cast< ClpSimplexOther * >(clp)->crunch(rhs, whichRow, whichColumn, nBound, true);
         if (!small) {
           anyAction = -2;
@@ -1000 +1000 @@
           int iObject = choice[i].objectNumber;
           const OsiObject *object = model->object(iObject);
-          const CbcSimpleInteger *simple = static_cast<const CbcSimpleInteger *>(object);
+          const CbcSimpleInteger *simple = static_cast< const CbcSimpleInteger * >(object);
           int iSequence = simple->columnNumber();
           newLower[i] = ceil(saveSolution[iSequence]);
@@ -1035 +1035 @@
             int iObject = choice[i].objectNumber;
             const OsiObject *object = model->object(iObject);
-            const CbcSimpleInteger *simple = static_cast<const CbcSimpleInteger *>(object);
+            const CbcSimpleInteger *simple = static_cast< const CbcSimpleInteger * >(object);
             int iSequence = simple->columnNumber();
             which[i] = iSequence;
@@ -1632 +1632 @@
   // get information on solver type
   const OsiAuxInfo *auxInfo = solver->getAuxiliaryInfo();
-  const OsiBabSolver *auxiliaryInfo = dynamic_cast<const OsiBabSolver *>(auxInfo);
+  const OsiBabSolver *auxiliaryInfo = dynamic_cast< const OsiBabSolver * >(auxInfo);
   if (!auxiliaryInfo) {
     // use one from CbcModel
@@ -1645 +1645 @@
     for (int i = model->numberIntegers(); i < numberObjects; i++) {
       OsiObject *object = model->modifiableObject(i);
-      CbcObject *obj = dynamic_cast<CbcObject *>(object);
+      CbcObject *obj = dynamic_cast< CbcObject * >(object);
       if (!obj || !obj->optionalObject()) {
         double infeasibility = object->checkInfeasibility(&usefulInfo);
@@ -1671 +1671 @@
     for (int i = 0; i < numberRows; i++)
       sumPi += fabs(pi[i]);
-    sumPi /= static_cast<double>(numberRows);
+    sumPi /= static_cast< double >(numberRows);
     // and scale back
     sumPi *= 0.01;
@@ -1735 +1735 @@
       for (int i = 0; i < numberObjects; i++) {
         OsiObject *object = model->modifiableObject(i);
-        const CbcSimpleInteger *thisOne = dynamic_cast<const CbcSimpleInteger *>(object);
+        const CbcSimpleInteger *thisOne = dynamic_cast< const CbcSimpleInteger * >(object);
         if (thisOne) {
           int iColumn = thisOne->columnNumber();
@@ -1801 +1801 @@
     for (i = 0; i < numberObjects; i++) {
       OsiObject *object = model->modifiableObject(i);
-      CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast<CbcSimpleIntegerDynamicPseudoCost *>(object);
+      CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object);
       assert(dynamicObject);
       int numberUp2 = 0;
@@ -1824 +1824 @@
     }
     if (numberUp)
-      averageUp /= static_cast<double>(numberUp);
+      averageUp /= static_cast< double >(numberUp);
     else
       averageUp = 1.0;
     if (numberDown)
-      averageDown /= static_cast<double>(numberDown);
+      averageDown /= static_cast< double >(numberDown);
     else
       averageDown = 1.0;
@@ -1842 +1842 @@
   char *cleanVariables = NULL;
 #ifdef COIN_HAS_CLP
-  OsiClpSolverInterface *osiclp = dynamic_cast<OsiClpSolverInterface *>(solver);
+  OsiClpSolverInterface *osiclp = dynamic_cast< OsiClpSolverInterface * >(solver);
   int saveClpOptions = 0;
   if (osiclp) {
@@ -1870 +1870 @@
     for (i = 0; i < numberObjects; i++) {
       OsiObject *object = model->modifiableObject(i);
-      CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast<CbcSimpleIntegerDynamicPseudoCost *>(object);
+      CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object);
       if (dynamicObject) {
         if (dynamicObject->numberTimesUp()) {
@@ -1883 +1883 @@
     }
     if (numberUp)
-      averageUp /= static_cast<double>(numberUp);
+      averageUp /= static_cast< double >(numberUp);
     else
       averageUp = 1.0;
     if (numberDown)
-      averageDown /= static_cast<double>(numberDown);
+      averageDown /= static_cast< double >(numberDown);
     else
       averageDown = 1.0;
     for (i = 0; i < numberObjects; i++) {
       OsiObject *object = model->modifiableObject(i);
-      CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast<CbcSimpleIntegerDynamicPseudoCost *>(object);
+      CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object);
       if (dynamicObject) {
         if (!dynamicObject->numberTimesUp())
@@ -2082 +2082 @@
       for (i = 0; i < numberObjects; i++) {
         OsiObject *object = model->modifiableObject(i);
-        CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast<CbcSimpleIntegerDynamicPseudoCost *>(object);
+        CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object);
         double infeasibility = object->checkInfeasibility(&usefulInfo);
         int priorityLevel = object->priority();
         if (hotstartSolution) {
           // we are doing hot start
-          const CbcSimpleInteger *thisOne = dynamic_cast<const CbcSimpleInteger *>(object);
+          const CbcSimpleInteger *thisOne = dynamic_cast< const CbcSimpleInteger * >(object);
           if (thisOne) {
             int iColumn = thisOne->columnNumber();
@@ -2191 +2191 @@
           } else {
             // see if SOS
-            CbcSOS *sosObject = dynamic_cast<CbcSOS *>(object);
+            CbcSOS *sosObject = dynamic_cast< CbcSOS * >(object);
             if (sosObject) {
               gotDown = false;
@@ -2373 +2373 @@
               for (int i = 0; i < numberObjects; i++) {
                 OsiObject *object = model->modifiableObject(i);
-                CbcSimpleIntegerDynamicPseudoCost *obj = dynamic_cast<CbcSimpleIntegerDynamicPseudoCost *>(object);
+                CbcSimpleIntegerDynamicPseudoCost *obj = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object);
                 assert(obj);
                 int iColumn = obj->columnNumber();
@@ -2397 +2397 @@
         bool roundAgain = false;
         // get basis
-        CoinWarmStartBasis *ws = dynamic_cast<CoinWarmStartBasis *>(solver->getWarmStart());
+        CoinWarmStartBasis *ws = dynamic_cast< CoinWarmStartBasis * >(solver->getWarmStart());
         if (!ws)
           break;
@@ -2500 +2500 @@
       int preferredWay;
       object->infeasibility(&usefulInfo, preferredWay);
-      CbcObject *obj = dynamic_cast<CbcObject *>(object);
+      CbcObject *obj = dynamic_cast< CbcObject * >(object);
       assert(obj);
       branch_ = obj->createCbcBranch(solver, &usefulInfo, preferredWay);
       {
-        CbcBranchingObject *branchObj = dynamic_cast<CbcBranchingObject *>(branch_);
+        CbcBranchingObject *branchObj = dynamic_cast< CbcBranchingObject * >(branch_);
         assert(branchObj);
         branchObj->way(preferredWay);
@@ -2534 +2534 @@
           } else if (gap < 1.0e5) {
             // maybe allow some not needed
-            int extra = static_cast<int>((1.0e6 - needed) / numberRows);
+            int extra = static_cast< int >((1.0e6 - needed) / numberRows);
             int nStored = numberObjects - optionalPenalties;
             extra = CoinMin(extra, nStored);
@@ -2580 +2580 @@
             int iObject = whichObject[j];
             OsiObject *object = model->modifiableObject(iObject);
-            CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast<CbcSimpleIntegerDynamicPseudoCost *>(object);
+            CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object);
             // Use this object's numberBeforeTrust
             int numberBeforeTrustThis = dynamicObject->numberBeforeTrust();
@@ -2601 +2601 @@
               sort[j] = -min1;
             } else if (numberThisDown < numberBeforeTrustThis || numberThisUp < numberBeforeTrustThis) {
-              double invTrust = 1.0 / static_cast<double>(numberBeforeTrustThis);
+              double invTrust = 1.0 / static_cast< double >(numberBeforeTrustThis);
               if (numberThisDown < numberBeforeTrustThis) {
                 double fraction = numberThisDown * invTrust;
@@ -2935 +2935 @@
                   int iObject = whichObject[iDo];
                   OsiObject *object = model->modifiableObject(iObject);
-                  CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast<CbcSimpleIntegerDynamicPseudoCost *>(object);
+                  CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object);
                   int iColumn = dynamicObject ? dynamicObject->columnNumber() : -1;
                   if (iColumn < 0 || orbits[iColumn] >= 0)
@@ -2965 +2965 @@
         int iObject = whichObject[iDo];
         OsiObject *object = model->modifiableObject(iObject);
-        CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast<CbcSimpleIntegerDynamicPseudoCost *>(object);
+        CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object);
         int iColumn = dynamicObject ? dynamicObject->columnNumber() : numberColumns + iObject;
         int preferredWay;
@@ -2982 +2982 @@
         }
 #endif
-        CbcSimpleInteger *obj = dynamic_cast<CbcSimpleInteger *>(object);
+        CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(object);
         if (obj) {
           if (choiceObject) {
@@ -2991 +2991 @@
           }
         } else {