Changeset 2006


Ignore:
Timestamp:
Dec 12, 2013 10:40:41 AM (5 years ago)
Author:
forrest
Message:

changes for parallel and idiot

Location:
stable/1.15/Clp/src
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • stable/1.15/Clp/src/AbcSimplex.cpp

    r1989 r2006  
    139139  lowerBasic_=lowerSaved_+numberTotal;
    140140  upperBasic_=upperSaved_+numberTotal;
    141   costBasic_=costSaved_+numberTotal;
     141  costBasic_=costSaved_+2*numberTotal;
    142142  solutionBasic_=solutionSaved_+numberTotal;
    143143  djBasic_=djSaved_+numberTotal;
     
    55995599      elAddress[i]=usefulArray_[i].denseVector();
    56005600  } else {
     5601    if(elAddress[0]!=usefulArray_[0].denseVector()) {
     5602      printf("elAddress not zero and does not match??\n");
     5603      for (int i=0;i<ABC_NUMBER_USEFUL_NORMAL;i++)
     5604        elAddress[i]=usefulArray_[i].denseVector();
     5605    }
    56015606    for (int i=0;i<ABC_NUMBER_USEFUL_NORMAL;i++)
    56025607      assert(elAddress[i]==usefulArray_[i].denseVector());
     
    58975902  return -1;
    58985903#endif
    5899   double objective = model->rawObjectiveValue();
    5900   if (model->algorithm() < 0)
    5901     objective -= model->bestPossibleImprovement();
     5904  double objective;
     5905  if (model_->algorithm() < 0) {
     5906    objective = model_->rawObjectiveValue();
     5907    objective -= model_->bestPossibleImprovement();
     5908  } else {
     5909    objective = model->abcNonLinearCost()->feasibleReportCost();
     5910  }
    59025911  double infeasibility;
    59035912  double realInfeasibility = 0.0;
    59045913  int numberInfeasibilities;
    59055914  int iterationNumber = model->numberIterations();
    5906   numberTimesFlagged_ = 0;
     5915  //numberTimesFlagged_ = 0;
    59075916  if (model->algorithm() < 0) {
    59085917    // dual
  • stable/1.15/Clp/src/AbcSimplexPrimal.cpp

    r1910 r2006  
    332332      if (factorType)
    333333        statusOfProblemInPrimal(factorType);
     334      if (problemStatus_==10 && (moreSpecialOptions_ & 2048) != 0) {
     335        problemStatus_=0;
     336      }
    334337      if (initialStatus == 10) {
    335338        initialStatus=-1;
     
    436439  // clean up
    437440  unflag();
     441  abcProgress_.clearTimesFlagged();
    438442#if ABC_PARALLEL>0
    439443  if (parallelMode()) {
     
    512516  // status stays at -1 while iterating, >=0 finished, -2 to invert
    513517  // status -3 to go to top without an invert
     518  int numberFlaggedStart =abcProgress_.timesFlagged();
    514519  while (problemStatus_ == -1) {
    515520    if (!ifValuesPass) {
     
    650655        problemStatus_ = -2; //
    651656      } else if (returnCode == -5) {
     657        if (abcProgress_.timesFlagged()>10+numberFlaggedStart)
     658          problemStatus_ =-2;
    652659        if ((moreSpecialOptions_ & 16) == 0 && abcFactorization_->pivots()) {
    653660          moreSpecialOptions_ |= 16;
     
    795802              setFlagged(sequenceOut_);
    796803            }
     804            abcProgress_.incrementTimesFlagged();
    797805            double newTolerance = CoinMax(0.5 + 0.499 * randomNumberGenerator_.randomDouble(), abcFactorization_->pivotTolerance());
    798806            abcFactorization_->pivotTolerance(newTolerance);
     
    959967            setFlagged(sequenceOut_);
    960968          }
     969          abcProgress_.incrementTimesFlagged();
    961970        }
    962971        type = 2; // so will restore weights
     
    9921001  else
    9931002    loop = -1;
     1003  if ((moreSpecialOptions_ & 2048) != 0 && !numberPrimalInfeasibilities_ && numberDualInfeasibilities_) {
     1004    double average = sumDualInfeasibilities_ / (static_cast<double> (numberDualInfeasibilities_));
     1005    if (abcProgress_.lastIterationNumber(2)==numberIterations_&&
     1006        ((abcProgress_.timesFlagged()>2&&average < 1.0e-1)||
     1007         abcProgress_.timesFlagged()>20)) {
     1008      numberDualInfeasibilities_ = 0;
     1009      sumDualInfeasibilities_ = 0.0;
     1010      problemStatus_=3;
     1011      loop=0;
     1012    }
     1013  }
    9941014  if (loop >= 0) {
    9951015    if (!problemStatus_) {
     
    12651285#endif
    12661286          unflag();
     1287        abcProgress_.clearTimesFlagged();
    12671288#if ABC_NORMAL_DEBUG>3
    12681289        if (unflagged && handler_->logLevel() > 0)
     
    13741395      }
    13751396      bool unflagged = (unflag() != 0);
     1397      abcProgress_.clearTimesFlagged();
    13761398      if ( lastCleaned_ != numberIterations_ || unflagged) {
    13771399        handler_->message(CLP_PRIMAL_OPTIMAL, messages_)
     
    14711493        //bool unflagged =
    14721494        unflag();
     1495        abcProgress_.clearTimesFlagged();
    14731496        if (sumDualInfeasibilities_ < 1.0e-3 ||
    14741497            (sumDualInfeasibilities_ / static_cast<double> (numberDualInfeasibilities_)) < 1.0e-5 ||
     
    17001723                            int valuesPass)
    17011724{
    1702 #if 0
     1725#if 1
    17031726  for (int iRow=0;iRow<numberRows_;iRow++) {
    17041727    int iPivot=abcPivotVariable_[iRow];
     
    31543177  // unflag
    31553178  unflag();
     3179  abcProgress_.clearTimesFlagged();
    31563180  // get a valid nonlinear cost function
    31573181  delete abcNonLinearCost_;
     
    32913315            << CoinMessageEol;
    32923316          setFlagged(sequenceIn_);
     3317          abcProgress_.incrementTimesFlagged();
    32933318          abcProgress_.clearBadTimes();
    32943319          lastBadIteration_ = numberIterations_; // say be more cautious
     
    33483373              << CoinMessageEol;
    33493374            setFlagged(sequenceIn_);
     3375            abcProgress_.incrementTimesFlagged();
    33503376#if 1 //def FEB_TRY
    33513377            // Make safer?
     
    34203446            << CoinMessageEol;
    34213447          setFlagged(sequenceIn_);
     3448          abcProgress_.incrementTimesFlagged();
    34223449          abcProgress_.clearBadTimes();
    34233450          lastBadIteration_ = numberIterations_; // say be more cautious
     
    34653492              << CoinMessageEol;
    34663493            setFlagged(sequenceIn_);
     3494            abcProgress_.incrementTimesFlagged();
    34673495            abcProgress_.clearBadTimes();
    34683496            roundAgain = true;
     
    37333761            << CoinMessageEol;
    37343762          setFlagged(sequenceIn_);
     3763          abcProgress_.incrementTimesFlagged();
    37353764          abcProgress_.clearBadTimes();
    37363765          lastBadIteration_ = numberIterations_; // say be more cautious
     
    39413970        << CoinMessageEol;
    39423971      setFlagged(sequenceIn_);
     3972      abcProgress_.incrementTimesFlagged();
    39433973      abcProgress_.clearBadTimes();
    39443974      lastBadIteration_ = numberIterations_; // say be more cautious
  • stable/1.15/Clp/src/ClpSimplex.hpp

    r1989 r2006  
    11851185         debug
    11861186         32768 bit - do dual in netlibd
    1187          65536 (*3) initial stateDualColumn
    11881187     */
    11891188     inline int moreSpecialOptions() const {
     
    12081207         32768 bit - don't swap algorithms from dual if small infeasibility
    12091208         65536 bit - perturb in postsolve cleanup (even if < 10000 rows)
     1209         1048576 bit - don't perturb even if long time
    12101210     */
    12111211     inline void setMoreSpecialOptions(int value) {
  • stable/1.15/Clp/src/ClpSimplexDual.cpp

    r1995 r2006  
    442442          // If getting nowhere - why not give it a kick
    443443          // does not seem to work too well - do some more work
    444           if (perturbation_ < 101 && numberIterations_ > 2 * (numberRows_ + numberColumns_)
     444          if (perturbation_ < 101 && numberIterations_ > 2 * (numberRows_ + numberColumns_) && (moreSpecialOptions_&1048576)==0
    445445                    && initialStatus != 10) {
    446446               perturb();
     
    784784               // If getting nowhere - why not give it a kick
    785785               // does not seem to work too well - do some more work
    786                if (perturbation_ < 101 && numberIterations_ > 2 * (numberRows_ + numberColumns_)
     786               if (perturbation_ < 101 && numberIterations_ > 2 * (numberRows_ + numberColumns_) && (moreSpecialOptions_&1048576)==0
    787787                         && initialStatus != 10) {
    788788                    perturb();
     
    63306330          // does not seem to work too well - do some more work
    63316331          if ((specialOptions_ & 524288) != 0 && (moreSpecialOptions_&2048) == 0 &&
    6332                     perturbation_ < 101 && numberIterations_ > 2 * (numberRows_ + numberColumns_)) {
     6332                    perturbation_ < 101 && numberIterations_ > 2 * (numberRows_ + numberColumns_) && (moreSpecialOptions_&1048576)==0) {
    63336333               perturb();
    63346334               // Can't get here if values pass
  • stable/1.15/Clp/src/ClpSimplexPrimal.cpp

    r1931 r2006  
    507507                    int status = eventHandler_->event(ClpEventHandler::endOfFactorization);
    508508                    if (status >= 0) {
    509                          problemStatus_ = 5;
    510                          secondaryStatus_ = ClpEventHandler::endOfFactorization;
    511                          break;
     509                        // if >=100 - then special e.g. unperturb
     510                        if (status!=101) {
     511                          problemStatus_ = 5;
     512                          secondaryStatus_ = ClpEventHandler::endOfFactorization;
     513                          break;
     514                        } else {
     515                          unPerturb();
     516                          continue;
     517                        }
    512518                    }
    513519               }
  • stable/1.15/Clp/src/ClpSolve.cpp

    r1989 r2006  
    16941694                    // pick up number passes
    16951695                    nPasses = options.getExtraInfo(1) % 1000000;
     1696#ifdef COIN_HAS_VOL
     1697                    int returnCode = solveWithVolume(model2, nPasses, saveDoIdiot);
     1698                    nPasses=0;
     1699                    if (!returnCode) {
     1700                      time2 = CoinCpuTime();
     1701                      timeIdiot = time2 - timeX;
     1702                      handler_->message(CLP_INTERVAL_TIMING, messages_)
     1703                        << "Idiot Crash" << timeIdiot << time2 - time1
     1704                        << CoinMessageEol;
     1705                      timeX = time2;
     1706                    }
     1707#endif
    16961708                    if (nPasses > 70) {
    16971709                         info.setStartingWeight(1.0e3);
     
    35823594     if (model_->algorithm() < 0) {
    35833595       objective = model_->rawObjectiveValue();
    3584           objective -= model_->bestPossibleImprovement();
     3596       objective -= model_->bestPossibleImprovement();
    35853597     } else {
    3586        objective = model_->rawObjectiveValue();
     3598       objective = model_->nonLinearCost()->feasibleReportCost();
    35873599     }
    35883600     double infeasibility;
     
    35903602     int numberInfeasibilities;
    35913603     int iterationNumber = model_->numberIterations();
    3592      numberTimesFlagged_ = 0;
     3604     //numberTimesFlagged_ = 0;
    35933605     if (model_->algorithm() < 0) {
    35943606          // dual
  • stable/1.15/Clp/src/CoinAbcBaseFactorization1.cpp

    r1910 r2006  
    14831483                 eArea,saveColumn,startColumnU,tempColumnCount,
    14841484                 elementU,numberInColumn,indexRowU);
     1485    assert (tempColumnCount[0]>=0);
    14851486    for (int iTry=numberZeroOther-1;iTry>=0;iTry--) {
    14861487      pivotWhile(0,numberInPivotRow,numberInPivotColumn,lengthArea,giveUp,
    14871488                 eArea,multipliersL);
     1489    assert (tempColumnCount[0]>=0);
    14881490      // find new pivot row
    14891491      int jPivotColumn=others[iTry];
     
    15061508        // put away last
    15071509        afterPivot(pivotRow,pivotColumn);
     1510        if (reinterpret_cast<unsigned int *>(elementUColumnPlusAddress_+lastEntryByColumnUPlus_)>aBits) {
     1511#ifndef NDEBUG
     1512          printf("? dense\n");
     1513#endif
     1514          return -99;
     1515        }
    15081516        // new ones
    15091517        pivotRow=indexL[jPivotRow];
     
    15271535        lastRow[pivotRow] = -2;
    15281536        numberInRow[pivotRow] = 0;
     1537    assert (tempColumnCount[0]>=0);
    15291538        //store column in L, compress in U and take column out
    15301539        CoinBigIndex l = lengthL_;
     
    15391548        // move to L and move last
    15401549        numberInPivotColumn--;
     1550    assert (tempColumnCount[0]>=0);
    15411551        if (jPivotRow!=numberInPivotColumn) {
    15421552          // swap
     
    15561566          jPivotRow=numberInPivotColumn;
    15571567        }
     1568    assert (tempColumnCount[0]>=0);
    15581569        numberInPivotRow--;
    15591570        CoinFactorizationDouble pivotElement = area[numberInPivotColumn];
     
    15681579        totalElements_-=numberInColumn[pivotColumn];
    15691580        mark[pivotColumn]=0;
     1581    assert (tempColumnCount[0]>=0);
    15701582        for (int jRow=0;jRow<numberInPivotColumn+1;jRow++) {
    15711583          CoinFactorizationDouble temp=areaLast[jRow];
     
    15781590          CoinFactorizationDouble * COIN_RESTRICT area =eArea+jColumn*lengthArea;
    15791591          CoinFactorizationDouble thisPivotValue = area[numberInPivotColumn];
     1592    assert (tempColumnCount[0]>=0);
    15801593          area[numberInPivotColumn]=thisPivotValue;
    15811594          if (fabs(thisPivotValue)>tolerance) {
     
    16011614          }
    16021615        }
     1616    assert (tempColumnCount[0]>=0);
    16031617        // put away last (but remember count is one out)
    16041618        CoinAbcMemcpy(elementL+lSave,multipliersL,numberInPivotColumn+1);
     
    16311645      }
    16321646    }
     1647    assert (tempColumnCount[0]>=0);
    16331648#if 0
    16341649    // zero out extra bits
  • stable/1.15/Clp/src/Idiot.cpp

    r1931 r2006  
    10721072     muAtExit_ = mu;
    10731073     // For last iteration make as feasible as possible
    1074      if (oddSlacks)
     1074     if (oddSlacks && (strategy_&32768)==0)
    10751075          strategy_ |= 16384;
    10761076     // not scaled
Note: See TracChangeset for help on using the changeset viewer.