Changeset 2545


Ignore:
Timestamp:
Apr 7, 2019 11:49:27 PM (6 months ago)
Author:
stefan
Message:

sync with trunk

Location:
stable/2.10
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • stable/2.10

  • stable/2.10/Cbc

  • stable/2.10/Cbc/src

  • stable/2.10/Cbc/src/CbcHeuristic.cpp

    r2467 r2545  
    25722572      }
    25732573    }
     2574    // but integer variables may have wandered
     2575    for (i = 0; i < numberIntegers; i++) {
     2576      int iColumn = integerVariable[i];
     2577      double value = newSolution[iColumn];
     2578      if (fabs(floor(value + 0.5) - value) > integerTolerance)
     2579        penalty += fabs(floor(value + 0.5) - value);
     2580    }
    25742581  }
    25752582
  • stable/2.10/Cbc/src/CbcModel.cpp

    r2534 r2545  
    39383938    // To make depth available we may need a fake node
    39393939    CbcNode fakeNode;
    3940     if (!currentNode_) {
    3941       // Not true if sub trees assert (!numberNodes_);
    3942       currentNode_ = &fakeNode;
    3943     }
    39443940    phase_ = 3;
    39453941    // only allow 1000 passes
     
    56505646
    56515647  memset(dblParam_, 0, sizeof(dblParam_));
    5652   dblParam_[CbcIntegerTolerance] = 1e-6;
     5648  dblParam_[CbcIntegerTolerance] = 1e-7;
    56535649  dblParam_[CbcCutoffIncrement] = 1e-5;
    56545650  dblParam_[CbcAllowableGap] = 1.0e-10;
     
    58215817
    58225818  memset(dblParam_, 0, sizeof(dblParam_));
    5823   dblParam_[CbcIntegerTolerance] = 1e-6;
     5819  dblParam_[CbcIntegerTolerance] = 1e-7;
    58245820  dblParam_[CbcCutoffIncrement] = 1e-5;
    58255821  dblParam_[CbcAllowableGap] = 1.0e-10;
     
    75947590  if (!defaultHandler_) {
    75957591    // Must have clone
    7596     handler_ = handler_->clone();
     7592    handler_ = handler_->clone();  // Not sure - worst is small memory leak
    75977593    defaultHandler_ = true;
    75987594  }
     
    1210812104  if (solver_) {
    1210912105    // Solvers know about direction
     12106    // but Clp tries to be too clever and flips twice!
     12107#ifndef COIN_HAS_CLP
    1211012108    double direction = solver_->getObjSense();
     12109#else
     12110    double direction = 1.0;
     12111    if (!dynamic_cast< OsiClpSolverInterface * >(solver_))
     12112      direction = solver_->getObjSense();
     12113#endif
    1211112114    solver_->setDblParam(OsiDualObjectiveLimit, value * direction);
    1211212115  }
     
    1214912152    int saveScaling = -1;
    1215012153#endif
     12154#define CBC_LEAVE_CRUNCH_ON_CHECK_SOLUTION // for now
     12155#ifndef CBC_LEAVE_CRUNCH_ON_CHECK_SOLUTION
     12156    int saveSpecialOptions=0;
     12157#endif
    1215112158    if (clpContinuousSolver) {
    1215212159      // be more accurate if possible
     
    1217912186        clpContinuousSolver->setHintParam(OsiDoScale, false, OsiHintTry);
    1218012187      }
     12188#endif
     12189#ifndef CBC_LEAVE_CRUNCH_ON_CHECK_SOLUTION
     12190      modifiedTolerances |= 8;
     12191      saveSpecialOptions = clpContinuousSolver->specialOptions();
     12192      clpContinuousSolver->setSpecialOptions(saveSpecialOptions&(~1)); // switch off crunch
    1218112193#endif
    1218212194    }
     
    1238512397          }
    1238612398#endif
     12399#ifndef CBC_LEAVE_CRUNCH_ON_CHECK_SOLUTION
     12400          // Restore
     12401          clpContinuousSolver->setSpecialOptions(saveSpecialOptions);
     12402#endif
    1238712403        }
    1238812404#endif
     
    1262012636      //assert(solver_->isProvenOptimal());
    1262112637      solver_->setHintParam(OsiDoDualInInitial, saveTakeHint, saveStrength);
    12622       objectiveValue = solver_->getObjValue() * solver_->getObjSense();
     12638      objectiveValue = solver_->isProvenOptimal() ? solver_->getObjValue() * solver_->getObjSense() : 1.0e50;
    1262312639    }
    1262412640    bestSolutionBasis_ = CoinWarmStartBasis();
     
    1286712883      }
    1286812884#endif
     12885#ifndef CBC_LEAVE_CRUNCH_ON_CHECK_SOLUTION
     12886      clpContinuousSolver->setSpecialOptions(saveSpecialOptions);
     12887#endif
    1286912888    }
    1287012889#endif
     
    1501015029        if (clpSolver) {
    1501115030          anyAction = newNode->chooseClpBranch(this, oldNode);
     15031          currentNode_ = NULL;
    1501215032          if (anyAction != -1)
    1501315033            break;
     
    1507315093          anyAction = newNode->chooseBranch(this, oldNode, numberPassesLeft); // dynamic did nothing
    1507415094      }
     15095      currentNode_ = NULL;
    1507515096#ifdef COIN_HAS_CLP
    1507615097      if (clpSolver && (moreSpecialOptions_ & 4194304) != 0) {
     
    1508515106      OsiBranchingInformation usefulInfo = usefulInformation();
    1508615107      anyAction = newNode->chooseOsiBranch(this, oldNode, &usefulInfo, branchingState);
    15087       ; // Osi method
     15108      currentNode_ = NULL;
    1508815109      //branchingState=0;
    1508915110    }
  • stable/2.10/Cbc/src/CbcSolver.cpp

    r2534 r2545  
    8282//#define USER_HAS_FAKE_CLP
    8383//#define USER_HAS_FAKE_CBC
    84 
     84//#define NEW_DEBUG_AND_FILL // use this to make it easier to trap unset
     85
     86#ifdef NEW_DEBUG_AND_FILL
     87#include <malloc.h>
     88#include <exception>
     89#include <new>
     90void *operator new(size_t size)
     91{
     92  void * p = malloc(size);
     93  char * xx = (char *) p;
     94  memset(xx,0x20,size);
     95  return p;
     96}
     97void operator delete(void *p) throw()
     98{
     99  free(p);
     100}
     101#endif // end NEW_DEBUG
    85102//#define CLP_MALLOC_STATISTICS
    86103
     
    331348    //presolvedModel->setBestSolution(bestSolution,numberColumns,objectiveValue);
    332349  }
     350}
     351
     352// For when number of column is messed up e.g. BiLinear
     353static int numberPrintingColumns(const OsiSolverInterface * solver)
     354{
     355#ifdef COIN_HAS_LINK
     356  const OsiSolverLink *linkSolver =
     357    dynamic_cast< const OsiSolverLink * >(solver);
     358  if (!linkSolver)
     359    return solver->getNumCols();
     360  return linkSolver->coinModel()->numberColumns();
     361#else
     362  return solver->getNumCols();
     363#endif
    333364}
    334365
     
    26582689              mixedAction = action;
    26592690              twomirAction = action;
    2660               //landpAction = action;
     2691              zerohalfAction = action;
    26612692              parameters_[whichParam(CBC_PARAM_STR_GOMORYCUTS, parameters_)].setCurrentOption(action);
    26622693              parameters_[whichParam(CBC_PARAM_STR_PROBINGCUTS, parameters_)].setCurrentOption(action);
     
    35833614                      cbcModel->addCutGenerator(&twomir, -99, "Twomir", true, false, false, -100, -1, -1);
    35843615                      cbcModel->cutGenerator(numCutGens++)->setTiming(true);
    3585 
    3586                       CbcHeuristicFPump heuristicFPump(*cbcModel);
    3587                       heuristicFPump.setWhen(13);
    3588                       heuristicFPump.setMaximumPasses(20);
    3589                       heuristicFPump.setMaximumRetries(7);
    3590                       heuristicFPump.setHeuristicName("feasibility pump");
    3591                       heuristicFPump.setInitialWeight(1);
    3592                       heuristicFPump.setFractionSmall(0.6);
    3593                       cbcModel->addHeuristic(&heuristicFPump);
    3594 
    3595                       CbcRounding rounding(*cbcModel);
    3596                       rounding.setHeuristicName("rounding");
    3597                       cbcModel->addHeuristic(&rounding);
    3598 
    3599                       CbcHeuristicLocal heuristicLocal(*cbcModel);
    3600                       heuristicLocal.setHeuristicName("combine solutions");
    3601                       heuristicLocal.setSearchType(1);
    3602                       heuristicLocal.setFractionSmall(0.6);
    3603                       cbcModel->addHeuristic(&heuristicLocal);
    3604 
    3605                       CbcHeuristicGreedyCover heuristicGreedyCover(*cbcModel);
    3606                       heuristicGreedyCover.setHeuristicName("greedy cover");
    3607                       cbcModel->addHeuristic(&heuristicGreedyCover);
    3608 
    3609                       CbcHeuristicGreedyEquality heuristicGreedyEquality(*cbcModel);
    3610                       heuristicGreedyEquality.setHeuristicName("greedy equality");
    3611                       cbcModel->addHeuristic(&heuristicGreedyEquality);
    3612 
    3613                       CbcCompareDefault compare;
    3614                       cbcModel->setNodeComparison(compare);
    3615                       cbcModel->setNumberBeforeTrust(5);
     3616                      int heuristicOption = parameters_[whichParam(CBC_PARAM_STR_HEURISTICSTRATEGY, parameters_)].currentOptionAsInteger();
     3617                      if (heuristicOption) {
     3618                        CbcHeuristicFPump heuristicFPump(*cbcModel);
     3619                        heuristicFPump.setWhen(13);
     3620                        heuristicFPump.setMaximumPasses(20);
     3621                        heuristicFPump.setMaximumRetries(7);
     3622                        heuristicFPump.setHeuristicName("feasibility pump");
     3623                        heuristicFPump.setInitialWeight(1);
     3624                        heuristicFPump.setFractionSmall(0.6);
     3625                        cbcModel->addHeuristic(&heuristicFPump);
     3626                       
     3627                        CbcRounding rounding(*cbcModel);
     3628                        rounding.setHeuristicName("rounding");
     3629                        cbcModel->addHeuristic(&rounding);
     3630                       
     3631                        CbcHeuristicLocal heuristicLocal(*cbcModel);
     3632                        heuristicLocal.setHeuristicName("combine solutions");
     3633                        heuristicLocal.setSearchType(1);
     3634                        heuristicLocal.setFractionSmall(0.6);
     3635                        cbcModel->addHeuristic(&heuristicLocal);
     3636                       
     3637                        CbcHeuristicGreedyCover heuristicGreedyCover(*cbcModel);
     3638                        heuristicGreedyCover.setHeuristicName("greedy cover");
     3639                        cbcModel->addHeuristic(&heuristicGreedyCover);
     3640                       
     3641                        CbcHeuristicGreedyEquality heuristicGreedyEquality(*cbcModel);
     3642                        heuristicGreedyEquality.setHeuristicName("greedy equality");
     3643                        cbcModel->addHeuristic(&heuristicGreedyEquality);
     3644                      }
     3645                      CbcCompareDefault compare;
     3646                      cbcModel->setNodeComparison(compare);
     3647                      cbcModel->setNumberBeforeTrust(5);
    36163648                      cbcModel->setSpecialOptions(2);
    36173649                      cbcModel->messageHandler()->setLogLevel(1);
     
    36573689                      CbcHeuristicDynamic3 dynamic(model_);
    36583690                      dynamic.setHeuristicName("dynamic pass thru");
    3659                       model_.addHeuristic(&dynamic);
     3691                      if (heuristicOption)
     3692                        model_.addHeuristic(&dynamic);
    36603693                      // if convex
    36613694                      if ((linkSolver->specialOptions2() & 4) != 0 && solution) {
     
    52615294                  char atEnd = (when < 2) ? 1 : 0;
    52625295                  int gomoryTypeMajor = 10;
    5263                   if (when < 3) {
     5296                  if (when != 3) {
    52645297                    // normal as well
    52655298                    babModel_->addCutGenerator(&gomoryGen, gType, "Gomory");
    52665299                    accuracyFlag[numberGenerators] = 3;
    52675300                    switches[numberGenerators++] = 0;
    5268                     if (when == 2)
     5301                    if (when == 2) {
    52695302                      gomoryTypeMajor = 20;
     5303                    } else if (when == 4) {
     5304                      gomoryTypeMajor = 20;
     5305                      when = 0;
     5306                    }
    52705307                  } else {
    52715308                    when--; // so on
     
    64126449                      CbcHeuristicDynamic3 serendipity(*babModel_);
    64136450                      serendipity.setHeuristicName("linked");
    6414                       babModel_->addHeuristic(&serendipity);
     6451                      int heuristicOption = parameters_[whichParam(CBC_PARAM_STR_HEURISTICSTRATEGY, parameters_)].currentOptionAsInteger();
     6452                      if (heuristicOption)
     6453                        babModel_->addHeuristic(&serendipity);
    64156454                      double dextra3 = parameters_[whichParam(CBC_PARAM_DBL_DEXTRA3, parameters_)].doubleValue();
    64166455                      if (dextra3)
     
    77097748                  }
    77107749
    7711                   assert(saveSolver->isProvenOptimal());
     7750                  //assert(saveSolver->isProvenOptimal());
    77127751#ifndef CBC_OTHER_SOLVER
    77137752                  // and original solver
     
    77327771                      osiclp->getModelPtr()->checkUnscaledSolution();
    77337772                  }
    7734                   assert(originalSolver->isProvenOptimal());
     7773                  //assert(originalSolver->isProvenOptimal());
    77357774#endif
    77367775                  babModel_->assignSolver(saveSolver);
     
    77907829#endif
    77917830                  }
    7792                   assert(originalSolver->isProvenOptimal());
     7831                  //assert(originalSolver->isProvenOptimal());
    77937832                }
    77947833#endif
     
    97279766                if (type == CLP_PARAM_ACTION_GMPL_SOLUTION) {
    97289767                  int numberRows = lpSolver->getNumRows();
    9729                   int numberColumns = lpSolver->getNumCols();
     9768                  int numberColumns = lpSolver->getNumCols();
    97309769                  int numberGlpkRows = numberRows + 1;
    97319770#ifdef COIN_HAS_GLPK
     
    1002510064                  delete[] newMasks;
    1002610065                }
    10027                 if (printMode > 5) {
     10066                if (printMode > 5 && printMode < 12) {
    1002810067                  ClpSimplex *solver = clpSolver->getModelPtr();
    10029                   int numberColumns = solver->numberColumns();
     10068                  int numberColumns = numberPrintingColumns(clpSolver);
     10069                  //int numberColumns = solver->numberColumns();
    1003010070                  // column length unless rhs ranging
    1003110071                  int number = numberColumns;
     
    1020410244                }
    1020510245                int iColumn;
    10206                 int numberColumns = clpSolver->getNumCols();
     10246                int numberColumns = numberPrintingColumns(clpSolver);
    1020710247                const double *dualColumnSolution = clpSolver->getReducedCost();
    1020810248                const double *primalColumnSolution = clpSolver->getColSolution();
    1020910249                const double *columnLower = clpSolver->getColLower();
    1021010250                const double *columnUpper = clpSolver->getColUpper();
    10211                 if (printMode != 2) {
     10251                if (printMode != 2 && printMode < 12) {
    1021210252                  if (printMode == 5) {
    1021310253                    if (lengthName)
     
    1027810318                    }
    1027910319                  }
    10280                 } else {
     10320                } else if (printMode==2){
    1028110321                  // special format suitable for OsiRowCutDebugger
    1028210322                  int n = 0;
     
    1032310363                  }
    1032410364                  fprintf(fp, "};\n");
     10365                } else {
     10366                  // Make up a fake bounds section
     10367                  char outputValue[24];
     10368                  for (iColumn = 0; iColumn < numberColumns; iColumn++) {
     10369                    if (printMode==13||model_.solver()->isInteger(iColumn)) {
     10370                      fprintf(fp," FX BOUND001  ");
     10371                      const char *name = columnNames[iColumn].c_str();
     10372                      size_t n = strlen(name);
     10373                      size_t i;
     10374                      for (i = 0; i < n; i++)
     10375                        fprintf(fp, "%c", name[i]);
     10376                      for (; i < lengthPrint; i++)
     10377                        fprintf(fp, " ");
     10378                      CoinConvertDouble(5,2,primalColumnSolution[iColumn],
     10379                                        outputValue);
     10380                      fprintf(fp,"  %s\n",outputValue);
     10381                    } else {
     10382                      fprintf(fp," LO BOUND001  ");
     10383                      const char *name = columnNames[iColumn].c_str();
     10384                      size_t n = strlen(name);
     10385                      size_t i;
     10386                      for (i = 0; i < n; i++)
     10387                        fprintf(fp, "%c", name[i]);
     10388                      for (; i < lengthPrint; i++)
     10389                        fprintf(fp, " ");
     10390                      CoinConvertDouble(5,2,CoinMax(-1.0e30,columnLower[iColumn]),
     10391                                        outputValue);
     10392                      fprintf(fp,"  %s\n",outputValue);
     10393                      fprintf(fp," UP BOUND001  ");
     10394                      for (i = 0; i < n; i++)
     10395                        fprintf(fp, "%c", name[i]);
     10396                      for (; i < lengthPrint; i++)
     10397                        fprintf(fp, " ");
     10398                      CoinConvertDouble(5,2,CoinMin(1.0e30,columnUpper[iColumn]),
     10399                                        outputValue);
     10400                      fprintf(fp,"  %s\n",outputValue);
     10401                    }
     10402                  }
     10403                  for (iColumn = 0; iColumn < numberColumns; iColumn++) {
     10404                    if (primalColumnSolution[iColumn] > columnUpper[iColumn] + primalTolerance || primalColumnSolution[iColumn] < columnLower[iColumn] - primalTolerance) {
     10405                      fprintf(fp," FX BOUND002  ");
     10406                      const char *name = columnNames[iColumn].c_str();
     10407                      size_t n = strlen(name);
     10408                      size_t i;
     10409                      for (i = 0; i < n; i++)
     10410                        fprintf(fp, "%c", name[i]);
     10411                      for (; i < lengthPrint; i++)
     10412                        fprintf(fp, " ");
     10413                      CoinConvertDouble(5,2,primalColumnSolution[iColumn],
     10414                                        outputValue);
     10415                      fprintf(fp,"  %s\n",outputValue);
     10416                    }
     10417                  }
    1032510418                }
    1032610419                if (fp != stdout)
  • stable/2.10/README.md

    r2534 r2545  
    7272
    7373
    74     /path/to/coinbrew fetch --mainProj=Cbc
    75     /path/to/coinbrew build --mainProj=Cbc --test
    76     /path/to/coinbrew install --mainProj=Cbc
     74    /path/to/coinbrew fetch --main-proj=Cbc
     75    /path/to/coinbrew build --main-proj=Cbc --test
     76    /path/to/coinbrew install --main-proj=Cbc
    7777
    7878
Note: See TracChangeset for help on using the changeset viewer.