Changeset 2063 for trunk


Ignore:
Timestamp:
Sep 14, 2014 3:54:51 AM (5 years ago)
Author:
forrest
Message:

fix typo and add some stability fixes

Location:
trunk/Clp/src
Files:
3 edited

Legend:

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

    r2046 r2063  
    25252525                         int iRow = rows[i];
    25262526                         if (checkDuplicates) {
    2527                               if (iRow >= numberRows_) {
     2527                              if (iRow < numberRows_) {
    25282528                                   if(which[iRow])
    25292529                                        numberErrors++;
  • trunk/Clp/src/ClpSimplexDual.cpp

    r2025 r2063  
    402402     double largestPrimalError = 0.0;
    403403     double largestDualError = 0.0;
     404     int numberRayTries=0;
    404405     // Start can skip some things in transposeTimes
    405406     specialOptions_ |= 131072;
     
    487488          statusOfProblemInDual(lastCleaned, factorType, saveDuals, data,
    488489                                ifValuesPass);
     490          if ((specialOptions_&2097152)!=0&&problemStatus_==1&&!ray_&&
     491              !numberRayTries) {
     492            numberRayTries=1;
     493            problemStatus_=-1;
     494          }
    489495          largestPrimalError = CoinMax(largestPrimalError, largestPrimalError_);
    490496          largestDualError = CoinMax(largestDualError, largestDualError_);
     
    12251231                    bestPossiblePivot = dualColumn(rowArray_[0], columnArray_[0], rowArray_[3],
    12261232                                                   columnArray_[1], acceptablePivot, dubiousWeights);
     1233                    if (sequenceIn_<0&&acceptablePivot>acceptablePivot_)
     1234                      acceptablePivot_ = - fabs(acceptablePivot_); // stop early exit
    12271235#if CAN_HAVE_ZERO_OBJ>1
    12281236                    if ((specialOptions_&2097152)!=0)
     
    17591767                         printf("** no column pivot\n");
    17601768#endif
    1761                     if (factorization_->pivots() < 2 && acceptablePivot_ <= 1.0e-8) {
     1769                    if ((factorization_->pivots() < 2
     1770                         ||((specialOptions_&2097152)!=0&&factorization_->pivots()<50))
     1771                        && acceptablePivot_ <= 1.0e-8 && acceptablePivot_ > 0.0) {
    17621772                         //&&goodAccuracy()) {
    17631773                         // If not in branch and bound etc save ray
    17641774                         delete [] ray_;
    1765                          if ((specialOptions_&(1024 | 4096)) == 0 || (specialOptions_ & 32) != 0) {
     1775                         if ((specialOptions_&(1024 | 4096)) == 0 || (specialOptions_ & (32|2097152)) != 0) {
    17661776                              // create ray anyway
    1767 #ifdef PRINT_RAY_METHOD
    1768                            printf("Dual creating infeasibility ray direction out %d - pivRow %d seqOut %d lower %g,val %g,upper %g\n",
    1769                                   directionOut_,spareIntArray_[3],sequenceOut_,lowerOut_,valueOut_,upperOut_);
    1770 #endif
    17711777                              ray_ = new double [ numberRows_];
    17721778                              rowArray_[0]->expand(); // in case packed
     
    17741780                              for (int i=0;i<numberRows_;i++)
    17751781                                ray_[i] = array[i];
     1782#ifdef PRINT_RAY_METHOD
     1783                              {
     1784                                double * farkas = new double [2*numberColumns_+numberRows_];
     1785                                int nBasic=0;
     1786                                int nPlusLower=0;
     1787                                int nPlusFixedLower=0;
     1788                                int nMinusLower=0;
     1789                                int nMinusFixedLower=0;
     1790                                int nPlusUpper=0;
     1791                                int nPlusFixedUpper=0;
     1792                                int nMinusUpper=0;
     1793                                int nMinusFixedUpper=0;
     1794                                memset(farkas,0,(2*numberColumns_+numberRows_)*sizeof(double));
     1795                                transposeTimes(-1.0,ray_,farkas);
     1796                                for (int i=0;i<numberRows_;i++) {
     1797                                  if (fabs(ray_[i])>1.0e-7) {
     1798                                    if (getRowStatus(i)==basic) {
     1799                                      nBasic++;
     1800                                    } else if (getRowStatus(i)==atLowerBound) {
     1801                                      if (ray_[i]>0.0)
     1802                                        nPlusLower++;
     1803                                      else
     1804                                        nMinusLower++;
     1805                                    } else if (getRowStatus(i)==atUpperBound) {
     1806                                      if (ray_[i]>0.0)
     1807                                        nPlusUpper++;
     1808                                      else
     1809                                        nMinusUpper++;
     1810                                    } else {
     1811                                      // fixed slack
     1812                                    }
     1813                                  }
     1814                                }
     1815                                printf("Slacks %d basic lower +,- %d,%d upper +,- %d,%d\n",
     1816                                       nBasic,nPlusLower,nMinusLower,nPlusUpper,nMinusLower);
     1817                                for (int i=0;i<numberColumns_;i++) {
     1818                                  if (fabs(farkas[i])>1.0e-7) {
     1819                                    if (getColumnStatus(i)==basic) {
     1820                                      nBasic++;
     1821                                    } else if (getColumnStatus(i)==atLowerBound) {
     1822                                      if (farkas[i]>0.0)
     1823                                        nPlusLower++;
     1824                                      else
     1825                                        nMinusLower++;
     1826                                    } else if (getColumnStatus(i)==atUpperBound) {
     1827                                      if (farkas[i]>0.0)
     1828                                        nPlusUpper++;
     1829                                      else
     1830                                        nMinusUpper++;
     1831                                    } else {
     1832                                      if (!lower_[i]) {
     1833                                        if (farkas[i]>0.0) {
     1834                                          nPlusFixedLower++;
     1835                                        } else {
     1836                                          nMinusFixedLower++;
     1837                                        }
     1838                                      } else {
     1839                                        if (farkas[i]>0.0) {
     1840                                          nPlusFixedUpper++;
     1841                                        } else {
     1842                                          nMinusFixedUpper++;
     1843                                        }
     1844                                      }
     1845                                    }
     1846                                  }
     1847                                }
     1848                                printf("End %d basic lower +,- %d,%d upper +,- %d,%d fixed %d,%d %d,%d\n",
     1849                                       nBasic,nPlusLower,nMinusLower,nPlusUpper,nMinusUpper,
     1850                                       nPlusFixedLower,nMinusFixedLower,nPlusFixedUpper,nMinusFixedUpper);
     1851                                printf("Dual creating infeasibility ray direction out %d - pivRow %d seqOut %d lower %g,val %g,upper %g\n",
     1852                                       directionOut_,spareIntArray_[3],sequenceOut_,lowerOut_,valueOut_,upperOut_);
     1853                                delete [] farkas;
     1854                              }
     1855#endif
    17761856                         } else {
    17771857                              ray_ = NULL;
     
    18711951                         }
    18721952                    }
     1953                    acceptablePivot_ = fabs(acceptablePivot_);
    18731954                    if (factorization_->pivots() < 5 && acceptablePivot_ > 1.0e-8)
    18741955                         acceptablePivot_ = 1.0e-8;
     
    23542435          double * COIN_RESTRICT solution = solutionRegion(0);
    23552436          double * COIN_RESTRICT reducedCost = djRegion(0);
    2356           const double * COIN_RESTRICT lower = lowerRegion(0);
    2357           const double * COIN_RESTRICT upper = upperRegion(0);
     2437          double * COIN_RESTRICT lower = lowerRegion(0);
     2438          double * COIN_RESTRICT upper = upperRegion(0);
    23582439          const double * COIN_RESTRICT cost = costRegion(0);
    23592440          int * COIN_RESTRICT which;
     
    23732454                         which[numberInfeasibilities++] = iSequence;
    23742455                         movement = lower[iSequence] - upper[iSequence];
     2456#define TRY_SET_FAKE
     2457#ifdef TRY_SET_FAKE
     2458                         if (fabs(movement) > dualBound_) {
     2459                           FakeBound bound = getFakeBound(iSequence + numberColumns_);
     2460                           if (bound == ClpSimplexDual::noFake) {
     2461                             setFakeBound(iSequence + numberColumns_,
     2462                                          ClpSimplexDual::lowerFake);
     2463                             lower[iSequence] = upper[iSequence] - dualBound_;
     2464                             assert (fabs(lower[iSequence])<1.0e30);
     2465                             movement = lower[iSequence] - upper[iSequence];
     2466                             numberFake_++;
     2467#ifndef NDEBUG
     2468                           } else {
     2469                             if (fabs(movement) >= 1.0e30)
     2470                               resetFakeBounds(-1000 - iSequence);
     2471#endif
     2472                           }
     2473                         }
     2474#endif
    23752475                         changeObj += movement * cost[iSequence];
    23762476                         outputArray->quickAdd(iSequence, -movement);
    2377 #ifndef NDEBUG
    2378                          if (fabs(movement) >= 1.0e30)
    2379                               resetFakeBounds(-1000 - iSequence);
    2380 #endif
    23812477#ifndef NO_SWAP7
    23822478                    } else if (value > -tolerance) {
     
    23862482                              movement = lower[iSequence] - upper[iSequence];
    23872483#ifndef NDEBUG
    2388                               if (fabs(movement) >= 1.0e30)
    2389                                    resetFakeBounds(-1000 - iSequence);
     2484                              if (fabs(movement) >= 1.0e30)
     2485                                resetFakeBounds(-1000 - iSequence);
    23902486#endif
    23912487                              setStatus(iSequence + numberColumns_, atLowerBound);
     
    24052501                         which[numberInfeasibilities++] = iSequence;
    24062502                         movement = upper[iSequence] - lower[iSequence];
     2503#ifdef TRY_SET_FAKE
     2504                         if (fabs(movement) > dualBound_) {
     2505                           FakeBound bound = getFakeBound(iSequence + numberColumns_);
     2506                           if (bound == ClpSimplexDual::noFake) {
     2507                             setFakeBound(iSequence + numberColumns_,
     2508                                          ClpSimplexDual::upperFake);
     2509                             upper[iSequence] = lower[iSequence] + dualBound_;
     2510                             assert (fabs(upper[iSequence])<1.0e30);
     2511                             movement = upper[iSequence] - lower[iSequence];
     2512                             numberFake_++;
    24072513#ifndef NDEBUG
    2408                          if (fabs(movement) >= 1.0e30)
    2409                               resetFakeBounds(-1000 - iSequence);
     2514                           } else {
     2515                             if (fabs(movement) >= 1.0e30)
     2516                               resetFakeBounds(-1000 - iSequence);
     2517#endif
     2518                           }
     2519                         }
    24102520#endif
    24112521                         changeObj += movement * cost[iSequence];
     
    24182528                              movement = upper[iSequence] - lower[iSequence];
    24192529#ifndef NDEBUG
    2420                               if (fabs(movement) >= 1.0e30)
    2421                                    resetFakeBounds(-1000 - iSequence);
     2530                              if (fabs(movement) >= 1.0e30)
     2531                                resetFakeBounds(-1000 - iSequence);
    24222532#endif
    24232533                              setStatus(iSequence + numberColumns_, atUpperBound);
     
    24542564                         which[numberInfeasibilities++] = iSequence;
    24552565                         movement = upper[iSequence] - lower[iSequence];
     2566#ifdef TRY_SET_FAKE
     2567                         if (fabs(movement) > dualBound_) {
     2568                           FakeBound bound = getFakeBound(iSequence);
     2569                           if (bound == ClpSimplexDual::noFake) {
     2570                             setFakeBound(iSequence,
     2571                                          ClpSimplexDual::upperFake);
     2572                             upper[iSequence] = lower[iSequence] + dualBound_;
     2573                             assert (fabs(upper[iSequence])<1.0e30);
     2574                             movement = upper[iSequence] - lower[iSequence];
     2575                             numberFake_++;
    24562576#ifndef NDEBUG
    2457                          if (fabs(movement) >= 1.0e30)
    2458                               resetFakeBounds(-1000 - iSequence);
     2577                           } else {
     2578                             if (fabs(movement) >= 1.0e30)
     2579                               resetFakeBounds(-1000 - iSequence);
     2580#endif
     2581                           }
     2582                         }
    24592583#endif
    24602584                         changeObj += movement * cost[iSequence];
     
    24672591                              movement = upper[iSequence] - lower[iSequence];
    24682592#ifndef NDEBUG
    2469                               if (fabs(movement) >= 1.0e30)
    2470                                    resetFakeBounds(-1000 - iSequence);
     2593                              if (fabs(movement) >= 1.0e30)
     2594                                resetFakeBounds(-1000 - iSequence);
    24712595#endif
    24722596                              setStatus(iSequence, atUpperBound);
     
    24862610                         which[numberInfeasibilities++] = iSequence;
    24872611                         movement = lower[iSequence] - upper[iSequence];
     2612#ifdef TRY_SET_FAKE
     2613                         if (fabs(movement) > dualBound_) {
     2614                           FakeBound bound = getFakeBound(iSequence);
     2615                           if (bound == ClpSimplexDual::noFake) {
     2616                             setFakeBound(iSequence,
     2617                                          ClpSimplexDual::lowerFake);
     2618                             lower[iSequence] = upper[iSequence] - dualBound_;
     2619                             assert (fabs(lower[iSequence])<1.0e30);
     2620                             movement = lower[iSequence] - upper[iSequence];
     2621                             numberFake_++;
    24882622#ifndef NDEBUG
    2489                          if (fabs(movement) >= 1.0e30)
    2490                               resetFakeBounds(-1000 - iSequence);
     2623                           } else {
     2624                             if (fabs(movement) >= 1.0e30)
     2625                               resetFakeBounds(-1000 - iSequence);
     2626#endif
     2627                           }
     2628                         }
    24912629#endif
    24922630                         changeObj += movement * cost[iSequence];
     
    24992637                              movement = lower[iSequence] - upper[iSequence];
    25002638#ifndef NDEBUG
    2501                               if (fabs(movement) >= 1.0e30)
    2502                                    resetFakeBounds(-1000 - iSequence);
     2639                              if (fabs(movement) >= 1.0e30)
     2640                                resetFakeBounds(-1000 - iSequence);
    25032641#endif
    25042642                              setStatus(iSequence, atLowerBound);
     
    38774015          if (handler_->logLevel() > 1)
    38784016               *handler_ << "forcing re-factorization" << CoinMessageEol;
     4017          //printf("badSumPivots %g theta_ %g badFree %g\n",badSumPivots,theta_,badFree);
    38794018          sequenceIn_ = -1;
     4019          acceptablePivot_=-acceptablePivot_;
    38804020     }
    38814021#endif
     
    64516591          if (problemStatus_ == 10) {
    64526592               ClpSimplex::dual(0, 0);
     6593               //if (problemStatus_)
     6594               //printf("second go in hot start %d iterations - status %d\n",
     6595               //       numberIterations_,problemStatus_);
    64536596               assert (problemStatus_ != 10);
    64546597               if (problemStatus_ == 0) {
    6455                     dual(0, 7);
    6456                     //assert (problemStatus_!=10);
     6598                 dual(0, 7);
     6599#if 0
     6600                 if (problemStatus_) {
     6601                   printf("third go in hot start %d iterations - status %d\n",
     6602                          numberIterations_,problemStatus_);
     6603                   //ClpSimplex::dual(0, 7);
     6604                   //printf("fourth go (part 1) in hot start %d iterations - status %d\n",
     6605                   //     numberIterations_,problemStatus_);
     6606                 }
     6607#endif
     6608#if 0
     6609                 if (problemStatus_==10 && rowScale_) {
     6610                   ClpSimplex::dual(0, 0);
     6611                   printf("fourth go (part 1) in hot start %d iterations - status %d\n",
     6612                      numberIterations_,problemStatus_);
     6613                   scaling(0);
     6614                   dual(0, 7);
     6615                   printf("fourth go (part 2) in hot start %d iterations - status %d\n",
     6616                      numberIterations_,problemStatus_);
     6617                   //assert (problemStatus_!=10);
     6618                 }
     6619#endif
    64576620               }
    64586621          }
    64596622          intParam_[ClpMaxNumIteration] = saveMaximumIterations;
    64606623          specialOptions_ = saveOptions;
    6461           if (problemStatus_ != 0 && problemStatus_ != 10)
     6624          if (problemStatus_ != 0 /*&& problemStatus_ != 10*/)
    64626625               return NULL; // say infeasible or odd
    64636626          // May be empty
  • trunk/Clp/src/OsiClp/OsiClpSolverInterface.cpp

    r2061 r2063  
    16231623  const int status = modelPtr_->status();
    16241624  const int secondaryStatus = modelPtr_->secondaryStatus();
    1625   return (status == 3 && secondaryStatus == 0);
     1625  return (status == 3 && secondaryStatus != 9);
    16261626}
    16271627
Note: See TracChangeset for help on using the changeset viewer.