Changeset 1710


Ignore:
Timestamp:
Mar 24, 2011 10:05:58 AM (9 years ago)
Author:
forrest
Message:

fix for initialSolve being called from odd place and fixes for difficult problems

Location:
trunk/Clp/src
Files:
2 edited

Legend:

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

    r1703 r1710  
    37453745{
    37463746     // If mode changes then we treat as new matrix (need new row copy)
    3747      if (mode != scalingFlag_)
     3747     if (mode != scalingFlag_) {
    37483748          whatsChanged_ &= ~(2 + 4 + 8);
     3749          // Get rid of scaled matrix
     3750          setClpScaledMatrix(NULL);
     3751     }
    37493752     if (mode > 0 && mode < 6) {
    37503753          scalingFlag_ = mode;
  • trunk/Clp/src/ClpSimplexDual.cpp

    r1706 r1710  
    605605          }
    606606     }
     607     // If infeasible but primal errors - try dual
     608     if (problemStatus_==1 && numberPrimalInfeasibilities_) {
     609       bool inCbcOrOther = (specialOptions_ & 0x03000000) != 0;
     610       double factor = (!inCbcOrOther) ? 1.0 : 0.3;
     611       double averageInfeasibility = sumPrimalInfeasibilities_/
     612         static_cast<double>(numberPrimalInfeasibilities_);
     613       if (averageInfeasibility<factor*largestPrimalError_)
     614         problemStatus_= 10;
     615     }
     616       
    607617     if (problemStatus_ == 10)
    608618          startFinishOptions |= 1;
     
    39873997          z_thinks += 2;
    39883998#endif
     3999     bool arraysNotCreated = (type==0);
    39894000     // If lots of iterations then adjust costs if large ones
    39904001     if (numberIterations_ > 4 * (numberRows_ + numberColumns_) && objectiveScale_ == 1.0) {
     
    48894900                    columnArray_[0]->clear();
    48904901                    double objectiveChange = 0.0;
     4902                    double savePrimalInfeasibilities = sumPrimalInfeasibilities_;
     4903                    if (!numberIterations_) {
     4904                      int nTotal = numberRows_ + numberColumns_;
     4905                      if (arraysNotCreated) {
     4906                        // create save arrays
     4907                        delete [] saveStatus_;
     4908                        delete [] savedSolution_;
     4909                        saveStatus_ = new unsigned char [nTotal];
     4910                        savedSolution_ = new double [nTotal];
     4911                        arraysNotCreated = false;
     4912                      }
     4913                      // save arrays
     4914                      CoinMemcpyN(status_, nTotal, saveStatus_);
     4915                      CoinMemcpyN(rowActivityWork_,
     4916                                  numberRows_, savedSolution_ + numberColumns_);
     4917                      CoinMemcpyN(columnActivityWork_, numberColumns_, savedSolution_);
     4918                    }
    48914919#if 0
    48924920                    double * xcost = new double[numberRows_+numberColumns_];
     
    49384966                                      0.0, objectiveChange, true);
    49394967                    dualTolerance_ = saveTolerance;
     4968                    if (!numberIterations_ && sumPrimalInfeasibilities_ >
     4969                        1.0e5*(savePrimalInfeasibilities+1.0e3) &&
     4970                        (moreSpecialOptions_ & 256) == 0) {
     4971                      // Use primal
     4972                      int nTotal = numberRows_ + numberColumns_;
     4973                      CoinMemcpyN(saveStatus_, nTotal, status_);
     4974                      CoinMemcpyN(savedSolution_ + numberColumns_ ,
     4975                                  numberRows_, rowActivityWork_);
     4976                      CoinMemcpyN(savedSolution_ ,
     4977                                  numberColumns_, columnActivityWork_);
     4978                      //numberDualInfeasibilities_=1;
     4979                      problemStatus_ = 10;
     4980                      situationChanged = 0;
     4981                      //numberPrimalInfeasibilities_=1;
     4982                    }
    49404983                    //assert(numberDualInfeasibilitiesWithoutFree_==0);
    49414984                    if (numberDualInfeasibilities_) {
     
    50245067#endif
    50255068          if (type == 0 || type == 1) {
    5026                if (!type) {
     5069               if (!type && arraysNotCreated) {
    50275070                    // create save arrays
    50285071                    delete [] saveStatus_;
     
    72307273                    numberFake_++;
    72317274                    if (fakeStatus == ClpSimplexDual::upperFake) {
    7232                          if (fabs(lowerValue - value) < 1.0e-5 ||
    7233                                    fabs(lowerValue + dualBound_ - value) < 1.0e-5) {
    7234                               upper_[iSequence] = lowerValue + dualBound_;
     7275                         upper_[iSequence] = lowerValue + dualBound_;
     7276                         if (status == ClpSimplex::atLowerBound) {
     7277                              solution_[iSequence] = lowerValue;
     7278                         } else if (status == ClpSimplex::atUpperBound) {
     7279                              solution_[iSequence] = upper_[iSequence];
    72357280                         } else {
    7236                               // wrong way
    7237                               if (fabs(upperValue - value) < 1.0e-5 ||
    7238                                         fabs(upperValue - dualBound_ - value) < 1.0e-5) {
    7239                                    lower_[iSequence] = upperValue - dualBound_;
    7240                                    setFakeBound(iSequence, ClpSimplexDual::lowerFake);
    7241                               } else {
    7242 #ifdef CLP_INVESTIGATE
    7243                                    printf("bad1\n");
    7244 #endif
    7245                               }
    7246                          }
    7247                          assert(fabs(upper_[iSequence] - value) < 1.0e-5 ||
    7248                                 fabs(lower_[iSequence] - value) < 1.0e-5);
     7281                              abort();
     7282                         }
    72497283                    } else if (fakeStatus == ClpSimplexDual::lowerFake) {
    7250                          if (fabs(upperValue - value) < 1.0e-5 ||
    7251                                    fabs(upperValue - dualBound_ - value) < 1.0e-5) {
    7252                               lower_[iSequence] = upperValue - dualBound_;
     7284                         lower_[iSequence] = upperValue - dualBound_;
     7285                         if (status == ClpSimplex::atLowerBound) {
     7286                              solution_[iSequence] = lower_[iSequence];
     7287                         } else if (status == ClpSimplex::atUpperBound) {
     7288                              solution_[iSequence] = upperValue;
    72537289                         } else {
    7254                               // wrong way
    7255                               if (fabs(lowerValue - value) < 1.0e-5 ||
    7256                                         fabs(lowerValue + dualBound_ - value) < 1.0e-5) {
    7257                                    upper_[iSequence] = lowerValue + dualBound_;
    7258                                    setFakeBound(iSequence, ClpSimplexDual::upperFake);
    7259                               } else {
    7260 #ifdef CLP_INVESTIGATE
    7261                                    printf("bad1\n");
    7262 #endif
    7263                               }
    7264                          }
    7265                          assert(fabs(upper_[iSequence] - value) < 1.0e-5 ||
    7266                                 fabs(lower_[iSequence] - value) < 1.0e-5);
    7267                     } else if (fakeStatus == ClpSimplexDual::bothFake) {
     7290                              abort();
     7291                         }
     7292                    } else {
     7293                         assert (fakeStatus == ClpSimplexDual::bothFake);
    72687294                         if (status == ClpSimplex::atLowerBound) {
    72697295                              lower_[iSequence] = value;
     
    72767302                              lower_[iSequence] = value - 0.5 * dualBound_;
    72777303                              upper_[iSequence] = value + 0.5 * dualBound_;
    7278                          } else if (status == ClpSimplex::isFixed) {
    7279                               abort();
    72807304                         } else {
    7281                               // basic
    7282                               abort();
    7283                               numberFake_--;
    7284                               // lower_[iSequence] = value;
    7285                               //upper_[iSequence] = value + dualBound_;
    7286                          }
    7287                     }
     7305                              abort();
     7306                         }
     7307                    }
    72887308               }
    72897309          }
Note: See TracChangeset for help on using the changeset viewer.