Changeset 2467 for trunk/Cbc


Ignore:
Timestamp:
Jan 3, 2019 4:26:29 PM (11 months ago)
Author:
unxusr
Message:

spaces after angles

Location:
trunk/Cbc/src
Files:
74 edited

Legend:

Unmodified
Added
Removed
  • trunk/Cbc/src/CbcBranchBase.cpp

    r2465 r2467  
    8989{
    9090  //assert (solver==model_->solver());
    91   CbcObject *fudge = const_cast<CbcObject *>(this);
     91  CbcObject *fudge = const_cast< CbcObject * >(this);
    9292  fudge->feasibleRegion();
    9393  return 0.0;
     
    103103{
    104104  //assert (solver==model_->solver());
    105   CbcObject *fudge = const_cast<CbcObject *>(this);
     105  CbcObject *fudge = const_cast< CbcObject * >(this);
    106106  fudge->feasibleRegion();
    107107  return 0.0;
     
    118118{
    119119  //assert (solver==model_->solver());
    120   CbcObject *fudge = const_cast<CbcObject *>(this);
     120  CbcObject *fudge = const_cast< CbcObject * >(this);
    121121  return fudge->createBranch(solver, info, way);
    122122}
  • trunk/Cbc/src/CbcBranchCut.cpp

    r2465 r2467  
    294294int CbcCutBranchingObject::compareOriginalObject(const CbcBranchingObject *brObj) const
    295295{
    296   const CbcCutBranchingObject *br = dynamic_cast<const CbcCutBranchingObject *>(brObj);
     296  const CbcCutBranchingObject *br = dynamic_cast< const CbcCutBranchingObject * >(brObj);
    297297  assert(br);
    298298  const OsiRowCut &r0 = way_ == -1 ? down_ : up_;
     
    313313CbcCutBranchingObject::compareBranchingObject(const CbcBranchingObject *brObj, const bool replaceIfOverlap)
    314314{
    315   const CbcCutBranchingObject *br = dynamic_cast<const CbcCutBranchingObject *>(brObj);
     315  const CbcCutBranchingObject *br = dynamic_cast< const CbcCutBranchingObject * >(brObj);
    316316  assert(br);
    317317  OsiRowCut &r0 = way_ == -1 ? down_ : up_;
  • trunk/Cbc/src/CbcBranchDefaultDecision.cpp

    r2465 r2467  
    215215          if (numberNext < numberUnsatisfied) {
    216216            int numberUp = numberUnsatisfied - numberInfeasibilitiesUp[i];
    217             double perUnsatisfied = changeUp[i] / static_cast<double>(numberUp);
     217            double perUnsatisfied = changeUp[i] / static_cast< double >(numberUp);
    218218            double estimatedObjective = objectiveValue + numberUnsatisfied * perUnsatisfied;
    219219            if (estimatedObjective < cutoff)
     
    223223          if (numberNext < numberUnsatisfied) {
    224224            int numberDown = numberUnsatisfied - numberInfeasibilitiesDown[i];
    225             double perUnsatisfied = changeDown[i] / static_cast<double>(numberDown);
     225            double perUnsatisfied = changeDown[i] / static_cast< double >(numberDown);
    226226            double estimatedObjective = objectiveValue + numberUnsatisfied * perUnsatisfied;
    227227            if (estimatedObjective < cutoff)
     
    344344        if (numberNext < numberUnsatisfied) {
    345345          int numberUp = numberUnsatisfied - numberInfeasibilitiesUp[i];
    346           double perUnsatisfied = changeUp[i] / static_cast<double>(numberUp);
     346          double perUnsatisfied = changeUp[i] / static_cast< double >(numberUp);
    347347          double estimatedObjective = objectiveValue + numberUnsatisfied * perUnsatisfied;
    348348          if (estimatedObjective < bestEstimate) {
     
    355355        if (numberNext < numberUnsatisfied) {
    356356          int numberDown = numberUnsatisfied - numberInfeasibilitiesDown[i];
    357           double perUnsatisfied = changeDown[i] / static_cast<double>(numberDown);
     357          double perUnsatisfied = changeDown[i] / static_cast< double >(numberDown);
    358358          double estimatedObjective = objectiveValue + numberUnsatisfied * perUnsatisfied;
    359359          if (estimatedObjective < bestEstimate) {
  • trunk/Cbc/src/CbcBranchDynamic.cpp

    r2465 r2467  
    202202  OsiBranchingObject *obj = object->clone();
    203203#ifndef NDEBUG
    204   CbcBranchingObject *obj2 = dynamic_cast<CbcBranchingObject *>(obj);
     204  CbcBranchingObject *obj2 = dynamic_cast< CbcBranchingObject * >(obj);
    205205  assert(obj2);
    206206#if COIN_DEVELOP > 1
    207   CbcDynamicPseudoCostBranchingObject *branchingObject = dynamic_cast<CbcDynamicPseudoCostBranchingObject *>(obj);
     207  CbcDynamicPseudoCostBranchingObject *branchingObject = dynamic_cast< CbcDynamicPseudoCostBranchingObject * >(obj);
    208208  if (!branchingObject)
    209209    printf("no dynamic branching object Dynamic Decision\n");
    210210#endif
    211211#else
    212   CbcBranchingObject *obj2 = static_cast<CbcBranchingObject *>(obj);
     212  CbcBranchingObject *obj2 = static_cast< CbcBranchingObject * >(obj);
    213213#endif
    214214  //object_=branchingObject;
     
    254254        */
    255255
    256   CbcDynamicPseudoCostBranchingObject *branchingObject = dynamic_cast<CbcDynamicPseudoCostBranchingObject *>(object_);
     256  CbcDynamicPseudoCostBranchingObject *branchingObject = dynamic_cast< CbcDynamicPseudoCostBranchingObject * >(object_);
    257257  if (!branchingObject) {
    258258    delete object_;
     
    312312#if TYPE2 == 0
    313313      object->addToSumDownCost(change / (nonZeroAmount + movement));
    314       object->setDownDynamicPseudoCost(object->sumDownCost() / static_cast<double>(object->numberTimesDown()));
     314      object->setDownDynamicPseudoCost(object->sumDownCost() / static_cast< double >(object->numberTimesDown()));
    315315#elif TYPE2 == 1
    316316      object->addToSumDownCost(change);
     
    358358#if TYPE2 == 0
    359359      object->addToSumUpCost(change / (nonZeroAmount + movement));
    360       object->setUpDynamicPseudoCost(object->sumUpCost() / static_cast<double>(object->numberTimesUp()));
     360      object->setUpDynamicPseudoCost(object->sumUpCost() / static_cast< double >(object->numberTimesUp()));
    361361#elif TYPE2 == 1
    362362      object->addToSumUpCost(change);
     
    479479    distanceToCutoffC = CoinMax(distanceToCutoffC, 1.0e-12 * (1.0 + fabs(objectiveValue)));
    480480    int numberInfC = model->getContinuousInfeasibilities();
    481     double perInf = distanceToCutoffC / static_cast<double>(numberInfC);
     481    double perInf = distanceToCutoffC / static_cast< double >(numberInfC);
    482482    assert(perInf > 0.0);
    483483    //int numberIntegers = model->numberIntegers();
     
    543543      // not much in it - look at unsatisfied
    544544      if (thisNumber < numberUnsatisfied || bestNumber < numberUnsatisfied) {
    545         double perInteger = distance / (static_cast<double>(numberUnsatisfied));
     545        double perInteger = distance / (static_cast< double >(numberUnsatisfied));
    546546        useValue += thisNumber * perInteger;
    547547        useBest += bestNumber * perInteger;
     
    560560  History hist;
    561561  {
    562     CbcDynamicPseudoCostBranchingObject *branchingObject = dynamic_cast<CbcDynamicPseudoCostBranchingObject *>(thisOne);
     562    CbcDynamicPseudoCostBranchingObject *branchingObject = dynamic_cast< CbcDynamicPseudoCostBranchingObject * >(thisOne);
    563563    if (branchingObject) {
    564564      CbcSimpleIntegerDynamicPseudoCost *object = branchingObject->object();
     
    583583#endif
    584584    // maybe change better way
    585     CbcDynamicPseudoCostBranchingObject *branchingObject = dynamic_cast<CbcDynamicPseudoCostBranchingObject *>(thisOne);
     585    CbcDynamicPseudoCostBranchingObject *branchingObject = dynamic_cast< CbcDynamicPseudoCostBranchingObject * >(thisOne);
    586586    if (branchingObject) {
    587587      CbcSimpleIntegerDynamicPseudoCost *object = branchingObject->object();
     
    752752  info.upMovement = object_->upDynamicPseudoCost() * (ceil(value_) - value_);
    753753  info.downMovement = object_->downDynamicPseudoCost() * (value_ - floor(value_));
    754   info.numIntInfeasUp -= static_cast<int>(object_->sumUpDecrease() / (1.0e-12 + static_cast<double>(object_->numberTimesUp())));
     754  info.numIntInfeasUp -= static_cast< int >(object_->sumUpDecrease() / (1.0e-12 + static_cast< double >(object_->numberTimesUp())));
    755755  info.numIntInfeasUp = CoinMax(info.numIntInfeasUp, 0);
    756756  info.numObjInfeasUp = 0;
    757757  info.finishedUp = false;
    758758  info.numItersUp = 0;
    759   info.numIntInfeasDown -= static_cast<int>(object_->sumDownDecrease() / (1.0e-12 + static_cast<double>(object_->numberTimesDown())));
     759  info.numIntInfeasDown -= static_cast< int >(object_->sumDownDecrease() / (1.0e-12 + static_cast< double >(object_->numberTimesDown())));
    760760  info.numIntInfeasDown = CoinMax(info.numIntInfeasDown, 0);
    761761  info.numObjInfeasDown = 0;
  • trunk/Cbc/src/CbcBranchLotsize.cpp

    r2465 r2467  
    792792CbcLotsizeBranchingObject::compareBranchingObject(const CbcBranchingObject *brObj, const bool replaceIfOverlap)
    793793{
    794   const CbcLotsizeBranchingObject *br = dynamic_cast<const CbcLotsizeBranchingObject *>(brObj);
     794  const CbcLotsizeBranchingObject *br = dynamic_cast< const CbcLotsizeBranchingObject * >(brObj);
    795795  assert(br);
    796796  double *thisBd = way_ == -1 ? down_ : up_;
  • trunk/Cbc/src/CbcBranchToFixLots.cpp

    r2465 r2467  
    129129  double tolerance = CoinMin(1.0e-8, integerTolerance);
    130130  // How many fixed are we aiming at
    131   int wantedFixed = static_cast<int>(static_cast<double>(numberIntegers) * fractionFixed_);
     131  int wantedFixed = static_cast< int >(static_cast< double >(numberIntegers) * fractionFixed_);
    132132  int nSort = 0;
    133133  int numberFixed = 0;
     
    380380  double tolerance = CoinMin(1.0e-8, integerTolerance);
    381381  // How many fixed are we aiming at
    382   int wantedFixed = static_cast<int>(static_cast<double>(numberIntegers) * fractionFixed_);
     382  int wantedFixed = static_cast< int >(static_cast< double >(numberIntegers) * fractionFixed_);
    383383  if (djTolerance_ < 1.0e10) {
    384384    int nSort = 0;
  • trunk/Cbc/src/CbcBranchingObject.hpp

    r2465 r2467  
    208208  virtual int compareOriginalObject(const CbcBranchingObject *brObj) const
    209209  {
    210     const CbcBranchingObject *br = dynamic_cast<const CbcBranchingObject *>(brObj);
     210    const CbcBranchingObject *br = dynamic_cast< const CbcBranchingObject * >(brObj);
    211211    return variable() - br->variable();
    212212  }
  • trunk/Cbc/src/CbcClique.cpp

    r2465 r2467  
    305305  const int *integer = model_->integerVariable();
    306306  //OsiSolverInterface * solver = model_->solver();
    307   CoinWarmStartBasis *basis = dynamic_cast<CoinWarmStartBasis *>(solver->getWarmStart());
     307  CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver->getWarmStart());
    308308  const double *solution = model_->testSolution();
    309309  const double *lower = solver->getColLower();
     
    613613int CbcCliqueBranchingObject::compareOriginalObject(const CbcBranchingObject *brObj) const
    614614{
    615   const CbcCliqueBranchingObject *br = dynamic_cast<const CbcCliqueBranchingObject *>(brObj);
     615  const CbcCliqueBranchingObject *br = dynamic_cast< const CbcCliqueBranchingObject * >(brObj);
    616616  assert(br);
    617617  return CbcCompareCliques(clique_, br->clique_);
     
    629629CbcCliqueBranchingObject::compareBranchingObject(const CbcBranchingObject *brObj, const bool /*replaceIfOverlap*/)
    630630{
    631   const CbcCliqueBranchingObject *br = dynamic_cast<const CbcCliqueBranchingObject *>(brObj);
     631  const CbcCliqueBranchingObject *br = dynamic_cast< const CbcCliqueBranchingObject * >(brObj);
    632632  assert(br);
    633633  unsigned int *thisMask = way_ < 0 ? upMask_ : downMask_;
    634634  const unsigned int *otherMask = br->way_ < 0 ? br->upMask_ : br->downMask_;
    635   const CoinUInt64 cl0 = (static_cast<CoinUInt64>(thisMask[0]) << 32) | thisMask[1];
    636   const CoinUInt64 cl1 = (static_cast<CoinUInt64>(otherMask[0]) << 32) | otherMask[1];
     635  const CoinUInt64 cl0 = (static_cast< CoinUInt64 >(thisMask[0]) << 32) | thisMask[1];
     636  const CoinUInt64 cl1 = (static_cast< CoinUInt64 >(otherMask[0]) << 32) | otherMask[1];
    637637  if (cl0 == cl1) {
    638638    return CbcRangeSame;
     
    650650  }
    651651  const CoinUInt64 cl_union = (cl0 | cl1);
    652   thisMask[0] = static_cast<unsigned int>(cl_union >> 32);
    653   thisMask[1] = static_cast<unsigned int>(cl_union & 0xffffffff);
     652  thisMask[0] = static_cast< unsigned int >(cl_union >> 32);
     653  thisMask[1] = static_cast< unsigned int >(cl_union & 0xffffffff);
    654654  return CbcRangeOverlap;
    655655}
     
    856856int CbcLongCliqueBranchingObject::compareOriginalObject(const CbcBranchingObject *brObj) const
    857857{
    858   const CbcLongCliqueBranchingObject *br = dynamic_cast<const CbcLongCliqueBranchingObject *>(brObj);
     858  const CbcLongCliqueBranchingObject *br = dynamic_cast< const CbcLongCliqueBranchingObject * >(brObj);
    859859  assert(br);
    860860  return CbcCompareCliques(clique_, br->clique_);
     
    872872CbcLongCliqueBranchingObject::compareBranchingObject(const CbcBranchingObject *brObj, const bool /*replaceIfOverlap*/)
    873873{
    874   const CbcLongCliqueBranchingObject *br = dynamic_cast<const CbcLongCliqueBranchingObject *>(brObj);
     874  const CbcLongCliqueBranchingObject *br = dynamic_cast< const CbcLongCliqueBranchingObject * >(brObj);
    875875  assert(br);
    876876  const int numberMembers = clique_->numberMembers();
  • trunk/Cbc/src/CbcCompareDefault.cpp

    r2465 r2467  
    193193    double target = (1.0 - THRESH2) * bestPossible_ + THRESH2 * cutoff_;
    194194    double weight;
    195     weight = (target - x->objectiveValue()) / static_cast<double>(x->numberUnsatisfied());
     195    weight = (target - x->objectiveValue()) / static_cast< double >(x->numberUnsatisfied());
    196196    double testX = -weight;
    197     weight = (target - y->objectiveValue()) / static_cast<double>(y->numberUnsatisfied());
     197    weight = (target - y->objectiveValue()) / static_cast< double >(y->numberUnsatisfied());
    198198    double testY = -weight;
    199199#elif TRY_THIS == 2
     
    229229    return (false); // solution was got by rounding
    230230  // set to get close to this solution
    231   double costPerInteger = (model->getObjValue() - objectiveAtContinuous) / static_cast<double>(numberInfeasibilitiesAtContinuous);
     231  double costPerInteger = (model->getObjValue() - objectiveAtContinuous) / static_cast< double >(numberInfeasibilitiesAtContinuous);
    232232  weight_ = 0.95 * costPerInteger;
    233233  saveWeight_ = 0.95 * weight_;
  • trunk/Cbc/src/CbcCutGenerator.cpp

    r2465 r2467  
    198198    depth = 0;
    199199  int howOften = whenCutGenerator_;
    200   if (dynamic_cast<CglProbing *>(generator_)) {
     200  if (dynamic_cast< CglProbing * >(generator_)) {
    201201    if (howOften == -100 && model_->doCutsNow(3)) {
    202202      howOften = 1; // do anyway
     
    258258    {
    259259      OsiClpSolverInterface *clpSolver
    260         = dynamic_cast<OsiClpSolverInterface *>(solver);
     260        = dynamic_cast< OsiClpSolverInterface * >(solver);
    261261      if (clpSolver)
    262262        randomNumberGenerator = clpSolver->getModelPtr()->randomNumberGenerator();
     
    303303    // above had &&!model_->parentModel()&&depth<2)
    304304    incrementNumberTimesEntered();
    305     CglProbing *generator = dynamic_cast<CglProbing *>(generator_);
     305    CglProbing *generator = dynamic_cast< CglProbing * >(generator_);
    306306    //if (!depth&&!pass)
    307307    //printf("Cut generator %s when %d\n",generatorName_,whenCutGenerator_);
     
    360360            2099999
    361361          };
    362           int n = static_cast<int>(sizeof(test) / sizeof(int));
     362          int n = static_cast< int >(sizeof(test) / sizeof(int));
    363363          int saveStack = generator->getMaxLook();
    364364          int saveNumber = generator->getMaxProbe();
     
    570570#ifdef COIN_HAS_CLP
    571571        OsiClpSolverInterface *clpSolver
    572           = dynamic_cast<OsiClpSolverInterface *>(solver);
     572          = dynamic_cast< OsiClpSolverInterface * >(solver);
    573573        if (clpSolver) {
    574574          clpSolver->setLastAlgorithm(2);
     
    588588      int numberObjects = model_->numberObjects();
    589589      for (int i = 0; i < numberObjects; i++) {
    590         CbcSimpleIntegerDynamicPseudoCost *obj1 = dynamic_cast<CbcSimpleIntegerDynamicPseudoCost *>(model_->modifiableObject(i));
     590        CbcSimpleIntegerDynamicPseudoCost *obj1 = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(model_->modifiableObject(i));
    591591        if (obj1) {
    592592          int iColumn = obj1->columnNumber();
     
    12821282    // leave Probing every SCANCUTS_PROBING
    12831283    howOften = howOften % 1000000;
    1284     CglProbing *generator = dynamic_cast<CglProbing *>(generator_);
     1284    CglProbing *generator = dynamic_cast< CglProbing * >(generator_);
    12851285
    12861286    if (generator && howOften > SCANCUTS_PROBING)
  • trunk/Cbc/src/CbcEventHandler.hpp

    r2465 r2467  
    137137  /*! \brief Data type for event/action pairs */
    138138
    139   typedef std::map<CbcEvent, CbcAction> eaMapPair;
     139  typedef std::map< CbcEvent, CbcAction > eaMapPair;
    140140
    141141  /*! \name Event Processing */
  • trunk/Cbc/src/CbcFathomDynamicProgramming.cpp

    r2465 r2467  
    199199  double check = COIN_INT_MAX;
    200200  for (i = 0; i < numberRows; i++) {
    201     int n = static_cast<int>(floor(rhs[i] + 0.5));
     201    int n = static_cast< int >(floor(rhs[i] + 0.5));
    202202    if (n) {
    203203      n++; // allow for 0,1... n
     
    228228    size_ = COIN_INT_MAX;
    229229  else
    230     size_ = static_cast<int>(size);
     230    size_ = static_cast< int >(size);
    231231
    232232  int n01 = 0;
     
    274274    int kBit = 0;
    275275    for (i = 0; i < numberRows; i++) {
    276       int n = static_cast<int>(floor(rhs[i] + 0.5));
     276      int n = static_cast< int >(floor(rhs[i] + 0.5));
    277277      if (n) {
    278278        lookup_[i] = numberActive;
     
    395395        int newRow = lookup_[i];
    396396        if (newRow >= 0) {
    397           int gap = static_cast<int>(rowUpper[i] - CoinMax(0.0, rowLower[i]));
     397          int gap = static_cast< int >(rowUpper[i] - CoinMax(0.0, rowLower[i]));
    398398          lower2[newRow] = rhs_[newRow] - gap;
    399399          int numberBits = numberBits_[newRow];
     
    483483      double cost = direction * objective[i];
    484484      fixedObj += lowerValue * cost;
    485       int gap = static_cast<int>(upper[i] - lowerValue);
     485      int gap = static_cast< int >(upper[i] - lowerValue);
    486486      CoinBigIndex start = columnStart[i];
    487487      tryColumn(columnLength[i], row + start, element + start, cost, gap);
     
    521521        int newRow = lookup_[i];
    522522        if (newRow >= 0) {
    523           int gap = static_cast<int>(rowUpper[i] - CoinMax(0.0, rowLower[i]));
     523          int gap = static_cast< int >(rowUpper[i] - CoinMax(0.0, rowLower[i]));
    524524          lower[newRow] = rhs_[newRow] - gap;
    525525          int numberBits = numberBits_[newRow];
     
    574574                int iRow = row[j];
    575575                double value = element[j];
    576                 int iValue = static_cast<int>(value);
     576                int iValue = static_cast< int >(value);
    577577                if (iValue != indices_[iRow]) {
    578578                  good = false;
     
    655655      int iRow = rows[j];
    656656      double value = coefficients[j];
    657       int iValue = static_cast<int>(value);
     657      int iValue = static_cast< int >(value);
    658658      int newRow = lookup_[iRow];
    659659      if (newRow < 0 || iValue > rhs_[newRow]) {
  • trunk/Cbc/src/CbcFollowOn.cpp

    r2465 r2467  
    7373        }
    7474        if (good)
    75           rhs_[i] = static_cast<int>(value);
     75          rhs_[i] = static_cast< int >(value);
    7676      }
    7777    }
     
    163163            numberUnsatisfied++;
    164164        } else {
    165           rhsValue -= static_cast<int>(value * floor(solValue + 0.5));
     165          rhsValue -= static_cast< int >(value * floor(solValue + 0.5));
    166166        }
    167167      }
     
    509509{
    510510#ifdef JJF_ZERO //ndef NDEBUG
    511   const CbcFixingBranchingObject *br = dynamic_cast<const CbcFixingBranchingObject *>(brObj);
     511  const CbcFixingBranchingObject *br = dynamic_cast< const CbcFixingBranchingObject * >(brObj);
    512512  assert(br);
    513513#endif
  • trunk/Cbc/src/CbcFullNodeInfo.cpp

    r2465 r2467  
    7373  }
    7474
    75   basis_ = dynamic_cast<CoinWarmStartBasis *>(solver->getWarmStart());
     75  basis_ = dynamic_cast< CoinWarmStartBasis * >(solver->getWarmStart());
    7676}
    7777
     
    7979  : CbcNodeInfo(rhs)
    8080{
    81   basis_ = dynamic_cast<CoinWarmStartBasis *>(rhs.basis_->clone());
     81  basis_ = dynamic_cast< CoinWarmStartBasis * >(rhs.basis_->clone());
    8282  numberIntegers_ = rhs.numberIntegers_;
    8383  lower_ = NULL;
     
    145145    delete basis;
    146146    if (basis_) {
    147       basis = dynamic_cast<CoinWarmStartBasis *>(basis_->clone());
     147      basis = dynamic_cast< CoinWarmStartBasis * >(basis_->clone());
    148148      basis->resize(numberRows, numberColumns);
    149149#ifdef CBC_CHECK_BASIS
     
    189189CbcFullNodeInfo::buildRowBasis(CoinWarmStartBasis &basis) const
    190190{
    191   const unsigned int *saved = reinterpret_cast<const unsigned int *>(basis_->getArtificialStatus());
    192   unsigned int *now = reinterpret_cast<unsigned int *>(basis.getArtificialStatus());
     191  const unsigned int *saved = reinterpret_cast< const unsigned int * >(basis_->getArtificialStatus());
     192  unsigned int *now = reinterpret_cast< unsigned int * >(basis.getArtificialStatus());
    193193  int number = basis_->getNumArtificial() >> 4;
    194194  ;
  • trunk/Cbc/src/CbcGenBaB.cpp

    r2465 r2467  
    306306  if (action != CbcGenCtlBlk::CGOff) {
    307307    if (action == CbcGenCtlBlk::CGForceBut) {
    308       CglProbing *probingGen = dynamic_cast<CglProbing *>(gen);
     308      CglProbing *probingGen = dynamic_cast< CglProbing * >(gen);
    309309      probingGen->setRowCuts(-3);
    310310    }
     
    484484{
    485485  assert(param != 0);
    486   CbcGenParam *genParam = dynamic_cast<CbcGenParam *>(param);
     486  CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(param);
    487487  assert(genParam != 0);
    488488  CbcGenCtlBlk *ctlBlk = genParam->obj();
  • trunk/Cbc/src/CbcGenCbcParamUtils.cpp

    r2465 r2467  
    219219    */
    220220  for (i = first; i <= last; i++) {
    221     CbcCbcParam *cbcParam = dynamic_cast<CbcCbcParam *>(paramVec[i]);
     221    CbcCbcParam *cbcParam = dynamic_cast< CbcCbcParam * >(paramVec[i]);
    222222    assert(cbcParam != 0);
    223223    cbcParam->setObj(obj);
     
    266266  assert(param != 0);
    267267
    268   CbcCbcParam *cbcParam = dynamic_cast<CbcCbcParam *>(param);
     268  CbcCbcParam *cbcParam = dynamic_cast< CbcCbcParam * >(param);
    269269  assert(cbcParam != 0);
    270270
     
    335335  assert(param != 0);
    336336
    337   CbcCbcParam *cbcParam = dynamic_cast<CbcCbcParam *>(param);
     337  CbcCbcParam *cbcParam = dynamic_cast< CbcCbcParam * >(param);
    338338  assert(cbcParam != 0);
    339339
  • trunk/Cbc/src/CbcGenCtlBlk.cpp

    r2465 r2467  
    260260    probing_.proto_->setRowCuts(probing_.rowCuts_);
    261261  }
    262   gen = dynamic_cast<CglCutGenerator *>(probing_.proto_);
     262  gen = dynamic_cast< CglCutGenerator * >(probing_.proto_);
    263263
    264264  return (probing_.action_);
     
    274274    clique_.proto_->setMinViolation(clique_.minViolation_);
    275275  }
    276   gen = dynamic_cast<CglCutGenerator *>(clique_.proto_);
     276  gen = dynamic_cast< CglCutGenerator * >(clique_.proto_);
    277277
    278278  return (clique_.action_);
     
    285285    flow_.proto_ = new CglFlowCover();
    286286  }
    287   gen = dynamic_cast<CglCutGenerator *>(flow_.proto_);
     287  gen = dynamic_cast< CglCutGenerator * >(flow_.proto_);
    288288
    289289  return (flow_.action_);
     
    298298    gomory_.proto_->setLimit(gomory_.limit_);
    299299  }
    300   gen = dynamic_cast<CglCutGenerator *>(gomory_.proto_);
     300  gen = dynamic_cast< CglCutGenerator * >(gomory_.proto_);
    301301
    302302  return (gomory_.action_);
     
    309309    knapsack_.proto_ = new CglKnapsackCover();
    310310  }
    311   gen = dynamic_cast<CglCutGenerator *>(knapsack_.proto_);
     311  gen = dynamic_cast< CglCutGenerator * >(knapsack_.proto_);
    312312
    313313  return (knapsack_.action_);
     
    320320    mir_.proto_ = new CglMixedIntegerRounding2();
    321321  }
    322   gen = dynamic_cast<CglCutGenerator *>(mir_.proto_);
     322  gen = dynamic_cast< CglCutGenerator * >(mir_.proto_);
    323323
    324324  return (mir_.action_);
     
    331331    redSplit_.proto_ = new CglRedSplit();
    332332  }
    333   gen = dynamic_cast<CglCutGenerator *>(redSplit_.proto_);
     333  gen = dynamic_cast< CglCutGenerator * >(redSplit_.proto_);
    334334
    335335  return (redSplit_.action_);
     
    343343    twomir_.proto_->setMaxElements(twomir_.maxElements_);
    344344  }
    345   gen = dynamic_cast<CglCutGenerator *>(twomir_.proto_);
     345  gen = dynamic_cast< CglCutGenerator * >(twomir_.proto_);
    346346
    347347  return (twomir_.action_);
     
    360360    fpump_.proto_->setMaximumPasses(fpump_.iters_);
    361361  }
    362   gen = dynamic_cast<CbcHeuristic *>(fpump_.proto_);
     362  gen = dynamic_cast< CbcHeuristic * >(fpump_.proto_);
    363363
    364364  return (fpump_.action_);
     
    377377    combine_.proto_->setSearchType(combine_.trySwap_);
    378378  }
    379   gen = dynamic_cast<CbcHeuristic *>(combine_.proto_);
     379  gen = dynamic_cast< CbcHeuristic * >(combine_.proto_);
    380380
    381381  return (combine_.action_);
     
    393393    greedyCover_.proto_ = new CbcHeuristicGreedyCover(*model);
    394394  }
    395   gen = dynamic_cast<CbcHeuristic *>(greedyCover_.proto_);
     395  gen = dynamic_cast< CbcHeuristic * >(greedyCover_.proto_);
    396396
    397397  return (greedyCover_.action_);
     
    409409    greedyEquality_.proto_ = new CbcHeuristicGreedyEquality(*model);
    410410  }
    411   gen = dynamic_cast<CbcHeuristic *>(greedyEquality_.proto_);
     411  gen = dynamic_cast< CbcHeuristic * >(greedyEquality_.proto_);
    412412
    413413  return (greedyEquality_.action_);
     
    425425    rounding_.proto_ = new CbcRounding(*model);
    426426  }
    427   gen = dynamic_cast<CbcHeuristic *>(rounding_.proto_);
     427  gen = dynamic_cast< CbcHeuristic * >(rounding_.proto_);
    428428
    429429  return (rounding_.action_);
  • trunk/Cbc/src/CbcGenCtlBlk.hpp

    r2465 r2467  
    684684  /*! \brief Record of parameters changed by user command */
    685685
    686   std::vector<bool> setByUser_;
     686  std::vector< bool > setByUser_;
    687687
    688688  /*! \brief False if the user has made nontrivial modifications to the
  • trunk/Cbc/src/CbcGenOsiParamUtils.cpp

    r2465 r2467  
    158158    */
    159159  for (i = first; i <= last; i++) {
    160     CbcOsiParam *osiParam = dynamic_cast<CbcOsiParam *>(paramVec[i]);
     160    CbcOsiParam *osiParam = dynamic_cast< CbcOsiParam * >(paramVec[i]);
    161161    assert(osiParam != 0);
    162162    osiParam->setObj(obj);
     
    215215  assert(param != 0);
    216216
    217   CbcOsiParam *osiParam = dynamic_cast<CbcOsiParam *>(param);
     217  CbcOsiParam *osiParam = dynamic_cast< CbcOsiParam * >(param);
    218218  assert(osiParam != 0);
    219219
     
    272272  assert(param != 0);
    273273
    274   CbcOsiParam *osiParam = dynamic_cast<CbcOsiParam *>(param);
     274  CbcOsiParam *osiParam = dynamic_cast< CbcOsiParam * >(param);
    275275  assert(osiParam != 0);
    276276
     
    335335{
    336336  assert(param != 0);
    337   CbcOsiParam *osiParam = dynamic_cast<CbcOsiParam *>(param);
     337  CbcOsiParam *osiParam = dynamic_cast< CbcOsiParam * >(param);
    338338  assert(osiParam != 0);
    339339  OsiSolverInterface *osi = osiParam->obj();
     
    400400{
    401401  assert(param != 0);
    402   CbcOsiParam *osiParam = dynamic_cast<CbcOsiParam *>(param);
     402  CbcOsiParam *osiParam = dynamic_cast< CbcOsiParam * >(param);
    403403  assert(osiParam != 0);
    404404  OsiSolverInterface *osi = osiParam->obj();
     
    459459{
    460460  assert(param != 0);
    461   CbcOsiParam *osiParam = dynamic_cast<CbcOsiParam *>(param);
     461  CbcOsiParam *osiParam = dynamic_cast< CbcOsiParam * >(param);
    462462  assert(osiParam != 0);
    463463  OsiSolverInterface *osi = osiParam->obj();
  • trunk/Cbc/src/CbcGenParamUtils.cpp

    r2465 r2467  
    600600    */
    601601  for (i = first; i <= last; i++) {
    602     CbcGenParam *genParam = dynamic_cast<CbcGenParam *>(paramVec[i]);
     602    CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(paramVec[i]);
    603603    assert(genParam != 0);
    604604    genParam->setObj(ctlBlk);
     
    620620  assert(param != 0);
    621621
    622   CbcGenParam *genParam = dynamic_cast<CbcGenParam *>(param);
     622  CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(param);
    623623  assert(genParam != 0);
    624624
     
    679679{
    680680  assert(param != 0);
    681   CbcGenParam *genParam = dynamic_cast<CbcGenParam *>(param);
     681  CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(param);
    682682  assert(genParam != 0);
    683683  CbcGenCtlBlk *ctlBlk = genParam->obj();
     
    705705{
    706706  assert(param != 0);
    707   CbcGenParam *genParam = dynamic_cast<CbcGenParam *>(param);
     707  CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(param);
    708708  assert(genParam != 0);
    709709  CbcGenCtlBlk *ctlBlk = genParam->obj();
     
    748748{
    749749  assert(param != 0);
    750   CbcGenParam *genParam = dynamic_cast<CbcGenParam *>(param);
     750  CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(param);
    751751  assert(genParam != 0);
    752752  CbcGenCtlBlk *ctlBlk = genParam->obj();
     
    785785{
    786786  assert(param != 0);
    787   CbcGenParam *genParam = dynamic_cast<CbcGenParam *>(param);
     787  CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(param);
    788788  assert(genParam != 0);
    789789  CbcGenCtlBlk *ctlBlk = genParam->obj();
     
    834834{
    835835  assert(param != 0);
    836   CbcGenParam *genParam = dynamic_cast<CbcGenParam *>(param);
     836  CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(param);
    837837  assert(genParam != 0);
    838838  CbcGenCtlBlk *ctlBlk = genParam->obj();
     
    927927{
    928928  assert(param != 0);
    929   CbcGenParam *genParam = dynamic_cast<CbcGenParam *>(param);
     929  CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(param);
    930930  assert(genParam != 0);
    931931  CbcGenCtlBlk *ctlBlk = genParam->obj();
     
    967967{
    968968  assert(param != 0);
    969   CbcGenParam *genParam = dynamic_cast<CbcGenParam *>(param);
     969  CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(param);
    970970  assert(genParam != 0);
    971971  CbcGenCtlBlk *ctlBlk = genParam->obj();
     
    11551155{
    11561156  assert(param != 0);
    1157   CbcGenParam *genParam = dynamic_cast<CbcGenParam *>(param);
     1157  CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(param);
    11581158  assert(genParam != 0);
    11591159  CbcGenCtlBlk *ctlBlk = genParam->obj();
     
    12441244{
    12451245  assert(param != 0);
    1246   CbcGenParam *genParam = dynamic_cast<CbcGenParam *>(param);
     1246  CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(param);
    12471247  assert(genParam != 0);
    12481248  CbcGenCtlBlk *ctlBlk = genParam->obj();
  • trunk/Cbc/src/CbcGenSolution.cpp

    r2465 r2467  
    208208{
    209209  assert(param != 0);
    210   CbcGenParam *genParam = dynamic_cast<CbcGenParam *>(param);
     210  CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(param);
    211211  assert(genParam != 0);
    212212  CbcGenCtlBlk *ctlBlk = genParam->obj();
     
    335335          value = ceil(value - .5);
    336336        }
    337         int ivalue = static_cast<int>(value);
     337        int ivalue = static_cast< int >(value);
    338338        fprintf(fp, "%d.0", ivalue);
    339339        if (++k == 10) {
     
    509509{
    510510  assert(param != 0);
    511   CbcGenParam *genParam = dynamic_cast<CbcGenParam *>(param);
     511  CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(param);
    512512  assert(genParam != 0);
    513513  CbcGenCtlBlk *ctlBlk = genParam->obj();
  • trunk/Cbc/src/CbcGenSolvers.cpp

    r2465 r2467  
    101101  Data types for a vector of OsiSolverInterface objects.
    102102*/
    103 typedef std::map<std::string, OsiSolverInterface *> solverMap_t;
     103typedef std::map< std::string, OsiSolverInterface * > solverMap_t;
    104104typedef solverMap_t::const_iterator solverMapIter_t;
    105105
     
    198198{
    199199  assert(param != 0);
    200   CbcGenParam *genParam = dynamic_cast<CbcGenParam *>(param);
     200  CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(param);
    201201  assert(genParam != 0);
    202202  CbcGenCtlBlk *ctlBlk = genParam->obj();
  • trunk/Cbc/src/CbcGeneralDepth.cpp

    r2465 r2467  
    159159    OsiSolverInterface *solver = model_->solver();
    160160    OsiClpSolverInterface *clpSolver
    161       = dynamic_cast<OsiClpSolverInterface *>(solver);
     161      = dynamic_cast< OsiClpSolverInterface * >(solver);
    162162    if (clpSolver) {
    163163      if ((model_->moreSpecialOptions() & 33554432) == 0) {
     
    170170        int nBranches = model_->getIntParam(CbcModel::CbcNumberBranches);
    171171        if (nBranches) {
    172           double average = model_->getDblParam(CbcModel::CbcSumChange) / static_cast<double>(nBranches);
     172          double average = model_->getDblParam(CbcModel::CbcSumChange) / static_cast< double >(nBranches);
    173173          info->smallChange_ = CoinMax(average * 1.0e-5, model_->getDblParam(CbcModel::CbcSmallestChange));
    174174          info->smallChange_ = CoinMax(info->smallChange_, 1.0e-8);
     
    220220        for (int i = 0; i < numberIntegers; i++) {
    221221#ifndef NDEBUG
    222           CbcSimpleIntegerDynamicPseudoCost *obj = dynamic_cast<CbcSimpleIntegerDynamicPseudoCost *>(objects[i]);
     222          CbcSimpleIntegerDynamicPseudoCost *obj = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(objects[i]);
    223223          assert(obj && obj->columnNumber() == integerVariable[i]);
    224224#else
    225           CbcSimpleIntegerDynamicPseudoCost *obj = static_cast<CbcSimpleIntegerDynamicPseudoCost *>(objects[i]);
     225          CbcSimpleIntegerDynamicPseudoCost *obj = static_cast< CbcSimpleIntegerDynamicPseudoCost * >(objects[i]);
    226226#endif
    227227          if (info->numberUp_[i] > 0) {
     
    250250        CbcHeuristicDive *dive = NULL;
    251251        for (int i = 0; i < model_->numberHeuristics(); i++) {
    252           CbcHeuristicDive *possible = dynamic_cast<CbcHeuristicDive *>(model_->heuristic(i));
     252          CbcHeuristicDive *possible = dynamic_cast< CbcHeuristicDive * >(model_->heuristic(i));
    253253          if (possible && possible->maxSimplexIterations() == COIN_INT_MAX) {
    254254            // if more than one then rotate later?
     
    281281#endif
    282282        //delete [] nodes;
    283         model_->setTemporaryPointer(reinterpret_cast<void *>(nodes));
     283        model_->setTemporaryPointer(reinterpret_cast< void * >(nodes));
    284284        // end try diving
    285285      }
     
    338338  //OsiSolverInterface * solver = model_->solver();
    339339  OsiClpSolverInterface *clpSolver
    340     = dynamic_cast<OsiClpSolverInterface *>(solver);
     340    = dynamic_cast< OsiClpSolverInterface * >(solver);
    341341  assert(clpSolver);
    342342  ClpSimplex *simplex = clpSolver->getModelPtr();
     
    422422  } else {
    423423    // from diving
    424     CbcSubProblem **nodes = reinterpret_cast<CbcSubProblem **>(model_->temporaryPointer());
     424    CbcSubProblem **nodes = reinterpret_cast< CbcSubProblem ** >(model_->temporaryPointer());
    425425    assert(nodes);
    426426    int adjustDepth = info->depth_;
     
    549549        thisProb->apply(solver);
    550550        OsiClpSolverInterface *clpSolver
    551           = dynamic_cast<OsiClpSolverInterface *>(solver);
     551          = dynamic_cast< OsiClpSolverInterface * >(solver);
    552552        assert(clpSolver);
    553553        // Move status to basis
  • trunk/Cbc/src/CbcGeneric.cpp

    r2465 r2467  
    9090
    9191{
    92   CbcGenParam *genParam = dynamic_cast<CbcGenParam *>(param);
    93   CbcCbcParam *cbcParam = dynamic_cast<CbcCbcParam *>(param);
    94   CbcOsiParam *osiParam = dynamic_cast<CbcOsiParam *>(param);
     92  CbcGenParam *genParam = dynamic_cast< CbcGenParam * >(param);
     93  CbcCbcParam *cbcParam = dynamic_cast< CbcCbcParam * >(param);
     94  CbcOsiParam *osiParam = dynamic_cast< CbcOsiParam * >(param);
    9595  int code = -1;
    9696
  • trunk/Cbc/src/CbcHeuristic.cpp

    r2465 r2467  
    4949void CbcHeuristicNodeList::gutsOfDelete()
    5050{
    51   for (int i = (static_cast<int>(nodes_.size())) - 1; i >= 0; --i) {
     51  for (int i = (static_cast< int >(nodes_.size())) - 1; i >= 0; --i) {
    5252    delete nodes_[i];
    5353  }
     
    206206    printf("nodeinfo: node %i\n", nodeInfo->nodeNumber());
    207207    {
    208       const CbcIntegerBranchingObject *brPrint = dynamic_cast<const CbcIntegerBranchingObject *>(nodeInfo->parentBranch());
     208      const CbcIntegerBranchingObject *brPrint = dynamic_cast< const CbcIntegerBranchingObject * >(nodeInfo->parentBranch());
    209209      if (!brPrint) {
    210210        printf("    parentBranch: NULL\n");
     
    215215        int way = brPrint->way();
    216216        printf("   parentBranch: var %i downBd [%i,%i] upBd [%i,%i] way %i\n",
    217           variable, static_cast<int>(downBounds[0]), static_cast<int>(downBounds[1]),
    218           static_cast<int>(upBounds[0]), static_cast<int>(upBounds[1]), way);
     217          variable, static_cast< int >(downBounds[0]), static_cast< int >(downBounds[1]),
     218          static_cast< int >(upBounds[0]), static_cast< int >(upBounds[1]), way);
    219219      }
    220220    }
     
    225225        node->nodeNumber(), node->depth(), node->onTree(), node->active());
    226226      const OsiBranchingObject *osibr = nodeInfo->owner()->branchingObject();
    227       const CbcBranchingObject *cbcbr = dynamic_cast<const CbcBranchingObject *>(osibr);
    228       const CbcIntegerBranchingObject *brPrint = dynamic_cast<const CbcIntegerBranchingObject *>(cbcbr);
     227      const CbcBranchingObject *cbcbr = dynamic_cast< const CbcBranchingObject * >(osibr);
     228      const CbcIntegerBranchingObject *brPrint = dynamic_cast< const CbcIntegerBranchingObject * >(cbcbr);
    229229      if (!brPrint) {
    230230        printf("        ownerBranch: NULL\n");
     
    235235        int way = brPrint->way();
    236236        printf("        ownerbranch: var %i downBd [%i,%i] upBd [%i,%i] way %i\n",
    237           variable, static_cast<int>(downBounds[0]), static_cast<int>(downBounds[1]),
    238           static_cast<int>(upBounds[0]), static_cast<int>(upBounds[1]), way);
     237          variable, static_cast< int >(downBounds[0]), static_cast< int >(downBounds[1]),
     238          static_cast< int >(upBounds[0]), static_cast< int >(upBounds[1]), way);
    239239      }
    240240    }
     
    401401            int old = howOften_;
    402402#endif
    403             howOften_ = CoinMin(CoinMax(static_cast<int>(howOften_ * 1.1), howOften_ + 1), 1000000);
     403            howOften_ = CoinMin(CoinMax(static_cast< int >(howOften_ * 1.1), howOften_ + 1), 1000000);
    404404#ifdef COIN_DEVELOP
    405405            printf("Howoften changed from %d to %d for %s\n",
     
    451451    while (time >= COIN_INT_MAX)
    452452      time *= 0.5;
    453     value = static_cast<int>(time);
     453    value = static_cast< int >(time);
    454454    char printArray[100];
    455455    sprintf(printArray, "using time of day seed was changed from %d to %d",
     
    544544#ifdef COIN_HAS_CLP
    545545  OsiClpSolverInterface *clpSolver
    546     = dynamic_cast<OsiClpSolverInterface *>(solver);
     546    = dynamic_cast< OsiClpSolverInterface * >(solver);
    547547#endif
    548548  if ((type & 2) != 0) {
     
    552552      for (int i = 0; i < n; i++) {
    553553        const OsiObject *obj = model_->object(i);
    554         const CbcSimpleInteger *thisOne = dynamic_cast<const CbcSimpleInteger *>(obj);
     554        const CbcSimpleInteger *thisOne = dynamic_cast< const CbcSimpleInteger * >(obj);
    555555        if (thisOne) {
    556556          int iColumn = thisOne->columnNumber();
     
    564564      for (int i = 0; i < n; i++) {
    565565        const OsiObject *obj = model_->object(i);
    566         const CbcSimpleInteger *thisOne = dynamic_cast<const CbcSimpleInteger *>(obj);
     566        const CbcSimpleInteger *thisOne = dynamic_cast< const CbcSimpleInteger * >(obj);
    567567        if (thisOne) {
    568568          int iColumn = thisOne->columnNumber();
     
    719719  }
    720720#ifdef COIN_HAS_CLP
    721   OsiClpSolverInterface *clpSolver = dynamic_cast<OsiClpSolverInterface *>(solver);
     721  OsiClpSolverInterface *clpSolver = dynamic_cast< OsiClpSolverInterface * >(solver);
    722722  if (clpSolver && (clpSolver->specialOptions() & 65536) == 0) {
    723723    // go faster stripes
     
    920920      const OsiRowCutDebugger *debugger = solver->getRowCutDebugger();
    921921      if (debugger) {
    922         process.setApplicationData(const_cast<double *>(debugger->optimalSolution()));
     922        process.setApplicationData(const_cast< double * >(debugger->optimalSolution()));
    923923      }
    924924    }
    925925#endif
    926926#ifdef COIN_HAS_CLP
    927     OsiClpSolverInterface *clpSolver = dynamic_cast<OsiClpSolverInterface *>(solver);
     927    OsiClpSolverInterface *clpSolver = dynamic_cast< OsiClpSolverInterface * >(solver);
    928928    // See if SOS
    929929    if (clpSolver && clpSolver->numberSOS()) {
     
    939939        int type = setInfo[i].setType();
    940940        int n = setInfo[i].numberEntries();
    941         sosType[i] = static_cast<char>(type);
     941        sosType[i] = static_cast< char >(type);
    942942        nTotal += n;
    943943        sosStart[i + 1] = nTotal;
     
    953953          int k = which[j];
    954954          sosIndices[j + base] = k;
    955           sosReference[j + base] = weights ? weights[j] : static_cast<double>(j);
     955          sosReference[j + base] = weights ? weights[j] : static_cast< double >(j);
    956956        }
    957957      }
     
    10231023        // redo SOS
    10241024        OsiClpSolverInterface *clpSolver
    1025           = dynamic_cast<OsiClpSolverInterface *>(model.solver());
     1025          = dynamic_cast< OsiClpSolverInterface * >(model.solver());
    10261026        if (clpSolver && clpSolver->numberSOS()) {
    10271027          int numberColumns = clpSolver->getNumCols();
    10281028          const int *originalColumns = process.originalColumns();
    1029           CoinSet *setInfo = const_cast<CoinSet *>(clpSolver->setInfo());
     1029          CoinSet *setInfo = const_cast< CoinSet * >(clpSolver->setInfo());
    10301030          int numberSOS = clpSolver->numberSOS();
    10311031          for (int iSOS = 0; iSOS < numberSOS; iSOS++) {
     
    10711071            double fraction = fractionSmall_ - floor(fractionSmall_);
    10721072            if (ratio > fraction) {
    1073               int type = static_cast<int>(floor(fractionSmall_ * 0.1));
    1074               int over = static_cast<int>(ceil(ratio - fraction));
     1073              int type = static_cast< int >(floor(fractionSmall_ * 0.1));
     1074              int over = static_cast< int >(ceil(ratio - fraction));
    10751075              int maxNodes[] = { -1, 0, 5, 10 };
    10761076              if (type > over)
     
    11311131          for (int i = 0; i < model.numberCutGenerators(); i++) {
    11321132            CbcCutGenerator *generator = model.cutGenerator(i);
    1133             CglGomory *gomory = dynamic_cast<CglGomory *>(generator->generator());
     1133            CglGomory *gomory = dynamic_cast< CglGomory * >(generator->generator());
    11341134            if (gomory && gomory->originalSolver())
    11351135              gomory->passInOriginalSolver(model.solver());
     
    11991199          CbcHeuristicFPump *fpump = NULL;
    12001200          for (int i = 0; i < model.numberHeuristics(); i++) {
    1201             CbcHeuristicFPump *pump = dynamic_cast<CbcHeuristicFPump *>(model.heuristic(i));
     1201            CbcHeuristicFPump *pump = dynamic_cast< CbcHeuristicFPump * >(model.heuristic(i));
    12021202            if (pump) {
    12031203              fpump = pump;
     
    12811281        for (int i = 0; i < model.numberHeuristics(); i++) {
    12821282          // reset lastNode
    1283           CbcHeuristicRINS *rins = dynamic_cast<CbcHeuristicRINS *>(model.heuristic(i));
     1283          CbcHeuristicRINS *rins = dynamic_cast< CbcHeuristicRINS * >(model.heuristic(i));
    12841284          if (rins) {
    12851285            rins->setLastNode(-1000);
     
    14541454                generator->numberCutsActive(),
    14551455                generator->timeInCutGenerator());
    1456               CglStored *stored = dynamic_cast<CglStored *>(generator->generator());
     1456              CglStored *stored = dynamic_cast< CglStored * >(generator->generator());
    14571457              if (stored && !generator->numberCutsInTotal())
    14581458                continue;
    14591459#ifndef CLP_INVESTIGATE
    1460               CglImplication *implication = dynamic_cast<CglImplication *>(generator->generator());
     1460              CglImplication *implication = dynamic_cast< CglImplication * >(generator->generator());
    14611461              if (implication)
    14621462                continue;
     
    14831483            // post process
    14841484#ifdef COIN_HAS_CLP
    1485           OsiClpSolverInterface *clpSolver = dynamic_cast<OsiClpSolverInterface *>(model.solver());
     1485          OsiClpSolverInterface *clpSolver = dynamic_cast< OsiClpSolverInterface * >(model.solver());
    14861486          if (clpSolver) {
    14871487            ClpSimplex *lpSolver = clpSolver->getModelPtr();
     
    16821682  while (nodeInfo->parentBranch() != NULL) {
    16831683    const OsiBranchingObject *br = nodeInfo->parentBranch();
    1684     const CbcBranchingObject *cbcbr = dynamic_cast<const CbcBranchingObject *>(br);
     1684    const CbcBranchingObject *cbcbr = dynamic_cast< const CbcBranchingObject * >(br);
    16851685    if (!cbcbr) {
    16861686      throw CoinError("CbcHeuristicNode can be used only with CbcBranchingObjects.\n",
     
    17601760    const CbcBranchingObject *br1 = node->brObj_[j];
    17611761#ifdef PRINT_DEBUG
    1762     const CbcIntegerBranchingObject *brPrint0 = dynamic_cast<const CbcIntegerBranchingObject *>(br0);
     1762    const CbcIntegerBranchingObject *brPrint0 = dynamic_cast< const CbcIntegerBranchingObject * >(br0);
    17631763    const double *downBounds = brPrint0->downBounds();
    17641764    const double *upBounds = brPrint0->upBounds();
     
    17661766    int way = brPrint0->way();
    17671767    printf("   br0: var %i downBd [%i,%i] upBd [%i,%i] way %i\n",
    1768       variable, static_cast<int>(downBounds[0]), static_cast<int>(downBounds[1]),
    1769       static_cast<int>(upBounds[0]), static_cast<int>(upBounds[1]), way);
    1770     const CbcIntegerBranchingObject *brPrint1 = dynamic_cast<const CbcIntegerBranchingObject *>(br1);
     1768      variable, static_cast< int >(downBounds[0]), static_cast< int >(downBounds[1]),
     1769      static_cast< int >(upBounds[0]), static_cast< int >(upBounds[1]), way);
     1770    const CbcIntegerBranchingObject *brPrint1 = dynamic_cast< const CbcIntegerBranchingObject * >(br1);
    17711771    downBounds = brPrint1->downBounds();
    17721772    upBounds = brPrint1->upBounds();
     
    17741774    way = brPrint1->way();
    17751775    printf("   br1: var %i downBd [%i,%i] upBd [%i,%i] way %i\n",
    1776       variable, static_cast<int>(downBounds[0]), static_cast<int>(downBounds[1]),
    1777       static_cast<int>(upBounds[0]), static_cast<int>(upBounds[1]), way);
     1776      variable, static_cast< int >(downBounds[0]), static_cast< int >(downBounds[1]),
     1777      static_cast< int >(upBounds[0]), static_cast< int >(upBounds[1]), way);
    17781778#endif
    17791779    const int brComp = compare3BranchingObjects(br0, br1);
     
    25842584    int start[2];
    25852585    int end[2];
    2586     int iRandom = static_cast<int>(randomNumber * (static_cast<double>(numberIntegers)));
     2586    int iRandom = static_cast< int >(randomNumber * (static_cast< double >(numberIntegers)));
    25872587    start[0] = iRandom;
    25882588    end[0] = numberIntegers;
     
    30573057    // get information on solver type
    30583058    OsiAuxInfo *auxInfo = model_->solver()->getAuxiliaryInfo();
    3059     OsiBabSolver *auxiliaryInfo = dynamic_cast<OsiBabSolver *>(auxInfo);
     3059    OsiBabSolver *auxiliaryInfo = dynamic_cast< OsiBabSolver * >(auxInfo);
    30603060    if (auxiliaryInfo) {
    30613061      return auxiliaryInfo->solution(solutionValue, betterSolution, model_->solver()->getNumCols());
  • trunk/Cbc/src/CbcHeuristic.hpp

    r2465 r2467  
    6060
    6161private:
    62   std::vector<CbcHeuristicNode *> nodes_;
     62  std::vector< CbcHeuristicNode * > nodes_;
    6363
    6464public:
     
    7676  inline int size() const
    7777  {
    78     return static_cast<int>(nodes_.size());
     78    return static_cast< int >(nodes_.size());
    7979  }
    8080};
     
    340340  {
    341341    const OsiClpSolverInterface *clpSolver
    342       = dynamic_cast<const OsiClpSolverInterface *>(solver);
     342      = dynamic_cast< const OsiClpSolverInterface * >(solver);
    343343    if (clpSolver)
    344344      return clpSolver->isHeuristicInteger(iColumn);
  • trunk/Cbc/src/CbcHeuristicDINS.cpp

    r2465 r2467  
    197197      double value = bestSolution[iColumn];
    198198      double nearest = floor(value + 0.5);
    199       values_[0][i] = static_cast<int>(nearest);
     199      values_[0][i] = static_cast< int >(nearest);
    200200    }
    201201    numberKeptSolutions_ = CoinMin(numberKeptSolutions_ + 1, maximumKeepSolutions_);
     
    246246          valueInt = originalUpper;
    247247        }
    248         int intValue = static_cast<int>(floor(valueInt + 0.5));
     248        int intValue = static_cast< int >(floor(valueInt + 0.5));
    249249        double currentValue = currentSolution[iColumn];
    250250        double currentLower = colLower[iColumn];
     
    393393    numberTries_++;
    394394    if ((numberTries_ % 10) == 0 && numberSuccesses_ * 3 < numberTries_)
    395       howOften_ += static_cast<int>(howOften_ * decayFactor_);
     395      howOften_ += static_cast< int >(howOften_ * decayFactor_);
    396396  }
    397397  return finalReturnCode;
  • trunk/Cbc/src/CbcHeuristicDW.cpp

    r2465 r2467  
    347347  int logLevel = model_->messageHandler()->logLevel();
    348348  // For moment just OsiClp
    349   OsiClpSolverInterface *solver = dynamic_cast<OsiClpSolverInterface *>(solver_);
     349  OsiClpSolverInterface *solver = dynamic_cast< OsiClpSolverInterface * >(solver_);
    350350  ClpSimplex *simplex = solver->getModelPtr();
    351351  double *columnLower = simplex->columnLower();
     
    851851    }
    852852    if (numberInDj)
    853       averageDj /= static_cast<double>(numberInDj);
     853      averageDj /= static_cast< double >(numberInDj);
    854854    if (numberInDiff)
    855       averageDiff /= static_cast<double>(numberInDiff);
     855      averageDiff /= static_cast< double >(numberInDiff);
    856856    double ratioDiff = averageDj / averageDiff;
    857857    // downplay
     
    872872      if (phase_ == 99)
    873873        blockSort[i] -= 2.0 * averageDj * goodBlock[i];
    874       blockSort[i] /= static_cast<double>(intsInBlock_[i]);
     874      blockSort[i] /= static_cast< double >(intsInBlock_[i]);
    875875      //blockSort[i] /= sqrt(static_cast<double>(intsInBlock_[i]));
    876876      if (doneBlock[i]) {
    877         blockSort[i] /= static_cast<double>(doneBlock[i] + 1);
     877        blockSort[i] /= static_cast< double >(doneBlock[i] + 1);
    878878        if (whenBlock[i] > pass_ - 10)
    879879          blockSort[i] += 1.0e2 * averageDj;
     
    14351435      if (thisBestValue * numberRowsDone > maximumBlockSize && numberRowsDone > halfway) {
    14361436        thisBestBreak = iRow;
    1437         thisBestValue = static_cast<double>(maximumBlockSize) / static_cast<double>(numberRowsDone);
     1437        thisBestValue = static_cast< double >(maximumBlockSize) / static_cast< double >(numberRowsDone);
    14381438      }
    14391439    }
     
    17921792          if (sum > 65535)
    17931793            sum = 65535;
    1794           unsigned short value = static_cast<unsigned short>(sum);
     1794          unsigned short value = static_cast< unsigned short >(sum);
    17951795          affinity_[iBlock * numberBlocks + jBlock] = value;
    17961796          affinity_[jBlock * numberBlocks + iBlock] = value;
     
    18171817      }
    18181818      sprintf(dwPrint, "Total not affinity %d - average %g%%",
    1819         nTotalZero, 100.0 * (static_cast<double>(nTotalZero) / (numberBlocks * numberBlocks)));
     1819        nTotalZero, 100.0 * (static_cast< double >(nTotalZero) / (numberBlocks * numberBlocks)));
    18201820      model_->messageHandler()->message(CBC_FPUMP1, model_->messages())
    18211821        << dwPrint
     
    18641864#define MAX_ADD 100000
    18651865  CoinBigIndex *startsDW = new CoinBigIndex[numberBlocks_ + 1 + MAX_ADD];
    1866   int *rowDW = reinterpret_cast<int *>(startsDW + numberBlocks_ + 1);
     1866  int *rowDW = reinterpret_cast< int * >(startsDW + numberBlocks_ + 1);
    18671867  double *elementDW = new double[MAX_ADD + 3 * numberBlocks_ + numberMasterRows_];
    18681868  double *newCost = elementDW + MAX_ADD;
     
    21722172      tempColumn[numberMasterColumns++] = i;
    21732173  }
    2174   OsiClpSolverInterface *solver = dynamic_cast<OsiClpSolverInterface *>(solver_);
     2174  OsiClpSolverInterface *solver = dynamic_cast< OsiClpSolverInterface * >(solver_);
    21752175  ClpSimplex *tempModel = new ClpSimplex(solver->getModelPtr(),
    21762176    numberMasterRows, tempRow,
  • trunk/Cbc/src/CbcHeuristicDive.cpp

    r2465 r2467  
    214214  for (int i = 0; i < numberObjects; i++) {
    215215    OsiObject *object = model_->modifiableObject(i);
    216     const CbcSimpleInteger *thisOne = dynamic_cast<const CbcSimpleInteger *>(object);
     216    const CbcSimpleInteger *thisOne = dynamic_cast< const CbcSimpleInteger * >(object);
    217217    if (!thisOne)
    218218      continue; // Not integer
     
    231231    for (int i = 0; i < numberObjects; i++) {
    232232      OsiObject *object = model_->modifiableObject(i);
    233       const CbcSimpleInteger *thisOne = dynamic_cast<const CbcSimpleInteger *>(object);
     233      const CbcSimpleInteger *thisOne = dynamic_cast< const CbcSimpleInteger * >(object);
    234234      if (!thisOne)
    235235        continue; // Not integer
     
    237237      assert(level < (1 << 29));
    238238      assert(nInteger < numberIntegers);
    239       priority_[nInteger].priority = static_cast<unsigned int>(level);
     239      priority_[nInteger].priority = static_cast< unsigned int >(level);
    240240      int direction = 0;
    241241      if (thisOne->preferredWay() < 0)
     
    244244        direction = 1 | 1;
    245245      // at present don't try other way is not used
    246       priority_[nInteger++].direction = static_cast<unsigned char>(direction);
     246      priority_[nInteger++].direction = static_cast< unsigned char >(direction);
    247247    }
    248248    assert(nInteger == numberIntegers);
     
    300300#ifdef COIN_HAS_CLP
    301301  OsiClpSolverInterface *clpSolver
    302     = dynamic_cast<OsiClpSolverInterface *>(solver);
     302    = dynamic_cast< OsiClpSolverInterface * >(solver);
    303303  if (clpSolver) {
    304304    ClpSimplex *clpSimplex = clpSolver->getModelPtr();
     
    372372  double *random = new double[numberIntegers];
    373373
    374   int maxNumberAtBoundToFix = static_cast<int>(floor(percentageToFix_ * numberIntegers));
     374  int maxNumberAtBoundToFix = static_cast< int >(floor(percentageToFix_ * numberIntegers));
    375375  assert(!maxNumberAtBoundToFix || !nodes);
    376376
     
    515515    if (binVarIndex_.size()) {
    516516      int cnt = 0;
    517       int n = static_cast<int>(binVarIndex_.size());
     517      int n = static_cast< int >(binVarIndex_.size());
    518518      for (int j = 0; j < n; j++) {
    519519        int iColumn1 = binVarIndex_[j];
     
    595595          if (upper[iColumn] > lower[iColumn]) {
    596596            int j = back[iColumn];
    597             fixPriority = CoinMin(fixPriority, static_cast<int>(priority_[j].priority));
     597            fixPriority = CoinMin(fixPriority, static_cast< int >(priority_[j].priority));
    598598          }
    599599        }
     
    623623          numberFree++;
    624624          if (priority_) {
    625             fixPriority = CoinMin(fixPriority, static_cast<int>(priority_[i].priority));
     625            fixPriority = CoinMin(fixPriority, static_cast< int >(priority_[i].priority));
    626626          }
    627627          double value = newSolution[iColumn];
     
    662662        if (upper[iColumn] > lower[iColumn]) {
    663663          if (priority_) {
    664             fixPriority = CoinMin(fixPriority, static_cast<int>(priority_[i].priority));
     664            fixPriority = CoinMin(fixPriority, static_cast< int >(priority_[i].priority));
    665665          }
    666666          double value = newSolution[iColumn];
     
    687687              if (priority_[j].priority > fixPriority)
    688688                continue; // skip - only fix ones at high priority
    689               int thisRound = static_cast<int>(priority_[j].direction);
     689              int thisRound = static_cast< int >(priority_[j].direction);
    690690              if ((thisRound & 1) != 0) {
    691691                // for now force way
     
    722722              if (priority_[j].priority > fixPriority)
    723723                continue; // skip - only fix ones at high priority
    724               int thisRound = static_cast<int>(priority_[j].direction);
     724              int thisRound = static_cast< int >(priority_[j].direction);
    725725              if ((thisRound & 1) != 0) {
    726726                // for now force way
     
    13071307      }
    13081308    }
    1309     downLocks_[i] = static_cast<unsigned short>(down);
    1310     upLocks_[i] = static_cast<unsigned short>(up);
     1309    downLocks_[i] = static_cast< unsigned short >(down);
     1310    upLocks_[i] = static_cast< unsigned short >(up);
    13111311  }
    13121312
     
    14321432#ifdef COIN_HAS_CLP
    14331433  OsiClpSolverInterface *clpSolver
    1434     = dynamic_cast<OsiClpSolverInterface *>(solver);
     1434    = dynamic_cast< OsiClpSolverInterface * >(solver);
    14351435  ClpSimplex *clpSimplex = NULL;
    14361436  if (clpSolver)
  • trunk/Cbc/src/CbcHeuristicDive.hpp

    r2465 r2467  
    170170  // Indexes of binary variables with 0 objective coefficient
    171171  // and in variable bound constraints
    172   std::vector<int> binVarIndex_;
     172  std::vector< int > binVarIndex_;
    173173
    174174  // Indexes of variable bound rows for each binary variable
    175   std::vector<int> vbRowIndex_;
     175  std::vector< int > vbRowIndex_;
    176176
    177177  // Percentage of integer variables to fix at bounds
  • trunk/Cbc/src/CbcHeuristicDiveCoefficient.cpp

    r2465 r2467  
    121121        // if priorities then use
    122122        if (priority_) {
    123           int thisRound = static_cast<int>(priority_[i].direction);
     123          int thisRound = static_cast< int >(priority_[i].direction);
    124124          if ((thisRound & 1) != 0)
    125125            round = ((thisRound & 2) == 0) ? -1 : +1;
     
    127127            nLocks = COIN_INT_MAX;
    128128          } else if (priority_[i].priority < bestPriority) {
    129             bestPriority = static_cast<int>(priority_[i].priority);
     129            bestPriority = static_cast< int >(priority_[i].priority);
    130130            bestLocks = COIN_INT_MAX;
    131131          }
  • trunk/Cbc/src/CbcHeuristicDiveFractional.cpp

    r2465 r2467  
    105105        // if priorities then use
    106106        if (priority_) {
    107           int thisRound = static_cast<int>(priority_[i].direction);
     107          int thisRound = static_cast< int >(priority_[i].direction);
    108108          if ((thisRound & 1) != 0)
    109109            round = ((thisRound & 2) == 0) ? -1 : +1;
     
    111111            fraction = COIN_DBL_MAX;
    112112          } else if (priority_[i].priority < bestPriority) {
    113             bestPriority = static_cast<int>(priority_[i].priority);
     113            bestPriority = static_cast< int >(priority_[i].priority);
    114114            bestFraction = COIN_DBL_MAX;
    115115          }
  • trunk/Cbc/src/CbcHeuristicDiveGuided.cpp

    r2465 r2467  
    115115        // if priorities then use
    116116        if (priority_) {
    117           int thisRound = static_cast<int>(priority_[i].direction);
     117          int thisRound = static_cast< int >(priority_[i].direction);
    118118          if ((thisRound & 1) != 0)
    119119            round = ((thisRound & 2) == 0) ? -1 : +1;
     
    121121            fraction = COIN_DBL_MAX;
    122122          } else if (priority_[i].priority < bestPriority) {
    123             bestPriority = static_cast<int>(priority_[i].priority);
     123            bestPriority = static_cast< int >(priority_[i].priority);
    124124            bestFraction = COIN_DBL_MAX;
    125125          }
  • trunk/Cbc/src/CbcHeuristicDiveLineSearch.cpp

    r2465 r2467  
    113113        // if priorities then use
    114114        if (priority_) {
    115           int thisRound = static_cast<int>(priority_[i].direction);
     115          int thisRound = static_cast< int >(priority_[i].direction);
    116116          if ((thisRound & 1) != 0)
    117117            round = ((thisRound & 2) == 0) ? -1 : +1;
     
    119119            relDistance = COIN_DBL_MAX;
    120120          } else if (priority_[i].priority < bestPriority) {
    121             bestPriority = static_cast<int>(priority_[i].priority);
     121            bestPriority = static_cast< int >(priority_[i].priority);
    122122            bestRelDistance = COIN_DBL_MAX;
    123123          }
  • trunk/Cbc/src/CbcHeuristicDivePseudoCost.cpp

    r2465 r2467  
    134134        // if priorities then use
    135135        if (priority_) {
    136           int thisRound = static_cast<int>(priority_[i].direction);
     136          int thisRound = static_cast< int >(priority_[i].direction);
    137137          if ((thisRound & 1) != 0)
    138138            round = ((thisRound & 2) == 0) ? -1 : +1;
     
    140140            score = COIN_DBL_MAX;
    141141          } else if (priority_[i].priority < bestPriority) {
    142             bestPriority = static_cast<int>(priority_[i].priority);
     142            bestPriority = static_cast< int >(priority_[i].priority);
    143143            bestScore = COIN_DBL_MAX;
    144144          }
     
    175175    OsiObject **objects = model_->objects();
    176176    for (int i = 0; i < numberInts; i++) {
    177       CbcSimpleIntegerDynamicPseudoCost *obj1 = dynamic_cast<CbcSimpleIntegerDynamicPseudoCost *>(objects[i]);
     177      CbcSimpleIntegerDynamicPseudoCost *obj1 = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(objects[i]);
    178178      if (obj1) {
    179179        //int iColumn = obj1->columnNumber();
  • trunk/Cbc/src/CbcHeuristicDiveVectorLength.cpp

    r2465 r2467  
    114114
    115115        // we want the smaller score
    116         double score = objDelta / (static_cast<double>(columnLength[iColumn]) + 1.0);
     116        double score = objDelta / (static_cast< double >(columnLength[iColumn]) + 1.0);
    117117
    118118        // if variable is not binary, penalize it
     
    122122        // if priorities then use
    123123        if (priority_) {
    124           int thisRound = static_cast<int>(priority_[i].direction);
     124          int thisRound = static_cast< int >(priority_[i].direction);
    125125          if ((thisRound & 1) != 0)
    126126            round = ((thisRound & 2) == 0) ? -1 : +1;
     
    128128            score = COIN_DBL_MAX;
    129129          } else if (priority_[i].priority < bestPriority) {
    130             bestPriority = static_cast<int>(priority_[i].priority);
     130            bestPriority = static_cast< int >(priority_[i].priority);
    131131            bestScore = COIN_DBL_MAX;
    132132          }
  • trunk/Cbc/src/CbcHeuristicFPump.cpp

    r2465 r2467  
    327327#ifndef NDEBUG
    328328    const OsiObject *object = model_->object(i);
    329     const CbcSimpleInteger *integerObject = dynamic_cast<const CbcSimpleInteger *>(object);
    330     const OsiSimpleInteger *integerObject2 = dynamic_cast<const OsiSimpleInteger *>(object);
     329    const CbcSimpleInteger *integerObject = dynamic_cast< const CbcSimpleInteger * >(object);
     330    const OsiSimpleInteger *integerObject2 = dynamic_cast< const OsiSimpleInteger * >(object);
    331331    assert(integerObject || integerObject2);
    332332#endif
     
    444444*/
    445445  CoinWarmStartBasis saveBasis;
    446   CoinWarmStartBasis *basis = dynamic_cast<CoinWarmStartBasis *>(model_->solver()->getWarmStart());
     446  CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(model_->solver()->getWarmStart());
    447447  if (basis) {
    448448    saveBasis = *basis;
     
    516516  {
    517517    OsiClpSolverInterface *clpSolver
    518       = dynamic_cast<OsiClpSolverInterface *>(model_->solver());
     518      = dynamic_cast< OsiClpSolverInterface * >(model_->solver());
    519519    if (clpSolver) {
    520520      if (maximumPasses == 30) {
     
    565565    {
    566566      OsiClpSolverInterface *clpSolver
    567         = dynamic_cast<OsiClpSolverInterface *>(solver);
     567        = dynamic_cast< OsiClpSolverInterface * >(solver);
    568568      if (clpSolver) {
    569569        // better to clean up using primal?
     
    722722    }
    723723    if (scaleFactor)
    724       scaleFactor = (initialWeight_ * sqrt(static_cast<double>(numberIntegers))) / sqrt(scaleFactor);
     724      scaleFactor = (initialWeight_ * sqrt(static_cast< double >(numberIntegers))) / sqrt(scaleFactor);
    725725#ifdef CLP_INVESTIGATE
    726726#ifdef COIN_DEVELOP
     
    811811      {
    812812        OsiClpSolverInterface *clpSolver
    813           = dynamic_cast<OsiClpSolverInterface *>(clonedSolver);
     813          = dynamic_cast< OsiClpSolverInterface * >(clonedSolver);
    814814        //printf("real cutoff %g fake %g - second pass %c\n",realCutoff,cutoff,
    815815        //     secondMajorPass ? 'Y' : 'N');
     
    10331033            if (exitNow(newSolutionValue))
    10341034              exitAll = true;
    1035             CoinWarmStartBasis *basis = dynamic_cast<CoinWarmStartBasis *>(solver->getWarmStart());
     1035            CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver->getWarmStart());
    10361036            if (basis) {
    10371037              bestBasis = *basis;
     
    13041304            if (newSolutionValue < solutionValue) {
    13051305              memcpy(betterSolution, newSolution, numberColumns * sizeof(double));
    1306               CoinWarmStartBasis *basis = dynamic_cast<CoinWarmStartBasis *>(solver->getWarmStart());
     1306              CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver->getWarmStart());
    13071307              solutionFound = true;
    13081308              numberSolutions++;
     
    13601360            if (dualPass == 1 && 2 * numberChanged < numberColumns && (numberChanged < 5000 || 6 * numberChanged < numberColumns)) {
    13611361              // but we need to make infeasible
    1362               CoinWarmStartBasis *basis = dynamic_cast<CoinWarmStartBasis *>(solver->getWarmStart());
     1362              CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver->getWarmStart());
    13631363              if (basis) {
    13641364                // modify
     
    14661466              if (numberTries == 1 || secondPassOpt > 3) {
    14671467                // save basis
    1468                 CoinWarmStartBasis *basis = dynamic_cast<CoinWarmStartBasis *>(solver->getWarmStart());
     1468                CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver->getWarmStart());
    14691469                if (basis) {
    14701470                  saveBasis = *basis;
     
    21812181#ifdef COIN_HAS_CLP
    21822182            OsiClpSolverInterface *clpSolver
    2183               = dynamic_cast<OsiClpSolverInterface *>(newSolver);
     2183              = dynamic_cast< OsiClpSolverInterface * >(newSolver);
    21842184            if (clpSolver) {
    21852185              ClpSimplex *simplex = clpSolver->getModelPtr();
     
    22892289          if (exitNow(newSolutionValue))
    22902290            exitAll = true;
    2291           CoinWarmStartBasis *basis = dynamic_cast<CoinWarmStartBasis *>(newSolver->getWarmStart());
     2291          CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(newSolver->getWarmStart());
    22922292          if (basis) {
    22932293            bestBasis = *basis;
     
    24362436    printf("XXX total iterations %d ratios - %g %g %g\n",
    24372437      totalNumberIterations,
    2438       static_cast<double>(totalNumberIterations) / nrow,
    2439       static_cast<double>(totalNumberIterations) / ncol,
    2440       static_cast<double>(totalNumberIterations) / (2 * nrow + 2 * ncol));
     2438      static_cast< double >(totalNumberIterations) / nrow,
     2439      static_cast< double >(totalNumberIterations) / ncol,
     2440      static_cast< double >(totalNumberIterations) / (2 * nrow + 2 * ncol));
    24412441  }
    24422442#endif
     
    24862486        } else {
    24872487          general++;
    2488           int up = static_cast<int>(upper[iColumn]);
    2489           int lo = static_cast<int>(lower[iColumn]);
    2490           int near = static_cast<int>(nearest);
     2488          int up = static_cast< int >(upper[iColumn]);
     2489          int lo = static_cast< int >(lower[iColumn]);
     2490          int near = static_cast< int >(nearest);
    24912491          up = CoinMin(up, near + maxAround);
    24922492          lo = CoinMax(lo, near - maxAround);
     
    25332533#endif
    25342534        if (upper[iColumn] - lower[iColumn] > 1.000001) {
    2535           int up = static_cast<int>(upper[iColumn]);
    2536           int lo = static_cast<int>(lower[iColumn]);
     2535          int up = static_cast< int >(upper[iColumn]);
     2536          int lo = static_cast< int >(lower[iColumn]);
    25372537          addLower[nAddRow] = lo;
    25382538          addUpper[nAddRow] = lo;
     
    26112611  int flip_down = 0;
    26122612  double v = randomNumberGenerator_.randomDouble() * 20.0;
    2613   int nn = 10 + static_cast<int>(v);
     2613  int nn = 10 + static_cast< int >(v);
    26142614  int nnv = 0;
    26152615  int *list = new int[nn];
     
    27762776    double *saveSolution = CoinCopyOfArray(solution, numberColumns);
    27772777    double *tempSolution = CoinCopyOfArray(solution, numberColumns);
    2778     CoinWarmStartBasis *saveBasis = dynamic_cast<CoinWarmStartBasis *>(solver->getWarmStart());
     2778    CoinWarmStartBasis *saveBasis = dynamic_cast< CoinWarmStartBasis * >(solver->getWarmStart());
    27792779    for (i = 0; i < numberIntegers; i++) {
    27802780      int iColumn = integerVariable[i];
     
    32313231  if (model) {
    32323232    osiModel_
    3233       = dynamic_cast<OsiClpSolverInterface *>(model->solver());
     3233      = dynamic_cast< OsiClpSolverInterface * >(model->solver());
    32343234    if (osiModel_)
    32353235      setSimplex(osiModel_->getModelPtr());
     
    32893289  if (model) {
    32903290    osiModel_
    3291       = dynamic_cast<OsiClpSolverInterface *>(model->solver());
     3291      = dynamic_cast< OsiClpSolverInterface * >(model->solver());
    32923292    if (osiModel_)
    32933293      setSimplex(osiModel_->getModelPtr());
  • trunk/Cbc/src/CbcHeuristicGreedy.cpp

    r2465 r2467  
    17151715    } else {
    17161716      if (iPass == 0) {
    1717         costBias = 10.0 * newSolutionValue / static_cast<double>(nAdded);
     1717        costBias = 10.0 * newSolutionValue / static_cast< double >(nAdded);
    17181718      } else {
    17191719        costBias *= 10.0;
  • trunk/Cbc/src/CbcHeuristicLocal.cpp

    r2465 r2467  
    504504    if (value < originalUpper - 0.5)
    505505      iway |= 2;
    506     way[i] = static_cast<char>(iway);
     506    way[i] = static_cast< char >(iway);
    507507  }
    508508  /*
     
    570570#ifdef COIN_HAS_CLP
    571571    OsiClpSolverInterface *clpSolver
    572       = dynamic_cast<OsiClpSolverInterface *>(model_->solver());
     572      = dynamic_cast< OsiClpSolverInterface * >(model_->solver());
    573573    if (clpSolver) {
    574574      // take out some integers
     
    850850        if (value < originalUpper - 0.5)
    851851          iway |= 2;
    852         way[goodK] = static_cast<char>(iway);
     852        way[goodK] = static_cast< char >(iway);
    853853        totalChange += bestChange;
    854854      }
     
    915915        // new solution
    916916        memcpy(betterSolution, newSolution, numberColumns * sizeof(double));
    917         CoinWarmStartBasis *basis = dynamic_cast<CoinWarmStartBasis *>(solver->getWarmStart());
     917        CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver->getWarmStart());
    918918        if (basis) {
    919919          model_->setBestSolutionBasis(*basis);
     
    10891089    // clone feasibility pump
    10901090    for (int i = 0; i < model_->numberHeuristics(); i++) {
    1091       const CbcHeuristicFPump *pump = dynamic_cast<const CbcHeuristicFPump *>(model_->heuristic(i));
     1091      const CbcHeuristicFPump *pump = dynamic_cast< const CbcHeuristicFPump * >(model_->heuristic(i));
    10921092      if (pump) {
    10931093        feasibilityPump_ = new CbcHeuristicFPump(*pump);
     
    11621162    pumpAdded = true;
    11631163    for (int i = 0; i < model_->numberHeuristics(); i++) {
    1164       const CbcHeuristicFPump *pump = dynamic_cast<const CbcHeuristicFPump *>(model_->heuristic(i));
     1164      const CbcHeuristicFPump *pump = dynamic_cast< const CbcHeuristicFPump * >(model_->heuristic(i));
    11651165      if (pump) {
    11661166        pumpAdded = false;
     
    12091209      solutionValue += obj[i] * betterSolution[i];
    12101210      if (isHeuristicInteger(solver, i)) {
    1211         int change = static_cast<int>(floor(solutionIn[i] - betterSolution[i] + 0.5));
     1211        int change = static_cast< int >(floor(solutionIn[i] - betterSolution[i] + 0.5));
    12121212        if (change > 0) {
    12131213          numberIncrease++;
     
    13451345  bool solutionFound = false;
    13461346  CoinWarmStartBasis saveBasis;
    1347   CoinWarmStartBasis *basis = dynamic_cast<CoinWarmStartBasis *>(solver->getWarmStart());
     1347  CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver->getWarmStart());
    13481348  if (basis) {
    13491349    saveBasis = *basis;
  • trunk/Cbc/src/CbcHeuristicLocal.hpp

    r2465 r2467  
    262262  // Data
    263263  /// Attempts
    264   std::vector<double> attempts_;
     264  std::vector< double > attempts_;
    265265  /// Random numbers to stop same search happening
    266266  double random_[10];
  • trunk/Cbc/src/CbcHeuristicPivotAndFix.cpp

    r2465 r2467  
    107107
    108108  OsiClpSolverInterface *clpSolverOriginal
    109     = dynamic_cast<OsiClpSolverInterface *>(model_->solver());
     109    = dynamic_cast< OsiClpSolverInterface * >(model_->solver());
    110110  assert(clpSolverOriginal);
    111111  OsiClpSolverInterface *clpSolver(clpSolverOriginal);
  • trunk/Cbc/src/CbcHeuristicRENS.cpp

    r2465 r2467  
    145145    double total = 0.0;
    146146    int n = 0;
    147     CoinWarmStartBasis *basis = dynamic_cast<CoinWarmStartBasis *>(solver->getWarmStart());
     147    CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver->getWarmStart());
    148148    if (basis && basis->getNumArtificial()) {
    149149      for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
     
    154154      }
    155155      if (n)
    156         djTolerance = (0.01 * total) / static_cast<double>(n);
     156        djTolerance = (0.01 * total) / static_cast< double >(n);
    157157      delete basis;
    158158    }
     
    169169    // SOS type fixing
    170170    bool fixSets = (type == 5) || (type == 7) || (type == 10) || (type == 11);
    171     CoinWarmStartBasis *basis = dynamic_cast<CoinWarmStartBasis *>(solver->getWarmStart());
     171    CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver->getWarmStart());
    172172    if (basis && basis->getNumArtificial()) {
    173173      //const double * rowLower = solver->getRowLower();
     
    281281        if (type < 10) {
    282282          std::sort(sort, sort + nSOS);
    283           int last = static_cast<int>(nSOS * 0.9 * fractionSmall_);
     283          int last = static_cast< int >(nSOS * 0.9 * fractionSmall_);
    284284          double tolerance = sort[last];
    285285          for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
     
    364364            }
    365365          }
    366           double averagePerSet = sum / static_cast<double>(numberRows);
     366          double averagePerSet = sum / static_cast< double >(numberRows);
    367367          // allow this extra
    368368          double factor = averagePerSet * fractionSmall_ * numberRows;
     
    441441          char *nonzero = new char[numberColumns];
    442442          // save basis and solution
    443           CoinWarmStartBasis *basis = dynamic_cast<CoinWarmStartBasis *>(newSolver->getWarmStart());
     443          CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(newSolver->getWarmStart());
    444444          assert(basis != NULL);
    445445          double *saveSolution = CoinCopyOfArray(newSolver->getColSolution(),
     
    510510          }
    511511          int nFixed = 0;
    512           int numberSetsToFix = static_cast<int>(nSOS * (1.0 - proportion));
     512          int numberSetsToFix = static_cast< int >(nSOS * (1.0 - proportion));
    513513          int *mixed = new int[numberRows];
    514514          memset(mixed, 0, numberRows * sizeof(int));
     
    601601    }
    602602    std::sort(sort, sort + numberColumns);
    603     int last = static_cast<int>(numberColumns * fractionSmall_);
     603    int last = static_cast< int >(numberColumns * fractionSmall_);
    604604    djTolerance = CoinMax(sort[last], 1.0e-5);
    605605    delete[] sort;
     
    655655      chunk[i] = -1;
    656656      if (whichRow[i]) {
    657         contribution[i] = -contribution[i] / static_cast<double>(whichRow[i]);
     657        contribution[i] = -contribution[i] / static_cast< double >(whichRow[i]);
    658658      } else {
    659659        contribution[i] = COIN_DBL_MAX;
     
    856856        double *sort = new double[nAtLb];
    857857        int *which = new int[nAtLb];
    858         double threshold = CoinMax((0.01 * sumDj) / static_cast<double>(nAtLb), 1.0e-6);
     858        double threshold = CoinMax((0.01 * sumDj) / static_cast< double >(nAtLb), 1.0e-6);
    859859        int nFix2 = 0;
    860860        for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
     
    913913          double *sort = new double[nAtLb];
    914914          int *which = new int[nAtLb];
    915           double threshold = CoinMax((0.01 * sumDj) / static_cast<double>(nAtLb), 1.0e-6);
     915          double threshold = CoinMax((0.01 * sumDj) / static_cast< double >(nAtLb), 1.0e-6);
    916916          int nFix2 = 0;
    917917          for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
  • trunk/Cbc/src/CbcHeuristicRINS.cpp

    r2465 r2467  
    369369    numberTries_++;
    370370    if ((numberTries_ % 10) == 0 && numberSuccesses_ * 3 < numberTries_)
    371       howOften_ += static_cast<int>(howOften_ * decayFactor_);
     371      howOften_ += static_cast< int >(howOften_ * decayFactor_);
    372372    delete newSolver;
    373373  }
  • trunk/Cbc/src/CbcHeuristicRandRound.cpp

    r2465 r2467  
    2424static inline int intRand(const int range)
    2525{
    26   return static_cast<int>(floor(CoinDrand48() * range));
     26  return static_cast< int >(floor(CoinDrand48() * range));
    2727}
    2828
     
    130130  double primalTolerance;
    131131  solver->getDblParam(OsiPrimalTolerance, primalTolerance);
    132   OsiClpSolverInterface *clpSolver = dynamic_cast<OsiClpSolverInterface *>(solver);
     132  OsiClpSolverInterface *clpSolver = dynamic_cast< OsiClpSolverInterface * >(solver);
    133133  assert(clpSolver);
    134134  ClpSimplex *simplex = clpSolver->getModelPtr();
     
    221221
    222222  double *newObj = new double[numCols];
    223   srand(static_cast<unsigned int>(time(NULL) + 1));
     223  srand(static_cast< unsigned int >(time(NULL) + 1));
    224224  int randNum;
    225225
     
    307307  // rlh: use some COIN max instead of 1e30 (?)
    308308  double bestObj = 1e30;
    309   std::vector<std::vector<double>> feasibles;
     309  std::vector< std::vector< double > > feasibles;
    310310  int numFeasibles = 0;
    311311
     
    360360      if (feasibility) {
    361361        numFeasibles++;
    362         feasibles.push_back(std::vector<double>(numCols));
     362        feasibles.push_back(std::vector< double >(numCols));
    363363        for (int k = 0; k < numCols; k++)
    364364          feasibles[numFeasibles - 1][k] = cornerPoints[i][k];
     
    388388  //-------------------------------------------
    389389
    390   srand(static_cast<unsigned int>(time(NULL) + 1));
     390  srand(static_cast< unsigned int >(time(NULL) + 1));
    391391  int numRandomPoints = 0;
    392392  while (numRandomPoints < 50000) {
     
    458458        printf("%.2f\n", CoinCpuTime() - start);
    459459        numFeasibles++;
    460         feasibles.push_back(std::vector<double>(numCols));
     460        feasibles.push_back(std::vector< double >(numCols));
    461461        for (int i = 0; i < numCols; i++)
    462462          feasibles[numFeasibles - 1][i] = roundRp[i];
  • trunk/Cbc/src/CbcHeuristicVND.cpp

    r2465 r2467  
    284284      numberTries_++;
    285285      if ((numberTries_ % 10) == 0 && numberSuccesses_ * 3 < numberTries_)
    286         howOften_ += static_cast<int>(howOften_ * decayFactor_);
     286        howOften_ += static_cast< int >(howOften_ * decayFactor_);
    287287    }
    288288
  • trunk/Cbc/src/CbcLinked.cpp

    r2465 r2467  
    145145      temp->removeGaps(1.0e-14);
    146146      ClpMatrixBase *save = modelPtr_->clpMatrix();
    147       ClpPackedMatrix *clpMatrix = dynamic_cast<ClpPackedMatrix *>(save);
     147      ClpPackedMatrix *clpMatrix = dynamic_cast< ClpPackedMatrix * >(save);
    148148      assert(clpMatrix);
    149149      if (save->getNumRows() > temp->getNumRows()) {
     
    238238            CbcCutGenerator *generator = cbcModel_->cutGenerator(iGenerator);
    239239            CglCutGenerator *gen = generator->generator();
    240             CglStored *gen2 = dynamic_cast<CglStored *>(gen);
     240            CglStored *gen2 = dynamic_cast< CglStored * >(gen);
    241241            if (gen2) {
    242242              // add OA cut
     
    311311      temp->removeGaps(1.0e-14);
    312312      ClpMatrixBase *save = modelPtr_->clpMatrix();
    313       ClpPackedMatrix *clpMatrix = dynamic_cast<ClpPackedMatrix *>(save);
     313      ClpPackedMatrix *clpMatrix = dynamic_cast< ClpPackedMatrix * >(save);
    314314      assert(clpMatrix);
    315315      if (save->getNumRows() > temp->getNumRows()) {
     
    435435        // and now rest
    436436        for (i = 0; i < numberObjects_; i++) {
    437           OsiBiLinear *obj = dynamic_cast<OsiBiLinear *>(object_[i]);
     437          OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(object_[i]);
    438438          if (obj) {
    439439            value += obj->xyCoefficient(solution);
     
    447447          bestObjectiveValue_ = value;
    448448          if (maxIts <= 10000 && cbcModel_) {
    449             OsiSolverLink *solver2 = dynamic_cast<OsiSolverLink *>(cbcModel_->solver());
     449            OsiSolverLink *solver2 = dynamic_cast< OsiSolverLink * >(cbcModel_->solver());
    450450            assert(solver2);
    451451            if (solver2 != this) {
     
    465465              CbcCutGenerator *generator = cbcModel_->cutGenerator(iGenerator);
    466466              CglCutGenerator *gen = generator->generator();
    467               CglStored *gen2 = dynamic_cast<CglStored *>(gen);
     467              CglStored *gen2 = dynamic_cast< CglStored * >(gen);
    468468              if (gen2) {
    469469                cbcModel_->lockThread();
     
    485485                  gradient[column2[i]] = element[i];
    486486                for (i = 0; i < numberObjects_; i++) {
    487                   OsiBiLinear *obj = dynamic_cast<OsiBiLinear *>(object_[i]);
     487                  OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(object_[i]);
    488488                  if (obj) {
    489489                    int xColumn = obj->xColumn();
     
    530530        double gap = 0.0;
    531531        for (i = 0; i < numberObjects_; i++) {
    532           OsiBiLinear *obj = dynamic_cast<OsiBiLinear *>(object_[i]);
     532          OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(object_[i]);
    533533          if (obj) {
    534534            if (obj->xMeshSize() < 1.0 && obj->yMeshSize() < 1.0) {
     
    552552            double newGap = 0.0;
    553553            for (i = 0; i < numberObjects_; i++) {
    554               OsiBiLinear *obj = dynamic_cast<OsiBiLinear *>(object_[i]);
     554              OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(object_[i]);
    555555              if (obj && (obj->branchingStrategy() & 8) == 0) {
    556556                if (obj->xMeshSize() < 1.0 && obj->yMeshSize() < 1.0) {
     
    657657            CbcCutGenerator *generator = cbcModel_->cutGenerator(iGenerator);
    658658            CglCutGenerator *gen = generator->generator();
    659             CglTemporary *gen2 = dynamic_cast<CglTemporary *>(gen);
     659            CglTemporary *gen2 = dynamic_cast< CglTemporary * >(gen);
    660660            if (gen2) {
    661661              double *solution2 = NULL;
     
    702702          CbcCutGenerator *generator = cbcModel_->cutGenerator(iGenerator);
    703703          CglCutGenerator *gen = generator->generator();
    704           CglTemporary *gen2 = dynamic_cast<CglTemporary *>(gen);
     704          CglTemporary *gen2 = dynamic_cast< CglTemporary * >(gen);
    705705          if (gen2) {
    706706            const double *solution = getColSolution();
     
    731731                gradient[column2[i]] = element[i];
    732732              for (i = startNonLinear_[iNon]; i < startNonLinear_[iNon + 1]; i++) {
    733                 OsiBiLinear *obj = dynamic_cast<OsiBiLinear *>(object_[whichNonLinear_[i]]);
     733                OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(object_[whichNonLinear_[i]]);
    734734                assert(obj);
    735735                int xColumn = obj->xColumn();
     
    809809  //const double * columnUpper = modelPtr_->columnUpper();
    810810  for (i = 0; i < numberObjects_; i++) {
    811     OsiBiLinear *obj = dynamic_cast<OsiBiLinear *>(object_[i]);
     811    OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(object_[i]);
    812812    if (obj) {
    813813      int xColumn = obj->xColumn();
     
    12211221    double *sort = new double[nBi];
    12221222    nBi = nInt;
    1223     const OsiObject **justBi = const_cast<const OsiObject **>(objects + nInt);
     1223    const OsiObject **justBi = const_cast< const OsiObject ** >(objects + nInt);
    12241224    for (iColumn = 0; iColumn < numberColumns; iColumn++) {
    12251225      if (quadraticObjective)
     
    14191419      CoinZeroN(whichRows, numberRows2);
    14201420      for (i = 0; i < numberObjects_; i++) {
    1421         OsiBiLinear *obj = dynamic_cast<OsiBiLinear *>(object_[i]);
     1421        OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(object_[i]);
    14221422        if (obj) {
    14231423          int xyRow = obj->xyRow();
     
    14521452      whichNonLinear_ = new int[n];
    14531453      for (i = 0; i < numberObjects_; i++) {
    1454         OsiBiLinear *obj = dynamic_cast<OsiBiLinear *>(object_[i]);
     1454        OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(object_[i]);
    14551455        if (obj) {
    14561456          int xyRow = obj->xyRow();
     
    14761476  const double *rowUpper = getRowUpper();
    14771477  for (int iObject = 0; iObject < numberObjects_; iObject++) {
    1478     OsiBiLinear *obj = dynamic_cast<OsiBiLinear *>(object_[iObject]);
     1478    OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(object_[iObject]);
    14791479    if (obj) {
    14801480      int xyRow = obj->xyRow();
     
    15511551  int i;
    15521552  for (i = 0; i < numberObjects_; i++) {
    1553     OsiBiLinear *obj = dynamic_cast<OsiBiLinear *>(object_[i]);
     1553    OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(object_[i]);
    15541554    if (obj) {
    15551555      //obj->setBranchingStrategy(4); // ***** temp
     
    17381738  int i;
    17391739  for (i = 0; i < numberObjects_; i++) {
    1740     OsiBiLinear *obj = dynamic_cast<OsiBiLinear *>(object_[i]);
     1740    OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(object_[i]);
    17411741    if (obj) {
    17421742      if (obj->xMeshSize() < 1.0 && obj->yMeshSize() < 1.0) {
     
    17761776  int i;
    17771777  for (i = 0; i < numberObjects_; i++) {
    1778     OsiBiLinear *obj = dynamic_cast<OsiBiLinear *>(object_[i]);
     1778    OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(object_[i]);
    17791779    if (obj) {
    17801780      bool change = false;
     
    18121812  int i;
    18131813  for (i = 0; i < numberObjects_; i++) {
    1814     OsiBiLinear *obj = dynamic_cast<OsiBiLinear *>(object_[i]);
     1814    OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(object_[i]);
    18151815    if (obj) {
    18161816      if (obj->xMeshSize() < 1.0 && obj->yMeshSize() < 1.0) {
     
    25102510    CbcModel *cbcModel = &model2;
    25112511    OsiSolverInterface *osiModel = model2.solver();
    2512     OsiClpSolverInterface *osiclpModel = dynamic_cast<OsiClpSolverInterface *>(osiModel);
     2512    OsiClpSolverInterface *osiclpModel = dynamic_cast< OsiClpSolverInterface * >(osiModel);
    25132513    ClpSimplex *clpModel = osiclpModel->getModelPtr();
    25142514
     
    26072607    cbcModel->initialSolve();
    26082608    cbcModel->branchAndBound();
    2609     OsiSolverLinearizedQuadratic *solver3 = dynamic_cast<OsiSolverLinearizedQuadratic *>(model2.solver());
     2609    OsiSolverLinearizedQuadratic *solver3 = dynamic_cast< OsiSolverLinearizedQuadratic * >(model2.solver());
    26102610    assert(solver3);
    26112611    solution = solver3->bestSolution();
     
    26652665    const double *upper = getColUpper();
    26662666    for (int iObject = 0; iObject < numberObjects_; iObject++) {
    2667       OsiSimpleInteger *obj = dynamic_cast<OsiSimpleInteger *>(object_[iObject]);
     2667      OsiSimpleInteger *obj = dynamic_cast< OsiSimpleInteger * >(object_[iObject]);
    26682668      if (obj && (obj->priority() < biLinearPriority_ || biLinearPriority_ <= 0)) {
    26692669        int iColumn = obj->columnNumber();
     
    26922692    memset(mark, 0, numberColumns);
    26932693    for (int iObject = 0; iObject < numberObjects_; iObject++) {
    2694       OsiSimpleInteger *obj = dynamic_cast<OsiSimpleInteger *>(object_[iObject]);
     2694      OsiSimpleInteger *obj = dynamic_cast< OsiSimpleInteger * >(object_[iObject]);
    26952695      if (obj && obj->priority() < biLinearPriority_) {
    26962696        int iColumn = obj->columnNumber();
     
    27002700        mark[iColumn] = 1;
    27012701      }
    2702       OsiBiLinear *objB = dynamic_cast<OsiBiLinear *>(object_[iObject]);
     2702      OsiBiLinear *objB = dynamic_cast< OsiBiLinear * >(object_[iObject]);
    27032703      if (objB) {
    27042704        // if one or both continuous then fix one
     
    27232723    newSolver.loadFromCoinModel(tempModel, true);
    27242724    for (int iObject = 0; iObject < numberObjects_; iObject++) {
    2725       OsiSimpleInteger *obj = dynamic_cast<OsiSimpleInteger *>(object_[iObject]);
     2725      OsiSimpleInteger *obj = dynamic_cast< OsiSimpleInteger * >(object_[iObject]);
    27262726      if (obj && obj->priority() < biLinearPriority_) {
    27272727        int iColumn = obj->columnNumber();
     
    27312731        newSolver.setColUpper(iColumn, value);
    27322732      }
    2733       OsiBiLinear *objB = dynamic_cast<OsiBiLinear *>(object_[iObject]);
     2733      OsiBiLinear *objB = dynamic_cast< OsiBiLinear * >(object_[iObject]);
    27342734      if (objB) {
    27352735        // if one or both continuous then fix one
     
    27522752  CbcModel *cbcModel = &model;
    27532753  OsiSolverInterface *osiModel = model.solver();
    2754   OsiClpSolverInterface *osiclpModel = dynamic_cast<OsiClpSolverInterface *>(osiModel);
     2754  OsiClpSolverInterface *osiclpModel = dynamic_cast< OsiClpSolverInterface * >(osiModel);
    27552755  ClpSimplex *clpModel = osiclpModel->getModelPtr();
    27562756  CglProbing probing;
     
    29332933    int n = 0;
    29342934    for (i = startNonLinear_[iNon]; i < startNonLinear_[iNon + 1]; i++) {
    2935       OsiBiLinear *obj = dynamic_cast<OsiBiLinear *>(object_[whichNonLinear_[i]]);
     2935      OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(object_[whichNonLinear_[i]]);
    29362936      assert(obj);
    29372937      int xColumn = obj->xColumn();
     
    32163216  int numberChanged = 0;
    32173217  for (int iObject = 0; iObject < numberObjects_; iObject++) {
    3218     OsiBiLinear *obj = dynamic_cast<OsiBiLinear *>(object_[iObject]);
     3218    OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(object_[iObject]);
    32193219    if (obj) {
    32203220      numberChanged += obj->updateCoefficients(lower, upper, objective, matrix, &basis_);
     
    32423242  int i;
    32433243  for (i = 0; i < numberObjects_; i++) {
    3244     OsiSimpleInteger *obj = dynamic_cast<OsiSimpleInteger *>(object_[i]);
     3244    OsiSimpleInteger *obj = dynamic_cast< OsiSimpleInteger * >(object_[i]);
    32453245    if (obj) {
    32463246#ifndef NDEBUG
     
    32613261    CoinZeroN(highPriority, numberColumns);
    32623262    for (i = 0; i < numberObjects_; i++) {
    3263       OsiSimpleInteger *obj = dynamic_cast<OsiSimpleInteger *>(object_[i]);
     3263      OsiSimpleInteger *obj = dynamic_cast< OsiSimpleInteger * >(object_[i]);
    32643264      if (obj) {
    32653265        int iColumn = obj->columnNumber();
     
    34223422    bool onOptimalPath = true;
    34233423    for (i = 0; i < 7; i++) {
    3424       if (static_cast<int>(upper[i]) != fake[i])
     3424      if (static_cast< int >(upper[i]) != fake[i])
    34253425        onOptimalPath = false;
    34263426    }
     
    34503450    CbcModel *cbcModel = &model;
    34513451    OsiSolverInterface *osiModel = model.solver();
    3452     OsiClpSolverInterface *osiclpModel = dynamic_cast<OsiClpSolverInterface *>(osiModel);
     3452    OsiClpSolverInterface *osiclpModel = dynamic_cast< OsiClpSolverInterface * >(osiModel);
    34533453    ClpSimplex *clpModel = osiclpModel->getModelPtr();
    34543454    CglProbing probing;
     
    35893589          cbcModel->setMaximumSolutions(1); // just getting a solution
    35903590#ifdef JJF_ZERO
    3591           OsiClpSolverInterface *osiclpModel = dynamic_cast<OsiClpSolverInterface *>(cbcModel->solver());
     3591          OsiClpSolverInterface *osiclpModel = dynamic_cast< OsiClpSolverInterface * >(cbcModel->solver());
    35923592          ClpSimplex *clpModel = osiclpModel->getModelPtr();
    35933593          const double *element = clpModel->matrix()->getMutableElements();
     
    37973797  }
    37983798  boundElementAction action;
    3799   action.affect = static_cast<unsigned char>(upperBoundAffected ? 1 : 0);
    3800   action.ubUsed = static_cast<unsigned char>(useUpperBound ? 1 : 0);
     3799  action.affect = static_cast< unsigned char >(upperBoundAffected ? 1 : 0);
     3800  action.ubUsed = static_cast< unsigned char >(useUpperBound ? 1 : 0);
    38013801  action.type = 2;
    3802   action.affected = static_cast<short int>(whichVariable);
     3802  action.affected = static_cast< short int >(whichVariable);
    38033803  action.multiplier = multiplier;
    38043804  affected_[numberAffected_++] = action;
     
    39073907    return 0;
    39083908  OsiSolverLink *clpSolver
    3909     = dynamic_cast<OsiSolverLink *>(model_->solver());
     3909    = dynamic_cast< OsiSolverLink * >(model_->solver());
    39103910  assert(clpSolver);
    39113911  double newSolutionValue = clpSolver->bestObjectiveValue();
     
    41054105    weight /= sum;
    41064106    valueInfeasibility = lastNonZero - firstNonZero + 1;
    4107     valueInfeasibility *= 0.5 / static_cast<double>(numberMembers_);
     4107    valueInfeasibility *= 0.5 / static_cast< double >(numberMembers_);
    41084108    //#define DISTANCE
    41094109#ifdef DISTANCE
     
    44954495OsiOldLinkBranchingObject::branch(OsiSolverInterface *solver)
    44964496{
    4497   const OsiOldLink *set = dynamic_cast<const OsiOldLink *>(originalObject_);
     4497  const OsiOldLink *set = dynamic_cast< const OsiOldLink * >(originalObject_);
    44984498  assert(set);
    44994499  int way = (!branchIndex_) ? (2 * firstBranch_ - 1) : -(2 * firstBranch_ - 1);
     
    45434543void OsiOldLinkBranchingObject::print(const OsiSolverInterface *solver)
    45444544{
    4545   const OsiOldLink *set = dynamic_cast<const OsiOldLink *>(originalObject_);
     4545  const OsiOldLink *set = dynamic_cast< const OsiOldLink * >(originalObject_);
    45464546  assert(set);
    45474547  int way = (!branchIndex_) ? (2 * firstBranch_ - 1) : -(2 * firstBranch_ - 1);
     
    48294829  for (i = numberExistingObjects - 1; i >= 0; i--) {
    48304830    const OsiObject *obj = objects[i];
    4831     const OsiBiLinear *obj2 = dynamic_cast<const OsiBiLinear *>(obj);
     4831    const OsiBiLinear *obj2 = dynamic_cast< const OsiBiLinear * >(obj);
    48324832    if (obj2) {
    48334833      if (xColumn_ == obj2->xColumn_ && !xDone) {
     
    49624962  for (i = 0; i < nAdd; i++) {
    49634963    CoinBigIndex iStart = starts[i];
    4964     coinModel->addRow(static_cast<int>(starts[i + 1] - iStart),
     4964    coinModel->addRow(static_cast< int >(starts[i + 1] - iStart),
    49654965      index + iStart, element + iStart,
    49664966      rowLower[i], rowUpper[i]);
     
    50605060  for (i = 0; i < 4; i++) {
    50615061    CoinBigIndex iStart = starts[i];
    5062     coinModel->addColumn(static_cast<int>(starts[i + 1] - iStart),
     5062    coinModel->addColumn(static_cast< int >(starts[i + 1] - iStart),
    50635063      index + iStart, element + iStart, columnLower[i],
    50645064      columnUpper[i], objective[i]);
     
    50805080  for (i = numberExistingObjects - 1; i >= 0; i--) {
    50815081    const OsiObject *obj = objects[i];
    5082     const OsiBiLinear *obj2 = dynamic_cast<const OsiBiLinear *>(obj);
     5082    const OsiBiLinear *obj2 = dynamic_cast< const OsiBiLinear * >(obj);
    50835083    if (obj2) {
    50845084      if (xColumn_ == obj2->xColumn_ && !xDone) {
     
    65476547  int chosen)
    65486548  : OsiTwoWayBranchingObject(solver, set, way, separator)
    6549   , chosen_(static_cast<short int>(chosen))
     6549  , chosen_(static_cast< short int >(chosen))
    65506550{
    65516551  assert(chosen_ >= 0 && chosen_ < 2);
     
    65826582OsiBiLinearBranchingObject::branch(OsiSolverInterface *solver)
    65836583{
    6584   const OsiBiLinear *set = dynamic_cast<const OsiBiLinear *>(originalObject_);
     6584  const OsiBiLinear *set = dynamic_cast< const OsiBiLinear * >(originalObject_);
    65856585  assert(set);
    65866586  int way = (!branchIndex_) ? (2 * firstBranch_ - 1) : -(2 * firstBranch_ - 1);
     
    65936593bool OsiBiLinearBranchingObject::boundBranch() const
    65946594{
    6595   const OsiBiLinear *set = dynamic_cast<const OsiBiLinear *>(originalObject_);
     6595  const OsiBiLinear *set = dynamic_cast< const OsiBiLinear * >(originalObject_);
    65966596  assert(set);
    65976597  return (set->branchingStrategy() & 4) != 0;
     
    66006600void OsiBiLinearBranchingObject::print(const OsiSolverInterface * /*solver*/)
    66016601{
    6602   const OsiBiLinear *set = dynamic_cast<const OsiBiLinear *>(originalObject_);
     6602  const OsiBiLinear *set = dynamic_cast< const OsiBiLinear * >(originalObject_);
    66036603  assert(set);
    66046604  int way = (!branchIndex_) ? (2 * firstBranch_ - 1) : -(2 * firstBranch_ - 1);
     
    66486648  }
    66496649  // See how many points
    6650   numberPoints_ = static_cast<int>((xB[1] - xB[0] + 0.5 * xMesh) / xMesh);
     6650  numberPoints_ = static_cast< int >((xB[1] - xB[0] + 0.5 * xMesh) / xMesh);
    66516651  // redo exactly
    6652   xMeshSize_ = (xB[1] - xB[0]) / static_cast<double>(numberPoints_);
     6652  xMeshSize_ = (xB[1] - xB[0]) / static_cast< double >(numberPoints_);
    66536653  numberPoints_++;
    66546654  //#define KEEPXY
     
    68636863    // new step size
    68646864    assert(numberPoints_ > 2);
    6865     step = CoinMax((1.5 * step) / static_cast<double>(numberPoints_ - 1), 0.5 * step);
     6865    step = CoinMax((1.5 * step) / static_cast< double >(numberPoints_ - 1), 0.5 * step);
    68666866    xB[0] = CoinMax(xB[0], xValue - 0.5 * step);
    68676867    xB[1] = CoinMin(xB[1], xValue + 0.5 * step);
    68686868    // and now divide these
    6869     mesh = (xB[1] - xB[0]) / static_cast<double>(numberPoints_ - 1);
     6869    mesh = (xB[1] - xB[0]) / static_cast< double >(numberPoints_ - 1);
    68706870  } else {
    68716871    // back to original
     
    70427042  if (preferredWay_ >= 0 && !satisfied)
    70437043    whichWay = preferredWay_;
    7044   whichWay_ = static_cast<short int>(whichWay);
     7044  whichWay_ = static_cast< short int >(whichWay);
    70457045  return infeasibility_;
    70467046}
     
    71477147  printf("Checking quadratic model %x\n", model);
    71487148  if (model) {
    7149     ClpQuadraticObjective *quadraticObj = (dynamic_cast<ClpQuadraticObjective *>(model->objectiveAsObject()));
     7149    ClpQuadraticObjective *quadraticObj = (dynamic_cast< ClpQuadraticObjective * >(model->objectiveAsObject()));
    71507150    assert(quadraticObj);
    71517151    CoinPackedMatrix *quadraticObjective = quadraticObj->quadraticObjective();
     
    74107410    assert(fabs(floor(gap + 0.5) - gap) < 1.0e-5);
    74117411    whichColumn[numJ] = iColumn;
    7412     bound[numJ] = static_cast<int>(gap);
     7412    bound[numJ] = static_cast< int >(gap);
    74137413    size[numJ++] = triple.value();
    74147414    offset += triple.value() * lowerColumn;
     
    79587958  assert(solver_ == info->solver_);
    79597959  // Only has to work with Clp
    7960   OsiSolverInterface *solverA = const_cast<OsiSolverInterface *>(solver_);
    7961   OsiSolverLink *solver = dynamic_cast<OsiSolverLink *>(solverA);
     7960  OsiSolverInterface *solverA = const_cast< OsiSolverInterface * >(solver_);
     7961  OsiSolverLink *solver = dynamic_cast< OsiSolverLink * >(solverA);
    79627962  assert(solver);
    79637963  int numberObjects = solver->numberObjects();
     
    79767976    for (i = 0; i < numberObjects; i++) {
    79777977      OsiObject *obj = objects[i];
    7978       OsiBiLinear *objB = dynamic_cast<OsiBiLinear *>(obj);
     7978      OsiBiLinear *objB = dynamic_cast< OsiBiLinear * >(obj);
    79797979      if (!objB)
    79807980        objects[numObj++] = obj;
     
    79887988    // See if any master objects
    79897989    for (i = 0; i < numberObjectsToUse_; i++) {
    7990       OsiUsesBiLinear *obj = dynamic_cast<OsiUsesBiLinear *>(objects[i]);
     7990      OsiUsesBiLinear *obj = dynamic_cast< OsiUsesBiLinear * >(objects[i]);
    79917991      if (obj)
    79927992        obj->addBiLinearObjects(solver);
     
    81268126  infeasibility_ = 0.0;
    81278127  for (int i = 0; i < numberBiLinear_; i++) {
    8128     OsiBiLinear *obj = dynamic_cast<OsiBiLinear *>(objects_[i]);
     8128    OsiBiLinear *obj = dynamic_cast< OsiBiLinear * >(objects_[i]);
    81298129    assert(obj);
    81308130    //obj->getPseudoShadow(info);
     
    81478147  if (preferredWay_ >= 0 && !satisfied)
    81488148    whichWay = preferredWay_;
    8149   whichWay_ = static_cast<short int>(whichWay);
     8149  whichWay_ = static_cast< short int >(whichWay);
    81508150  return infeasibility_;
    81518151}
     
    81978197  for (i = 0; i < numberObjects; i++) {
    81988198    OsiObject *obj = objects[i];
    8199     OsiBiLinear *objB = dynamic_cast<OsiBiLinear *>(obj);
     8199    OsiBiLinear *objB = dynamic_cast< OsiBiLinear * >(obj);
    82008200    if (objB) {
    82018201      if (objB->xColumn() == columnNumber_ || objB->yColumn() == columnNumber_)
     
    82088208    for (i = 0; i < numberObjects; i++) {
    82098209      OsiObject *obj = objects[i];
    8210       OsiBiLinear *objB = dynamic_cast<OsiBiLinear *>(obj);
     8210      OsiBiLinear *objB = dynamic_cast< OsiBiLinear * >(obj);
    82118211      if (objB) {
    82128212        if (objB->xColumn() == columnNumber_ || objB->yColumn() == columnNumber_)
  • trunk/Cbc/src/CbcMipStartIO.cpp

    r2465 r2467  
    3030
    3131int readMIPStart(CbcModel *model, const char *fileName,
    32   vector<pair<string, double>> &colValues,
     32  vector< pair< string, double > > &colValues,
    3333  double & /*solObj*/)
    3434{
     
    6363      double value = atof(col[2]);
    6464
    65       colValues.push_back(pair<string, double>(string(name), value));
     65      colValues.push_back(pair< string, double >(string(name), value));
    6666    }
    6767  }
    6868
    6969  if (colValues.size()) {
    70     sprintf(printLine, "MIPStart values read for %d variables.", static_cast<int>(colValues.size()));
     70    sprintf(printLine, "MIPStart values read for %d variables.", static_cast< int >(colValues.size()));
    7171    model->messageHandler()->message(CBC_GENERAL, model->messages()) << printLine << CoinMessageEol;
    7272    if (colValues.size() < model->getNumCols()) {
    7373      int numberColumns = model->getNumCols();
    7474      OsiSolverInterface *solver = model->solver();
    75       vector<pair<string, double>> fullValues;
     75      vector< pair< string, double > > fullValues;
    7676      /* for fast search of column names */
    77       map<string, int> colIdx;
     77      map< string, int > colIdx;
    7878      for (int i = 0; i < numberColumns; i++) {
    79         fullValues.push_back(pair<string, double>(solver->getColName(i), 0.0));
     79        fullValues.push_back(pair< string, double >(solver->getColName(i), 0.0));
    8080        colIdx[solver->getColName(i)] = i;
    8181      }
    82       for (int i = 0; (i < static_cast<int>(colValues.size())); ++i) {
    83         map<string, int>::const_iterator mIt = colIdx.find(colValues[i].first);
     82      for (int i = 0; (i < static_cast< int >(colValues.size())); ++i) {
     83        map< string, int >::const_iterator mIt = colIdx.find(colValues[i].first);
    8484        if (mIt != colIdx.end()) {
    8585          const int idx = mIt->second;
     
    101101
    102102int computeCompleteSolution(CbcModel *model,
    103   const vector<string> colNames,
    104   const std::vector<std::pair<std::string, double>> &colValues,
     103  const vector< string > colNames,
     104  const std::vector< std::pair< std::string, double > > &colValues,
    105105  double *sol, double &obj)
    106106{
     
    112112  bool foundIntegerSol = false;
    113113  OsiSolverInterface *lp = model->solver()->clone();
    114   map<string, int> colIdx;
    115   assert((static_cast<int>(colNames.size())) == lp->getNumCols());
     114  map< string, int > colIdx;
     115  assert((static_cast< int >(colNames.size())) == lp->getNumCols());
    116116  /* for fast search of column names */
    117   for (int i = 0; (i < static_cast<int>(colNames.size())); ++i)
     117  for (int i = 0; (i < static_cast< int >(colNames.size())); ++i)
    118118    colIdx[colNames[i]] = i;
    119119
     
    135135  }
    136136#endif
    137   for (int i = 0; (i < static_cast<int>(colValues.size())); ++i) {
    138     map<string, int>::const_iterator mIt = colIdx.find(colValues[i].first);
     137  for (int i = 0; (i < static_cast< int >(colValues.size())); ++i) {
     138    map< string, int >::const_iterator mIt = colIdx.find(colValues[i].first);
    139139    if (mIt == colIdx.end()) {
    140140      if (!notFound)
     
    167167  }
    168168
    169   if (notFound >= ((static_cast<double>(colNames.size())) * 0.5)) {
     169  if (notFound >= ((static_cast< double >(colNames.size())) * 0.5)) {
    170170    sprintf(printLine, "Warning: %d column names were not found (e.g. %s) while filling solution.", notFound, colNotFound);
    171171    model->messageHandler()->message(CBC_GENERAL, model->messages())
     
    195195      int numberObjects = model->numberObjects();
    196196      for (int i = 0; i < numberObjects; i++) {
    197         const OsiSOS *object = dynamic_cast<const OsiSOS *>(model->object(i));
     197        const OsiSOS *object = dynamic_cast< const OsiSOS * >(model->object(i));
    198198        if (object) {
    199199          int n = object->numberMembers();
     
    274274  /* some additional effort is needed to provide an integer solution */
    275275  if (lp->getFractionalIndices().size() > 0) {
    276     sprintf(printLine, "MIPStart solution provided values for %d of %d integer variables, %d variables are still fractional.", fixed, lp->getNumIntegers(), static_cast<int>(lp->getFractionalIndices().size()));
     276    sprintf(printLine, "MIPStart solution provided values for %d of %d integer variables, %d variables are still fractional.", fixed, lp->getNumIntegers(), static_cast< int >(lp->getFractionalIndices().size()));
    277277    model->messageHandler()->message(CBC_GENERAL, model->messages())
    278278      << printLine << CoinMessageEol;
  • trunk/Cbc/src/CbcMipStartIO.hpp

    r2465 r2467  
    1414   1 otherwise */
    1515int readMIPStart(CbcModel *model, const char *fileName,
    16   std::vector<std::pair<std::string, double>> &colValues,
     16  std::vector< std::pair< std::string, double > > &colValues,
    1717  double &solObj);
    1818
     
    2020   remaining variable values */
    2121int computeCompleteSolution(CbcModel *model,
    22   const std::vector<std::string> colNames,
    23   const std::vector<std::pair<std::string, double>> &colValues,
     22  const std::vector< std::string > colNames,
     23  const std::vector< std::pair< std::string, double > > &colValues,
    2424  double *sol, double &obj);
    2525
  • trunk/Cbc/src/CbcModel.cpp

    r2465 r2467  
    434434            else if (cost != objValue)
    435435              cost = -COIN_DBL_MAX;
    436             int gap = static_cast<int>(upper[iColumn] - lower[iColumn]);
     436            int gap = static_cast< int >(upper[iColumn] - lower[iColumn]);
    437437            if (gap > 1) {
    438438              numberGeneralIntegerObj++;
     
    506506        int highPriority = (branchOnSatisfied) ? -999 : 100;
    507507        for (int i = 0; i < numberObjects_; i++) {
    508           CbcSimpleInteger *thisOne = dynamic_cast<CbcSimpleInteger *>(object_[i]);
     508          CbcSimpleInteger *thisOne = dynamic_cast< CbcSimpleInteger * >(object_[i]);
    509509          object_[i]->setPriority(1000);
    510510          if (thisOne) {
     
    517517#ifdef COIN_HAS_CLP
    518518      OsiClpSolverInterface *clpSolver
    519         = dynamic_cast<OsiClpSolverInterface *>(solver_);
     519        = dynamic_cast< OsiClpSolverInterface * >(solver_);
    520520      if (clpSolver && createFake) {
    521521        // Create artificial objective to be used when all else fixed
     
    592592#endif
    593593        for (int i = 0; i < numberObjects_; i++) {
    594           CbcSimpleInteger *obj = dynamic_cast<CbcSimpleInteger *>(object_[i]);
     594          CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(object_[i]);
    595595          if (obj) {
    596596            int iColumn = obj->columnNumber();
     
    10151015          double value = objValue * multiplier;
    10161016          if (value < 2.1e9) {
    1017             int nearest = static_cast<int>(floor(value + 0.5));
     1017            int nearest = static_cast< int >(floor(value + 0.5));
    10181018            if (fabs(value - floor(value + 0.5)) > 1.0e-8) {
    10191019              increment = 0;
     
    10451045      if (bigIntegers) {
    10461046        // allow for 1.0
    1047         increment = gcd(increment, static_cast<int>(multiplier));
     1047        increment = gcd(increment, static_cast< int >(multiplier));
    10481048        value = increment;
    10491049      }
     
    14431443#ifdef COIN_HAS_CLP
    14441444    OsiClpSolverInterface *clpSolver
    1445       = dynamic_cast<OsiClpSolverInterface *>(copy1);
     1445      = dynamic_cast< OsiClpSolverInterface * >(copy1);
    14461446    if (false && clpSolver) {
    14471447      numberRows = clpSolver->getNumRows();
     
    16451645  }
    16461646  int saveMoreSpecialOptions = moreSpecialOptions_;
    1647   if (dynamic_cast<CbcTreeLocal *>(tree_))
     1647  if (dynamic_cast< CbcTreeLocal * >(tree_))
    16481648    specialOptions_ |= 4096 + 8192;
    16491649#ifdef COIN_HAS_CLP
    16501650  {
    16511651    OsiClpSolverInterface *clpSolver
    1652       = dynamic_cast<OsiClpSolverInterface *>(solver_);
     1652      = dynamic_cast< OsiClpSolverInterface * >(solver_);
    16531653    if (clpSolver) {
    16541654      // pass in disaster handler
     
    17161716        nOrig = CoinMax(nOrig, originalColumns[numberColumns - 1] + 1);
    17171717        // try and redo debugger
    1718         OsiRowCutDebugger *debugger = const_cast<OsiRowCutDebugger *>(solver_->getRowCutDebuggerAlways());
     1718        OsiRowCutDebugger *debugger = const_cast< OsiRowCutDebugger * >(solver_->getRowCutDebuggerAlways());
    17191719        if (debugger) {
    17201720          if (numberColumns <= debugger->numberColumns())
     
    17551755          if (temp[jColumn] >= 0) {
    17561756            int iObject = temp[jColumn];
    1757             CbcSimpleInteger *obj = dynamic_cast<CbcSimpleInteger *>(originalObject[iObject]);
     1757            CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(originalObject[iObject]);
    17581758            if (obj)
    17591759              numberOldIntegers++;
     
    17891789          if (temp[jColumn] >= 0) {
    17901790            int iObject = temp[jColumn];
    1791             CbcSimpleInteger *obj = dynamic_cast<CbcSimpleInteger *>(originalObject[iObject]);
     1791            CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(originalObject[iObject]);
    17921792            if (obj) {
    17931793              object_[numberIntegers_] = originalObject[iObject]->clone();
     
    18091809          if (temp[jColumn] >= 0) {
    18101810            int iObject = temp[jColumn];
    1811             CbcSimpleInteger *obj = dynamic_cast<CbcSimpleInteger *>(originalObject[iObject]);
     1811            CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(originalObject[iObject]);
    18121812            if (!obj) {
    18131813              object_[numberObjects_] = originalObject[iObject]->clone();
    18141814              // redo ids etc
    1815               CbcObject *obj = dynamic_cast<CbcObject *>(object_[numberObjects_]);
     1815              CbcObject *obj = dynamic_cast< CbcObject * >(object_[numberObjects_]);
    18161816              assert(obj);
    18171817              obj->redoSequenceEtc(this, numberColumns, originalColumns);
     
    18281828#ifdef JJF_ZERO
    18291829            // redo ids etc
    1830             CbcObject *obj = dynamic_cast<CbcObject *>(object_[numberObjects_]);
     1830            CbcObject *obj = dynamic_cast< CbcObject * >(object_[numberObjects_]);
    18311831            assert(obj);
    18321832            obj->redoSequenceEtc(this, numberColumns, originalColumns);
     
    18441844        const int *originalColumns = process->originalColumns();
    18451845        // try and redo debugger
    1846         OsiRowCutDebugger *debugger = const_cast<OsiRowCutDebugger *>(solver_->getRowCutDebuggerAlways());
     1846        OsiRowCutDebugger *debugger = const_cast< OsiRowCutDebugger * >(solver_->getRowCutDebuggerAlways());
    18471847        if (debugger)
    18481848          debugger->redoSolution(numberColumns, originalColumns);
     
    19571957    // set all unset ones
    19581958    for (int iObject = 0; iObject < numberObjects_; iObject++) {
    1959       CbcObject *obj = dynamic_cast<CbcObject *>(object_[iObject]);
     1959      CbcObject *obj = dynamic_cast< CbcObject * >(object_[iObject]);
    19601960      if (obj && !obj->preferredWay())
    19611961        obj->setPreferredWay(preferredWay_);
     
    19681968  synchronizeModel();
    19691969  if (!solverCharacteristics_) {
    1970     OsiBabSolver *solverCharacteristics = dynamic_cast<OsiBabSolver *>(solver_->getAuxiliaryInfo());
     1970    OsiBabSolver *solverCharacteristics = dynamic_cast< OsiBabSolver * >(solver_->getAuxiliaryInfo());
    19711971    if (solverCharacteristics) {
    19721972      solverCharacteristics_ = solverCharacteristics;
     
    19751975      OsiBabSolver defaultC;
    19761976      solver_->setAuxiliaryInfo(&defaultC);
    1977       solverCharacteristics_ = dynamic_cast<OsiBabSolver *>(solver_->getAuxiliaryInfo());
     1977      solverCharacteristics_ = dynamic_cast< OsiBabSolver * >(solver_->getAuxiliaryInfo());
    19781978    }
    19791979  }
     
    19951995  {
    19961996    OsiClpSolverInterface *clpSolver
    1997       = dynamic_cast<OsiClpSolverInterface *>(solver_);
     1997      = dynamic_cast< OsiClpSolverInterface * >(solver_);
    19981998    if (clpSolver) {
    19991999      ClpSimplex *clpSimplex = clpSolver->getModelPtr();
     
    20262026    int numberOdd = 0;
    20272027    for (int i = 0; i < numberObjects_; i++) {
    2028       CbcSimpleInteger *obj = dynamic_cast<CbcSimpleInteger *>(object_[i]);
     2028      CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(object_[i]);
    20292029      if (!obj)
    20302030        numberOdd++;
     
    21762176    if (numberOriginalObjects) {
    21772177      for (int iObject = 0; iObject < numberObjects_; iObject++) {
    2178         CbcObject *obj = dynamic_cast<CbcObject *>(object_[iObject]);
     2178        CbcObject *obj = dynamic_cast< CbcObject * >(object_[iObject]);
    21792179        if (obj) {
    2180           CbcSimpleInteger *obj2 = dynamic_cast<CbcSimpleInteger *>(obj);
     2180          CbcSimpleInteger *obj2 = dynamic_cast< CbcSimpleInteger * >(obj);
    21812181          if (obj2) {
    21822182            // back to Osi land
     
    21842184            delete obj;
    21852185          } else {
    2186             OsiSimpleInteger *obj3 = dynamic_cast<OsiSimpleInteger *>(obj);
     2186            OsiSimpleInteger *obj3 = dynamic_cast< OsiSimpleInteger * >(obj);
    21872187            if (!obj3) {
    2188               OsiSOS *obj4 = dynamic_cast<OsiSOS *>(obj);
     2188              OsiSOS *obj4 = dynamic_cast< OsiSOS * >(obj);
    21892189              if (!obj4) {
    2190                 CbcSOS *obj5 = dynamic_cast<CbcSOS *>(obj);
     2190                CbcSOS *obj5 = dynamic_cast< CbcSOS * >(obj);
    21912191                if (obj5) {
    21922192                  // back to Osi land
     
    22322232      if (!object_[i]->canDoHeuristics())
    22332233        numberOdd++;
    2234       CbcSOS *obj = dynamic_cast<CbcSOS *>(object_[i]);
     2234      CbcSOS *obj = dynamic_cast< CbcSOS * >(object_[i]);
    22352235      if (obj)
    22362236        numberSOS++;
     
    23362336#ifdef COIN_HAS_CLP
    23372337    OsiClpSolverInterface *clpSolver
    2338       = dynamic_cast<OsiClpSolverInterface *>(solver_);
     2338      = dynamic_cast< OsiClpSolverInterface * >(solver_);
    23392339    if (clpSolver) {
    23402340      int specialOptions = clpSolver->getModelPtr()->specialOptions();
     
    24212421    // pass tolerance and increment to solver
    24222422    OsiClpSolverInterface *clpSolver
    2423       = dynamic_cast<OsiClpSolverInterface *>(solver_);
     2423      = dynamic_cast< OsiClpSolverInterface * >(solver_);
    24242424    if (clpSolver)
    24252425      clpSolver->setStuff(getIntegerTolerance(), getCutoffIncrement());
     
    24542454    */
    24552455  CbcCompareDefault *compareActual
    2456     = dynamic_cast<CbcCompareDefault *>(nodeCompare_);
     2456    = dynamic_cast< CbcCompareDefault * >(nodeCompare_);
    24572457  if (compareActual) {
    24582458    compareActual->setBestPossible(direction * solver_->getObjValue());
     
    25842584        for (int i = 0; i < numberHeuristics_; i++) {
    25852585          CbcHeuristicRINS *rins
    2586             = dynamic_cast<CbcHeuristicRINS *>(heuristic_[i]);
     2586            = dynamic_cast< CbcHeuristicRINS * >(heuristic_[i]);
    25872587          if (rins) {
    25882588            rins->setLastNode(-100);
     
    26292629      while (time >= COIN_INT_MAX)
    26302630        time *= 0.5;
    2631       newSeed = static_cast<unsigned int>(time);
     2631      newSeed = static_cast< unsigned int >(time);
    26322632    } else if (newSeed < 0) {
    26332633      newSeed = 123456789;
    26342634#ifdef COIN_HAS_CLP
    26352635      OsiClpSolverInterface *clpSolver
    2636         = dynamic_cast<OsiClpSolverInterface *>(solver_);
     2636        = dynamic_cast< OsiClpSolverInterface * >(solver_);
    26372637      if (clpSolver) {
    26382638        newSeed += clpSolver->getModelPtr()->randomNumberGenerator()->getSeed();
     
    26402640#endif
    26412641    }
    2642     CoinWarmStartBasis *basis = dynamic_cast<CoinWarmStartBasis *>(solver_->getEmptyWarmStart());
     2642    CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver_->getEmptyWarmStart());
    26432643    for (int i = 0; i < numberModels; i++) {
    26442644      rootModels[i] = new CbcModel(*this);
     
    26592659#ifdef COIN_HAS_CLP
    26602660      OsiClpSolverInterface *clpSolver
    2661         = dynamic_cast<OsiClpSolverInterface *>(rootModels[i]->solver_);
     2661        = dynamic_cast< OsiClpSolverInterface * >(rootModels[i]->solver_);
    26622662#define NEW_RANDOM_BASIS
    26632663#ifdef NEW_RANDOM_BASIS
     
    26802680          for (int iThrow = 0; iThrow < throwOut; iThrow++) {
    26812681            double random = simplex->randomNumberGenerator()->randomDouble();
    2682             int iStart = static_cast<int>(random * numberRows);
     2682            int iStart = static_cast< int >(random * numberRows);
    26832683            for (int j = iStart; j < numberRows; j++) {
    26842684              if (simplex->getRowStatus(j) != ClpSimplex::basic) {
     
    26912691#else
    26922692            double random = simplex->randomNumberGenerator()->randomDouble();
    2693             int bias = static_cast<int>(random * (numberIterations / 4));
     2693            int bias = static_cast< int >(random * (numberIterations / 4));
    26942694            simplex->setMaximumIterations(numberIterations / 2 + bias);
    26952695            simplex->primal();
     
    30313031                  initialCuts++;
    30323032                  nRead = fread(elements, sizeof(double), numberEntries + 2, fp);
    3033                   if (nRead != static_cast<size_t>(numberEntries + 2))
     3033                  if (nRead != static_cast< size_t >(numberEntries + 2))
    30343034                    throw("Error in fread");
    30353035                  nRead = fread(indices, sizeof(int), numberEntries, fp);
    3036                   if (nRead != static_cast<size_t>(numberEntries))
     3036                  if (nRead != static_cast< size_t >(numberEntries))
    30373037                    throw("Error in fread");
    30383038                  if (randomNumber > threshold) {
     
    31253125                initialCuts++;
    31263126                nRead = fread(elements, sizeof(double), numberEntries + 2, fp);
    3127                 if (nRead != static_cast<size_t>(numberEntries + 2))
     3127                if (nRead != static_cast< size_t >(numberEntries + 2))
    31283128                  throw("Error in fread");
    31293129                nRead = fread(indices, sizeof(int), numberEntries, fp);
    3130                 if (nRead != static_cast<size_t>(numberEntries))
     3130                if (nRead != static_cast< size_t >(numberEntries))
    31313131                  throw("Error in fread");
    31323132              } else {
     
    31683168              throw("Error in fwrite");
    31693169            nWrite = fwrite(elements, sizeof(double), n + 2, fp);
    3170             if (nWrite != static_cast<size_t>(n + 2))
     3170            if (nWrite != static_cast< size_t >(n + 2))
    31713171              throw("Error in fwrite");
    31723172            nWrite = fwrite(indices, sizeof(int), n, fp);
    3173             if (nWrite != static_cast<size_t>(n))
     3173            if (nWrite != static_cast< size_t >(n))
    31743174              throw("Error in fwrite");
    31753175          }
     
    32773277              for (int i = 0; i < numberHeuristics_; i++) {
    32783278                CbcHeuristicRINS *rins
    3279                   = dynamic_cast<CbcHeuristicRINS *>(heuristic_[i]);
     3279                  = dynamic_cast< CbcHeuristicRINS * >(heuristic_[i]);
    32803280                if (rins) {
    32813281                  rins->setLastNode(-100);
     
    33493349  if ((moreSpecialOptions_ & 2097152) != 0 && !parentModel_ && feasible) {
    33503350    OsiClpSolverInterface *clpSolver
    3351       = dynamic_cast<OsiClpSolverInterface *>(solver_);
     3351      = dynamic_cast< OsiClpSolverInterface * >(solver_);
    33523352    if (clpSolver)
    33533353      resolveClp(clpSolver, 0);
     
    33863386    double time1 = CoinCpuTime();
    33873387    OsiClpSolverInterface *clpSolver
    3388       = dynamic_cast<OsiClpSolverInterface *>(solver_);
     3388      = dynamic_cast< OsiClpSolverInterface * >(solver_);
    33893389    OsiCpxSolverInterface cpxSolver;
    33903390    double direction = clpSolver->getObjSense();
     
    35333533      // But make sure position is correct
    35343534      OsiObject *obj2 = object_[numberObjects_];
    3535       obj = dynamic_cast<CbcObject *>(obj2);
     3535      obj = dynamic_cast< CbcObject * >(obj2);
    35363536      assert(obj);
    35373537      obj->setPosition(numberObjects_);
     
    35423542  if (true) {
    35433543    OsiClpSolverInterface *clpSolver
    3544       = dynamic_cast<OsiClpSolverInterface *>(solver_);
     3544      = dynamic_cast< OsiClpSolverInterface * >(solver_);
    35453545    if (clpSolver && !parentModel_) {
    35463546      ClpSimplex *clpSimplex = clpSolver->getModelPtr();
     
    35923592#ifdef COIN_HAS_CLP
    35933593    OsiClpSolverInterface *clpSolver
    3594       = dynamic_cast<OsiClpSolverInterface *>(solver_);
     3594      = dynamic_cast< OsiClpSolverInterface * >(solver_);
    35953595    if (clpSolver) {
    35963596      if (getCutoff() > 1.0e20) {
     
    36373637      const double *saveUpper = continuousSolver_->getColUpper();
    36383638      for (int i = 0; i < numberObjects_; i++) {
    3639         const CbcSimpleInteger *thisOne = dynamic_cast<const CbcSimpleInteger *>(object_[i]);
     3639        const CbcSimpleInteger *thisOne = dynamic_cast< const CbcSimpleInteger * >(object_[i]);
    36403640        if (thisOne) {
    36413641          int iColumn = thisOne->columnNumber();
     
    36663666        double direction = solver->getObjSense();
    36673667        solver->setDblParam(OsiDualObjectiveLimit, 1.0e50 * direction);
    3668         CoinWarmStartBasis *basis = dynamic_cast<CoinWarmStartBasis *>(solver->getEmptyWarmStart());
     3668        CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver->getEmptyWarmStart());
    36693669        solver->setWarmStart(basis);
    36703670        delete basis;
     
    40554055          generator_[numberCutGenerators_ - 1]->setTiming(true);
    40564056          for (int i = 0; i < numberCutGenerators_; i++) {
    4057             CglKnapsackCover *cutGen = dynamic_cast<CglKnapsackCover *>(generator_[i]->generator());
     4057            CglKnapsackCover *cutGen = dynamic_cast< CglKnapsackCover * >(generator_[i]->generator());
    40584058            if (cutGen) {
    40594059              cutGen->createCliques(*fake, 2, 200, false);
     
    41074107               "(active only) %d\n",
    41084108          numberRowsAtContinuous_ + numberNewCuts_ + numberOldActiveCuts_);
    4109         const CoinWarmStartBasis *debugws = dynamic_cast<const CoinWarmStartBasis *>(solver_->getWarmStart());
     4109        const CoinWarmStartBasis *debugws = dynamic_cast< const CoinWarmStartBasis * >(solver_->getWarmStart());
    41104110        debugws->print();
    41114111        delete debugws;
     
    41184118    if (lastws)
    41194119      delete lastws;
    4120     lastws = dynamic_cast<CoinWarmStartBasis *>(solver_->getWarmStart());
     4120    lastws = dynamic_cast< CoinWarmStartBasis * >(solver_->getWarmStart());
    41214121  }
    41224122  /*
     
    41544154      // save pointer to root node - so can pick up bounds
    41554155      if (!topOfTree_)
    4156         topOfTree_ = dynamic_cast<CbcFullNodeInfo *>(newNode->nodeInfo());
     4156        topOfTree_ = dynamic_cast< CbcFullNodeInfo * >(newNode->nodeInfo());
    41574157      if (statistics_) {
    41584158        if (numberNodes2_ == maximumStatistics_) {
     
    42094209  {
    42104210    OsiClpSolverInterface *clpSolver
    4211       = dynamic_cast<OsiClpSolverInterface *>(solver_);
     4211      = dynamic_cast< OsiClpSolverInterface * >(solver_);
    42124212    if (clpSolver && !parentModel_) {
    42134213      clpSolver->computeLargestAway();
     
    42264226    */
    42274227  if (solver_->getRowCutDebuggerAlways()) {
    4228     OsiRowCutDebugger *debuggerX = const_cast<OsiRowCutDebugger *>(solver_->getRowCutDebuggerAlways());
     4228    OsiRowCutDebugger *debuggerX = const_cast< OsiRowCutDebugger * >(solver_->getRowCutDebuggerAlways());
    42294229    const OsiRowCutDebugger *debugger = solver_->getRowCutDebugger();
    42304230    if (!debugger) {
     
    43014301      for (i = 0; i < numberObjects_; i++) {
    43024302        OsiObject *object = object_[i];
    4303         CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast<CbcSimpleIntegerDynamicPseudoCost *>(object);
     4303        CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object);
    43044304        if (dynamicObject) {
    43054305          numberInts++;
     
    43614361      }
    43624362      if (numberUp)
    4363         averageUp /= static_cast<double>(numberUp);
     4363        averageUp /= static_cast< double >(numberUp);
    43644364      else
    43654365        averageUp = 0.0;
    43664366      if (numberDown)
    4367         averageDown /= static_cast<double>(numberDown);
     4367        averageDown /= static_cast< double >(numberDown);
    43684368      else
    43694369        averageDown = 0.0;
     
    43744374          neverBranchedDown, neverBranchedUp);
    43754375      printf("down average %g times (%d infeasible) average increase %g min/max times (%d,%d)\n",
    4376         static_cast<double>(numberDown2) / numberDown, infeasibleTimesDown, averageDown,
     4376        static_cast< double >(numberDown2) / numberDown, infeasibleTimesDown, averageDown,
    43774377        minTimesDown, maxTimesDown);
    43784378      printf("up average %g times (%d infeasible) average increase %g min/max times (%d,%d)\n",
    4379         static_cast<double>(numberUp2) / numberUp, infeasibleTimesUp, averageUp,
     4379        static_cast< double >(numberUp2) / numberUp, infeasibleTimesUp, averageUp,
    43804380        minTimesUp, maxTimesUp);
    43814381    }
     
    44064406#ifdef COIN_HAS_CLP
    44074407      OsiClpSolverInterface *clpSolver
    4408         = dynamic_cast<OsiClpSolverInterface *>(solver_);
     4408        = dynamic_cast< OsiClpSolverInterface * >(solver_);
    44094409      if (clpSolver && ((specialOptions_ & 131072) == 0) && true) {
    44104410        ClpSimplex *simplex = clpSolver->getModelPtr();
     
    46144614      if (!parallelMode()) {
    46154615        if (kNode == DIVE_WHEN + 1 || numberConsecutiveInfeasible > 1) {
    4616           CbcCompareDefault *compare = dynamic_cast<CbcCompareDefault *>(nodeCompare_);
     4616          CbcCompareDefault *compare = dynamic_cast< CbcCompareDefault * >(nodeCompare_);
    46174617          // Don't interfere if user has replaced the compare function.
    46184618          if (compare) {
     
    50755075  if (doStatistics == 100) {
    50765076    for (int i = 0; i < numberObjects_; i++) {
    5077       CbcSimpleIntegerDynamicPseudoCost *obj = dynamic_cast<CbcSimpleIntegerDynamicPseudoCost *>(object_[i]);
     5077      CbcSimpleIntegerDynamicPseudoCost *obj = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object_[i]);
    50785078      if (obj)
    50795079        obj->print();
     
    52005200    // Now print
    52015201    if (numberSolutions)
    5202       averageSolutionDepth /= static_cast<double>(numberSolutions);
     5202      averageSolutionDepth /= static_cast< double >(numberSolutions);
    52035203    int numberSolved = numberNodes2_ - numberCutoff;
    52045204    double averageNumberIterations2 = numberIterations_ - averageNumberIterations1
    52055205      - numberIterationsAtContinuous;
    52065206    if (numberCutoff) {
    5207       averageCutoffDepth /= static_cast<double>(numberCutoff);
    5208       averageNumberIterations2 /= static_cast<double>(numberCutoff);
     5207      averageCutoffDepth /= static_cast< double >(numberCutoff);
     5208      averageNumberIterations2 /= static_cast< double >(numberCutoff);
    52095209    }
    52105210    if (numberNodes2_)
    5211       averageValue /= static_cast<double>(numberNodes2_);
     5211      averageValue /= static_cast< double >(numberNodes2_);
    52125212    if (numberSolved) {
    5213       averageNumberIterations1 /= static_cast<double>(numberSolved);
    5214       averageSolvedDepth /= static_cast<double>(numberSolved);
     5213      averageNumberIterations1 /= static_cast< double >(numberSolved);
     5214      averageSolvedDepth /= static_cast< double >(numberSolved);
    52155215    }
    52165216    printf("%d solution(s) were found (by branching) at an average depth of %g\n",
     
    52235223      numberSolved, averageSolvedDepth, averageNumberIterations1);
    52245224    if (numberDown) {
    5225       averageInfDown /= static_cast<double>(numberDown);
    5226       averageObjDown /= static_cast<double>(numberDown);
     5225      averageInfDown /= static_cast< double >(numberDown);
     5226      averageObjDown /= static_cast< double >(numberDown);
    52275227    }
    52285228    printf("Down %d nodes (%d first, %d second) - %d cutoff, rest decrease numinf %g increase obj %g\n",
     
    52305230      averageInfDown, averageObjDown);
    52315231    if (numberUp) {
    5232       averageInfUp /= static_cast<double>(numberUp);
    5233       averageObjUp /= static_cast<double>(numberUp);
     5232      averageInfUp /= static_cast< double >(numberUp);
     5233      averageObjUp /= static_cast< double >(numberUp);
    52345234    }
    52355235    printf("Up %d nodes (%d first, %d second) - %d cutoff, rest decrease numinf %g increase obj %g\n",
     
    53455345  {
    53465346    OsiClpSolverInterface *clpSolver
    5347       = dynamic_cast<OsiClpSolverInterface *>(solver_);
     5347      = dynamic_cast< OsiClpSolverInterface * >(solver_);
    53485348    if (clpSolver) {
    53495349      // Possible restore of pivot method
     
    54135413  {
    54145414    OsiClpSolverInterface *clpSolver
    5415       = dynamic_cast<OsiClpSolverInterface *>(solver_);
     5415      = dynamic_cast< OsiClpSolverInterface * >(solver_);
    54165416    if (clpSolver)
    5417       clpSolver->setFakeObjective(reinterpret_cast<double *>(NULL));
     5417      clpSolver->setFakeObjective(reinterpret_cast< double * >(NULL));
    54185418  }
    54195419#endif
     
    54315431  checkModel();
    54325432  if (!solverCharacteristics_) {
    5433     OsiBabSolver *solverCharacteristics = dynamic_cast<OsiBabSolver *>(solver_->getAuxiliaryInfo());
     5433    OsiBabSolver *solverCharacteristics = dynamic_cast< OsiBabSolver * >(solver_->getAuxiliaryInfo());
    54345434    if (solverCharacteristics) {
    54355435      solverCharacteristics_ = solverCharacteristics;
     
    54385438      OsiBabSolver defaultC;
    54395439      solver_->setAuxiliaryInfo(&defaultC);
    5440       solverCharacteristics_ = dynamic_cast<OsiBabSolver *>(solver_->getAuxiliaryInfo());
     5440      solverCharacteristics_ = dynamic_cast< OsiBabSolver * >(solver_->getAuxiliaryInfo());
    54415441    }
    54425442  }
     
    54825482        "getEmptyBasis", "CbcModel");
    54835483    }
    5484     emptyBasis = dynamic_cast<CoinWarmStartBasis *>(solver_->getEmptyWarmStart());
     5484    emptyBasis = dynamic_cast< CoinWarmStartBasis * >(solver_->getEmptyWarmStart());
    54855485    if (emptyBasis == 0) {
    54865486      throw CoinError(
     
    54895489    }
    54905490    emptyBasis->setSize(0, 0);
    5491     emptyWarmStart_ = dynamic_cast<CoinWarmStart *>(emptyBasis);
     5491    emptyWarmStart_ = dynamic_cast< CoinWarmStart * >(emptyBasis);
    54925492  }
    54935493  /*
    54945494      Clone the empty basis object, resize it as requested, and return.
    54955495    */
    5496   emptyBasis = dynamic_cast<CoinWarmStartBasis *>(emptyWarmStart_->clone());
     5496  emptyBasis = dynamic_cast< CoinWarmStartBasis * >(emptyWarmStart_->clone());
    54975497  assert(emptyBasis);
    54985498  if (ns != 0 || na != 0)
     
    61576157      for (i = 0; i < numberObjects_; i++) {
    61586158        object_[i] = (rhs.object_[i])->clone();
    6159         CbcObject *obj = dynamic_cast<CbcObject *>(object_[i]);
     6159        CbcObject *obj = dynamic_cast< CbcObject * >(object_[i]);
    61606160        // Could be OsiObjects
    61616161        if (obj)
     
    67986798    for (int i = 0; i < numberCutGenerators_; i++) {
    67996799      CglImplication *cutGen;
    6800       cutGen = dynamic_cast<CglImplication *>(generator_[i]->generator());
     6800      cutGen = dynamic_cast< CglImplication * >(generator_[i]->generator());
    68016801      if (!cutGen) {
    68026802        generator_[n] = generator_[i];
     
    68066806        cutGen->setProbingInfo(NULL);
    68076807        delete generator_[i];
    6808         cutGen = dynamic_cast<CglImplication *>(virginGenerator_[i]->generator());
     6808        cutGen = dynamic_cast< CglImplication * >(virginGenerator_[i]->generator());
    68096809        assert(cutGen);
    68106810        cutGen->setProbingInfo(NULL);
     
    75957595  if (!defaultHandler) {
    75967596    OsiClpSolverInterface *solver;
    7597     solver = dynamic_cast<OsiClpSolverInterface *>(solver_);
     7597    solver = dynamic_cast< OsiClpSolverInterface * >(solver_);
    75987598    if (solver) {
    75997599      solver->passInMessageHandler(handler_);
    76007600      solver->getModelPtr()->passInMessageHandler(handler_);
    76017601    }
    7602     solver = dynamic_cast<OsiClpSolverInterface *>(continuousSolver_);
     7602    solver = dynamic_cast< OsiClpSolverInterface * >(continuousSolver_);
    76037603    if (solver) {
    76047604      solver->passInMessageHandler(handler_);
     
    76407640#ifdef COIN_HAS_CLP
    76417641  OsiClpSolverInterface *clpSolver
    7642     = dynamic_cast<OsiClpSolverInterface *>(solver_);
     7642    = dynamic_cast< OsiClpSolverInterface * >(solver_);
    76437643  ClpSimplex *clpSimplex = NULL;
    76447644  if (clpSolver)
     
    77707770#ifdef COIN_HAS_CLP
    77717771  OsiClpSolverInterface *clpSolver
    7772     = dynamic_cast<OsiClpSolverInterface *>(solver_);
     7772    = dynamic_cast< OsiClpSolverInterface * >(solver_);
    77737773  int saveClpOptions = 0;
    77747774  if (clpSolver)
     
    79867986  if (node && branchingMethod_) {
    79877987    OsiBranchingObject *bobj = node->modifiableBranchingObject();
    7988     CbcBranchingObject *cbcobj = dynamic_cast<CbcBranchingObject *>(bobj);
     7988    CbcBranchingObject *cbcobj = dynamic_cast< CbcBranchingObject * >(bobj);
    79897989    if (cbcobj && cbcobj->object()) {
    79907990      CbcObject *object = cbcobj->object();
    79917991      CbcObjectUpdateData update = object->createUpdateInformation(solver_, node, cbcobj);
    79927992      // have to compute object number as not saved
    7993       CbcSimpleInteger *simpleObject = static_cast<CbcSimpleInteger *>(object);
     7993      CbcSimpleInteger *simpleObject = static_cast< CbcSimpleInteger * >(object);
    79947994      int iObject = simpleObject->position();
    79957995#ifndef NDEBUG
     
    79977997      int jObject;
    79987998      for (jObject = 0; jObject < numberObjects_; jObject++) {
    7999         simpleObject = static_cast<CbcSimpleInteger *>(object_[jObject]);
     7999        simpleObject = static_cast< CbcSimpleInteger * >(object_[jObject]);
    80008000        if (simpleObject->columnNumber() == iColumn)
    80018001          break;
     
    80128012      // update here
    80138013      {
    8014         CbcObject *object = dynamic_cast<CbcObject *>(update.object_);
     8014        CbcObject *object = dynamic_cast< CbcObject * >(update.object_);
    80158015        if (object)
    80168016          object->updateInformation(update);
     
    80288028        double objectiveChange = lastObjective - objectiveValue;
    80298029        if (objectiveChange > 1.0e-5) {
    8030           CbcIntegerBranchingObject *branch = dynamic_cast<CbcIntegerBranchingObject *>(cbcobj);
     8030          CbcIntegerBranchingObject *branch = dynamic_cast< CbcIntegerBranchingObject * >(cbcobj);
    80318031          assert(branch);
    80328032          if (way < 0) {
     
    80678067#endif
    80688068    } else {
    8069       OsiIntegerBranchingObject *obj = dynamic_cast<OsiIntegerBranchingObject *>(bobj);
     8069      OsiIntegerBranchingObject *obj = dynamic_cast< OsiIntegerBranchingObject * >(bobj);
    80708070      if (obj) {
    80718071        const OsiObject *object = obj->originalObject();
     
    81188118        solver_->writeMpsNative("infeas.mps", NULL, NULL, 2);
    81198119        solver_->getRowCutDebuggerAlways()->printOptimalSolution(*solver_);
    8120         CoinWarmStartBasis *slack = dynamic_cast<CoinWarmStartBasis *>(solver_->getEmptyWarmStart());
     8120        CoinWarmStartBasis *slack = dynamic_cast< CoinWarmStartBasis * >(solver_->getEmptyWarmStart());
    81218121        solver_->setWarmStart(slack);
    81228122        delete slack;
     
    82868286        int numberColumns = solver_->getNumCols();
    82878287        CoinBigIndex maximumAdd = CoinMax(numberElements / 10,
    8288                                     static_cast<CoinBigIndex>(2 * numberColumns))
     8288                                    static_cast< CoinBigIndex >(2 * numberColumns))
    82898289          + 100;
    82908290        double *violations = new double[numberCuts];
     
    85078507        phase_ = 4;
    85088508        CbcTreeLocal *tree
    8509           = dynamic_cast<CbcTreeLocal *>(tree_);
     8509          = dynamic_cast< CbcTreeLocal * >(tree_);
    85108510        if (tree)
    85118511          tree->passInSolution(bestSolution_, heuristicValue);
     
    86838683        }
    86848684        solver_->applyRowCuts(numberToAdd, addCuts);
    8685         CoinWarmStartBasis *basis = dynamic_cast<CoinWarmStartBasis *>(solver_->getWarmStart());
     8685        CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver_->getWarmStart());
    86868686        assert(basis != NULL); // make sure not volume
    86878687        /* dylp bug
     
    87968796                nBadPasses++;
    87978797              } else {
    8798                 goodDrop = (thisObj - cut_obj[j]) / static_cast<double>(nBadPasses + 1);
     8798                goodDrop = (thisObj - cut_obj[j]) / static_cast< double >(nBadPasses + 1);
    87998799                break;
    88008800              }
     
    88088808            //minimumDrop = CoinMax(1.5*minimumDrop,1.0e-5*fabs(thisObj));
    88098809            double test = 0.1 * minimumDrop;
    8810             double goodDrop = (thisObj - cut_obj[0]) / static_cast<double>(CUT_HISTORY);
     8810            double goodDrop = (thisObj - cut_obj[0]) / static_cast< double >(CUT_HISTORY);
    88118811            double objValue = thisObj;
    88128812            for (int j = CUT_HISTORY - 1; j >= 0; j--) {
     
    89978997    int numberAdded = numberRows - numberRowsAtContinuous_;
    89988998    if (numberAdded) {
    8999       CoinWarmStartBasis *basis = dynamic_cast<CoinWarmStartBasis *>(solver_->getWarmStart());
     8999      CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver_->getWarmStart());
    90009000      assert(basis != NULL);
    90019001      int *added = new int[numberAdded];
     
    91119111    int numberRowsAdded = solver_->getNumRows() - numberRowsAtStart;
    91129112    CoinBigIndex numberElementsAdded = solver_->getNumElements() - numberElementsAtStart;
    9113     double densityOld = static_cast<double>(numberElementsAtStart) / static_cast<double>(numberRowsAtStart);
    9114     double densityNew = numberRowsAdded ? (static_cast<double>(numberElementsAdded)) / static_cast<double>(numberRowsAdded)
     9113    double densityOld = static_cast< double >(numberElementsAtStart) / static_cast< double >(numberRowsAtStart);
     9114    double densityNew = numberRowsAdded ? (static_cast< double >(numberElementsAdded)) / static_cast< double >(numberRowsAdded)
    91159115                                        : 0.0;
    91169116    /*
     
    93089308        */
    93099309    if (!numberNodes_) {
    9310       double value = CoinMax(minimumDrop_, 0.005 * (thisObjective - startObjective) / static_cast<double>(currentPassNumber_));
     9310      double value = CoinMax(minimumDrop_, 0.005 * (thisObjective - startObjective) / static_cast< double >(currentPassNumber_));
    93119311      if (numberColumns < 200)
    93129312        value = CoinMax(minimumDrop_, 0.1 * value);
     
    93549354        */
    93559355    int iProbing = -1;
    9356     double smallProblem = (0.2 * totalCuts) / static_cast<double>(numberActiveGenerators + 1.0e-100);
     9356    double smallProblem = (0.2 * totalCuts) / static_cast< double >(numberActiveGenerators + 1.0e-100);
    93579357    for (i = 0; i < numberCutGenerators_; i++) {
    93589358      int howOften = generator_[i]->howOften();
     
    93729372            */
    93739373      bool probingWasOnBut = false;
    9374       CglProbing *probing = dynamic_cast<CglProbing *>(generator_[i]->generator());
     9374      CglProbing *probing = dynamic_cast< CglProbing * >(generator_[i]->generator());
    93759375      if (probing && !numberNodes_) {
    93769376        if (generator_[i]->numberCutsInTotal()) {
    93779377          // If large number of probing - can be biased
    9378           smallProblem = (0.2 * (totalCuts - generator_[i]->numberCutsInTotal())) / static_cast<double>(numberActiveGenerators - 1 + 1.0e-100);
     9378          smallProblem = (0.2 * (totalCuts - generator_[i]->numberCutsInTotal())) / static_cast< double >(numberActiveGenerators - 1 + 1.0e-100);
    93799379        }
    93809380        iProbing = i;
     
    94919491                            */
    94929492              if (generator_[i]->whatDepth() < 0 || howOften != -1) {
    9493                 int k = static_cast<int>(sqrt(smallProblem / thisCuts));
     9493                int k = static_cast< int >(sqrt(smallProblem / thisCuts));
    94949494                /*
    94959495                                  Not objective improvement, set to new frequency, otherwise turn off.
     
    95809580      // increment cut counts
    95819581      generator_[i]->incrementNumberCutsActive(count[i]);
    9582       CglStored *stored = dynamic_cast<CglStored *>(generator_[i]->generator());
     9582      CglStored *stored = dynamic_cast< CglStored * >(generator_[i]->generator());
    95839583      if (stored && !generator_[i]->numberCutsInTotal())
    95849584        continue;
     
    96359635        // probing->setRowCuts(0);
    96369636        for (int i = 0; i < numberObjects_; i++) {
    9637           CbcSimpleIntegerDynamicPseudoCost *obj = dynamic_cast<CbcSimpleIntegerDynamicPseudoCost *>(object_[i]);
     9637          CbcSimpleIntegerDynamicPseudoCost *obj = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object_[i]);
    96389638          if (obj)
    96399639            obj->setMethod(1);
     
    96719671#ifdef COIN_HAS_CLP
    96729672        OsiClpSolverInterface *clpSolver
    9673           = dynamic_cast<OsiClpSolverInterface *>(solver_);
     9673          = dynamic_cast< OsiClpSolverInterface * >(solver_);
    96749674        if (clpSolver) {
    96759675          // Maybe solver might like to know only column bounds will change
     
    96829682#ifdef COIN_HAS_CLP
    96839683        OsiClpSolverInterface *clpSolver
    9684           = dynamic_cast<OsiClpSolverInterface *>(solver_);
     9684          = dynamic_cast< OsiClpSolverInterface * >(solver_);
    96859685        if (clpSolver) {
    96869686          // make sure factorization can't carry over
     
    96949694#ifdef COIN_HAS_CLP
    96959695    OsiClpSolverInterface *clpSolver
    9696       = dynamic_cast<OsiClpSolverInterface *>(solver_);
     9696      = dynamic_cast< OsiClpSolverInterface * >(solver_);
    96979697    if (clpSolver) {
    96989698      // Maybe solver might like to know only column bounds will change
     
    97229722#ifdef CHECK_CUT_COUNTS
    97239723  if (feasible) {
    9724     CoinWarmStartBasis *basis = dynamic_cast<CoinWarmStartBasis *>(solver_->getWarmStart());
     9724    CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver_->getWarmStart());
    97259725    printf("solveWithCuts: Number of rows at end (only active cuts) %d\n",
    97269726      numberRowsAtContinuous_ + numberNewCuts_ + numberOldActiveCuts_);
     
    98259825      numberRowCutsAfter = theseCuts.sizeRowCuts();
    98269826      if (fullScan && generator_[i]->howOften() == 1000000 + SCANCUTS_PROBING) {
    9827         CglProbing *probing = dynamic_cast<CglProbing *>(generator_[i]->generator());
     9827        CglProbing *probing = dynamic_cast< CglProbing * >(generator_[i]->generator());
    98289828        if (probing && (numberRowCutsBefore < numberRowCutsAfter || numberColumnCutsBefore < theseCuts.sizeColCuts())) {
    98299829          // switch on
     
    1008510085  int problemStatus = -1;
    1008610086  OsiClpSolverInterface *clpSolver
    10087     = dynamic_cast<OsiClpSolverInterface *>(solver_);
     10087    = dynamic_cast< OsiClpSolverInterface * >(solver_);
    1008810088  if (clpSolver)
    1008910089    problemStatus = clpSolver->getModelPtr()->status();
     
    1010010100    int i;
    1010110101    int kCut = 0;
    10102     ws = dynamic_cast<const CoinWarmStartBasis *>(solver_->getWarmStart());
     10102    ws = dynamic_cast< const CoinWarmStartBasis * >(solver_->getWarmStart());
    1010310103    /*
    1010410104          Scan the basis entries of the old cuts generated prior to this round of cut
     
    1030010300#ifdef COIN_HAS_CLP
    1030110301  OsiClpSolverInterface *clpSolver
    10302     = dynamic_cast<OsiClpSolverInterface *>(solver_);
     10302    = dynamic_cast< OsiClpSolverInterface * >(solver_);
    1030310303#endif
    1030410304  /*
     
    1050310503            value = fabs(cost) * multiplier;
    1050410504            if (value < 2.1e9) {
    10505               int nearest = static_cast<int>(floor(value + 0.5));
     10505              int nearest = static_cast< int >(floor(value + 0.5));
    1050610506              assert(fabs(value - floor(value + 0.5)) < 1.0e-8);
    1050710507              if (!increment)
     
    1070610706      }
    1070710707    }
    10708     int iUpper = static_cast<int>(floor(upperValue + 1.0e-5));
    10709     int iLower = static_cast<int>(ceil(lowerValue - 1.0e-5));
     10708    int iUpper = static_cast< int >(floor(upperValue + 1.0e-5));
     10709    int iLower = static_cast< int >(ceil(lowerValue - 1.0e-5));
    1071010710    /*
    1071110711          What do we have? If the row upper bound is greater than 1-numberM1, this
     
    1084710847      printf("%d cliques of average size %g found, %d P1, %d M1\n",
    1084810848        numberCliques,
    10849         (static_cast<double>(totalP1 + totalM1)) / (static_cast<double>(numberCliques)),
     10849        (static_cast< double >(totalP1 + totalM1)) / (static_cast< double >(numberCliques)),
    1085010850        totalP1, totalM1);
    1085110851    else
     
    1093810938      // zero out
    1093910939      for (int i = 0; i < numberObjects_; i++) {
    10940         CbcSimpleIntegerDynamicPseudoCost *obj1 = dynamic_cast<CbcSimpleIntegerDynamicPseudoCost *>(object_[i]);
     10940        CbcSimpleIntegerDynamicPseudoCost *obj1 = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object_[i]);
    1094110941        if (obj1) {
    1094210942          //assert (obj1->downShadowPrice()>0.0);
     
    1121611216    }
    1121711217    if (numberIntegers) {
    11218       double averagePrice = (0.5 * (upSum + downSum)) / static_cast<double>(numberIntegers);
     11218      double averagePrice = (0.5 * (upSum + downSum)) / static_cast< double >(numberIntegers);
    1121911219      //averagePrice *= 0.1;
    1122011220      averagePrice *= 100.0;
     
    1122911229  delete[] columnWeight;
    1123011230  if (numberIntegers) {
    11231     double smallDown = 0.0001 * (downSum / static_cast<double>(numberIntegers));
    11232     double smallUp = 0.0001 * (upSum / static_cast<double>(numberIntegers));
     11231    double smallDown = 0.0001 * (downSum / static_cast< double >(numberIntegers));
     11232    double smallUp = 0.0001 * (upSum / static_cast< double >(numberIntegers));
    1123311233#define PSEUDO_FACTOR 5.0e-1
    1123411234    double pseudoFactor = PSEUDO_FACTOR;
     
    1123611236    //pseudoFactor=0.0;
    1123711237    for (int i = 0; i < numberObjects_; i++) {
    11238       CbcSimpleIntegerDynamicPseudoCost *obj1 = dynamic_cast<CbcSimpleIntegerDynamicPseudoCost *>(object_[i]);
     11238      CbcSimpleIntegerDynamicPseudoCost *obj1 = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object_[i]);
    1123911239      if (obj1 && obj1->upShadowPrice() >= 0.0) {
    1124011240        int iColumn = obj1->columnNumber();
     
    1132511325    heuristic_[i]->setModel(this);
    1132611326  for (i = 0; i < numberObjects_; i++) {
    11327     CbcObject *obj = dynamic_cast<CbcObject *>(object_[i]);
     11327    CbcObject *obj = dynamic_cast< CbcObject * >(object_[i]);
    1132811328    if (obj) {
    1132911329      obj->setModel(this);
     
    1133511335
    1133611336  if (!solverCharacteristics_) {
    11337     OsiBabSolver *solverCharacteristics = dynamic_cast<OsiBabSolver *>(solver_->getAuxiliaryInfo());
     11337    OsiBabSolver *solverCharacteristics = dynamic_cast< OsiBabSolver * >(solver_->getAuxiliaryInfo());
    1133811338    if (solverCharacteristics) {
    1133911339      solverCharacteristics_ = solverCharacteristics;
     
    1134211342      OsiBabSolver defaultC;
    1134311343      solver_->setAuxiliaryInfo(&defaultC);
    11344       solverCharacteristics_ = dynamic_cast<OsiBabSolver *>(solver_->getAuxiliaryInfo());
     11344      solverCharacteristics_ = dynamic_cast< OsiBabSolver * >(solver_->getAuxiliaryInfo());
    1134511345    }
    1134611346  }
     
    1140211402  for (iObject = 0; iObject < numberObjects_; iObject++) {
    1140311403    iPriority = CoinMax(iPriority, object_[iObject]->priority());
    11404     CbcSimpleInteger *obj = dynamic_cast<CbcSimpleInteger *>(oldObject[iObject]);
     11404    CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(oldObject[iObject]);
    1140511405    if (obj) {
    1140611406      int iColumn = obj->columnNumber();
     
    1141611416  if (!nObjects) {
    1141711417    OsiClpSolverInterface *clpSolver
    11418       = dynamic_cast<OsiClpSolverInterface *>(solver_);
     11418      = dynamic_cast< OsiClpSolverInterface * >(solver_);
    1141911419    if (clpSolver && (clpSolver->numberSOS() || clpSolver->numberObjects())) {
    1142011420      // deal with sos
     
    1144011440        OsiObject **osiObjects = clpSolver->objects();
    1144111441        for (int i = 0; i < numberObjects; i++) {
    11442           OsiSOS *obj = dynamic_cast<OsiSOS *>(osiObjects[i]);
     11442          OsiSOS *obj = dynamic_cast< OsiSOS * >(osiObjects[i]);
    1144311443          if (obj) {
    1144411444            int type = obj->setType();
     
    1150511505  bool allDynamic = true;
    1150611506  for (iObject = 0; iObject < numberObjects_; iObject++) {
    11507     CbcSimpleInteger *obj1 = dynamic_cast<CbcSimpleInteger *>(object_[iObject]);
    11508     CbcSimpleIntegerPseudoCost *obj1a = dynamic_cast<CbcSimpleIntegerPseudoCost *>(object_[iObject]);
    11509     CbcSimpleIntegerDynamicPseudoCost *obj2 = dynamic_cast<CbcSimpleIntegerDynamicPseudoCost *>(object_[iObject]);
     11507    CbcSimpleInteger *obj1 = dynamic_cast< CbcSimpleInteger * >(object_[iObject]);
     11508    CbcSimpleIntegerPseudoCost *obj1a = dynamic_cast< CbcSimpleIntegerPseudoCost * >(object_[iObject]);
     11509    CbcSimpleIntegerDynamicPseudoCost *obj2 = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object_[iObject]);
    1151011510    if (obj1 && !obj2) {
    1151111511      // replace
     
    1153511535      object_[iObject] = newObject;
    1153611536    } else if (!obj2) {
    11537       CbcObject *obj3 = dynamic_cast<CbcObject *>(object_[iObject]);
     11537      CbcObject *obj3 = dynamic_cast< CbcObject * >(object_[iObject]);
    1153811538      if (!obj3 || !obj3->optionalObject())
    1153911539        allDynamic = false;
     
    1159711597    if (columnLower[iColumn] || columnUpper[iColumn] != 1.0)
    1159811598      continue;
    11599     if (!dynamic_cast<CbcSimpleInteger *>(object_[i]))
     11599    if (!dynamic_cast< CbcSimpleInteger * >(object_[i]))
    1160011600      continue;
    1160111601    int nAdd = 0;
     
    1166311663        sort[nAdd] = COIN_INT_MAX;
    1166411664        whichRow[nAdd] = COIN_INT_MAX;
    11665         CbcSimpleIntegerDynamicPseudoCost *thisOne = dynamic_cast<CbcSimpleIntegerDynamicPseudoCost *>(object_[i]);
     11665        CbcSimpleIntegerDynamicPseudoCost *thisOne = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object_[i]);
    1166611666        if (thisOne) {
    1166711667          assert(iColumn == thisOne->columnNumber());
     
    1166911669          delete thisOne;
    1167011670        } else {
    11671           CbcSimpleInteger *thisOne = dynamic_cast<CbcSimpleInteger *>(object_[i]);
     11671          CbcSimpleInteger *thisOne = dynamic_cast< CbcSimpleInteger * >(object_[i]);
    1167211672          assert(thisOne);
    1167311673          assert(iColumn == thisOne->columnNumber());
     
    1171911719      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) {
    1172011720        // forces to zero
    11721         CbcSwitchingBinary *object = dynamic_cast<CbcSwitchingBinary *>(object_[i]);
     11721        CbcSwitchingBinary *object = dynamic_cast< CbcSwitchingBinary * >(object_[i]);
    1172211722        if (!object) {
    1172311723          // create empty one
    11724           CbcSimpleIntegerDynamicPseudoCost *thisOne = dynamic_cast<CbcSimpleIntegerDynamicPseudoCost *>(object_[i]);
     11724          CbcSimpleIntegerDynamicPseudoCost *thisOne = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object_[i]);
    1172511725          if (thisOne) {
    1172611726            assert(iColumn == thisOne->columnNumber());
     
    1172811728            delete thisOne;
    1172911729          } else {
    11730             CbcSimpleInteger *thisOne = dynamic_cast<CbcSimpleInteger *>(object_[i]);
     11730            CbcSimpleInteger *thisOne = dynamic_cast< CbcSimpleInteger * >(object_[i]);
    1173111731            assert(thisOne);
    1173211732            assert(iColumn == thisOne->columnNumber());
     
    1177311773      n = 0;
    1177411774      for (int i = 0; i < numberObjects_; i++) {
    11775         CbcSwitchingBinary *object = dynamic_cast<CbcSwitchingBinary *>(object_[i]);
     11775        CbcSwitchingBinary *object = dynamic_cast< CbcSwitchingBinary * >(object_[i]);
    1177611776        if (object) {
    1177711777          n += object->setAssociatedBounds(solver, cleanBasis);
     
    1179811798    int nBetween = 0;
    1179911799    for (int i = 0; i < numberObjects_; i++) {
    11800       CbcSwitchingBinary *object = dynamic_cast<CbcSwitchingBinary *>(object_[i]);
     11800      CbcSwitchingBinary *object = dynamic_cast< CbcSwitchingBinary * >(object_[i]);
    1180111801      if (object) {
    1180211802        int state[3];
     
    1182811828  int iObject;
    1182911829  for (iObject = 0; iObject < numberObjects_; iObject++) {
    11830     CbcSimpleIntegerDynamicPseudoCost *obj2 = dynamic_cast<CbcSimpleIntegerDynamicPseudoCost *>(object_[iObject]);
     11830    CbcSimpleIntegerDynamicPseudoCost *obj2 = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object_[iObject]);
    1183111831    if (obj2) {
    1183211832      // synchronize trust
     
    1187111871  int newIntegers = 0;
    1187211872  for (i = 0; i < numberObjects; i++) {
    11873     CbcSimpleInteger *obj = dynamic_cast<CbcSimpleInteger *>(objects[i]);
     11873    CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(objects[i]);
    1187411874    if (obj) {
    1187511875      int iColumn = obj->columnNumber();
     
    1188111881  // and existing
    1188211882  for (i = 0; i < numberObjects_; i++) {
    11883     CbcSimpleInteger *obj = dynamic_cast<CbcSimpleInteger *>(object_[i]);
     11883    CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(object_[i]);
    1188411884    if (obj) {
    1188511885      int iColumn = obj->columnNumber();
     
    1193111931  for (i = 0; i < numberObjects_; i++) {
    1193211932    if (object_[i]) {
    11933       CbcSimpleInteger *obj = dynamic_cast<CbcSimpleInteger *>(object_[i]);
     11933      CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(object_[i]);
    1193411934      if (obj) {
    1193511935        delete object_[i];
     
    1194111941  // and rest of new
    1194211942  for (i = 0; i < numberObjects; i++) {
    11943     CbcSimpleInteger *obj = dynamic_cast<CbcSimpleInteger *>(objects[i]);
     11943    CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(objects[i]);
    1194411944    if (!obj) {
    1194511945      temp[n] = objects[i]->clone();
    11946       CbcObject *obj = dynamic_cast<CbcObject *>(temp[n]);
     11946      CbcObject *obj = dynamic_cast< CbcObject * >(temp[n]);
    1194711947      if (obj)
    1194811948        obj->setModel(this);
     
    1197611976  int newIntegers = 0;
    1197711977  for (i = 0; i < numberObjects; i++) {
    11978     CbcSimpleInteger *obj = dynamic_cast<CbcSimpleInteger *>(objects[i]);
     11978    CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(objects[i]);
    1197911979    if (obj) {
    1198011980      int iColumn = obj->columnNumber();
     
    1198211982      newIntegers++;
    1198311983    } else {
    11984       OsiSimpleInteger *obj2 = dynamic_cast<OsiSimpleInteger *>(objects[i]);
     11984      OsiSimpleInteger *obj2 = dynamic_cast< OsiSimpleInteger * >(objects[i]);
    1198511985      if (obj2) {
    1198611986        // Osi takes precedence
     
    1199311993  // and existing
    1199411994  for (i = 0; i < numberObjects_; i++) {
    11995     CbcSimpleInteger *obj = dynamic_cast<CbcSimpleInteger *>(object_[i]);
     11995    CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(object_[i]);
    1199611996    if (obj) {
    1199711997      int iColumn = obj->columnNumber();
     
    1204212042  for (i = 0; i < numberObjects_; i++) {
    1204312043    if (object_[i]) {
    12044       CbcSimpleInteger *obj = dynamic_cast<CbcSimpleInteger *>(object_[i]);
     12044      CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(object_[i]);
    1204512045      if (obj) {
    1204612046        delete object_[i];
     
    1205212052  // and rest of new
    1205312053  for (i = 0; i < numberObjects; i++) {
    12054     CbcSimpleInteger *obj = dynamic_cast<CbcSimpleInteger *>(objects[i]);
    12055     OsiSimpleInteger *obj2 = dynamic_cast<OsiSimpleInteger *>(objects[i]);
     12054    CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(objects[i]);
     12055    OsiSimpleInteger *obj2 = dynamic_cast< OsiSimpleInteger * >(objects[i]);
    1205612056    if (!obj && !obj2) {
    1205712057      temp[n] = objects[i]->clone();
    12058       CbcObject *obj = dynamic_cast<CbcObject *>(temp[n]);
     12058      CbcObject *obj = dynamic_cast< CbcObject * >(temp[n]);
    1205912059      if (obj)
    1206012060        obj->setModel(this);
     
    1213312133#ifdef COIN_HAS_CLP
    1213412134    OsiClpSolverInterface *clpContinuousSolver
    12135       = dynamic_cast<OsiClpSolverInterface *>(continuousSolver_);
     12135      = dynamic_cast< OsiClpSolverInterface * >(continuousSolver_);
    1213612136    int modifiedTolerances = 0;
    1213712137#ifndef CBC_LEAVE_PERTURBATION_ON_CHECK_SOLUTION
     
    1219112191      solver_ = continuousSolver_;
    1219212192    // save basis and solution
    12193     CoinWarmStartBasis *basis = dynamic_cast<CoinWarmStartBasis *>(solver_->getWarmStart());
     12193    CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver_->getWarmStart());
    1219412194    assert(basis != NULL);
    1219512195    double *saveSolution = CoinCopyOfArray(solver_->getColSolution(),
     
    1223912239      if ((moreSpecialOptions2_ & 4) != 0) {
    1224012240        for (int i = 0; i < numberObjects_; i++) {
    12241           CbcSwitchingBinary *object = dynamic_cast<CbcSwitchingBinary *>(object_[i]);
     12241          CbcSwitchingBinary *object = dynamic_cast< CbcSwitchingBinary * >(object_[i]);
    1224212242          if (object) {
    1224312243            int iColumn = object->columnNumber();
     
    1241212412      if ((moreSpecialOptions2_ & 4) != 0) {
    1241312413        for (int i = 0; i < numberObjects_; i++) {
    12414           CbcSwitchingBinary *object = dynamic_cast<CbcSwitchingBinary *>(object_[i]);
     12414          CbcSwitchingBinary *object = dynamic_cast< CbcSwitchingBinary * >(object_[i]);
    1241512415          if (object) {
    1241612416            int iColumn = object->columnNumber();
     
    1249512495    // If relaxed then leave bounds on basic variables
    1249612496    if (fixVariables == -1 && (specialOptions_ & 16) == 0) {
    12497       CoinWarmStartBasis *basis = dynamic_cast<CoinWarmStartBasis *>(saveSolver->getWarmStart());
     12497      CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(saveSolver->getWarmStart());
    1249812498      assert(basis != NULL);
    1249912499#ifdef JJF_ZERO //ndef CBC_OTHER_SOLVER
    1250012500      for (i = 0; i < numberObjects_; i++) {
    12501         CbcSimpleInteger *obj = dynamic_cast<CbcSimpleInteger *>(object_[i]);
     12501        CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(object_[i]);
    1250212502        if (obj) {
    1250312503          int iColumn = obj->columnNumber();
     
    1252212522                  residual influence on initialSolve().
    1252312523                */
    12524         CoinWarmStartBasis *slack = dynamic_cast<CoinWarmStartBasis *>(solver_->getEmptyWarmStart());
     12524        CoinWarmStartBasis *slack = dynamic_cast< CoinWarmStartBasis * >(solver_->getEmptyWarmStart());
    1252512525        solver_->setWarmStart(slack);
    1252612526        delete slack;
     
    1255212552#ifdef COIN_HAS_CLP
    1255312553        OsiClpSolverInterface *clpSolver
    12554           = dynamic_cast<OsiClpSolverInterface *>(solver_);
     12554          = dynamic_cast< OsiClpSolverInterface * >(solver_);
    1255512555        if (clpSolver) {
    1255612556          clpSolver->getModelPtr()->writeBasis("feasible.bas", true);
     
    1257912579        specialOptions_ &= ~2;
    1258012580        if (!solver_->isProvenOptimal()) {
    12581           CoinWarmStartBasis *slack = dynamic_cast<CoinWarmStartBasis *>(solver_->getEmptyWarmStart());
     12581          CoinWarmStartBasis *slack = dynamic_cast< CoinWarmStartBasis * >(solver_->getEmptyWarmStart());
    1258212582          solver_->setWarmStart(slack);
    1258312583          delete slack;
     
    1295712957    double newObjectiveValue = cutoff;
    1295812958    if (solverCharacteristics_->solution(newObjectiveValue,
    12959           const_cast<double *>(solution),
     12959          const_cast< double * >(solution),
    1296012960          numberColumns)) {
    1296112961      objectiveValue = newObjectiveValue;
     
    1303813038    double saveObjectiveValue = objectiveValue;
    1303913039    // save basis
    13040     CoinWarmStartBasis *basis = dynamic_cast<CoinWarmStartBasis *>(solver_->getWarmStart());
     13040    CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver_->getWarmStart());
    1304113041    assert(basis != NULL);
    1304213042    objectiveValue = checkSolution(cutoff, solution, fixVariables, objectiveValue);
     
    1305113051      // try again with basic variables with original bounds
    1305213052      // save basis
    13053       CoinWarmStartBasis *basis2 = dynamic_cast<CoinWarmStartBasis *>(solver_->getWarmStart());
     13053      CoinWarmStartBasis *basis2 = dynamic_cast< CoinWarmStartBasis * >(solver_->getWarmStart());
    1305413054      assert(basis2 != NULL);
    1305513055      solver_->setWarmStart(basis);
     
    1309113091        }
    1309213092        for (i = 0; i < numberObjects_; i++) {
    13093           CbcSimpleInteger *obj = dynamic_cast<CbcSimpleInteger *>(object_[i]);
     13093          CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(object_[i]);
    1309413094          if (obj) {
    1309513095            int iColumn = obj->columnNumber();
     
    1363413634  //probingInfo_->initializeFixing();
    1363513635  for (iGen = 0; iGen < numberCutGenerators_; iGen++) {
    13636     generator = dynamic_cast<CglProbing *>(generator_[iGen]->generator());
     13636    generator = dynamic_cast< CglProbing * >(generator_[iGen]->generator());
    1363713637    if (generator)
    1363813638      break;
     
    1434414344#ifdef COIN_HAS_CLP
    1434514345  OsiClpSolverInterface *clpSolver
    14346     = dynamic_cast<OsiClpSolverInterface *>(solver);
     14346    = dynamic_cast< OsiClpSolverInterface * >(solver);
    1434714347#endif
    1434814348#ifdef CLIQUE_ANALYSIS
     
    1449614496        for (int iCutGenerator = 0; iCutGenerator < numberCutGenerators_; iCutGenerator++) {
    1449714497          CglCutGenerator *generator = generator_[iCutGenerator]->generator();
    14498           CglGomory *cgl1 = dynamic_cast<CglGomory *>(generator);
     14498          CglGomory *cgl1 = dynamic_cast< CglGomory * >(generator);
    1449914499          if (cgl1) {
    1450014500            cgl1->setLimitAtRoot(cgl1->getLimit());
    1450114501          }
    14502           CglTwomir *cgl2 = dynamic_cast<CglTwomir *>(generator);
     14502          CglTwomir *cgl2 = dynamic_cast< CglTwomir * >(generator);
    1450314503          if (cgl2) {
    1450414504            generator_[iCutGenerator]->setHowOften(-100);
     
    1456614566      for (int iCutGenerator = 0; iCutGenerator < numberCutGenerators_; iCutGenerator++) {
    1456714567        CglCutGenerator *generator = generator_[iCutGenerator]->generator();
    14568         CglGomory *cgl1 = dynamic_cast<CglGomory *>(generator);
     14568        CglGomory *cgl1 = dynamic_cast< CglGomory * >(generator);
    1456914569        if (cgl1) {
    1457014570          cgl1->setLimitAtRoot(cgl1->getLimit());
    1457114571        }
    14572         CglTwomir *cgl2 = dynamic_cast<CglTwomir *>(generator);
     14572        CglTwomir *cgl2 = dynamic_cast< CglTwomir * >(generator);
    1457314573        if (cgl2) {
    1457414574          generator_[iCutGenerator]->setHowOften(-100);
     
    1478614786#ifdef COIN_HAS_CLP
    1478714787    OsiClpSolverInterface *clpSolver
    14788       = dynamic_cast<OsiClpSolverInterface *>(solver_);
     14788      = dynamic_cast< OsiClpSolverInterface * >(solver_);
    1478914789    if (clpSolver) {
    1479014790      ClpSimplex *clpSimplex = clpSolver->getModelPtr();
     
    1493214932  int nBranches = intParam_[CbcNumberBranches];
    1493314933  if (nBranches) {
    14934     double average = dblParam_[CbcSumChange] / static_cast<double>(nBranches);
     14934    double average = dblParam_[CbcSumChange] / static_cast< double >(nBranches);
    1493514935    dblParam_[CbcSmallChange] = CoinMax(average * 1.0e-5, dblParam_[CbcSmallestChange]);
    1493614936    dblParam_[CbcSmallChange] = CoinMax(dblParam_[CbcSmallChange], 1.0e-8);
     
    1500215002        && !cuts.sizeRowCuts()) {
    1500315003        OsiClpSolverInterface *clpSolver
    15004           = dynamic_cast<OsiClpSolverInterface *>(solver_);
     15004          = dynamic_cast< OsiClpSolverInterface * >(solver_);
    1500515005        if (clpSolver) {
    1500615006          anyAction = newNode->chooseClpBranch(this, oldNode);
     
    1501615016      int save = 0;
    1501715017      OsiClpSolverInterface *clpSolver
    15018         = dynamic_cast<OsiClpSolverInterface *>(solver_);
     15018        = dynamic_cast< OsiClpSolverInterface * >(solver_);
    1501915019      if (clpSolver && (moreSpecialOptions_ & 4194304) != 0) {
    1502015020        ClpSimplex *clpSimplex = clpSolver->getModelPtr();
     
    1508715087        for (int i = 0; i < numberUpdateItems_; i++) {
    1508815088          CbcObjectUpdateData *update = updateItems_ + i;
    15089           CbcObject *object = dynamic_cast<CbcObject *>(update->object_);
     15089          CbcObject *object = dynamic_cast< CbcObject * >(update->object_);
    1509015090#ifndef NDEBUG
    1509115091          bool found = false;
     
    1520615206               "(active only) %d\n",
    1520715207          numberRowsAtContinuous_ + numberNewCuts_ + numberOldActiveCuts_);
    15208         const CoinWarmStartBasis *debugws = dynamic_cast<const CoinWarmStartBasis *>(solver_->getWarmStart());
     15208        const CoinWarmStartBasis *debugws = dynamic_cast< const CoinWarmStartBasis * >(solver_->getWarmStart());
    1520915209        debugws->print();
    1521015210        delete debugws;
     
    1521415214    {
    1521515215      OsiBranchingObject *branchingObject = newNode->modifiableBranchingObject();
    15216       CbcGeneralBranchingObject *generalBranch = dynamic_cast<CbcGeneralBranchingObject *>(branchingObject);
     15216      CbcGeneralBranchingObject *generalBranch = dynamic_cast< CbcGeneralBranchingObject * >(branchingObject);
    1521715217      if (generalBranch && false) {
    1521815218        int numberProblems = generalBranch->numberSubProblems();
     
    1541815418      solution = solver_->getColSolution();
    1541915419      // Save current basis
    15420       CoinWarmStartBasis *ws = dynamic_cast<CoinWarmStartBasis *>(solver_->getWarmStart());
     15420      CoinWarmStartBasis *ws = dynamic_cast< CoinWarmStartBasis * >(solver_->getWarmStart());
    1542115421      assert(ws);
    1542215422      setBestSolutionBasis(*ws);
     
    1558915589              void *argBundle);
    1559015590            parallelHeuristics(nThisTime,
    15591               static_cast<int>(sizeof(argBundle)),
     15591              static_cast< int >(sizeof(argBundle)),
    1559215592              parameters);
    1559315593            double cutoff = heuristicValue;
     
    1575915759    if (found >= 0) {
    1576015760      CbcTreeLocal *tree
    15761         = dynamic_cast<CbcTreeLocal *>(tree_);
     15761        = dynamic_cast< CbcTreeLocal * >(tree_);
    1576215762      if (tree)
    1576315763        tree->passInSolution(bestSolution_, heuristicValue);
     
    1577915779      // delete FPump
    1578015780      CbcHeuristicFPump *pump
    15781         = dynamic_cast<CbcHeuristicFPump *>(heuristic_[i]);
     15781        = dynamic_cast< CbcHeuristicFPump * >(heuristic_[i]);
    1578215782      if (pump && pump->feasibilityPumpOptions() < 1000000
    1578315783        && (specialOptions_ & 33554432) == 0) {
     
    1583415834      name.c_str(), howOften);
    1583515835    // change name
    15836     name[0] = static_cast<char>(toupper(name[0]));
     15836    name[0] = static_cast< char >(toupper(name[0]));
    1583715837    fprintf(fp, "\"%s\",%s,%s,%s,%d,%d,%d);\n",
    1583815838      name.c_str(), normal ? "true" : "false",
     
    1596615966  double &originalUpper)
    1596715967{
    15968   const CbcSimpleInteger *integerObject = dynamic_cast<const CbcSimpleInteger *>(object);
     15968  const CbcSimpleInteger *integerObject = dynamic_cast< const CbcSimpleInteger * >(object);
    1596915969  if (integerObject) {
    1597015970    // get original bounds
     
    1597215972    originalUpper = integerObject->originalUpperBound();
    1597315973  } else {
    15974     const OsiSimpleInteger *integerObject = dynamic_cast<const OsiSimpleInteger *>(object);
     15974    const OsiSimpleInteger *integerObject = dynamic_cast< const OsiSimpleInteger * >(object);
    1597515975    assert(integerObject);
    1597615976    // get original bounds
     
    1611116111      OsiBranchingObject *branch2 = node->modifiableBranchingObject();
    1611216112#ifndef NDEBUG
    16113       CbcBranchingObject *branch = dynamic_cast<CbcBranchingObject *>(branch2);
     16113      CbcBranchingObject *branch = dynamic_cast< CbcBranchingObject * >(branch2);
    1611416114      assert(branch);
    1611516115#else
    16116       CbcBranchingObject *branch = static_cast<CbcBranchingObject *>(branch2);
     16116      CbcBranchingObject *branch = static_cast< CbcBranchingObject * >(branch2);
    1611716117#endif
    1611816118#if 1
     
    1619816198#ifdef COIN_HAS_CLP
    1619916199      OsiClpSolverInterface *clpSolver
    16200         = dynamic_cast<OsiClpSolverInterface *>(solver_);
     16200        = dynamic_cast< OsiClpSolverInterface * >(solver_);
    1620116201      if ((clpSolver || (specialOptions_ & 16384) != 0) && fastNodeDepth_ < -1
    1620216202        && (specialOptions_ & 2048) == 0) {
     
    1625116251            int nBranches = intParam_[CbcNumberBranches];
    1625216252            if (nBranches) {
    16253               double average = dblParam_[CbcSumChange] / static_cast<double>(nBranches);
     16253              double average = dblParam_[CbcSumChange] / static_cast< double >(nBranches);
    1625416254              info->smallChange_ = CoinMax(average * 1.0e-5, dblParam_[CbcSmallestChange]);
    1625516255              info->smallChange_ = CoinMax(info->smallChange_, 1.0e-8);
     
    1642816428              double largest = -1.0;
    1642916429              for (int i = 0; i < numberIntegers_; i++) {
    16430                 CbcSimpleIntegerDynamicPseudoCost *obj = dynamic_cast<CbcSimpleIntegerDynamicPseudoCost *>(object_[i]);
     16430                CbcSimpleIntegerDynamicPseudoCost *obj = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object_[i]);
    1643116431                if (!obj)
    1643216432                  continue;
     
    1659816598          solver_->getRowCutDebuggerAlways()->printOptimalSolution(*solver_);
    1659916599          solver_->writeMpsNative("infeas.mps", NULL, NULL, 2);
    16600           CoinWarmStartBasis *slack = dynamic_cast<CoinWarmStartBasis *>(solver_->getEmptyWarmStart());
     16600          CoinWarmStartBasis *slack = dynamic_cast< CoinWarmStartBasis * >(solver_->getEmptyWarmStart());
    1660116601          solver_->setWarmStart(slack);
    1660216602          delete slack;
     
    1663316633          //const double * bounds = nodeInfo->newBounds();
    1663416634          const OsiBranchingObject *obj = node->branchingObject();
    16635           const CbcIntegerBranchingObject *objectI = dynamic_cast<const CbcIntegerBranchingObject *>(obj);
     16635          const CbcIntegerBranchingObject *objectI = dynamic_cast< const CbcIntegerBranchingObject * >(obj);
    1663616636          if (objectI) {
    16637             const CbcSimpleInteger *object1 = dynamic_cast<const CbcSimpleInteger *>(objectI->object());
     16637            const CbcSimpleInteger *object1 = dynamic_cast< const CbcSimpleInteger * >(objectI->object());
    1663816638            int iColumn1 = -1;
    1663916639            int way1 = 0;
     
    1664516645              double originalUpper1 = object1->originalUpperBound();
    1664616646              // Unset all bounds from parents
    16647               CbcPartialNodeInfo *partial = dynamic_cast<CbcPartialNodeInfo *>(nodeInfo);
     16647              CbcPartialNodeInfo *partial = dynamic_cast< CbcPartialNodeInfo * >(nodeInfo);
    1664816648              touched[iColumn1] = 1;
    1664916649              if (partial) {
     
    1670816708                continue;
    1670916709              OsiBranchingObject *obj = nodeLook->modifiableBranchingObject();
    16710               CbcIntegerBranchingObject *objectI = dynamic_cast<CbcIntegerBranchingObject *>(obj);
     16710              CbcIntegerBranchingObject *objectI = dynamic_cast< CbcIntegerBranchingObject * >(obj);
    1671116711              //const OsiObject * object2a = obj->originalObject();
    1671216712              //assert (object2a);
    16713               const CbcSimpleInteger *object2 = dynamic_cast<const CbcSimpleInteger *>(objectI->object());
     16713              const CbcSimpleInteger *object2 = dynamic_cast< const CbcSimpleInteger * >(objectI->object());
    1671416714              if (nodeInfo->numberBranchesLeft() && object2) {
    1671516715                int iColumn2 = object2->columnNumber();
     
    1696716967        for (i = 0; i < numberUpdateItems_; i++) {
    1696816968          CbcObjectUpdateData *update = updateItems_ + i;
    16969           CbcObject *object = dynamic_cast<CbcObject *>(update->object_);
     16969          CbcObject *object = dynamic_cast< CbcObject * >(update->object_);
    1697016970#ifndef NDEBUG
    1697116971          bool found = false;
     
    1731617316  if (nodeLook) {
    1731717317    OsiBranchingObject *obj = nodeLook->modifiableBranchingObject();
    17318     CbcIntegerBranchingObject *objectI = dynamic_cast<CbcIntegerBranchingObject *>(obj);
     17318    CbcIntegerBranchingObject *objectI = dynamic_cast< CbcIntegerBranchingObject * >(obj);
    1731917319    //const OsiObject * object2 = obj->orig
    1732017320#ifndef NDEBUG
    17321     const CbcSimpleInteger *object2 = dynamic_cast<const CbcSimpleInteger *>(objectI->object());
     17321    const CbcSimpleInteger *object2 = dynamic_cast< const CbcSimpleInteger * >(objectI->object());
    1732217322    assert(object2);
    1732317323    assert(iColumn == object2->columnNumber());
     
    1733617336    if (nodeLook) {
    1733717337      const OsiBranchingObject *obj = nodeLook->branchingObject();
    17338       const CbcIntegerBranchingObject *objectI = dynamic_cast<const CbcIntegerBranchingObject *>(obj);
     17338      const CbcIntegerBranchingObject *objectI = dynamic_cast< const CbcIntegerBranchingObject * >(obj);
    1733917339      //const OsiObject * object2 = obj->orig
    17340       const CbcSimpleInteger *object2 = dynamic_cast<const CbcSimpleInteger *>(objectI->object());
     17340      const CbcSimpleInteger *object2 = dynamic_cast< const CbcSimpleInteger * >(objectI->object());
    1734117341      assert(object2);
    1734217342      int iColumn2 = object2->columnNumber();
     
    1738217382#endif
    1738317383  for (i = 0; i < numberObjects_; i++) {
    17384     CbcSimpleIntegerDynamicPseudoCost *obj = dynamic_cast<CbcSimpleIntegerDynamicPseudoCost *>(object_[i]);
     17384    CbcSimpleIntegerDynamicPseudoCost *obj = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object_[i]);
    1738517385    if (!obj)
    1738617386      continue;
     
    1752617526  int nRoot = CoinMax(40000, 8 * numberRows + 4 * numberColumns);
    1752717527  for (int i = 0; i < numberHeuristics_; i++) {
    17528     CbcHeuristicDive *heuristic = dynamic_cast<CbcHeuristicDive *>(heuristic_[i]);
     17528    CbcHeuristicDive *heuristic = dynamic_cast< CbcHeuristicDive * >(heuristic_[i]);
    1752917529    if (heuristic && heuristic->maxSimplexIterations() != COIN_INT_MAX) {
    1753017530      heuristic->setMaxSimplexIterations(nTree);
     
    1757217572  } else if (which <= numberSavedSolutions_) {
    1757317573    double *sol = savedSolutions_[which - 1];
    17574     assert(static_cast<int>(sol[0]) == solver_->getNumCols());
     17574    assert(static_cast< int >(sol[0]) == solver_->getNumCols());
    1757517575    return sol[1];
    1757617576  } else {
     
    1758617586  } else if (which <= numberSavedSolutions_) {
    1758717587    double *sol = savedSolutions_[which - 1];
    17588     assert(static_cast<int>(sol[0]) == solver_->getNumCols());
     17588    assert(static_cast< int >(sol[0]) == solver_->getNumCols());
    1758917589    return sol + 2;
    1759017590  } else {
     
    1760617606    for (k = numberSavedSolutions_ - 1; k >= 0; k--) {
    1760717607      double *sol = savedSolutions_[k];
    17608       assert(static_cast<int>(sol[0]) == n);
     17608      assert(static_cast< int >(sol[0]) == n);
    1760917609      if (objectiveValue > sol[1])
    1761017610        break;
     
    1766917669  if (!savePivotMethod && !parentModel_) {
    1767017670    OsiClpSolverInterface *clpSolver
    17671       = dynamic_cast<OsiClpSolverInterface *>(solver_);
     17671      = dynamic_cast< OsiClpSolverInterface * >(solver_);
    1767217672    if (clpSolver && numberNodes_ >= numberNodes && numberNodes_ < 2 * numberNodes && clpSolver->getNumRows() < 10000) {
    1767317673      if (numberIterations_ < (numberSolves_ + numberNodes_) * 10) {
     
    1767517675        ClpSimplex *simplex = clpSolver->getModelPtr();
    1767617676        ClpDualRowPivot *pivotMethod = simplex->dualRowPivot();
    17677         ClpDualRowDantzig *pivot = dynamic_cast<ClpDualRowDantzig *>(pivotMethod);
     17677        ClpDualRowDantzig *pivot = dynamic_cast< ClpDualRowDantzig * >(pivotMethod);
    1767817678        if (!pivot) {
    1767917679          savePivotMethod = pivotMethod->clone(true);
     
    1776417764  synchronizeModel(); // make sure everything that needs solver has it
    1776517765  if (!solverCharacteristics_) {
    17766     OsiBabSolver *solverCharacteristics = dynamic_cast<OsiBabSolver *>(solver_->getAuxiliaryInfo());
     17766    OsiBabSolver *solverCharacteristics = dynamic_cast< OsiBabSolver * >(solver_->getAuxiliaryInfo());
    1776717767    if (solverCharacteristics) {
    1776817768      solverCharacteristics_ = solverCharacteristics;
     
    1777117771      OsiBabSolver defaultC;
    1777217772      solver_->setAuxiliaryInfo(&defaultC);
    17773       solverCharacteristics_ = dynamic_cast<OsiBabSolver *>(solver_->getAuxiliaryInfo());
     17773      solverCharacteristics_ = dynamic_cast< OsiBabSolver * >(solver_->getAuxiliaryInfo());
    1777417774    }
    1777517775  }
     
    1786617866            if (objective[iColumn]) {
    1786717867              double value = fabs(objective[iColumn]) * multiplier;
    17868               int nearest = static_cast<int>(floor(value + 0.5));
     17868              int nearest = static_cast< int >(floor(value + 0.5));
    1786917869              if (fabs(value - floor(value + 0.5)) > 1.0e-8 || value > 2.1e9) {
    1787017870                increment = 0;
     
    1790117901    // do presolve - for now just clp but easy to get osi interface
    1790217902    OsiClpSolverInterface *clpSolver
    17903       = dynamic_cast<OsiClpSolverInterface *>(cleanModel);
     17903      = dynamic_cast< OsiClpSolverInterface * >(cleanModel);
    1790417904    if (clpSolver) {
    1790517905      ClpSimplex *clp = clpSolver->getModelPtr();
     
    1810218102    // do presolve - for now just clp but easy to get osi interface
    1810318103    OsiClpSolverInterface *clpSolver
    18104       = dynamic_cast<OsiClpSolverInterface *>(solver_);
     18104      = dynamic_cast< OsiClpSolverInterface * >(solver_);
    1810518105    assert(clpSolver);
    1810618106    ClpSimplex *clp = clpSolver->getModelPtr();
     
    1815518155#ifdef COIN_HAS_CLP
    1815618156  OsiClpSolverInterface *clpSolver
    18157     = dynamic_cast<OsiClpSolverInterface *>(solver_);
     18157    = dynamic_cast< OsiClpSolverInterface * >(solver_);
    1815818158  if (clpSolver)
    1815918159    clpSolver->setOptionalInteger(index);
     
    1822218222#ifdef COIN_HAS_CLP
    1822318223    OsiClpSolverInterface *clpSolver
    18224       = dynamic_cast<OsiClpSolverInterface *>(solver);
     18224      = dynamic_cast< OsiClpSolverInterface * >(solver);
    1822518225    if (clpSolver) {
    1822618226      double *dj = clpSolver->getModelPtr()->dualColumnSolution();
     
    1828918289  int numberSOS2 = 0;
    1829018290  for (i = 0; i < numberObjects_; i++) {
    18291     CbcSOS *objSOS = dynamic_cast<CbcSOS *>(object_[i]);
     18291    CbcSOS *objSOS = dynamic_cast< CbcSOS * >(object_[i]);
    1829218292    if (objSOS) {
    1829318293      int type = objSOS->sosType();
     
    1830218302    memset(prohibited, 0, numberColumns);
    1830318303    for (i = 0; i < numberObjects_; i++) {
    18304       CbcSOS *objSOS = dynamic_cast<CbcSOS *>(object_[i]);
     18304      CbcSOS *objSOS = dynamic_cast< CbcSOS * >(object_[i]);
    1830518305      if (objSOS) {
    1830618306        int type = objSOS->sosType();
     
    1835918359      if (temp[jColumn] >= 0) {
    1836018360        int iObject = temp[jColumn];
    18361         CbcSimpleInteger *obj = dynamic_cast<CbcSimpleInteger *>(originalObject[iObject]);
     18361        CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(originalObject[iObject]);
    1836218362        if (obj)
    1836318363          numberOldIntegers++;
     
    1839318393      if (temp[jColumn] >= 0) {
    1839418394        int iObject = temp[jColumn];
    18395         CbcSimpleInteger *obj = dynamic_cast<CbcSimpleInteger *>(originalObject[iObject]);
     18395        CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(originalObject[iObject]);
    1839618396        if (obj) {
    1839718397          object_[numberIntegers_] = originalObject[iObject]->clone();
     
    1841318413      if (temp[jColumn] >= 0) {
    1841418414        int iObject = temp[jColumn];
    18415         CbcSimpleInteger *obj = dynamic_cast<CbcSimpleInteger *>(originalObject[iObject]);
     18415        CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(originalObject[iObject]);
    1841618416        if (!obj) {
    1841718417          object_[numberObjects_] = originalObject[iObject]->clone();
    1841818418          // redo ids etc
    18419           CbcObject *obj = dynamic_cast<CbcObject *>(object_[numberObjects_]);
     18419          CbcObject *obj = dynamic_cast< CbcObject * >(object_[numberObjects_]);
    1842018420          assert(obj);
    1842118421          obj->redoSequenceEtc(this, numberColumns, originalColumns);
     
    1843018430        object_[numberObjects_] = originalObject[iObject]->clone();
    1843118431        // redo ids etc
    18432         CbcObject *obj = static_cast<CbcObject *>(object_[numberObjects_]);
     18432        CbcObject *obj = static_cast< CbcObject * >(object_[numberObjects_]);
    1843318433        assert(obj);
    1843418434        obj->redoSequenceEtc(this, numberColumns, originalColumns);
     
    1864518645    const OsiObject *object = object_[i];
    1864618646#ifndef NDEBUG
    18647     const CbcSimpleInteger *integerObject = dynamic_cast<const CbcSimpleInteger *>(object);
     18647    const CbcSimpleInteger *integerObject = dynamic_cast< const CbcSimpleInteger * >(object);
    1864818648    assert(integerObject);
    1864918649#else
    18650       const CbcSimpleInteger *integerObject = static_cast<const CbcSimpleInteger *>(object);
     18650      const CbcSimpleInteger *integerObject = static_cast< const CbcSimpleInteger * >(object);
    1865118651#endif
    1865218652    // get original bounds
     
    1877718777    const OsiObject *object = object_[i];
    1877818778#ifndef NDEBUG
    18779     const CbcSimpleInteger *integerObject = dynamic_cast<const CbcSimpleInteger *>(object);
     18779    const CbcSimpleInteger *integerObject = dynamic_cast< const CbcSimpleInteger * >(object);
    1878018780    assert(integerObject);
    1878118781#else
    18782       const CbcSimpleInteger *integerObject = static_cast<const CbcSimpleInteger *>(object);
     18782      const CbcSimpleInteger *integerObject = static_cast< const CbcSimpleInteger * >(object);
    1878318783#endif
    1878418784    // get original bounds
     
    1886618866static void *doRootCbcThread(void *voidInfo)
    1886718867{
    18868   CbcModel *model = reinterpret_cast<CbcModel *>(voidInfo);
     18868  CbcModel *model = reinterpret_cast< CbcModel * >(voidInfo);
    1886918869#ifdef COIN_HAS_CLP
    1887018870  OsiClpSolverInterface *clpSolver
    18871     = dynamic_cast<OsiClpSolverInterface *>(model->solver());
     18871    = dynamic_cast< OsiClpSolverInterface * >(model->solver());
    1887218872  char general[200];
    1887318873  if (clpSolver) {
     
    1890718907#ifdef COIN_HAS_CLP
    1890818908  const OsiClpSolverInterface *clpSolver
    18909     = dynamic_cast<const OsiClpSolverInterface *>(solver);
     18909    = dynamic_cast< const OsiClpSolverInterface * >(solver);
    1891018910  if (clpSolver && topOfTree_) {
    1891118911    int debugMode = 0;
     
    1926819268  mipStart_.clear();
    1926919269  for (int i = 0; (i < count); ++i)
    19270     mipStart_.push_back(std::pair<std::string, double>(std::string(colNames[i]), colValues[i]));
     19270    mipStart_.push_back(std::pair< std::string, double >(std::string(colNames[i]), colValues[i]));
    1927119271}
    1927219272#ifdef COIN_HAS_NTY
     
    1928719287#ifdef COIN_HAS_CLP
    1928819288  OsiClpSolverInterface *clpSolver
    19289     = dynamic_cast<OsiClpSolverInterface *>(solver_);
     19289    = dynamic_cast< OsiClpSolverInterface * >(solver_);
    1929019290  if (clpSolver) {
    1929119291    int numberColumns = clpSolver->getNumCols();
     
    1929519295    int numberSOS = 0;
    1929619296    for (int i = 0; i < numberObjects_; i++) {
    19297       CbcObject *obj = dynamic_cast<CbcObject *>(object_[i]);
    19298       CbcSimpleInteger *thisInt = dynamic_cast<CbcSimpleInteger *>(obj);
    19299       OsiSOS *objSOS1 = dynamic_cast<OsiSOS *>(obj);
    19300       CbcSOS *objSOS2 = dynamic_cast<CbcSOS *>(obj);
     19297      CbcObject *obj = dynamic_cast< CbcObject * >(object_[i]);
     19298      CbcSimpleInteger *thisInt = dynamic_cast< CbcSimpleInteger * >(obj);
     19299      OsiSOS *objSOS1 = dynamic_cast< OsiSOS * >(obj);
     19300      CbcSOS *objSOS2 = dynamic_cast< CbcSOS * >(obj);
    1930119301      if (thisInt) {
    1930219302        clpSolver->setInteger(thisInt->columnNumber());
     
    1932119321      numberSOS = 0;
    1932219322      for (int i = 0; i < numberObjects_; i++) {
    19323         CbcObject *obj = dynamic_cast<CbcObject *>(object_[i]);
    19324         OsiSOS *objSOS1 = dynamic_cast<OsiSOS *>(obj);
    19325         CbcSOS *objSOS2 = dynamic_cast<CbcSOS *>(obj);
     19323        CbcObject *obj = dynamic_cast< CbcObject * >(object_[i]);
     19324        OsiSOS *objSOS1 = dynamic_cast< OsiSOS * >(obj);
     19325        CbcSOS *objSOS2 = dynamic_cast< CbcSOS * >(obj);
    1932619326        if (objSOS1 || objSOS2) {
    1932719327          int numberMembers;
     
    1936619366#define ZERO_ODD_TOLERANCE 1.0e-14
    1936719367#endif
    19368   OsiClpSolverInterface *osiclp = dynamic_cast<OsiClpSolverInterface *>(solver);
     19368  OsiClpSolverInterface *osiclp = dynamic_cast< OsiClpSolverInterface * >(solver);
    1936919369  if (osiclp && osiclp->isProvenOptimal()) {
    1937019370    int numberColumns = osiclp->getNumCols();
     
    1943419434CbcModel::setupCleanVariables()
    1943519435{
    19436   OsiClpSolverInterface *osiclp = dynamic_cast<OsiClpSolverInterface *>(solver_);
     19436  OsiClpSolverInterface *osiclp = dynamic_cast< OsiClpSolverInterface * >(solver_);
    1943719437  int numberColumns = osiclp->getNumCols();
    1943819438  char *cleanVariables = NULL;
     
    1944119441    memset(cleanVariables, 0, numberColumns);
    1944219442    for (int i = 0; i < numberObjects_; i++) {
    19443       const CbcSimpleInteger *intvar = dynamic_cast<const CbcSimpleInteger *>(object_[i]);
    19444       const CbcSOS *sos = dynamic_cast<const CbcSOS *>(object_[i]);
     19443      const CbcSimpleInteger *intvar = dynamic_cast< const CbcSimpleInteger * >(object_[i]);
     19444      const CbcSOS *sos = dynamic_cast< const CbcSOS * >(object_[i]);
    1944519445      if (intvar) {
    1944619446#ifdef CLEAN_INTEGER_VARIABLES
  • trunk/Cbc/src/CbcModel.hpp

    r2465 r2467  
    26912691  //@}
    26922692
    2693   void setMIPStart(const std::vector<std::pair<std::string, double>> &mips)
     2693  void setMIPStart(const std::vector< std::pair< std::string, double > > &mips)
    26942694  {
    26952695    this->mipStart_ = mips;
     
    27002700  void setMIPStart(int count, const char **colNames, const double colValues[]);
    27012701
    2702   const std::vector<std::pair<std::string, double>> &getMIPStart()
     2702  const std::vector< std::pair< std::string, double > > &getMIPStart()
    27032703  {
    27042704    return this->mipStart_;
     
    27822782      values for integer variables which will be converted to a complete integer initial feasible solution
    27832783    */
    2784   std::vector<std::pair<std::string, double>> mipStart_;
     2784  std::vector< std::pair< std::string, double > > mipStart_;
    27852785  /** Warm start object produced by heuristic or strong branching
    27862786
  • trunk/Cbc/src/CbcNode.cpp

    r2465 r2467  
    140140        */
    141141    bool mustDeleteBasis;
    142     const CoinWarmStartBasis *ws = dynamic_cast<const CoinWarmStartBasis *>(solver->getPointerToWarmStart(mustDeleteBasis));
     142    const CoinWarmStartBasis *ws = dynamic_cast< const CoinWarmStartBasis * >(solver->getPointerToWarmStart(mustDeleteBasis));
    143143    assert(ws != NULL); // make sure not volume
    144144    //int numberArtificials = lastws->getNumArtificial();
     
    159159          and new cuts (numberNewCuts). This will become the expanded basis.
    160160        */
    161     CoinWarmStartBasis *expanded = dynamic_cast<CoinWarmStartBasis *>(ws->clone());
     161    CoinWarmStartBasis *expanded = dynamic_cast< CoinWarmStartBasis * >(ws->clone());
    162162    int iCompact = numberRowsAtContinuous + numberOldActiveCuts + numberNewCuts;
    163163    // int nPartial = numberRowsAtContinuous+currentNumberCuts;
     
    349349  else {
    350350    bool mustDeleteBasis;
    351     const CoinWarmStartBasis *ws = dynamic_cast<const CoinWarmStartBasis *>(solver->getPointerToWarmStart(mustDeleteBasis));
     351    const CoinWarmStartBasis *ws = dynamic_cast< const CoinWarmStartBasis * >(solver->getPointerToWarmStart(mustDeleteBasis));
    352352    assert(ws != NULL); // make sure not volume
    353353    //int numberArtificials = lastws->getNumArtificial();
     
    384384        basis. Makes me (Lou) less nervous to compare apples to apples.
    385385        */
    386     CoinWarmStartBasis *expanded = dynamic_cast<CoinWarmStartBasis *>(ws->clone());
     386    CoinWarmStartBasis *expanded = dynamic_cast< CoinWarmStartBasis * >(ws->clone());
    387387    int numberRowsAtContinuous = model->numberRowsAtContinuous();
    388388    int iFull = numberRowsAtContinuous + model->currentNumberCuts() + numberNewCuts;
     
    532532  char *cleanVariables = NULL;
    533533#ifdef COIN_HAS_CLP
    534   OsiClpSolverInterface *osiclp = dynamic_cast<OsiClpSolverInterface *>(solver);
     534  OsiClpSolverInterface *osiclp = dynamic_cast< OsiClpSolverInterface * >(solver);
    535535  int saveClpOptions = 0;
    536536  if (osiclp) {
     
    588588      for (int i = 0; i < numberObjects; i++) {
    589589        OsiObject *object = model->modifiableObject(i);
    590         const CbcSimpleInteger *thisOne = dynamic_cast<const CbcSimpleInteger *>(object);
     590        const CbcSimpleInteger *thisOne = dynamic_cast< const CbcSimpleInteger * >(object);
    591591        if (thisOne) {
    592592          int iColumn = thisOne->columnNumber();
     
    634634    */
    635635  CbcBranchDecision *decision = model->branchingMethod();
    636   CbcDynamicPseudoCostBranchingObject *dynamicBranchingObject = dynamic_cast<CbcDynamicPseudoCostBranchingObject *>(decision);
     636  CbcDynamicPseudoCostBranchingObject *dynamicBranchingObject = dynamic_cast< CbcDynamicPseudoCostBranchingObject * >(decision);
    637637  if (!decision || dynamicBranchingObject)
    638638    decision = new CbcBranchDefaultDecision();
     
    694694        if (hotstartSolution) {
    695695          // we are doing hot start
    696           const CbcSimpleInteger *thisOne = dynamic_cast<const CbcSimpleInteger *>(object);
     696          const CbcSimpleInteger *thisOne = dynamic_cast< const CbcSimpleInteger * >(object);
    697697          if (thisOne) {
    698698            int iColumn = thisOne->columnNumber();
     
    782782            choice[iSmallest].upMovement = infeasibility;
    783783            delete choice[iSmallest].possibleBranch;
    784             CbcObject *obj = dynamic_cast<CbcObject *>(object);
     784            CbcObject *obj = dynamic_cast< CbcObject * >(object);
    785785            assert(obj);
    786786            choice[iSmallest].possibleBranch = obj->createCbcBranch(solver, &usefulInfo, preferredWay);
     
    812812          int k = choice[0].objectNumber;
    813813          OsiObject *object = model->modifiableObject(k);
    814           const CbcSimpleInteger *thisOne = dynamic_cast<const CbcSimpleInteger *>(object);
     814          const CbcSimpleInteger *thisOne = dynamic_cast< const CbcSimpleInteger * >(object);
    815815          assert(thisOne);
    816816          int iColumn = thisOne->columnNumber();
     
    826826        bool roundAgain = false;
    827827        // get basis
    828         CoinWarmStartBasis *ws = dynamic_cast<CoinWarmStartBasis *>(solver->getWarmStart());
     828        CoinWarmStartBasis *ws = dynamic_cast< CoinWarmStartBasis * >(solver->getWarmStart());
    829829        if (!ws)
    830830          break;
     
    871871      choice[i].numIntInfeasDown = numberUnsatisfied_;
    872872      choice[i].fix = 0; // say not fixed
    873       if (!dynamic_cast<const CbcSimpleInteger *>(model->object(choice[i].objectNumber)))
     873      if (!dynamic_cast< const CbcSimpleInteger * >(model->object(choice[i].objectNumber)))
    874874        allNormal = false; // Something odd so lets skip clever fast branching
    875875      if (!model->object(choice[i].objectNumber)->boundBranch())
     
    957957        int *whichColumn = new int[2 * numberColumns];
    958958        int nBound;
    959         ClpSimplex *small = static_cast<ClpSimplexOther *>(clp)->crunch(rhs, whichRow, whichColumn, nBound, true);
     959        ClpSimplex *small = static_cast< ClpSimplexOther * >(clp)->crunch(rhs, whichRow, whichColumn, nBound, true);
    960960        if (!small) {
    961961          anyAction = -2;
     
    10001000          int iObject = choice[i].objectNumber;
    10011001          const OsiObject *object = model->object(iObject);
    1002           const CbcSimpleInteger *simple = static_cast<const CbcSimpleInteger *>(object);
     1002          const CbcSimpleInteger *simple = static_cast< const CbcSimpleInteger * >(object);
    10031003          int iSequence = simple->columnNumber();
    10041004          newLower[i] = ceil(saveSolution[iSequence]);
     
    10351035            int iObject = choice[i].objectNumber;
    10361036            const OsiObject *object = model->object(iObject);
    1037             const CbcSimpleInteger *simple = static_cast<const CbcSimpleInteger *>(object);
     1037            const CbcSimpleInteger *simple = static_cast< const CbcSimpleInteger * >(object);
    10381038            int iSequence = simple->columnNumber();
    10391039            which[i] = iSequence;
     
    16321632  // get information on solver type
    16331633  const OsiAuxInfo *auxInfo = solver->getAuxiliaryInfo();
    1634   const OsiBabSolver *auxiliaryInfo = dynamic_cast<const OsiBabSolver *>(auxInfo);
     1634  const OsiBabSolver *auxiliaryInfo = dynamic_cast< const OsiBabSolver * >(auxInfo);
    16351635  if (!auxiliaryInfo) {
    16361636    // use one from CbcModel
     
    16451645    for (int i = model->numberIntegers(); i < numberObjects; i++) {
    16461646      OsiObject *object = model->modifiableObject(i);
    1647       CbcObject *obj = dynamic_cast<CbcObject *>(object);
     1647      CbcObject *obj = dynamic_cast< CbcObject * >(object);
    16481648      if (!obj || !obj->optionalObject()) {
    16491649        double infeasibility = object->checkInfeasibility(&usefulInfo);
     
    16711671    for (int i = 0; i < numberRows; i++)
    16721672      sumPi += fabs(pi[i]);
    1673     sumPi /= static_cast<double>(numberRows);
     1673    sumPi /= static_cast< double >(numberRows);
    16741674    // and scale back
    16751675    sumPi *= 0.01;
     
    17351735      for (int i = 0; i < numberObjects; i++) {
    17361736        OsiObject *object = model->modifiableObject(i);
    1737         const CbcSimpleInteger *thisOne = dynamic_cast<const CbcSimpleInteger *>(object);
     1737        const CbcSimpleInteger *thisOne = dynamic_cast< const CbcSimpleInteger * >(object);
    17381738        if (thisOne) {
    17391739          int iColumn = thisOne->columnNumber();
     
    18011801    for (i = 0; i < numberObjects; i++) {
    18021802      OsiObject *object = model->modifiableObject(i);
    1803       CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast<CbcSimpleIntegerDynamicPseudoCost *>(object);
     1803      CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object);
    18041804      assert(dynamicObject);
    18051805      int numberUp2 = 0;
     
    18241824    }
    18251825    if (numberUp)
    1826       averageUp /= static_cast<double>(numberUp);
     1826      averageUp /= static_cast< double >(numberUp);
    18271827    else
    18281828      averageUp = 1.0;
    18291829    if (numberDown)
    1830       averageDown /= static_cast<double>(numberDown);
     1830      averageDown /= static_cast< double >(numberDown);
    18311831    else
    18321832      averageDown = 1.0;
     
    18421842  char *cleanVariables = NULL;
    18431843#ifdef COIN_HAS_CLP
    1844   OsiClpSolverInterface *osiclp = dynamic_cast<OsiClpSolverInterface *>(solver);
     1844  OsiClpSolverInterface *osiclp = dynamic_cast< OsiClpSolverInterface * >(solver);
    18451845  int saveClpOptions = 0;
    18461846  if (osiclp) {
     
    18701870    for (i = 0; i < numberObjects; i++) {
    18711871      OsiObject *object = model->modifiableObject(i);
    1872       CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast<CbcSimpleIntegerDynamicPseudoCost *>(object);
     1872      CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object);
    18731873      if (dynamicObject) {
    18741874        if (dynamicObject->numberTimesUp()) {
     
    18831883    }
    18841884    if (numberUp)
    1885       averageUp /= static_cast<double>(numberUp);
     1885      averageUp /= static_cast< double >(numberUp);
    18861886    else
    18871887      averageUp = 1.0;
    18881888    if (numberDown)
    1889       averageDown /= static_cast<double>(numberDown);
     1889      averageDown /= static_cast< double >(numberDown);
    18901890    else
    18911891      averageDown = 1.0;
    18921892    for (i = 0; i < numberObjects; i++) {
    18931893      OsiObject *object = model->modifiableObject(i);
    1894       CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast<CbcSimpleIntegerDynamicPseudoCost *>(object);
     1894      CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object);
    18951895      if (dynamicObject) {
    18961896        if (!dynamicObject->numberTimesUp())
     
    20822082      for (i = 0; i < numberObjects; i++) {
    20832083        OsiObject *object = model->modifiableObject(i);
    2084         CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast<CbcSimpleIntegerDynamicPseudoCost *>(object);
     2084        CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object);
    20852085        double infeasibility = object->checkInfeasibility(&usefulInfo);
    20862086        int priorityLevel = object->priority();
    20872087        if (hotstartSolution) {
    20882088          // we are doing hot start
    2089           const CbcSimpleInteger *thisOne = dynamic_cast<const CbcSimpleInteger *>(object);
     2089          const CbcSimpleInteger *thisOne = dynamic_cast< const CbcSimpleInteger * >(object);
    20902090          if (thisOne) {
    20912091            int iColumn = thisOne->columnNumber();
     
    21912191          } else {
    21922192            // see if SOS
    2193             CbcSOS *sosObject = dynamic_cast<CbcSOS *>(object);
     2193            CbcSOS *sosObject = dynamic_cast< CbcSOS * >(object);
    21942194            if (sosObject) {
    21952195              gotDown = false;
     
    23732373              for (int i = 0; i < numberObjects; i++) {
    23742374                OsiObject *object = model->modifiableObject(i);
    2375                 CbcSimpleIntegerDynamicPseudoCost *obj = dynamic_cast<CbcSimpleIntegerDynamicPseudoCost *>(object);
     2375                CbcSimpleIntegerDynamicPseudoCost *obj = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object);
    23762376                assert(obj);
    23772377                int iColumn = obj->columnNumber();
     
    23972397        bool roundAgain = false;
    23982398        // get basis
    2399         CoinWarmStartBasis *ws = dynamic_cast<CoinWarmStartBasis *>(solver->getWarmStart());
     2399        CoinWarmStartBasis *ws = dynamic_cast< CoinWarmStartBasis * >(solver->getWarmStart());
    24002400        if (!ws)
    24012401          break;
     
    25002500      int preferredWay;
    25012501      object->infeasibility(&usefulInfo, preferredWay);
    2502       CbcObject *obj = dynamic_cast<CbcObject *>(object);
     2502      CbcObject *obj = dynamic_cast< CbcObject * >(object);
    25032503      assert(obj);
    25042504      branch_ = obj->createCbcBranch(solver, &usefulInfo, preferredWay);
    25052505      {
    2506         CbcBranchingObject *branchObj = dynamic_cast<CbcBranchingObject *>(branch_);
     2506        CbcBranchingObject *branchObj = dynamic_cast< CbcBranchingObject * >(branch_);
    25072507        assert(branchObj);
    25082508        branchObj->way(preferredWay);
     
    25342534          } else if (gap < 1.0e5) {
    25352535            // maybe allow some not needed
    2536             int extra = static_cast<int>((1.0e6 - needed) / numberRows);
     2536            int extra = static_cast< int >((1.0e6 - needed) / numberRows);
    25372537            int nStored = numberObjects - optionalPenalties;
    25382538            extra = CoinMin(extra, nStored);
     
    25802580            int iObject = whichObject[j];
    25812581            OsiObject *object = model->modifiableObject(iObject);
    2582             CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast<CbcSimpleIntegerDynamicPseudoCost *>(object);
     2582            CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object);
    25832583            // Use this object's numberBeforeTrust
    25842584            int numberBeforeTrustThis = dynamicObject->numberBeforeTrust();
     
    26012601              sort[j] = -min1;
    26022602            } else if (numberThisDown < numberBeforeTrustThis || numberThisUp < numberBeforeTrustThis) {
    2603               double invTrust = 1.0 / static_cast<double>(numberBeforeTrustThis);
     2603              double invTrust = 1.0 / static_cast< double >(numberBeforeTrustThis);
    26042604              if (numberThisDown < numberBeforeTrustThis) {
    26052605                double fraction = numberThisDown * invTrust;
     
    29352935                  int iObject = whichObject[iDo];
    29362936                  OsiObject *object = model->modifiableObject(iObject);
    2937                   CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast<CbcSimpleIntegerDynamicPseudoCost *>(object);
     2937                  CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object);
    29382938                  int iColumn = dynamicObject ? dynamicObject->columnNumber() : -1;
    29392939                  if (iColumn < 0 || orbits[iColumn] >= 0)
     
    29652965        int iObject = whichObject[iDo];
    29662966        OsiObject *object = model->modifiableObject(iObject);
    2967         CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast<CbcSimpleIntegerDynamicPseudoCost *>(object);
     2967        CbcSimpleIntegerDynamicPseudoCost *dynamicObject = dynamic_cast< CbcSimpleIntegerDynamicPseudoCost * >(object);
    29682968        int iColumn = dynamicObject ? dynamicObject->columnNumber() : numberColumns + iObject;
    29692969        int preferredWay;
     
    29822982        }
    29832983#endif
    2984         CbcSimpleInteger *obj = dynamic_cast<CbcSimpleInteger *>(object);
     2984        CbcSimpleInteger *obj = dynamic_cast< CbcSimpleInteger * >(object);
    29852985        if (obj) {
    29862986          if (choiceObject) {
     
    29912991          }
    29922992        } else {