Ignore:
Timestamp:
Jun 26, 2007 3:00:48 AM (13 years ago)
Author:
forrest
Message:

moving branches/devel to trunk

Location:
trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk

    • Property svn:externals
      •  

        old new  
        11MSVisualStudio   https://projects.coin-or.org/svn/MSVisualStudio/trunk/ExternalsDirs/Clp
        22BuildTools    https://projects.coin-or.org/svn/BuildTools/trunk
        3 Data/Netlib   https://projects.coin-or.org/svn/Data/trunk/Netlib
        4 Data/Sample   https://projects.coin-or.org/svn/Data/trunk/Sample
        5 CoinUtils     https://projects.coin-or.org/svn/CoinUtils/stable/2.0/CoinUtils
         3ThirdParty/Blas https://projects.coin-or.org/svn/BuildTools/ThirdParty/Blas/stable/1.0
         4ThirdParty/Lapack https://projects.coin-or.org/svn/BuildTools/ThirdParty/Lapack/stable/1.0
         5Data/Netlib   https://projects.coin-or.org/svn/Data/stable/1.0/Netlib
         6Data/Sample   https://projects.coin-or.org/svn/Data/stable/1.0/Sample
         7CoinUtils     https://projects.coin-or.org/svn/CoinUtils/trunk/CoinUtils
  • trunk/Clp/src/ClpSimplexDual.cpp

    r919 r1034  
    298298    }
    299299    if (problemStatus_<0&&perturbation_<100) {
    300       perturb();
     300      bool inCbcOrOther = (specialOptions_&0x03000000)!=0;
     301      if (!inCbcOrOther)
     302        perturb();
    301303      // Can't get here if values pass
    302304      gutsOfSolution(NULL,NULL);
     
    312314                             <<numberDualInfeasibilitiesWithoutFree_;
    313315        handler_->message()<<CoinMessageEol;
     316      }
     317      if (inCbcOrOther) {
     318        if (numberPrimalInfeasibilities_) {
     319          perturb();
     320          if (perturbation_>=101)
     321            computeDuals(NULL);
     322          //gutsOfSolution(NULL,NULL);
     323        } else if (numberDualInfeasibilities_) {
     324          problemStatus_=10;
     325          return 1; // to primal
     326        }
    314327      }
    315328    }
     
    384397      }
    385398    }
     399    // see if in Cbc etc
     400    bool inCbcOrOther = (specialOptions_&0x03000000)!=0;
     401#if 0
     402    bool gotoPrimal=false;
     403    if (inCbcOrOther&&numberIterations_>disasterArea_+numberRows_&&
     404        numberDualInfeasibilitiesWithoutFree_&&largestDualError_>1.0e-1) {
     405      if (!disasterArea_) {
     406        printf("trying all slack\n");
     407        // try all slack basis
     408        allSlackBasis(true);
     409        disasterArea_=2*numberRows_;
     410      } else {
     411        printf("going to primal\n");
     412        // go to primal
     413        gotoPrimal=true;
     414        allSlackBasis(true);
     415      }
     416    }
     417#endif
     418    bool disaster=false;
     419    if (disasterArea_&&inCbcOrOther&&disasterArea_->check()) {
     420      disasterArea_->saveInfo();
     421      disaster=true;
     422    }
    386423    // may factorize, checks if problem finished
    387424    statusOfProblemInDual(lastCleaned,factorType,saveDuals,data,
    388425                          ifValuesPass);
     426    if (disaster)
     427      problemStatus_=3;
    389428    // If values pass then do easy ones on first time
    390429    if (ifValuesPass&&
     
    445484    CoinMemcpyN(dual_,numberRows_,saveDuals);
    446485  }
     486  if (alphaAccuracy_!=-1.0)
     487    alphaAccuracy_ = 1.0;
    447488  int returnCode = startupSolve(ifValuesPass,saveDuals,startFinishOptions);
    448489  // Save so can see if doing after primal
     
    900941#if CLP_DEBUG>2
    901942    // very expensive
    902     if (numberIterations_>0&&numberIterations_<-801) {
    903       handler_->setLogLevel(63);
     943    if (numberIterations_>3063&&numberIterations_<30700) {
     944      //handler_->setLogLevel(63);
    904945      double saveValue = objectiveValue_;
    905946      double * saveRow1 = new double[numberRows_];
     
    14181459          printf("obj backwards %g %g\n",objectiveValue_,oldobj);
    14191460#endif
     1461#if 0
     1462        {
     1463          for (int i=0;i<numberRows_+numberColumns_;i++) {
     1464            FakeBound bound = getFakeBound(i);
     1465            if (bound==ClpSimplexDual::upperFake) {
     1466              assert (upper_[i]<1.0e20);
     1467            } else if (bound==ClpSimplexDual::lowerFake) {
     1468              assert (lower_[i]>-1.0e20);
     1469            } else if (bound==ClpSimplexDual::bothFake) {
     1470              assert (upper_[i]<1.0e20);
     1471              assert (lower_[i]>-1.0e20);
     1472            }
     1473          }
     1474        }
     1475#endif
    14201476        if (whatNext==1||candidate==-2) {
    14211477          problemStatus_ =-2; // refactorize
     
    31323188    // so (dualIn_+modification)==theta_*alpha_
    31333189    double modification = theta_*alpha_-dualIn_;
     3190    // But should not move objectivetoo much ??
     3191#define DONT_MOVE_OBJECTIVE
     3192#ifdef DONT_MOVE_OBJECTIVE
     3193    double moveObjective = fabs(modification*solution_[sequenceIn_]);
     3194    double smallMove = CoinMax(fabs(objectiveValue_),1.0e-3);
     3195    if (moveObjective>smallMove) {
     3196      printf("would move objective by %g - original mod %g sol value %g\n",moveObjective,
     3197             modification,solution_[sequenceIn_]);
     3198      modification *= smallMove/moveObjective;
     3199    }
     3200#endif
    31343201    if ((specialOptions_&(2048+4096))!=0) {
    31353202      if ((specialOptions_&16384)!=0) {
     
    32463313  return status;
    32473314}
     3315//static int count_alpha=0;
    32483316/* Checks if finished.  Updates status */
    32493317void
     
    32693337  double realDualInfeasibilities=0.0;
    32703338  if (type==2) {
     3339    if (alphaAccuracy_!=-1.0)
     3340      alphaAccuracy_=-2.0;
    32713341    // trouble - restore solution
    32723342    CoinMemcpyN(saveStatus_,numberColumns_+numberRows_,status_);
     
    32803350    forceFactorization_=1; // a bit drastic but ..
    32813351    changeMade_++; // say something changed
     3352    // get correct bounds on all variables
     3353    resetFakeBounds();
    32823354  }
    32833355  int tentativeStatus = problemStatus_;
    32843356  double changeCost;
    32853357  bool unflagVariables = true;
    3286   if (problemStatus_>-3||factorization_->pivots()) {
    3287     // factorize
    3288     // later on we will need to recover from singularities
    3289     // also we could skip if first time
    3290     // save dual weights
    3291     dualRowPivot_->saveWeights(this,1);
    3292     if (type) {
    3293       // is factorization okay?
    3294       if (internalFactorize(1)) {
    3295         // no - restore previous basis
    3296         unflagVariables = false;
    3297         assert (type==1);
    3298         changeMade_++; // say something changed
    3299         // Keep any flagged variables
    3300         int i;
    3301         for (i=0;i<numberRows_+numberColumns_;i++) {
    3302           if (flagged(i))
    3303             saveStatus_[i] |= 64; //say flagged
    3304         }
    3305         CoinMemcpyN(saveStatus_,numberColumns_+numberRows_,status_);
    3306         CoinMemcpyN(savedSolution_+numberColumns_ ,
    3307                numberRows_,rowActivityWork_);
    3308         CoinMemcpyN(savedSolution_ ,
    3309                numberColumns_,columnActivityWork_);
    3310         // restore extra stuff
    3311         int dummy;
    3312         matrix_->generalExpanded(this,6,dummy);
    3313         // get correct bounds on all variables
    3314         double dummyChangeCost=0.0;
    3315         changeBounds(true,rowArray_[2],dummyChangeCost);
    3316         // throw away change
    3317         for (i=0;i<4;i++)
    3318           rowArray_[i]->clear();
    3319         // need to reject something
    3320         char x = isColumn(sequenceOut_) ? 'C' :'R';
    3321         handler_->message(CLP_SIMPLEX_FLAG,messages_)
    3322           <<x<<sequenceWithin(sequenceOut_)
    3323           <<CoinMessageEol;
    3324         setFlagged(sequenceOut_);
    3325         progress_->clearBadTimes();
    3326        
    3327         // Go to safe
    3328         factorization_->pivotTolerance(0.99);
    3329         forceFactorization_=1; // a bit drastic but ..
    3330         type = 2;
    3331         //assert (internalFactorize(1)==0);
     3358  bool weightsSaved=false;
     3359  if (alphaAccuracy_<0.0||!numberPivots||alphaAccuracy_>1.0e4||factorization_->pivots()>20) {
     3360    if (problemStatus_>-3||numberPivots) {
     3361      // factorize
     3362      // later on we will need to recover from singularities
     3363      // also we could skip if first time
     3364      // save dual weights
     3365      dualRowPivot_->saveWeights(this,1);
     3366      weightsSaved=true;
     3367      if (type) {
     3368        // is factorization okay?
    33323369        if (internalFactorize(1)) {
     3370          // no - restore previous basis
     3371          unflagVariables = false;
     3372          assert (type==1);
     3373          changeMade_++; // say something changed
     3374          // Keep any flagged variables
     3375          int i;
     3376          for (i=0;i<numberRows_+numberColumns_;i++) {
     3377            if (flagged(i))
     3378              saveStatus_[i] |= 64; //say flagged
     3379          }
    33333380          CoinMemcpyN(saveStatus_,numberColumns_+numberRows_,status_);
    33343381          CoinMemcpyN(savedSolution_+numberColumns_ ,
    3335                  numberRows_,rowActivityWork_);
     3382                      numberRows_,rowActivityWork_);
    33363383          CoinMemcpyN(savedSolution_ ,
    3337                  numberColumns_,columnActivityWork_);
     3384                      numberColumns_,columnActivityWork_);
    33383385          // restore extra stuff
    33393386          int dummy;
    33403387          matrix_->generalExpanded(this,6,dummy);
    3341           // debug
    3342           int returnCode = internalFactorize(1);
    3343           while (returnCode) {
    3344             // ouch
    3345             // switch off dense
    3346             int saveDense = factorization_->denseThreshold();
    3347             factorization_->setDenseThreshold(0);
    3348             // Go to safe
    3349             factorization_->pivotTolerance(0.99);
    3350             // make sure will do safe factorization
    3351             pivotVariable_[0]=-1;
    3352             returnCode=internalFactorize(2);
    3353             factorization_->setDenseThreshold(saveDense);
    3354           }
    3355         }
    3356       }
    3357     }
    3358     if (problemStatus_!=-4||factorization_->pivots()>10)
    3359       problemStatus_=-3;
     3388          // get correct bounds on all variables
     3389          resetFakeBounds();
     3390          // need to reject something
     3391          char x = isColumn(sequenceOut_) ? 'C' :'R';
     3392          handler_->message(CLP_SIMPLEX_FLAG,messages_)
     3393            <<x<<sequenceWithin(sequenceOut_)
     3394            <<CoinMessageEol;
     3395          setFlagged(sequenceOut_);
     3396          progress_->clearBadTimes();
     3397         
     3398          // Go to safe
     3399          factorization_->pivotTolerance(0.99);
     3400          forceFactorization_=1; // a bit drastic but ..
     3401          type = 2;
     3402          //assert (internalFactorize(1)==0);
     3403          if (internalFactorize(1)) {
     3404            CoinMemcpyN(saveStatus_,numberColumns_+numberRows_,status_);
     3405            CoinMemcpyN(savedSolution_+numberColumns_ ,
     3406                        numberRows_,rowActivityWork_);
     3407            CoinMemcpyN(savedSolution_ ,
     3408                        numberColumns_,columnActivityWork_);
     3409            // restore extra stuff
     3410            int dummy;
     3411            matrix_->generalExpanded(this,6,dummy);
     3412            // debug
     3413            int returnCode = internalFactorize(1);
     3414            while (returnCode) {
     3415              // ouch
     3416              // switch off dense
     3417              int saveDense = factorization_->denseThreshold();
     3418              factorization_->setDenseThreshold(0);
     3419              // Go to safe
     3420              factorization_->pivotTolerance(0.99);
     3421              // make sure will do safe factorization
     3422              pivotVariable_[0]=-1;
     3423              returnCode=internalFactorize(2);
     3424              factorization_->setDenseThreshold(saveDense);
     3425            }
     3426            // get correct bounds on all variables
     3427            resetFakeBounds();
     3428          }
     3429        }
     3430      }
     3431      if (problemStatus_!=-4||numberPivots>10)
     3432        problemStatus_=-3;
     3433    }
     3434  } else {
     3435    //printf("testing with accuracy of %g and status of %d\n",alphaAccuracy_,problemStatus_);
     3436    //count_alpha++;
     3437    //if ((count_alpha%5000)==0)
     3438    //printf("count alpha %d\n",count_alpha);
    33603439  }
    33613440  // at this stage status is -3 or -4 if looks infeasible
     
    33823461    matrix_->generalExpanded(this,6,dummy);
    33833462    // get correct bounds on all variables
    3384     //double dummyChangeCost=0.0;
    3385     //changeBounds(true,rowArray_[2],dummyChangeCost);
    3386     // throw away change
    3387     for (i=0;i<4;i++)
    3388       rowArray_[i]->clear();
     3463    resetFakeBounds();
    33893464    // need to reject something
    33903465    char x = isColumn(sequenceOut_) ? 'C' :'R';
     
    33993474    factorization_->pivotTolerance(newTolerance);
    34003475    forceFactorization_=1; // a bit drastic but ..
     3476    if (alphaAccuracy_!=-1.0)
     3477      alphaAccuracy_=-2.0;
    34013478    type = 2;
    34023479    //assert (internalFactorize(1)==0);
     
    34243501        factorization_->setDenseThreshold(saveDense);
    34253502      }
     3503      // get correct bounds on all variables
     3504      resetFakeBounds();
    34263505    }
    34273506    // get primal and dual solutions
     
    34633542        matrix_->generalExpanded(this,6,dummy);
    34643543        // get correct bounds on all variables
    3465         double dummyChangeCost=0.0;
    3466         changeBounds(true,rowArray_[2],dummyChangeCost);
    3467         // throw away change
    3468         for (int i=0;i<4;i++)
    3469           rowArray_[i]->clear();
     3544        resetFakeBounds();
    34703545        if(factorization_->pivotTolerance()<0.2)
    34713546          factorization_->pivotTolerance(0.2);
     3547        if (alphaAccuracy_!=-1.0)
     3548          alphaAccuracy_=-2.0;
    34723549        if (internalFactorize(1)) {
    34733550          CoinMemcpyN(saveStatus_,numberColumns_+numberRows_,status_);
     
    34933570            factorization_->setDenseThreshold(saveDense);
    34943571          }
     3572          resetFakeBounds();
    34953573        }
    34963574        type = 2; // so will restore weights
     
    36053683          <<CoinMessageEol;
    36063684        // save solution in case unbounded
    3607         CoinMemcpyN(columnActivityWork_,numberColumns_,
    3608                           columnArray_[0]->denseVector());
    3609         CoinMemcpyN(rowActivityWork_,numberRows_,
    3610                           rowArray_[2]->denseVector());
     3685        double * saveColumnSolution = NULL;
     3686        double * saveRowSolution = NULL;
     3687        bool inCbc = (specialOptions_&0x01000000)!=0;
     3688        if (!inCbc) {
     3689          saveColumnSolution = CoinCopyOfArray(columnActivityWork_,numberColumns_);
     3690          saveRowSolution = CoinCopyOfArray(rowActivityWork_,numberRows_);
     3691        }
    36113692        numberChangedBounds=changeBounds(false,rowArray_[3],changeCost);
    36123693        if (numberChangedBounds<=0&&!numberDualInfeasibilities_) {
     
    36353716            if (numberTimesOptimal_==1) {
    36363717              dualTolerance_ = dblParam_[ClpDualTolerance];
    3637               // better to have small tolerance even if slower
    3638               factorization_->zeroTolerance(1.0e-15);
    36393718            } else {
     3719              if (numberTimesOptimal_==2) {
     3720                // better to have small tolerance even if slower
     3721                factorization_->zeroTolerance(1.0e-15);
     3722              }
    36403723              dualTolerance_ = dblParam_[ClpDualTolerance];
    36413724              dualTolerance_ *= pow(2.0,numberTimesOptimal_-1);
     
    36563739            int iSequence;
    36573740            int iChosen=-1;
    3658             double largest = 100.0*primalTolerance_;
    3659             for (iSequence=0;iSequence<numberRows_+numberColumns_;
    3660                  iSequence++) {
    3661               double djValue = dj_[iSequence];
    3662               double originalLo = originalLower(iSequence);
    3663               double originalUp = originalUpper(iSequence);
    3664               if (fabs(djValue)>fabs(largest)) {
    3665                 if (getStatus(iSequence)!=basic) {
    3666                   if (djValue>0&&originalLo<-1.0e20) {
    3667                     if (djValue>fabs(largest)) {
    3668                       largest=djValue;
    3669                       iChosen=iSequence;
    3670                     }
    3671                   } else if (djValue<0&&originalUp>1.0e20) {
    3672                     if (-djValue>fabs(largest)) {
    3673                       largest=djValue;
    3674                       iChosen=iSequence;
    3675                     }
    3676                   }
     3741            if (!inCbc) {
     3742              double largest = 100.0*primalTolerance_;
     3743              for (iSequence=0;iSequence<numberRows_+numberColumns_;
     3744                   iSequence++) {
     3745                double djValue = dj_[iSequence];
     3746                double originalLo = originalLower(iSequence);
     3747                double originalUp = originalUpper(iSequence);
     3748                if (fabs(djValue)>fabs(largest)) {
     3749                  if (getStatus(iSequence)!=basic) {
     3750                    if (djValue>0&&originalLo<-1.0e20) {
     3751                      if (djValue>fabs(largest)) {
     3752                        largest=djValue;
     3753                        iChosen=iSequence;
     3754                      }
     3755                    } else if (djValue<0&&originalUp>1.0e20) {
     3756                      if (-djValue>fabs(largest)) {
     3757                        largest=djValue;
     3758                        iChosen=iSequence;
     3759                      }
     3760                    }
     3761                  }
    36773762                }
    36783763              }
     
    37093794                if(getColumnStatus(iColumn)!= basic)
    37103795                  ray_[iColumn] +=
    3711                     columnActivityWork_[iColumn]-original[iColumn];
     3796                    saveColumnSolution[iColumn]-original[iColumn];
    37123797                columnActivityWork_[iColumn] = original[iColumn];
    37133798              }
    3714               CoinMemcpyN(rowArray_[2]->denseVector(),numberRows_,
     3799              CoinMemcpyN(saveRowSolution,numberRows_,
    37153800                                rowActivityWork_);
    37163801            }
     
    37203805          }
    37213806        }
    3722         CoinZeroN(columnArray_[0]->denseVector(),numberColumns_);
    3723         CoinZeroN(rowArray_[2]->denseVector(),numberRows_);
     3807        delete [] saveColumnSolution;
     3808        delete [] saveRowSolution;
    37243809      }
    37253810      if (problemStatus_==-4||problemStatus_==-5) {
     
    39053990        dualTolerance_=saveTolerance;
    39063991        //assert(numberDualInfeasibilitiesWithoutFree_==0);
    3907 
    39083992        if (numberDualInfeasibilities_) {
    39093993          if (numberPrimalInfeasibilities_||numberPivots)
     
    39414025    matrix_->generalExpanded(this,5,dummy);
    39424026  }
    3943 
    3944   // restore weights (if saved) - also recompute infeasibility list
    3945   if (tentativeStatus>-3)
    3946     dualRowPivot_->saveWeights(this,(type <2) ? 2 : 4);
    3947   else
    3948     dualRowPivot_->saveWeights(this,3);
     4027  if (weightsSaved) {
     4028    // restore weights (if saved) - also recompute infeasibility list
     4029    if (tentativeStatus>-3)
     4030      dualRowPivot_->saveWeights(this,(type <2) ? 2 : 4);
     4031    else
     4032      dualRowPivot_->saveWeights(this,3);
     4033  }
    39494034  // unflag all variables (we may want to wait a bit?)
    39504035  if ((tentativeStatus!=-2&&tentativeStatus!=-1)&&unflagVariables) {
     
    39834068  double limit = 0.0;
    39844069  getDblParam(ClpDualObjectiveLimit, limit);
     4070#if 0
    39854071  if(fabs(limit)<1.0e30&&objectiveValue()*optimizationDirection_>
    3986            limit&&
    3987            !numberAtFakeBound()&&!numberDualInfeasibilities_) {
    3988     //printf("lim %g obj %g %g\n",limit,objectiveValue_,objectiveValue());
    3989     // Even if not perturbed internal costs may have changed
    3990     if (true||perturbation_==101) {
    3991       // be careful
    3992       if (numberIterations_) {
    3993         computeObjectiveValue(true); // value without perturbation
    3994         if(objectiveValue()*optimizationDirection_>limit) {
    3995           problemStatus_=1;
    3996           secondaryStatus_ = 1; // and say was on cutoff
    3997         }
    3998       }
    3999     } else {
    4000       problemStatus_=1;
    4001       secondaryStatus_ = 1; // and say was on cutoff
     4072     limit+100.0) {
     4073    printf("lim %g obj %g %g - wo perturb %g sum dual %g\n",
     4074           limit,objectiveValue_,objectiveValue(),computeInternalObjectiveValue(),sumDualInfeasibilities_);
     4075  }
     4076#endif
     4077  if(fabs(limit)<1.0e30&&objectiveValue()*optimizationDirection_>
     4078     limit&&!numberAtFakeBound()) {
     4079    bool looksInfeasible = !numberDualInfeasibilities_;
     4080    if (objectiveValue()*optimizationDirection_>limit+fabs(0.1*limit)+1.0e2*sumDualInfeasibilities_+1.0e4&&
     4081        sumDualInfeasibilities_<largestDualError_&&numberIterations_>0.5*numberRows_+1000)
     4082      looksInfeasible=true;
     4083    if (looksInfeasible) {
     4084      // Even if not perturbed internal costs may have changed
     4085      if (true||perturbation_==101) {
     4086        // be careful
     4087        if (numberIterations_) {
     4088          if(computeInternalObjectiveValue()>limit) {
     4089            problemStatus_=1;
     4090            secondaryStatus_ = 1; // and say was on cutoff
     4091          }
     4092        }
     4093      } else {
     4094        problemStatus_=1;
     4095        secondaryStatus_ = 1; // and say was on cutoff
     4096      }
    40024097    }
    40034098  }
     
    40214116        secondaryStatus_ = 1; // and say was on cutoff
    40224117      } else if (largestPrimalError_>1.0e5) {
    4023         allSlackBasis();
    4024         problemStatus_=10;
     4118        {
     4119          int iBigB=-1;
     4120          double bigB=0.0;
     4121          int iBigN=-1;
     4122          double bigN=0.0;
     4123          for (int i=0;i<numberRows_+numberColumns_;i++) {
     4124            double value = fabs(solution_[i]);
     4125            if (getStatus(i)==basic) {
     4126              if (value>bigB) {
     4127                bigB= value;
     4128                iBigB=i;
     4129              }
     4130            } else {
     4131              if (value>bigN) {
     4132                bigN= value;
     4133                iBigN=i;
     4134              }
     4135            }
     4136          }
     4137          if (bigB>1.0e8||bigN>1.0e8) {
     4138            if (handler_->logLevel()>0)
     4139              printf("it %d - basic %d %g, nonbasic %d %g\n",
     4140                     numberIterations_,iBigB,bigB,iBigN,bigN);
     4141          }
     4142        }
    40254143        if (handler_->logLevel()>2)
    40264144          printf("bad dual - going to primal %d %g\n",looksBad,largestPrimalError_);
     4145        allSlackBasis(true);
     4146        problemStatus_=10;
    40274147      }
    40284148    }
     
    40514171  }
    40524172#endif
     4173  // Allow matrices to be sorted etc
     4174  int fake=-999; // signal sort
     4175  matrix_->correctSequence(this,fake,fake);
     4176  if (alphaAccuracy_>0.0)
     4177      alphaAccuracy_=1.0;
    40534178}
    40544179/* While updateDualsInDual sees what effect is of flip
     
    41134238ClpSimplexDual::originalBound( int iSequence)
    41144239{
    4115   if (getFakeBound(iSequence)!=noFake)
     4240  if (getFakeBound(iSequence)!=noFake) {
    41164241    numberFake_--;;
    4117   if (auxiliaryModel_) {
    4118     // just copy back
    4119     lower_[iSequence]=auxiliaryModel_->lowerRegion()[iSequence+numberRows_+numberColumns_];
    4120     upper_[iSequence]=auxiliaryModel_->upperRegion()[iSequence+numberRows_+numberColumns_];
    41214242    setFakeBound(iSequence,noFake);
    4122     return;
    4123   }
    4124   if (iSequence>=numberColumns_) {
    4125     // rows
    4126     int iRow = iSequence-numberColumns_;
    4127     rowLowerWork_[iRow]=rowLower_[iRow];
    4128     rowUpperWork_[iRow]=rowUpper_[iRow];
    4129     if (rowScale_) {
    4130       if (rowLowerWork_[iRow]>-1.0e50)
    4131         rowLowerWork_[iRow] *= rowScale_[iRow]*rhsScale_;
    4132       if (rowUpperWork_[iRow]<1.0e50)
    4133         rowUpperWork_[iRow] *= rowScale_[iRow]*rhsScale_;
    4134     } else if (rhsScale_!=1.0) {
    4135       if (rowLowerWork_[iRow]>-1.0e50)
    4136         rowLowerWork_[iRow] *= rhsScale_;
    4137       if (rowUpperWork_[iRow]<1.0e50)
    4138         rowUpperWork_[iRow] *= rhsScale_;
    4139     }
    4140   } else {
    4141     // columns
    4142     columnLowerWork_[iSequence]=columnLower_[iSequence];
    4143     columnUpperWork_[iSequence]=columnUpper_[iSequence];
    4144     if (rowScale_) {
    4145       double multiplier = 1.0/columnScale_[iSequence];
    4146       if (columnLowerWork_[iSequence]>-1.0e50)
    4147         columnLowerWork_[iSequence] *= multiplier*rhsScale_;
    4148       if (columnUpperWork_[iSequence]<1.0e50)
    4149         columnUpperWork_[iSequence] *= multiplier*rhsScale_;
    4150     } else if (rhsScale_!=1.0) {
    4151       if (columnLowerWork_[iSequence]>-1.0e50)
    4152         columnLowerWork_[iSequence] *= rhsScale_;
    4153       if (columnUpperWork_[iSequence]<1.0e50)
    4154         columnUpperWork_[iSequence] *= rhsScale_;
    4155     }
    4156   }
    4157   setFakeBound(iSequence,noFake);
     4243    if (auxiliaryModel_) {
     4244      // just copy back
     4245      lower_[iSequence]=auxiliaryModel_->lowerRegion()[iSequence+numberRows_+numberColumns_];
     4246      upper_[iSequence]=auxiliaryModel_->upperRegion()[iSequence+numberRows_+numberColumns_];
     4247      return;
     4248    }
     4249    if (iSequence>=numberColumns_) {
     4250      // rows
     4251      int iRow = iSequence-numberColumns_;
     4252      rowLowerWork_[iRow]=rowLower_[iRow];
     4253      rowUpperWork_[iRow]=rowUpper_[iRow];
     4254      if (rowScale_) {
     4255        if (rowLowerWork_[iRow]>-1.0e50)
     4256          rowLowerWork_[iRow] *= rowScale_[iRow]*rhsScale_;
     4257        if (rowUpperWork_[iRow]<1.0e50)
     4258          rowUpperWork_[iRow] *= rowScale_[iRow]*rhsScale_;
     4259      } else if (rhsScale_!=1.0) {
     4260        if (rowLowerWork_[iRow]>-1.0e50)
     4261          rowLowerWork_[iRow] *= rhsScale_;
     4262        if (rowUpperWork_[iRow]<1.0e50)
     4263          rowUpperWork_[iRow] *= rhsScale_;
     4264      }
     4265    } else {
     4266      // columns
     4267      columnLowerWork_[iSequence]=columnLower_[iSequence];
     4268      columnUpperWork_[iSequence]=columnUpper_[iSequence];
     4269      if (rowScale_) {
     4270        double multiplier = 1.0/columnScale_[iSequence];
     4271        if (columnLowerWork_[iSequence]>-1.0e50)
     4272          columnLowerWork_[iSequence] *= multiplier*rhsScale_;
     4273        if (columnUpperWork_[iSequence]<1.0e50)
     4274          columnUpperWork_[iSequence] *= multiplier*rhsScale_;
     4275      } else if (rhsScale_!=1.0) {
     4276        if (columnLowerWork_[iSequence]>-1.0e50)
     4277          columnLowerWork_[iSequence] *= rhsScale_;
     4278        if (columnUpperWork_[iSequence]<1.0e50)
     4279          columnUpperWork_[iSequence] *= rhsScale_;
     4280      }
     4281    }
     4282  }
    41584283}
    41594284/* As changeBounds but just changes new bounds for a single variable.
     
    41744299  lower_[iSequence] = oldLower;
    41754300  upper_[iSequence] = oldUpper;
    4176   if (getFakeBound(iSequence)!=noFake)
    4177     numberFake_--;;
     4301  assert (getFakeBound(iSequence)==noFake);
     4302  //if (getFakeBound(iSequence)!=noFake)
     4303  //numberFake_--;;
    41784304  if (value==oldLower) {
    41794305    if (upperValue > oldLower + dualBound_) {
     
    42244350  double elementRatio = largestPositive/smallestPositive;
    42254351  int numberNonZero=0;
    4226   if (!numberIterations_&&perturbation_==50) {
     4352  if (!numberIterations_&&perturbation_>=50) {
    42274353    // See if we need to perturb
    42284354    double * sort = new double[numberColumns_];
     
    48164942  double saveDualBound = dualBound_;
    48174943
     4944  if (alphaAccuracy_!=-1.0)
     4945    alphaAccuracy_ = 1.0;
    48184946  double objectiveChange;
    48194947  // for dual we will change bounds using dualBound_
     
    56395767  }
    56405768}
     5769void
     5770ClpSimplexDual::resetFakeBounds()
     5771{
     5772  double dummyChangeCost=0.0;
     5773  changeBounds(true,rowArray_[2],dummyChangeCost);
     5774  // throw away change
     5775  for (int i=0;i<4;i++)
     5776    rowArray_[i]->clear();
     5777}
Note: See TracChangeset for help on using the changeset viewer.