Changeset 1423 for trunk/Clp


Ignore:
Timestamp:
Aug 18, 2009 6:58:35 AM (10 years ago)
Author:
forrest
Message:

more info on bad movement

File:
1 edited

Legend:

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

    r1412 r1423  
    21742174          double movement = mult*(lower[iSequence] - upper[iSequence]);
    21752175          which[numberInfeasibilities++]=iSequence;
    2176           assert (fabs(movement)<1.0e30);
     2176#ifndef NDEBUG
     2177          if (fabs(movement)>=1.0e30)
     2178            resetFakeBounds(-1000-iSequence);
     2179#endif
    21772180#ifdef CLP_DEBUG
    21782181          if ((handler_->logLevel()&32))
     
    22142217            double movement = mult*(upper[iSequence] - lower[iSequence]);
    22152218            which[numberInfeasibilities++]=iSequence;
    2216             assert (fabs(movement)<1.0e30);
     2219#ifndef NDEBUG
     2220            if (fabs(movement)>=1.0e30)
     2221              resetFakeBounds(-1000-iSequence);
     2222#endif
    22172223#ifdef CLP_DEBUG
    22182224            if ((handler_->logLevel()&32))
     
    22412247            which[numberInfeasibilities++]=iSequence;
    22422248            movement = upper[iSequence] - lower[iSequence];
    2243             assert (fabs(movement)<1.0e30);
     2249#ifndef NDEBUG
     2250            if (fabs(movement)>=1.0e30)
     2251              resetFakeBounds(-1000-iSequence);
     2252#endif
    22442253#ifdef CLP_DEBUG
    22452254            if ((handler_->logLevel()&32))
     
    22592268            which[numberInfeasibilities++]=iSequence;
    22602269            movement = lower[iSequence]-upper[iSequence];
    2261             assert (fabs(movement)<1.0e30);
     2270#ifndef NDEBUG
     2271            if (fabs(movement)>=1.0e30)
     2272              resetFakeBounds(-1000-iSequence);
     2273#endif
    22622274#ifdef CLP_DEBUG
    22632275            if ((handler_->logLevel()&32))
     
    22982310          changeObj += movement*cost[iSequence];
    22992311          outputArray->quickAdd(iSequence,-movement);
    2300           assert (fabs(movement)<1.0e30);
     2312#ifndef NDEBUG
     2313          if (fabs(movement)>=1.0e30)
     2314            resetFakeBounds(-1000-iSequence);
     2315#endif
    23012316#ifndef NO_SWAP7
    23022317        } else if (value>-tolerance) {
     
    23052320          if (bound==ClpSimplexDual::upperFake) {
    23062321            movement = lower[iSequence]-upper[iSequence];
    2307             assert (fabs(movement)<1.0e30);
     2322#ifndef NDEBUG
     2323            if (fabs(movement)>=1.0e30)
     2324              resetFakeBounds(-1000-iSequence);
     2325#endif
    23082326            setStatus(iSequence+numberColumns_,atLowerBound);
    23092327            solution[iSequence] = lower[iSequence];
     
    23222340          which[numberInfeasibilities++]=iSequence;
    23232341          movement = upper[iSequence] - lower[iSequence];
    2324           assert (fabs(movement)<1.0e30);
     2342#ifndef NDEBUG
     2343          if (fabs(movement)>=1.0e30)
     2344            resetFakeBounds(-1000-iSequence);
     2345#endif
    23252346          changeObj += movement*cost[iSequence];
    23262347          outputArray->quickAdd(iSequence,-movement);
     
    23312352          if (bound==ClpSimplexDual::lowerFake) {
    23322353            movement = upper[iSequence]-lower[iSequence];
    2333             assert (fabs(movement)<1.0e30);
     2354#ifndef NDEBUG
     2355            if (fabs(movement)>=1.0e30)
     2356              resetFakeBounds(-1000-iSequence);
     2357#endif
    23342358            setStatus(iSequence+numberColumns_,atUpperBound);
    23352359            solution[iSequence] = upper[iSequence];
     
    23652389          which[numberInfeasibilities++]=iSequence;
    23662390          movement = upper[iSequence] - lower[iSequence];
    2367           assert (fabs(movement)<1.0e30);
     2391#ifndef NDEBUG
     2392          if (fabs(movement)>=1.0e30)
     2393            resetFakeBounds(-1000-iSequence);
     2394#endif
    23682395          changeObj += movement*cost[iSequence];
    23692396          matrix_->add(this,outputArray,iSequence,movement);
     
    23742401          if (bound==ClpSimplexDual::lowerFake) {
    23752402            movement = upper[iSequence]-lower[iSequence];
    2376             assert (fabs(movement)<1.0e30);
     2403#ifndef NDEBUG
     2404          if (fabs(movement)>=1.0e30)
     2405            resetFakeBounds(-1000-iSequence);
     2406#endif
    23772407            setStatus(iSequence,atUpperBound);
    23782408            solution[iSequence] = upper[iSequence];
     
    23912421          which[numberInfeasibilities++]=iSequence;
    23922422          movement = lower[iSequence]-upper[iSequence];
    2393           assert (fabs(movement)<1.0e30);
     2423#ifndef NDEBUG
     2424          if (fabs(movement)>=1.0e30)
     2425            resetFakeBounds(-1000-iSequence);
     2426#endif
    23942427          changeObj += movement*cost[iSequence];
    23952428          matrix_->add(this,outputArray,iSequence,movement);
     
    24002433          if (bound==ClpSimplexDual::upperFake) {
    24012434            movement = lower[iSequence]-upper[iSequence];
    2402             assert (fabs(movement)<1.0e30);
     2435#ifndef NDEBUG
     2436            if (fabs(movement)>=1.0e30)
     2437              resetFakeBounds(-1000-iSequence);
     2438#endif
    24032439            setStatus(iSequence,atLowerBound);
    24042440            solution[iSequence] = lower[iSequence];
     
    68996935    double * tempUpper = CoinCopyOfArray(upper_,nTotal);
    69006936    int iSequence;
     6937    // Get scaled true bounds
    69016938    if (columnScale_) {
    69026939      for (iSequence=0;iSequence<numberColumns_;iSequence++) {
    6903         FakeBound fakeStatus = getFakeBound(iSequence);
    6904         if (fakeStatus!=noFake) {
    6905           if ((static_cast<int> (fakeStatus)&1)!=0) {
    6906             // lower
    6907             double value = columnLower_[iSequence];
    6908             if (value>-1.0e30) {
    6909               double multiplier = rhsScale_*inverseColumnScale_[iSequence];
    6910               value *= multiplier;
    6911             }
    6912             tempLower[iSequence]=value;
    6913           }
    6914           if ((static_cast<int> (fakeStatus)&2)!=0) {
    6915             // upper
    6916             double value = columnUpper_[iSequence];
    6917             if (value<1.0e30) {
    6918               double multiplier = rhsScale_*inverseColumnScale_[iSequence];
    6919               value *= multiplier;
    6920             }
    6921             tempUpper[iSequence]=value;
    6922           }
    6923         }
     6940        // lower
     6941        double value = columnLower_[iSequence];
     6942        if (value>-1.0e30) {
     6943          double multiplier = rhsScale_*inverseColumnScale_[iSequence];
     6944          value *= multiplier;
     6945        }
     6946        tempLower[iSequence]=value;
     6947        // upper
     6948        value = columnUpper_[iSequence];
     6949        if (value<1.0e30) {
     6950          double multiplier = rhsScale_*inverseColumnScale_[iSequence];
     6951          value *= multiplier;
     6952        }
     6953        tempUpper[iSequence]=value;
    69246954      }
    69256955      for (iSequence=0;iSequence<numberRows_;iSequence++) {
    6926         FakeBound fakeStatus = getFakeBound(iSequence+numberColumns_);
    6927         if (fakeStatus!=noFake) {
    6928           if ((static_cast<int> (fakeStatus)&1)!=0) {
    6929             // lower
    6930             double value = rowLower_[iSequence];
    6931             if (value>-1.0e30) {
    6932               double multiplier = rhsScale_*rowScale_[iSequence];
    6933               value *= multiplier;
    6934             }
    6935             tempLower[iSequence+numberColumns_]=value;
    6936           }
    6937           if ((static_cast<int> (fakeStatus)&2)!=0) {
    6938             // upper
    6939             double value = rowUpper_[iSequence];
    6940             if (value<1.0e30) {
    6941               double multiplier = rhsScale_*rowScale_[iSequence];
    6942               value *= multiplier;
    6943             }
    6944             tempUpper[iSequence+numberColumns_]=value;
    6945           }
    6946         }
     6956        // lower
     6957        double value = rowLower_[iSequence];
     6958        if (value>-1.0e30) {
     6959          double multiplier = rhsScale_*rowScale_[iSequence];
     6960          value *= multiplier;
     6961        }
     6962        tempLower[iSequence+numberColumns_]=value;
     6963        // upper
     6964        value = rowUpper_[iSequence];
     6965        if (value<1.0e30) {
     6966          double multiplier = rhsScale_*rowScale_[iSequence];
     6967          value *= multiplier;
     6968        }
     6969        tempUpper[iSequence+numberColumns_]=value;
    69476970      }
    69486971    } else {
    69496972      for (iSequence=0;iSequence<numberColumns_;iSequence++) {
    6950         FakeBound fakeStatus = getFakeBound(iSequence);
    6951         if ((static_cast<int> (fakeStatus)&1)!=0) {
    6952           // lower
    6953           tempLower[iSequence]=columnLower_[iSequence];
    6954         }
    6955         if ((static_cast<int> (fakeStatus)&2)!=0) {
    6956           // upper
    6957           tempUpper[iSequence]=columnUpper_[iSequence];
    6958         }
     6973        // lower
     6974        tempLower[iSequence]=columnLower_[iSequence];
     6975        // upper
     6976        tempUpper[iSequence]=columnUpper_[iSequence];
    69596977      }
    69606978      for (iSequence=0;iSequence<numberRows_;iSequence++) {
    6961         FakeBound fakeStatus = getFakeBound(iSequence+numberColumns_);
    6962         if ((static_cast<int> (fakeStatus)&1)!=0) {
    6963           // lower
    6964           tempLower[iSequence+numberColumns_]=rowLower_[iSequence];
    6965         }
    6966         if ((static_cast<int> (fakeStatus)&2)!=0) {
    6967           // upper
    6968           tempUpper[iSequence+numberColumns_]=rowUpper_[iSequence];
    6969         }
     6979        // lower
     6980        tempLower[iSequence+numberColumns_]=rowLower_[iSequence];
     6981        // upper
     6982        tempUpper[iSequence+numberColumns_]=rowUpper_[iSequence];
    69706983      }
    69716984    }
    69726985    int nFake=0;
     6986    int nErrors=0;
     6987    int nSuperBasic=0;
     6988    int nWarnings=0;
    69736989    for (iSequence=0;iSequence<nTotal;iSequence++) {
    69746990      FakeBound fakeStatus = getFakeBound(iSequence);
    69756991      Status status = getStatus(iSequence);
    69766992      bool isFake=false;
     6993      char RC = 'C';
     6994      int jSequence=iSequence;
     6995      if (jSequence>=numberColumns_) {
     6996        RC='R';
     6997        jSequence-=numberColumns_;
     6998      }
     6999      double lowerValue=tempLower[iSequence];
     7000      double upperValue=tempUpper[iSequence];
     7001      double value = solution_[iSequence];
     7002      CoinRelFltEq equal;
    69777003      if (status==atUpperBound||
    69787004          status==atLowerBound) {
    6979         double lowerValue=tempLower[iSequence];
    6980         double upperValue=tempUpper[iSequence];
    6981         double value = solution_[iSequence];
    6982         CoinRelFltEq equal;
    69837005        if (fakeStatus==ClpSimplexDual::upperFake) {
    6984           assert(equal(upper_[iSequence],(lowerValue+dualBound_)));
    6985           assert(equal(upper_[iSequence],value)||
    6986                  equal(lower_[iSequence],value));
     7006          if(!equal(upper_[iSequence],(lowerValue+dualBound_))||
     7007          !(equal(upper_[iSequence],value)||
     7008            equal(lower_[iSequence],value))) {
     7009            nErrors++;
     7010            printf("** upperFake %c%d %g <= %g <= %g true %g, %g\n",
     7011                   RC,jSequence,lower_[iSequence],solution_[iSequence],
     7012                   upper_[iSequence],lowerValue,upperValue);
     7013          }
    69877014          isFake=true;;
    69887015        } else if (fakeStatus==ClpSimplexDual::lowerFake) {
    6989           assert(equal(lower_[iSequence],(upperValue-dualBound_)));
    6990           assert(equal(upper_[iSequence],value)||
    6991                  equal(lower_[iSequence],value));
     7016          if(!equal(lower_[iSequence],(upperValue-dualBound_))||
     7017             !(equal(upper_[iSequence],value)||
     7018               equal(lower_[iSequence],value))) {
     7019            nErrors++;
     7020            printf("** lowerFake %c%d %g <= %g <= %g true %g, %g\n",
     7021                   RC,jSequence,lower_[iSequence],solution_[iSequence],
     7022                   upper_[iSequence],lowerValue,upperValue);
     7023          }
    69927024          isFake=true;;
     7025        } else if (fakeStatus==ClpSimplexDual::bothFake) {
     7026          nWarnings++;
     7027          printf("** %d at bothFake?\n",iSequence);
     7028        } else if (upper_[iSequence]-lower_[iSequence]>2.0*dualBound_) {
     7029          nErrors++;
     7030          printf("** noFake! %c%d %g <= %g <= %g true %g, %g\n",
     7031                 RC,jSequence,lower_[iSequence],solution_[iSequence],
     7032                 upper_[iSequence],lowerValue,upperValue);
     7033        }
     7034      } else if (status==superBasic||status==isFree) {
     7035        nSuperBasic++;
     7036        printf("** free or superbasic %c%d %g <= %g <= %g true %g, %g - status %d\n",
     7037               RC,jSequence,lower_[iSequence],solution_[iSequence],
     7038               upper_[iSequence],lowerValue,upperValue,status);
     7039      } else if (status==basic) {
     7040        bool odd=false;
     7041        if (!equal(lower_[iSequence],lowerValue))
     7042          odd=true;
     7043        if (!equal(upper_[iSequence],upperValue))
     7044          odd=true;
     7045        if (odd) {
     7046          printf("** basic %c%d %g <= %g <= %g true %g, %g\n",
     7047               RC,jSequence,lower_[iSequence],solution_[iSequence],
     7048               upper_[iSequence],lowerValue,upperValue);
     7049          nWarnings++;
     7050        }
     7051      } else if (status==isFixed) {
     7052        if (!equal(upper_[iSequence],lower_[iSequence])) {
     7053          nErrors++;
     7054          printf("** fixed! %c%d %g <= %g <= %g true %g, %g\n",
     7055                 RC,jSequence,lower_[iSequence],solution_[iSequence],
     7056                 upper_[iSequence],lowerValue,upperValue);
    69937057        }
    69947058      }
     
    69967060        nFake++;
    69977061      } else {
    6998         assert (fakeStatus==ClpSimplexDual::noFake);
    6999       }
    7000     }
    7001     //printf("nfake %d numberFake %d\n",nFake,numberFake_);
    7002     assert (nFake==numberFake_);
     7062        if (fakeStatus!=ClpSimplexDual::noFake) {
     7063          nErrors++;
     7064          printf("** bad fake status %c%d %d\n",
     7065                 RC,jSequence,fakeStatus);
     7066        }
     7067      }
     7068    }
     7069    if (nFake!=numberFake_) {
     7070      printf("nfake %d numberFake %d\n",nFake,numberFake_);
     7071      nErrors++;
     7072    }
     7073    if (nErrors||type<=-1000) {
     7074      printf("%d errors, %d warnings, %d free/superbasic, %d fake\n",
     7075             nErrors,nWarnings,nSuperBasic,numberFake_);
     7076      printf("dualBound %g\n",
     7077             dualBound_);
     7078      if (type<=-1000) {
     7079        iSequence = -type;
     7080        iSequence -= 1000;
     7081        char RC = 'C';
     7082        int jSequence=iSequence;
     7083        if (jSequence>=numberColumns_) {
     7084          RC='R';
     7085          jSequence-=numberColumns_;
     7086        }
     7087        double lowerValue=tempLower[iSequence];
     7088        double upperValue=tempUpper[iSequence];
     7089        printf("*** movement>1.0e30 for  %c%d %g <= %g <= %g true %g, %g - status %d\n",
     7090                 RC,jSequence,lower_[iSequence],solution_[iSequence],
     7091               upper_[iSequence],lowerValue,upperValue,status_[iSequence]);
     7092        assert (nErrors); // should have been picked up
     7093      }
     7094      assert (!nErrors);
     7095    }
    70037096    delete [] tempLower;
    70047097    delete [] tempUpper;
Note: See TracChangeset for help on using the changeset viewer.