Changeset 1677 for trunk


Ignore:
Timestamp:
Jan 21, 2011 1:01:03 PM (9 years ago)
Author:
forrest
Message:

gub

Location:
trunk/Clp/src
Files:
7 edited

Legend:

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

    r1676 r1677  
    9494     lowerSet_ = ClpCopyOfArray(rhs.lowerSet_, numberSets_);
    9595     upperSet_ = ClpCopyOfArray(rhs.upperSet_, numberSets_);
    96      status_ = ClpCopyOfArray(rhs.status_, 2*numberSets_);
     96     status_ = ClpCopyOfArray(rhs.status_, 2*numberSets_+4*sizeof(int));
    9797     model_ = rhs.model_;
    9898     sumDualInfeasibilities_ = rhs. sumDualInfeasibilities_;
     
    237237     flags_ &= ~1;
    238238     // resize model (matrix stays same)
    239      int newRowSize = numberRows + CoinMin(numberSets_, CoinMax(frequency, numberRows)) + 1;
     239     int newRowSize = numberRows + CoinMin(numberSets_, frequency+numberRows) + 1;
    240240     model->resize(newRowSize, numberNeeded);
    241241     for (i = numberRows; i < newRowSize; i++)
     
    259259     keyVariable_ = new int[numberSets_];
    260260     if (status) {
    261           status_ = ClpCopyOfArray(status, 2*numberSets_);
     261          status_ = ClpCopyOfArray(status, 2*numberSets_+4*sizeof(int));
    262262          assert (dynamicStatus);
    263263          dynamicStatus_ = ClpCopyOfArray(dynamicStatus, 2*numberGubColumns_);
    264264     } else {
    265           status_ = new unsigned char [2*numberSets_];
     265          status_ = new unsigned char [2*numberSets_+4*sizeof(int)];
    266266          memset(status_, 0, numberSets_);
    267267          int i;
     
    356356          lowerSet_ = ClpCopyOfArray(rhs.lowerSet_, numberSets_);
    357357          upperSet_ = ClpCopyOfArray(rhs.upperSet_, numberSets_);
    358           status_ = ClpCopyOfArray(rhs.status_, 2*numberSets_);
     358          status_ = ClpCopyOfArray(rhs.status_, 2*numberSets_+4*sizeof(int));
    359359          model_ = rhs.model_;
    360360          sumDualInfeasibilities_ = rhs. sumDualInfeasibilities_;
     
    865865          if (lowerSet_[iSet] == upperSet_[iSet])
    866866               setStatus(iSet, ClpSimplex::isFixed);
     867#if 0
    867868          if (getStatus(iSet) != model->getStatus(sequenceOut))
    868869               printf("** set %d status %d, var status %d\n", iSet,
    869870                      getStatus(iSet), model->getStatus(sequenceOut));
     871#endif
    870872     }
    871873     ClpMatrixBase::updatePivot(model, oldInValue, oldOutValue);
     
    10441046{
    10451047     int returnCode = 0;
     1048#if 0 //ndef NDEBUG
     1049     {
     1050       int numberColumns = model->numberColumns();
     1051       int numberRows = model->numberRows();
     1052       int * pivotVariable = model->pivotVariable();
     1053       if (pivotVariable&&model->numberIterations()) {
     1054         for (int i=numberStaticRows_+numberActiveSets_;i<numberRows;i++) {
     1055           assert (pivotVariable[i]==i+numberColumns);
     1056         }
     1057       }
     1058     }
     1059#endif
    10461060     switch (mode) {
    10471061          // Fill in pivotVariable
     
    10871101     case 5: {
    10881102       memcpy(status_+numberSets_,status_,numberSets_);
     1103       memcpy(status_+2*numberSets_,&numberActiveSets_,sizeof(int));
    10891104       memcpy(dynamicStatus_+maximumGubColumns_,
    10901105              dynamicStatus_,maximumGubColumns_);
     
    10941109     case 6: {
    10951110       memcpy(status_,status_+numberSets_,numberSets_);
     1111       memcpy(&numberActiveSets_,status_+2*numberSets_,sizeof(int));
    10961112       memcpy(dynamicStatus_,dynamicStatus_+maximumGubColumns_,
    10971113              maximumGubColumns_);
     
    12661282          return 1;
    12671283     }
     1284#ifndef NDEBUG
     1285     {
     1286       int numberColumns = model->numberColumns();
     1287       int numberRows = model->numberRows();
     1288       int * pivotVariable = model->pivotVariable();
     1289       for (int i=numberStaticRows_+numberActiveSets_;i<numberRows;i++) {
     1290         assert (pivotVariable[i]==i+numberColumns);
     1291       }
     1292     }
     1293#endif
    12681294     // lookup array
    12691295     int * active = new int [numberActiveSets_];
     
    14791505               }
    14801506          }
     1507          if (iPut<numberStaticRows_+numberActiveSets_) {
     1508            printf("lost %d sets\n",
     1509                   numberStaticRows_+numberActiveSets_-iPut);
     1510            iPut = numberStaticRows_+numberActiveSets_;
     1511          }
    14811512          for (i = numberActiveSets_; i < currentNumberActiveSets; i++) {
    14821513               pivotVariable[iPut++] = i + base3;
    14831514          }
    1484           assert (iPut == numberRows);
     1515          //assert (iPut == numberRows);
    14851516     }
    14861517#ifdef CLP_DEBUG
     
    22882319          keyVariable_[iSet] = whichKey;
    22892320     }
     2321     // clean up pivotVariable
     2322     int numberColumns = model_->numberColumns();
     2323     int numberRows = model_->numberRows();
     2324     int * pivotVariable = model_->pivotVariable();
     2325     if (pivotVariable) {
     2326       for (int i=0; i<numberStaticRows_+numberActiveSets_;i++) {
     2327         if (model_->getRowStatus(i)!=ClpSimplex::basic)
     2328           pivotVariable[i]=-1;
     2329         else
     2330           pivotVariable[i]=numberColumns+i;
     2331       }
     2332       for (int i=numberStaticRows_+numberActiveSets_;i<numberRows;i++) {
     2333         pivotVariable[i]=i+numberColumns;
     2334       }
     2335       int put=-1;
     2336       for (int i=0;i<numberColumns;i++) {
     2337         if (model_->getColumnStatus(i)==ClpSimplex::basic) {
     2338           while(put<numberRows) {
     2339             put++;
     2340             if (pivotVariable[put]==-1) {
     2341               pivotVariable[put]=i;
     2342               break;
     2343             }
     2344           }
     2345         }
     2346       }
     2347       for (int i=CoinMax(put,0);i<numberRows;i++) {
     2348         if (pivotVariable[i]==-1)
     2349           pivotVariable[i]=i+numberColumns;
     2350       }
     2351     }
     2352     if (rhsOffset_) {
     2353       double * cost = model_->costRegion();
     2354       double * columnLower = model_->lowerRegion();
     2355       double * columnUpper = model_->upperRegion();
     2356       double * solution = model_->solutionRegion();
     2357       int numberRows = model_->numberRows();
     2358       for (int i = numberActiveSets_; i < numberRows-numberStaticRows_; i++) {
     2359         int iSequence = i + numberStaticRows_ + numberColumns;
     2360         solution[iSequence] = 0.0;
     2361         columnLower[iSequence] = -COIN_DBL_MAX;
     2362         columnUpper[iSequence] = COIN_DBL_MAX;
     2363         cost[iSequence] = 0.0;
     2364         model_->nonLinearCost()->setOne(iSequence, solution[iSequence],
     2365                                        columnLower[iSequence],
     2366                                        columnUpper[iSequence], 0.0);
     2367         model_->setStatus(iSequence, ClpSimplex::basic);
     2368         rhsOffset_[i+numberStaticRows_] = 0.0;
     2369       }
     2370#if 0
     2371       for (int i=0;i<numberStaticRows_;i++)
     2372         printf("%d offset %g\n",
     2373                i,rhsOffset_[i]);
     2374#endif
     2375     }
    22902376     numberActiveColumns_ = firstAvailable_;
     2377#if 0
     2378     for (iSet = 0; iSet < numberSets_; iSet++) {
     2379       for (int j=startSet_[iSet];j<startSet_[iSet+1];j++) {
     2380         if (getDynamicStatus(j)==soloKey)
     2381           printf("%d in set %d is solo key\n",j,iSet);
     2382         else if (getDynamicStatus(j)==inSmall)
     2383           printf("%d in set %d is in small\n",j,iSet);
     2384       }
     2385     }
     2386#endif
    22912387     return;
    22922388}
  • trunk/Clp/src/ClpMessage.cpp

    r1665 r1677  
    104104     {CLP_PARAMETRICS_STATS2, 63, 2, "Theta %g - objective %g, %s in, %s out"},
    105105     {CLP_GENERAL, 1000, 1, "%s"},
     106     {CLP_GENERAL2, 1001, 2, "%s"},
    106107     {CLP_DUMMY_END, 999999, 0, ""}
    107108};
  • trunk/Clp/src/ClpMessage.hpp

    r1665 r1677  
    105105     CLP_PARAMETRICS_STATS2,
    106106     CLP_GENERAL,
     107     CLP_GENERAL2,
    107108     CLP_DUMMY_END
    108109};
  • trunk/Clp/src/ClpNonLinearCost.cpp

    r1676 r1677  
    9191          }
    9292     }
    93      if (allZero)
     93     if (allZero&&model_->clpMatrix()->type()<15)
    9494          model_->setInfeasibilityCost(1.0);
    9595     double infeasibilityCost = model_->infeasibilityCost();
  • trunk/Clp/src/ClpSimplexOther.cpp

    r1676 r1677  
    41734173  if (numberGub >= neededGub) {
    41744174    sprintf(message,"%d gub rows", numberGub);
    4175     handler_->message(CLP_GENERAL, messages_)
     4175    handler_->message(CLP_GENERAL2, messages_)
    41764176      << message << CoinMessageEol;
    41774177    int numberNormal = 0;
     
    41834183    if (!numberNormal) {
    41844184      sprintf(message,"Putting back one gub row to make non-empty");
    4185       handler_->message(CLP_GENERAL, messages_)
     4185      handler_->message(CLP_GENERAL2, messages_)
    41864186        << message << CoinMessageEol;
    41874187      rowIsGub[smallestGubRow]=-1;
     
    43994399    sprintf(message,"** Before adding matrix there are %d rows and %d columns",
    44004400           model2->numberRows(), model2->numberColumns());
    4401     handler_->message(CLP_GENERAL, messages_)
     4401    handler_->message(CLP_GENERAL2, messages_)
    44024402      << message << CoinMessageEol;
    44034403    delete [] scaleArray;
     
    44394439            "** While after adding matrix there are %d rows and %d columns",
    44404440            model2->numberRows(), model2->numberColumns());
    4441     handler_->message(CLP_GENERAL, messages_)
     4441    handler_->message(CLP_GENERAL2, messages_)
    44424442      << message << CoinMessageEol;
    44434443    model2->setSpecialOptions(4);    // exactly to bound
     
    44714471  double * solution = primalColumnSolution();
    44724472  const double * originalSolution = original.primalColumnSolution();
     4473  const double * upperSet = gubMatrix->upperSet();
    44734474  int numberSets = gubMatrix->numberSets();
    44744475  const int * startSet = gubMatrix->startSets();
     
    44774478  for (int i=0;i<numberSets;i++) {
    44784479    for (int j=startSet[i];j<startSet[i+1];j++) {
     4480      gubMatrix->setDynamicStatus(j,ClpDynamicMatrix::atLowerBound);
    44794481      int iColumn = whichColumns[j+numberNormal];
    44804482      if (iColumn<numberColumns)
     
    45434545    int iRow = whichRows[numberNonGub+i];
    45444546    if (!numberKey[iRow]) {
    4545       if (original.getRowStatus(iRow)==ClpSimplex::basic) {
     4547      double upper = upperSet[i]-1.0e-7;
     4548      if (original.getRowStatus(iRow)==ClpSimplex::basic)
    45464549        gubMatrix->setStatus(i,ClpSimplex::basic);
    4547       } else {
    4548         // If not at lb make key otherwise one with smallest number els
    4549         double largest=0.0;
    4550         int fewest=numberRows+1;
    4551         int chosen=-1;
    4552         for (int j=startSet[i];j<startSet[i+1];j++) {
    4553           int length=startColumn[j+1]-startColumn[j];
    4554           int iOrig = whichColumns[j+numberNormal];
    4555           double value;
    4556           if (iOrig<numberColumns) {
    4557             value=originalSolution[iOrig]-columnLower[j];
    4558           } else {
    4559             // slack - take value as 0.0 as will win on length
    4560             value=0.0;
    4561           }
    4562           if (value>largest+1.0e-8) {
    4563             largest=value;
    4564             fewest=length;
    4565             chosen=j;
    4566           } else if (fabs(value-largest)<=1.0e-8&&length<fewest) {
    4567             largest=value;
    4568             fewest=length;
    4569             chosen=j;
    4570           }
     4550      // If not at lb make key otherwise one with smallest number els
     4551      double largest=0.0;
     4552      int fewest=numberRows+1;
     4553      int chosen=-1;
     4554      for (int j=startSet[i];j<startSet[i+1];j++) {
     4555        int length=startColumn[j+1]-startColumn[j];
     4556        int iOrig = whichColumns[j+numberNormal];
     4557        double value;
     4558        if (iOrig<numberColumns) {
     4559          value=originalSolution[iOrig]-columnLower[j];
     4560          if (value>upper)
     4561            gubMatrix->setStatus(i,ClpSimplex::atLowerBound);
     4562        } else {
     4563          // slack - take value as 0.0 as will win on length
     4564          value=0.0;
    45714565        }
    4572         assert(chosen>=0);
     4566        if (value>largest+1.0e-8) {
     4567          largest=value;
     4568          fewest=length;
     4569          chosen=j;
     4570        } else if (fabs(value-largest)<=1.0e-8&&length<fewest) {
     4571          largest=value;
     4572          fewest=length;
     4573          chosen=j;
     4574        }
     4575      }
     4576      assert(chosen>=0);
     4577      if (gubMatrix->getStatus(i)!=ClpSimplex::basic) {
    45734578        // set as key
    45744579        for (int j=startSet[i];j<startSet[i+1];j++) {
  • trunk/Clp/src/OsiClp/OsiClpSolverInterface.cpp

    r1664 r1677  
    5757  }
    5858#endif
     59  if ((specialOptions_&2097152)!=0) {
     60    resolveGub((9*modelPtr_->numberRows())/10);
     61    return;
     62  }
    5963  bool deleteSolver;
    6064  ClpSimplex * solver;
     
    783787    return;
    784788  }
     789  if ((specialOptions_&2097152)!=0) {
     790    resolveGub((9*modelPtr_->numberRows())/10);
     791    return;
     792  }
    785793  //void pclp(char *);
    786794  //pclp("res");
     
    12691277    modelPtr_->whatsChanged_ &= ~0xffff;
    12701278  modelPtr_->whatsChanged_ |= 0x30000;
     1279}
     1280#include "ClpSimplexOther.hpp"
     1281// Resolve an LP relaxation after problem modification (try GUB)
     1282void
     1283OsiClpSolverInterface::resolveGub(int needed)
     1284{
     1285  bool takeHint;
     1286  OsiHintStrength strength;
     1287  // Switch off printing if asked to
     1288  bool gotHint = (getHintParam(OsiDoReducePrint,takeHint,strength));
     1289  assert (gotHint);
     1290  int saveMessageLevel=modelPtr_->logLevel();
     1291  if (strength!=OsiHintIgnore&&takeHint) {
     1292    int messageLevel=messageHandler()->logLevel();
     1293    if (messageLevel>0)
     1294      modelPtr_->messageHandler()->setLogLevel(messageLevel-1);
     1295    else
     1296      modelPtr_->messageHandler()->setLogLevel(0);
     1297  }
     1298  setBasis(basis_,modelPtr_);
     1299  // find gub
     1300  int numberRows = modelPtr_->numberRows();
     1301  int * which = new int[numberRows];
     1302  int numberColumns = modelPtr_->numberColumns();
     1303  int * whichC = new int[numberColumns+numberRows];
     1304  ClpSimplex * model2 =
     1305    static_cast<ClpSimplexOther *> (modelPtr_)->gubVersion(which,whichC,
     1306                                                           needed);
     1307  if (model2) {
     1308    // move in solution
     1309    static_cast<ClpSimplexOther *> (model2)->setGubBasis(*modelPtr_,
     1310                                                         which,whichC);
     1311    model2->setLogLevel(CoinMin(1,model2->logLevel()));
     1312    ClpPrimalColumnSteepest steepest(5);
     1313    model2->setPrimalColumnPivotAlgorithm(steepest);
     1314    double time1 = CoinCpuTime();
     1315    model2->primal();
     1316    //printf("Primal took %g seconds\n",CoinCpuTime()-time1);
     1317    static_cast<ClpSimplexOther *> (model2)->getGubBasis(*modelPtr_,
     1318                                                         which,whichC);
     1319    int totalIterations = model2->numberIterations();
     1320    //modelPtr_->setLogLevel(63);
     1321    modelPtr_->primal(1);
     1322    modelPtr_->setNumberIterations(totalIterations+modelPtr_->numberIterations());
     1323  } else {
     1324    modelPtr_->dual();
     1325  }
     1326  basis_ = getBasis(modelPtr_);
     1327  modelPtr_->messageHandler()->setLogLevel(saveMessageLevel);
    12711328}
    12721329// Sort of lexicographic resolve
     
    62766333      }
    62776334      // set normal
    6278       specialOptions_ &= (2047+3*8192+15*65536);
     6335      specialOptions_ &= (2047|3*8192|15*65536|2097152);
    62796336      if (otherInformation!=NULL) {
    62806337        int * array = static_cast<int *> (otherInformation);
  • trunk/Clp/src/OsiClp/OsiClpSolverInterface.hpp

    r1664 r1677  
    5252  /// Resolve an LP relaxation after problem modification
    5353  virtual void resolve();
     54 
     55  /// Resolve an LP relaxation after problem modification (try GUB)
     56  virtual void resolveGub(int needed);
    5457 
    5558  /// Invoke solver's built-in enumeration algorithm
     
    13691372      524288 Fake objective and 0-1
    13701373      1048576 Don't recompute ray after crunch
     1374      2097152
    13711375  */
    13721376  mutable unsigned int specialOptions_;
Note: See TracChangeset for help on using the changeset viewer.