Ignore:
Timestamp:
Nov 18, 2014 6:15:36 AM (5 years ago)
Author:
forrest
Message:

for memory leaks and heuristics and some experimental stuff

File:
1 edited

Legend:

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

    r2092 r2094  
    448448        if (!numberContinuousObj && numberIntegerObj <= 5 && numberIntegerWeight <= 100 &&
    449449                numberIntegerObj*3 < numberObjects_ && !parentModel_ && solver_->getNumRows() > 100)
    450           iType = 1 + 4 + ((moreSpecialOptions_&536870912)==0) ? 2 : 0;
     450          iType = 1 + 4 + (((moreSpecialOptions_&536870912)==0) ? 2 : 0);
    451451        else if (!numberContinuousObj && numberIntegerObj <= 100 &&
    452452                 numberIntegerObj*5 < numberObjects_ && numberIntegerWeight <= 100 &&
    453453                 !parentModel_ &&
    454454                 solver_->getNumRows() > 100 && cost != -COIN_DBL_MAX)
    455           iType = 4 + ((moreSpecialOptions_&536870912)==0) ? 2 : 0;
     455          iType = 4 + (((moreSpecialOptions_&536870912)==0) ? 2 : 0);
    456456        else if (!numberContinuousObj && numberIntegerObj <= 100 &&
    457457                 numberIntegerObj*5 < numberObjects_ &&
     
    590590                   !numberContinuousObj &&
    591591                   !numberGeneralIntegerObj &&
    592                    numberIntegerObj*2 < numberColumns) {
     592                   numberIntegerObj*2 < CoinMin(numberColumns,20)) {
    593593            // up priorities on costed
    594594            int iPriority = -1;
     
    601601            }
    602602            if (iPriority >= 100) {
    603 #ifdef CLP_INVESTIGATE
     603#if CBC_USEFUL_PRINTING>1
    604604                printf("Setting variables with obj to high priority\n");
    605605#endif
     
    10911091        int numberColumns = getNumCols();
    10921092        if (tryNewSearch) {
    1093 #ifdef CLP_INVESTIGATE
     1093#if CBC_USEFUL_PRINTING>1
    10941094            printf("after %d nodes, cutoff %g - looking\n",
    10951095                   numberNodes_, getCutoff());
     
    12371237    int numberColumns = continuousSolver_->getNumCols();
    12381238    int numberRows = continuousSolver_->getNumRows();
     1239    int numberOriginalIntegers = numberIntegers_;
    12391240    int * del = new int [CoinMax(numberColumns, numberRows)];
    12401241    int * original = new int [numberColumns];
     
    12951296        if (continuousSolver_->isInteger(i))
    12961297            del[nDel++] = i;
     1298    }
     1299    {
     1300      // we must not exclude current best solution (rounding errors)
     1301      // also not if large values
     1302      const int * row = continuousSolver_->getMatrixByCol()->getIndices();
     1303      const CoinBigIndex * columnStart = continuousSolver_->getMatrixByCol()->getVectorStarts();
     1304      const int * columnLength = continuousSolver_->getMatrixByCol()->getVectorLengths();
     1305      const double * solution = continuousSolver_->getColSolution();
     1306      for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
     1307        if (!continuousSolver_->isInteger(iColumn)) {
     1308          double value = bestSolution_ ? bestSolution_[iColumn] : 0.0;
     1309          double value2 = solution[iColumn];
     1310          if (fabs(value-floor(value+0.5))>1.0e-8 ||
     1311              fabs(value2)>1.0e3) {
     1312            CoinBigIndex start = columnStart[iColumn];
     1313            CoinBigIndex end = start + columnLength[iColumn];
     1314            for (CoinBigIndex j = start; j < end; j++) {
     1315              int iRow = row[j];
     1316              possibleRow[iRow]=0;
     1317            }
     1318          }
     1319        }
     1320      }
    12971321    }
    12981322    int nExtra = 0;
     
    14471471            int n = clpSolver->getModelPtr()->findNetwork(rotate, 1.0);
    14481472            delete [] rotate;
    1449 #ifdef CLP_INVESTIGATE
     1473#if CBC_USEFUL_PRINTING>1
    14501474            printf("INTA network %d rows out of %d\n", n, numberRows);
    14511475#endif
     
    14551479                    if (!possibleRow[i]) {
    14561480                        couldBeNetwork = false;
    1457 #ifdef CLP_INVESTIGATE
     1481#if CBC_USEFUL_PRINTING>1
    14581482                        printf("but row %d is bad\n", i);
    14591483#endif
     
    15351559                assert(solver_->isInteger(i));
    15361560        }
    1537 #ifdef CLP_INVESTIGATE
     1561#if CBC_USEFUL_PRINTING>1
    15381562        if (couldBeNetwork || nExtra)
    15391563            printf("INTA %d extra integers, %d left%s\n", nExtra,
     
    15441568        convertToDynamic();
    15451569    }
    1546 #ifdef CLP_INVESTIGATE
     1570#if CBC_USEFUL_PRINTING>1
    15471571    if (!couldBeNetwork && copy1->getNumCols() &&
    15481572            copy1->getNumRows()) {
     
    15621586    // double check increment
    15631587    analyzeObjective();
     1588    // If any changes - tell code
     1589    if(numberOriginalIntegers<numberIntegers_)
     1590      synchronizeModel();
    15641591}
    15651592/**
     
    15751602*/
    15761603
     1604#ifdef CONFLICT_CUTS
     1605#if PRINT_CONFLICT==1
     1606static int numberConflictCuts=0;
     1607static int lastNumberConflictCuts=0;
     1608static double lengthConflictCuts=0.0;
     1609#endif
     1610#endif
    15771611/*
    15781612  The overall flow can be divided into three stages:
     
    19922026            ClpSimplex * clpSimplex = clpSolver->getModelPtr();
    19932027            if ((specialOptions_&32) == 0) {
    1994                 // take off names
    1995                 clpSimplex->dropNames();
     2028                // take off names (unless going to be saving)
     2029                if (numberAnalyzeIterations_>=0||(-numberAnalyzeIterations_&64)==0)
     2030                  clpSimplex->dropNames();
    19962031            }
    19972032            // no crunch if mostly continuous
     
    22272262        if (numberThreads_ > 0) {
    22282263            // switch off fast nodes for now
    2229             fastNodeDepth_ = -1;
     2264            //fastNodeDepth_ = -1;
    22302265        }
    22312266    }
     
    22892324      constraint system (aka the continuous system).
    22902325    */
     2326    delete continuousSolver_;
    22912327    continuousSolver_ = solver_->clone() ;
    22922328#ifdef COIN_HAS_NTY
     
    22962332      symmetryInfo_->setupSymmetry(*continuousSolver_);
    22972333      int numberGenerators = symmetryInfo_->statsOrbits(this,0);
    2298       if (!numberGenerators&&(moreSpecialOptions2_&(128|256))!=(128|256)) {
     2334      if (!symmetryInfo_->numberUsefulOrbits()&&(moreSpecialOptions2_&(128|256))!=(128|256)) {
    22992335        delete symmetryInfo_;
    23002336        symmetryInfo_=NULL;
     
    25882624        rootModels[i]->setSpecialOptions(specialOptions_ |(4194304|8388608));
    25892625        rootModels[i]->setMoreSpecialOptions(moreSpecialOptions_ &
    2590                                              (~134217728));
     2626                                             (~(134217728|4194304)));
    25912627        rootModels[i]->setMoreSpecialOptions2(moreSpecialOptions2_ &
    2592                                              (~128));
     2628                                              (~(128|256)));
    25932629        rootModels[i]->solver_->setWarmStart(basis);
    25942630#ifdef COIN_HAS_CLP
     
    26362672            simplex->primal();
    26372673#endif
     2674#endif
    26382675          }
    26392676#ifdef NEW_RANDOM_BASIS
     
    26422679#endif
    26432680        }
    2644 #endif
    26452681        for (int j=0;j<numberHeuristics_;j++)
    26462682          rootModels[i]->heuristic_[j]->setSeed(rootModels[i]->heuristic_[j]->getSeed()+100000000*i);
     
    35393575    //solverCharacteristics_->setSolver(solver_);
    35403576    if (feasible) {
     3577      // mark all cuts as globally valid
     3578      int numberCuts=cuts.sizeRowCuts();
     3579      for (int i=0;i<numberCuts;i++) {
     3580        cuts.rowCutPtr(i)->setGloballyValid();
     3581        whichGenerator_[i]=20000+(whichGenerator_[i]%10000);
     3582      }
    35413583#define HOTSTART -1
    35423584#if HOTSTART<0
     
    36373679                        }
    36383680                    }
    3639 #ifdef CLP_INVESTIGATE
     3681#if CBC_USEFUL_PRINTING>1
    36403682                    printf("%d forced, %d naturally at lower, %d at upper - %d zero dj\n",
    36413683                           nForced, nAtLbNatural, nAtUbNatural, nZeroDj);
     
    38593901        int numberPassesLeft = 1000;
    38603902        // This is first crude step
    3861         if (numberAnalyzeIterations_) {
     3903        if (numberAnalyzeIterations_ && !parentModel_) {
    38623904            delete [] analyzeResults_;
    3863             analyzeResults_ = new double [4*numberIntegers_];
     3905            int numberColumns = solver_->getNumCols();
     3906            analyzeResults_ = new double [5*numberIntegers_];
    38643907            numberFixedAtRoot_ = newNode->analyze(this, analyzeResults_);
    38653908            if (numberFixedAtRoot_ > 0) {
     
    38763919        }
    38773920        OsiSolverBranch * branches = NULL;
    3878         anyAction = chooseBranch(newNode, numberPassesLeft, NULL, cuts, resolved,
     3921        if (feasible)
     3922          anyAction = chooseBranch(newNode, numberPassesLeft, NULL, cuts, resolved,
    38793923                                 NULL, NULL, NULL, branches);
    38803924        if (anyAction == -2 || newNode->objectiveValue() >= cutoff) {
     
    39724016            }
    39734017            if (probingInfo_->packDown()) {
    3974 #ifdef CLP_INVESTIGATE
     4018#if CBC_USEFUL_PRINTING>1
    39754019                printf("%d implications on %d 0-1\n", toZero[number01], number01);
    39764020#endif
     
    39794023                addCutGenerator(&implication, 1, "ImplicationCuts", true, false, false, -200);
    39804024                generator_[numberCutGenerators_-1]->setGlobalCuts(true);
     4025                generator_[numberCutGenerators_-1]->setTiming(true);
    39814026            } else {
    39824027                delete probingInfo_;
     
    42134258                ClpSimplex * simplex = clpSolver->getModelPtr();
    42144259                int perturbation = simplex->perturbation();
    4215 #ifdef CLP_INVESTIGATE
     4260#if CBC_USEFUL_PRINTING>1
    42164261                printf("Testing its n,s %d %d solves n,s %d %d - pert %d\n",
    42174262                       numberIterations_, saveNumberIterations,
     
    42224267                    // switch off perturbation
    42234268                    simplex->setPerturbation(100);
    4224 #ifdef CLP_INVESTIGATE
     4269#if CBC_USEFUL_PRINTING>1
    42254270                    printf("Perturbation switched off\n");
    42264271#endif
     
    42364281                int numberColumns = getNumCols();
    42374282                if (tryNewSearch) {
    4238                     checkCutoffForRestart = getCutoff() ;
    4239 #ifdef CLP_INVESTIGATE
     4283                    // adding increment back allows current best - tiny bit weaker
     4284                    checkCutoffForRestart = getCutoff() + getCutoffIncrement() ;
     4285#if CBC_USEFUL_PRINTING>1
    42404286                    printf("after %d nodes, cutoff %g - looking\n",
    42414287                           numberNodes_, getCutoff());
     
    43144360                        tryNewSearch = false;
    43154361                }
     4362#ifdef CONFLICT_CUTS
     4363                // temporary
     4364                if ((moreSpecialOptions_&4194304)!=0)
     4365                  tryNewSearch=false;
     4366#endif
    43164367                if (tryNewSearch) {
    43174368                    // back to solver without cuts?
     
    44464497                            break;
    44474498                        }
     4499                        // add as global cut
     4500                        objLower[i]=-COIN_DBL_MAX;
     4501                        OsiRowCut rc;
     4502                        rc.setLb(newLower[i]);
     4503                        rc.setUb(COIN_DBL_MAX);
     4504                        double one=1.0;
     4505                        rc.setRow(1,integerVariable_+i,&one,false);
     4506                        rc.setGloballyValidAsInteger(2);
     4507                        globalCuts_.addCutIfNotDuplicate(rc) ;
    44484508                    } else if (objUpper[i] > newCutoff) {
    44494509                        n++;
     4510                        // add as global cut
     4511                        objUpper[i]=-COIN_DBL_MAX;
     4512                        OsiRowCut rc;
     4513                        rc.setLb(-COIN_DBL_MAX);
     4514                        rc.setUb(newUpper[i]);
     4515                        double one=1.0;
     4516                        rc.setRow(1,integerVariable_+i,&one,false);
     4517                        rc.setGloballyValidAsInteger(2);
     4518                        globalCuts_.addCutIfNotDuplicate(rc) ;
    44504519                    }
    44514520                }
     
    45364605#endif
    45374606            unlockThread();
    4538 #ifdef CLP_INVESTIGATE
     4607#if CBC_USEFUL_PRINTING>1
    45394608            if (getCutoff() < 1.0e20) {
    45404609                if (fabs(getCutoff() - (bestObjective_ - getCutoffIncrement())) > 1.0e-6 &&
     
    45664635            } else {
    45674636                messageHandler()->message(CBC_STATUS3, messages())
    4568                 << numberNodes_ << numberExtraNodes_ << nNodes << bestObjective_ << bestPossibleObjective_
     4637                << numberNodes_ << numberFathoms_ << numberExtraNodes_ << nNodes
     4638                << bestObjective_ << bestPossibleObjective_
    45694639                << tree_->lastDepth() << tree_->lastUnsatisfied() << numberIterations_ << numberExtraIterations_
    45704640                << getCurrentSeconds()
     
    45744644            if (symmetryInfo_)
    45754645              symmetryInfo_->statsOrbits(this,1);
     4646#endif
     4647#if PRINT_CONFLICT==1
     4648            if (numberConflictCuts>lastNumberConflictCuts) {
     4649              double length = lengthConflictCuts/numberConflictCuts;
     4650              printf("%d new conflict cuts - total %d - average length %g\n",
     4651                     numberConflictCuts-lastNumberConflictCuts,
     4652                     numberConflictCuts,length);
     4653              lastNumberConflictCuts = numberConflictCuts;
     4654            }
    45764655#endif
    45774656            if (eventHandler && !eventHandler->event(CbcEventHandler::treeStatus)) {
     
    48014880        << CoinMessageEol ;
    48024881    }
     4882    if ((moreSpecialOptions_&4194304)!=0) {
     4883      // Conflict cuts
     4884      int numberCuts = globalCuts_.sizeRowCuts();
     4885      int nConflict=0;
     4886      double sizeConflict = 0.0;
     4887      for (int i=0;i<numberCuts;i++) {
     4888        OsiRowCut2 * cut = globalCuts_.cut(i);
     4889        if (cut->whichRow()==1) {
     4890          nConflict++;
     4891          sizeConflict += cut->row().getNumElements();
     4892        }
     4893      }
     4894      if (nConflict) {
     4895        sizeConflict /= nConflict;
     4896        char general[200];
     4897        sprintf(general, "%d conflict cuts generated - average length %g",
     4898                nConflict,sizeConflict);
     4899        messageHandler()->message(CBC_GENERAL,
     4900                                  messages())
     4901          << general << CoinMessageEol ;
     4902      }
     4903    }
    48034904    if (numberStrongIterations_)
    48044905        handler_->message(CBC_STRONG_STATS, messages_)
     
    48124913        handler_->message(CBC_OTHER_STATS2, messages_)
    48134914        << maximumDepthActual_
    4814         << numberDJFixed_ << numberExtraNodes_ << numberExtraIterations_
     4915        << numberDJFixed_ << numberFathoms_ << numberExtraNodes_ << numberExtraIterations_
    48154916        << CoinMessageEol ;
    48164917#ifdef COIN_HAS_NTY
     
    53465447        numberExtraIterations_(0),
    53475448        numberExtraNodes_(0),
     5449        numberFathoms_(0),
    53485450        continuousObjective_(COIN_DBL_MAX),
    53495451        originalContinuousObjective_(COIN_DBL_MAX),
     
    53835485        numberThreads_(0),
    53845486        threadMode_(0),
     5487        numberGlobalCutsIn_(0),
    53855488        master_(NULL),
    53865489        masterThread_(NULL)
     
    55145617        numberExtraIterations_(0),
    55155618        numberExtraNodes_(0),
     5619        numberFathoms_(0),
    55165620        continuousObjective_(COIN_DBL_MAX),
    55175621        originalContinuousObjective_(COIN_DBL_MAX),
     
    55515655        numberThreads_(0),
    55525656        threadMode_(0),
     5657        numberGlobalCutsIn_(0),
    55535658        master_(NULL),
    55545659        masterThread_(NULL)
     
    56115716        // Space for current solution
    56125717        currentSolution_ = new double[numberColumns];
    5613         continuousSolution_ = new double[numberColumns];
     5718        continuousSolution_ = CoinCopyOfArray(solver_->getColSolution(),numberColumns);
    56145719        usedInSolution_ = new int[numberColumns];
    56155720        CoinZeroN(usedInSolution_, numberColumns);
     
    57995904        numberExtraIterations_(rhs.numberExtraIterations_),
    58005905        numberExtraNodes_(rhs.numberExtraNodes_),
     5906        numberFathoms_(rhs.numberFathoms_),
    58015907        continuousObjective_(rhs.continuousObjective_),
    58025908        originalContinuousObjective_(rhs.originalContinuousObjective_),
     
    58365942        numberThreads_(rhs.numberThreads_),
    58375943        threadMode_(rhs.threadMode_),
     5944        numberGlobalCutsIn_(rhs.numberGlobalCutsIn_),
    58385945        master_(NULL),
    58395946        masterThread_(NULL)
     
    59956102    // Space for current solution
    59966103    currentSolution_ = new double[numberColumns];
    5997     continuousSolution_ = new double[numberColumns];
     6104    continuousSolution_ = CoinCopyOfArray(solver_->getColSolution(),numberColumns);
    59986105    usedInSolution_ = new int[numberColumns];
    59996106    CoinZeroN(usedInSolution_, numberColumns);
     
    61136220            // Space for current solution
    61146221            currentSolution_ = new double[numberColumns];
    6115             continuousSolution_ = new double[numberColumns];
     6222            continuousSolution_ = CoinCopyOfArray(solver_->getColSolution(),numberColumns);
    61166223            usedInSolution_ = new int[numberColumns];
    61176224            CoinZeroN(usedInSolution_, numberColumns);
     
    61646271        numberExtraIterations_ = rhs.numberExtraIterations_;
    61656272        numberExtraNodes_ = rhs.numberExtraNodes_;
     6273        numberFathoms_ = rhs.numberFathoms_;
    61666274        continuousObjective_ = rhs.continuousObjective_;
    61676275        originalContinuousObjective_ = rhs.originalContinuousObjective_;
     
    62246332        numberThreads_ = rhs.numberThreads_;
    62256333        threadMode_ = rhs.threadMode_;
     6334        numberGlobalCutsIn_ = rhs.numberGlobalCutsIn_;
    62266335        delete master_;
    62276336        master_ = NULL;
     
    65786687    numberExtraIterations_ = 0;
    65796688    numberExtraNodes_ = 0;
     6689    numberFathoms_ = 0;
    65806690    continuousObjective_ = 0.0;
    65816691    originalContinuousObjective_ = 0.0;
     
    66366746    numberThreads_ = rhs.numberThreads_;
    66376747    threadMode_ = rhs.threadMode_;
     6748    numberGlobalCutsIn_ = rhs.numberGlobalCutsIn_;
    66386749    delete master_;
    66396750    master_ = NULL;
     
    71007211  descendants.
    71017212*/
    7102 int CbcModel::addCuts (CbcNode *node, CoinWarmStartBasis *&lastws, bool canFix)
     7213int CbcModel::addCuts (CbcNode *node, CoinWarmStartBasis *&lastws)
    71037214{
    71047215    /*
     
    71177228    double cutoff = getCutoff() ;
    71187229    int currentNumberCuts = currentNumberCuts_;
    7119     if (canFix) {
    7120         bool feasible = true;
    7121         const double *lower = solver_->getColLower() ;
    7122         const double *upper = solver_->getColUpper() ;
    7123         double * newLower = analyzeResults_;
    7124         double * objLower = newLower + numberIntegers_;
    7125         double * newUpper = objLower + numberIntegers_;
    7126         double * objUpper = newUpper + numberIntegers_;
    7127         int n = 0;
    7128         for (i = 0; i < numberIntegers_; i++) {
    7129             int iColumn = integerVariable_[i];
    7130             bool changed = false;
    7131             double lo = 0.0;
    7132             double up = 0.0;
    7133             if (objLower[i] > cutoff) {
    7134                 lo = lower[iColumn];
    7135                 up = upper[iColumn];
    7136                 if (lo < newLower[i]) {
    7137                     lo = newLower[i];
    7138                     solver_->setColLower(iColumn, lo);
    7139                     changed = true;
    7140                     n++;
    7141                 }
    7142                 if (objUpper[i] > cutoff) {
    7143                     if (up > newUpper[i]) {
    7144                         up = newUpper[i];
    7145                         solver_->setColUpper(iColumn, up);
    7146                         changed = true;
    7147                         n++;
    7148                     }
    7149                 }
    7150             } else if (objUpper[i] > cutoff) {
    7151                 lo = lower[iColumn];
    7152                 up = upper[iColumn];
    7153                 if (up > newUpper[i]) {
    7154                     up = newUpper[i];
    7155                     solver_->setColUpper(iColumn, up);
    7156                     changed = true;
    7157                     n++;
    7158                 }
    7159             }
    7160             if (changed && lo > up) {
    7161                 feasible = false;
    7162                 break;
    7163             }
    7164         }
    7165         if (!feasible) {
    7166           COIN_DETAIL_PRINT(printf("analysis says node infeas\n"));
    7167             cutoff = -COIN_DBL_MAX;
    7168         }
    7169     }
    71707230    /*
    71717231      If the node can't be fathomed by bound, reinstall tight cuts in the
     
    72107270                           numberRowsAtContinuous_ + numberToAdd);
    72117271#         endif
     7272                    whichGenerator_[numberToAdd] = whichGenerator_[i];
    72127273                    addCuts[numberToAdd++] = addedCuts_[i];
    72137274#if 1
     
    73377398                }
    73387399#endif
    7339                 //int n2=solver_->getNumRows();
    7340                 //for (int j=0;j<numberToAdd;j++)
    7341                 //addCuts[j]->print();
    73427400                solver_->applyRowCuts(numberToAdd, addCuts);
    7343                 //int n3=solver_->getNumRows();
    7344                 //printf("NBefore %d, after del %d, now %d\n",n1,n2,n3);
    73457401            }
    73467402#     ifdef CBC_CHECK_BASIS
     
    73497405            lastws->print();
    73507406#     endif
    7351             //for (i=0;i<numberToAdd;i++)
    7352             //delete addCuts[i];
    73537407            delete [] addCuts;
    73547408            delete [] cutsToDrop ;
     
    76617715    int returnCode = resolve(node ? node->nodeInfo() : NULL, 1);
    76627716    moreSpecialOptions_=save;
    7663 #ifdef CONFLICT_CUTS
     7717#ifdef CONFLICT_CUTS 
    76647718#ifdef COIN_HAS_CLP
    76657719    // if infeasible conflict analysis
    76667720    if (solver_->isProvenPrimalInfeasible()&&!parentModel_&&
    76677721        (moreSpecialOptions_&4194304)!=0&&clpSolver) {
    7668       //printf("infeasible - do conflict analysis\n");
     7722      if (!topOfTree_ && masterThread_)
     7723        topOfTree_ = masterThread_->master_->baseModel_->topOfTree_;
    76697724      assert (topOfTree_);
    7670       int iType=1;
     7725      int iType=0;
    76717726      OsiRowCut * cut = clpSolver->modelCut(topOfTree_->lower(),
    76727727                                            topOfTree_->upper(),
    76737728                                            numberRowsAtContinuous_,whichGenerator_,iType);
    76747729      if (cut) {
    7675         printf("XXXXXX cut\n");
    76767730        //cut->print();
    76777731        if (!iType) {
    7678           makeGlobalCut(cut) ;
     7732          int badCut = makeGlobalCut(cut) ;
     7733          if (!badCut) {
     7734#if PRINT_CONFLICT==1
     7735            numberConflictCuts++;
     7736            lengthConflictCuts += cut->row().getNumElements();
     7737#endif
     7738#if PRINT_CONFLICT<2
     7739            if (handler_->logLevel() > 1) {
     7740#endif
     7741              printf("Conflict cut at depth %d (%d elements)\n",
     7742                     currentDepth_,cut->row().getNumElements());
     7743              if (cut->row().getNumElements()<3)
     7744                cut->print();
     7745#if PRINT_CONFLICT<2
     7746            }
     7747#endif
     7748          }
    76797749          if ((specialOptions_&1) != 0) {
    76807750            debugger = continuousSolver_->getRowCutDebugger() ;
     
    79247994    if ( maximumSecondsReached() )
    79257995        numberTries = 0; // exit
     7996    if ((moreSpecialOptions2_&(2048|4096))!=0 && currentDepth_>5) {
     7997      // howOftenGlobalScan_ = 10;
     7998      int type = (moreSpecialOptions2_&(2048|4096))>>11;
     7999      if (type==1) {
     8000        int n=0;
     8001        int k=currentDepth_;
     8002        while (k) {
     8003          if ((k&1)!=0)
     8004            n++;
     8005          k = k >>1;
     8006        }
     8007        if (n>1)
     8008          numberTries=0;
     8009      } else if (type==2) {
     8010        if ((currentDepth_%4)!=0)
     8011          numberTries=0;
     8012      } else {
     8013        if ((currentDepth_%8)!=0)
     8014          numberTries=0;
     8015      }
     8016    }
    79268017    //if ((numberNodes_%100)==0)
    79278018    //printf("XXa sum obj changed by %g\n",sumChangeObjective1_);
     
    80838174                       thisCut->violated(cbcColSolution_)) ;
    80848175#endif
    8085                 whichGenerator_[numberViolated++] = -1;
     8176                whichGenerator_[numberViolated++] = 20099;
    80868177#ifndef GLOBAL_CUTS_JUST_POINTERS
    80878178                theseCuts.insert(*thisCut) ;
     
    81348225            if (clpSolver)
    81358226                clpSolver->setSpecialOptions(save);
    8136 #ifdef CLP_INVESTIGATE
     8227#if CBC_USEFUL_PRINTING>1
    81378228            if (clpSolver->getModelPtr()->numberIterations())
    81388229                printf("ITS %d pass %d\n",
     
    81688259            resizeWhichGenerator(numberViolated, numberViolated + 1);
    81698260            // set whichgenerator (also serves as marker to say don't delete0
    8170             whichGenerator_[numberViolated++] = -2;
     8261            whichGenerator_[numberViolated++] = 20098;
    81718262        }
    81728263
     
    82508341                    incrementUsed(newSolution);
    82518342                    lastHeuristic_ = heuristic_[found];
    8252 #ifdef CLP_INVESTIGATE
     8343#ifdef HEURISTIC_INFORM
    82538344                    printf("HEUR %s where %d A\n",
    82548345                           lastHeuristic_->heuristicName(), whereFrom);
     
    84208511            if (numberToAdd > 0) {
    84218512                int i ;
     8513                int * whichGenerator = whichGenerator_-
     8514                  numberRowsAtContinuous_+solver_->getNumRows();
    84228515                // Faster to add all at once
    84238516                addCuts = new const OsiRowCut * [numberToAdd] ;
    84248517                for (i = 0 ; i < numberToAdd ; i++) {
    84258518                    addCuts[i] = &theseCuts.rowCut(i) ;
     8519                    whichGenerator[i]=90;
    84268520                }
    84278521                if ((specialOptions_&262144) != 0 && !parentModel_) {
     
    85678661                            }
    85688662                        }
    8569 #ifdef CLP_INVESTIGATE2
     8663#if CBC_USEFUL_PRINTING>12
    85708664                        if (!parentModel_ && !numberNodes_)
    85718665                            printf("badObj %s nBad %d maxBad %d goodDrop %g minDrop %g thisDrop %g obj %g\n",
     
    85908684                    if (thisObj - lastObjective > drop[currentDepth_]*minimumDrop) {
    85918685                        numberTries++;
    8592 #ifdef CLP_INVESTIGATE
     8686#if CBC_USEFUL_PRINTING>1
    85938687                        //printf("drop %g %g %d\n",thisObj,lastObjective,currentPassNumber_);
    85948688#endif
     
    87048798
    87058799                    for (int i = numberGlobalBefore ; i < numberGlobalAfter ; i++) {
    8706                         whichGenerator_[numberNewCuts_++] = -1;
     8800                        whichGenerator_[numberNewCuts_++] = 20099;
    87078801#ifndef GLOBAL_CUTS_JUST_POINTERS
    87088802                        cuts.insert(*globalCuts_.rowCutPtr(i)) ;
     
    87878881                    incrementUsed(newSolution);
    87888882                    lastHeuristic_ = heuristic_[found];
    8789 #ifdef CLP_INVESTIGATE
     8883#ifdef HEURISTIC_INFORM
    87908884                    printf("HEUR %s where %d B\n",
    87918885                           lastHeuristic_->heuristicName(), whereFrom);
     
    89069000                bool smallProblem = size <= 550;
    89079001                smallProblem = false;
    8908 #ifdef CLP_INVESTIGATE
     9002#if CBC_USEFUL_PRINTING>1
    89099003                int maxPass = maximumCutPasses_;
    89109004#endif
     
    90039097                    whenCuts_ += 100000;
    90049098                //// end
    9005 #ifdef CLP_INVESTIGATE
     9099#if CBC_USEFUL_PRINTING>1
    90069100                printf("changing whenCuts from %d to %d and cutPasses from %d to %d objchange %g\n",
    90079101                       whenC, whenCuts_, maxPass, maximumCutPasses_, thisObjective - startObjective);
     
    90609154            if (numberColumns < 200)
    90619155                value = CoinMax(minimumDrop_, 0.1 * value);
    9062 #ifdef CLP_INVESTIGATE
     9156#if CBC_USEFUL_PRINTING>1
    90639157            printf("Minimum drop for cuts was %g, now is %g\n", minimumDrop_, value);
    90649158#endif
     
    90709164        for (i = 0; i < numberNewCuts_; i++) {
    90719165            int iGenerator = whichGenerator_[i];
     9166            assert (iGenerator>=0);
    90729167            if (iGenerator>=0)
    90739168              iGenerator=iGenerator%10000;
     
    94559550                for (i = 0; i < numberNewCuts_; i++) {
    94569551                    int iGenerator = whichGenerator_[i];
     9552#ifdef CONFLICT_CUTS
     9553                    assert (iGenerator>=0);
     9554#endif
    94579555                    if (iGenerator>=0)
    94589556                      iGenerator=iGenerator%10000;
    9459                     if (iGenerator >= 0)
     9557                    if (iGenerator >= 0 && iGenerator < numberCutGenerators_)
    94609558                        generator_[iGenerator]->incrementNumberCutsActive();
    94619559                }
     
    96199717            }
    96209718#endif
    9621             if (mustResolve || (specialOptions_&1) != 0) {
     9719            if (mustResolve /*|| (specialOptions_&1) != 0*/) {
    96229720                int returnCode = resolve(node ? node->nodeInfo() : NULL, 2);
    96239721                if (returnCode  == 0)
     
    96909788                break;
    96919789            }
    9692             whichGenerator_[numberBefore++] = i ;
     9790            whichGenerator_[numberBefore++] = i+20000 ;
    96939791            if (!numberNodes_||generator_[i]->globalCuts())
    96949792              whichGenerator_[numberBefore-1]=i+10000;
     
    97159813            for (; j < numberRowCutsAfter; j++) {
    97169814                const OsiRowCut * thisCut = theseCuts.rowCutPtr(j) ;
    9717                 whichGenerator_[numberBefore++] = i ;
     9815                whichGenerator_[numberBefore++] = i+20000 ;
    97189816                if (!numberNodes_||generator_[i]->globalCuts())
    97199817                  whichGenerator_[numberBefore-1]=i+10000;
     
    97669864                    printf("Old cut added - violation %g\n",
    97679865                           thisCut->violated(cbcColSolution_)) ;
    9768                 whichGenerator_[numberOld++] = -3;
     9866                whichGenerator_[numberOld++] = 20097;
    97699867                theseCuts.insert(*thisCut) ;
    97709868            }
     
    98409938        int numberOldToDelete = 0 ;
    98419939        int i ;
     9940        int kCut=0;
    98429941        ws = dynamic_cast<const CoinWarmStartBasis*>(solver_->getWarmStart()) ;
    98439942        /*
     
    98659964                        if (slackCut->effectiveness() != -1.234) {
    98669965                            slackCut->setEffectiveness(-1.234);
     9966                            slackCut->setGloballyValid();
    98679967                            saveCuts->insert(*slackCut);
    98689968                        }
     
    98739973                    oldCutIndex++ ;
    98749974                } else {
    9875                     oldCutIndex++ ;
     9975                    whichGenerator_[kCut++] = whichGenerator_[oldCutIndex] ;
     9976                    oldCutIndex++;
    98769977                }
    98779978            }
     
    98869987        */
    98879988        int firstNewCut = firstOldCut + numberOldActiveCuts_ ;
    9888         int k = 0 ;
    98899989        int nCuts = newCuts.sizeRowCuts();
    98909990        for (i = 0 ; i < nCuts ; i++) {
     
    98959995                newCutIndices[numberNewToDelete++] = i ;
    98969996            } else { // save which generator did it
    9897                 // -2 means branch cut! assert (whichGenerator_[i]!=-2); // ?? what if it is - memory leak?
    9898                 whichGenerator_[k++] = whichGenerator_[i] ;
     9997                // 20098 means branch cut! assert (whichGenerator_[i]!=20098); // ?? what if it is - memory leak?
     9998                whichGenerator_[kCut++] = whichGenerator_[i] ;
    98999999            }
    990010000        }
     
    992710027                if (slackCut->effectiveness() != -1.234) {
    992810028                    slackCut->setEffectiveness(-1.234);
     10029                    slackCut->setGloballyValid();
    992910030                    saveCuts->insert(slackCut);
    993010031                } else {
     
    997610077        }
    997710078    }
     10079   
    997810080    /*
    997910081      Clean up and return.
     
    999910101    cbc_resolve_check(solver_);
    1000010102#endif
     10103    bool onOptimalPath = false;
     10104    if ((specialOptions_&1) != 0) {
     10105      const OsiRowCutDebugger *debugger = solver_->getRowCutDebugger() ;
     10106      if (debugger) {
     10107        onOptimalPath = true;
     10108        printf("On optimal path d\n") ;
     10109      }
     10110    }
    1000110111    // We may have deliberately added in violated cuts - check to avoid message
    1000210112    int iRow;
     
    1003110141    */
    1003210142    if (feasible) {
    10033         bool onOptimalPath = false;
    10034         if ((specialOptions_&1) != 0) {
    10035             const OsiRowCutDebugger *debugger = solver_->getRowCutDebugger() ;
    10036             if (debugger) {
    10037                 onOptimalPath = true;
    10038                 printf("On optimal path d\n") ;
    10039             }
    10040         }
    1004110143        int nTightened = 0;
    1004210144#ifdef COIN_HAS_CLP
     
    1007610178                //double cutoff = getCutoff();
    1007710179                if (bestObjective_ - getCutoffIncrement() < testValue) {
    10078 #ifdef CLP_INVESTIGATE
     10180#if CBC_USEFUL_PRINTING>1
    1007910181                    double value ;
    1008010182                    solver_->getDblParam(OsiDualObjectiveLimit, value) ;
     
    1032410426        }
    1032510427    }
     10428#if 0
     10429    if ((specialOptions_&1) != 0 && onOptimalPath) {
     10430      const OsiRowCutDebugger *debugger = solver_->getRowCutDebugger() ;
     10431      if (!debugger) {
     10432        // tighten did something???
     10433        solver_->getRowCutDebuggerAlways()->printOptimalSolution(*solver_);
     10434        solver_->writeMpsNative("infeas4.mps", NULL, NULL, 2);
     10435        printf("Not on optimalpath aaaa\n");
     10436        //abort();
     10437      } else {
     10438        printf("Still on optimal path\n");
     10439      }
     10440    }
     10441#endif
    1032610442    return returnStatus ;
    1032710443}
     
    1189412010
    1189512011{
     12012    int numberContinuousColumns=continuousSolver_->getNumCols();
    1189612013    if (!solverCharacteristics_->solutionAddsCuts()) {
    1189712014        // Can trust solution
     
    1197712094        memcpy(saveLower, getColLower(), numberColumns*sizeof(double));
    1197812095        //#define CLP_INVESTIGATE4
    11979 #ifdef CLP_INVESTIGATE4
     12096#if CBC_USEFUL_PRINTING>14
    1198012097        {
    1198112098          int nBad=checkAssociated(solver_,solver_->getColSolution(),1);
     
    1209712214        for (i = 0; i < numberObjects_; i++)
    1209812215            object_[i]->feasibleRegion(solver_, &usefulInfo);
    12099 #ifdef CLP_INVESTIGATE4
     12216#if CBC_USEFUL_PRINTING>14
    1210012217        {
    1210112218          int nBad=checkAssociated(solver_,solver_->getColSolution(),1);
     
    1229812415#endif
    1229912416                    solver_->initialSolve();
     12417                    //solver_->writeMps("bad");
    1230012418#ifdef COIN_HAS_CLP
    1230112419                    if (!solver_->isProvenOptimal()&&modifiedTolerances) {
     
    1236012478            int nNotNeeded = 0;
    1236112479#endif
    12362             for (iColumn = 0 ; iColumn < numberColumns ; iColumn++) {
     12480            for (iColumn = 0 ; iColumn < numberContinuousColumns ; iColumn++) {
    1236312481                double value = solution[iColumn] ;
    1236412482                value = CoinMax(value, saveLower[iColumn]) ;
     
    1282412942                    objectiveValue = objectiveValue2;
    1282512943                }
    12826             } else {
     12944            } else if (!parentModel_) {
    1282712945              // not good
    12828               messageHandler()->message(CBC_GENERAL, messages())
     12946              messageHandler()->message(CBC_FPUMP2, messages())
    1282912947                << "On closer inspection - solution discarded"
    1283012948                << CoinMessageEol ;
     
    1370313821}
    1370413822// Make given cut into a global cut
    13705 void
     13823int
    1370613824CbcModel::makeGlobalCut(const OsiRowCut * cut)
    1370713825{
     13826  if (cut->row().getNumElements()>1-1) {
    1370813827    OsiRowCut newCut(*cut);
    1370913828    newCut.setGloballyValidAsInteger(2);
    1371013829    newCut.mutableRow().setTestForDuplicateIndex(false);
    13711     globalCuts_.addCutIfNotDuplicate(newCut) ;
     13830    return globalCuts_.addCutIfNotDuplicate(newCut,1) ;
     13831  } else {
     13832    assert (cut->row().getNumElements()==1);
     13833    int iColumn = cut->row().getIndices()[0];
     13834    double value = cut->row().getElements()[0];
     13835    double lb = cut->lb();
     13836    double ub = cut->ub();
     13837    if (value>0) {
     13838      if (lb>-COIN_DBL_MAX)
     13839        lb /= value;
     13840      if (ub<COIN_DBL_MAX)
     13841        ub /= value;
     13842    } else {
     13843      double saveUb=ub;
     13844      if (lb>-COIN_DBL_MAX)
     13845        ub = lb/value;
     13846      else
     13847        ub = COIN_DBL_MAX;
     13848      if (saveUb<COIN_DBL_MAX)
     13849        lb = saveUb/value;
     13850      else
     13851        lb =- COIN_DBL_MAX;
     13852    }
     13853#if PRINT_CONFLICT==0
     13854    if (handler_->logLevel() > 1) {
     13855#endif
     13856      printf("Conflict cut at depth %d (%d elements)\n",
     13857             currentDepth_,cut->row().getNumElements());
     13858      cut->print();
     13859#if PRINT_CONFLICT==0
     13860    }
     13861#endif
     13862    const double * lower;
     13863    const double * upper;
     13864    if (topOfTree_) {
     13865      lower = topOfTree_->lower();
     13866      upper = topOfTree_->upper();
     13867      lb = CoinMax(lb,lower[iColumn]);
     13868      topOfTree_->setColLower(iColumn,lb);
     13869      ub = CoinMin(ub,upper[iColumn]);
     13870      topOfTree_->setColUpper(iColumn,ub);
     13871    } else {
     13872      lower = solver_->getColLower();
     13873      upper = solver_->getColUpper();
     13874      lb = CoinMax(lb,lower[iColumn]);
     13875      solver_->setColLower(iColumn,lb);
     13876      ub = CoinMin(ub,upper[iColumn]);
     13877      solver_->setColUpper(iColumn,ub);
     13878    }
     13879    return 1;
     13880  }
    1371213881}
    1371313882// Make given cut into a global cut
    13714 void
     13883int
    1371513884CbcModel::makeGlobalCut(const OsiRowCut & cut)
    1371613885{
     
    1371813887    newCut.setGloballyValid(true);
    1371913888    newCut.mutableRow().setTestForDuplicateIndex(false);
    13720     globalCuts_.addCutIfNotDuplicate(newCut) ;
     13889    return globalCuts_.addCutIfNotDuplicate(newCut) ;
    1372113890}
    1372213891// Make given column cut into a global cut
     
    1372413893CbcModel::makeGlobalCut(const OsiColCut * cut)
    1372513894{
     13895  abort(); // need to think about top of tree
    1372613896  const double * lower;
    1372713897  const double * upper;
     
    1384214012  newCut.setLb(lo);
    1384314013  newCut.setRow(nConflict,column,values);
    13844   printf("CUTa has %d (started at %d) - final bSum %g\n",nConflict,nC,bSum);
     14014  printf("CUTa has %d (started at %d) - final bSum %g - depth %d\n",nConflict,nC,bSum,currentDepth_);
    1384514015  if (nConflict>1) {
    1384614016    if ((specialOptions_&1) != 0) {
     
    1392214092CbcModel::incrementUsed(const double * solution)
    1392314093{
    13924     // might as well mark all including continuous
    13925     int numberColumns = solver_->getNumCols();
    13926     for (int i = 0; i < numberColumns; i++) {
     14094    if(usedInSolution_) {
     14095      // might as well mark all including continuous
     14096      int numberColumns = solver_->getNumCols();
     14097      for (int i = 0; i < numberColumns; i++) {
    1392714098        if (solution[i])
    13928             usedInSolution_[i]++;
     14099          usedInSolution_[i]++;
     14100      }
    1392914101    }
    1393014102}
     
    1408814260                                   clpSimplex->largestPrimalError());
    1408914261            if (error > 1.0e-2 || !clpSolver->isProvenOptimal()) {
    14090 #ifdef CLP_INVESTIGATE
     14262#if CBC_USEFUL_PRINTING>1
    1409114263                printf("Problem was %s largest dual error %g largest primal %g - safer cuts\n",
    1409214264                       clpSolver->isProvenOptimal() ? "optimal" : "!infeasible",
     
    1412214294        }
    1412314295        clpSolver->setSpecialOptions(save2);
    14124 #ifdef CLP_INVESTIGATE
     14296#if CBC_USEFUL_PRINTING>1
    1412514297        if (clpSimplex->numberIterations() > 1000)
    1412614298            printf("node %d took %d iterations\n", numberNodes_, clpSimplex->numberIterations());
     
    1415914331                             clpSimplex->largestPrimalError());
    1416014332      if (error > 1.0e-2 || !clpSolver->isProvenOptimal()) {
    14161 #ifdef CLP_INVESTIGATE
     14333#if CBC_USEFUL_PRINTING>1
    1416214334        printf("Problem was %s largest dual error %g largest primal %g - safer cuts\n",
    1416314335               clpSolver->isProvenOptimal() ? "optimal" : "!infeasible",
     
    1419314365    }
    1419414366    clpSolver->setSpecialOptions(save2);
    14195 #ifdef CLP_INVESTIGATE
     14367#if CBC_USEFUL_PRINTING>1
    1419614368    if (clpSimplex->numberIterations() > 1000)
    1419714369      printf("node %d took %d iterations\n", numberNodes_, clpSimplex->numberIterations());
     
    1509015262            solver_->getDblParam(OsiObjOffset, offset);
    1509115263            solver_->setRowUpper(cutoffRowNumber_,cutoff+offset);
     15264            if (continuousSolver_&&solver_->getNumCols()>continuousSolver_->getNumCols()) {
     15265              solver_->setRowUpper(cutoffRowNumber_,floor(cutoff)+offset);
     15266              solver_->setRowLower(cutoffRowNumber_,floor(cutoff)+offset);
     15267            }
    1509215268          }
    1509315269        }
     
    1532615502                            //                            numberSolutions_++;
    1532715503                            numberHeuristicSolutions_++;
    15328 #ifdef CLP_INVESTIGATE
     15504#ifdef HEURISTIC_INFORM
    1532915505                            printf("HEUR %s where %d C\n",
    1533015506                                   lastHeuristic_->heuristicName(), whereFrom);
     
    1535615532                        } else {
    1535715533                            // NOT better solution
    15358 #ifdef CLP_INVESTIGATE
     15534#if CBC_USEFUL_PRINTING>1
    1535915535                            printf("HEUR %s where %d REJECTED i==%d\n",
    1536015536                                   heuristic_[i]->heuristicName(), whereFrom, i);
     
    1570915885    }
    1571015886    int save2 = maximumDepth_;
    15711     int retCode = addCuts(node, lastws, numberFixedNow_ > numberFixedAtRoot_);
     15887    int retCode = addCuts(node, lastws);
    1571215888#ifdef SWITCH_VARIABLES
    1571315889    fixAssociated(solver_,0);
     
    1596516141                        simplex->setMoreSpecialOptions(saveMoreOptions);
    1596616142                        simplex->setPerturbation(perturbation);
    15967                         numberExtraNodes_ += info->numberNodesExplored_;
    15968                         numberExtraIterations_ += info->numberIterations_;
     16143                        incrementExtra(info->numberNodesExplored_,
     16144                                       info->numberIterations_);
    1596916145                        char general[200];
    1597016146                        int fathomStatus=info->nNodes_;
     
    1598516161                                FATHOM_BIAS - fastNodeDepth_ << CoinMessageEol ;
    1598616162#endif
    15987 #ifdef CLP_INVESTIGATE
     16163#if CBC_USEFUL_PRINTING>0
    1598816164                            printf(">10000 - depth now %d so at depth >= %d\n",
    1598916165                                   fastNodeDepth_, FATHOM_BIAS - fastNodeDepth_);
     
    1599316169                            // we gave up
    1599416170                            //abort();
    15995                             fastNodeDepth_ -= 3;
     16171                          fastNodeDepth_ -= (info->nNodes_==-10) ? 5 : 2;
    1599616172#ifndef NO_FATHOM_PRINT
    1599716173                          if ((moreSpecialOptions_&262144) != 0)
     
    1599916175                              FATHOM_BIAS - fastNodeDepth_ << CoinMessageEol ;
    1600016176#endif
    16001 #ifdef CLP_INVESTIGATE
    16002                             printf("fastNodeDepth now %d - so at depth >= %d\n",
     16177#if CBC_USEFUL_PRINTING>0
     16178                            printf("gave up fastNodeDepth now %d - so at depth >= %d\n",
    1600316179                                   fastNodeDepth_, FATHOM_BIAS - fastNodeDepth_);
    1600416180#endif
     
    1667816854                            } else {
    1667916855                                lastHeuristic_ = heuristic_[found];
    16680 #ifdef CLP_INVESTIGATE
     16856#ifdef HEURISTIC_INFORM
    1668116857                                printf("HEUR %s where %d D\n",
    1668216858                                       lastHeuristic_->heuristicName(), whereFrom);
     
    1669316869                    if (found >= 0 && parallelMode() > 0) {
    1669416870                        lastHeuristic_ = heuristic_[found];
    16695 #ifdef CLP_INVESTIGATE
     16871#if CBC_USEFUL_PRINTING>1
    1669616872                        printf("HEUR %s where %d D\n",
    1669716873                               lastHeuristic_->heuristicName(), whereFrom);
     
    1685217028            delete [] delRows ;
    1685317029        }
     17030        numberNewCuts_=0;
    1685417031    }
    1685517032#endif
     
    1699717174    for (i = 0; i < numberIntegers_; i++)
    1699817175        back[integerVariable_[i]] = i;
    16999 #ifdef CLP_INVESTIGATE
     17176#if CBC_USEFUL_PRINTING>1
    1700017177    int numberNot = 0;
    1700117178#endif
     
    1700517182        if (!obj)
    1700617183            continue;
    17007 #ifdef CLP_INVESTIGATE
     17184#if CBC_USEFUL_PRINTING>1
    1700817185        if (obj->numberTimesDown() < numberBeforeTrust_ ||
    1700917186                obj->numberTimesUp() < numberBeforeTrust_)
     
    1702617203        }
    1702717204    }
    17028 #ifdef CLP_INVESTIGATE5
     17205#if CBC_USEFUL_PRINTING>5
    1702917206    if (priority)
    1703017207        printf("Before fathom %d not trusted out of %d\n",
     
    1760617783                    // better solution save
    1760717784                    lastHeuristic_ = heuristic_[found];
    17608 #ifdef CLP_INVESTIGATE
     17785#ifdef HEURISTIC_INFORM
    1760917786                    printf("HEUR %s where %d oddE\n",
    1761017787                           lastHeuristic_->heuristicName(), whereFrom);
     
    1852518702    char general[200];
    1852618703    if (clpSolver) {
    18527       clpSolver->getModelPtr()->dual(); // probably not needed
     18704      sprintf(general,"Starting multiple root solver");
     18705      model->messageHandler()->message(CBC_GENERAL,
     18706                                       model->messages())
     18707        << general << CoinMessageEol ;
     18708      clpSolver->setHintParam(OsiDoReducePrint, true, OsiHintTry);
     18709      ClpSimplex * simplex = clpSolver->getModelPtr();
     18710      int logLevel=simplex->logLevel();
     18711      if (logLevel<=1)
     18712        simplex->setLogLevel(0);
     18713      simplex->dual();
     18714      simplex->setLogLevel(logLevel);
    1852818715      clpSolver->setWarmStart(NULL);
    18529       sprintf(general,"Starting multiple root solver");
    1853018716    } else {
    18531 #endif
    18532 #ifdef COIN_HAS_CLP
    1853318717      model->initialSolve();
    1853418718      sprintf(general,"Solver did %d iterations in initialSolve\n",
    1853518719             model->solver()->getIterationCount());
    18536     }
    18537 #endif
    18538     model->messageHandler()->message(CBC_GENERAL,
    18539                               model->messages())
    18540       << general << CoinMessageEol ;
     18720      model->messageHandler()->message(CBC_GENERAL,
     18721                                       model->messages())
     18722        << general << CoinMessageEol ;
     18723    }
     18724#endif
    1854118725    model->branchAndBound();
    1854218726    sprintf(general,"Ending multiple root solver");
     
    1861018794        for (int iRow=numberRowsAtContinuous_;iRow<numberRows;iRow++) {
    1861118795          int iType=whichGenerator[iRow];
    18612           if ((iType>=0&&iType<10000)||iType<-1) {
     18796          if ((iType>=0&&iType<20000)) {
    1861318797            if (fabs(ray[iRow])>1.0e-10) {
    1861418798              badRows++;
Note: See TracChangeset for help on using the changeset viewer.