Changeset 1729 for trunk/Clp


Ignore:
Timestamp:
May 10, 2011 8:29:37 AM (8 years ago)
Author:
forrest
Message:

messages for Cbc fathoming and allow perturbation and some safety?

Location:
trunk/Clp/src
Files:
9 edited

Legend:

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

    r1677 r1729  
    103103     {CLP_PARAMETRICS_STATS, 62, 1, "Theta %g - objective %g"},
    104104     {CLP_PARAMETRICS_STATS2, 63, 2, "Theta %g - objective %g, %s in, %s out"},
     105#ifndef NO_FATHOM_PRINT
     106     {CLP_FATHOM_STATUS, 63, 2, "Fathoming node %d - %d nodes (%d iterations) - current depth %d"},
     107     {CLP_FATHOM_SOLUTION, 64, 1, "Fathoming node %d - solution of %g after %d nodes at depth %d"},
     108     {CLP_FATHOM_FINISH, 65, 1, "Fathoming node %d (depth %d) took %d nodes (%d iterations) - maximum depth %d"},
     109#endif
    105110     {CLP_GENERAL, 1000, 1, "%s"},
    106111     {CLP_GENERAL2, 1001, 2, "%s"},
  • trunk/Clp/src/ClpMessage.hpp

    r1677 r1729  
    106106     CLP_GENERAL,
    107107     CLP_GENERAL2,
     108#ifndef NO_FATHOM_PRINT
     109     CLP_FATHOM_STATUS,
     110     CLP_FATHOM_SOLUTION,
     111     CLP_FATHOM_FINISH,
     112#endif
    108113     CLP_DUMMY_END
    109114};
  • trunk/Clp/src/ClpNode.cpp

    r1665 r1729  
    267267     double smallChange = stuff->smallChange_;
    268268#endif
     269#ifndef INFEAS_MULTIPLIER
     270#define INFEAS_MULTIPLIER 1.0
     271#endif
    269272     for (iColumn = 0; iColumn < numberColumns; iColumn++) {
    270273          if (integerType[iColumn]) {
     
    310313                    // Extra for infeasible branches
    311314                    if (nUp) {
    312                          double ratio = 1.0 + static_cast<double>(numberUpInfeasible[iInteger]) /
     315                         double ratio = 1.0 + INFEAS_MULTIPLIER*static_cast<double>(numberUpInfeasible[iInteger]) /
    313316                                        static_cast<double>(nUp);
    314317                         upValue2 *= ratio;
     
    317320                    double downValue2 = (downPseudo[iInteger] / (1.0 + nDown));
    318321                    if (nDown) {
    319                          double ratio = 1.0 + static_cast<double>(numberDownInfeasible[iInteger]) /
     322                         double ratio = 1.0 + INFEAS_MULTIPLIER*static_cast<double>(numberDownInfeasible[iInteger]) /
    320323                                        static_cast<double>(nDown);
    321324                         downValue2 *= ratio;
     
    354357                                     (1.0 + nUp));
    355358                    if (nUp) {
    356                          double ratio = 1.0 + static_cast<double>(numberUpInfeasible[iInteger]) /
     359                         double ratio = 1.0 + INFEAS_MULTIPLIER*static_cast<double>(numberUpInfeasible[iInteger]) /
    357360                                        static_cast<double>(nUp);
    358361                         upValue *= ratio;
     
    361364                                       (1.0 + nDown));
    362365                    if (nDown) {
    363                          double ratio = 1.0 + static_cast<double>(numberDownInfeasible[iInteger]) /
     366                         double ratio = 1.0 + INFEAS_MULTIPLIER*static_cast<double>(numberDownInfeasible[iInteger]) /
    364367                                        static_cast<double>(nDown);
    365368                         downValue *= ratio;
     
    711714     whichRow_(NULL),
    712715     whichColumn_(NULL),
     716#ifndef NO_FATHOM_PRINT
     717     handler_(NULL),
     718#endif
    713719     nBound_(0),
    714720     saveOptions_(0),
     
    722728     numberIterations_(0),
    723729     presolveType_(0)
     730#ifndef NO_FATHOM_PRINT
     731     ,startingDepth_(-1),
     732     nodeCalled_(-1)
     733#endif
    724734{
    725735
     
    745755       whichRow_(NULL),
    746756       whichColumn_(NULL),
     757#ifndef NO_FATHOM_PRINT
     758       handler_(rhs.handler_),
     759#endif
    747760       nBound_(0),
    748761       saveOptions_(rhs.saveOptions_),
     
    756769       numberIterations_(rhs.numberIterations_),
    757770       presolveType_(rhs.presolveType_)
     771#ifndef NO_FATHOM_PRINT
     772     ,startingDepth_(rhs.startingDepth_),
     773       nodeCalled_(rhs.nodeCalled_)
     774#endif
    758775{
    759776}
     
    798815          numberIterations_ = rhs.numberIterations_;
    799816          presolveType_ = rhs.presolveType_;
     817#ifndef NO_FATHOM_PRINT
     818          handler_ = rhs.handler_;
     819          startingDepth_ = rhs.startingDepth_;
     820          nodeCalled_ = rhs.nodeCalled_;
     821#endif
    800822     }
    801823     return *this;
  • trunk/Clp/src/ClpNode.hpp

    r1665 r1729  
    219219     /// Integer increment
    220220     double integerIncrement_;
    221      /// Small chnage in branch
     221     /// Small change in branch
    222222     double smallChange_;
    223223     /// Down pseudo costs
     
    245245     /// Which columns in large model
    246246     int * whichColumn_;
     247#ifndef NO_FATHOM_PRINT
     248     /// Cbc's message handler
     249     CoinMessageHandler * handler_;
     250#endif
    247251     /// Number bounds in large model
    248252     int nBound_;
     
    274278     /// Type of presolve - 0 none, 1 crunch
    275279     int presolveType_;
     280#ifndef NO_FATHOM_PRINT
     281     /// Depth passed in
     282     int startingDepth_;
     283     /// Node at which called
     284     int nodeCalled_;
     285#endif
    276286     //@}
    277287};
  • trunk/Clp/src/ClpSimplex.cpp

    r1726 r1729  
    1007410074}
    1007510075#include "ClpNode.hpp"
     10076//#define COIN_DEVELOP
    1007610077// Fathom - 1 if solution
    1007710078int
     
    1008410085     moreSpecialOptions_ |= 8;
    1008510086     int saveMaxIterations = maximumIterations();
    10086      setMaximumIterations(100 + 5 * (numberRows_ + numberColumns_));
    10087 #if 0
    10088      bool onOptimal = true;
     10087     setMaximumIterations((((moreSpecialOptions_&2048)==0) ? 100 : 2000)
     10088                          + 5 * (numberRows_ + numberColumns_));
     10089     double saveObjLimit;
     10090     getDblParam(ClpDualObjectiveLimit, saveObjLimit);
     10091     if (perturbation_<100) {
     10092       double limit = saveObjLimit * optimizationDirection_;
     10093       setDblParam(ClpDualObjectiveLimit,
     10094                   (limit+1.0e-2+1.0e-7*fabs(limit))*optimizationDirection_);
     10095     }
     10096 #if 0
     10097     bool onOptimal = (numberColumns_==100);
    1008910098     double optVal[133];
    1009010099     {
     
    1010510114#endif
    1010610115     }
    10107      if (numberColumns_ == -100) {
     10116     if (numberColumns_ == 100) {
    1010810117          const char * integerType = integerInformation();
    1010910118          for (int i = 0; i < 100; i++) {
     
    1011510124               }
    1011610125          }
    10117           if (onOptimal)
     10126          if (onOptimal) {
    1011810127               printf("On optimal path fathom\n");
     10128          }
    1011910129     }
    1012010130#endif
     
    1013810148               //printf(" %g\n",limit);
    1013910149               // pack down pseudocosts
     10150               small->moreSpecialOptions_ = moreSpecialOptions_;
    1014010151               if (info->upPseudo_) {
    1014110152                    const char * integerType2 = small->integerInformation();
     
    1027010281          delete [] whichColumn;
    1027110282          setMaximumIterations(saveMaxIterations);
     10283          setDblParam(ClpDualObjectiveLimit, saveObjLimit);
    1027210284          return returnCode;
    1027310285     }
     
    1027610288          stopFastDual2(info);
    1027710289          setMaximumIterations(saveMaxIterations);
     10290          setDblParam(ClpDualObjectiveLimit, saveObjLimit);
    1027810291          return returnCode;
    1027910292     }
     
    1032110334          info->nNodes_ = -1;
    1032210335          setMaximumIterations(saveMaxIterations);
     10336          setDblParam(ClpDualObjectiveLimit, saveObjLimit);
    1032310337          return 0;
    1032410338     }
    1032510339     int numberNodes = 1;
    1032610340     int numberIterations = numberIterations_;
    10327 #ifdef COIN_DEVELOP
    10328      int printFrequency = 1000;
     10341#if defined(COIN_DEVELOP) || !defined(NO_FATHOM_PRINT)
     10342     int printFrequency = 2000;
    1032910343#endif
    1033010344     if (problemStatus_ == 1) {
     
    1033410348          info->numberIterations_ = numberIterations;
    1033510349          setMaximumIterations(saveMaxIterations);
     10350          setDblParam(ClpDualObjectiveLimit, saveObjLimit);
    1033610351          return 0;
    1033710352     } else if (problemStatus_ != 0) {
     
    1034010355          info->numberIterations_ = numberIterations;
    1034110356          setMaximumIterations(saveMaxIterations);
     10357          setDblParam(ClpDualObjectiveLimit, saveObjLimit);
    1034210358          // say bad
    1034310359          info->nNodes_ = -1;
     
    1044710463          }
    1044810464#endif
     10465#ifdef COIN_DEVELOP
     10466          static int zzzzzz=0;
     10467          zzzzzz++;
     10468          if ((zzzzzz%100000)==0)
     10469            printf("%d fathom solves\n",zzzzzz);
     10470          if (zzzzzz==-1) {
     10471            printf("TROUBLE\n");
     10472          }
     10473#endif
    1044910474          // Get fake bounds correctly
    1045010475          (static_cast<ClpSimplexDual *>(this))->changeBounds(3, NULL, dummyChange);
     
    1047110496               info->nNodes_ = -1;
    1047210497#ifdef COIN_DEVELOP
    10473                printf("OUCH giving up on loop! %d %d %d %d\n",
    10474                       numberNodes, numberIterations, problemStatus_, numberIterations_);
     10498               printf("OUCH giving up on loop! %d %d %d %d - zzzzzz %d - max %d\n",
     10499                      numberNodes, numberIterations, problemStatus_, numberIterations_,zzzzzz,intParam_[0]);
    1047510500               printf("xx %d\n", numberIterations*(numberRows_ + numberColumns_));
    1047610501               //abort();
     
    1048310508#ifdef COIN_DEVELOP
    1048410509               if ((numberNodes % printFrequency) == 0) {
    10485                     printf("After %d nodes (%d iterations) - best solution %g - current depth %d\n",
    10486                            numberNodes, numberIterations, bestObjective, depth);
     10510                    printf("Fathoming from node %d - %d nodes (%d iterations) - current depth %d\n",
     10511                           info->nodeCalled_,numberNodes,
     10512                           numberIterations, depth+info->startingDepth_);
    1048710513                    printFrequency *= 2;
    1048810514               }
    10489 #endif
    10490                if (numberIterations*(numberRows_ + numberColumns_) > 5.0e8 ||
    10491                          numberNodes > 1.0e6) {
     10515#elif !defined(NO_FATHOM_PRINT)
     10516               if ((numberNodes % printFrequency) == 0) {
     10517                 if ((moreSpecialOptions_&2048)!=0)
     10518                   info->handler_->message(CLP_FATHOM_STATUS, messages_)
     10519                     << info->nodeCalled_ << numberNodes
     10520                     << numberIterations << depth+info->startingDepth_
     10521                     << CoinMessageEol;
     10522                 printFrequency *= 2;
     10523               }
     10524#endif
     10525               if ((numberIterations*(numberRows_ + numberColumns_) > 5.0e10 ||
     10526                    numberNodes > 2.0e4) &&
     10527                   (moreSpecialOptions_&4096)==0) {
    1049210528                    // give up
    1049310529                    info->nNodes_ = -1;
     
    1056010596               }
    1056110597#if 0
    10562                if (numberColumns_ == 133 && onOptimal) {
     10598               if (numberColumns_ == 100 && onOptimal) {
    1056310599                    const char * integerType = integerInformation();
    10564                     for (int i = 0; i < 133; i++) {
     10600                    bool localOptimal=true;
     10601                    for (int i = 0; i < 100; i++) {
    1056510602                         if (integerType[i]) {
    1056610603                              if (columnLower_[i] > optVal[i] || columnUpper_[i] < optVal[i]) {
    10567                                    onOptimal = false;
     10604                                localOptimal = false;
    1056810605                                   printf("bad %d %g %g %g\n", i, columnLower_[i], optVal[i],
    1056910606                                          columnUpper_[i]);
     10607                                   break;
    1057010608                              }
    1057110609                         }
    1057210610                    }
     10611                    if (localOptimal) {
     10612                      printf("still on optimal\n");
     10613                    }
    1057310614                    assert (onOptimal);
    1057410615               }
     
    1057710618                    // solution
    1057810619                    double objectiveValue = doubleCheck();
     10620                    if (objectiveValue < bestObjective) {
    1057910621#ifdef COIN_DEVELOP
    10580                     printf("Solution of %g after %d nodes at depth %d\n",
    10581                            objectiveValue, numberNodes, depth);
    10582 #endif
    10583                     if (objectiveValue < bestObjective) {
     10622                      printf("Fathoming from node %d - solution of %g after %d nodes at depth %d\n",
     10623                             info->nodeCalled_,objectiveValue,
     10624                             numberNodes, depth+info->startingDepth_);
     10625#elif !defined(NO_FATHOM_PRINT)
     10626                      if ((moreSpecialOptions_&2048)!=0)
     10627                        info->handler_->message(CLP_FATHOM_SOLUTION, messages_)
     10628                          << info->nodeCalled_ << objectiveValue
     10629                          << numberNodes << depth+info->startingDepth_
     10630                          << CoinMessageEol;
     10631#endif
    1058410632                         ClpNode node2(this, info, depth);
    1058510633                         assert (node2.sequence() < 0);
     
    1059210640                         bestStatus = CoinCopyOfArray(status_, numberTotal);
    1059310641                         bestObjective = objectiveValue - increment;
     10642                         if (perturbation_<100)
     10643                           bestObjective += 1.0e-2+1.0e-7*fabs(bestObjective);
    1059410644                         setDblParam(ClpDualObjectiveLimit, bestObjective * optimizationDirection_);
    1059510645                    } else {
    1059610646                         //#define CLP_INVESTIGATE
    10597 #ifdef CLP_INVESTIGATE
     10647#ifdef COIN_DEVELOP
    1059810648                         printf("why bad solution feasible\n");
    1059910649#endif
     
    1061710667     delete [] back;
    1061810668     stopFastDual2(info);
     10669#ifndef NO_FATHOM_PRINT
     10670     if ((moreSpecialOptions_&2048)!=0 && numberNodes >= 10000)
     10671       info->handler_->message(CLP_FATHOM_FINISH, messages_)
     10672         << info->nodeCalled_ << info->startingDepth_
     10673         << numberNodes << numberIterations << maxDepth+info->startingDepth_
     10674         << CoinMessageEol;
     10675#endif
    1061910676     //printf("fathom finished after %d nodes\n",numberNodes);
    1062010677     if (bestStatus) {
     
    1062610683          delete [] bestStatus;
    1062710684          setDblParam(ClpDualObjectiveLimit, saveBestObjective);
     10685          saveObjLimit = saveBestObjective;
    1062810686          int saveOptions = specialOptions_;
    1062910687          specialOptions_ &= ~65536;
     
    1065210710     delete [] saveUpperInternal;
    1065310711     setMaximumIterations(saveMaxIterations);
     10712     setDblParam(ClpDualObjectiveLimit, saveObjLimit);
    1065410713     return returnCode;
    1065510714}
     
    1135511414     assert (!info->saveCosts_);
    1135611415     int numberTotal = numberRows_ + numberColumns_;
    11357      double * save = new double [3*numberTotal];
     11416     double * save = new double [4*numberTotal];
     11417     CoinMemcpyN(cost_, numberTotal, save+3*numberTotal);
     11418     if (perturbation_<100) {
     11419       int saveIterations = numberIterations_;
     11420       //int saveOptions = moreSpecialOptions_;
     11421       int savePerturbation = perturbation_;
     11422       numberIterations_ = 0;
     11423       //moreSpecialOptions_ |= 128;
     11424       bool allZero = true;
     11425       for (int i=0;i<numberColumns_;i++) {
     11426         if (cost_[i]) {
     11427           if (upper_[i]>lower_[i]) {
     11428             allZero=false;
     11429             break;
     11430           }
     11431         }
     11432       }
     11433       if (allZero)
     11434         perturbation_ = 58;
     11435       static_cast< ClpSimplexDual *>(this)->perturb();
     11436       numberIterations_ = saveIterations;
     11437       //moreSpecialOptions_ = saveOptions;
     11438       perturbation_ = savePerturbation;
     11439     }
    1135811440     info->saveCosts_ = save;
    1135911441     CoinMemcpyN(cost_, numberTotal, save);
     
    1148211564          }
    1148311565          handler_->setLogLevel(saveLog);
     11566          // if done primal arrays may be rubbish
     11567          save = info->saveCosts_ + numberTotal;
     11568          CoinMemcpyN(save, numberTotal, lower_);
     11569          save += numberTotal;
     11570          CoinMemcpyN(save, numberTotal, upper_);
    1148411571     }
    1148511572     status = problemStatus_;
  • trunk/Clp/src/ClpSimplex.hpp

    r1696 r1729  
    10741074         512 bit - alternative use of solveType_
    10751075         1024 bit - don't do row copy of factorization
     1076         2048 bit - perturb in complete fathoming
     1077         4096 bit - try more for complete fathoming
    10761078     */
    10771079     inline int moreSpecialOptions() const {
     
    10901092         512 bit - alternative use of solveType_
    10911093         1024 bit - don't do row copy of factorization
     1094         2048 bit - perturb in complete fathoming
     1095         4096 bit - try more for complete fathoming
    10921096     */
    10931097     inline void setMoreSpecialOptions(int value) {
  • trunk/Clp/src/ClpSimplexDual.cpp

    r1723 r1729  
    54405440          }
    54415441          delete [] sort;
    5442           if (!numberNonZero)
     5442          if (!numberNonZero && perturbation_ < 55)
    54435443               return 1; // safer to use primal
    54445444#if 0
     
    54945494     if (perturbation_ >= 50) {
    54955495          perturbation = 1.0e-8;
     5496          if (perturbation_ > 50 && perturbation_ < 60)
     5497            perturbation = CoinMax(1.0e-8,maximumFraction);
    54965498          bool allSame = true;
    54975499          double lastValue = 0.0;
     
    61836185          // If getting nowhere - why not give it a kick
    61846186          // does not seem to work too well - do some more work
    6185           if ((specialOptions_ & 524288) != 0 &&
     6187          if ((specialOptions_ & 524288) != 0 && (moreSpecialOptions_&2048) == 0 &&
    61866188                    perturbation_ < 101 && numberIterations_ > 2 * (numberRows_ + numberColumns_)) {
    61876189               perturb();
     
    62906292          specialOptions_ |= 16384;
    62916293          // solve
     6294          int saveMaximumIterations = intParam_[ClpMaxNumIteration];
     6295          intParam_[ClpMaxNumIteration] = 100+numberRows_+numberColumns_;
    62926296          dual(0, 7);
    62936297          if (problemStatus_ == 10) {
     
    62996303               }
    63006304          }
     6305          intParam_[ClpMaxNumIteration] = saveMaximumIterations;
    63016306          specialOptions_ = saveOptions;
    6302           if (problemStatus_ == 1)
    6303                return NULL; // say infeasible
     6307          if (problemStatus_ != 0 )
     6308               return NULL; // say infeasible or odd
    63046309          // May be empty
    63056310          solveLp = (solution_ != NULL && problemStatus_ == 0);
     
    63926397          startFinishOptions = 1 + 2 + 4;
    63936398     }
    6394      if ((startFinishOptions & 1) == 0) {
     6399     if ((startFinishOptions & 1) == 0 && cost_) {
    63956400          deleteRim(1);
    63966401     } else {
  • trunk/Clp/src/ClpSimplexPrimal.cpp

    r1723 r1729  
    29262926
    29272927                    //alpha_ = rowArray_[1]->denseVector()[pivotRow_];
    2928                     CoinAssert (fabs(alpha_) > 1.0e-8);
     2928                    CoinAssert (fabs(alpha_) > 1.0e-12);
    29292929                    double multiplier = dualIn_ / alpha_;
    29302930                    rowArray_[0]->insert(pivotRow_, multiplier);
  • trunk/Clp/src/OsiClp/OsiClpSolverInterface.cpp

    r1724 r1729  
    20802080                             numberColumns,false);
    20812081#else
    2082       assert (factorization!=NULL);
     2082      assert (factorization!=NULL || small->problemStatus_ );
    20832083      factorization_ = factorization;
    20842084#endif
Note: See TracChangeset for help on using the changeset viewer.