Changeset 2280


Ignore:
Timestamp:
Jun 14, 2016 10:39:54 AM (2 years ago)
Author:
forrest
Message:

allow heuristics to see if integers are 'optional'

Location:
trunk/Cbc/src
Files:
17 edited

Legend:

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

    r2161 r2280  
    12511251                    OsiSolverInterface * solver3 = solver2->clone();
    12521252                    for (int i = 0; i < numberColumns; i++) {
    1253                         if (solver3->isInteger(i)) {
     1253                        if (isHeuristicInteger(solver3,i)) {
    12541254                            int k = which[i];
    12551255                            double value = inputSolution_[k];
     
    12671267                        OsiSolverInterface * solver4 = solver2->clone();
    12681268                        for (int i = 0; i < numberColumns; i++) {
    1269                             if (solver4->isInteger(i)) {
     1269                            if (isHeuristicInteger(solver4,i)) {
    12701270                                int k = which[i];
    12711271                                double value = floor(inputSolution_[k] + 0.5);
     
    12831283                            const double * solution = solver4->getColSolution();
    12841284                            for (int i = 0; i < numberColumns; i++) {
    1285                                 if (solver4->isInteger(i)) {
     1285                                if (isHeuristicInteger(solver4,i)) {
    12861286                                    double value = floor(solution[i] + 0.5);
    12871287                                    if (fabs(value - solution[i]) > 1.0e-6)
     
    14941494            bool good = true;
    14951495            for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
    1496                 if (solverC->isInteger(iColumn)) {
     1496                if (isHeuristicInteger(solverC,iColumn)) {
    14971497                    if (lower[iColumn] > lowerC[iColumn] &&
    14981498                            upper[iColumn] < upperC[iColumn]) {
     
    15091509                int n = 0;
    15101510                for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
    1511                     if (solverC->isInteger(iColumn)) {
     1511                    if (isHeuristicInteger(solverC,iColumn)) {
    15121512                        if (lower[iColumn] == upperC[iColumn]) {
    15131513                            rhs += lower[iColumn];
     
    20752075
    20762076    double penalty = 0.0;
    2077     const char * integerType = model_->integerType();
    20782077    // see if feasible - just using singletons
    20792078    for (i = 0; i < numberRows; i++) {
     
    21102109                            double distance = absInfeasibility / absElement;
    21112110                            double thisCost = -direction * objective[iColumn] * distance;
    2112                             if (integerType[iColumn]) {
     2111                            if (isHeuristicInteger(solver,iColumn)) {
    21132112                                distance = ceil(distance - useTolerance);
    21142113                                if (currentValue - distance >= lowerValue - useTolerance) {
     
    21352134                            double distance = absInfeasibility / absElement;
    21362135                            double thisCost = direction * objective[iColumn] * distance;
    2137                             if (integerType[iColumn]) {
     2136                            if (isHeuristicInteger(solver,iColumn)) {
    21382137                                distance = ceil(distance - 1.0e-7);
    21392138                                assert (currentValue - distance <= upperValue + useTolerance);
     
    21712170        int iColumn;
    21722171        for (iColumn = 0; iColumn < numberColumns; iColumn++) {
    2173             if (integerType[iColumn])
     2172            if (isHeuristicInteger(solver,iColumn))
    21742173                continue;
    21752174            double currentValue = newSolution[iColumn];
     
    23202319            numberPasses++;
    23212320            for (iColumn = 0; iColumn < numberColumns; iColumn++) {
    2322                 bool isInteger = (integerType[iColumn] != 0);
     2321                bool isInteger = isHeuristicInteger(solver,iColumn);
    23232322                double currentValue = newSolution[iColumn];
    23242323                double lowerValue = lower[iColumn];
     
    26522651        int nCandidate = 0;
    26532652        for (iColumn = 0; iColumn < numberColumns; iColumn++) {
    2654             bool isInteger = (integerType[iColumn] != 0);
     2653            bool isInteger = isHeuristicInteger(solver,iColumn);
    26552654            if (isInteger) {
    26562655                double currentValue = newSolution[iColumn];
  • trunk/Cbc/src/CbcHeuristic.hpp

    r2094 r2280  
    1717
    1818class CbcModel;
    19 
     19#ifdef COIN_HAS_CLP
     20#include "OsiClpSolverInterface.hpp"
     21#endif
    2022//#############################################################################
    2123
     
    302304        return numCouldRun_;
    303305    }
     306    /// Is it integer for heuristics?
     307#ifdef COIN_HAS_CLP
     308  inline bool isHeuristicInteger(const OsiSolverInterface * solver, int iColumn) const
     309  {
     310    const OsiClpSolverInterface * clpSolver
     311    = dynamic_cast<const OsiClpSolverInterface *> (solver);
     312    if (clpSolver)
     313        return clpSolver->isHeuristicInteger(iColumn);
     314      else
     315        return solver->isInteger(iColumn);
     316  }
     317#else
     318  inline bool isHeuristicInteger(const OsiSolverInterface * solver, int iColumn)
     319  { return solver->isInteger(iColumn);}
     320#endif
    304321    /*! \brief Clone, but ...
    305322
  • trunk/Cbc/src/CbcHeuristicDive.cpp

    r2184 r2280  
    99#endif
    1010
    11 #include "CbcHeuristicDive.hpp"
    1211#include "CbcStrategy.hpp"
    1312#include "CbcModel.hpp"
     
    2019#include "OsiClpSolverInterface.hpp"
    2120#endif
     21#include "CbcHeuristicDive.hpp"
    2222
    2323//#define DIVE_FIX_BINARY_VARIABLES
     
    389389        random[i] = randomNumberGenerator_.randomDouble() + 0.3;
    390390        int iColumn = integerVariable[i];
     391        if (!isHeuristicInteger(solver,iColumn))
     392          continue;
    391393        back[iColumn]=i;
    392394        double value = newSolution[iColumn];
     
    433435            for (int i = 0; i < numberIntegers; i++) {
    434436                int iColumn = integerVariable[i];
     437                if (!isHeuristicInteger(solver,iColumn))
     438                  continue;
    435439                double value = newSolution[iColumn];
    436440                if (fabs(floor(value + 0.5) - value) > integerTolerance) {
     
    456460                  for (int i = 0; i < numberIntegers; i++) {
    457461                    int iColumn = integerVariable[i];
     462                    if (!isHeuristicInteger(solver,iColumn))
     463                      continue;
    458464                    double value = newSolution[iColumn];
    459465                    if (fabs(floor(value + 0.5) - value) > integerTolerance) {
     
    476482                  for (i = 0; i < numberIntegers; i++) {
    477483                    int iColumn = integerVariable[i];
     484                    if (!isHeuristicInteger(solver,iColumn))
     485                      continue;
    478486                    double value = newSolution[bestColumn];
    479487                    if (fabs(floor(value + 0.5) - value) > integerTolerance) {
     
    620628            for (int i = 0; i < numberIntegers; i++) {
    621629                int iColumn = integerVariable[i];
     630                if (!isHeuristicInteger(solver,iColumn))
     631                  continue;
    622632                if (upper[iColumn] > lower[iColumn]) {
    623633                    numberFree++;
     
    659669            for (int i = 0; i < numberIntegers; i++) {
    660670                int iColumn = integerVariable[i];
     671                if (!isHeuristicInteger(solver,iColumn))
     672                  continue;
    661673                if (upper[iColumn] > lower[iColumn]) {
    662674                    if (priority_) {
     
    787799            for (int i = 0; i < numberIntegers; i++) {
    788800              int iColumn = integerVariable[i];
     801              if (!isHeuristicInteger(solver,iColumn))
     802                continue;
    789803              double value = newSolution[iColumn];
    790804              double away = fabs(floor(value + 0.5) - value);
     
    931945        for (int i = 0; i < numberIntegers; i++) {
    932946            int iColumn = integerVariable[i];
     947            if (!isHeuristicInteger(solver,iColumn))
     948              continue;
    933949            double value = newSolution[iColumn];
    934950            double away = fabs(floor(value + 0.5) - value);
     
    10661082      for (int i = 0; i < numberIntegers; i++) {
    10671083        int iColumn = integerVariable[i];
     1084        if (!isHeuristicInteger(solver,iColumn))
     1085          continue;
    10681086        double value = newSolution[iColumn];
    10691087        if (fabs(floor(value + 0.5) - value) > integerTolerance) {
     
    12791297    const int * row = matrix_.getIndices();
    12801298    const CoinBigIndex * columnStart = matrix_.getVectorStarts();
     1299    OsiSolverInterface * solver = model_->solver();
    12811300    const int * columnLength = matrix_.getVectorLengths();
    1282     const double * rowLower = model_->solver()->getRowLower();
    1283     const double * rowUpper = model_->solver()->getRowUpper();
     1301    const double * rowLower = solver->getRowLower();
     1302    const double * rowUpper = solver->getRowUpper();
    12841303    for (int i = 0; i < numberIntegers; i++) {
    12851304        int iColumn = integerVariable[i];
     1305        if (!isHeuristicInteger(solver,iColumn))
     1306          continue;
    12861307        int down = 0;
    12871308        int up = 0;
     
    13291350    const int numberRows = matrixByRow_.getNumRows();
    13301351    const int numberCols = matrixByRow_.getNumCols();
    1331 
    1332     const double * lower = model_->solver()->getColLower();
    1333     const double * upper = model_->solver()->getColUpper();
    1334     const double * rowLower = model_->solver()->getRowLower();
    1335     const double * rowUpper = model_->solver()->getRowUpper();
     1352   
     1353    OsiSolverInterface * solver = model_->solver();
     1354    const double * lower = solver->getColLower();
     1355    const double * upper = solver->getColUpper();
     1356    const double * rowLower = solver->getRowLower();
     1357    const double * rowUpper = solver->getRowUpper();
    13361358
    13371359    //  const char * integerType = model_->integerType();
     
    13401362    //  const int numberIntegers = model_->numberIntegers();
    13411363    //  const int * integerVariable = model_->integerVariable();
    1342     const double * objective = model_->solver()->getObjCoefficients();
     1364    const double * objective = solver->getObjCoefficients();
    13431365
    13441366    // vector to store the row number of variable bound rows
     
    13531375        for (int k = rowStart[i]; k < rowStart[i] + rowLength[i]; k++) {
    13541376            int iColumn = column[k];
    1355             if (model_->solver()->isInteger(iColumn) &&
     1377            if (isHeuristicInteger(solver,iColumn) &&
    13561378                    lower[iColumn] == 0.0 && upper[iColumn] == 1.0 &&
    13571379                    objective[iColumn] == 0.0 &&
     
    13591381                    positiveBinary < 0)
    13601382                positiveBinary = iColumn;
    1361             else if (model_->solver()->isInteger(iColumn) &&
     1383            else if (isHeuristicInteger(solver,iColumn) &&
    13621384                     lower[iColumn] == 0.0 && upper[iColumn] == 1.0 &&
    13631385                     objective[iColumn] == 0.0 &&
     
    14641486    for (int i = 0 ; i < numberIntegers ; i++) {
    14651487        int iColumn = integerVariable[i] ;
     1488        if (!isHeuristicInteger(solver,iColumn))
     1489          continue;
    14661490        double djValue = direction * reducedCost[iColumn] ;
    14671491        if (upper[iColumn] - lower[iColumn] > integerTolerance) {
     
    15471571    for (int i = 0; i < numberIntegers; i++) {
    15481572        int iColumn = integerVariable[i];
     1573        if (!isHeuristicInteger(solver,iColumn))
     1574          continue;
    15491575        if (upper[iColumn] > lower[iColumn]) {
    15501576            numberFree++;
  • trunk/Cbc/src/CbcHeuristicDiveCoefficient.cpp

    r2094 r2280  
    8686    for (int i = 0; i < numberIntegers; i++) {
    8787        int iColumn = integerVariable[i];
     88        if (!isHeuristicInteger(solver,iColumn))
     89          continue;
    8890        double value = newSolution[iColumn];
    8991        double fraction = value - floor(value);
  • trunk/Cbc/src/CbcHeuristicDiveFractional.cpp

    r2093 r2280  
    8181    for (int i = 0; i < numberIntegers; i++) {
    8282        int iColumn = integerVariable[i];
     83        if (!isHeuristicInteger(solver,iColumn))
     84          continue;
    8385        double value = newSolution[iColumn];
    8486        double fraction = value - floor(value);
  • trunk/Cbc/src/CbcHeuristicDiveGuided.cpp

    r2093 r2280  
    9393    for (int i = 0; i < numberIntegers; i++) {
    9494        int iColumn = integerVariable[i];
     95        if (!isHeuristicInteger(solver,iColumn))
     96          continue;
    9597        double value = newSolution[iColumn];
    9698        double fraction = value - floor(value);
  • trunk/Cbc/src/CbcHeuristicDiveLineSearch.cpp

    r2093 r2280  
    8484    for (int i = 0; i < numberIntegers; i++) {
    8585        int iColumn = integerVariable[i];
     86        if (!isHeuristicInteger(solver,iColumn))
     87          continue;
    8688        double rootValue = rootNodeLPSol[iColumn];
    8789        double value = newSolution[iColumn];
  • trunk/Cbc/src/CbcHeuristicDivePseudoCost.cpp

    r2093 r2280  
    8989    for (int i = 0; i < numberIntegers; i++) {
    9090        int iColumn = integerVariable[i];
     91        if (!isHeuristicInteger(solver,iColumn))
     92          continue;
    9193        double rootValue = rootNodeLPSol[iColumn];
    9294        double value = newSolution[iColumn];
     
    218220    for (int i = 0; i < numberIntegers; i++) {
    219221        int iColumn = integerVariable[i];
     222        if (!isHeuristicInteger(solver,iColumn))
     223          continue;
    220224        if (upper[iColumn] > lower[iColumn]) {
    221225            numberFree++;
  • trunk/Cbc/src/CbcHeuristicDiveVectorLength.cpp

    r2093 r2280  
    8585    for (int i = 0; i < numberIntegers; i++) {
    8686        int iColumn = integerVariable[i];
     87        if (!isHeuristicInteger(solver,iColumn))
     88          continue;
    8789        double value = newSolution[iColumn];
    8890        double fraction = value - floor(value);
  • trunk/Cbc/src/CbcHeuristicFPump.cpp

    r2146 r2280  
    216216// Returns 1 if solution, 0 if not
    217217int
    218 CbcHeuristicFPump::solution(double & solutionValue,
     218CbcHeuristicFPump::solutionInternal(double & solutionValue,
    219219                            double * betterSolution)
    220220{
     
    286286    double cutoff;
    287287    model_->solver()->getDblParam(OsiDualObjectiveLimit, cutoff);
     288    double realCutoff=cutoff;
     289    bool secondMajorPass=false;
    288290    double direction = model_->solver()->getObjSense();
    289291    cutoff *= direction;
     
    336338        assert(integerObject || integerObject2);
    337339#endif
     340#ifdef COIN_HAS_CLP
     341        if (!isHeuristicInteger(model_->solver(),iColumn))
     342          continue;
     343#endif
    338344        double value = initialSolution[iColumn];
    339345        double nearest = floor(value + 0.5);
     
    370376        for (i = 0; i < numberIntegers; i++) {
    371377            int iColumn = integerVariableOrig[i];
     378#ifdef COIN_HAS_CLP
     379            if (!isHeuristicInteger(model_->solver(),iColumn))
     380              continue;
     381#endif
    372382            if (upper[iColumn] - lower[iColumn] < 1.000001)
    373383                integerVariable[j++] = iColumn;
     
    476486    double artificialFactor = 0.00001;
    477487    // also try rounding!
    478     double * roundingSolution = new double[numberColumns];
    479     double roundingObjective = solutionValue;
     488    double * roundingSolution = new double[2*numberColumns];
     489    double roundingObjective = realCutoff;
    480490    CbcRounding roundingHeuristic(*model_);
    481491    int dualPass = 0;
     
    807817                randomNumberGenerator_.setSeed(987654321);
    808818            }
     819#ifdef COIN_HAS_CLP
     820            {
     821              OsiClpSolverInterface * clpSolver
     822                = dynamic_cast<OsiClpSolverInterface *> (clonedSolver);
     823              //printf("real cutoff %g fake %g - second pass %c\n",realCutoff,cutoff,
     824              //     secondMajorPass ? 'Y' : 'N');
     825              if (clpSolver && (((accumulate_&16) != 0) ||
     826                                ((accumulate_&8)!=0 && secondMajorPass))) {
     827                // try rounding heuristic
     828                OsiSolverInterface * saveSolver = model_->swapSolver(clonedSolver);
     829                ClpSimplex * simplex = clpSolver->getModelPtr();
     830                double * solverSolution = simplex->primalColumnSolution();
     831                memcpy(solverSolution,solution,numberColumns*sizeof(double));
     832                // Compute using dot product
     833                double newSolutionValue = -saveOffset;
     834                for (  i = 0 ; i < numberColumns ; i++ )
     835                  newSolutionValue += saveObjective[i] * solution[i];
     836                simplex->setObjectiveValue(newSolutionValue);
     837                clpSolver->setObjective(saveObjective);
     838                CbcRounding heuristic1(*model_);
     839                heuristic1.setHeuristicName("rounding in feaspump!");
     840                heuristic1.setWhen(1);
     841                newSolutionValue=realCutoff;
     842                int ifSolR = heuristic1.solution(newSolutionValue,
     843                                                 roundingSolution+numberColumns);
     844                model_->swapSolver(saveSolver);
     845                if (ifSolR&&newSolutionValue<roundingObjective) {
     846                  roundingObjective=newSolutionValue;
     847                  //printf("rounding obj of %g?\n", roundingObjective);
     848                  memcpy(roundingSolution,roundingSolution+numberColumns,
     849                         numberColumns*sizeof(double));
     850                }
     851              }
     852            }
     853#endif
    809854            returnCode = rounds(solver, newSolution,/*saveObjective,*/
    810855                                numberIntegers, integerVariable,
     
    817862            }
    818863            numberPasses++;
     864            if (roundingObjective<realCutoff) {
     865              if (returnCode) {
     866                newSolutionValue = -saveOffset;
     867                for (  i = 0 ; i < numberColumns ; i++ )
     868                    newSolutionValue += saveObjective[i] * newSolution[i];
     869              } else {
     870                newSolutionValue = COIN_DBL_MAX;
     871              }
     872              if (roundingObjective<newSolutionValue&&false) {
     873                returnCode=1;
     874                memcpy(newSolution,roundingSolution,
     875                       numberColumns*sizeof(double));
     876              }
     877            }
    819878            if (returnCode) {
    820879                // SOLUTION IS INTEGER
     
    841900                        for (i = 0; i < numberIntegersOrig; i++) {
    842901                            int iColumn = integerVariableOrig[i];
     902#ifdef COIN_HAS_CLP
     903                            if (!isHeuristicInteger(solver,iColumn))
     904                              continue;
     905#endif
    843906                            double value = floor(newSolution[iColumn] + 0.5);
    844907                            if (solver->isBinary(iColumn)) {
     
    932995                                }
    933996                                newSolutionValue += objective[iColumn] * newSolution[iColumn];
    934                                 if (solver->isInteger(iColumn)) {
     997                                if (isHeuristicInteger(solver,iColumn)) {
    935998                                  double intValue = floor(value+0.5);
    936999                                  if (fabs(value-intValue)>largestAway) {
     
    9931056                                    model_->setBestSolution(saveOldSolution, numberColumns, saveObjectiveValue);
    9941057                                delete [] saveOldSolution;
     1058                                realCutoff = model_->getMinimizationObjValue();
    9951059                            }
    9961060                            if (action == 0 || model_->maximumSecondsReached()) {
     
    11561220                        continue;
    11571221                    // deal with fixed variables (i.e., upper=lower)
    1158                     if (fabs(lower[iColumn] - upper[iColumn]) < primalTolerance || !solver->isInteger(iColumn)) {
     1222                    if (fabs(lower[iColumn] - upper[iColumn]) < primalTolerance || !isHeuristicInteger(solver,iColumn)) {
    11591223                        //if (lower[iColumn] > 1. - primalTolerance) solver->setObjCoeff(iColumn,-costValue);
    11601224                        //else                                       solver->setObjCoeff(iColumn,costValue);
     
    13181382                                for (i = 0; i < numberIntegersOrig; i++) {
    13191383                                    int iColumn = integerVariableOrig[i];
     1384#ifdef COIN_HAS_CLP
     1385                                    if (!isHeuristicInteger(solver,iColumn))
     1386                                      continue;
     1387#endif
    13201388#ifdef RAND_RAND
    13211389                                    if (nChanged > numberChanged)
     
    13411409                                    for (i = 0; i < numberIntegersOrig; i++) {
    13421410                                        int iColumn = integerVariableOrig[i];
     1411#ifdef COIN_HAS_CLP
     1412                                        if (!isHeuristicInteger(solver,iColumn))
     1413                                          continue;
     1414#endif
    13431415                                        if (objective[iColumn] > 0.0) {
    13441416                                            if (basis->getStructStatus(iColumn) ==
     
    13951467                        const double * newSolution = solver->getColSolution();
    13961468                        for (int iColumn = 0 ; iColumn < numberColumns ; iColumn++ ) {
    1397                             if (solver->isInteger(iColumn)) {
     1469                            if (isHeuristicInteger(solver,iColumn)) {
    13981470                                double value = newSolution[iColumn];
    13991471                                double nearest = floor(value + 0.5);
     
    14591531                            for (  i = 0 ; i < numberColumns ; i++ ) {
    14601532                                double value = newSolution[i];
    1461                                 if (solver->isInteger(i)) {
     1533                                if (isHeuristicInteger(solver,i)) {
    14621534                                    double nearest = floor(value + 0.5);
    14631535                                    if (fabs(value - nearest) > 1.0e-6) {
     
    16721744                        const double * newSolution = solver->getColSolution();
    16731745                        for (  i = 0 ; i < numberColumns ; i++ ) {
    1674                             if (solver->isInteger(i)) {
     1746                            if (isHeuristicInteger(solver,i)) {
    16751747                                double value = newSolution[i];
    16761748                                double nearest = floor(value + 0.5);
     
    17401812                    for (i = 0; i < numberIntegersOrig; i++) {
    17411813                        int iColumn = integerVariableOrig[i];
     1814#ifdef COIN_HAS_CLP
     1815                        if (!isHeuristicInteger(solver,iColumn))
     1816                          continue;
     1817#endif
    17421818                        if (objective[iColumn] > 0.0)
    17431819                            closestSolution[i] = 0;
     
    18571933            solutionValue = roundingObjective;
    18581934            newSolutionValue = solutionValue;
     1935            realCutoff=solutionValue-1.0e-5;
    18591936            memcpy(betterSolution, roundingSolution, numberColumns*sizeof(double));
    18601937            solutionFound = true;
     
    19031980                for (i = 0; i < numberIntegersOrig; i++) {
    19041981                    int iColumn = integerVariableOrig[i];
     1982#ifdef COIN_HAS_CLP
     1983                    if (!isHeuristicInteger(newSolver,iColumn))
     1984                      continue;
     1985#endif
    19051986                    //const OsiObject * object = model_->object(i);
    19061987                    //double originalLower;
     
    19342015                if (fixContinuous) {
    19352016                    for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
    1936                         if (!newSolver->isInteger(iColumn) && usedColumn[iColumn] <= allowedPass) {
     2017                        if (!isHeuristicInteger(newSolver,iColumn) && usedColumn[iColumn] <= allowedPass) {
    19372018                            double value = lastSolution[iColumn];
    19382019                            if (value < colLower[iColumn] + 1.0e-8) {
     
    20422123                    const double * obj = newSolver->getObjCoefficients();
    20432124                    for (int i = 0 ; i < numberColumns ; i++ ) {
    2044                         if (newSolver->isInteger(i)) {
     2125                        if (isHeuristicInteger(newSolver,i)) {
    20452126                            double value = newSolution[i];
    20462127                            double nearest = floor(value + 0.5);
     
    20672148                        for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
    20682149                            double value = newSolution[iColumn];
    2069                             if (newSolver->isInteger(iColumn)) {
     2150                            if (isHeuristicInteger(newSolver,iColumn)) {
    20702151                                value = floor(newSolution[iColumn] + 0.5);
    20712152                                newSolver->setColLower(iColumn, value);
     
    21502231                                    const double * solution = newSolver->getColSolution();
    21512232                                    for (int  i = 0 ; i < numberColumns ; i++ ) {
    2152                                         if (newSolver->isInteger(i)) {
     2233                                        if (isHeuristicInteger(newSolver,i)) {
    21532234                                            double value = solution[i];
    21542235                                            double nearest = floor(value + 0.5);
     
    21922273                        const double * upper = model_->solver()->getColUpper();
    21932274                        for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
    2194                             if (newSolver->isInteger(iColumn)) {
     2275                            if (isHeuristicInteger(newSolver,iColumn)) {
    21952276                                double value = floor(newSolution[iColumn] + 0.5);
    21962277                                newSolver->setColLower(iColumn, value);
     
    22532334        if (solutionFound) finalReturnCode = 1;
    22542335        cutoff = CoinMin(cutoff, solutionValue - model_->getCutoffIncrement());
     2336        realCutoff = cutoff;
    22552337        if (numberTries >= maximumRetries_ || !solutionFound || exitAll || cutoff < continuousObjectiveValue + 1.0e-7) {
    22562338            break;
     
    22722354                break;
    22732355            sprintf(pumpPrint, "Round again with cutoff of %g", cutoff);
     2356            secondMajorPass=true;
    22742357            model_->messageHandler()->message(CBC_FPUMP1, model_->messages())
    22752358            << pumpPrint
     
    23012384        for (i = 0; i < numberIntegersOrig; i++) {
    23022385            int iColumn = integerVariableOrig[i];
     2386#ifdef COIN_HAS_CLP
     2387            if (!isHeuristicInteger(newSolver,iColumn))
     2388              continue;
     2389#endif
    23032390            int direction = closestSolution[i];
    23042391            closestSolution[i] = iColumn;
     
    23832470
    23842471/**************************END MAIN PROCEDURE ***********************************/
     2472/* If general integers then adds variables to turn into binaries round
     2473   solution
     2474*/
     2475int
     2476CbcHeuristicFPump::solution(double & objectiveValue, double * newSolution)
     2477{
     2478  double * newSolution2=NULL;
     2479  double objective2=COIN_DBL_MAX;
     2480  int returnCode2=0;
     2481  int oddGeneral = (accumulate_&(32|64|128))>>5;
     2482  if (oddGeneral) {
     2483    int maxAround=2;
     2484    bool fixSatisfied=false;
     2485    // clone solver and modify
     2486    OsiSolverInterface * solver = cloneBut(2); // wasmodel_->solver()->clone();
     2487    double cutoff;
     2488    model_->solver()->getDblParam(OsiDualObjectiveLimit, cutoff);
     2489    int numberColumns = model_->getNumCols();
     2490    int numberIntegers = model_->numberIntegers();
     2491    const int * integerVariableOrig = model_->integerVariable();
     2492    int general = 0;
     2493    int nAdd=0;
     2494    const double * lower = solver->getColLower();
     2495    const double * upper = solver->getColUpper();
     2496    const double * initialSolution = solver->getColSolution();
     2497    // we may be being clever so make sure solver lines up wuth model
     2498    for (int i = 0; i < numberColumns; i++)
     2499      solver->setContinuous(i);
     2500    for (int i = 0; i < numberIntegers; i++) {
     2501      int iColumn = integerVariableOrig[i];
     2502#ifdef COIN_HAS_CLP
     2503      if (!isHeuristicInteger(solver,iColumn))
     2504        continue;
     2505#endif
     2506      double value = initialSolution[iColumn];
     2507      double nearest = floor(value + 0.5);
     2508      if (upper[iColumn] - lower[iColumn] > 1.000001) {
     2509        if (fabs(value-nearest)<1.0e-6&&fixSatisfied) {
     2510          solver->setColLower(iColumn,nearest);
     2511          solver->setColUpper(iColumn,nearest);
     2512        } else {
     2513          general++;
     2514          int up=static_cast<int>(upper[iColumn]);
     2515          int lo=static_cast<int>(lower[iColumn]);
     2516          int near=static_cast<int>(nearest);
     2517          up = CoinMin(up,near+maxAround);
     2518          lo = CoinMax(lo,near-maxAround);
     2519          solver->setColLower(iColumn,lo);
     2520          solver->setColUpper(iColumn,up);
     2521          int n=up-lo;
     2522          // 1 - 1, 2,3 - 2, 4567 - 3
     2523          while (n) {
     2524            nAdd++;
     2525            n = n>>1;
     2526          }
     2527        }
     2528      } else {
     2529        solver->setInteger(iColumn);
     2530      }
     2531    }
     2532    if (!general) {
     2533      delete solver;
     2534    }
     2535    if (general) {
     2536      CbcModel * saveModel = model_;
     2537      int * addStart = new int[nAdd+1];
     2538      memset(addStart,0,(nAdd+1)*sizeof(int));
     2539      int * addIndex = new int[general+nAdd];
     2540      double * addElement = new double[general+nAdd];
     2541      double * addLower = new double[nAdd];
     2542      double * addUpper = new double[nAdd];
     2543      for (int i=0;i<nAdd;i++) {
     2544        addLower[i]=0.0;
     2545        addUpper[i]=1.0;
     2546      }
     2547      solver->addCols(nAdd, addStart, NULL, NULL, addLower, addUpper, NULL);
     2548      lower = solver->getColLower();
     2549      upper = solver->getColUpper();
     2550      // now rows
     2551      nAdd = 0;
     2552      int nEl = 0;
     2553      int nAddRow = 0;
     2554      for (int i = 0; i < numberIntegers; i++) {
     2555        int iColumn = integerVariableOrig[i];
     2556#ifdef COIN_HAS_CLP
     2557        if (!isHeuristicInteger(solver,iColumn))
     2558          continue;
     2559#endif
     2560        if (upper[iColumn] - lower[iColumn] > 1.000001) {
     2561          int up=static_cast<int>(upper[iColumn]);
     2562          int lo=static_cast<int>(lower[iColumn]);
     2563          addLower[nAddRow] = lo;
     2564          addUpper[nAddRow] = lo;
     2565          addIndex[nEl] = iColumn;
     2566          addElement[nEl++] = 1.0;
     2567          int n=up-lo;
     2568          // 1 - 1, 2,3 - 2, 4567 - 3
     2569          int el=1;
     2570          while (n) {
     2571            addIndex[nEl] = numberColumns+nAdd;
     2572            addElement[nEl++] = -el;
     2573            nAdd++;
     2574            n = n>>1;
     2575            el = el<<1;
     2576          }
     2577          nAddRow++;
     2578          addStart[nAddRow]=nEl;
     2579        }
     2580      }
     2581      for (int i=0;i<nAdd;i++)
     2582        solver->setInteger(i+numberColumns);
     2583      solver->addRows(nAddRow, addStart, addIndex, addElement, addLower, addUpper);
     2584      delete [] addStart;
     2585      delete [] addIndex;
     2586      delete [] addElement;
     2587      delete [] addLower;
     2588      delete [] addUpper;
     2589      solver->resolve();
     2590      solver->writeMps("test");
     2591      // new CbcModel
     2592      model_=new CbcModel(*solver);
     2593      model_->findIntegers(true);
     2594      // set cutoff
     2595      solver->setDblParam(OsiDualObjectiveLimit, cutoff);
     2596      model_->setCutoff(cutoff);
     2597      newSolution2 = new double [numberColumns+nAdd];
     2598      objective2=objectiveValue;
     2599      returnCode2=solutionInternal(objective2,newSolution2);
     2600      delete solver;
     2601      delete model_;
     2602      model_=saveModel;
     2603    }
     2604  }
     2605  int returnCode=solutionInternal(objectiveValue,newSolution);
     2606  if (returnCode2&&false) {
     2607    int numberColumns=model_->getNumCols();
     2608    memcpy(newSolution,newSolution2,numberColumns*sizeof(double));
     2609  }
     2610  delete [] newSolution2;
     2611  return returnCode;
     2612}
    23852613
    23862614// update model
     
    24332661                for (CoinBigIndex k = rowStart[i]; k < rowStart[i] + rowLength[i]; k++) {
    24342662                    int iColumn = column[k];
    2435                     if (elementByRow[k] != 1.0 || !solver->isInteger(iColumn)) {
     2663                    if (elementByRow[k] != 1.0 || !isHeuristicInteger(solver,iColumn)) {
    24362664                        cover = false;
    24372665                        break;
     
    24792707            for (CoinBigIndex k = rowStart[i]; k < rowStart[i] + rowLength[i]; k++) {
    24802708                int iColumn = column[k];
    2481                 if (elementByRow[k] != 1.0 || !solver->isInteger(iColumn)) {
     2709                if (elementByRow[k] != 1.0 || !isHeuristicInteger(solver,iColumn)) {
    24822710                    cover = false;
    24832711                    break;
     
    27002928            // First improve by moving continuous ones
    27012929            for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
    2702                 if (!solver->isInteger(iColumn)) {
     2930                if (!isHeuristicInteger(solver,iColumn)) {
    27032931                    double solValue = solution[iColumn];
    27042932                    double thetaUp = columnUpper[iColumn] - solValue;
  • trunk/Cbc/src/CbcHeuristicFPump.hpp

    r1573 r2280  
    6565    virtual int solution(double & objectiveValue,
    6666                         double * newSolution);
    67 
     67    /** If general integers then adds variables to turn into binaries round
     68      solution
     69    */
     70    int solutionGeneral(double & objectiveValue, double * newSolution,
     71                        int maxAround=1,bool fixSatisfied=false);
    6872    /// Set maximum Time (default off) - also sets starttime to current
    6973    void setMaximumTime(double value);
     
    249253         reuse - refers to initial solve after adding in new "cut"
    250254         If we add 8 then can run after initial cuts (if no solution)
     255         16 - extra rounding
     256         32,64,128 - create binaries for general
    251257    */
    252258    int accumulate_;
     
    271277               /*bool roundExpensive=false,*/
    272278               double downValue = 0.5, int *flip = 0);
     279    /// Does real work
     280  int solutionInternal(double & objectiveValue, double * newSolution);
    273281    /* note for eagle eyed readers.
    274282       when_ can now be exotic -
  • trunk/Cbc/src/CbcHeuristicGreedy.cpp

    r2216 r2280  
    172172        CoinBigIndex j;
    173173        double value = solution[iColumn];
    174         if (solver->isInteger(iColumn)) {
     174        if (isHeuristicInteger(solver,iColumn)) {
    175175            // Round down integer
    176176            if (fabs(floor(value + 0.5) - value) < integerTolerance) {
     
    201201            CoinBigIndex j;
    202202            double value = solution[iColumn];
    203             if (solver->isInteger(iColumn)) {
     203            if (isHeuristicInteger(solver,iColumn)) {
    204204                // but round up if no activity
    205205                if (roundup && value >= 0.499999 && !newSolution[iColumn]) {
     
    246246            double value = newSolution[iColumn];
    247247            double cost = direction * objective[iColumn];
    248             if (solver->isInteger(iColumn)) {
     248            if (isHeuristicInteger(solver,iColumn)) {
    249249                // use current upper or original upper
    250250                if (value + 0.99 < originalUpper[iColumn]) {
     
    593593        CoinBigIndex j;
    594594        double value = solution[iColumn];
    595         if (solver->isInteger(iColumn)) {
     595        if (isHeuristicInteger(solver,iColumn)) {
    596596            // Round down integer
    597597            if (fabs(floor(value + 0.5) - value) < integerTolerance) {
     
    623623            CoinBigIndex j;
    624624            double value = solution[iColumn];
    625             if (solver->isInteger(iColumn)) {
     625            if (isHeuristicInteger(solver,iColumn)) {
    626626                // but round up if no activity
    627627                if (roundup && value >= 0.6 && !newSolution[iColumn]) {
     
    669669            double value = newSolution[iColumn];
    670670            double cost = direction * objective[iColumn];
    671             if (solver->isInteger(iColumn)) {
     671            if (isHeuristicInteger(solver,iColumn)) {
    672672                // use current upper or original upper
    673673                if (value + 0.9999 < originalUpper[iColumn]) {
     
    750750        OsiSolverInterface * newSolver = model_->continuousSolver()->clone();
    751751        for (iColumn = 0; iColumn < numberColumns; iColumn++) {
    752             if (newSolver->isInteger(iColumn))
     752            if (isHeuristicInteger(newSolver,iColumn))
    753753                newSolver->setColLower(iColumn, newSolution[iColumn]);
    754754        }
     
    10361036        int nSOS=0;
    10371037        int iSOS=-1;
    1038         if (!solver->isInteger(iColumn))
     1038        if (!isHeuristicInteger(solver,iColumn))
    10391039          good = false;
    10401040        for (j = columnStart[iColumn];
     
    18621862            CoinBigIndex j;
    18631863            int nSOS=0;
    1864             if (!solver->isInteger(iColumn))
     1864            if (!isHeuristicInteger(solver,iColumn))
    18651865              good = false;
    18661866            for (j = columnStart[iColumn];
  • trunk/Cbc/src/CbcHeuristicLocal.cpp

    r2105 r2280  
    182182    for (i = 0; i < numberIntegers; i++) {
    183183        int iColumn = integerVariable[i];
     184        if (!isHeuristicInteger(newSolver,iColumn))
     185          continue;
    184186        const OsiObject * object = model_->object(i);
    185187        // get original bounds
     
    212214        for (i = 0; i < numberIntegers; i++) {
    213215            int iColumn = integerVariable[i];
     216            if (!isHeuristicInteger(newSolver,iColumn))
     217              continue;
    214218            if (used_[iColumn]) {
    215219                which[n] = iColumn;
     
    224228        for (i = 0; i < n; i++) {
    225229            int iColumn = integerVariable[i];
     230            if (!isHeuristicInteger(newSolver,iColumn))
     231              continue;
    226232            if (used_[iColumn] <= allow) {
    227233                newSolver->setColUpper(iColumn, colLower[iColumn]);
     
    260266                double direction = newSolver->getObjSense();
    261267                for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
    262                     if (!newSolver->isInteger(iColumn)) {
     268                    if (!isHeuristicInteger(newSolver,iColumn)) {
    263269                        if (!used_[iColumn]) {
    264270                            //double djValue = dj[iColumn]*direction;
     
    275281                    int nFix2 = 0;
    276282                    for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
    277                         if (!newSolver->isInteger(iColumn)) {
     283                        if (!isHeuristicInteger(newSolver,iColumn)) {
    278284                            if (!used_[iColumn]) {
    279285                                double djValue = dj[iColumn] * direction;
     
    437443    const double * columnLower = solver->getColLower();
    438444    for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
    439         if (!solver->isInteger(iColumn)) {
     445        if (!isHeuristicInteger(solver,iColumn)) {
    440446            if (solution[iColumn] > columnLower[iColumn] + 1.0e-8)
    441447                used_[iColumn] = numberSolutions_;
     
    473479    for (i = 0; i < numberIntegers; i++) {
    474480        int iColumn = integerVariable[i];
     481        if (!isHeuristicInteger(solver,iColumn))
     482          continue;
    475483        const OsiObject * object = model_->object(i);
    476484        // get original bounds
     
    571579        int * integerVariable =
    572580          CoinCopyOfArray(model_->integerVariable(),numberIntegers);
     581#ifdef COIN_HAS_CLP
     582        OsiClpSolverInterface * clpSolver
     583          = dynamic_cast<OsiClpSolverInterface *> (model_->solver());
     584        if (clpSolver ) {
     585          // take out some integers
     586          int nn=numberIntegers;
     587          numberIntegers=0;
     588          for (int i=0;i<nn;i++) {
     589            int iColumn=integerVariable[i];
     590            if (clpSolver->isHeuristicInteger(iColumn))
     591              integerVariable[numberIntegers++]=iColumn;
     592          }
     593        }
     594#endif
    573595        if (swap>9 && numberIntegers>500) {
    574596          int type=swap/10;
     
    11471169  for (int i = 0; i < numberIntegers; i++) {
    11481170    int iColumn = integerVariable[i];
     1171    if (!isHeuristicInteger(newSolver,iColumn))
     1172      continue;
    11491173    if (fabs(solutionIn[iColumn])<1.0e-5)
    11501174      obj[iColumn]=1.0;
     
    12011225  if ((returnCode&1) != 0) {
    12021226    // redo objective
    1203     const double * obj = model_->continuousSolver()->getObjCoefficients();
     1227    OsiSolverInterface * solver = model_->continuousSolver();
     1228    const double * obj = solver->getObjCoefficients();
    12041229    solutionValue = - offset;
    12051230    int sumIncrease=0.0;
     
    12091234    for (int i=0;i<numberColumns;i++) {
    12101235      solutionValue += obj[i]*betterSolution[i];
    1211       if (model_->isInteger(i)) {
     1236      if (isHeuristicInteger(solver,i)) {
    12121237        int change=static_cast<int>(floor(solutionIn[i]-betterSolution[i]+0.5));
    12131238        if (change>0) {
     
    13601385    for (i = 0; i < numberIntegers; i++) {
    13611386        int iColumn = integerVariable[i];
     1387        if (!isHeuristicInteger(newSolver,iColumn))
     1388          continue;
    13621389        double lower = colLower[iColumn];
    13631390        double upper = colUpper[iColumn];
     
    13891416    for (i = 0; i < numberIntegers; i++) {
    13901417        int iColumn = integerVariable[i];
     1418        if (!isHeuristicInteger(newSolver,iColumn))
     1419          continue;
    13911420        double lower = colLower[iColumn];
    13921421        double upper = colUpper[iColumn];
     
    14511480        double newLower;
    14521481        double newUpper;
    1453         if (newSolver->isInteger(iColumn)) {
     1482        if (isHeuristicInteger(newSolver,iColumn)) {
    14541483            newLower = CoinMax(lower, floor(value) - 2.0);
    14551484            newUpper = CoinMin(upper, ceil(value) + 2.0);
     
    14741503                double newLower = lower;
    14751504                double newUpper = upper;
    1476                 if (newSolver->isInteger(iColumn)) {
     1505                if (isHeuristicInteger(newSolver,iColumn)) {
    14771506                    if (value < lower + 1.0e-6) {
    14781507                        nFix++;
     
    16401669        const double * solution = model_->savedSolution(k);
    16411670        for (int j = 0; j < numberColumns; j++) {
    1642             if (solver->isInteger(j)) {
     1671            if (isHeuristicInteger(solver,j)) {
    16431672                if (fixed[j] == -COIN_DBL_MAX)
    16441673                    fixed[j] = floor(solution[j] + 0.5);
     
    16501679    const double * colLower = solver->getColLower();
    16511680    for (int i = 0; i < numberColumns; i++) {
    1652         if (solver->isInteger(i)) {
     1681        if (isHeuristicInteger(solver,i)) {
    16531682            double value = fixed[i];
    16541683            if (value != COIN_DBL_MAX) {
  • trunk/Cbc/src/CbcHeuristicRINS.cpp

    r2094 r2280  
    166166        numberSolutions_ = model_->getSolutionCount();
    167167
     168        OsiSolverInterface * solver = model_->solver();
    168169        int numberIntegers = model_->numberIntegers();
    169170        const int * integerVariable = model_->integerVariable();
     
    172173        for (i = 0; i < numberIntegers; i++) {
    173174            int iColumn = integerVariable[i];
     175            if (!isHeuristicInteger(solver,iColumn))
     176              continue;
    174177            const OsiObject * object = model_->object(i);
    175178            // get original bounds
     
    223226        for (i = 0; i < numberIntegers; i++) {
    224227            int iColumn = integerVariable[i];
     228            if (!isHeuristicInteger(solver,iColumn))
     229              continue;
    225230            const OsiObject * object = model_->object(i);
    226231            // get original bounds
     
    282287                double direction = newSolver->getObjSense();
    283288                for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
    284                     if (!newSolver->isInteger(iColumn)) {
     289                    if (!isHeuristicInteger(newSolver,iColumn)) {
    285290                        double value = bestSolution[iColumn];
    286291                        if (value < colLower[iColumn] + 1.0e-8) {
     
    298303                    int nFix2 = 0;
    299304                    for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
    300                         if (!newSolver->isInteger(iColumn)) {
     305                        if (!isHeuristicInteger(newSolver,iColumn)) {
    301306                            double value = bestSolution[iColumn];
    302307                            if (value < colLower[iColumn] + 1.0e-8) {
  • trunk/Cbc/src/CbcSolver.cpp

    r2279 r2280  
    43624362                                    threshold -= 10000*highPriority;
    43634363                                  }
     4364                                  // If 1000 set then don't put obj on ne variables
     4365                                  bool moveObjective=true;
     4366                                  if (threshold>1000) {
     4367                                    moveObjective=false;
     4368                                    threshold -= 1000;
     4369                                  }
    43644370                                  const double * columnLower = solver2->getColLower();
    43654371                                  const double * columnUpper = solver2->getColUpper();
     
    44924498                                          for (int kColumn=iLast;kColumn<jColumn;kColumn++) {
    44934499                                            iColumn=which[kColumn];
    4494                                             solver2->setObjCoeff(iColumn,0.0);
     4500                                            if (moveObjective)
     4501                                              solver2->setObjCoeff(iColumn,0.0);
    44954502                                            double lowerValue=columnLower[iColumn];
    44964503                                            double upperValue=columnUpper[iColumn];
     
    45014508                                              elementValue=1.0;
    45024509                                            }
     4510                                            if (!moveObjective)
     4511                                              objectiveNew[numberDifferentObj]=0.0;
    45034512                                            columnAdd[numberElements]=iColumn;
    45044513                                            elementAdd[numberElements++]=elementValue;
     
    45464555                                                       lowerNew, upperNew,objectiveNew);
    45474556                                      // add constraints and make integer if all integer in group
     4557#ifdef COIN_HAS_CLP
     4558                                      OsiClpSolverInterface * clpSolver2
     4559                                        = dynamic_cast<OsiClpSolverInterface *> (solver2);
     4560#endif
    45484561                                      for (int iObj=0; iObj < numberDifferentObj; iObj++) {
    45494562                                        lowerNew[iObj]=0.0;
    45504563                                        upperNew[iObj]=0.0;
    45514564                                        solver2->setInteger(numberColumns+iObj);
     4565#ifdef COIN_HAS_CLP
     4566                                        if (clpSolver2)
     4567                                          clpSolver2->setOptionalInteger(numberColumns+iObj);
     4568#endif
    45524569                                      }
    45534570                                      solver2->addRows(numberDifferentObj,
  • trunk/Cbc/src/CbcSolverHeuristics.cpp

    r2105 r2280  
    12151215            int accumulate = r / 1000;
    12161216            r -= 1000 * accumulate;
    1217             if (accumulate >= 10) {
    1218                 int which = accumulate / 10;
    1219                 accumulate -= 10 * which;
     1217            if (accumulate >= 100) {
     1218                int which = accumulate / 100;
     1219                accumulate -= 100 * which;
    12201220                which--;
    12211221                // weights and factors
  • trunk/Cbc/src/CbcSymmetry.hpp

    r2207 r2280  
    222222  { return GSparse_ != NULL;}
    223223  inline int errorStatus() const
     224#ifndef NTY_TRACES
    224225  { return stats_->errstatus;}
     226#else
     227  { return 0;}
     228#endif
    225229  /**
    226230   * Methods to classify orbits.  Not horribly efficient, but gets the job done
Note: See TracChangeset for help on using the changeset viewer.