Changeset 1972 for trunk


Ignore:
Timestamp:
Jul 21, 2013 5:00:37 AM (6 years ago)
Author:
forrest
Message:

changes to allow more options and stop on feasible (and a few other things)

Location:
trunk/Clp/src
Files:
16 edited

Legend:

Unmodified
Added
Removed
  • trunk/Clp/src/CbcOrClpParam.cpp

    r1958 r1972  
    25272527          CbcOrClpParam("more!MipOptions", "More dubious options for mip",
    25282528                        -1, COIN_INT_MAX, CBC_PARAM_INT_MOREMIPOPTIONS, 0);
     2529     parameters[numberParameters++] =
     2530          CbcOrClpParam("more2!MipOptions", "More more dubious options for mip",
     2531                        -1, COIN_INT_MAX, CBC_PARAM_INT_MOREMOREMIPOPTIONS, 0);
     2532     parameters[numberParameters-1].setIntValue(0);
    25292533     parameters[numberParameters++] =
    25302534          CbcOrClpParam("mixed!IntegerRoundingCuts", "Whether to use Mixed Integer Rounding cuts",
  • trunk/Clp/src/CbcOrClpParam.hpp

    r1924 r1972  
    142142     CBC_PARAM_INT_EXTRA_VARIABLES,
    143143     CBC_PARAM_INT_MAX_SLOW_CUTS,
     144     CBC_PARAM_INT_MOREMOREMIPOPTIONS,
    144145
    145146     CLP_PARAM_STR_DIRECTION = 201,
  • trunk/Clp/src/ClpMain.cpp

    r1946 r1972  
    34613461           } else if (value!=-COIN_DBL_MAX) {
    34623462             if (model->logLevel() > 4)
    3463              printf("Singleton %d with objective in row with %d equal elements - rhs %g,%g\n",iColumn,rowLength[iRow],rowLower[iRow],rowUpper[iRow]);
     3463               printf("Singleton %d (%s) with objective in row %d (%s) with %d equal elements - rhs %g,%g\n",iColumn,model->getColumnName(iColumn).c_str(),
     3464                      iRow,model->getRowName(iRow).c_str(),
     3465                      rowLength[iRow],rowLower[iRow],rowUpper[iRow]);
    34643466             nPossibleNonzeroCost++;
    34653467           }
     
    34703472                nPossibleZeroCost,nPossibleNonzeroCost);
    34713473       // look for DW
    3472        int * blockStart = new int [2*(numberRows+numberColumns)+1+numberRows];
     3474       int * blockStart = new int [3*(numberRows+numberColumns)+1];
    34733475       int * columnBlock = blockStart+numberRows;
    34743476       int * nextColumn = columnBlock+numberColumns;
    34753477       int * blockCount = nextColumn+numberColumns;
    34763478       int * blockEls = blockCount+numberRows+1;
     3479       int * countIntegers = blockEls+numberRows;
     3480       memset(countIntegers,0,numberColumns*sizeof(int));
    34773481       int direction[2]={-1,1};
    34783482       int bestBreak=-1;
     
    36533657         int numberEmptyColumns=0;
    36543658         int numberMasterColumns=0;
     3659         int numberMasterIntegers=0;
    36553660         for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
    36563661           int iBlock=columnBlock[iColumn];
     3662           bool isInteger = (model->isInteger(iColumn));
    36573663           if (iBlock>=0) {
    36583664             nextColumn[iBlock]++;
     3665             if (isInteger)
     3666               countIntegers[iBlock]++;
    36593667           } else {
     3668             if (isInteger)
     3669               numberMasterIntegers++;
    36603670             if (columnLength[iColumn])
    36613671               numberMasterColumns++;
     
    36753685         if (numberMaster>halfway||largestRows*3>numberRows)
    36763686           useful=false;
    3677          printf("%s %d blocks (largest %d,%d), %d master rows (%d empty) out of %d, %d master columns (%d empty) out of %d\n",
     3687         printf("%s %d blocks (largest %d,%d), %d master rows (%d empty) out of %d, %d master columns (%d empty, %d integer) out of %d\n",
    36783688                useful ? "**Useful" : "NoGood",
    36793689                numberBlocks,largestRows,largestColumns,numberMaster,numberEmpty,numberRows,
    3680                 numberMasterColumns,numberEmptyColumns,numberColumns);
     3690                numberMasterColumns,numberEmptyColumns,numberMasterIntegers,
     3691                numberColumns);
    36813692         for (int i=0;i<numberBlocks;i++)
    3682            printf("Block %d has %d rows and %d columns (%d elements)\n",
    3683                   i,blockCount[i],nextColumn[i],blockEls[i]);
     3693           printf("Block %d has %d rows and %d columns (%d elements, %d integers)\n",
     3694                  i,blockCount[i],nextColumn[i],blockEls[i],countIntegers[i]);
     3695         FILE * fpBlocks = fopen("blocks.data","wb");
     3696         printf("Blocks data on file blocks.data\n");
     3697         int stats[3];
     3698         stats[0]=numberRows;
     3699         stats[1]=numberColumns;
     3700         stats[2]=numberBlocks;
     3701         size_t numberWritten;
     3702         numberWritten=fwrite(stats,sizeof(int),3,fpBlocks);
     3703         assert (numberWritten==3);
     3704         numberWritten=fwrite(blockStart,sizeof(int),numberRows,fpBlocks);
     3705         assert (numberWritten==numberRows);
     3706         numberWritten=fwrite(columnBlock,sizeof(int),numberColumns,fpBlocks);
     3707         assert (numberWritten==numberColumns);
     3708         fclose(fpBlocks);
    36843709         if (model->logLevel() == 17) {
    36853710           int * whichRows=new int[numberRows+numberColumns];
     
    36993724             }
    37003725             ClpSimplex subset(model,nRows,whichRows,nColumns,whichColumns);
     3726             for (int jRow=0;jRow<nRows;jRow++) {
     3727               int iRow = whichRows[jRow];
     3728               std::string name = model->getRowName(iRow);
     3729               subset.setRowName(jRow,name);
     3730             }
     3731             for (int jColumn=0;jColumn<nColumns;jColumn++) {
     3732               int iColumn = whichColumns[jColumn];
     3733               if (model->isInteger(iColumn))
     3734                 subset.setInteger(jColumn);
     3735               std::string name = model->getColumnName(iColumn);
     3736               subset.setColumnName(jColumn,name);
     3737             }
    37013738             subset.writeMps(name,0,1);
    37023739           }
     
    42824319     breakdown("ColumnUpper", numberColumns, columnUpper);
    42834320     breakdown("Objective", numberColumns, objective);
     4321     // do integer objective
     4322     double * obj = CoinCopyOfArray(objective,numberColumns);
     4323     int n=0;
     4324     //#define FIX_COSTS 1.0
     4325#ifdef FIX_COSTS
     4326     double * obj2   = originalModel->objective();
     4327     double * upper2   = originalModel->columnUpper();
     4328#endif
     4329     for (int i=0;i<numberColumns;i++) {
     4330       if (integerInformation&&integerInformation[i]) {
     4331         obj[n++]=obj[i];
     4332#ifdef FIX_COSTS
     4333         if (obj2[i]>FIX_COSTS)
     4334         upper2[i]=0.0;
     4335#endif
     4336       }
     4337     }
     4338     if (n) {
     4339       breakdown("Integer objective", n, obj);
     4340     }
    42844341}
    42854342static bool maskMatches(const int * starts, char ** masks,
  • trunk/Clp/src/ClpModel.hpp

    r1939 r1972  
    420420         8 - failed due to bad element check
    421421         9 - status was 3 and stopped on time
     422         10 - status was 3 but stopped as primal feasible
    422423         100 up - translation of enum from ClpEventHandler
    423424     */
     
    10381039         1048576 - don't need to finish dual (can return 3)
    10391040         2097152 - zero costs!
     1041         4194304 - don't scale integer variables
    10401042         NOTE - many applications can call Clp but there may be some short cuts
    10411043                which are taken which are not guaranteed safe from all applications.
  • trunk/Clp/src/ClpPackedMatrix.cpp

    r1958 r1972  
    33663366          }
    33673367     }
     3368     // don't scale integers if option set
     3369     if ((model->specialOptions()&4194304)!=0 && model->integerInformation()) {
     3370       const char * integer  = model->integerInformation();
     3371       for (iColumn = 0; iColumn < numberColumns; iColumn++) {
     3372         if (integer[iColumn])
     3373           usefulColumn[iColumn]=0;
     3374       }
     3375     }
    33683376     if (deletedElements) {
    33693377       matrix_->setNumElements(matrix_->getNumElements()-deletedElements);
  • trunk/Clp/src/ClpPdco.cpp

    r1938 r1972  
    317317     //bool useQR   = (LSmethod == 2);
    318318     bool direct  = (LSmethod <= 2 && ifexplicit);
    319      char solver[6];
     319     char solver[7];
    320320     strcpy(solver, "  LSQR");
    321321
  • trunk/Clp/src/ClpPresolve.cpp

    r1929 r1972  
    953953          const bool duprow = doDuprow();
    954954          const bool dual = doDualStuff;
     955          // Whether we want to allow duplicate intersections
     956          if (doIntersection())
     957            prob->presolveOptions_ |= 0x10;
    955958
    956959          // some things are expensive so just do once (normally)
  • trunk/Clp/src/ClpPresolve.hpp

    r1926 r1972  
    176176          else presolveActions_ |= 2048;
    177177     }
     178     /// Whether we want to allow duplicate intersections
     179     inline bool doIntersection() const {
     180          return (presolveActions_ & 4096) != 0;
     181     }
     182     inline void setDoIntersection(bool doIntersection) {
     183          if (doIntersection) presolveActions_  &= ~4096;
     184          else presolveActions_ |= 4096;
     185     }
    178186     /// Set whole group
    179187     inline int presolveActions() const {
  • trunk/Clp/src/ClpSimplex.cpp

    r1964 r1972  
    54175417       problemStatus_ = 10; // clean up in primal as fake bounds
    54185418     }
     5419     if ((moreSpecialOptions_&262144)!=0&&
     5420         !nonLinearCost_->numberInfeasibilities()&&
     5421         fabs(dblParam_[ClpDualObjectiveLimit])>1.0e30) {
     5422       problemStatus_=0;
     5423     }
    54195424     if (problemStatus_ == 10) {
    54205425          //printf("Cleaning up with primal\n");
  • trunk/Clp/src/ClpSimplex.hpp

    r1926 r1972  
    421421     /// After mini presolve
    422422     void miniPostsolve(const ClpSimplex * presolvedModel,void * info);
     423     /// Scale real objective
     424     void scaleRealObjective(double multiplier);
     425     /// Scale so no RHS (abs not infinite) > value
     426     void scaleRealRhs(double maxValue, double killIfSmaller);
    423427     /** Write the basis in MPS format to the specified file.
    424428         If writeValues true writes values of structurals
     
    11861190         32768 bit - do dual in netlibd
    11871191         65536 (*3) initial stateDualColumn
     1192         262144 bit - stop when primal feasible
    11881193     */
    11891194     inline int moreSpecialOptions() const {
     
    12061211         8192 bit - don't even think of using primal if user asks for dual (and vv)
    12071212         16384 bit - in initialSolve so be more flexible
     1213         debug
     1214         32768 bit - do dual in netlibd
     1215         65536 (*3) initial stateDualColumn
     1216         262144 bit - stop when primal feasible
    12081217     */
    12091218     inline void setMoreSpecialOptions(int value) {
  • trunk/Clp/src/ClpSimplexDual.cpp

    r1930 r1972  
    19281928               }
    19291929               if (!numberPivots || specialCase) {
     1930                 if (numberPrimalInfeasibilities_ && problemStatus_==-1)
     1931                   problemStatus_=-4;
    19301932                    // may have crept through - so may be optimal
    19311933                    // check any flagged variables
  • trunk/Clp/src/ClpSimplexOther.cpp

    r1929 r1972  
    1044410444  delete [] rowLowerX;
    1044510445}
     10446// Scale real objective
     10447void
     10448ClpSimplex::scaleRealObjective(double multiplier)
     10449{
     10450  double * obj = objective();
     10451  for (int i=0;i<numberColumns_;i++)
     10452    obj[i] *= multiplier;
     10453  setObjectiveOffset(multiplier*objectiveOffset());
     10454}
     10455// Scale so no RHS (abs not infinite) > value
     10456void
     10457ClpSimplex::scaleRealRhs(double maxValue, double killIfSmaller)
     10458{
     10459  ClpPackedMatrix * matrix = dynamic_cast<ClpPackedMatrix *>(matrix_);
     10460  if (matrix&&maxValue>1.0) {
     10461    matrix->allElementsInRange(this,
     10462                               1.0e-12,1.0e12,8);
     10463    double * element = matrix->getMutableElements();
     10464    const int * row = matrix->getIndices();
     10465    const int * columnLength = matrix->getVectorLengths();
     10466    const CoinBigIndex * columnStart = matrix->getVectorStarts();
     10467    for (int iRow=0;iRow<numberRows_;iRow++) {
     10468      double lowerValue=rowLower_[iRow];
     10469      if (lowerValue<-1.0e15)
     10470        lowerValue=-1.0;
     10471      double upperValue=rowUpper_[iRow];
     10472      if (upperValue>1.0e15)
     10473        upperValue=1.0;
     10474      double scale = CoinMax(fabs(lowerValue),fabs(upperValue));
     10475      if (scale>maxValue) {
     10476        dual_[iRow]=maxValue/scale;
     10477      } else {
     10478        dual_[iRow]=1.0;
     10479      }
     10480      if (lowerValue>=-1.0e15)
     10481        rowLower_[iRow] *= dual_[iRow];
     10482      if (upperValue<=1.0e15)
     10483        rowUpper_[iRow] *= dual_[iRow];
     10484    }
     10485    for (int iColumn=0;iColumn<numberColumns_;iColumn++) {
     10486      for (CoinBigIndex j = columnStart[iColumn];
     10487           j < columnStart[iColumn] + columnLength[iColumn]; j++) {
     10488        int iRow = row[j];
     10489        element[j] *= dual_[iRow];
     10490      }
     10491    }
     10492    matrix->allElementsInRange(this,
     10493                               killIfSmaller,1.0e22,15);
     10494  } else {
     10495    printf("Can't scale rhs as not ClpPackedMatrix\n");
     10496  }
     10497}
  • trunk/Clp/src/ClpSimplexPrimal.cpp

    r1930 r1972  
    481481
    482482               // test for maximum iterations
    483                if (hitMaximumIterations() || (ifValuesPass == 2 && firstFree_ < 0)) {
     483               if (hitMaximumIterations() ||
     484                   (ifValuesPass == 2 && firstFree_ < 0)) {
    484485                    problemStatus_ = 3;
     486                    break;
     487               } else if ((moreSpecialOptions_&262144)!=0&&
     488                          !nonLinearCost_->numberInfeasibilities()&&
     489                          fabs(dblParam_[ClpDualObjectiveLimit])>1.0e30) {
     490                    problemStatus_ = 3;
     491                    secondaryStatus_ = 10;
    485492                    break;
    486493               }
  • trunk/Clp/src/ClpSolve.cpp

    r1953 r1972  
    36593659                         // dual - change tolerance
    36603660                         model_->setCurrentDualTolerance(model_->currentDualTolerance() * 1.05);
     3661                         model_->setCurrentPrimalTolerance(model_->currentPrimalTolerance() * 1.05);
    36613662                         // if infeasible increase dual bound
    36623663                         if (model_->dualBound() < 1.0e17) {
  • trunk/Clp/src/OsiClp/OsiClpSolverInterface.cpp

    r1926 r1972  
    44684468  delete [] rowrange_;
    44694469  delete matrixByRow_;
    4470   if (modelPtr_&&modelPtr_->scaledMatrix_) {
    4471     delete modelPtr_->scaledMatrix_;
    4472     modelPtr_->scaledMatrix_=NULL;
    4473   }
    44744470  //delete ws_;
    44754471  rowsense_=NULL;
     
    44784474  matrixByRow_=NULL;
    44794475  //ws_ = NULL;
    4480   if (modelPtr_&&modelPtr_->clpMatrix()) {
    4481     modelPtr_->clpMatrix()->refresh(modelPtr_); // make sure all clean
     4476  if (!notOwned_&&modelPtr_) {
     4477    if(modelPtr_->scaledMatrix_) {
     4478      delete modelPtr_->scaledMatrix_;
     4479      modelPtr_->scaledMatrix_=NULL;
     4480    }
     4481    if (modelPtr_->clpMatrix()) {
     4482      modelPtr_->clpMatrix()->refresh(modelPtr_); // make sure all clean
    44824483#ifndef NDEBUG
    4483     ClpPackedMatrix * clpMatrix = dynamic_cast<ClpPackedMatrix *> (modelPtr_->clpMatrix());
    4484     if (clpMatrix) {
    4485       if (clpMatrix->getNumCols())
    4486         assert (clpMatrix->getNumRows()==modelPtr_->getNumRows());
    4487       if (clpMatrix->getNumRows())
    4488         assert (clpMatrix->getNumCols()==modelPtr_->getNumCols());
    4489     }
    4490 #endif
     4484      ClpPackedMatrix * clpMatrix = dynamic_cast<ClpPackedMatrix *> (modelPtr_->clpMatrix());
     4485      if (clpMatrix) {
     4486        if (clpMatrix->getNumCols())
     4487          assert (clpMatrix->getNumRows()==modelPtr_->getNumRows());
     4488        if (clpMatrix->getNumRows())
     4489          assert (clpMatrix->getNumCols()==modelPtr_->getNumCols());
     4490      }
     4491#endif
     4492    }
    44914493  }
    44924494}
     
    57925794  basis_ = getBasis(modelPtr_);
    57935795  return 0;
     5796}
     5797// Set column status in ClpSimplex and warmStart
     5798void
     5799OsiClpSolverInterface::setColumnStatus(int iColumn, ClpSimplex::Status status)
     5800{
     5801  if (status!=modelPtr_->status_[iColumn]) {
     5802    modelPtr_->whatsChanged_ &= 0xffff;
     5803    // Say can't gurantee optimal basis etc
     5804    lastAlgorithm_=999;
     5805    modelPtr_->setColumnStatus(iColumn,status);
     5806    switch (status) {
     5807    case ClpSimplex::basic:
     5808      basis_.setStructStatus(iColumn,CoinWarmStartBasis::basic);
     5809      break;
     5810    case ClpSimplex::atUpperBound:
     5811      basis_.setStructStatus(iColumn,CoinWarmStartBasis::atUpperBound);
     5812      break;
     5813    case ClpSimplex::isFixed:
     5814    case ClpSimplex::atLowerBound:
     5815      basis_.setStructStatus(iColumn,CoinWarmStartBasis::atLowerBound);
     5816      break;
     5817    case ClpSimplex::superBasic:
     5818    case ClpSimplex::isFree:
     5819      basis_.setStructStatus(iColumn,CoinWarmStartBasis::isFree);
     5820      break;
     5821    }
     5822  }
    57945823}
    57955824
  • trunk/Clp/src/OsiClp/OsiClpSolverInterface.hpp

    r1926 r1972  
    308308  */
    309309  virtual CoinWarmStart* getPointerToWarmStart(bool & mustDelete) ;
     310
     311  /// Set column status in ClpSimplex and warmStart
     312  void setColumnStatus(int iColumn, ClpSimplex::Status status);
    310313
    311314  //@}
Note: See TracChangeset for help on using the changeset viewer.