Ignore:
Timestamp:
Nov 5, 2009 10:57:25 AM (10 years ago)
Author:
forrest
Message:

Creating new stable branch 2.4 from trunk (rev 1270)

Location:
stable/2.4
Files:
1 edited
1 copied

Legend:

Unmodified
Added
Removed
  • stable/2.4

    • Property svn:externals
      •  

        old new  
        77CoinUtils         https://projects.coin-or.org/svn/CoinUtils/stable/2.5/CoinUtils
        88Cgl               https://projects.coin-or.org/svn/Cgl/stable/0.54/Cgl
        9 Clp               https://projects.coin-or.org/svn/Clp/stable/1.10/Clp
         9Clp               https://projects.coin-or.org/svn/Clp/stable/1.11/Clp
        1010Osi               https://projects.coin-or.org/svn/Osi/stable/0.100/Osi
        1111Vol               https://projects.coin-or.org/svn/Vol/stable/1.1/Vol
  • stable/2.4/Cbc/src/CbcBranchCut.cpp

    r1121 r1271  
     1/* $Id$ */
    12// Copyright (C) 2004, International Business Machines
    23// Corporation and others.  All Rights Reserved.
     
    4950// Assignment operator
    5051CbcBranchCut &
    51 CbcBranchCut::operator=( const CbcBranchCut& rhs)
     52CbcBranchCut::operator=( const CbcBranchCut& /*rhs*/)
    5253{
    5354  return *this;
     
    5859{
    5960}
    60 
    61 // Infeasibility - large is 0.5
    6261double
    63 CbcBranchCut::infeasibility(int & preferredWay) const
     62CbcBranchCut::infeasibility(const OsiBranchingInformation * /*info*/,
     63                               int &preferredWay) const
    6464{
    6565  throw CoinError("Use of base class","infeasibility","CbcBranchCut");
     
    8282CbcBranchCut::boundBranch() const
    8383{return false;}
    84 
    85 // Creates a branching object
    8684CbcBranchingObject *
    87 CbcBranchCut::createBranch(int way)
    88 {
    89   throw CoinError("Use of base class","createBranch","CbcBranchCut");
     85CbcBranchCut::createCbcBranch(OsiSolverInterface * /*solver*/,const OsiBranchingInformation * /*info*/, int /*way*/)
     86{
     87  throw CoinError("Use of base class","createCbcBranch","CbcBranchCut");
    9088  return new CbcCutBranchingObject();
    9189}
     
    198196    way_=-1;      // Swap direction
    199197  }
     198  printf("CUT %s ",(way_==-1) ? "up" : "down");
     199  cut->print();
    200200  // See if cut just fixes variables
    201201  double lb = cut->lb();
     
    431431  delete [] mark_;
    432432}
    433 // Creates a branching object
    434433CbcBranchingObject *
    435 CbcBranchToFixLots::createBranch(int way)
     434CbcBranchToFixLots::createCbcBranch(OsiSolverInterface * solver,const OsiBranchingInformation * /*info*/, int /*way*/)
    436435{
    437436  // by default way must be -1
    438   assert (way==-1);
    439   OsiSolverInterface * solver = model_->solver();
     437  //assert (way==-1);
     438  //OsiSolverInterface * solver = model_->solver();
    440439  const double * solution = model_->testSolution();
    441440  const double * lower = solver->getColLower();
     
    456455  int * sort = new int[numberColumns];
    457456  double * dsort = new double[numberColumns];
    458   int type = shallWe();
    459   assert (type);
    460   // Take clean first
    461   if (type==1) {
    462     for (i=0;i<numberIntegers;i++) {
    463       int iColumn = integerVariable[i];
    464       if (upper[iColumn]>lower[iColumn]) {
    465         if (!mark_||!mark_[iColumn]) {
    466           if(solution[iColumn]<lower[iColumn]+tolerance) {
    467             if (dj[iColumn]>djTolerance_) {
    468               dsort[nSort]=-dj[iColumn];
    469               sort[nSort++]=iColumn;
     457  if (djTolerance_!=-1.234567) {
     458    int type = shallWe();
     459    assert (type);
     460    // Take clean first
     461    if (type==1) {
     462      for (i=0;i<numberIntegers;i++) {
     463        int iColumn = integerVariable[i];
     464        if (upper[iColumn]>lower[iColumn]) {
     465          if (!mark_||!mark_[iColumn]) {
     466            if(solution[iColumn]<lower[iColumn]+tolerance) {
     467              if (dj[iColumn]>djTolerance_) {
     468                dsort[nSort]=-dj[iColumn];
     469                sort[nSort++]=iColumn;
     470              }
     471            } else if (solution[iColumn]>upper[iColumn]-tolerance) {
     472              if (dj[iColumn]<-djTolerance_) {
     473                dsort[nSort]=dj[iColumn];
     474                sort[nSort++]=iColumn;
     475              }
    470476            }
    471           } else if (solution[iColumn]>upper[iColumn]-tolerance) {
    472             if (dj[iColumn]<-djTolerance_) {
    473               dsort[nSort]=dj[iColumn];
     477          }
     478        } else {
     479          numberFixed++;
     480        }
     481      }
     482      // sort
     483      CoinSort_2(dsort,dsort+nSort,sort);
     484      nSort= CoinMin(nSort,wantedFixed-numberFixed);
     485    } else if (type<10) {
     486      int i;
     487      //const double * rowLower = solver->getRowLower();
     488      const double * rowUpper = solver->getRowUpper();
     489      // Row copy
     490      const double * elementByRow = matrixByRow_.getElements();
     491      const int * column = matrixByRow_.getIndices();
     492      const CoinBigIndex * rowStart = matrixByRow_.getVectorStarts();
     493      const int * rowLength = matrixByRow_.getVectorLengths();
     494      const double * columnLower = solver->getColLower();
     495      const double * columnUpper = solver->getColUpper();
     496      const double * solution = solver->getColSolution();
     497      int numberColumns = solver->getNumCols();
     498      int numberRows = solver->getNumRows();
     499      for (i=0;i<numberColumns;i++) {
     500        sort[i]=i;
     501        if (columnLower[i]!=columnUpper[i]){
     502          dsort[i]=1.0e100;
     503        } else {
     504          dsort[i]=1.0e50;
     505          numberFixed++;
     506        }
     507      }
     508      for (i=0;i<numberRows;i++) {
     509        double rhsValue = rowUpper[i];
     510        bool oneRow=true;
     511        // check elements
     512        int numberUnsatisfied=0;
     513        for (int j=rowStart[i];j<rowStart[i]+rowLength[i];j++) {
     514          int iColumn = column[j];
     515          double value = elementByRow[j];
     516          double solValue = solution[iColumn];
     517          if (columnLower[iColumn]!=columnUpper[iColumn]) {
     518            if (solValue<1.0-integerTolerance&&solValue>integerTolerance)
     519              numberUnsatisfied++;
     520            if (value!=1.0) {
     521              oneRow=false;
     522              break;
     523            }
     524          } else {
     525            rhsValue -= value*floor(solValue+0.5);
     526          }
     527        }
     528        if (oneRow&&rhsValue<=1.0+tolerance) {
     529          if (!numberUnsatisfied) {
     530            for (int j=rowStart[i];j<rowStart[i]+rowLength[i];j++) {
     531              int iColumn = column[j];
     532              if (dsort[iColumn]>1.0e50){
     533                dsort[iColumn]=0;
     534                nSort++;
     535              }
     536            }
     537          }
     538        }
     539      }
     540      // sort
     541      CoinSort_2(dsort,dsort+numberColumns,sort);
     542    } else {
     543      // new way
     544      for (i=0;i<numberIntegers;i++) {
     545        int iColumn = integerVariable[i];
     546        if (upper[iColumn]>lower[iColumn]) {
     547          if (!mark_||!mark_[iColumn]) {
     548            double distanceDown=solution[iColumn]-lower[iColumn];
     549            double distanceUp=upper[iColumn]-solution[iColumn];
     550            double distance = CoinMin(distanceDown,distanceUp);
     551            if (distance>0.001&&distance<0.5) {
     552              dsort[nSort]=distance;
    474553              sort[nSort++]=iColumn;
    475554            }
    476555          }
    477556        }
    478       } else {
    479         numberFixed++;
    480       }
    481     }
    482     // sort
    483     CoinSort_2(dsort,dsort+nSort,sort);
    484     nSort= CoinMin(nSort,wantedFixed-numberFixed);
    485   } else if (type<10) {
    486     int i;
    487     //const double * rowLower = solver->getRowLower();
    488     const double * rowUpper = solver->getRowUpper();
    489     // Row copy
    490     const double * elementByRow = matrixByRow_.getElements();
     557      }
     558      // sort
     559      CoinSort_2(dsort,dsort+nSort,sort);
     560      int n=0;
     561      double sum=0.0;
     562      for (int k=0;k<nSort;k++) {
     563        sum += dsort[k];
     564        if (sum<=djTolerance_)
     565          n=k;
     566        else
     567          break;
     568      }
     569      nSort = CoinMin(n,numberClean_/1000000);
     570    }
     571  } else {
     572#define FIX_IF_LESS -0.1
     573    // 3 in same row and sum <FIX_IF_LESS?
     574    int numberRows = matrixByRow_.getNumRows();
     575    const double * solution = model_->testSolution();
    491576    const int * column = matrixByRow_.getIndices();
    492577    const CoinBigIndex * rowStart = matrixByRow_.getVectorStarts();
    493578    const int * rowLength = matrixByRow_.getVectorLengths();
    494     const double * columnLower = solver->getColLower();
    495     const double * columnUpper = solver->getColUpper();
    496     const double * solution = solver->getColSolution();
    497     int numberColumns = solver->getNumCols();
    498     int numberRows = solver->getNumRows();
    499     for (i=0;i<numberColumns;i++) {
    500       sort[i]=i;
    501       if (columnLower[i]!=columnUpper[i]){
    502         dsort[i]=1.0e100;
    503       } else {
    504         dsort[i]=1.0e50;
    505         numberFixed++;
    506       }
    507     }
    508     for (i=0;i<numberRows;i++) {
    509       double rhsValue = rowUpper[i];
    510       bool oneRow=true;
    511       // check elements
     579    double bestSum=1.0;
     580    int nBest=-1;
     581    int kRow=-1;
     582    OsiSolverInterface * solver = model_->solver();
     583    for (int i=0;i<numberRows;i++) {
    512584      int numberUnsatisfied=0;
     585      double sum=0.0;
    513586      for (int j=rowStart[i];j<rowStart[i]+rowLength[i];j++) {
    514587        int iColumn = column[j];
    515         double value = elementByRow[j];
     588        if (solver->isInteger(iColumn)) {
     589          double solValue = solution[iColumn];
     590          if (solValue>1.0e-5&&solValue<FIX_IF_LESS) {
     591            numberUnsatisfied++;
     592            sum += solValue;
     593          }
     594        }
     595      }
     596      if (numberUnsatisfied>=3&&sum<FIX_IF_LESS) {
     597        // possible
     598        if (numberUnsatisfied>nBest||
     599            (numberUnsatisfied==nBest&&sum<bestSum)) {
     600          nBest=numberUnsatisfied;
     601          bestSum=sum;
     602          kRow=i;
     603        }
     604      }
     605    }
     606    assert (nBest>0);
     607    for (int j=rowStart[kRow];j<rowStart[kRow]+rowLength[kRow];j++) {
     608      int iColumn = column[j];
     609      if (solver->isInteger(iColumn)) {
    516610        double solValue = solution[iColumn];
    517         if (columnLower[iColumn]!=columnUpper[iColumn]) {
    518           if (solValue<1.0-integerTolerance&&solValue>integerTolerance)
    519             numberUnsatisfied++;
    520           if (value!=1.0) {
    521             oneRow=false;
    522             break;
    523           }
    524         } else {
    525           rhsValue -= value*floor(solValue+0.5);
    526         }
    527       }
    528       if (oneRow&&rhsValue<=1.0+tolerance) {
    529         if (!numberUnsatisfied) {
    530           for (int j=rowStart[i];j<rowStart[i]+rowLength[i];j++) {
    531             int iColumn = column[j];
    532             if (dsort[iColumn]>1.0e50){
    533               dsort[iColumn]=0;
    534               nSort++;
    535             }
    536           }
    537         }
    538       }
    539     }
    540     // sort
    541     CoinSort_2(dsort,dsort+numberColumns,sort);
    542   } else {
    543     // new way
    544     for (i=0;i<numberIntegers;i++) {
    545       int iColumn = integerVariable[i];
    546       if (upper[iColumn]>lower[iColumn]) {
    547         if (!mark_||!mark_[iColumn]) {
    548           double distanceDown=solution[iColumn]-lower[iColumn];
    549           double distanceUp=upper[iColumn]-solution[iColumn];
    550           double distance = CoinMin(distanceDown,distanceUp);
    551           if (distance>0.001&&distance<0.5) {
    552             dsort[nSort]=distance;
    553             sort[nSort++]=iColumn;
    554           }
    555         }
    556       }
    557     }
    558     // sort
    559     CoinSort_2(dsort,dsort+nSort,sort);
    560     int n=0;
    561     double sum=0.0;
    562     for (int k=0;k<nSort;k++) {
    563       sum += dsort[k];
    564       if (sum<=djTolerance_)
    565         n=k;
    566       else
    567         break;
    568     }
    569     nSort = CoinMin(n,numberClean_/1000000);
     611        if (solValue>1.0e-5&&solValue<FIX_IF_LESS) {
     612          sort[nSort++]=iColumn;
     613        }
     614      }
     615    }
    570616  }
    571617  OsiRowCut down;
     
    762808  return returnCode;
    763809}
    764 // Infeasibility - large is 0.5
    765810double
    766 CbcBranchToFixLots::infeasibility(int & preferredWay) const
     811CbcBranchToFixLots::infeasibility(const OsiBranchingInformation * /*info*/,
     812                               int &preferredWay) const
    767813{
    768814  preferredWay=-1;
     
    779825      return 0.0;
    780826  }
    781   if (!shallWe())
    782     return 0.0;
    783   else
    784     return 1.0e20;
     827  if (djTolerance_!=-1.234567) {
     828    if (!shallWe())
     829      return 0.0;
     830    else
     831      return 1.0e20;
     832  } else {
     833    // See if 3 in same row and sum <FIX_IF_LESS?
     834    int numberRows = matrixByRow_.getNumRows();
     835    const double * solution = model_->testSolution();
     836    const int * column = matrixByRow_.getIndices();
     837    const CoinBigIndex * rowStart = matrixByRow_.getVectorStarts();
     838    const int * rowLength = matrixByRow_.getVectorLengths();
     839    double bestSum=1.0;
     840    int nBest=-1;
     841    OsiSolverInterface * solver = model_->solver();
     842    for (int i=0;i<numberRows;i++) {
     843      int numberUnsatisfied=0;
     844      double sum=0.0;
     845      for (int j=rowStart[i];j<rowStart[i]+rowLength[i];j++) {
     846        int iColumn = column[j];
     847        if (solver->isInteger(iColumn)) {
     848          double solValue = solution[iColumn];
     849          if (solValue>1.0e-5&&solValue<FIX_IF_LESS) {
     850            numberUnsatisfied++;
     851            sum += solValue;
     852          }
     853        }
     854      }
     855      if (numberUnsatisfied>=3&&sum<FIX_IF_LESS) {
     856        // possible
     857        if (numberUnsatisfied>nBest||
     858            (numberUnsatisfied==nBest&&sum<bestSum)) {
     859          nBest=numberUnsatisfied;
     860          bestSum=sum;
     861        }
     862      }
     863    }
     864    if (nBest>0)
     865      return 1.0e20;
     866    else
     867      return 0.0;
     868  }
     869}
     870// Redoes data when sequence numbers change
     871void
     872CbcBranchToFixLots::redoSequenceEtc(CbcModel * model, int numberColumns, const int * originalColumns)
     873{
     874  model_=model;
     875  if (mark_) {
     876    OsiSolverInterface * solver = model_->solver();
     877    int numberColumnsNow = solver->getNumCols();
     878    char * temp = new char[numberColumnsNow];
     879    memset(temp,0,numberColumnsNow);
     880    for (int i=0;i<numberColumns;i++) {
     881      int j = originalColumns[i];
     882      temp[i]=mark_[j];
     883    }
     884    delete [] mark_;
     885    mark_=temp;
     886  }
     887  OsiSolverInterface * solver = model_->solver();
     888  matrixByRow_ = *solver->getMatrixByRow();
    785889}
    786890
     
    836940  delete [] which_;
    837941}
    838 // Creates a branching object
    839942CbcBranchingObject *
    840 CbcBranchAllDifferent::createBranch(int way)
     943CbcBranchAllDifferent::createCbcBranch(OsiSolverInterface * /*solver*/
     944                                       ,const OsiBranchingInformation * /*info*/,
     945                                       int /*way*/)
    841946{
    842947  // by default way must be -1
    843   assert (way==-1);
     948  //assert (way==-1);
    844949  const double * solution = model_->testSolution();
    845950  double * values = new double[numberInSet_];
     
    884989  return newObject;
    885990}
    886 // Infeasibility - large is 0.5
    887991double
    888 CbcBranchAllDifferent::infeasibility(int & preferredWay) const
     992CbcBranchAllDifferent::infeasibility(const OsiBranchingInformation * /*info*/,
     993                               int &preferredWay) const
    889994{
    890995  preferredWay=-1;
Note: See TracChangeset for help on using the changeset viewer.