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

allow heuristics to see if integers are 'optional'

File:
1 edited

Legend:

Unmodified
Added
Removed
  • 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++;
Note: See TracChangeset for help on using the changeset viewer.