Ignore:
File:
1 edited

Legend:

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

    r1902 r2105  
    3030#include "CbcHeuristicFPump.hpp"
    3131#include "CbcHeuristicRINS.hpp"
     32#include "CbcHeuristicDW.hpp"
     33#include "CbcHeuristicVND.hpp"
    3234
    3335#include "CbcHeuristicDiveCoefficient.hpp"
     
    11651167    int useRINS = parameters_[whichParam(CBC_PARAM_STR_RINS, numberParameters_, parameters_)].currentOptionAsInteger();
    11661168    int useRENS = parameters_[whichParam(CBC_PARAM_STR_RENS, numberParameters_, parameters_)].currentOptionAsInteger();
     1169    int useVND = parameters_[whichParam(CBC_PARAM_STR_VND, numberParameters_, parameters_)].currentOptionAsInteger();
    11671170    int useDINS = parameters_[whichParam(CBC_PARAM_STR_DINS, numberParameters_, parameters_)].currentOptionAsInteger();
    11681171    int useDIVING2 = parameters_[whichParam(CBC_PARAM_STR_DIVINGS, numberParameters_, parameters_)].currentOptionAsInteger();
    11691172    int useNaive = parameters_[whichParam(CBC_PARAM_STR_NAIVE, numberParameters_, parameters_)].currentOptionAsInteger();
     1173    int useDW = parameters_[whichParam(CBC_PARAM_STR_DW, numberParameters_, parameters_)].currentOptionAsInteger();
    11701174    int kType = (type < 10) ? type : 1;
    11711175    assert (kType == 1 || kType == 2);
     
    12941298                if (fakeIncrement)
    12951299                    increment = fakeIncrement;
    1296                 heuristic4.setAbsoluteIncrement(increment);
     1300                if (increment>=0.0)
     1301                  heuristic4.setAbsoluteIncrement(increment);
     1302                else
     1303                  heuristic4.setRelativeIncrement(-increment);
    12971304                heuristic4.setMaximumRetries(r + 1);
    12981305                if (printStuff) {
    12991306                    if (increment) {
    1300                         sprintf(generalPrint, "Increment of %g", increment);
     1307                      if (increment>0.0)
     1308                        sprintf(generalPrint, "Absolute increment of %g", increment);
     1309                      else
     1310                        sprintf(generalPrint, "Relative increment of %g", -increment);
    13011311                        generalMessageHandler->message(CBC_GENERAL, generalMessages)
    13021312                        << generalPrint
     
    13811391        model->addHeuristic(&heuristic6a) ;
    13821392    }
    1383     if (useRENS >= kType && useRENS <= kType + 1) {
    1384 #ifndef JJF_ONE
     1393    if ((useRENS >= kType && useRENS <= kType + 1)||
     1394        useRENS>2) {
    13851395        CbcHeuristicRENS heuristic6(*model);
    13861396        heuristic6.setHeuristicName("RENS");
    13871397        heuristic6.setFractionSmall(0.4);
    13881398        heuristic6.setFeasibilityPumpOptions(1008003);
     1399        int nodes [] = { -2, 50, 50, 50, 200, 1000, 10000, -1, -1, 200};
     1400        heuristic6.setNumberNodes(nodes[useRENS]);
     1401        heuristic6.setRensType(useRENS!=9 ? 0 : 32);
     1402        model->addHeuristic(&heuristic6) ;
     1403        anyToDo = true;
     1404    }
     1405    if (useVND >= kType && useVND <= kType + 1) {
     1406        CbcHeuristicVND heuristic6b(*model);
     1407        heuristic6b.setHeuristicName("VND");
     1408        heuristic6b.setFractionSmall(0.4);
     1409        heuristic6b.setFeasibilityPumpOptions(1008003);
    13891410        int nodes [] = { -2, 50, 50, 50, 200, 1000, 10000};
    1390         heuristic6.setNumberNodes(nodes[useRENS]);
    1391 #else
    1392         CbcHeuristicVND heuristic6(*model);
    1393         heuristic6.setHeuristicName("VND");
    1394         heuristic5.setFractionSmall(0.5);
    1395         heuristic5.setDecayFactor(5.0);
    1396 #endif
    1397         model->addHeuristic(&heuristic6) ;
     1411        heuristic6b.setNumberNodes(nodes[useVND]);
     1412        model->addHeuristic(&heuristic6b) ;
    13981413        anyToDo = true;
    13991414    }
     
    14541469
    14551470    if (useDIVING > 0) {
    1456         int majorIterations=64;
     1471        int majorIterations=parameters_[whichParam(CBC_PARAM_INT_DIVEOPTSOLVES, numberParameters_, parameters_)].intValue();
    14571472        int diveOptions2 = parameters_[whichParam(CBC_PARAM_INT_DIVEOPT, numberParameters_, parameters_)].intValue();
    14581473        int diveOptions;
     
    14651480            diveOptions2 = 0;
    14661481        }
    1467         if (diveOptions < 0 || diveOptions > 9)
     1482        if (diveOptions < 0 || diveOptions > 29)
    14681483            diveOptions = 2;
     1484        int diveOptionsNotC=diveOptions;
     1485        if (diveOptions>10) {
     1486          if (diveOptions>20) {
     1487            diveOptions-=20;
     1488            diveOptionsNotC-=20;
     1489          } else {
     1490            diveOptions -= 10;
     1491            diveOptionsNotC = 4;
     1492          }
     1493          useDIVING = 63;
     1494        }
    14691495        if ((useDIVING&1) != 0) {
    14701496            CbcHeuristicDiveVectorLength heuristicDV(*model);
    14711497            heuristicDV.setHeuristicName("DiveVectorLength");
    1472             heuristicDV.setWhen(diveOptions);
     1498            heuristicDV.setWhen(diveOptionsNotC);
     1499            heuristicDV.setMaxIterations(majorIterations);
    14731500            if (diveOptions2) {
    1474               heuristicDV.setMaxIterations(majorIterations);
    14751501              heuristicDV.setPercentageToFix(0.0);
    14761502              heuristicDV.setMaxSimplexIterations(COIN_INT_MAX);
     
    14821508            CbcHeuristicDiveGuided heuristicDG(*model);
    14831509            heuristicDG.setHeuristicName("DiveGuided");
    1484             heuristicDG.setWhen(diveOptions);
     1510            heuristicDG.setWhen(diveOptionsNotC);
     1511            heuristicDG.setMaxIterations(majorIterations);
    14851512            if (diveOptions2) {
    1486               heuristicDG.setMaxIterations(majorIterations);
    14871513              heuristicDG.setPercentageToFix(0.0);
    14881514              heuristicDG.setMaxSimplexIterations(COIN_INT_MAX);
     
    14941520            CbcHeuristicDiveFractional heuristicDF(*model);
    14951521            heuristicDF.setHeuristicName("DiveFractional");
    1496             heuristicDF.setWhen(diveOptions);
     1522            heuristicDF.setWhen(diveOptionsNotC);
     1523            heuristicDF.setMaxIterations(majorIterations);
    14971524            if (diveOptions2) {
    1498               heuristicDF.setMaxIterations(majorIterations);
    14991525              heuristicDF.setPercentageToFix(0.0);
    15001526              heuristicDF.setMaxSimplexIterations(COIN_INT_MAX);
     
    15071533            heuristicDC.setHeuristicName("DiveCoefficient");
    15081534            heuristicDC.setWhen(diveOptions);
     1535            heuristicDC.setMaxIterations(majorIterations);
    15091536            if (diveOptions2) {
    1510               heuristicDC.setMaxIterations(majorIterations);
    15111537              heuristicDC.setPercentageToFix(0.0);
    15121538              heuristicDC.setMaxSimplexIterations(COIN_INT_MAX);
     
    15181544            CbcHeuristicDiveLineSearch heuristicDL(*model);
    15191545            heuristicDL.setHeuristicName("DiveLineSearch");
    1520             heuristicDL.setWhen(diveOptions);
     1546            heuristicDL.setWhen(diveOptionsNotC);
     1547            heuristicDL.setMaxIterations(majorIterations);
    15211548            if (diveOptions2) {
    1522               heuristicDL.setMaxIterations(majorIterations);
    15231549              heuristicDL.setPercentageToFix(0.0);
    15241550              heuristicDL.setMaxSimplexIterations(COIN_INT_MAX);
     
    15301556            CbcHeuristicDivePseudoCost heuristicDP(*model);
    15311557            heuristicDP.setHeuristicName("DivePseudoCost");
    1532             heuristicDP.setWhen(diveOptions /*+ diveOptions2*/);
     1558            heuristicDP.setWhen(diveOptionsNotC /*+ diveOptions2*/);
     1559            heuristicDP.setMaxIterations(majorIterations);
    15331560            if (diveOptions2) {
    1534               heuristicDP.setMaxIterations(majorIterations);
    15351561              heuristicDP.setPercentageToFix(0.0);
    15361562              heuristicDP.setMaxSimplexIterations(COIN_INT_MAX);
     
    15891615        anyToDo = true;
    15901616    }
    1591     if (useCombine >= kType && useCombine <= kType + 1) {
     1617    if (useDW >= kType && useDW <= kType + 1) {
     1618        CbcHeuristicDW heuristic13(*model);
     1619        heuristic13.setHeuristicName("Dantzig-Wolfe");
     1620        heuristic13.setNumberPasses(100);
     1621        heuristic13.setNumberBadPasses(10);
     1622        int numberIntegers=0;
     1623        const OsiSolverInterface * solver = model->solver();
     1624        int numberColumns = solver->getNumCols();
     1625        for (int i=0;i<numberColumns;i++) {
     1626          if(solver->isInteger(i))
     1627            numberIntegers++;
     1628        }
     1629        heuristic13.setNumberNeeded(CoinMin(200,numberIntegers/10));
     1630        model->addHeuristic(&heuristic13);
     1631        anyToDo = true;
     1632    }
     1633    if (useCombine >= kType && (useCombine-1)%3 <= kType ) {
    15921634        CbcHeuristicLocal heuristic2(*model);
    15931635        heuristic2.setHeuristicName("combine solutions");
    15941636        heuristic2.setFractionSmall(0.5);
    1595         heuristic2.setSearchType(1);
     1637        int searchType=1;
     1638        if (useCombine>3)
     1639          searchType += 10; // experiment
     1640        heuristic2.setSearchType(searchType);
    15961641        model->addHeuristic(&heuristic2);
    15971642        anyToDo = true;
    15981643    }
    1599     if ((useProximity >= kType && useProximity <= kType + 1)||
    1600         (kType == 1 && useProximity >= 4)) {
     1644    if ((useProximity >= kType && useProximity <= kType + 1) ||
     1645        (kType == 1 && useProximity > 3) ){
    16011646        CbcHeuristicProximity heuristic2a(*model);
    16021647        heuristic2a.setHeuristicName("Proximity Search");
     
    16101655          if (useProximity==6)
    16111656            heuristic2a.setFeasibilityPumpOptions(-3);
     1657        } else {
     1658          int proximityNumber;
     1659          parameters_[whichParam(CBC_PARAM_STR_PROXIMITY, numberParameters_, parameters_)].currentOptionAsInteger(proximityNumber);
     1660          if (proximityNumber>0) {
     1661            heuristic2a.setNumberNodes(proximityNumber);
     1662            // more print out and stronger feasibility pump
     1663            if (proximityNumber>=300)
     1664              heuristic2a.setFeasibilityPumpOptions(-3);
     1665          }
    16121666        }
    16131667        model->addHeuristic(&heuristic2a);
Note: See TracChangeset for help on using the changeset viewer.