Ignore:
Timestamp:
Oct 2, 2003 1:21:02 PM (17 years ago)
Author:
forrest
Message:

lots of stuff

File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/pre/ClpSimplexDual.cpp

    r210 r212  
    202202  ClpDataSave data = saveData();
    203203
     204  // Save so can see if doing after primal
     205  int initialStatus=problemStatus_;
     206
    204207  // If values pass then save given duals round check solution
    205208  double * saveDuals = NULL;
     
    208211    memcpy(saveDuals,dual_,numberRows_*sizeof(double));
    209212  }
    210 
     213 
    211214  // sanity check
    212215  // initialize - no values pass and algorithm_ is -1
     
    221224    // If values pass then scale pi
    222225    if (ifValuesPass) {
    223       if (!problemStatus_&&perturbation_<100)
     226      if (problemStatus_&&perturbation_<100)
    224227        perturb();
    225228      int i;
     
    311314      // If getting nowhere - why not give it a kick
    312315      // does not seem to work too well - do some more work
    313       if (perturbation_<101&&numberIterations_>2*(numberRows_+numberColumns_)) {
     316      if (perturbation_<101&&numberIterations_>2*(numberRows_+numberColumns_)
     317          &&initialStatus!=10) {
    314318        perturb();
    315319        // Can't get here if values pass
     
    29112915  if (perturbation_>100)
    29122916    return; //perturbed already
     2917  if (perturbation_==100)
     2918    perturbation_=50; // treat as normal
    29132919  bool modifyRowCosts=false;
    29142920  // dual perturbation
     
    29202926  int maxLength=0;
    29212927  int minLength=numberRows_;
    2922   if (perturbation_==50) {
    2923     int count[101];
    2924     int numberTotal=0;
    2925     memset(count,0,101*sizeof(int));
    2926     int iColumn;
    2927     for (iColumn=0;iColumn<numberColumns_;iColumn++) {
    2928       if (columnLowerWork_[iColumn]<columnUpperWork_[iColumn]) {
    2929         double value = fabs(objectiveWork_[iColumn]);
    2930         int k;
    2931         numberTotal++;
    2932         if (!value) {
    2933           k=0;
    2934         } else if (value>99.5) {
    2935           k=100;
    2936         } else {
    2937           double lo = floor(value+0.5);
    2938           if (fabs(lo-value)<1.0e-8)
    2939             k = (int) lo;
    2940           else
    2941             k=100;
    2942         }
    2943         count[k]++;
    2944         int length = lengths[iColumn];
    2945         if (length>2) {
    2946           maxLength = max(maxLength,length);
    2947           minLength = min(minLength,length);
    2948         }
    2949       }
    2950     }
    2951     int numberZero = count[0];
    2952     int numberNonZero = numberTotal-numberZero;
    2953     int numberOdd=count[100];
    2954     int numberInteger = numberNonZero-numberOdd;
    2955     if (3*numberOdd>numberTotal) {
    2956       // be more subtle
    2957       maximumFraction=1.0e-6;
    2958       constantPerturbation *= 0.1;
    2959     } else if (count[1]==numberInteger&&!numberOdd) {
    2960       // be less subtle
    2961       maximumFraction=2.0e-5;
    2962     }
    2963   } else {
    2964     int iColumn;
    2965     for (iColumn=0;iColumn<numberColumns_;iColumn++) {
    2966       if (columnLowerWork_[iColumn]<columnUpperWork_[iColumn]) {
    2967         int length = lengths[iColumn];
    2968         if (length>2) {
    2969           maxLength = max(maxLength,length);
    2970           minLength = min(minLength,length);
    2971         }
     2928  if (!numberIterations_&&perturbation_==50) {
     2929    // See if we need to perturb
     2930    double * sort = new double[numberColumns_];
     2931    int i;
     2932    for (i=0;i<numberColumns_;i++) {
     2933      double value = fabs(objectiveWork_[i]);
     2934      sort[i]=value;
     2935    }
     2936    std::sort(sort,sort+numberColumns_);
     2937    int number=1;
     2938    double last = sort[0];
     2939    for (i=1;i<numberColumns_;i++) {
     2940      if (last!=sort[i])
     2941        number++;
     2942      last=sort[i];
     2943    }
     2944    delete [] sort;
     2945    if (number*4>numberColumns_)
     2946      return; // good enough
     2947  }
     2948  int iColumn;
     2949  for (iColumn=0;iColumn<numberColumns_;iColumn++) {
     2950    if (columnLowerWork_[iColumn]<columnUpperWork_[iColumn]) {
     2951      int length = lengths[iColumn];
     2952      if (length>2) {
     2953        maxLength = max(maxLength,length);
     2954        minLength = min(minLength,length);
    29722955      }
    29732956    }
     
    29862969    maximumFraction = m[min(perturbation_-51,10)];
    29872970  }
    2988   int iRow,iColumn;
     2971  int iRow;
    29892972  double smallestNonZero=1.0e100;
    29902973  if (perturbation_>=50) {
    29912974    perturbation = 1.0e-8;
     2975    bool allSame=true;
     2976    double lastValue=0.0;
    29922977    for (iRow=0;iRow<numberRows_;iRow++) {
    2993       if (rowLowerWork_[iRow]<rowUpperWork_[iRow]) {
     2978      double lo = rowLowerWork_[iRow];
     2979      double up = rowUpperWork_[iRow];
     2980      if (lo<up) {
    29942981        double value = fabs(rowObjectiveWork_[iRow]);
    29952982        perturbation = max(perturbation,value);
     
    29982985          smallestNonZero = min(smallestNonZero,value);
    29992986        }
     2987      }
     2988      if (lo&&lo>-1.0e10) {
     2989        lo=fabs(lo);
     2990        if (!lastValue)
     2991          lastValue=lo;
     2992        else if (fabs(lo-lastValue)>1.0e-7)
     2993          allSame=false;
     2994      }
     2995      if (up&&up<1.0e10) {
     2996        up=fabs(up);
     2997        if (!lastValue)
     2998          lastValue=up;
     2999        else if (fabs(up-lastValue)>1.0e-7)
     3000          allSame=false;
    30003001      }
    30013002    }
    30023003    for (iColumn=0;iColumn<numberColumns_;iColumn++) {
    3003       if (columnLowerWork_[iColumn]<columnUpperWork_[iColumn]) {
     3004      double lo = columnLowerWork_[iColumn];
     3005      double up = columnUpperWork_[iColumn];
     3006      if (lo<up) {
    30043007        double value =
    30053008          fabs(objectiveWork_[iColumn]);
     
    30093012        }
    30103013      }
     3014      if (lo&&lo>-1.0e10) {
     3015        lo=fabs(lo);
     3016        if (!lastValue)
     3017          lastValue=lo;
     3018        else if (fabs(lo-lastValue)>1.0e-7)
     3019          allSame=false;
     3020      }
     3021      if (up&&up<1.0e10) {
     3022        up=fabs(up);
     3023        if (!lastValue)
     3024          lastValue=up;
     3025        else if (fabs(up-lastValue)>1.0e-7)
     3026          allSame=false;
     3027      }
     3028    }
     3029    if (allSame) {
     3030      // Really hit perturbation
     3031      maximumFraction = max(1.0e-2*lastValue,maximumFraction);
    30113032    }
    30123033    perturbation = min(perturbation,smallestNonZero/maximumFraction);
     
    30393060  // modify costs
    30403061  bool printOut=(handler_->logLevel()==63);
     3062  printOut=false;
    30413063  if (modifyRowCosts) {
    30423064    for (iRow=0;iRow<numberRows_;iRow++) {
     
    39854007  delete [] scaled;
    39864008}
     4009int
     4010ClpSimplexDual::nextSuperBasic()
     4011{
     4012  if (firstFree_>=0) {
     4013    int returnValue=firstFree_;
     4014    int iColumn=firstFree_+1;
     4015    for (;iColumn<numberRows_+numberColumns_;iColumn++) {
     4016      if (getStatus(iColumn)==isFree)
     4017        if (fabs(dj_[iColumn])>1.0e2*dualTolerance_)
     4018          break;
     4019    }
     4020    firstFree_ = iColumn;
     4021    if (firstFree_==numberRows_+numberColumns_)
     4022      firstFree_=-1;
     4023    return returnValue;
     4024  } else {
     4025    return -1;
     4026  }
     4027}
Note: See TracChangeset for help on using the changeset viewer.