Changeset 259 for trunk/CbcNode.cpp


Ignore:
Timestamp:
Feb 18, 2006 3:46:11 PM (14 years ago)
Author:
forrest
Message:

changes to annoy people

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/CbcNode.cpp

    r231 r259  
    1818#include "CbcModel.hpp"
    1919#include "CbcNode.hpp"
     20#include "CbcStatistics.hpp"
    2021#include "CbcBranchActual.hpp"
    2122#include "CbcBranchDynamic.hpp"
     
    883884  if (model->hotstartSolution())
    884885    numberStrong=0;
     886  int numberStrongDone=0;
     887  int numberUnfinished=0;
     888  int numberStrongInfeasible=0;
     889  int numberStrongIterations=0;
    885890  int saveNumberStrong=numberStrong;
    886891  int numberObjects = model->numberObjects();
     
    917922    estimatedDegradation=0.0;
    918923    //int numberIntegerInfeasibilities=0; // without odd ones
     924    numberStrongDone=0;
     925    numberUnfinished=0;
     926    numberStrongInfeasible=0;
     927    numberStrongIterations=0;
    919928   
    920929    // We may go round this loop twice (only if we think we have solution)
     
    926935      //                      numberIntegerInfeasibilities,
    927936      //                      numberObjectInfeasibilities);
    928       // If forcePriority > 0 then we want best solution
    929937      const double * hotstartSolution = model->hotstartSolution();
    930938      const int * hotstartPriorities = model->hotstartPriorities();
     
    10791087          }
    10801088        }
    1081         if (roundAgain) {
     1089        if (roundAgain&&saveNumberStrong) {
    10821090          // restore basis
    10831091          solver->setWarmStart(ws);
     
    13481356          if (feasible) {
    13491357            solver->solveFromHotStart() ;
     1358            numberStrongDone++;
     1359            numberStrongIterations += solver->getIterationCount();
    13501360            /*
    13511361              We now have an estimate of objective degradation that we can use for strong
     
    13731383          iStatus = outputStuff[2*i];
    13741384          choice[i].numItersDown = outputStuff[2*numberStrong+2*i];
     1385          numberStrongDone++;
     1386          numberStrongIterations += choice[i].numItersDown;
    13751387          newObjectiveValue = objectiveValue+newUpper[i];
    13761388          solver->setColSolution(outputSolution[2*i]);
     
    13811393          if (newObjectiveValue>=model->getCutoff()) {
    13821394            objectiveChange = 1.0e100; // say infeasible
     1395            numberStrongInfeasible++;
    13831396          } else {
    13841397            // See if integer solution
     
    13911404              model->setLastHeuristic(NULL);
    13921405              model->incrementUsed(solver->getColSolution());
    1393               if (newObjectiveValue >= model->getCutoff())      //  *new* cutoff
     1406              if (newObjectiveValue >= model->getCutoff()) {    //  *new* cutoff
    13941407                objectiveChange = 1.0e100 ;
     1408                numberStrongInfeasible++;
     1409              }
    13951410            }
    13961411          }
    13971412        } else if (iStatus==1) {
    13981413          objectiveChange = 1.0e100 ;
     1414          numberStrongInfeasible++;
    13991415        } else {
    14001416          // Can't say much as we did not finish
    14011417          choice[i].finishedDown = false ;
     1418          numberUnfinished++;
    14021419        }
    14031420        choice[i].downMovement = objectiveChange ;
     
    14401457          if (feasible) {
    14411458            solver->solveFromHotStart() ;
     1459            numberStrongDone++;
     1460            numberStrongIterations += solver->getIterationCount();
    14421461            /*
    14431462              We now have an estimate of objective degradation that we can use for strong
     
    14651484          iStatus = outputStuff[2*i+1];
    14661485          choice[i].numItersUp = outputStuff[2*numberStrong+2*i+1];
     1486          numberStrongDone++;
     1487          numberStrongIterations += choice[i].numItersUp;
    14671488          newObjectiveValue = objectiveValue+newLower[i];
    14681489          solver->setColSolution(outputSolution[2*i+1]);
     
    14731494          if (newObjectiveValue>=model->getCutoff()) {
    14741495            objectiveChange = 1.0e100; // say infeasible
     1496            numberStrongInfeasible++;
    14751497          } else {
    14761498            // See if integer solution
     
    14831505              model->setLastHeuristic(NULL);
    14841506              model->incrementUsed(solver->getColSolution());
    1485               if (newObjectiveValue >= model->getCutoff())      //  *new* cutoff
     1507              if (newObjectiveValue >= model->getCutoff()) {    //  *new* cutoff
    14861508                objectiveChange = 1.0e100 ;
     1509                numberStrongInfeasible++;
     1510              }
    14871511            }
    14881512          }
    14891513        } else if (iStatus==1) {
    14901514          objectiveChange = 1.0e100 ;
     1515          numberStrongInfeasible++;
    14911516        } else {
    14921517          // Can't say much as we did not finish
    14931518          choice[i].finishedUp = false ;
     1519          numberUnfinished++;
    14941520        }
    14951521        choice[i].upMovement = objectiveChange ;
     
    16541680      }
    16551681      delete ws;
     1682      int numberNodes = model->getNodeCount();
     1683      // update number of strong iterations
     1684      model->setNumberStrongIterations(model->numberStrongIterations()+numberStrongIterations);
    16561685     
    16571686      /*
     
    16651694      if (anyAction>=0) {
    16661695       
    1667         int numberNodes = model->getNodeCount();
    16681696        // get average cost per iteration and assume stopped ones
    16691697        // would stop after 50% more iterations at average cost??? !!! ???
     
    18071835  //assert(objectiveValue_ == solver->getObjSense()*solver->getObjValue());
    18081836  double cutoff =model->getCutoff();
     1837  double distanceToCutoff=cutoff-objectiveValue_;
    18091838  const double * lower = solver->getColLower();
    18101839  const double * upper = solver->getColUpper();
     
    18311860  if (model->hotstartSolution())
    18321861    return -3;
     1862#define RANGING
     1863#ifdef RANGING
    18331864  // Pass number
    18341865  int kPass=0;
     1866  int numberRows = solver->getNumRows();
     1867#endif
    18351868  int numberColumns = model->getNumCols();
    1836   int numberRows = solver->getNumRows();
    18371869  double * saveUpper = new double[numberColumns];
    18381870  double * saveLower = new double[numberColumns];
     
    18511883    decision = new CbcBranchDynamicDecision();
    18521884  int numberMini=0;
    1853   int xStrong=0;
    1854   int xIters=0;
    18551885  int xPen=0;
    18561886  int xMark=0;
     
    18881918    osiclp->setSpecialOptions(saveClpOptions|1024);
    18891919  }
     1920  int saveSearchStrategy2 = model->searchStrategy();
     1921  if (saveSearchStrategy2<999) {
     1922    // Get average up and down costs
     1923    double averageUp=0.0;
     1924    double averageDown=0.0;
     1925    {
     1926      int numberUp=0;
     1927      int numberDown=0;
     1928      int i;
     1929      for ( i=0;i<numberObjects;i++) {
     1930        CbcObject * object = model->modifiableObject(i);
     1931        CbcSimpleIntegerDynamicPseudoCost * dynamicObject =
     1932          dynamic_cast <CbcSimpleIntegerDynamicPseudoCost *>(object) ;
     1933        assert(dynamicObject);
     1934        if (dynamicObject->numberTimesUp()) {
     1935          numberUp++;
     1936          averageUp += dynamicObject->upDynamicPseudoCost();
     1937        }
     1938        if (dynamicObject->numberTimesDown()) {
     1939          numberDown++;
     1940          averageDown += dynamicObject->downDynamicPseudoCost();
     1941        }
     1942      }
     1943      if (numberUp)
     1944        averageUp /= (double) numberUp;
     1945      else
     1946        averageUp=1.0;
     1947      if (numberDown)
     1948        averageDown /= (double) numberDown;
     1949      else
     1950        averageDown=1.0;
     1951      for ( i=0;i<numberObjects;i++) {
     1952        CbcObject * object = model->modifiableObject(i);
     1953        CbcSimpleIntegerDynamicPseudoCost * dynamicObject =
     1954          dynamic_cast <CbcSimpleIntegerDynamicPseudoCost *>(object) ;
     1955        assert(dynamicObject);
     1956        if (!dynamicObject->numberTimesUp())
     1957          dynamicObject->setUpDynamicPseudoCost(averageUp);
     1958      if (!dynamicObject->numberTimesDown())
     1959        dynamicObject->setDownDynamicPseudoCost(averageDown);
     1960      }
     1961    }
     1962  } else if (saveSearchStrategy2<1999) {
     1963    // pseudo shadow prices
     1964    model->pseudoShadow(NULL,NULL);
     1965  } else if (saveSearchStrategy2<2999) {
     1966    // leave old ones
     1967  } else if (saveSearchStrategy2<3999) {
     1968    // pseudo shadow prices at root
     1969    if (!numberNodes)
     1970      model->pseudoShadow(NULL,NULL);
     1971  } else {
     1972    abort();
     1973  }
     1974  if (saveSearchStrategy2>=0)
     1975    saveSearchStrategy2 = saveSearchStrategy2 % 1000;
     1976  if (saveSearchStrategy2==999)
     1977    saveSearchStrategy2=-1;
     1978  int px[4]={-1,-1,-1,-1};
     1979  int saveSearchStrategy = saveSearchStrategy2<99 ? saveSearchStrategy2 : saveSearchStrategy2-100;
     1980  bool newWay = saveSearchStrategy2>98;
     1981  int numberNotTrusted=0;
     1982  int numberStrongDone;
     1983  int numberUnfinished;
     1984  int numberStrongInfeasible;
     1985  int numberStrongIterations;
    18901986  while(!finished) {
    18911987    finished=true;
     
    18961992    int numberIntegerInfeasibilities=0; // without odd ones
    18971993    int numberToDo=0;
    1898     double averageDown=0.0;
    1899     int numberDown=0;
    1900     double averageUp=0.0;
    1901     int numberUp=0;
    19021994    int iBestNot=-1;
    19031995    int iBestGot=-1;
    19041996    double best=0.0;
    1905     int numberNotTrusted=0;
     1997    numberNotTrusted=0;
     1998    numberStrongDone=0;
     1999    numberUnfinished=0;
     2000    numberStrongInfeasible=0;
     2001    numberStrongIterations=0;
    19062002    int * which = objectMark+numberObjects+1;
    19072003    int neededPenalties;
     
    19312027      numberToDo=0;
    19322028      neededPenalties=0;
    1933       averageDown=0.0;
    1934       numberDown=0;
    1935       averageUp=0.0;
    1936       numberUp=0;
    19372029      iBestNot=-1;
    19382030      double bestNot=0.0;
     
    19482040        double infeasibility = object->infeasibility(preferredWay);
    19492041        int priorityLevel = object->priority();
     2042#define ZERO_ONE 0
     2043#define ZERO_FAKE 1.0e20;
     2044#if ZERO_ONE==1
     2045        // branch on 0-1 first (temp)
     2046        if (fabs(saveSolution[dynamicObject->columnNumber()])<1.0)
     2047          priorityLevel--;
     2048#endif
     2049#if ZERO_ONE==2
     2050        if (fabs(saveSolution[dynamicObject->columnNumber()])<1.0)
     2051          infeasibility *= ZERO_FAKE;
     2052#endif
    19502053        if (infeasibility) {
     2054          int iColumn = dynamicObject->columnNumber();
     2055          double gap = saveUpper[iColumn]-saveLower[iColumn];
     2056          // Give precedence to ones with gap of 1.0
     2057          assert(gap>0.0);
     2058          infeasibility /= CoinMin(gap,100.0);
    19512059          if (!depth_&&false) {
    19522060            // try closest to 0.5
    1953             int iColumn = dynamicObject->columnNumber();
    19542061            double part =saveSolution[iColumn]-floor(saveSolution[iColumn]);
    19552062            infeasibility = fabs(0.5-part);
     
    19572064          bool gotDown=false;
    19582065          int numberThisDown = dynamicObject->numberTimesDown();
    1959           if (numberThisDown) {
    1960             averageDown += dynamicObject->downDynamicPseudoCost();
    1961             numberDown++;
    1962             if (numberThisDown>=numberBeforeTrust)
    1963               gotDown=true;
    1964           }
     2066          if (numberThisDown>=numberBeforeTrust)
     2067            gotDown=true;
    19652068          bool gotUp=false;
    19662069          int numberThisUp = dynamicObject->numberTimesUp();
    1967           if (numberThisUp) {
    1968             averageUp += dynamicObject->upDynamicPseudoCost();
    1969             numberUp++;
    1970             if (numberThisUp>=numberBeforeTrust)
    1971               gotUp=true;
    1972           }
     2070          if (numberThisUp>=numberBeforeTrust)
     2071            gotUp=true;
    19732072          if ((numberNodes%PRINT_STUFF)==0&&PRINT_STUFF>0)
    19742073            printf("%d down %d %g up %d %g - infeas %g\n",
     
    20042103            int iColumn = dynamicObject->columnNumber();
    20052104            double part =saveSolution[iColumn]-floor(saveSolution[iColumn]);
    2006             sort[numberToDo]=-infeasibility;
     2105            sort[numberToDo]=-10.0*infeasibility;
     2106            if (!(numberThisUp+numberThisDown))
     2107              sort[numberToDo] *= 100.0; // make even more likely
    20072108            if (1.0-fabs(part-0.5)>bestNot) {
    20082109              iBestNot=numberToDo;
     
    20852186    //bool skipAll = (numberBeforeTrust>20&&numberNodes>20000&&numberNotTrusted==0);
    20862187    bool skipAll = numberNotTrusted==0;
     2188    bool doneHotStart=false;
     2189#ifndef CBC_WEAK_STRONG
    20872190    if ((numberNodes%20)==0||(model->specialOptions()&8)!=0)
    20882191      skipAll=false;
     2192#endif
     2193    int searchStrategy = saveSearchStrategy>=0 ? (saveSearchStrategy%10) : -1;
     2194    if (!newWay) {
     2195    // 10 up always use %10, 20 up as 10 and allow penalties
     2196    // But adjust depending on ratio of iterations
     2197    if (searchStrategy>0&&saveSearchStrategy<10) {
     2198      if (numberBeforeTrust>=5&&numberBeforeTrust<=10) {
     2199        if (searchStrategy!=2) {
     2200          int numberIterations = model->getIterationCount();
     2201          int numberStrongIterations = model->numberStrongIterations();
     2202          if (numberStrongIterations>numberIterations+10000) {
     2203            searchStrategy=2;
     2204            //skipAll=true;
     2205          } else if (numberStrongIterations*4+1000<numberIterations||depth_<5) {
     2206            searchStrategy=3;
     2207            skipAll=false;
     2208          }
     2209        } else {
     2210          skipAll=true;
     2211        }
     2212      }
     2213    }
     2214    } else {
     2215    // But adjust depending on ratio of iterations
     2216    if (saveSearchStrategy<0) {
     2217      // unset
     2218      if ((numberNodes%20)==0||(model->specialOptions()&8)!=0) {
     2219        // Do numberStrong
     2220        searchStrategy=3;
     2221      } else if (depth_<5) {
     2222        // Do numberStrong
     2223        searchStrategy=2;
     2224      } else {
     2225        int numberIterations = model->getIterationCount();
     2226        int numberStrongIterations = model->numberStrongIterations();
     2227        int numberRows = solver->getNumRows();
     2228        if (numberStrongIterations>numberIterations+CoinMin(10000,10*numberRows)) {
     2229          // off
     2230          searchStrategy=0;
     2231        } else if (numberStrongIterations*4+1000<numberIterations) {
     2232          // Do numberStrong if not trusted
     2233          searchStrategy=2;
     2234        } else {
     2235          searchStrategy=1;
     2236        }
     2237      }
     2238    }
     2239    if (searchStrategy<3&&(!numberNotTrusted||!searchStrategy))
     2240      skipAll=true;
     2241    else
     2242      skipAll=false;
     2243    }
    20892244    // worth trying if too many times
    20902245    // Save basis
     
    20922247    // save limit
    20932248    int saveLimit=0;
     2249    solver->getIntParam(OsiMaxNumIterationHotStart,saveLimit);
    20942250    if (!skipAll) {
    20952251      ws = solver->getWarmStart();
    2096       solver->getIntParam(OsiMaxNumIterationHotStart,saveLimit);
    2097       if (!saveStateOfSearch&&saveLimit<100)
    2098         solver->setIntParam(OsiMaxNumIterationHotStart,100);
     2252      int limit=100;
     2253#if 0
     2254      int averageBranchIterations = model->getIterationCount()/(model->getNodeCount()+1);
     2255      if (numberNodes)
     2256        limit = CoinMin(CoinMax(limit,2*averageBranchIterations),500);
     2257      else
     2258        limit = 500;
     2259#endif
     2260      if ((!saveStateOfSearch||searchStrategy>3)&&saveLimit<limit&&saveLimit==100)
     2261        solver->setIntParam(OsiMaxNumIterationHotStart,limit);
    20992262    }
    21002263    // Say which one will be best
     
    21262289        solver->setHintParam(OsiDoInBranchAndCut,true,OsiHintDo,&easy) ;
    21272290      int iDo;
    2128 #define RANGING
    21292291#ifdef RANGING
    2130       if (skipAll&&numberBeforeTrust)
     2292      if ((skipAll&&numberBeforeTrust&&saveSearchStrategy<20)||saveSearchStrategy<10)
    21312293        numberPenalties=0;
    21322294      {
     
    21342296        double needed = neededPenalties;
    21352297        needed *= numberRows;
    2136         if (needed>1.0e6) {
     2298        if (needed>1.0e6&&numberNodes&&saveSearchStrategy<20) {
    21372299          numberPenalties=0;
    21382300          neededPenalties=0;
     
    21542316          solver->markHotStart();
    21552317        }
     2318        doneHotStart=true;
    21562319        xMark++;
    21572320        kPass++;
     
    21592322        const double * downCost=osiclp->upRange();
    21602323        const double * upCost=osiclp->downRange();
    2161         //printf("numberTodo %d needed %d numberpenalties %d\n",numberToDo,needed,numberPenalties);
     2324        //printf("numberTodo %d needed %d numberpenalties %d\n",numberToDo,neededPenalties,numberPenalties);
    21622325        double invTrust = 1.0/((double) numberBeforeTrust);
    21632326        for (int i=0;i<neededPenalties;i++) {
     
    21892352          }
    21902353          sort[j] = - CoinMin(downEstimate[iObject],upEstimate[iObject]);
    2191           if ((numberNodes%PRINT_STUFF)==0&&PRINT_STUFF>0)
     2354#ifdef CBC_WEAK_STRONG
     2355          sort[j] -= 1.0e10; // make more likely to be chosen
     2356#endif
     2357          //if ((numberNodes%PRINT_STUFF)==0&&PRINT_STUFF>0)
     2358          if (!numberNodes)
    21922359            printf("%d pen down ps %g -> %g up ps %g -> %g\n",
    21932360                   iObject,downCost[i],downPenalty,upCost[i],upPenalty);
     
    21972364          // Mark hot start
    21982365          solver->markHotStart();
     2366          doneHotStart=true;
    21992367          xMark++;
    22002368          //if (solver->isProvenPrimalInfeasible())
     
    22062374      }
    22072375#else
    2208       // Mark hot start
    2209       solver->markHotStart();
    2210           xMark++;
     2376      if (!skipAll) {
     2377        // Mark hot start
     2378        doneHotStart=true;
     2379        solver->markHotStart();
     2380        xMark++;
     2381      }
    22112382      // make sure best will be first
    22122383      if (iBestGot>=0)
     
    22322403      //printf("todo %d, strong %d\n",numberToDo,numberStrong);
    22332404      int numberTest=numberNotTrusted>0 ? numberStrong : (numberStrong+1)/2;
    2234       int numberTest2 = CoinMax(2*numberStrong,10)+1000000;
     2405      int numberTest2 = 2*numberStrong;
     2406      if (!newWay) {
     2407      if (searchStrategy==3) {
     2408        // Previously decided we need strong
     2409        doQuickly=false;
     2410        numberTest = numberStrong;
     2411        //numberTest2 = 1000000;
     2412      }
     2413      if (searchStrategy<0||searchStrategy==1)
     2414        //numberTest2 = 1000000;
    22352415#if 0
    22362416      if (numberBeforeTrust>20&&(numberNodes>20000||(numberNodes>200&&numberNotTrusted==0))) {
     
    22422422#else
    22432423      // Try nearly always off
    2244       if ((numberNodes%20)!=0) {
    2245         numberTest=0;
     2424      if (searchStrategy<2) {
     2425        if ((numberNodes%20)!=0) {
     2426          if ((model->specialOptions()&8)==0) {
     2427            numberTest=0;
     2428            doQuickly=true;
     2429          }
     2430        } else {
     2431          doQuickly=false;
     2432          numberTest=2*numberStrong;
     2433        }
     2434      } else if (searchStrategy!=3) {
    22462435        doQuickly=true;
    2247       } else {
    2248         doQuickly=true;
    2249         numberTest=2*numberStrong;
     2436        numberTest=numberStrong;
    22502437      }
    22512438#endif
    22522439      if (depth_<10&&numberStrong) {
    2253         doQuickly=false;
    2254         if (depth_<7)
    2255           numberStrong *=3;
    2256         if (!depth_)
    2257           numberStrong=CoinMin(6*numberStrong,numberToDo);
    2258         numberTest=numberStrong;
     2440        if (searchStrategy!=2) {
     2441          doQuickly=false;
     2442          if (depth_<7)
     2443            numberStrong *=3;
     2444          if (!depth_)
     2445            numberStrong=CoinMin(6*numberStrong,numberToDo);
     2446          numberTest=numberStrong;
     2447        }
    22592448        model->setStateOfSearch(2); // use min min
    22602449      }
     
    22642453      // if too many and big then just do 10 its
    22652454      if (!skipAll&&saveStateOfSearch) {
    2266         //if (numberNotTrusted>3*numberStrong&&numberRows>250&&numberColumns>1000)
     2455        //if (numberNotTrusted>3*numberStrong&&numberRows>250&&numberColumns>1000&&saveLimit==100)
    22672456          // off solver->setIntParam(OsiMaxNumIterationHotStart,10);
    22682457      }
    2269       double distanceToCutoff=model->getCutoff()-objectiveValue_;
    22702458      // make negative for test
    22712459      distanceToCutoff = - distanceToCutoff;
     
    22872475        numberTest = CoinMax(numberTest,5);
    22882476      }
     2477      } else {
     2478      int numberTest=numberNotTrusted>0 ? numberStrong : (numberStrong+1)/2;
     2479      int numberTest2 = 2*numberStrong;
     2480      if (searchStrategy>=3) {
     2481        // Previously decided we need strong
     2482        doQuickly=false;
     2483        if (depth_<7)
     2484          numberStrong *=3;
     2485        if (!depth_)
     2486          numberStrong=CoinMin(6*numberStrong,numberToDo);
     2487        numberTest = numberStrong;
     2488        numberTest2 *= 2;
     2489      } else if (searchStrategy==2||(searchStrategy==1&&depth_<6)) {
     2490        numberStrong *=2;
     2491        if (!depth_)
     2492          numberStrong=CoinMin(2*numberStrong,numberToDo);
     2493        numberTest = numberStrong;
     2494      } else if (searchStrategy==1&&numberNotTrusted) {
     2495        numberTest = numberStrong;
     2496      } else {
     2497        numberTest=0;
     2498        skipAll=true;
     2499      }
     2500      distanceToCutoff=model->getCutoff()-objectiveValue_;
     2501      // make negative for test
     2502      distanceToCutoff = - distanceToCutoff;
     2503      if (numberObjects>-100) {
     2504        // larger
     2505        distanceToCutoff *= 100.0;
     2506      }
     2507      distanceToCutoff = -COIN_DBL_MAX;
     2508      if (skipAll) {
     2509        numberTest=0;
     2510        doQuickly=true;
     2511      }
     2512      }
     2513      px[0]=numberTest;
     2514      px[1]=numberTest2;
     2515      px[2]= doQuickly ? 1 : -1;
     2516      px[3]=numberStrong;
     2517      //printf("skipAll %c doQuickly %c numberTest %d numberTest2 %d numberNot %d\n",
     2518      //     skipAll ? 'Y' : 'N',doQuickly ? 'Y' : 'N',numberTest,numberTest2,numberNotTrusted);
    22892519      // See if we want mini tree
    22902520      bool wantMiniTree=false;
     
    23132543        // see if can skip strong branching
    23142544        int canSkip = choice.possibleBranch->fillStrongInfo(choice);
    2315         if (!doQuickly||numberTest>0)
     2545        if (!newWay) {
     2546        if (!doQuickly||(numberTest>0&&searchStrategy!=2))
    23162547          canSkip=0;
     2548        } else {
     2549        if (skipAll)
     2550          canSkip=1;
     2551        else if (numberTest>0&&searchStrategy>=3)
     2552          canSkip=0;
     2553        }
    23172554        if (!numberBeforeTrust) {
    23182555          canSkip=1;
     
    23202557        if (sort[iDo]<distanceToCutoff)
    23212558          canSkip=0;
    2322         if (numberTest2<=0&&sort[iDo]>distanceToCutoff)
     2559        if (((numberTest2<=0&&numberTest<=0)||skipAll)&&sort[iDo]>distanceToCutoff) {
    23232560          canSkip=1; // always skip
     2561          if (iDo>20)
     2562            break; // give up anyway
     2563        }
    23242564        if (model->messageHandler()->logLevel()>3&&numberBeforeTrust)
    23252565          dynamicObject->print(1,choice.possibleBranch->value());
    23262566        // was if (!canSkip)
     2567        if (newWay)
     2568        numberTest2--;
    23272569        if (!canSkip) {
    23282570          numberTest--;
     2571          if (!newWay)
    23292572          numberTest2--;
    23302573          // just do a few
    2331           if (canSkip)
    2332             solver->setIntParam(OsiMaxNumIterationHotStart,10);
     2574          //if (canSkip)
     2575          //solver->setIntParam(OsiMaxNumIterationHotStart,10);
    23332576          double objectiveChange ;
    23342577          double newObjectiveValue=1.0e100;
     
    23462589          choice.possibleBranch->branch() ;
    23472590          solver->solveFromHotStart() ;
    2348           xStrong++;
    2349           xIters += solver->getIterationCount();
     2591          numberStrongDone++;
     2592          numberStrongIterations += solver->getIterationCount();
    23502593          /*
    23512594            We now have an estimate of objective degradation that we can use for strong
     
    23702613            if (newObjectiveValue>=cutoff) {
    23712614              objectiveChange = 1.0e100; // say infeasible
     2615              numberStrongInfeasible++;
    23722616            } else {
    23732617              // See if integer solution
     
    23812625                model->incrementUsed(solver->getColSolution());
    23822626                cutoff =model->getCutoff();
    2383                 if (newObjectiveValue >= cutoff)        //  *new* cutoff
     2627                if (newObjectiveValue >= cutoff) {      //  *new* cutoff
    23842628                  objectiveChange = 1.0e100 ;
     2629                  numberStrongInfeasible++;
     2630                }
    23852631              }
    23862632            }
    23872633          } else if (iStatus==1) {
    23882634            objectiveChange = 1.0e100 ;
     2635            numberStrongInfeasible++;
    23892636          } else {
    23902637            // Can't say much as we did not finish
    23912638            choice.finishedDown = false ;
     2639            numberUnfinished++;
    23922640          }
    23932641          choice.downMovement = objectiveChange ;
     
    24092657          choice.possibleBranch->branch();
    24102658          solver->solveFromHotStart() ;
    2411           xStrong++;
    2412           xIters += solver->getIterationCount();
     2659          numberStrongDone++;
     2660          numberStrongIterations += solver->getIterationCount();
    24132661          /*
    24142662            We now have an estimate of objective degradation that we can use for strong
     
    24332681            if (newObjectiveValue>=cutoff) {
    24342682              objectiveChange = 1.0e100; // say infeasible
     2683              numberStrongInfeasible++;
    24352684            } else {
    24362685              // See if integer solution
     
    24442693                model->incrementUsed(solver->getColSolution());
    24452694                cutoff =model->getCutoff();
    2446                 if (newObjectiveValue >= cutoff)        //  *new* cutoff
     2695                if (newObjectiveValue >= cutoff) {      //  *new* cutoff
    24472696                  objectiveChange = 1.0e100 ;
     2697                  numberStrongInfeasible++;
     2698                }
    24482699              }
    24492700            }
    24502701          } else if (iStatus==1) {
    24512702            objectiveChange = 1.0e100 ;
     2703            numberStrongInfeasible++;
    24522704          } else {
    24532705            // Can't say much as we did not finish
    24542706            choice.finishedUp = false ;
     2707            numberUnfinished++;
    24552708          }
    24562709          choice.upMovement = objectiveChange ;
     
    24882741            choice.upMovement = CoinMax(0.0,choice.upMovement);
    24892742            choice.downMovement = CoinMax(0.0,choice.downMovement);
     2743#if ZERO_ONE==2
     2744            // branch on 0-1 first (temp)
     2745            if (fabs(choice.possibleBranch->value())<1.0) {
     2746              choice.upMovement *= ZERO_FAKE;
     2747              choice.downMovement *= ZERO_FAKE;
     2748            }
     2749#endif
    24902750            // feasible - see which best
    24912751            if (!canSkip) {
     2752              if (iColumn==-46) {
     2753                printf("sort %g downest %g upest %g ",sort[iDo],downEstimate[iObject],
     2754                     upEstimate[iObject]);
     2755                printf("downMove %g upMove %g value %g current pseudo %g %g\n",
     2756                       choice.downMovement,choice.upMovement,choice.possibleBranch->value(),
     2757                       dynamicObject->downDynamicPseudoCost(),dynamicObject->upDynamicPseudoCost());
     2758              }
    24922759              if (model->messageHandler()->logLevel()>3)
    24932760                printf("sort %g downest %g upest %g ",sort[iDo],downEstimate[iObject],
     
    25052772              decision->setBestCriterion(-1.0);
    25062773            double bestCriterion = -1.0;
     2774            double gap = saveUpper[iColumn]-saveLower[iColumn];
     2775            // Give precedence to ones with gap of 1.0
     2776            assert(gap>0.0);
     2777            double factor = changeFactor/CoinMin(gap,100.0);
    25072778            int betterWay = decision->betterBranch(choice.possibleBranch,
    25082779                                                   branch_,
    2509                                                    choice.upMovement*changeFactor,
     2780                                                   choice.upMovement*factor,
    25102781                                                   choice.numIntInfeasUp ,
    2511                                                    choice.downMovement*changeFactor,
     2782                                                   choice.downMovement*factor,
    25122783                                                   choice.numIntInfeasDown );
    25132784            if (wantMiniTree) {
     
    25782849              saveLower[iColumn]=value;
    25792850              solver->setColLower(iColumn,value);
     2851              assert(doneHotStart);
     2852              solver->unmarkHotStart();
     2853              solver->markHotStart();
    25802854#endif
    25812855            }
     
    26022876              saveUpper[iColumn]=value;
    26032877              solver->setColUpper(iColumn,value);
     2878              assert(doneHotStart);
     2879              solver->unmarkHotStart();
     2880              solver->markHotStart();
    26042881#endif
    26052882            }
     
    26482925                 iDo,whichChoice,numberToDo);
    26492926      }
    2650       if (!skipAll) {
     2927      if (doneHotStart) {
    26512928        // Delete the snapshot
    26522929        solver->unmarkHotStart();
    26532930        // back to normal
    26542931        solver->setHintParam(OsiDoInBranchAndCut,true,OsiHintDo,NULL) ;
    2655         solver->setIntParam(OsiMaxNumIterationHotStart,saveLimit);
    26562932        // restore basis
    26572933        solver->setWarmStart(ws);
    26582934      }
     2935      solver->setIntParam(OsiMaxNumIterationHotStart,saveLimit);
    26592936      // Unless infeasible we will carry on
    26602937      // But we could fix anyway
     
    27263003  }
    27273004  if (model->messageHandler()->logLevel()>2)
    2728     printf("%d strong, %d iters, %d pen, %d mark, %d fixed, action %d\n",
    2729          xStrong,xIters,xPen,xMark,numberToFix,anyAction);
     3005    printf("%d strong, %d iters, %d pen, %d mark, %d fixed, action %d nnott %d nt %d, %d dq %s ns %d\n",
     3006         numberStrongDone,numberStrongIterations,xPen,xMark,
     3007           numberToFix,anyAction,numberNotTrusted,px[0],px[1],px[2]>0 ? "y" : "n",px[3]);
     3008  // update number of strong iterations
     3009  model->setNumberStrongIterations(model->numberStrongIterations()+numberStrongIterations);
     3010  if (!newWay) {
     3011  if (((model->searchStrategy()+1)%1000)==0) {
     3012    if (solver->messageHandler()->logLevel()>1)
     3013      printf("%d strong, %d iters, %d inf, %d not finished, %d not trusted\n",
     3014             numberStrongDone,numberStrongIterations,numberStrongInfeasible,numberUnfinished,
     3015             numberNotTrusted);
     3016    // decide what to do
     3017    int strategy=1;
     3018    if (numberUnfinished*4>numberStrongDone&&numberStrongInfeasible*10<numberStrongDone) {
     3019      strategy=2;
     3020      if (model->logLevel()>1)
     3021        printf("going to strategy 2\n");
     3022    }
     3023    if (numberNodes)
     3024      strategy=1;  // should only happen after hot start
     3025    model->setSearchStrategy(strategy);
     3026  }
     3027  }
    27303028  //if (numberToFix&&depth_<5)
    27313029  //printf("%d fixed by strong at depth %d\n",numberToFix,depth_);
Note: See TracChangeset for help on using the changeset viewer.