Changeset 98


Ignore:
Timestamp:
Jan 21, 2003 12:06:20 PM (17 years ago)
Author:
forrest
Message:

Relax a tolerance

Location:
trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/ClpSimplex.cpp

    r95 r98  
    32443244  assert(!pivot); // rest not coded yet
    32453245  assert(!rowObjective_); // not coded
    3246   int i;
     3246  int iColumn;
    32473247  int numberBad=0;
    32483248  int numberBasic=0;
     
    32523252    createStatus();
    32533253 
    3254   for (i=0;i<numberColumns_;i++) {
    3255     if (getColumnStatus(i)==basic)
     3254  for (iColumn=0;iColumn<numberColumns_;iColumn++) {
     3255    if (getColumnStatus(iColumn)==basic)
    32563256      numberBasic++;
    32573257  }
     
    32603260    return 0;
    32613261  } else {
    3262     for (i=0;i<numberColumns_;i++) {
     3262    double * dj = new double [numberColumns_];
     3263    double objectiveValue=0.0;
     3264    int iColumn;
     3265    for (iColumn=0;iColumn<numberColumns_;iColumn++)
     3266      dj[iColumn] = optimizationDirection_*objective_[iColumn];
     3267    for (iColumn=0;iColumn<numberColumns_;iColumn++) {
    32633268      // assume natural place is closest to zero
    3264       double lowerBound = columnLower_[i];
    3265       double upperBound = columnUpper_[i];
     3269      double lowerBound = columnLower_[iColumn];
     3270      double upperBound = columnUpper_[iColumn];
    32663271      if (lowerBound>-1.0e20||upperBound<1.0e20) {
    32673272        bool atLower;
    32683273        if (fabs(upperBound)<fabs(lowerBound)) {
    32693274          atLower=false;
    3270           setColumnStatus(i,atUpperBound);
     3275          setColumnStatus(iColumn,atUpperBound);
    32713276        } else {
    32723277          atLower=true;
    3273           setColumnStatus(i,atLowerBound);
    3274         }
    3275         if (optimizationDirection_*objective_[i]<0.0) {
     3278          setColumnStatus(iColumn,atLowerBound);
     3279        }
     3280        if (dj[iColumn]<0.0) {
    32763281          // should be at upper bound
    32773282          if (atLower) {
    32783283            // can we flip
    32793284            if (upperBound-lowerBound<=gap) {
    3280               columnActivity_[i]=upperBound;
    3281               setColumnStatus(i,atUpperBound);
    3282             } else {
     3285              columnActivity_[iColumn]=upperBound;
     3286              setColumnStatus(iColumn,atUpperBound);
     3287            } else if (dj[iColumn]<-dualTolerance_) {
    32833288              numberBad++;
    32843289            }
    32853290          }
    3286         } else if (optimizationDirection_*objective_[i]>0.0) {
     3291        } else if (dj[iColumn]>0.0) {
    32873292          // should be at lower bound
    32883293          if (!atLower) {
    32893294            // can we flip
    32903295            if (upperBound-lowerBound<=gap) {
    3291               columnActivity_[i]=lowerBound;
    3292               setColumnStatus(i,atLowerBound);
    3293             } else {
     3296              columnActivity_[iColumn]=lowerBound;
     3297              setColumnStatus(iColumn,atLowerBound);
     3298            } else if (dj[iColumn]>dualTolerance_) {
    32943299              numberBad++;
    32953300            }
     
    32983303      } else {
    32993304        // free
    3300         setColumnStatus(i,isFree);
    3301         if (objective_[i])
     3305        setColumnStatus(iColumn,isFree);
     3306        if (fabs(dj[iColumn])>dualTolerance_)
    33023307          numberBad++;
    33033308      }
     
    33053310    if (numberBad) {
    33063311      if (!pivot) {
     3312        delete [] dj;
    33073313        return 1;
    33083314      } else {
     3315#if 0
    33093316        // see if can be made dual feasible with gubs etc
    3310         // steal coding from tightenPrimalBounds
     3317        double * pi = new double[numberRows_];
     3318        memset (pi,0,numberRows_*sizeof(double));
     3319        int * way = new int[numberColumns];
     3320
    33113321        // Get column copy
    33123322        CoinPackedMatrix * columnCopy = matrix();
     
    33153325        copy.reverseOrderedCopyOf(*columnCopy);
    33163326        // get matrix data pointers
    3317 #if 0
    33183327        const int * column = copy.getIndices();
    33193328        const CoinBigIndex * rowStart = copy.getVectorStarts();
     
    33243333        const int * columnLength = columnCopy->getVectorLengths();
    33253334        const double * element = columnCopy->getElements();
     3335
     3336       
    33263337        // if equality row and bounds mean artificial in basis bad
    33273338        // then do anyway
     3339
     3340        for (iColumn=0;iColumn<numberColumns_;iColumn++) {
     3341          // - if we want to reduce dj, + if we want to increase
     3342          int thisWay = 100;
     3343          double lowerBound = columnLower_[iColumn];
     3344          double upperBound = columnUpper_[iColumn];
     3345          if (upperBound>lowerBound) {
     3346            switch(getColumnStatus(iColumn)) {
     3347             
     3348            case basic:
     3349              thisWay=0;
     3350              break;
     3351            case isFree:
     3352            case superBasic:
     3353              if (dj[iColumn]<-dualTolerance)
     3354                thisWay = 1;
     3355              else if (dj[iColumn]>dualTolerance)
     3356                thisWay = -1;
     3357              else
     3358                thisWay =0;
     3359              break;
     3360            case atUpperBound:
     3361              if (dj[iColumn]>dualTolerance)
     3362                thisWay = -1;
     3363              else if (dj[iColumn]<-dualTolerance)
     3364                thisWay = -3;
     3365              else
     3366                thisWay = -2;
     3367              break;
     3368            case atLowerBound:
     3369              if (dj[iColumn]<-dualTolerance)
     3370                thisWay = 1;
     3371              else if (dj[iColumn]>dualTolerance)
     3372                thisWay = 3;
     3373              else
     3374                thisWay = 2;
     3375              break;
     3376            }
     3377          }
     3378          way[iColumn] = thisWay;
     3379        }
     3380        // we need to maximize chance of doing good
     3381        int iRow;
     3382        for (iRow=0;iRow<numberRows_;iRow++) {
     3383          double lowerBound = rowLower_[iRow];
     3384          double upperBound = rowUpper_[iRow];
     3385          if (getRowStatus(iRow)==basic) {
     3386            // see if we can find a column to pivot on
     3387            int j;
     3388            double maximumDown = DBL_MAX;
     3389            double maximumUp = DBL_MAX;
     3390            int numberBad=0;
     3391            if (lowerBound<-1.0e20)
     3392              maximumDown = -1.0;;
     3393            if (upperBound<1.0e20)
     3394              maximumUp = -1.0;;
     3395            for (j=rowStart[iRow];j<rowStart[iRow]+rowLength[iRow];j++) {
     3396              int iColumn = column[j];
     3397              /* way -
     3398                 -3 - okay at upper bound with negative dj
     3399                 -2 - marginal at upper bound with zero dj - can only decrease
     3400                 -1 - bad at upper bound
     3401                 0 - we can never pivot on this row
     3402                 1 - bad at lower bound
     3403                 2 - marginal at lower bound with zero dj - can only increase
     3404                 3 - okay at lower bound with positive dj
     3405                 100 - fine we can just ignore
     3406              */
     3407              if (way[iColumn]!=100) {
     3408                switch(way[iColumn]) {
     3409             
     3410                case -3:
     3411                 
     3412                  break;
     3413                case -2:
     3414                 
     3415                  break;
     3416                case -1:
     3417                 
     3418                  break;
     3419                case 0:
     3420                  maximumDown = -1.0;
     3421                  maximumUp=-1.0;
     3422                  break;
     3423                case 1:
     3424                 
     3425                  break;
     3426                case 2:
     3427                 
     3428                  break;
     3429                case 3:
     3430                 
     3431                  break;
     3432                default:
     3433                  break;
     3434                }
     3435              }
     3436            }
     3437            if (max(maximumUp,maximumDown)>0.0) {
     3438              // do something
     3439            }
     3440          }
     3441        }
     3442        abort();
     3443        delete [] pi;
     3444        delete [] dj;
     3445        delete [] way;
    33283446#endif
    3329         abort();
    33303447        return -1;
    33313448      }
    33323449    } else {
     3450      delete [] dj;
    33333451      return -1;
    33343452    }
  • trunk/ClpSimplexDual.cpp

    r97 r98  
    11381138  double totalThru=0.0; // for when variables flip
    11391139  double acceptablePivot=1.0e-7;
    1140   if (factorization_->pivots())
     1140  if (factorization_->pivots()>10)
    11411141    acceptablePivot=1.0e-5; // if we have iterated be more strict
     1142  else if (factorization_->pivots()>5)
     1143    acceptablePivot=1.0e-6; // if we have iterated be slightly more strict
    11421144  double bestEverPivot=acceptablePivot;
    11431145  int lastSequence = -1;
Note: See TracChangeset for help on using the changeset viewer.