Ignore:
Timestamp:
Jun 19, 2011 12:27:26 PM (9 years ago)
Author:
stefan
Message:

sync with trunk rev1751

Location:
stable/1.14
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • stable/1.14

    • Property svn:externals
      •  

        old new  
        1 BuildTools  https://projects.coin-or.org/svn/BuildTools/stable/0.7
        2 ThirdParty/Blas  https://projects.coin-or.org/svn/BuildTools/ThirdParty/Blas/stable/1.2
        3 ThirdParty/Lapack  https://projects.coin-or.org/svn/BuildTools/ThirdParty/Lapack/stable/1.3
        4 Data/Sample  https://projects.coin-or.org/svn/Data/Sample/stable/1.2
        5 CoinUtils  https://projects.coin-or.org/svn/CoinUtils/stable/2.8/CoinUtils
        6 Osi  https://projects.coin-or.org/svn/Osi/stable/0.105/Osi
         1BuildTools        https://projects.coin-or.org/svn/BuildTools/stable/0.7
         2ThirdParty/Blas   https://projects.coin-or.org/svn/BuildTools/ThirdParty/Blas/stable/1.2
         3ThirdParty/Lapack https://projects.coin-or.org/svn/BuildTools/ThirdParty/Lapack/stable/1.3
         4ThirdParty/Metis  https://projects.coin-or.org/svn/BuildTools/ThirdParty/Metis/stable/1.2
         5ThirdParty/Mumps  https://projects.coin-or.org/svn/BuildTools/ThirdParty/Mumps/stable/1.4
         6ThirdParty/Glpk   https://projects.coin-or.org/svn/BuildTools/ThirdParty/Glpk/stable/1.8
         7Data/Netlib       https://projects.coin-or.org/svn/Data/Netlib/stable/1.2
         8Data/Sample       https://projects.coin-or.org/svn/Data/Sample/stable/1.2
         9CoinUtils         https://projects.coin-or.org/svn/CoinUtils/stable/2.8/CoinUtils
         10Osi               https://projects.coin-or.org/svn/Osi/stable/0.105/Osi
    • Property svn:mergeinfo changed
      /trunk (added)merged: 1670-1671,​1675-1685,​1687-1711,​1716-1727,​1729-1735,​1737-1748,​1750-1752
  • stable/1.14/Clp/src/ClpSimplexDual.cpp

    r1665 r1753  
    535535          // Do iterations
    536536          int returnCode = whileIterating(saveDuals, ifValuesPass);
     537          if (problemStatus_ == 1 && (progressFlag_&8) != 0 &&
     538              fabs(objectiveValue_) > 1.0e10 )
     539            problemStatus_ = 10; // infeasible - but has looked feasible
    537540#ifdef CLP_INVESTIGATE_SERIAL
    538541          nPivots = factorization_->pivots();
     
    605608          }
    606609     }
     610     // If infeasible but primal errors - try dual
     611     if (problemStatus_==1 && numberPrimalInfeasibilities_) {
     612       bool inCbcOrOther = (specialOptions_ & 0x03000000) != 0;
     613       double factor = (!inCbcOrOther) ? 1.0 : 0.3;
     614       double averageInfeasibility = sumPrimalInfeasibilities_/
     615         static_cast<double>(numberPrimalInfeasibilities_);
     616       if (averageInfeasibility<factor*largestPrimalError_)
     617         problemStatus_= 10;
     618     }
     619       
    607620     if (problemStatus_ == 10)
    608621          startFinishOptions |= 1;
     
    13561369                                   printf("flag a %g %g\n", btranAlpha, alpha_);
    13571370#endif
    1358                                    //#define FEB_TRY
    1359 #ifdef FEB_TRY
     1371                                   //#define FEB_TRY
     1372#if 1 //def FEB_TRY
    13601373                                   // Make safer?
    1361                                    factorization_->saferTolerances (1.0e-15, -1.03);
     1374                                   factorization_->saferTolerances (-0.99, -1.03);
    13621375#endif
    13631376                                   setFlagged(sequenceOut_);
     
    19411954                                   }
    19421955                                   if (bad >= 0)
    1943                                         printf("bad %d old %g new %g\n", bad, comp[bad], solution_[bad]);
     1956                                     COIN_DETAIL_PRINT(printf("bad %d old %g new %g\n", bad, comp[bad], solution_[bad]));
    19441957#endif
    19451958                                   checkPrimalSolution(rowActivityWork_, columnActivityWork_);
     
    39874000          z_thinks += 2;
    39884001#endif
     4002     bool arraysNotCreated = (type==0);
    39894003     // If lots of iterations then adjust costs if large ones
    39904004     if (numberIterations_ > 4 * (numberRows_ + numberColumns_) && objectiveScale_ == 1.0) {
     
    44834497        objectiveValue(),sumPrimalInfeasibilities_,
    44844498        sumDualInfeasibilities_);*/
     4499     // mark as having gone optimal if looks like it
     4500     if (!numberPrimalInfeasibilities_&&
     4501         !numberDualInfeasibilities_)
     4502       progressFlag_ |= 8;
    44854503     if (handler_->detail(CLP_SIMPLEX_STATUS, messages_) < 100) {
    44864504          handler_->message(CLP_SIMPLEX_STATUS, messages_)
     
    47084726                                   if (numberDualInfeasibilities_) {
    47094727                                        if (fabs(changeCost) > 1.0e-5)
    4710                                              printf("Odd free/unbounded combo\n");
     4728                                          COIN_DETAIL_PRINT(printf("Odd free/unbounded combo\n"));
    47114729                                        changeCost += cost_[iChosen];
    47124730                                   }
     
    48854903                    columnArray_[0]->clear();
    48864904                    double objectiveChange = 0.0;
     4905                    double savePrimalInfeasibilities = sumPrimalInfeasibilities_;
     4906                    if (!numberIterations_) {
     4907                      int nTotal = numberRows_ + numberColumns_;
     4908                      if (arraysNotCreated) {
     4909                        // create save arrays
     4910                        delete [] saveStatus_;
     4911                        delete [] savedSolution_;
     4912                        saveStatus_ = new unsigned char [nTotal];
     4913                        savedSolution_ = new double [nTotal];
     4914                        arraysNotCreated = false;
     4915                      }
     4916                      // save arrays
     4917                      CoinMemcpyN(status_, nTotal, saveStatus_);
     4918                      CoinMemcpyN(rowActivityWork_,
     4919                                  numberRows_, savedSolution_ + numberColumns_);
     4920                      CoinMemcpyN(columnActivityWork_, numberColumns_, savedSolution_);
     4921                    }
    48874922#if 0
    48884923                    double * xcost = new double[numberRows_+numberColumns_];
     
    49344969                                      0.0, objectiveChange, true);
    49354970                    dualTolerance_ = saveTolerance;
     4971                    if (!numberIterations_ && sumPrimalInfeasibilities_ >
     4972                        1.0e5*(savePrimalInfeasibilities+1.0e3) &&
     4973                        (moreSpecialOptions_ & 256) == 0) {
     4974                      // Use primal
     4975                      int nTotal = numberRows_ + numberColumns_;
     4976                      CoinMemcpyN(saveStatus_, nTotal, status_);
     4977                      CoinMemcpyN(savedSolution_ + numberColumns_ ,
     4978                                  numberRows_, rowActivityWork_);
     4979                      CoinMemcpyN(savedSolution_ ,
     4980                                  numberColumns_, columnActivityWork_);
     4981                      problemStatus_ = 10;
     4982                      situationChanged = 0;
     4983                    }
    49364984                    //assert(numberDualInfeasibilitiesWithoutFree_==0);
    49374985                    if (numberDualInfeasibilities_) {
    4938                          if (numberPrimalInfeasibilities_ || numberPivots) {
     4986                        if ((numberPrimalInfeasibilities_ || numberPivots)
     4987                            && problemStatus_!=10) {
    49394988                              problemStatus_ = -1; // carry on as normal
    49404989                         } else {
     
    50205069#endif
    50215070          if (type == 0 || type == 1) {
    5022                if (!type) {
     5071               if (!type && arraysNotCreated) {
    50235072                    // create save arrays
    50245073                    delete [] saveStatus_;
     
    51935242     if (problemStatus_ > 2)
    51945243          objectiveValue_ = approximateObjective;
     5244     if (problemStatus_ == 1 && (progressFlag_&8) != 0 &&
     5245         fabs(objectiveValue_) > 1.0e10 )
     5246       problemStatus_ = 10; // infeasible - but has looked feasible
    51955247}
    51965248/* While updateDualsInDual sees what effect is of flip
     
    53885440          }
    53895441          delete [] sort;
    5390           if (!numberNonZero)
     5442          if (!numberNonZero && perturbation_ < 55)
    53915443               return 1; // safer to use primal
    53925444#if 0
     
    54425494     if (perturbation_ >= 50) {
    54435495          perturbation = 1.0e-8;
     5496          if (perturbation_ > 50 && perturbation_ < 60)
     5497            perturbation = CoinMax(1.0e-8,maximumFraction);
    54445498          bool allSame = true;
    54455499          double lastValue = 0.0;
     
    61316185          // If getting nowhere - why not give it a kick
    61326186          // does not seem to work too well - do some more work
    6133           if ((specialOptions_ & 524288) != 0 &&
     6187          if ((specialOptions_ & 524288) != 0 && (moreSpecialOptions_&2048) == 0 &&
    61346188                    perturbation_ < 101 && numberIterations_ > 2 * (numberRows_ + numberColumns_)) {
    61356189               perturb();
     
    62386292          specialOptions_ |= 16384;
    62396293          // solve
     6294          int saveMaximumIterations = intParam_[ClpMaxNumIteration];
     6295          intParam_[ClpMaxNumIteration] = 100+numberRows_+numberColumns_;
    62406296          dual(0, 7);
    62416297          if (problemStatus_ == 10) {
     
    62476303               }
    62486304          }
     6305          intParam_[ClpMaxNumIteration] = saveMaximumIterations;
    62496306          specialOptions_ = saveOptions;
    6250           if (problemStatus_ == 1)
    6251                return NULL; // say infeasible
     6307          if (problemStatus_ != 0 )
     6308               return NULL; // say infeasible or odd
    62526309          // May be empty
    62536310          solveLp = (solution_ != NULL && problemStatus_ == 0);
     
    63406397          startFinishOptions = 1 + 2 + 4;
    63416398     }
    6342      if ((startFinishOptions & 1) == 0) {
     6399     if ((startFinishOptions & 1) == 0 && cost_) {
    63436400          deleteRim(1);
    63446401     } else {
     
    66616718                    alpha = work[i];
    66626719                    if (addSequence) {
    6663                          printf("possible - pivot row %d this %d\n", pivotRow_, iSequence);
     6720                      COIN_DETAIL_PRINT(printf("possible - pivot row %d this %d\n", pivotRow_, iSequence));
    66646721                         oldValue = dj_[iSequence2];
    66656722                         if (alpha <= -acceptablePivot) {
     
    72237280                    numberFake_++;
    72247281                    if (fakeStatus == ClpSimplexDual::upperFake) {
    7225                          if (fabs(lowerValue - value) < 1.0e-5 ||
    7226                                    fabs(lowerValue + dualBound_ - value) < 1.0e-5) {
    7227                               upper_[iSequence] = lowerValue + dualBound_;
     7282                         upper_[iSequence] = lowerValue + dualBound_;
     7283                         if (status == ClpSimplex::atLowerBound) {
     7284                              solution_[iSequence] = lowerValue;
     7285                         } else if (status == ClpSimplex::atUpperBound) {
     7286                              solution_[iSequence] = upper_[iSequence];
    72287287                         } else {
    7229                               // wrong way
    7230                               if (fabs(upperValue - value) < 1.0e-5 ||
    7231                                         fabs(upperValue - dualBound_ - value) < 1.0e-5) {
    7232                                    lower_[iSequence] = upperValue - dualBound_;
    7233                                    setFakeBound(iSequence, ClpSimplexDual::lowerFake);
    7234                               } else {
    7235 #ifdef CLP_INVESTIGATE
    7236                                    printf("bad1\n");
    7237 #endif
    7238                               }
    7239                          }
    7240                          assert(fabs(upper_[iSequence] - value) < 1.0e-5 ||
    7241                                 fabs(lower_[iSequence] - value) < 1.0e-5);
     7288                              abort();
     7289                         }
    72427290                    } else if (fakeStatus == ClpSimplexDual::lowerFake) {
    7243                          if (fabs(upperValue - value) < 1.0e-5 ||
    7244                                    fabs(upperValue - dualBound_ - value) < 1.0e-5) {
    7245                               lower_[iSequence] = upperValue - dualBound_;
     7291                         lower_[iSequence] = upperValue - dualBound_;
     7292                         if (status == ClpSimplex::atLowerBound) {
     7293                              solution_[iSequence] = lower_[iSequence];
     7294                         } else if (status == ClpSimplex::atUpperBound) {
     7295                              solution_[iSequence] = upperValue;
    72467296                         } else {
    7247                               // wrong way
    7248                               if (fabs(lowerValue - value) < 1.0e-5 ||
    7249                                         fabs(lowerValue + dualBound_ - value) < 1.0e-5) {
    7250                                    upper_[iSequence] = lowerValue + dualBound_;
    7251                                    setFakeBound(iSequence, ClpSimplexDual::upperFake);
    7252                               } else {
    7253 #ifdef CLP_INVESTIGATE
    7254                                    printf("bad1\n");
    7255 #endif
    7256                               }
    7257                          }
    7258                          assert(fabs(upper_[iSequence] - value) < 1.0e-5 ||
    7259                                 fabs(lower_[iSequence] - value) < 1.0e-5);
    7260                     } else if (fakeStatus == ClpSimplexDual::bothFake) {
     7297                              abort();
     7298                         }
     7299                    } else {
     7300                         assert (fakeStatus == ClpSimplexDual::bothFake);
    72617301                         if (status == ClpSimplex::atLowerBound) {
    72627302                              lower_[iSequence] = value;
     
    72697309                              lower_[iSequence] = value - 0.5 * dualBound_;
    72707310                              upper_[iSequence] = value + 0.5 * dualBound_;
    7271                          } else if (status == ClpSimplex::isFixed) {
    7272                               abort();
    72737311                         } else {
    7274                               // basic
    7275                               abort();
    7276                               numberFake_--;
    7277                               // lower_[iSequence] = value;
    7278                               //upper_[iSequence] = value + dualBound_;
    7279                          }
    7280                     }
     7312                              abort();
     7313                         }
     7314                    }
    72817315               }
    72827316          }
    72837317#ifndef NDEBUG
    72847318     } else {
    7285           printf("NULL lower\n");
     7319       COIN_DETAIL_PRINT(printf("NULL lower\n"));
    72867320#endif
    72877321     }
Note: See TracChangeset for help on using the changeset viewer.