Ignore:
File:
1 edited

Legend:

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

    r2088 r2106  
    6262#include "CbcFathom.hpp"
    6363#include "CbcFullNodeInfo.hpp"
     64#ifdef COIN_HAS_NTY
     65#include "CbcSymmetry.hpp"
     66#endif
    6467// include Probing
    6568#include "CglProbing.hpp"
     
    7174#include "CglStored.hpp"
    7275#include "CglClique.hpp"
     76#include "CglKnapsackCover.hpp"
    7377
    7478#include "CoinTime.hpp"
     
    444448        if (!numberContinuousObj && numberIntegerObj <= 5 && numberIntegerWeight <= 100 &&
    445449                numberIntegerObj*3 < numberObjects_ && !parentModel_ && solver_->getNumRows() > 100)
    446           iType = 1 + 4 + ((moreSpecialOptions_&536870912)==0) ? 2 : 0;
     450          iType = 1 + 4 + (((moreSpecialOptions_&536870912)==0) ? 2 : 0);
    447451        else if (!numberContinuousObj && numberIntegerObj <= 100 &&
    448452                 numberIntegerObj*5 < numberObjects_ && numberIntegerWeight <= 100 &&
    449453                 !parentModel_ &&
    450454                 solver_->getNumRows() > 100 && cost != -COIN_DBL_MAX)
    451           iType = 4 + ((moreSpecialOptions_&536870912)==0) ? 2 : 0;
     455          iType = 4 + (((moreSpecialOptions_&536870912)==0) ? 2 : 0);
    452456        else if (!numberContinuousObj && numberIntegerObj <= 100 &&
    453457                 numberIntegerObj*5 < numberObjects_ &&
     
    586590                   !numberContinuousObj &&
    587591                   !numberGeneralIntegerObj &&
    588                    numberIntegerObj*2 < numberColumns) {
     592                   numberIntegerObj*2 < CoinMin(numberColumns,20)) {
    589593            // up priorities on costed
    590594            int iPriority = -1;
     
    597601            }
    598602            if (iPriority >= 100) {
    599 #ifdef CLP_INVESTIGATE
     603#if CBC_USEFUL_PRINTING>1
    600604                printf("Setting variables with obj to high priority\n");
    601605#endif
     
    10871091        int numberColumns = getNumCols();
    10881092        if (tryNewSearch) {
    1089 #ifdef CLP_INVESTIGATE
     1093#if CBC_USEFUL_PRINTING>1
    10901094            printf("after %d nodes, cutoff %g - looking\n",
    10911095                   numberNodes_, getCutoff());
     
    12331237    int numberColumns = continuousSolver_->getNumCols();
    12341238    int numberRows = continuousSolver_->getNumRows();
     1239    int numberOriginalIntegers = numberIntegers_;
    12351240    int * del = new int [CoinMax(numberColumns, numberRows)];
    12361241    int * original = new int [numberColumns];
    1237     int numberOriginalIntegers=numberIntegers_;
    12381242    char * possibleRow = new char [numberRows];
    12391243    {
     
    12661270                    j < rowStart[i] + rowLength[i]; j++) {
    12671271                int iColumn = column[j];
    1268                 double value = fabs(element[j]);
    12691272                if (continuousSolver_->isInteger(iColumn)) {
    1270                     if (value != 1.0)
     1273                    if (fabs(element[j]) != 1.0)
    12711274                        possible = false;
    12721275                } else {
    12731276                    nLeft++;
    1274                     if (value>100.0)
    1275                       allSame=-1.0; // not safe
    12761277                    if (!allSame) {
    1277                       allSame = value;
     1278                      allSame = fabs(element[j]);
    12781279                    } else if (allSame>0.0) {
    1279                       if (allSame!=value)
     1280                      if (allSame!=fabs(element[j]))
    12801281                        allSame = -1.0;
    12811282                    }
     
    14701471            int n = clpSolver->getModelPtr()->findNetwork(rotate, 1.0);
    14711472            delete [] rotate;
    1472 #ifdef CLP_INVESTIGATE
     1473#if CBC_USEFUL_PRINTING>1
    14731474            printf("INTA network %d rows out of %d\n", n, numberRows);
    14741475#endif
     
    14781479                    if (!possibleRow[i]) {
    14791480                        couldBeNetwork = false;
    1480 #ifdef CLP_INVESTIGATE
     1481#if CBC_USEFUL_PRINTING>1
    14811482                        printf("but row %d is bad\n", i);
    14821483#endif
     
    15581559                assert(solver_->isInteger(i));
    15591560        }
    1560 #ifdef CLP_INVESTIGATE
     1561#if CBC_USEFUL_PRINTING>1
    15611562        if (couldBeNetwork || nExtra)
    15621563            printf("INTA %d extra integers, %d left%s\n", nExtra,
     
    15671568        convertToDynamic();
    15681569    }
    1569 #ifdef CLP_INVESTIGATE
     1570#if CBC_USEFUL_PRINTING>1
    15701571    if (!couldBeNetwork && copy1->getNumCols() &&
    15711572            copy1->getNumRows()) {
     
    16011602*/
    16021603
     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
    16031611/*
    16041612  The overall flow can be divided into three stages:
     
    16211629
    16221630{
    1623   if (!parentModel_)
    1624     /*
    1625       Capture a time stamp before we start (unless set).
    1626     */
    1627     if (!dblParam_[CbcStartSeconds]) {
    1628       if (!useElapsedTime())
    1629         dblParam_[CbcStartSeconds] = CoinCpuTime();
    1630       else
    1631         dblParam_[CbcStartSeconds] = CoinGetTimeOfDay();
     1631    if (!parentModel_) {
     1632      /*
     1633        Capture a time stamp before we start (unless set).
     1634      */
     1635      if (!dblParam_[CbcStartSeconds]) {
     1636        if (!useElapsedTime())
     1637          dblParam_[CbcStartSeconds] = CoinCpuTime();
     1638        else
     1639          dblParam_[CbcStartSeconds] = CoinGetTimeOfDay();
     1640      }
    16321641    }
    16331642    dblParam_[CbcSmallestChange] = COIN_DBL_MAX;
     
    20172026            ClpSimplex * clpSimplex = clpSolver->getModelPtr();
    20182027            if ((specialOptions_&32) == 0) {
    2019                 // take off names
    2020                 clpSimplex->dropNames();
     2028                // take off names (unless going to be saving)
     2029                if (numberAnalyzeIterations_>=0||(-numberAnalyzeIterations_&64)==0)
     2030                  clpSimplex->dropNames();
    20212031            }
    20222032            // no crunch if mostly continuous
     
    20382048#endif
    20392049    bool feasible;
     2050    numberSolves_ = 0 ;
    20402051    {
    20412052      // check
     
    20502061        moreSpecialOptions_ |= 1073741824;
    20512062    }
    2052     numberSolves_ = 0 ;
    20532063    // If NLP then we assume already solved outside branchAndbound
    20542064    if (!solverCharacteristics_->solverType() || solverCharacteristics_->solverType() == 4) {
     
    22242234        }
    22252235        if (numberOdd) {
    2226             if (numberHeuristics_) {
     2236          if (numberHeuristics_ && (specialOptions_&1024)==0 ) {
    22272237                int k = 0;
    22282238                for (int i = 0; i < numberHeuristics_; i++) {
     
    22412251            // If odd switch off AddIntegers
    22422252            specialOptions_ &= ~65536;
     2253            // switch off fast nodes for now
     2254            fastNodeDepth_ = -1;
     2255            moreSpecialOptions_ &= ~33554432; // no diving
    22432256        } else if (numberSOS) {
    22442257            specialOptions_ |= 128; // say can do SOS in dynamic mode
     
    22492262        if (numberThreads_ > 0) {
    22502263            // switch off fast nodes for now
    2251             fastNodeDepth_ = -1;
     2264            //fastNodeDepth_ = -1;
    22522265        }
    22532266    }
     
    23112324      constraint system (aka the continuous system).
    23122325    */
     2326    delete continuousSolver_;
    23132327    continuousSolver_ = solver_->clone() ;
     2328#ifdef COIN_HAS_NTY
     2329    // maybe allow on fix and restart later
     2330    if ((moreSpecialOptions2_&(128|256))!=0&&!parentModel_) {
     2331      symmetryInfo_ = new CbcSymmetry();
     2332      symmetryInfo_->setupSymmetry(*continuousSolver_);
     2333      int numberGenerators = symmetryInfo_->statsOrbits(this,0);
     2334      if (!symmetryInfo_->numberUsefulOrbits()&&(moreSpecialOptions2_&(128|256))!=(128|256)) {
     2335        delete symmetryInfo_;
     2336        symmetryInfo_=NULL;
     2337        moreSpecialOptions2_ &= ~(128|256);
     2338      }
     2339      if ((moreSpecialOptions2_&(128|256))==(128|256)) {
     2340        //moreSpecialOptions2_ &= ~256;
     2341      }
     2342    }
     2343#endif
    23142344
    23152345    // add cutoff as constraint if wanted
     
    25392569        }
    25402570    }
     2571#ifdef SWITCH_VARIABLES
     2572    // see if any switching variables
     2573    if (numberIntegers_<solver_->getNumCols())
     2574      findSwitching();
     2575#endif
    25412576    /*
    25422577      Run heuristics at the root. This is the only opportunity to run FPump; it
     
    25792614      }
    25802615      CoinWarmStartBasis * basis = dynamic_cast<CoinWarmStartBasis *> (solver_->getEmptyWarmStart());
    2581       int numberIterations=0;
    25822616      for (int i=0;i<numberModels;i++) {
    25832617        rootModels[i]=new CbcModel(*this);
     
    25902624        rootModels[i]->setSpecialOptions(specialOptions_ |(4194304|8388608));
    25912625        rootModels[i]->setMoreSpecialOptions(moreSpecialOptions_ &
    2592                                              (~134217728));
     2626                                             (~(134217728|4194304)));
     2627        rootModels[i]->setMoreSpecialOptions2(moreSpecialOptions2_ &
     2628                                              (~(128|256)));
    25932629        rootModels[i]->solver_->setWarmStart(basis);
    25942630#ifdef COIN_HAS_CLP
    25952631        OsiClpSolverInterface * clpSolver
    25962632          = dynamic_cast<OsiClpSolverInterface *> (rootModels[i]->solver_);
     2633#define NEW_RANDOM_BASIS
     2634#ifdef NEW_RANDOM_BASIS
     2635        if (i==0)
     2636          continue;
     2637#endif
    25972638        if (clpSolver) {
    25982639          ClpSimplex * simplex = clpSolver->getModelPtr();
     
    26052646            simplex->setLogLevel(0);
    26062647          if (i!=0) {
     2648#ifdef NEW_RANDOM_BASIS
     2649            int numberRows = simplex->numberRows();
     2650            int throwOut=20;//2+numberRows/100;
     2651            for (int iThrow=0;iThrow<throwOut;iThrow++) {
     2652              double random = simplex->randomNumberGenerator()->randomDouble();
     2653              int iStart=static_cast<int>(random*numberRows);
     2654              for (int j=iStart;j<numberRows;j++) {
     2655                if (simplex->getRowStatus(j)!=ClpSimplex::basic) {
     2656                  simplex->setRowStatus(j,ClpSimplex::basic);
     2657                  break;
     2658                }
     2659              }
     2660            }
     2661            clpSolver->setWarmStart(NULL);
     2662#else
    26072663            double random = simplex->randomNumberGenerator()->randomDouble();
    26082664            int bias = static_cast<int>(random*(numberIterations/4));
     
    26112667            simplex->setMaximumIterations(COIN_INT_MAX);
    26122668            simplex->dual();
     2669#endif
    26132670          } else {
     2671#ifndef NEW_RANDOM_BASIS
    26142672            simplex->primal();
    2615             numberIterations=simplex->numberIterations();
     2673#endif
     2674#endif
    26162675          }
     2676#ifdef NEW_RANDOM_BASIS
    26172677          simplex->setLogLevel(logLevel);
    26182678          clpSolver->setWarmStart(NULL);
     2679#endif
    26192680        }
    2620 #endif
    26212681        for (int j=0;j<numberHeuristics_;j++)
    26222682          rootModels[i]->heuristic_[j]->setSeed(rootModels[i]->heuristic_[j]->getSeed()+100000000*i);
     
    28532913                  //rowCut.addCuts(globalCuts_);
    28542914                  int nTightened=0;
    2855                   assert (feasible);
     2915                  assert(feasible);
    28562916                  {
    28572917                    double tolerance=1.0e-5;
     
    28592919                    const double * upper = solver_->getColUpper();
    28602920                    for (int i=0;i<numberColumns;i++) {
    2861                       if (tightBounds[2*i+0]>tightBounds[2*i+1]) {
     2921                      if (tightBounds[2*i+0]>tightBounds[2*i+1]+1.0e-9) {
    28622922                        feasible=false;
    28632923                        char general[200];
     
    34863546    numberFixedAtRoot_ = 0;
    34873547    numberFixedNow_ = 0;
     3548    if (!parentModel_&&(moreSpecialOptions2_&2)!=0) {
     3549#ifdef COIN_HAS_CLP
     3550      OsiClpSolverInterface * clpSolver
     3551        = dynamic_cast<OsiClpSolverInterface *> (solver_);
     3552      if (clpSolver) {
     3553        if (getCutoff()>1.0e20) {
     3554          printf("Zapping costs\n");
     3555          int numberColumns=solver_->getNumCols();
     3556          double * zeroCost = new double [numberColumns];
     3557          // could make small random
     3558          memset(zeroCost,0,numberColumns*sizeof(double));
     3559          solver_->setObjective(zeroCost);
     3560          double objValue = solver_->getObjValue();
     3561          solver_->setDblParam(OsiObjOffset,-objValue);
     3562          clpSolver->getModelPtr()->setObjectiveValue(objValue);
     3563          delete [] zeroCost;
     3564        } else {
     3565          moreSpecialOptions2_ &= ~2;
     3566        }
     3567      } else {
     3568#endif
     3569          moreSpecialOptions2_ &= ~2;
     3570#ifdef COIN_HAS_CLP
     3571      }
     3572#endif
     3573    }
    34883574    int numberIterationsAtContinuous = numberIterations_;
    34893575    //solverCharacteristics_->setSolver(solver_);
    34903576    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      }
    34913583#define HOTSTART -1
    34923584#if HOTSTART<0
     
    35873679                        }
    35883680                    }
    3589 #ifdef CLP_INVESTIGATE
     3681#if CBC_USEFUL_PRINTING>1
    35903682                    printf("%d forced, %d naturally at lower, %d at upper - %d zero dj\n",
    35913683                           nForced, nAtLbNatural, nAtUbNatural, nZeroDj);
     
    38093901        int numberPassesLeft = 1000;
    38103902        // This is first crude step
    3811         if (numberAnalyzeIterations_) {
     3903        if (numberAnalyzeIterations_ && !parentModel_) {
    38123904            delete [] analyzeResults_;
    3813             analyzeResults_ = new double [4*numberIntegers_];
     3905            //int numberColumns = solver_->getNumCols();
     3906            analyzeResults_ = new double [5*numberIntegers_];
    38143907            numberFixedAtRoot_ = newNode->analyze(this, analyzeResults_);
    38153908            if (numberFixedAtRoot_ > 0) {
     
    38263919        }
    38273920        OsiSolverBranch * branches = NULL;
    3828         anyAction = chooseBranch(newNode, numberPassesLeft, NULL, cuts, resolved,
     3921        if (feasible)
     3922          anyAction = chooseBranch(newNode, numberPassesLeft, NULL, cuts, resolved,
    38293923                                 NULL, NULL, NULL, branches);
    38303924        if (anyAction == -2 || newNode->objectiveValue() >= cutoff) {
     
    38323926                // zap parent nodeInfo
    38333927#ifdef COIN_DEVELOP
    3834                 printf("zapping CbcNodeInfo %x\n", reinterpret_cast<int>(newNode->nodeInfo()->parent()));
     3928                printf("zapping CbcNodeInfo %x\n", newNode->nodeInfo()->parent());
    38353929#endif
    38363930                if (newNode->nodeInfo())
     
    38503944        if (toZero[number01]) {
    38513945            CglTreeProbingInfo info(*probingInfo_);
    3852 #ifdef JJF_ZERO
    3853             /*
    3854               Marginal idea. Further exploration probably good. Build some extra
    3855               cliques from probing info. Not quite worth the effort?
    3856             */
    3857             OsiSolverInterface * fake = info.analyze(*solver_, 1);
    3858             if (fake) {
    3859                 fake->writeMps("fake");
     3946            if ((moreSpecialOptions2_&64)!=0&&!parentModel_) {
     3947              /*
     3948                Marginal idea. Further exploration probably good. Build some extra
     3949                cliques from probing info. Not quite worth the effort?
     3950              */
     3951              CglProbing generator1;
     3952              generator1.setUsingObjective(false);
     3953              generator1.setMaxPass(1);
     3954              generator1.setMaxPassRoot(1);
     3955              generator1.setMaxLook(100);
     3956              generator1.setRowCuts(3);
     3957              generator1.setMaxElements(300);
     3958              generator1.setMaxProbeRoot(solver_->getNumCols());
     3959              CoinThreadRandom randomGenerator;
     3960              //CglTreeProbingInfo info(solver_);
     3961              info.level = 0;
     3962              info.formulation_rows = solver_->getNumRows();
     3963              info.inTree = false;
     3964              info.randomNumberGenerator=&randomGenerator;
     3965              info.pass=4;
     3966              generator1.setMode(8);
     3967              OsiCuts cs;
     3968              generator1.generateCutsAndModify(*solver_,cs,&info);
     3969              // very clunky
     3970              OsiSolverInterface * temp = generator1.cliqueModel(solver_,2);
     3971              CglPreProcess dummy;
     3972              OsiSolverInterface * newSolver=dummy.cliqueIt(*temp,0.0001);
     3973              delete temp;
     3974              OsiSolverInterface * fake = NULL;
     3975              if (newSolver) {
     3976#if 0
     3977                int numberCliques = generator1.numberCliques();
     3978                cliqueEntry * entry = generator1.cliqueEntry();
     3979                cliqueType * type = new cliqueType [numberCliques];
     3980                int * start = new int [numberCliques+1];
     3981                start[numberCliques]=2*numberCliques;
     3982                int n=0;
     3983                for (int i=0;i<numberCliques;i++) {
     3984                  start[i]=2*i;
     3985                  setOneFixesInCliqueEntry(entry[2*i],true);
     3986                  setOneFixesInCliqueEntry(entry[2*i+1],true);
     3987                  type[i]=0;
     3988                }
     3989                fake = info.analyze(*solver_, 1,numberCliques,start,
     3990                                    entry,type);
     3991                delete [] type;
     3992                delete [] entry;
     3993#else
     3994                fake = info.analyze(*newSolver, 1,-1);
     3995#endif
     3996                delete newSolver;
     3997              } else {
     3998                fake = info.analyze(*solver_, 1);
     3999              }
     4000              if (fake) {
     4001                //fake->writeMps("fake");
    38604002                CglFakeClique cliqueGen(fake);
    38614003                cliqueGen.setStarCliqueReport(false);
     
    38644006                addCutGenerator(&cliqueGen, 1, "Fake cliques", true, false, false, -200);
    38654007                generator_[numberCutGenerators_-1]->setTiming(true);
    3866             }
    3867 #endif
     4008                for (int i = 0; i < numberCutGenerators_; i++) {
     4009                  CglKnapsackCover * cutGen =
     4010                  dynamic_cast<CglKnapsackCover *>(generator_[i]->generator());
     4011                  if (cutGen) {
     4012                    cutGen->createCliques(*fake,2,200,false);
     4013                  }
     4014                }
     4015              }
     4016            }
    38684017            if (probingInfo_->packDown()) {
    3869 #ifdef CLP_INVESTIGATE
     4018#if CBC_USEFUL_PRINTING>1
    38704019                printf("%d implications on %d 0-1\n", toZero[number01], number01);
    38714020#endif
     
    38744023                addCutGenerator(&implication, 1, "ImplicationCuts", true, false, false, -200);
    38754024                generator_[numberCutGenerators_-1]->setGlobalCuts(true);
     4025                generator_[numberCutGenerators_-1]->setTiming(true);
    38764026            } else {
    38774027                delete probingInfo_;
     
    38914041    assert (!newNode || newNode->objectiveValue() <= cutoff) ;
    38924042    // Save address of root node as we don't want to delete it
    3893     // initialize for print out
    3894     int lastDepth = 0;
    3895     int lastUnsatisfied = 0;
    3896     if (newNode)
    3897         lastUnsatisfied = newNode->numberUnsatisfied();
    38984043    /*
    38994044      The common case is that the lp relaxation is feasible but doesn't satisfy
     
    41134258                ClpSimplex * simplex = clpSolver->getModelPtr();
    41144259                int perturbation = simplex->perturbation();
    4115 #ifdef CLP_INVESTIGATE
     4260#if CBC_USEFUL_PRINTING>1
    41164261                printf("Testing its n,s %d %d solves n,s %d %d - pert %d\n",
    41174262                       numberIterations_, saveNumberIterations,
     
    41224267                    // switch off perturbation
    41234268                    simplex->setPerturbation(100);
    4124 #ifdef CLP_INVESTIGATE
     4269#if CBC_USEFUL_PRINTING>1
    41254270                    printf("Perturbation switched off\n");
    41264271#endif
     
    41364281                int numberColumns = getNumCols();
    41374282                if (tryNewSearch) {
    4138                     checkCutoffForRestart = getCutoff() ;
    4139 #ifdef CLP_INVESTIGATE
     4283                    // adding increment back allows current best - tiny bit weaker
     4284                    checkCutoffForRestart = getCutoff() + getCutoffIncrement() ;
     4285#if CBC_USEFUL_PRINTING>1
    41404286                    printf("after %d nodes, cutoff %g - looking\n",
    41414287                           numberNodes_, getCutoff());
     
    42144360                        tryNewSearch = false;
    42154361                }
     4362#ifdef CONFLICT_CUTS
     4363                // temporary
     4364                if ((moreSpecialOptions_&4194304)!=0)
     4365                  tryNewSearch=false;
     4366#endif
    42164367                if (tryNewSearch) {
    42174368                    // back to solver without cuts?
     
    43464497                            break;
    43474498                        }
     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) ;
    43484508                    } else if (objUpper[i] > newCutoff) {
    43494509                        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) ;
    43504519                    }
    43514520                }
     
    44364605#endif
    44374606            unlockThread();
    4438 #ifdef CLP_INVESTIGATE
     4607#if CBC_USEFUL_PRINTING>1
    44394608            if (getCutoff() < 1.0e20) {
    44404609                if (fabs(getCutoff() - (bestObjective_ - getCutoffIncrement())) > 1.0e-6 &&
     
    44544623                messageHandler()->message(CBC_STATUS2, messages())
    44554624                << numberNodes_ << nNodes << bestObjective_ << bestPossibleObjective_
    4456                 << lastDepth << lastUnsatisfied << numberIterations_
     4625                << tree_->lastDepth() << tree_->lastUnsatisfied()
     4626                << tree_->lastObjective() << numberIterations_
    44574627                << getCurrentSeconds()
    44584628                << CoinMessageEol ;
     
    44604630                messageHandler()->message(CBC_STATUS2, messages())
    44614631                << numberNodes_ << nNodes << bestObjective_ << bestPossibleObjective_
    4462                 << lastDepth << lastUnsatisfied << numberIterations_
     4632                << tree_->lastDepth() << tree_->lastUnsatisfied() << numberIterations_
    44634633                << getCurrentSeconds()
    44644634                << CoinMessageEol ;
    44654635            } else {
    44664636                messageHandler()->message(CBC_STATUS3, messages())
    4467                 << numberNodes_ << numberExtraNodes_ << nNodes << bestObjective_ << bestPossibleObjective_
    4468                 << lastDepth << lastUnsatisfied << numberIterations_ << numberExtraIterations_
     4637                << numberNodes_ << numberFathoms_ << numberExtraNodes_ << nNodes
     4638                << bestObjective_ << bestPossibleObjective_
     4639                << tree_->lastDepth() << tree_->lastUnsatisfied() << numberIterations_ << numberExtraIterations_
    44694640                << getCurrentSeconds()
    44704641                << CoinMessageEol ;
    44714642            }
     4643#ifdef COIN_HAS_NTY
     4644            if (symmetryInfo_)
     4645              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            }
     4655#endif
    44724656            if (eventHandler && !eventHandler->event(CbcEventHandler::treeStatus)) {
    44734657                eventHappened_ = true; // exit
     
    45444728        } else {
    45454729            // Deterministic parallel
    4546             if (tree_->size() < CoinMax(numberThreads_, 8) && !goneParallel) {
     4730          if ((tree_->size() < CoinMax(numberThreads_, 8)||
     4731               hotstartSolution_) && !goneParallel) {
    45474732                node = tree_->bestNode(cutoff) ;
    45484733                // Possible one on tree worse than cutoff
     
    46034788        master_->stopThreads(-1);
    46044789        master_->waitForThreadsInTree(2);
    4605         delete master_;
    4606         master_ = NULL;
    4607         masterThread_ = NULL;
    46084790        // adjust time to allow for children on some systems
    46094791        //dblParam_[CbcStartSeconds] -= CoinCpuTimeJustChildren();
     
    46274809            double dummyBest;
    46284810            tree_->cleanTree(this, -COIN_DBL_MAX, dummyBest) ;
     4811#ifdef CBC_THREAD
     4812            if (parallelMode() > 0 && master_) {
     4813              // see if any dangling nodes
     4814              int numberThreads = master_->numberThreads();
     4815              for (int i=0;i<numberThreads;i++) {
     4816                CbcThread * child = master_->child(i);
     4817                //if (child->createdNode())
     4818                //printf("CHILD_NODE %p\n",child->createdNode());
     4819                delete child->createdNode();
     4820              }
     4821            }
     4822#endif
    46294823        }
    46304824        delete nextRowCut_;
     
    46654859        }
    46664860    }
     4861#ifdef CBC_THREAD
     4862    if (master_) {
     4863        delete master_;
     4864        master_ = NULL;
     4865        masterThread_ = NULL;
     4866    }
     4867#endif
    46674868    /*
    46684869      That's it, we've exhausted the search tree, or broken out of the loop because
     
    46954896        << CoinMessageEol ;
    46964897    }
     4898    if ((moreSpecialOptions_&4194304)!=0) {
     4899      // Conflict cuts
     4900      int numberCuts = globalCuts_.sizeRowCuts();
     4901      int nConflict=0;
     4902      double sizeConflict = 0.0;
     4903      for (int i=0;i<numberCuts;i++) {
     4904        OsiRowCut2 * cut = globalCuts_.cut(i);
     4905        if (cut->whichRow()==1) {
     4906          nConflict++;
     4907          sizeConflict += cut->row().getNumElements();
     4908        }
     4909      }
     4910      if (nConflict) {
     4911        sizeConflict /= nConflict;
     4912        char general[200];
     4913        sprintf(general, "%d conflict cuts generated - average length %g",
     4914                nConflict,sizeConflict);
     4915        messageHandler()->message(CBC_GENERAL,
     4916                                  messages())
     4917          << general << CoinMessageEol ;
     4918      }
     4919    }
    46974920    if (numberStrongIterations_)
    46984921        handler_->message(CBC_STRONG_STATS, messages_)
     
    47064929        handler_->message(CBC_OTHER_STATS2, messages_)
    47074930        << maximumDepthActual_
    4708         << numberDJFixed_ << numberExtraNodes_ << numberExtraIterations_
     4931        << numberDJFixed_ << numberFathoms_ << numberExtraNodes_ << numberExtraIterations_
    47094932        << CoinMessageEol ;
     4933#ifdef COIN_HAS_NTY
     4934    if (symmetryInfo_)
     4935      symmetryInfo_->statsOrbits(this,1);
     4936#endif
    47104937    if (doStatistics == 100) {
    47114938        for (int i = 0; i < numberObjects_; i++) {
     
    52015428        specialOptions_(0),
    52025429        moreSpecialOptions_(0),
     5430        moreSpecialOptions2_(0),
    52035431        topOfTree_(NULL),
    52045432        subTreeModel_(NULL),
     
    52245452        fastNodeDepth_(-1),
    52255453        eventHandler_(NULL),
     5454#ifdef COIN_HAS_NTY
     5455        symmetryInfo_(NULL),
     5456#endif
    52265457        numberObjects_(0),
    52275458        object_(NULL),
     
    52325463        numberExtraIterations_(0),
    52335464        numberExtraNodes_(0),
     5465        numberFathoms_(0),
    52345466        continuousObjective_(COIN_DBL_MAX),
    52355467        originalContinuousObjective_(COIN_DBL_MAX),
     
    52695501        numberThreads_(0),
    52705502        threadMode_(0),
     5503        numberGlobalCutsIn_(0),
    52715504        master_(NULL),
    52725505        masterThread_(NULL)
     
    53655598        specialOptions_(0),
    53665599        moreSpecialOptions_(0),
     5600        moreSpecialOptions2_(0),
    53675601        topOfTree_(NULL),
    53685602        subTreeModel_(NULL),
     
    53885622        fastNodeDepth_(-1),
    53895623        eventHandler_(NULL),
     5624#ifdef COIN_HAS_NTY
     5625        symmetryInfo_(NULL),
     5626#endif
    53905627        numberObjects_(0),
    53915628        object_(NULL),
     
    53965633        numberExtraIterations_(0),
    53975634        numberExtraNodes_(0),
     5635        numberFathoms_(0),
    53985636        continuousObjective_(COIN_DBL_MAX),
    53995637        originalContinuousObjective_(COIN_DBL_MAX),
     
    54335671        numberThreads_(0),
    54345672        threadMode_(0),
     5673        numberGlobalCutsIn_(0),
    54355674        master_(NULL),
    54365675        masterThread_(NULL)
     
    54935732        // Space for current solution
    54945733        currentSolution_ = new double[numberColumns];
    5495         continuousSolution_ = new double[numberColumns];
     5734        continuousSolution_ = CoinCopyOfArray(solver_->getColSolution(),numberColumns);
    54965735        usedInSolution_ = new int[numberColumns];
    54975736        CoinZeroN(usedInSolution_, numberColumns);
     
    56605899        specialOptions_(rhs.specialOptions_),
    56615900        moreSpecialOptions_(rhs.moreSpecialOptions_),
     5901        moreSpecialOptions2_(rhs.moreSpecialOptions2_),
    56625902        topOfTree_(NULL),
    56635903        subTreeModel_(rhs.subTreeModel_),
     
    56805920        numberExtraIterations_(rhs.numberExtraIterations_),
    56815921        numberExtraNodes_(rhs.numberExtraNodes_),
     5922        numberFathoms_(rhs.numberFathoms_),
    56825923        continuousObjective_(rhs.continuousObjective_),
    56835924        originalContinuousObjective_(rhs.originalContinuousObjective_),
     
    57175958        numberThreads_(rhs.numberThreads_),
    57185959        threadMode_(rhs.threadMode_),
     5960        numberGlobalCutsIn_(rhs.numberGlobalCutsIn_),
    57195961        master_(NULL),
    57205962        masterThread_(NULL)
     
    57886030        numberObjects_ = 0;
    57896031        object_ = NULL;
     6032    }
     6033    if (rhs.continuousSolver_) {
     6034        continuousSolver_ = rhs.continuousSolver_->clone() ;
     6035    } else {
     6036        continuousSolver_ = NULL ;
    57906037    }
    57916038    if (rhs.referenceSolver_)
     
    58716118    // Space for current solution
    58726119    currentSolution_ = new double[numberColumns];
    5873     continuousSolution_ = new double[numberColumns];
     6120    continuousSolution_ = CoinCopyOfArray(solver_->getColSolution(),numberColumns);
    58746121    usedInSolution_ = new int[numberColumns];
    58756122    CoinZeroN(usedInSolution_, numberColumns);
     
    59056152        lastCut_ = NULL;
    59066153    }
     6154#ifdef COIN_HAS_NTY
     6155    if (rhs.symmetryInfo_)
     6156      symmetryInfo_ = new CbcSymmetry(*rhs.symmetryInfo_);
     6157    else
     6158      symmetryInfo_ = NULL;
     6159#endif
    59076160    synchronizeModel();
    59086161    if (cloneHandler && !defaultHandler_) {
     
    59836236            // Space for current solution
    59846237            currentSolution_ = new double[numberColumns];
    5985             continuousSolution_ = new double[numberColumns];
     6238            continuousSolution_ = CoinCopyOfArray(solver_->getColSolution(),numberColumns);
    59866239            usedInSolution_ = new int[numberColumns];
    59876240            CoinZeroN(usedInSolution_, numberColumns);
     
    60146267        specialOptions_ = rhs.specialOptions_;
    60156268        moreSpecialOptions_ = rhs.moreSpecialOptions_;
     6269        moreSpecialOptions2_ = rhs.moreSpecialOptions2_;
    60166270        subTreeModel_ = rhs.subTreeModel_;
    60176271        heuristicModel_ = NULL;
     
    60336287        numberExtraIterations_ = rhs.numberExtraIterations_;
    60346288        numberExtraNodes_ = rhs.numberExtraNodes_;
     6289        numberFathoms_ = rhs.numberFathoms_;
    60356290        continuousObjective_ = rhs.continuousObjective_;
    60366291        originalContinuousObjective_ = rhs.originalContinuousObjective_;
     
    60936348        numberThreads_ = rhs.numberThreads_;
    60946349        threadMode_ = rhs.threadMode_;
     6350        numberGlobalCutsIn_ = rhs.numberGlobalCutsIn_;
    60956351        delete master_;
    60966352        master_ = NULL;
     
    62386494            lastCut_ = NULL;
    62396495        }
     6496#ifdef COIN_HAS_NTY
     6497        if (rhs.symmetryInfo_)
     6498          symmetryInfo_ = new CbcSymmetry(*rhs.symmetryInfo_);
     6499        else
     6500          symmetryInfo_ = NULL;
     6501#endif
    62406502        synchronizeModel();
    62416503        cbcColLower_ = NULL;
     
    63296591    topOfTree_ = NULL;
    63306592    resetModel();
     6593#ifdef COIN_HAS_NTY
     6594    delete symmetryInfo_;
     6595    symmetryInfo_ = NULL;
     6596#endif
    63316597}
    63326598// Clears out enough to reset CbcModel
     
    64376703    numberExtraIterations_ = 0;
    64386704    numberExtraNodes_ = 0;
     6705    numberFathoms_ = 0;
    64396706    continuousObjective_ = 0.0;
    64406707    originalContinuousObjective_ = 0.0;
     
    64706737    specialOptions_ = rhs.specialOptions_;
    64716738    moreSpecialOptions_ = rhs.moreSpecialOptions_;
     6739    moreSpecialOptions2_ = rhs.moreSpecialOptions2_;
    64726740    numberStrong_ = rhs.numberStrong_;
    64736741    numberBeforeTrust_ = rhs.numberBeforeTrust_;
     
    64946762    numberThreads_ = rhs.numberThreads_;
    64956763    threadMode_ = rhs.threadMode_;
     6764    numberGlobalCutsIn_ = rhs.numberGlobalCutsIn_;
    64966765    delete master_;
    64976766    master_ = NULL;
     
    65246793            } else {
    65256794                generator_[i] = new CbcCutGenerator(*rhs.virginGenerator_[i]);
    6526                 // But copy across maximumTries
     6795                // But copy across maximumTries and switches
    65276796                generator_[i]->setMaximumTries(rhs.generator_[i]->maximumTries());
     6797                generator_[i]->setSwitches(rhs.generator_[i]->switches());
    65286798            }
    65296799            virginGenerator_[i] = new CbcCutGenerator(*rhs.virginGenerator_[i]);
     
    65536823    messageHandler()->setLogLevel(rhs.messageHandler()->logLevel());
    65546824    whenCuts_ = rhs.whenCuts_;
     6825#ifdef COIN_HAS_NTY
     6826    if (rhs.symmetryInfo_)
     6827      symmetryInfo_ = new CbcSymmetry (*rhs.symmetryInfo_);
     6828    else
     6829      symmetryInfo_ = NULL;
     6830#endif
    65556831    synchronizeModel();
    65566832}
     
    69177193      easy way to pass in the size. But we take a hit for memory allocation.
    69187194    */
    6919     lastws->setSize(numberColumns, numberRowsAtContinuous_ + currentNumberCuts);
     7195    if (lastws)
     7196      lastws->setSize(numberColumns, numberRowsAtContinuous_ + currentNumberCuts);
    69207197    currentNumberCuts = 0;
    69217198    while (nNode) {
     
    69257202    }
    69267203#ifndef NDEBUG
    6927     if (!lastws->fullBasis()) {
     7204    if (lastws&&!lastws->fullBasis()) {
    69287205#ifdef COIN_DEVELOP
    69297206        printf("******* bad basis\n");
     
    69507227  descendants.
    69517228*/
    6952 int CbcModel::addCuts (CbcNode *node, CoinWarmStartBasis *&lastws, bool canFix)
     7229int CbcModel::addCuts (CbcNode *node, CoinWarmStartBasis *&lastws)
    69537230{
    69547231    /*
     
    69677244    double cutoff = getCutoff() ;
    69687245    int currentNumberCuts = currentNumberCuts_;
    6969     if (canFix) {
    6970         bool feasible = true;
    6971         const double *lower = solver_->getColLower() ;
    6972         const double *upper = solver_->getColUpper() ;
    6973         double * newLower = analyzeResults_;
    6974         double * objLower = newLower + numberIntegers_;
    6975         double * newUpper = objLower + numberIntegers_;
    6976         double * objUpper = newUpper + numberIntegers_;
    6977         int n = 0;
    6978         for (i = 0; i < numberIntegers_; i++) {
    6979             int iColumn = integerVariable_[i];
    6980             bool changed = false;
    6981             double lo = 0.0;
    6982             double up = 0.0;
    6983             if (objLower[i] > cutoff) {
    6984                 lo = lower[iColumn];
    6985                 up = upper[iColumn];
    6986                 if (lo < newLower[i]) {
    6987                     lo = newLower[i];
    6988                     solver_->setColLower(iColumn, lo);
    6989                     changed = true;
    6990                     n++;
    6991                 }
    6992                 if (objUpper[i] > cutoff) {
    6993                     if (up > newUpper[i]) {
    6994                         up = newUpper[i];
    6995                         solver_->setColUpper(iColumn, up);
    6996                         changed = true;
    6997                         n++;
    6998                     }
    6999                 }
    7000             } else if (objUpper[i] > cutoff) {
    7001                 lo = lower[iColumn];
    7002                 up = upper[iColumn];
    7003                 if (up > newUpper[i]) {
    7004                     up = newUpper[i];
    7005                     solver_->setColUpper(iColumn, up);
    7006                     changed = true;
    7007                     n++;
    7008                 }
    7009             }
    7010             if (changed && lo > up) {
    7011                 feasible = false;
    7012                 break;
    7013             }
    7014         }
    7015         if (!feasible) {
    7016           COIN_DETAIL_PRINT(printf("analysis says node infeas\n"));
    7017             cutoff = -COIN_DBL_MAX;
    7018         }
    7019     }
    70207246    /*
    70217247      If the node can't be fathomed by bound, reinstall tight cuts in the
     
    70607286                           numberRowsAtContinuous_ + numberToAdd);
    70617287#         endif
     7288                    whichGenerator_[numberToAdd] = whichGenerator_[i];
    70627289                    addCuts[numberToAdd++] = addedCuts_[i];
    70637290#if 1
     
    71877414                }
    71887415#endif
    7189                 //int n2=solver_->getNumRows();
    7190                 //for (int j=0;j<numberToAdd;j++)
    7191                 //addCuts[j]->print();
    71927416                solver_->applyRowCuts(numberToAdd, addCuts);
    7193                 //int n3=solver_->getNumRows();
    7194                 //printf("NBefore %d, after del %d, now %d\n",n1,n2,n3);
    71957417            }
    71967418#     ifdef CBC_CHECK_BASIS
     
    71997421            lastws->print();
    72007422#     endif
    7201             //for (i=0;i<numberToAdd;i++)
    7202             //delete addCuts[i];
    72037423            delete [] addCuts;
    72047424            delete [] cutsToDrop ;
     
    73687588    }
    73697589    numberDJFixed_ += numberFixed - numberTightened;
     7590#ifdef SWITCH_VARIABLES
     7591    if (numberFixed)
     7592      fixAssociated(NULL,0);
     7593#endif
    73707594    return numberFixed;
    73717595}
     
    75077731    int returnCode = resolve(node ? node->nodeInfo() : NULL, 1);
    75087732    moreSpecialOptions_=save;
    7509 #ifdef CONFLICT_CUTS
     7733#ifdef CONFLICT_CUTS 
    75107734#ifdef COIN_HAS_CLP
    75117735    // if infeasible conflict analysis
    75127736    if (solver_->isProvenPrimalInfeasible()&&!parentModel_&&
    75137737        (moreSpecialOptions_&4194304)!=0&&clpSolver) {
    7514       //printf("infeasible - do conflict analysis\n");
     7738      if (!topOfTree_ && masterThread_)
     7739        topOfTree_ = masterThread_->master_->baseModel_->topOfTree_;
    75157740      assert (topOfTree_);
    7516       int iType=1;
     7741      int iType=0;
    75177742      OsiRowCut * cut = clpSolver->modelCut(topOfTree_->lower(),
    75187743                                            topOfTree_->upper(),
    75197744                                            numberRowsAtContinuous_,whichGenerator_,iType);
    75207745      if (cut) {
    7521         printf("XXXXXX cut\n");
    75227746        //cut->print();
    75237747        if (!iType) {
    7524           makeGlobalCut(cut) ;
     7748          int badCut = makeGlobalCut(cut) ;
     7749          if (!badCut) {
     7750#if PRINT_CONFLICT==1
     7751            numberConflictCuts++;
     7752            lengthConflictCuts += cut->row().getNumElements();
     7753#endif
     7754#if PRINT_CONFLICT<2
     7755            if (handler_->logLevel() > 1) {
     7756#endif
     7757              printf("Conflict cut at depth %d (%d elements)\n",
     7758                     currentDepth_,cut->row().getNumElements());
     7759              if (cut->row().getNumElements()<3)
     7760                cut->print();
     7761#if PRINT_CONFLICT<2
     7762            }
     7763#endif
     7764          }
    75257765          if ((specialOptions_&1) != 0) {
    75267766            debugger = continuousSolver_->getRowCutDebugger() ;
     
    75477787#endif
    75487788#endif   
    7549 #if COIN_DEVELOP>1
    7550     //if (!solver_->getIterationCount()&&solver_->isProvenOptimal())
    7551     //printf("zero iterations on first solve of branch\n");
    7552 #endif
    75537789    double lastObjective = solver_->getObjValue() * solver_->getObjSense();
    75547790    cut_obj[CUT_HISTORY-1] = lastObjective;
     
    77107946                double objectiveValue = solver_->getObjValue() * solver_->getObjSense();
    77117947                double changeInObjective = CoinMax(0.0, objectiveValue - originalValue);
    7712                 int iStatus = (feasible) ? 0 : 0;
    77137948                double value = obj->value();
    77147949                double movement;
     
    77187953                    movement = value - floor(value);
    77197954                branchingMethod_->chooseMethod()->updateInformation(iObject, branch, changeInObjective,
    7720                         movement, iStatus);
     7955                                            movement, 0 /*(feasible) ? 0 : 1; */);
    77217956            }
    77227957        }
     
    77748009    if ( maximumSecondsReached() )
    77758010        numberTries = 0; // exit
     8011    if ((moreSpecialOptions2_&(2048|4096))!=0 && currentDepth_>5) {
     8012      // howOftenGlobalScan_ = 10;
     8013      int type = (moreSpecialOptions2_&(2048|4096))>>11;
     8014      if (type==1) {
     8015        int n=0;
     8016        int k=currentDepth_;
     8017        while (k) {
     8018          if ((k&1)!=0)
     8019            n++;
     8020          k = k >>1;
     8021        }
     8022        if (n>1)
     8023          numberTries=0;
     8024      } else if (type==2) {
     8025        if ((currentDepth_%4)!=0)
     8026          numberTries=0;
     8027      } else {
     8028        if ((currentDepth_%8)!=0)
     8029          numberTries=0;
     8030      }
     8031    }
    77768032    //if ((numberNodes_%100)==0)
    77778033    //printf("XXa sum obj changed by %g\n",sumChangeObjective1_);
     
    79258181#define CHECK_DEBUGGER
    79268182#ifdef CHECK_DEBUGGER
    7927                 if ((specialOptions_&1) != 0 ) {
     8183                if ((specialOptions_&1) != 0 && ! parentModel_) {
    79288184                  CoinAssert (!solver_->getRowCutDebuggerAlways()->invalidCut(*thisCut));
    79298185                }
     
    79338189                       thisCut->violated(cbcColSolution_)) ;
    79348190#endif
    7935                 whichGenerator_[numberViolated++] = -1;
     8191                whichGenerator_[numberViolated++] = 20099;
    79368192#ifndef GLOBAL_CUTS_JUST_POINTERS
    79378193                theseCuts.insert(*thisCut) ;
     
    79848240            if (clpSolver)
    79858241                clpSolver->setSpecialOptions(save);
    7986 #ifdef CLP_INVESTIGATE
     8242#if CBC_USEFUL_PRINTING>1
    79878243            if (clpSolver->getModelPtr()->numberIterations())
    79888244                printf("ITS %d pass %d\n",
     
    80188274            resizeWhichGenerator(numberViolated, numberViolated + 1);
    80198275            // set whichgenerator (also serves as marker to say don't delete0
    8020             whichGenerator_[numberViolated++] = -2;
     8276            whichGenerator_[numberViolated++] = 20098;
    80218277        }
    80228278
     
    81008356                    incrementUsed(newSolution);
    81018357                    lastHeuristic_ = heuristic_[found];
    8102 #ifdef CLP_INVESTIGATE
     8358#ifdef HEURISTIC_INFORM
    81038359                    printf("HEUR %s where %d A\n",
    81048360                           lastHeuristic_->heuristicName(), whereFrom);
     
    82708526            if (numberToAdd > 0) {
    82718527                int i ;
     8528                int * whichGenerator = whichGenerator_ -
     8529                  numberRowsAtContinuous_+solver_->getNumRows();
    82728530                // Faster to add all at once
    82738531                addCuts = new const OsiRowCut * [numberToAdd] ;
    82748532                for (i = 0 ; i < numberToAdd ; i++) {
    82758533                    addCuts[i] = &theseCuts.rowCut(i) ;
     8534                    whichGenerator[i]=90;
    82768535                }
    82778536                if ((specialOptions_&262144) != 0 && !parentModel_) {
     
    84178676                            }
    84188677                        }
    8419 #ifdef CLP_INVESTIGATE2
     8678#if CBC_USEFUL_PRINTING>12
    84208679                        if (!parentModel_ && !numberNodes_)
    84218680                            printf("badObj %s nBad %d maxBad %d goodDrop %g minDrop %g thisDrop %g obj %g\n",
     
    84408699                    if (thisObj - lastObjective > drop[currentDepth_]*minimumDrop) {
    84418700                        numberTries++;
    8442 #ifdef CLP_INVESTIGATE
     8701#if CBC_USEFUL_PRINTING>1
    84438702                        //printf("drop %g %g %d\n",thisObj,lastObjective,currentPassNumber_);
    84448703#endif
     
    85548813
    85558814                    for (int i = numberGlobalBefore ; i < numberGlobalAfter ; i++) {
    8556                         whichGenerator_[numberNewCuts_++] = -1;
     8815                        whichGenerator_[numberNewCuts_++] = 20099;
    85578816#ifndef GLOBAL_CUTS_JUST_POINTERS
    85588817                        cuts.insert(*globalCuts_.rowCutPtr(i)) ;
     
    86378896                    incrementUsed(newSolution);
    86388897                    lastHeuristic_ = heuristic_[found];
    8639 #ifdef CLP_INVESTIGATE
     8898#ifdef HEURISTIC_INFORM
    86408899                    printf("HEUR %s where %d B\n",
    86418900                           lastHeuristic_->heuristicName(), whereFrom);
     
    87569015                bool smallProblem = size <= 550;
    87579016                smallProblem = false;
    8758 #ifdef CLP_INVESTIGATE
     9017#if CBC_USEFUL_PRINTING>1
    87599018                int maxPass = maximumCutPasses_;
    87609019#endif
     
    88539112                    whenCuts_ += 100000;
    88549113                //// end
    8855 #ifdef CLP_INVESTIGATE
     9114#if CBC_USEFUL_PRINTING>1
    88569115                printf("changing whenCuts from %d to %d and cutPasses from %d to %d objchange %g\n",
    88579116                       whenC, whenCuts_, maxPass, maximumCutPasses_, thisObjective - startObjective);
     
    89109169            if (numberColumns < 200)
    89119170                value = CoinMax(minimumDrop_, 0.1 * value);
    8912 #ifdef CLP_INVESTIGATE
     9171#if CBC_USEFUL_PRINTING>1
    89139172            printf("Minimum drop for cuts was %g, now is %g\n", minimumDrop_, value);
    89149173#endif
     
    89209179        for (i = 0; i < numberNewCuts_; i++) {
    89219180            int iGenerator = whichGenerator_[i];
     9181            //assert (iGenerator>=0);
    89229182            if (iGenerator>=0)
    89239183              iGenerator=iGenerator%10000;
     
    93059565                for (i = 0; i < numberNewCuts_; i++) {
    93069566                    int iGenerator = whichGenerator_[i];
     9567#ifdef CONFLICT_CUTS
     9568                    assert (iGenerator>=0);
     9569#endif
    93079570                    if (iGenerator>=0)
    93089571                      iGenerator=iGenerator%10000;
    9309                     if (iGenerator >= 0)
     9572                    if (iGenerator >= 0 && iGenerator < numberCutGenerators_)
    93109573                        generator_[iGenerator]->incrementNumberCutsActive();
    93119574                }
     
    94699732            }
    94709733#endif
    9471             if (mustResolve || (specialOptions_&1) != 0) {
     9734            if (mustResolve /*|| (specialOptions_&1) != 0*/) {
    94729735                int returnCode = resolve(node ? node->nodeInfo() : NULL, 2);
    94739736                if (returnCode  == 0)
     
    95409803                break;
    95419804            }
    9542             whichGenerator_[numberBefore++] = i ;
     9805            whichGenerator_[numberBefore++] = i+20000 ;
    95439806            if (!numberNodes_||generator_[i]->globalCuts())
    95449807              whichGenerator_[numberBefore-1]=i+10000;
     
    95659828            for (; j < numberRowCutsAfter; j++) {
    95669829                const OsiRowCut * thisCut = theseCuts.rowCutPtr(j) ;
    9567                 whichGenerator_[numberBefore++] = i ;
     9830                whichGenerator_[numberBefore++] = i+20000 ;
    95689831                if (!numberNodes_||generator_[i]->globalCuts())
    95699832                  whichGenerator_[numberBefore-1]=i+10000;
     
    96169879                    printf("Old cut added - violation %g\n",
    96179880                           thisCut->violated(cbcColSolution_)) ;
    9618                 whichGenerator_[numberOld++] = -3;
     9881                whichGenerator_[numberOld++] = 20097;
    96199882                theseCuts.insert(*thisCut) ;
    96209883            }
     
    96769939    int firstOldCut = numberRowsAtContinuous_ ;
    96779940    int totalNumberCuts = numberNewCuts_ + numberOldActiveCuts_ ;
     9941    assert (numberRowsAtContinuous_+totalNumberCuts==
     9942            solver_->getNumRows());
    96789943    int *solverCutIndices = new int[totalNumberCuts] ;
    96799944    int *newCutIndices = new int[numberNewCuts_] ;
     
    96909955        int numberOldToDelete = 0 ;
    96919956        int i ;
     9957        int kCut=0;
    96929958        ws = dynamic_cast<const CoinWarmStartBasis*>(solver_->getWarmStart()) ;
    96939959        /*
     
    97159981                        if (slackCut->effectiveness() != -1.234) {
    97169982                            slackCut->setEffectiveness(-1.234);
     9983                            slackCut->setGloballyValid();
    97179984                            saveCuts->insert(*slackCut);
    97189985                        }
     
    97239990                    oldCutIndex++ ;
    97249991                } else {
    9725                     oldCutIndex++ ;
     9992                    int iGenerator = addedCuts_[oldCutIndex]->whichCutGenerator();
     9993                    if (iGenerator==-1)
     9994                      iGenerator=100;
     9995                    whichGenerator_[kCut++] = iGenerator ;
     9996                    oldCutIndex++;
    97269997                }
    97279998            }
     
    973610007        */
    973710008        int firstNewCut = firstOldCut + numberOldActiveCuts_ ;
    9738         int k = 0 ;
    973910009        int nCuts = newCuts.sizeRowCuts();
    974010010        for (i = 0 ; i < nCuts ; i++) {
     
    974510015                newCutIndices[numberNewToDelete++] = i ;
    974610016            } else { // save which generator did it
    9747                 // -2 means branch cut! assert (whichGenerator_[i]!=-2); // ?? what if it is - memory leak?
    9748                 whichGenerator_[k++] = whichGenerator_[i] ;
     10017                // 20098 means branch cut! assert (whichGenerator_[i]!=20098); // ?? what if it is - memory leak?
     10018                whichGenerator_[kCut++] = whichGenerator_[i] ;
    974910019            }
    975010020        }
     
    977710047                if (slackCut->effectiveness() != -1.234) {
    977810048                    slackCut->setEffectiveness(-1.234);
     10049                    slackCut->setGloballyValid();
    977910050                    saveCuts->insert(slackCut);
    978010051                } else {
     
    982610097        }
    982710098    }
     10099   
    982810100    /*
    982910101      Clean up and return.
     
    984910121    cbc_resolve_check(solver_);
    985010122#endif
     10123    bool onOptimalPath = false;
     10124    if ((specialOptions_&1) != 0) {
     10125      const OsiRowCutDebugger *debugger = solver_->getRowCutDebugger() ;
     10126      if (debugger) {
     10127        onOptimalPath = true;
     10128        printf("On optimal path d\n") ;
     10129      }
     10130    }
    985110131    // We may have deliberately added in violated cuts - check to avoid message
    985210132    int iRow;
     
    988110161    */
    988210162    if (feasible) {
    9883         bool onOptimalPath = false;
    9884         if ((specialOptions_&1) != 0) {
    9885             const OsiRowCutDebugger *debugger = solver_->getRowCutDebugger() ;
    9886             if (debugger) {
    9887                 onOptimalPath = true;
    9888                 printf("On optimal path d\n") ;
    9889             }
    9890         }
    989110163        int nTightened = 0;
    989210164#ifdef COIN_HAS_CLP
     
    992610198                //double cutoff = getCutoff();
    992710199                if (bestObjective_ - getCutoffIncrement() < testValue) {
    9928 #ifdef CLP_INVESTIGATE
     10200#if CBC_USEFUL_PRINTING>1
    992910201                    double value ;
    993010202                    solver_->getDblParam(OsiDualObjectiveLimit, value) ;
     
    1017410446        }
    1017510447    }
     10448#if 0
     10449    if ((specialOptions_&1) != 0 && onOptimalPath) {
     10450      const OsiRowCutDebugger *debugger = solver_->getRowCutDebugger() ;
     10451      if (!debugger) {
     10452        // tighten did something???
     10453        solver_->getRowCutDebuggerAlways()->printOptimalSolution(*solver_);
     10454        solver_->writeMpsNative("infeas4.mps", NULL, NULL, 2);
     10455        printf("Not on optimalpath aaaa\n");
     10456        //abort();
     10457      } else {
     10458        printf("Still on optimal path\n");
     10459      }
     10460    }
     10461#endif
    1017610462    return returnStatus ;
    1017710463}
     
    1041910705            printf("%d cliques of average size %g found, %d P1, %d M1\n",
    1042010706                   numberCliques,
    10421                    (static_cast<double>(totalP1 + totalM1)) / (static_cast<double> numberCliques),
     10707                   (static_cast<double>(totalP1 + totalM1)) / (static_cast<double> (numberCliques)),
    1042210708                   totalP1, totalM1);
    1042310709        else
     
    1110511391            // treat as if will cost what it says up
    1110611392            double upCost = costValue;
     11393#ifndef BRANCH_BREAKEVEN
     11394#define BRANCH_BREAKEVEN 0.3
     11395#else
     11396            preferredWay=1;
     11397#endif
    1110711398            // and balance at breakeven of 0.3
    11108             double downCost = (0.7 * upCost) / 0.3;
     11399            double downCost = ((1.0-BRANCH_BREAKEVEN) * upCost) / BRANCH_BREAKEVEN;
    1110911400            if (obj1a) {
    1111011401                upCost = obj1a->upPseudoCost();
     
    1114211433        branchingMethod_ = new CbcBranchDynamicDecision();
    1114311434    }
     11435#ifdef SWITCH_VARIABLES
     11436    // see if any switching variables
     11437    if (numberIntegers_<solver_->getNumCols())
     11438      findSwitching();
     11439#endif
    1114411440    synchronizeNumberBeforeTrust();
    1114511441}
     11442#ifdef SWITCH_VARIABLES
     11443// Convert Dynamic to Switching
     11444int
     11445CbcModel::findSwitching()
     11446{
     11447  if ((moreSpecialOptions2_&1)==0)
     11448    return 0;
     11449  const CoinPackedMatrix * rowCopy = solver_->getMatrixByRow();
     11450  const int * column = rowCopy->getIndices();
     11451  const int * rowLength = rowCopy->getVectorLengths();
     11452  const CoinBigIndex * rowStart = rowCopy->getVectorStarts();
     11453  const double * rowLower = solver_->getRowLower();
     11454  const double * rowUpper = solver_->getRowUpper();
     11455  const double * columnLower = solver_->getColLower();
     11456  const double * columnUpper = solver_->getColUpper();
     11457  const double * element = rowCopy->getElements();
     11458  //const double * element = solver_->getMatrixByCol()->getElements();
     11459  const int * row = solver_->getMatrixByCol()->getIndices();
     11460  const CoinBigIndex * columnStart = solver_->getMatrixByCol()->getVectorStarts();
     11461  const int * columnLength = solver_->getMatrixByCol()->getVectorLengths();
     11462  int numberRows = solver_->getNumRows();
     11463  int numberColumns = solver_->getNumCols();
     11464  int * sort = new int[2*numberRows+2+numberColumns];
     11465  int * whichRow = sort+numberRows+1;
     11466  int * marked = whichRow+numberRows+1;
     11467  memset(marked,0,numberColumns*sizeof(int));
     11468  int nnSwitch=0;
     11469  int nnSwitchTotal=0;
     11470  int n2Switch=0;
     11471  double largeRatio1=1000.0;
     11472  double largeRatio2=100.0;
     11473  for (int i=0;i<numberIntegers_;i++) {
     11474    int iColumn = integerVariable_[i];
     11475    if (columnLower[iColumn]||columnUpper[iColumn]!=1.0)
     11476      continue;
     11477    if (!dynamic_cast <CbcSimpleInteger *> (object_[i]))
     11478      continue;
     11479    int nAdd=0;
     11480    bool takeThis=false;
     11481    CoinBigIndex start = columnStart[iColumn];
     11482    CoinBigIndex end = start + columnLength[iColumn];
     11483    for (CoinBigIndex j = start; j < end; j++) {
     11484      int iRow = row[j];
     11485      if (rowLength[iRow]!=2) {
     11486        continue;
     11487      }
     11488      // for now just 0.0 in rhs
     11489      if (!rowLower[iRow]) {
     11490        if (rowUpper[iRow]!=COIN_DBL_MAX)
     11491          continue;
     11492      } else if (rowLower[iRow]!=-COIN_DBL_MAX) {
     11493        continue;
     11494      } else if (rowUpper[iRow]) {
     11495        continue;
     11496      }
     11497      CoinBigIndex k = rowStart[iRow];
     11498      double bValue, cValue;
     11499      int cColumn;
     11500      if (column[k]==iColumn) {
     11501        bValue=element[k];
     11502        cValue=element[k+1];
     11503        cColumn=column[k+1];
     11504      } else {
     11505        bValue=element[k+1];
     11506        cValue=element[k];
     11507        cColumn=column[k];
     11508      }
     11509      if (solver_->isInteger(cColumn))
     11510        continue;
     11511      if (columnLower[cColumn]<0.0)
     11512        continue;
     11513      if (bValue*cValue>0.0)
     11514        continue;
     11515      if (fabs(bValue)>largeRatio1*fabs(cValue))
     11516        takeThis=true;
     11517      // add to list
     11518      whichRow[nAdd]=iRow;
     11519      sort[nAdd++]=cColumn;
     11520    }
     11521    if (nAdd) {
     11522      n2Switch++;
     11523      CoinSort_2(sort,sort+nAdd,whichRow);
     11524      int last=sort[0];
     11525      for (int k=1;k<nAdd;k++) {
     11526        if (sort[k]==last)
     11527          takeThis=true;
     11528        else
     11529          last=sort[k];
     11530      }
     11531      if (takeThis) {
     11532        int last=sort[0];
     11533        marked[last]++;
     11534        for (int k=1;k<nAdd;k++) {
     11535          if (sort[k]!=last) {
     11536            last=sort[k];
     11537            marked[last]++;
     11538          }
     11539        }
     11540        //printf("Column %d has %d other columns\n",iColumn,nAdd);
     11541        sort[nAdd]=COIN_INT_MAX;
     11542        whichRow[nAdd]=COIN_INT_MAX;
     11543        CbcSimpleIntegerDynamicPseudoCost * thisOne =
     11544          dynamic_cast <CbcSimpleIntegerDynamicPseudoCost *> (object_[i]);
     11545        if (thisOne) {
     11546          assert(iColumn == thisOne->columnNumber());
     11547          object_[i]=new CbcSwitchingBinary(thisOne,nAdd,sort,whichRow);
     11548          delete thisOne;
     11549        } else {
     11550          CbcSimpleInteger * thisOne =
     11551            dynamic_cast <CbcSimpleInteger *> (object_[i]);
     11552          assert (thisOne);
     11553          assert(iColumn == thisOne->columnNumber());
     11554          CbcSimpleIntegerDynamicPseudoCost tempObj(this,iColumn,0.1);
     11555          object_[i]=new CbcSwitchingBinary(&tempObj,nAdd,sort,whichRow);
     11556          delete thisOne;
     11557        }
     11558      }
     11559    }
     11560    // see if there is an interesting row
     11561    for (CoinBigIndex j = start; j < end; j++) {
     11562      int iRow = row[j];
     11563      // for now just 0.0 in rhs
     11564      if (!rowLower[iRow]) {
     11565        if (rowUpper[iRow]!=COIN_DBL_MAX)
     11566          continue;
     11567      } else if (rowLower[iRow]!=-COIN_DBL_MAX) {
     11568        continue;
     11569      } else if (rowUpper[iRow]) {
     11570        continue;
     11571      }
     11572      int nOther=0;
     11573      double bEl=0.0;
     11574      double cMax=-COIN_DBL_MAX;
     11575      double cMin=COIN_DBL_MAX;
     11576      for (CoinBigIndex k = rowStart[iRow];
     11577           k<rowStart[iRow]+rowLength[iRow];k++) {
     11578        int jColumn = column[k];
     11579        if (jColumn==iColumn) {
     11580          bEl=element[k];
     11581        } else {
     11582          sort[nOther++]=jColumn;
     11583          if (solver_->isInteger(jColumn)) {
     11584            cMin=-1.0;
     11585            cMax=1.0;
     11586            break;
     11587          } else {
     11588            cMax=CoinMax(cMax,element[k]);
     11589            cMin=CoinMin(cMin,element[k]);
     11590            if (columnLower[jColumn]<0.0) {
     11591              cMin=-1.0;
     11592              cMax=1.0;
     11593              break;
     11594            }
     11595          }
     11596        }
     11597      }
     11598      double largestC = CoinMax(fabs(cMin),fabs(cMax));
     11599      if (((cMin>0.0&&bEl<0.0&&!rowUpper[iRow])||
     11600           (cMin<0.0&&bEl>0.0&&!rowLower[iRow]))&&cMin*cMax>0.0&&
     11601          fabs(bEl)>largeRatio2*largestC) {
     11602        // forces to zero
     11603        CbcSwitchingBinary * object =
     11604          dynamic_cast <CbcSwitchingBinary *> (object_[i]);
     11605        if (!object) {
     11606          // create empty one
     11607          CbcSimpleIntegerDynamicPseudoCost * thisOne =
     11608            dynamic_cast <CbcSimpleIntegerDynamicPseudoCost *> (object_[i]);
     11609          if (thisOne) {
     11610            assert(iColumn == thisOne->columnNumber());
     11611            object=new CbcSwitchingBinary(thisOne,0,sort,whichRow);
     11612            delete thisOne;
     11613          } else {
     11614            CbcSimpleInteger * thisOne =
     11615              dynamic_cast <CbcSimpleInteger *> (object_[i]);
     11616            assert (thisOne);
     11617            assert(iColumn == thisOne->columnNumber());
     11618            CbcSimpleIntegerDynamicPseudoCost tempObj(this,iColumn,0.1);
     11619            object=new CbcSwitchingBinary(&tempObj,0,sort,whichRow);
     11620            delete thisOne;
     11621          }
     11622          object_[i]=object;
     11623        }
     11624        object->addZeroSwitches(nOther,sort);
     11625        nnSwitch++;
     11626        nnSwitchTotal+=nOther;
     11627      }
     11628    }
     11629  }
     11630  if (n2Switch+nnSwitch) {
     11631    if (handler_->logLevel()>2)
     11632      printf("%d two switch variables - %d multi (total multi %d)\n",
     11633             n2Switch,nnSwitch,nnSwitchTotal);
     11634    memset(whichRow,0,(numberRows+1)*sizeof(int));
     11635    for (int i=0;i<numberColumns;i++) {
     11636      whichRow[marked[i]]++;
     11637    }
     11638    if (handler_->logLevel()>2) {
     11639      for (int i=0;i<numberRows+1;i++) {
     11640        if (whichRow[i])
     11641          printf("%d variables have %d switches\n",whichRow[i],i);
     11642      }
     11643    }
     11644  }
     11645  delete [] sort;
     11646  // say switches exist
     11647  if (n2Switch+nnSwitch)
     11648    moreSpecialOptions2_|=4;
     11649  return n2Switch+nnSwitch;
     11650}
     11651// Fix associated variables
     11652int
     11653CbcModel::fixAssociated(OsiSolverInterface * solver,int cleanBasis)
     11654{
     11655  int nChanged=0;
     11656  if ((moreSpecialOptions2_&4)!=0) {
     11657    int n=-1;
     11658    while (n) {
     11659      n=0;
     11660      for (int i=0;i<numberObjects_;i++) {
     11661        CbcSwitchingBinary * object = dynamic_cast<CbcSwitchingBinary *> (object_[i]);
     11662        if (object) {
     11663          n += object->setAssociatedBounds(solver,cleanBasis);
     11664        }
     11665      }
     11666      nChanged+=n;
     11667    }
     11668  }
     11669  return nChanged;
     11670}
     11671/* Debug associated variables
     11672   printLevel - 1 summary if bad on fixed
     11673                2 summary if bad on satisfied
     11674                3 for individuals
     11675 */
     11676int
     11677CbcModel::checkAssociated(const OsiSolverInterface * solver,
     11678                          const double * solution,int printLevel)
     11679{
     11680  int nBad=0;
     11681  int nBadFixed=0;
     11682  if ((moreSpecialOptions2_&4)!=0) {
     11683    int nAt0=0;
     11684    int nAt1=0;
     11685    int nBetween=0;
     11686    for (int i=0;i<numberObjects_;i++) {
     11687      CbcSwitchingBinary * object = dynamic_cast<CbcSwitchingBinary *> (object_[i]);
     11688      if (object) {
     11689        int state[3];
     11690        nBad += object->checkAssociatedBounds(solver,solution,printLevel,state,
     11691                                              nBadFixed);
     11692        if (state[0]==0)
     11693          nBetween++;
     11694        else if (state[0]==-1)
     11695          nAt0++;
     11696        else
     11697          nAt1++;
     11698      }
     11699    }
     11700    if (handler_->logLevel()>2) {
     11701      if (printLevel>1||(printLevel==1&&nBadFixed)) {
     11702        printf("%d switches, %d at 0, %d at 1, %d between - %d bad values (%d when fixed)\n",
     11703               nBetween+nAt0+nAt1,nAt0,nAt1,nBetween,nBad,nBadFixed);
     11704        if (nBadFixed && printLevel!=3)
     11705          checkAssociated(solver,solution,3);
     11706      }
     11707    }
     11708  }
     11709  return nBad;
     11710}
     11711#endif
    1114611712// Set numberBeforeTrust in all objects
    1114711713void
     
    1146412030
    1146512031{
     12032    int numberContinuousColumns=continuousSolver_->getNumCols();
    1146612033    if (!solverCharacteristics_->solutionAddsCuts()) {
    1146712034        // Can trust solution
    1146812035        int numberColumns = solver_->getNumCols();
     12036#ifdef COIN_HAS_CLP
     12037        OsiClpSolverInterface * clpContinuousSolver
     12038          = dynamic_cast<OsiClpSolverInterface *> (continuousSolver_);
     12039        int modifiedTolerances=0;
     12040#ifndef CBC_LEAVE_PERTURBATION_ON_CHECK_SOLUTION
     12041        int savePerturbation=-1;
     12042#endif
     12043#ifndef CBC_LEAVE_TOLERANCE_ON_CHECK_SOLUTION
     12044        double savePrimalTolerance=0.0;
     12045#endif
     12046#ifndef CBC_LEAVE_SCALING_ON_CHECK_SOLUTION
     12047        int saveScaling=-1;
     12048#endif
     12049        if (clpContinuousSolver ) {
     12050          // be more accurate if possible
     12051          ClpSimplex * clp = clpContinuousSolver->getModelPtr();
     12052#ifndef CBC_LEAVE_PERTURBATION_ON_CHECK_SOLUTION
     12053          savePerturbation=clp->perturbation();
     12054#endif
     12055#ifndef CBC_LEAVE_TOLERANCE_ON_CHECK_SOLUTION
     12056          savePrimalTolerance=clp->primalTolerance();
     12057#endif
     12058#ifndef CBC_LEAVE_SCALING_ON_CHECK_SOLUTION
     12059          saveScaling=clp->scalingFlag();
     12060#endif
     12061#ifndef CBC_LEAVE_TOLERANCE_ON_CHECK_SOLUTION
     12062          if (savePrimalTolerance>0.9999999e-7) {
     12063            modifiedTolerances |= 1;
     12064            clp->setPrimalTolerance(1.0e-8);
     12065          }
     12066#endif
     12067#ifndef CBC_LEAVE_PERTURBATION_ON_CHECK_SOLUTION
     12068          if (savePerturbation<100) {
     12069            modifiedTolerances |= 2;
     12070            clp->setPerturbation(100);
     12071          }
     12072#endif
     12073#ifndef CBC_LEAVE_SCALING_ON_CHECK_SOLUTION
     12074          if (saveScaling) {
     12075            modifiedTolerances |= 4;
     12076            clp->scaling(0);
     12077          }
     12078#endif
     12079        }
     12080#endif
    1146912081
    1147012082        /*
     
    1150112113        memcpy(saveUpper, getColUpper(), numberColumns*sizeof(double));
    1150212114        memcpy(saveLower, getColLower(), numberColumns*sizeof(double));
     12115        //#define CLP_INVESTIGATE4
     12116#if CBC_USEFUL_PRINTING>14
     12117        {
     12118          int nBad=checkAssociated(solver_,solver_->getColSolution(),1);
     12119          if (nBad)
     12120            checkAssociated(solver_,solver_->getColSolution(),3);
     12121          double largestInfeasibility = 0.0;
     12122          double primalTolerance ;
     12123          double offset;
     12124          solver_->getDblParam(OsiObjOffset, offset);
     12125          solver_->getDblParam(OsiPrimalTolerance, primalTolerance) ;
     12126          const double *objective = getObjCoefficients() ;
     12127          const double * rowLower = solver_->getRowLower() ;
     12128          const double * rowUpper = solver_->getRowUpper() ;
     12129          const double * columnLower = solver_->getColLower() ;
     12130          const double * columnUpper = solver_->getColUpper() ;
     12131          int numberRows = solver_->getNumRows() ;
     12132          double *rowActivity = new double[numberRows] ;
     12133          memset(rowActivity, 0, numberRows*sizeof(double)) ;
     12134          double *rowSum = new double[numberRows] ;
     12135          memset(rowSum, 0, numberRows*sizeof(double)) ;
     12136          int * marked = new int [numberColumns];
     12137          for (int i=0;i<numberColumns;i++)
     12138            marked[i]=-1;
     12139          for (int i=0;i<numberIntegers_;i++)
     12140            marked[integerVariable_[i]]=-2;
     12141          if ((moreSpecialOptions2_&4)!=0) {
     12142            for (int i=0;i<numberObjects_;i++) {
     12143              CbcSwitchingBinary * object = dynamic_cast<CbcSwitchingBinary *> (object_[i]);
     12144              if (object) {
     12145                int iColumn = object->columnNumber();
     12146                const int * other = object->otherVariable();
     12147                marked[iColumn]=-3-other[0];
     12148                int n=object->numberOther();
     12149                for (int k=0;k<n;k++)
     12150                  marked[other[k]]=iColumn;
     12151              }
     12152            }
     12153          }
     12154          const double * element = solver_->getMatrixByCol()->getElements();
     12155          const int * row = solver_->getMatrixByCol()->getIndices();
     12156          const CoinBigIndex * columnStart = solver_->getMatrixByCol()->getVectorStarts();
     12157          const int * columnLength = solver_->getMatrixByCol()->getVectorLengths();
     12158          const CoinPackedMatrix * rowCopy = solver_->getMatrixByRow();
     12159          const int * column = rowCopy->getIndices();
     12160          const int * rowLength = rowCopy->getVectorLengths();
     12161          const CoinBigIndex * rowStart = rowCopy->getVectorStarts();
     12162          const double * elementByRow = rowCopy->getElements();
     12163          double objValue=-offset;
     12164          for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
     12165            double value = solution[iColumn];
     12166            objValue += value*objective[iColumn];
     12167            if (value>columnUpper[iColumn]) {
     12168              if (value-columnUpper[iColumn]>1.0e-8)
     12169                printf("column %d has value %.12g above %.12g\n",iColumn,value,columnUpper[iColumn]);
     12170              value=columnUpper[iColumn];
     12171            } else if (value<columnLower[iColumn]) {
     12172              if (value-columnLower[iColumn]<-1.0e-8)
     12173                printf("column %d has value %.12g below %.12g\n",iColumn,value,columnLower[iColumn]);
     12174              value=columnLower[iColumn];
     12175            }
     12176            if (value) {
     12177              CoinBigIndex start = columnStart[iColumn];
     12178              CoinBigIndex end = start + columnLength[iColumn];
     12179              for (CoinBigIndex j = start; j < end; j++) {
     12180                int iRow = row[j];
     12181                rowActivity[iRow] += value * element[j];
     12182                rowSum[iRow] += fabs(value * element[j]);
     12183              }
     12184            }
     12185          }
     12186          for (int i = 0 ; i < numberRows ; i++) {
     12187#if 0 //def CLP_INVESTIGATE
     12188            double inf;
     12189            inf = rowLower[i] - rowActivity[i];
     12190            if (inf > primalTolerance)
     12191              printf("Row %d inf %g sum %g %g <= %g <= %g\n",
     12192                     i, inf, rowSum[i], rowLower[i], rowActivity[i], rowUpper[i]);
     12193            inf = rowActivity[i] - rowUpper[i];
     12194            if (inf > primalTolerance)
     12195              printf("Row %d inf %g sum %g %g <= %g <= %g\n",
     12196                     i, inf, rowSum[i], rowLower[i], rowActivity[i], rowUpper[i]);
     12197#endif
     12198            double infeasibility = CoinMax(rowActivity[i]-rowUpper[i],
     12199                                           rowLower[i]-rowActivity[i]);
     12200            // but allow for errors
     12201            double factor = CoinMax(1.0,rowSum[i]*1.0e-3);
     12202            if (infeasibility>largestInfeasibility*factor) {
     12203              largestInfeasibility = infeasibility/factor;
     12204              printf("Ainf of %g on row %d sum %g scaled %g\n",
     12205                     infeasibility,i,rowSum[i],largestInfeasibility);
     12206              if (infeasibility>1.0e10) {
     12207                for (CoinBigIndex j=rowStart[i];
     12208                     j<rowStart[i]+rowLength[i];j++) {
     12209                  printf("col %d element %g marked %d\n",
     12210                         column[j],elementByRow[j],marked[column[j]]);
     12211                }
     12212              }
     12213            }
     12214          }
     12215          delete [] rowActivity ;
     12216          delete [] rowSum;
     12217          delete [] marked;
     12218          if (largestInfeasibility > 10.0*primalTolerance)
     12219            printf("Alargest infeasibility is %g - obj %g\n", largestInfeasibility,objValue);
     12220          else
     12221            printf("Afeasible (%g) - obj %g\n", largestInfeasibility,objValue);
     12222        }
     12223#endif
    1150312224        // point to useful information
    1150412225        OsiBranchingInformation usefulInfo = usefulInformation();
     
    1151312234        for (i = 0; i < numberObjects_; i++)
    1151412235            object_[i]->feasibleRegion(solver_, &usefulInfo);
     12236#if CBC_USEFUL_PRINTING>14
     12237        {
     12238          int nBad=checkAssociated(solver_,solver_->getColSolution(),1);
     12239          if (nBad)
     12240            checkAssociated(solver_,solver_->getColSolution(),3);
     12241          double largestInfeasibility = 0.0;
     12242          double primalTolerance ;
     12243          double offset;
     12244          solver_->getDblParam(OsiObjOffset, offset);
     12245          solver_->getDblParam(OsiPrimalTolerance, primalTolerance) ;
     12246          const double *objective = getObjCoefficients() ;
     12247          const double * rowLower = solver_->getRowLower() ;
     12248          const double * rowUpper = solver_->getRowUpper() ;
     12249          const double * columnLower = solver_->getColLower() ;
     12250          const double * columnUpper = solver_->getColUpper() ;
     12251          int numberRows = solver_->getNumRows() ;
     12252          double *rowActivity = new double[numberRows] ;
     12253          memset(rowActivity, 0, numberRows*sizeof(double)) ;
     12254          double *rowSum = new double[numberRows] ;
     12255          memset(rowSum, 0, numberRows*sizeof(double)) ;
     12256          int * marked = new int [numberColumns];
     12257          for (int i=0;i<numberColumns;i++)
     12258            marked[i]=-1;
     12259          for (int i=0;i<numberIntegers_;i++)
     12260            marked[integerVariable_[i]]=-2;
     12261          if ((moreSpecialOptions2_&4)!=0) {
     12262            for (int i=0;i<numberObjects_;i++) {
     12263              CbcSwitchingBinary * object = dynamic_cast<CbcSwitchingBinary *> (object_[i]);
     12264              if (object) {
     12265                int iColumn = object->columnNumber();
     12266                const int * other = object->otherVariable();
     12267                marked[iColumn]=-3-other[0];
     12268                int n=object->numberOther();
     12269                for (int k=0;k<n;k++)
     12270                  marked[other[k]]=iColumn;
     12271              }
     12272            }
     12273          }
     12274          const double * element = solver_->getMatrixByCol()->getElements();
     12275          const int * row = solver_->getMatrixByCol()->getIndices();
     12276          const CoinBigIndex * columnStart = solver_->getMatrixByCol()->getVectorStarts();
     12277          const int * columnLength = solver_->getMatrixByCol()->getVectorLengths();
     12278          const CoinPackedMatrix * rowCopy = solver_->getMatrixByRow();
     12279          const int * column = rowCopy->getIndices();
     12280          const int * rowLength = rowCopy->getVectorLengths();
     12281          const CoinBigIndex * rowStart = rowCopy->getVectorStarts();
     12282          const double * elementByRow = rowCopy->getElements();
     12283          double objValue=-offset;
     12284          for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
     12285            double value = solution[iColumn];
     12286            objValue += value*objective[iColumn];
     12287            if (value>columnUpper[iColumn]) {
     12288              if (value-columnUpper[iColumn]>1.0e-8)
     12289                printf("column %d has value %.12g above %.12g\n",iColumn,value,columnUpper[iColumn]);
     12290              value=columnUpper[iColumn];
     12291            } else if (value<columnLower[iColumn]) {
     12292              if (value-columnLower[iColumn]<-1.0e-8)
     12293                printf("column %d has value %.12g below %.12g\n",iColumn,value,columnLower[iColumn]);
     12294              value=columnLower[iColumn];
     12295            }
     12296            if (value) {
     12297              CoinBigIndex start = columnStart[iColumn];
     12298              CoinBigIndex end = start + columnLength[iColumn];
     12299              for (CoinBigIndex j = start; j < end; j++) {
     12300                int iRow = row[j];
     12301                rowActivity[iRow] += value * element[j];
     12302                rowSum[iRow] += fabs(value * element[j]);
     12303              }
     12304            }
     12305          }
     12306          for (int i = 0 ; i < numberRows ; i++) {
     12307#if 0 //def CLP_INVESTIGATE
     12308            double inf;
     12309            inf = rowLower[i] - rowActivity[i];
     12310            if (inf > primalTolerance)
     12311              printf("Row %d inf %g sum %g %g <= %g <= %g\n",
     12312                     i, inf, rowSum[i], rowLower[i], rowActivity[i], rowUpper[i]);
     12313            inf = rowActivity[i] - rowUpper[i];
     12314            if (inf > primalTolerance)
     12315              printf("Row %d inf %g sum %g %g <= %g <= %g\n",
     12316                     i, inf, rowSum[i], rowLower[i], rowActivity[i], rowUpper[i]);
     12317#endif
     12318            double infeasibility = CoinMax(rowActivity[i]-rowUpper[i],
     12319                                           rowLower[i]-rowActivity[i]);
     12320            // but allow for errors
     12321            double factor = CoinMax(1.0,rowSum[i]*1.0e-3);
     12322            if (infeasibility>largestInfeasibility*factor) {
     12323              largestInfeasibility = infeasibility/factor;
     12324              printf("inf of %g on row %d sum %g scaled %g\n",
     12325                     infeasibility,i,rowSum[i],largestInfeasibility);
     12326              if (infeasibility>1.0e10) {
     12327                for (CoinBigIndex j=rowStart[i];
     12328                     j<rowStart[i]+rowLength[i];j++) {
     12329                  printf("col %d element %g marked %d\n",
     12330                         column[j],elementByRow[j],marked[column[j]]);
     12331                }
     12332              }
     12333            }
     12334          }
     12335          delete [] rowActivity ;
     12336          delete [] rowSum;
     12337          delete [] marked;
     12338          if (largestInfeasibility > 10.0*primalTolerance)
     12339            printf("Largest infeasibility is %g - obj %g\n", largestInfeasibility,objValue);
     12340          else
     12341            printf("Feasible (%g) - obj %g\n", largestInfeasibility,objValue);
     12342        }
     12343#endif
    1151512344        // If relaxed then leave bounds on basic variables
    1151612345        if (fixVariables == -1 && (specialOptions_&16) == 0) {
     
    1153312362        }
    1153412363        // We can switch off check
    11535         if ((specialOptions_&4) == 0) {
     12364        if ((specialOptions_&4) == 0 && (moreSpecialOptions2_&10) != 8) {
    1153612365            if ((specialOptions_&2) == 0 && solverCharacteristics_->warmStart()) {
    1153712366                /*
     
    1155912388            solver_->setHintParam(OsiDoDualInInitial, true, OsiHintTry);
    1156012389            solver_->initialSolve();
     12390#ifdef SWITCH_VARIABLES
     12391            if (solver_->isProvenOptimal()) {
     12392              int nBad=checkAssociated(solver_,solver_->getColSolution(),1);
     12393              if (nBad)
     12394                checkAssociated(solver_,solver_->getColSolution(),3);
     12395            }
     12396#endif
    1156112397#ifdef JJF_ZERO
    1156212398            if (solver_->isProvenOptimal()) {
    11563                 solver_->writeMps("feasible");
     12399              solver_->writeMpsNative("feasible.mps",NULL,NULL,2);
     12400#ifdef COIN_HAS_CLP
     12401              OsiClpSolverInterface * clpSolver
     12402                = dynamic_cast<OsiClpSolverInterface *> (solver_);
     12403              if (clpSolver ) {
     12404                clpSolver->getModelPtr()->writeBasis("feasible.bas",true);
     12405              }
     12406#endif
    1156412407                printf("XXXXXXXXXXXX - saving feasible\n");
    1156512408            }
    1156612409#endif
    1156712410            if (!solver_->isProvenOptimal()) {
    11568 #if COIN_DEVELOP>1
     12411#if CBC_FEASIBILITY_INVESTIGATE
    1156912412                printf("checkSolution infeas! Retrying with primal.\n");
    1157012413#endif
     
    1158812431                    solver_->setWarmStart(slack);
    1158912432                    delete slack ;
    11590 #if COIN_DEVELOP>1
     12433#if CBC_FEASIBILITY_INVESTIGATE
    1159112434                    printf("checkSolution infeas! Retrying wihout basis and with primal.\n");
    1159212435#endif
    1159312436                    solver_->initialSolve();
    11594 #if COIN_DEVELOP>1
     12437                    //solver_->writeMps("bad");
     12438#ifdef COIN_HAS_CLP
     12439                    if (!solver_->isProvenOptimal()&&modifiedTolerances) {
     12440                      // Restore
     12441                      ClpSimplex * clp = clpContinuousSolver->getModelPtr();
     12442#ifndef CBC_LEAVE_TOLERANCE_ON_CHECK_SOLUTION
     12443                      clp->setPrimalTolerance(savePrimalTolerance);
     12444#endif
     12445#ifndef CBC_LEAVE_PERTURBATION_ON_CHECK_SOLUTION
     12446                      clp->setPerturbation(savePerturbation);
     12447#endif
     12448#ifndef CBC_LEAVE_SCALING_ON_CHECK_SOLUTION
     12449                      clp->scaling(saveScaling);
     12450#endif
     12451                      solver_->resolve();
     12452                    }
     12453#endif
     12454#if CBC_FEASIBILITY_INVESTIGATE
    1159512455                    if (!solver_->isProvenOptimal()) {
    1159612456                        printf("checkSolution still infeas!\n");
     
    1162412484            double integerTolerance = getIntegerTolerance() ;
    1162512485#endif
    11626 #if COIN_DEVELOP>1
     12486#if CBC_FEASIBILITY_INVESTIGATE
    1162712487            const double * dj = solver_->getReducedCost();
    1162812488            const double * colLower = saveSolver->getColLower();
     
    1163812498            int nNotNeeded = 0;
    1163912499#endif
    11640             for (iColumn = 0 ; iColumn < numberColumns ; iColumn++) {
     12500            for (iColumn = 0 ; iColumn < numberContinuousColumns ; iColumn++) {
    1164112501                double value = solution[iColumn] ;
    1164212502                value = CoinMax(value, saveLower[iColumn]) ;
     
    1164412504                if (solver_->isInteger(iColumn)) {
    1164512505                    assert(fabs(value - solution[iColumn]) <= 100.0*integerTolerance) ;
    11646 #if COIN_DEVELOP>1
     12506#if CBC_FEASIBILITY_INVESTIGATE
    1164712507                    double value2 = floor(value + 0.5);
    1164812508                    if (dj[iColumn] < -1.0e-6) {
     
    1169512555                solution[iColumn] = value ;
    1169612556            }
    11697 #if COIN_DEVELOP>1
     12557#if CBC_FEASIBILITY_INVESTIGATE
    1169812558            printf("nAtLbNat %d,nAtUbNat %d,nAtLbNatZero %d,nAtUbNatZero %d,nAtLbFixed %d,nAtUbFixed %d,nAtOther %d,nAtOtherNat %d, useless %d\n",
    1169912559                   nAtLbNatural,
     
    1173412594                const CoinBigIndex * columnStart = solver_->getMatrixByCol()->getVectorStarts();
    1173512595                const int * columnLength = solver_->getMatrixByCol()->getVectorLengths();
    11736                 for (iColumn = 0; iColumn < numberColumns; iColumn++) {
    11737                     double value = solution[iColumn];
     12596                double offset;
     12597                solver_->getDblParam(OsiObjOffset, offset);
     12598                double objValue=-offset;
     12599                const double *objective = getObjCoefficients() ;
     12600                for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
     12601                  double value = solution[iColumn];
     12602                  objValue += value*objective[iColumn];
    1173812603                    if (value) {
    1173912604                        CoinBigIndex start = columnStart[iColumn];
     
    1174712612                }
    1174812613                for (i = 0 ; i < numberRows ; i++) {
    11749 #ifdef CLP_INVESTIGATE
     12614#if CBC_FEASIBILITY_INVESTIGATE>1
    1175012615                    double inf;
    1175112616                    inf = rowLower[i] - rowActivity[i];
     
    1176212627                    // but allow for errors
    1176312628                    double factor = CoinMax(1.0,rowSum[i]*1.0e-3);
    11764                     if (infeasibility>largestInfeasibility*factor)
     12629                    if (infeasibility>largestInfeasibility*factor) {
    1176512630                      largestInfeasibility = infeasibility/factor;
     12631                      //printf("inf of %g on row %d sum %g scaled %g\n",
     12632                      //     infeasibility,i,rowSum[i],largestInfeasibility);
     12633                    }
    1176612634                }
    1176712635                delete [] rowActivity ;
    1176812636                delete [] rowSum;
    11769 #ifdef CLP_INVESTIGATE
     12637#if CBC_FEASIBILITY_INVESTIGATE==0
     12638                if (handler_->logLevel()>2) {
     12639#endif
     12640                  if (largestInfeasibility > 10.0*primalTolerance)
     12641                    printf("BLargest infeasibility is %g - obj %g (%g)\n", largestInfeasibility,objValue,objectiveValue);
     12642                  else
     12643                    printf("BFeasible (%g) - obj %g %g\n", largestInfeasibility,objValue,objectiveValue);
     12644#if CBC_FEASIBILITY_INVESTIGATE==0
     12645                }
     12646#endif
     12647                //if (fabs(objValue-objectiveValue)>1.0e-7*fabs(objectiveValue)) {
     12648                //printf("Bad obj values\n");
     12649                objectiveValue = objValue;
     12650                //}
     12651#if CBC_FEASIBILITY_INVESTIGATE
    1177012652                if (largestInfeasibility > 10.0*primalTolerance)
    11771                     printf("largest infeasibility is %g\n", largestInfeasibility);
    11772 #endif
    11773                 if (largestInfeasibility > 1000.0*primalTolerance) {
     12653                    printf("XX largest infeasibility is %g\n", largestInfeasibility);
     12654#endif
     12655                if (largestInfeasibility > 200.0*primalTolerance) {
    1177412656                    handler_->message(CBC_NOTFEAS3, messages_)
    1177512657                    << largestInfeasibility << CoinMessageEol ;
     
    1180312685        solver_ = saveSolver;
    1180412686        testSolution_ = save;
     12687#ifdef COIN_HAS_CLP
     12688        if (modifiedTolerances) {
     12689          // Restore
     12690          ClpSimplex * clp = clpContinuousSolver->getModelPtr();
     12691#ifndef CBC_LEAVE_TOLERANCE_ON_CHECK_SOLUTION
     12692          clp->setPrimalTolerance(savePrimalTolerance);
     12693#endif
     12694#ifndef CBC_LEAVE_PERTURBATION_ON_CHECK_SOLUTION
     12695          clp->setPerturbation(savePerturbation);
     12696#endif
     12697#ifndef CBC_LEAVE_SCALING_ON_CHECK_SOLUTION
     12698          clp->scaling(saveScaling);
     12699#endif
     12700        }
     12701#endif
    1180512702        return objectiveValue;
    1180612703    } else {
     
    1194312840
    1194412841{
     12842 
    1194512843    double * solution = CoinCopyOfArray(solutionIn, solver_->getNumCols());
    1194612844#ifdef JJF_ZERO
     
    1198012878        assert(basis != NULL);
    1198112879        objectiveValue = checkSolution(cutoff, solution, fixVariables, objectiveValue);
    11982         if (saveObjectiveValue + 1.0e-3 < objectiveValue) {
    11983 #if COIN_DEVELOP>1
     12880        if (cutoff>1.0e40&&objectiveValue<1.0e10)
     12881          saveObjectiveValue = objectiveValue; // take anyway
     12882        if (saveObjectiveValue + 1.0e-3 +1.0e-7*fabs(saveObjectiveValue)
     12883            < objectiveValue) {
     12884#if CBC_FEASIBILITY_INVESTIGATE
    1198412885            printf("First try at solution had objective %.16g, rechecked as %.16g\n",
    1198512886                   saveObjectiveValue, objectiveValue);
     
    1199512896            double objectiveValue2 = saveObjectiveValue;
    1199612897            objectiveValue2 = checkSolution(cutoff, solution2, -1, objectiveValue2);
    11997 #if COIN_DEVELOP>1
     12898#if CBC_FEASIBILITY_INVESTIGATE
    1199812899            printf("Relaxed second try had objective of %.16g\n",
    1199912900                   objectiveValue2);
     
    1200712908                int iAway = -1;
    1200812909                double largestInfeasibility = tolerance;
    12009 #if COIN_DEVELOP>1
     12910#if CBC_FEASIBILITY_INVESTIGATE
    1201012911                int iInfeas = -1;
    1201112912#endif
     
    1201612917                    double value = solution2[i];
    1201712918                    if (value > columnUpper[i] + largestInfeasibility) {
    12018 #if COIN_DEVELOP>1
     12919#if CBC_FEASIBILITY_INVESTIGATE
    1201912920                        iInfeas = i;
    1202012921#endif
    1202112922                        largestInfeasibility = value - columnUpper[i];
    1202212923                    } else if (value < columnLower[i] - largestInfeasibility) {
    12023 #if COIN_DEVELOP>1
     12924#if CBC_FEASIBILITY_INVESTIGATE
    1202412925                        iInfeas = i;
    1202512926#endif
     
    1204012941                    }
    1204112942                }
    12042 #if COIN_DEVELOP>1
     12943#if CBC_FEASIBILITY_INVESTIGATE
    1204312944                if (iInfeas >= 0)
    1204412945                    printf("Largest infeasibility of %g on column %d - tolerance %g\n",
     
    1206112962                    objectiveValue = objectiveValue2;
    1206212963                }
    12063             }
     12964            } else if (!parentModel_) {
     12965              // not good
     12966              messageHandler()->message(CBC_FPUMP2, messages())
     12967                << "On closer inspection - solution discarded"
     12968                << CoinMessageEol ;
     12969           }
    1206412970            delete [] solution2;
    1206512971            solver_->setWarmStart(basis2);
     
    1209913005            // But allow for rounding errors
    1210013006            if (dblParam_[CbcCutoffIncrement] == 1e-5) {
    12101 #if COIN_DEVELOP>5
     13007#if CBC_FEASIBILITY_INVESTIGATE
    1210213008                if (saveObjectiveValue + 1.0e-7 < bestObjective_)
    1210313009                    printf("First try at solution had objective %.16g, rechecked as %.16g\n",
     
    1210913015                    cutoff -= 2.0e-5;
    1211013016            }
     13017            if (!parentModel_&&(moreSpecialOptions2_&2)!=0) {
     13018              // put back objective
     13019              solver_->setObjective(continuousSolver_->getObjCoefficients());
     13020              double offset;
     13021              continuousSolver_->getDblParam(OsiObjOffset,offset);
     13022              solver_->setDblParam(OsiObjOffset,offset);
     13023              moreSpecialOptions2_ &= ~2;
     13024            }
    1211113025            // This is not correct - that way cutoff can go up if maximization
    1211213026            //double direction = solver_->getObjSense();
     
    1265713571                    } else {
    1265813572                        // relax a bit
    12659                         value = CoinMin(saveUpper, value + 1.0e-5 * (fabs(saveUpper) + 1));
     13573                        value = CoinMin(saveUpper, value + 1.0e-8 * (fabs(saveUpper) + 1));
    1266013574                    }
    1266113575                    if (value - saveLower < 1.0e-7)
     
    1267113585                    } else {
    1267213586                        // relax a bit
    12673                         value = CoinMax(saveLower, value - 1.0e-5 * (fabs(saveLower) + 1));
     13587                        value = CoinMax(saveLower, value - 1.0e-8 * (fabs(saveLower) + 1));
    1267413588                    }
    1267513589                    if (saveUpper - value < 1.0e-7)
     
    1271913633                                    newLower = CoinMax(lower[jColumn],
    1272013634                                                       newLower
    12721                                                        - 1.0e-5 * (fabs(lower[jColumn]) + 1));
     13635                                                       - 1.0e-8 * (fabs(lower[jColumn]) + 1));
    1272213636                                    newUpper = CoinMin(upper[jColumn],
    1272313637                                                       newUpper
    12724                                                        + 1.0e-5 * (fabs(upper[jColumn]) + 1));
     13638                                                       + 1.0e-8 * (fabs(upper[jColumn]) + 1));
    1272513639                                }
    1272613640                                solver->setColLower(jColumn, newLower);
     
    1292713841}
    1292813842// Make given cut into a global cut
    12929 void
     13843int
    1293013844CbcModel::makeGlobalCut(const OsiRowCut * cut)
    1293113845{
     13846  if (cut->row().getNumElements()>1-1) {
    1293213847    OsiRowCut newCut(*cut);
    1293313848    newCut.setGloballyValidAsInteger(2);
    1293413849    newCut.mutableRow().setTestForDuplicateIndex(false);
    12935     globalCuts_.addCutIfNotDuplicate(newCut) ;
     13850    return globalCuts_.addCutIfNotDuplicate(newCut,1) ;
     13851  } else {
     13852    assert (cut->row().getNumElements()==1);
     13853    int iColumn = cut->row().getIndices()[0];
     13854    double value = cut->row().getElements()[0];
     13855    double lb = cut->lb();
     13856    double ub = cut->ub();
     13857    if (value>0) {
     13858      if (lb>-COIN_DBL_MAX)
     13859        lb /= value;
     13860      if (ub<COIN_DBL_MAX)
     13861        ub /= value;
     13862    } else {
     13863      double saveUb=ub;
     13864      if (lb>-COIN_DBL_MAX)
     13865        ub = lb/value;
     13866      else
     13867        ub = COIN_DBL_MAX;
     13868      if (saveUb<COIN_DBL_MAX)
     13869        lb = saveUb/value;
     13870      else
     13871        lb =- COIN_DBL_MAX;
     13872    }
     13873#if PRINT_CONFLICT==0
     13874    if (handler_->logLevel() > 1) {
     13875#endif
     13876      printf("Conflict cut at depth %d (%d elements)\n",
     13877             currentDepth_,cut->row().getNumElements());
     13878      cut->print();
     13879#if PRINT_CONFLICT==0
     13880    }
     13881#endif
     13882    const double * lower;
     13883    const double * upper;
     13884    if (topOfTree_) {
     13885      lower = topOfTree_->lower();
     13886      upper = topOfTree_->upper();
     13887      lb = CoinMax(lb,lower[iColumn]);
     13888      topOfTree_->setColLower(iColumn,lb);
     13889      ub = CoinMin(ub,upper[iColumn]);
     13890      topOfTree_->setColUpper(iColumn,ub);
     13891    } else {
     13892      lower = solver_->getColLower();
     13893      upper = solver_->getColUpper();
     13894      lb = CoinMax(lb,lower[iColumn]);
     13895      solver_->setColLower(iColumn,lb);
     13896      ub = CoinMin(ub,upper[iColumn]);
     13897      solver_->setColUpper(iColumn,ub);
     13898    }
     13899    return 1;
     13900  }
    1293613901}
    1293713902// Make given cut into a global cut
    12938 void
     13903int
    1293913904CbcModel::makeGlobalCut(const OsiRowCut & cut)
    1294013905{
     
    1294213907    newCut.setGloballyValid(true);
    1294313908    newCut.mutableRow().setTestForDuplicateIndex(false);
    12944     globalCuts_.addCutIfNotDuplicate(newCut) ;
     13909    return globalCuts_.addCutIfNotDuplicate(newCut) ;
    1294513910}
    1294613911// Make given column cut into a global cut
     
    1294813913CbcModel::makeGlobalCut(const OsiColCut * cut)
    1294913914{
     13915  abort(); // need to think about top of tree
    1295013916  const double * lower;
    1295113917  const double * upper;
     
    1306614032  newCut.setLb(lo);
    1306714033  newCut.setRow(nConflict,column,values);
    13068   printf("CUTa has %d (started at %d) - final bSum %g\n",nConflict,nC,bSum);
     14034  printf("CUTa has %d (started at %d) - final bSum %g - depth %d\n",nConflict,nC,bSum,currentDepth_);
    1306914035  if (nConflict>1) {
    1307014036    if ((specialOptions_&1) != 0) {
     
    1314614112CbcModel::incrementUsed(const double * solution)
    1314714113{
    13148     // might as well mark all including continuous
    13149     int numberColumns = solver_->getNumCols();
    13150     for (int i = 0; i < numberColumns; i++) {
     14114    if(usedInSolution_) {
     14115      // might as well mark all including continuous
     14116      int numberColumns = solver_->getNumCols();
     14117      for (int i = 0; i < numberColumns; i++) {
    1315114118        if (solution[i])
    13152             usedInSolution_[i]++;
     14119          usedInSolution_[i]++;
     14120      }
    1315314121    }
    1315414122}
     
    1325714225    if (probingInfo_ && currentDepth_ > 0) {
    1325814226        int nFix = probingInfo_->fixColumns(*solver);
     14227#ifdef SWITCH_VARIABLES
     14228        if (nFix>0)
     14229          fixAssociated(solver_,0);
     14230#endif
    1325914231        if (nFix < 0) {
    1326014232#ifdef COIN_HAS_CLP
     
    1330814280                                   clpSimplex->largestPrimalError());
    1330914281            if (error > 1.0e-2 || !clpSolver->isProvenOptimal()) {
    13310 #ifdef CLP_INVESTIGATE
     14282#if CBC_USEFUL_PRINTING>1
    1331114283                printf("Problem was %s largest dual error %g largest primal %g - safer cuts\n",
    1331214284                       clpSolver->isProvenOptimal() ? "optimal" : "!infeasible",
     
    1334214314        }
    1334314315        clpSolver->setSpecialOptions(save2);
    13344 #ifdef CLP_INVESTIGATE
     14316#if CBC_USEFUL_PRINTING>1
    1334514317        if (clpSimplex->numberIterations() > 1000)
    1334614318            printf("node %d took %d iterations\n", numberNodes_, clpSimplex->numberIterations());
     
    1335414326#else
    1335514327    solver->resolve();
     14328#endif
     14329#ifdef SWITCH_VARIABLES
     14330    if (solver_->isProvenOptimal()) {
     14331      int nBad=checkAssociated(solver_,solver_->getColSolution(),0);
     14332      if (nBad)
     14333        checkAssociated(solver_,solver_->getColSolution(),1);
     14334    }
    1335614335#endif
    1335714336    return solver->isProvenOptimal() ? 1 : 0;
     
    1337214351                             clpSimplex->largestPrimalError());
    1337314352      if (error > 1.0e-2 || !clpSolver->isProvenOptimal()) {
    13374 #ifdef CLP_INVESTIGATE
     14353#if CBC_USEFUL_PRINTING>1
    1337514354        printf("Problem was %s largest dual error %g largest primal %g - safer cuts\n",
    1337614355               clpSolver->isProvenOptimal() ? "optimal" : "!infeasible",
     
    1340614385    }
    1340714386    clpSolver->setSpecialOptions(save2);
    13408 #ifdef CLP_INVESTIGATE
     14387#if CBC_USEFUL_PRINTING>1
    1340914388    if (clpSimplex->numberIterations() > 1000)
    1341014389      printf("node %d took %d iterations\n", numberNodes_, clpSimplex->numberIterations());
     
    1385514834            }
    1385614835#endif
     14836#ifdef COIN_HAS_NTY
     14837            if (symmetryInfo_) {
     14838              CbcNodeInfo * infoX = oldNode ? oldNode->nodeInfo() : NULL;
     14839              bool worthTrying = false;
     14840              if (infoX) {
     14841                CbcNodeInfo * info = infoX;
     14842                for (int i=0;i<NTY_BAD_DEPTH;i++) {
     14843                  if (!info->parent()) {
     14844                    worthTrying = true;
     14845                    break;
     14846                  }
     14847                  info = info->parent();
     14848                  if (info->symmetryWorked()) {
     14849                    worthTrying = true;
     14850                    break;
     14851                  }
     14852                }
     14853              } else {
     14854                worthTrying=true;
     14855              }
     14856              if ((moreSpecialOptions2_&(128|256))==(128|256)&&currentDepth_>5)
     14857                worthTrying=false;
     14858              if (worthTrying) {
     14859                int n=symmetryInfo_->orbitalFixing(solver_);
     14860                if (n) {
     14861#if PRINT_MORE==0
     14862                  if (logLevel()>1)
     14863                    printf("%d orbital fixes\n",n);
     14864#endif
     14865                  solver_->resolve();
     14866                  if(!isProvenOptimal()) {
     14867                    if (logLevel()>1)
     14868                      printf("infeasible after orbital fixing\n");
     14869                  }
     14870                }
     14871              }
     14872            }
     14873#endif
    1385714874            if (numberBeforeTrust_ == 0 ) {
    1385814875                anyAction = newNode->chooseBranch(this, oldNode, numberPassesLeft) ;
     
    1412315140            // zap parent nodeInfo
    1412415141#ifdef COIN_DEVELOP
    14125             printf("zapping3 CbcNodeInfo %x\n", reinterpret_cast<int>(newNode->nodeInfo()->parent()));
     15142            printf("zapping3 CbcNodeInfo %x\n", newNode->nodeInfo()->parent());
    1412615143#endif
    1412715144            if (newNode->nodeInfo())
     
    1426515282            solver_->getDblParam(OsiObjOffset, offset);
    1426615283            solver_->setRowUpper(cutoffRowNumber_,cutoff+offset);
     15284            if (continuousSolver_&&solver_->getNumCols()>continuousSolver_->getNumCols()) {
     15285              solver_->setRowUpper(cutoffRowNumber_,floor(cutoff)+offset);
     15286              solver_->setRowLower(cutoffRowNumber_,floor(cutoff)+offset);
     15287            }
    1426715288          }
    1426815289        }
     
    1433115352        bool exitNow = false;
    1433215353        for (i = 0; i < numberHeuristics_; i++) {
    14333             heuristic_[i]->setModelOnly(this);
    1433415354            if (heuristic_[i]->exitNow(bestObjective_))
    1433515355                exitNow = true;
     
    1445715477                        line << CoinMessageEol ;
    1445815478                    }
     15479                    //#define DEBUG_BEST
     15480#ifdef DEBUG_BEST
     15481  FILE * fp = fopen("solution.data","rb");
     15482  if (!fp&&ifSol>0) {
     15483    int numberColumns=getNumCols();
     15484    fp = fopen("solution.data","wb");
     15485    printf("Solution data on file solution.data\n");
     15486    size_t numberWritten;
     15487    numberWritten=fwrite(&numberColumns,sizeof(int),1,fp);
     15488    assert (numberWritten==1);
     15489    numberWritten=fwrite(&heuristicValue,sizeof(double),1,fp);
     15490    assert (numberWritten==1);
     15491    numberWritten=fwrite(newSolution,sizeof(double),numberColumns,fp);
     15492    assert (numberWritten==numberColumns);
     15493    fclose(fp);
     15494  } else if (fp) {
     15495    int numberColumns=getNumCols();
     15496    int numberColumnsX;
     15497    size_t numberRead;
     15498    numberRead=fread(&numberColumnsX,sizeof(int),1,fp);
     15499    assert (numberRead==1);
     15500    if (numberColumns==numberColumnsX) {
     15501      numberRead=fread(&heuristicValue,sizeof(double),1,fp);
     15502      assert (numberRead==1);
     15503      numberRead=fread(newSolution,sizeof(double),numberColumns,fp);
     15504      assert (numberRead==numberColumns);
     15505      ifSol=1;
     15506    }
     15507    fclose(fp);
     15508  }
     15509#endif
    1445915510                    if (ifSol > 0) {
    1446015511                        // better solution found
     
    1447115522                            //                            numberSolutions_++;
    1447215523                            numberHeuristicSolutions_++;
    14473 #ifdef CLP_INVESTIGATE
     15524#ifdef HEURISTIC_INFORM
    1447415525                            printf("HEUR %s where %d C\n",
    1447515526                                   lastHeuristic_->heuristicName(), whereFrom);
     
    1450115552                        } else {
    1450215553                            // NOT better solution
    14503 #ifdef CLP_INVESTIGATE
     15554#if CBC_USEFUL_PRINTING>1
    1450415555                            printf("HEUR %s where %d REJECTED i==%d\n",
    1450515556                                   heuristic_[i]->heuristicName(), whereFrom, i);
     
    1485415905    }
    1485515906    int save2 = maximumDepth_;
    14856     int retCode = addCuts(node, lastws, numberFixedNow_ > numberFixedAtRoot_);
     15907    int retCode = addCuts(node, lastws);
     15908#ifdef SWITCH_VARIABLES
     15909    fixAssociated(solver_,0);
     15910#endif
    1485715911    //if (save1<maximumNumberCuts_) {
    1485815912    // increased
     
    1497916033            }
    1498016034#ifdef COIN_HAS_CLP
    14981             bool fathomDone = false;
    1498216035            OsiClpSolverInterface * clpSolver
    1498316036            = dynamic_cast<OsiClpSolverInterface *> (solver_);
     
    1510816161                        simplex->setMoreSpecialOptions(saveMoreOptions);
    1510916162                        simplex->setPerturbation(perturbation);
    15110                         numberExtraNodes_ += info->numberNodesExplored_;
    15111                         numberExtraIterations_ += info->numberIterations_;
     16163                        incrementExtra(info->numberNodesExplored_,
     16164                                       info->numberIterations_);
    1511216165                        char general[200];
    1511316166                        int fathomStatus=info->nNodes_;
     
    1512816181                                FATHOM_BIAS - fastNodeDepth_ << CoinMessageEol ;
    1512916182#endif
    15130 #ifdef CLP_INVESTIGATE
     16183#if CBC_USEFUL_PRINTING>0
    1513116184                            printf(">10000 - depth now %d so at depth >= %d\n",
    1513216185                                   fastNodeDepth_, FATHOM_BIAS - fastNodeDepth_);
     
    1513616189                            // we gave up
    1513716190                            //abort();
    15138                             fastNodeDepth_ -= 3;
     16191                          fastNodeDepth_ -= (info->nNodes_==-10) ? 5 : 2;
    1513916192#ifndef NO_FATHOM_PRINT
    1514016193                          if ((moreSpecialOptions_&262144) != 0)
     
    1514216195                              FATHOM_BIAS - fastNodeDepth_ << CoinMessageEol ;
    1514316196#endif
    15144 #ifdef CLP_INVESTIGATE
    15145                             printf("fastNodeDepth now %d - so at depth >= %d\n",
     16197#if CBC_USEFUL_PRINTING>0
     16198                            printf("gave up fastNodeDepth now %d - so at depth >= %d\n",
    1514616199                                   fastNodeDepth_, FATHOM_BIAS - fastNodeDepth_);
    1514716200#endif
     
    1515416207                                clpSolver->setWarmStart(NULL);
    1515516208                                // try and do solution
    15156                                 double value = simplex->objectiveValue() *
    15157                                                simplex->optimizationDirection();
     16209                                double value = simplex->objectiveValue();
    1515816210                                double * newSolution =
    1515916211                                    CoinCopyOfArray(simplex->primalColumnSolution(),
     
    1517216224                                clpSolver->setWarmStart(NULL);
    1517316225                                // try and do solution
    15174                                 double value = simplex->objectiveValue() *
    15175                                                simplex->optimizationDirection();
     16226                                double value = simplex->objectiveValue();
    1517616227                                double * newSolution =
    1517716228                                    CoinCopyOfArray(simplex->primalColumnSolution(),
    1517816229                                                    numberColumns);
    1517916230                                setBestSolution(CBC_STRONGSOL, value, newSolution) ;
     16231                                // in case of inaccuracy
     16232                                simplex->setObjectiveValue(CoinMax(bestObjective_,
     16233                                                                   simplex->objectiveValue()));
    1518016234                                delete [] newSolution;
    1518116235                            }
     
    1520716261                            }
    1520816262                            //printf("range of costs %g to %g\n",smallest,largest);
    15209                             // If value of objective borderline then may not be feasible
    15210                             double value = simplex->objectiveValue() * simplex->optimizationDirection();
    15211                             if (value - getCutoff() < -1.0e-1)
    15212                                 fathomDone = true;
    1521316263                        }
    1521416264                        simplex->setLogLevel(saveLevel);
     
    1528116331                            setBestSolution(CBC_STRONGSOL, value, newSolution) ;
    1528216332                            delete [] newSolution;
    15283                             fathomDone = true;
    15284                         } else {
    15285                             feasible = false;
    1528616333                        }
    1528716334#endif
     
    1529316340                int numberPasses = /*doCutsNow(1) ?*/ maximumCutPasses_ /*: 0*/;
    1529416341                feasible = solveWithCuts(cuts, numberPasses, node);
    15295                 if (fathomDone)
    15296                     assert (feasible);
    1529716342            }
    1529816343#else
     
    1581116856                    int iHeur ;
    1581216857                    int whereFrom = 3;
     16858                    // allow more heuristics
     16859                    currentPassNumber_=0;
    1581316860                    for (iHeur = 0 ; iHeur < numberHeuristics_ ; iHeur++) {
    1581416861                        // skip if can't run here
     
    1582716874                            } else {
    1582816875                                lastHeuristic_ = heuristic_[found];
    15829 #ifdef CLP_INVESTIGATE
     16876#ifdef HEURISTIC_INFORM
    1583016877                                printf("HEUR %s where %d D\n",
    1583116878                                       lastHeuristic_->heuristicName(), whereFrom);
     
    1583616883                            }
    1583716884                        } else if (ifSol < 0)   { // just returning an estimate
    15838                             estValue = CoinMin(heurValue, estValue) ;
     16885                            estValue = heurValue; //CoinMin(heurValue, estValue) ;
    1583916886                            heurValue = saveValue ;
    1584016887                        }
     
    1584216889                    if (found >= 0 && parallelMode() > 0) {
    1584316890                        lastHeuristic_ = heuristic_[found];
    15844 #ifdef CLP_INVESTIGATE
     16891#if CBC_USEFUL_PRINTING>1
    1584516892                        printf("HEUR %s where %d D\n",
    1584616893                               lastHeuristic_->heuristicName(), whereFrom);
     
    1600117048            delete [] delRows ;
    1600217049        }
     17050        numberNewCuts_=0;
    1600317051    }
    1600417052#endif
     
    1601617064            usedInSolution_[i] = 0;
    1601717065        }
    16018         baseModel->numberSolutions_++;
    1601917066        if (bestObjective_ < baseModel->bestObjective_ && bestObjective_ < baseModel->getCutoff()) {
    1602017067            baseModel->bestObjective_ = bestObjective_ ;
     
    1602417071            CoinCopyN(bestSolution_, numberColumns, baseModel->bestSolution_);
    1602517072            baseModel->setCutoff(getCutoff());
    16026         }
     17073            baseModel->handler_->message(CBC_ROUNDING, messages_)
     17074              << bestObjective_
     17075              << "heuristic"
     17076              << baseModel->numberIterations_
     17077              << baseModel->numberNodes_ << getCurrentSeconds()
     17078              << CoinMessageEol;
     17079        }
     17080        baseModel->numberSolutions_++;
    1602717081        unlockThread();
    1602817082    }
     
    1614017194    for (i = 0; i < numberIntegers_; i++)
    1614117195        back[integerVariable_[i]] = i;
    16142 #ifdef CLP_INVESTIGATE
     17196#if CBC_USEFUL_PRINTING>1
    1614317197    int numberNot = 0;
    1614417198#endif
     
    1614817202        if (!obj)
    1614917203            continue;
    16150 #ifdef CLP_INVESTIGATE
     17204#if CBC_USEFUL_PRINTING>1
    1615117205        if (obj->numberTimesDown() < numberBeforeTrust_ ||
    1615217206                obj->numberTimesUp() < numberBeforeTrust_)
     
    1616917223        }
    1617017224    }
    16171 #ifdef CLP_INVESTIGATE4
     17225#if CBC_USEFUL_PRINTING>5
    1617217226    if (priority)
    1617317227        printf("Before fathom %d not trusted out of %d\n",
     
    1627217326                             * dblParam_[CbcAllowableFractionGap]);
    1627317327    returnCode = (bestObjective_ - bestPossibleObjective_ < testGap && getCutoffIncrement() >= 0.0);
    16274   }
     17328  }
     17329#if 0
     17330  if (returnCode) {
     17331    if (fabs(bestObjective_+1469650.0)<1.0) {
     17332      fprintf(stderr,"BAD - cr to continue\n");
     17333      fflush(stdout);
     17334      char xx;
     17335      xx=getc(stdin);
     17336    }
     17337  }
     17338#endif
    1627517339  return returnCode;
    1627617340}
     
    1643517499        OsiClpSolverInterface * clpSolver
    1643617500        = dynamic_cast<OsiClpSolverInterface *> (solver_);
    16437         if (clpSolver && numberNodes_ >= numberNodes && numberNodes_ < 2*numberNodes) {
     17501        if (clpSolver && numberNodes_ >= numberNodes && numberNodes_ < 2*numberNodes  && clpSolver->getNumRows() < 10000) {
    1643817502            if (numberIterations_ < (numberSolves_ + numberNodes_)*10) {
    1643917503                //if (numberIterations_<numberNodes_*20) {
     
    1673917803                    // better solution save
    1674017804                    lastHeuristic_ = heuristic_[found];
    16741 #ifdef CLP_INVESTIGATE
     17805#ifdef HEURISTIC_INFORM
    1674217806                    printf("HEUR %s where %d oddE\n",
    1674317807                           lastHeuristic_->heuristicName(), whereFrom);
     
    1693818002    bool hitMaxTime = (totalTime >= maxSeconds);
    1693918003    if (parentModel_ && !hitMaxTime) {
    16940         // In a sub tree 
     18004        // In a sub tree
    1694118005        assert (parentModel_);
    1694218006        maxSeconds = parentModel_->getMaximumSeconds();
     
    1765818722    char general[200];
    1765918723    if (clpSolver) {
    17660       clpSolver->getModelPtr()->dual(); // probably not needed
     18724      sprintf(general,"Starting multiple root solver");
     18725      model->messageHandler()->message(CBC_GENERAL,
     18726                                       model->messages())
     18727        << general << CoinMessageEol ;
     18728      clpSolver->setHintParam(OsiDoReducePrint, true, OsiHintTry);
     18729      ClpSimplex * simplex = clpSolver->getModelPtr();
     18730      int logLevel=simplex->logLevel();
     18731      if (logLevel<=1)
     18732        simplex->setLogLevel(0);
     18733      simplex->dual();
     18734      simplex->setLogLevel(logLevel);
    1766118735      clpSolver->setWarmStart(NULL);
    17662       sprintf(general,"Starting multiple root solver");
    1766318736    } else {
    17664 #endif
    17665 #ifdef COIN_HAS_CLP
    1766618737      model->initialSolve();
    1766718738      sprintf(general,"Solver did %d iterations in initialSolve\n",
    1766818739             model->solver()->getIterationCount());
    17669     }
    17670 #endif
    17671     model->messageHandler()->message(CBC_GENERAL,
    17672                               model->messages())
    17673       << general << CoinMessageEol ;
     18740      model->messageHandler()->message(CBC_GENERAL,
     18741                                       model->messages())
     18742        << general << CoinMessageEol ;
     18743    }
     18744#endif
    1767418745    model->branchAndBound();
    1767518746    sprintf(general,"Ending multiple root solver");
     
    1774318814        for (int iRow=numberRowsAtContinuous_;iRow<numberRows;iRow++) {
    1774418815          int iType=whichGenerator[iRow];
    17745           if ((iType>=0&&iType<10000)||iType<-1) {
     18816          if ((iType>=0&&iType<20000)) {
    1774618817            if (fabs(ray[iRow])>1.0e-10) {
    1774718818              badRows++;
     
    1805219123  return cut;
    1805319124}
    18054 
Note: See TracChangeset for help on using the changeset viewer.