Changeset 382


Ignore:
Timestamp:
Jun 1, 2004 11:30:49 AM (16 years ago)
Author:
forrest
Message:

stuff

Location:
trunk
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/ClpInterior.cpp

    r378 r382  
    5858  primalObjective_(0.0),
    5959  diagonalNorm_(1.0e-12),
    60   stepLength_(0.99995),
     60  stepLength_(0.995),
    6161  linearPerturbation_(1.0e-12),
    6262  diagonalPerturbation_(1.0e-15),
     
    10421042  ClpModel::returnModel(otherModel);
    10431043}
     1044// Return number fixed to see if worth presolving
     1045int
     1046ClpInterior::numberFixed() const
     1047{
     1048  int i;
     1049  int nFixed=0;
     1050  for (i=0;i<numberColumns_;i++) {
     1051    if (columnUpper_[i]<1.0e20||columnLower_[i]>-1.0e20) {
     1052      if (columnUpper_[i]>columnLower_[i]) {
     1053        if (fixedOrFree(i))
     1054          nFixed++;
     1055      }
     1056    }
     1057  }
     1058  for (i=0;i<numberRows_;i++) {
     1059    if (rowUpper_[i]<1.0e20||rowLower_[i]>-1.0e20) {
     1060      if (rowUpper_[i]>rowLower_[i]) {
     1061        if (fixedOrFree(i+numberColumns_))
     1062          nFixed++;
     1063      }
     1064    }
     1065  }
     1066  return nFixed;
     1067}
     1068// fix variables interior says should be
     1069void
     1070ClpInterior::fixFixed()
     1071{
     1072  int i;
     1073  for (i=0;i<numberColumns_;i++) {
     1074    if (columnUpper_[i]<1.0e20||columnLower_[i]>-1.0e20) {
     1075      if (columnUpper_[i]>columnLower_[i]) {
     1076        if (fixedOrFree(i)) {
     1077          if (columnActivity_[i]-columnLower_[i]<columnUpper_[i]-columnActivity_[i]) {
     1078            columnUpper_[i]=columnLower_[i];
     1079            columnActivity_[i]=columnLower_[i];
     1080          } else {
     1081            columnLower_[i]=columnUpper_[i];
     1082            columnActivity_[i]=columnUpper_[i];
     1083          }
     1084        }
     1085      }
     1086    }
     1087  }
     1088  for (i=0;i<numberRows_;i++) {
     1089    if (rowUpper_[i]<1.0e20||rowLower_[i]>-1.0e20) {
     1090      if (rowUpper_[i]>rowLower_[i]) {
     1091        if (fixedOrFree(i+numberColumns_)) {
     1092          if (rowActivity_[i]-rowLower_[i]<rowUpper_[i]-rowActivity_[i]) {
     1093            rowUpper_[i]=rowLower_[i];
     1094            rowActivity_[i]=rowLower_[i];
     1095          } else {
     1096            rowLower_[i]=rowUpper_[i];
     1097            rowActivity_[i]=rowUpper_[i];
     1098          }
     1099        }
     1100      }
     1101    }
     1102  }
     1103}
  • trunk/ClpPredictorCorrector.cpp

    r380 r382  
    222222            break;
    223223          }
     224          if (complementarityGap_>0.95*checkGap&&bestObjectiveGap<1.0e-3&&
     225              numberIterations_>saveIteration+5) {
     226            handler_->message(CLP_BARRIER_EXIT2,messages_)
     227              <<saveIteration
     228              <<CoinMessageEol;
     229            break;
     230          }
    224231        }
    225232      }
     
    374381    if (directionAccuracy>worstDirectionAccuracy_) {
    375382      worstDirectionAccuracy_=directionAccuracy;
    376     }
     383    }
     384    if (saveIteration>0&&directionAccuracy>1.0) {
     385      handler_->message(CLP_BARRIER_EXIT2,messages_)
     386        <<saveIteration
     387        <<CoinMessageEol;
     388      break;
     389    }
    377390    findStepLength(phase);
    378391    nextGap=complementarityGap(nextNumber,nextNumberItems,1);
     
    507520              phase=0;
    508521              // Try primal dual step instead - but with small mu
    509               phase=2;
     522              if (numberIterations_<100)
     523                phase=2;
    510524              double floatNumber;
    511525              floatNumber = 2.0*numberComplementarityPairs_;
     
    575589      // just for debug
    576590      nextGap=complementarityGap(nextNumber,nextNumberItems,2);
    577       if (nextGap>0.99*complementarityGap_&&bestPhase==0&&affineGap<nextGap) {
     591      if (nextGap>0.9*complementarityGap_&&bestPhase==0&&affineGap<nextGap) {
    578592        // Back to affine
    579593        phase=0;
    580594        // no
    581         phase=2;
     595        if (numberIterations_<80)
     596          phase=2;
    582597        mu_ *= 0.5;
    583598        setupForSolve(phase);
     
    732747  //direction vector in deltaX
    733748  double * deltaX = deltaX_;
     749  // If done many iterations then allow to hit boundary
     750  double hitTolerance;
     751  //printf("objective norm %g\n",objectiveNorm_);
     752  if (numberIterations_<80|!gonePrimalFeasible_)
     753    hitTolerance = COIN_DBL_MAX;
     754  else
     755    hitTolerance = max(1.0e3,1.0e-3*objectiveNorm_);
    734756  int iColumn;
    735757  for (iColumn=0;iColumn<numberTotal;iColumn++) {
     
    742764        double delta = - deltaSL_[iColumn];
    743765        double z1 = deltaZ_[iColumn];
    744         if (lowerSlack[iColumn]<maximumPrimalStep*delta) {
    745           maximumPrimalStep=lowerSlack[iColumn]/delta;
    746           chosenPrimalSequence=iColumn;
    747         }
     766        double newZ = zVec[iColumn]+z1;
    748767        if (zVec[iColumn]>tolerance) {
    749768          if (zVec[iColumn]<-z1*maximumDualStep) {
     
    752771          }
    753772        }
     773        if (lowerSlack[iColumn]<maximumPrimalStep*delta) {
     774          double newStep=lowerSlack[iColumn]/delta;
     775          if (newStep>0.2||newZ<hitTolerance||delta>1.0e3||delta<=1.0e-6||dj_[iColumn]<hitTolerance) {
     776            maximumPrimalStep = newStep;
     777            chosenPrimalSequence=iColumn;
     778          } else {
     779            printf("small %d delta %g newZ %g step %g\n",iColumn,delta,newZ,newStep);
     780          }
     781        }
    754782      }
    755783      if (upperBound(iColumn)) {
    756784        double delta = - deltaSU_[iColumn];;
    757785        double t1 = deltaT_[iColumn];
    758         if (upperSlack[iColumn]<maximumPrimalStep*delta) {
    759           maximumPrimalStep=upperSlack[iColumn]/delta;
    760           chosenPrimalSequence=iColumn;
    761         }
     786        double newT = tVec[iColumn]+t1;
    762787        if (tVec[iColumn]>tolerance) {
    763788          if (tVec[iColumn]<-t1*maximumDualStep) {
     
    765790            chosenDualSequence=iColumn;
    766791          }
     792        }
     793        if (upperSlack[iColumn]<maximumPrimalStep*delta) {
     794          double newStep=upperSlack[iColumn]/delta;
     795          if (newStep>0.2||newT<hitTolerance||delta>1.0e3||delta<=1.0e-6||dj_[iColumn]>-hitTolerance) {
     796            maximumPrimalStep = newStep;
     797            chosenPrimalSequence=iColumn;
     798          } else {
     799            printf("small %d delta %g newT %g step %g\n",iColumn,delta,newT,newStep);
     800          }
    767801        }
    768802      }
     
    20462080  double returnGap=bestNextGap;
    20472081  double nextGap=complementarityGap(nextNumber,nextNumberItems,2);
    2048   if (nextGap>bestNextGap&&nextGap>-0.9*complementarityGap_) {
     2082  if (nextGap>bestNextGap&&nextGap>0.9*complementarityGap_) {
    20492083#ifdef SOME_DEBUG
    20502084    printf("checkGood phase 1 next gap %.18g, phase 0 %.18g, old gap %.18g\n",
     
    23482382  double * cost = cost_;
    23492383  double largeGap2 = max(1.0e7,1.0e2*solutionNorm_);
     2384  // When to start looking at killing (factor0
     2385  double killFactor;
     2386  if (numberIterations_<50)
     2387    killFactor = 1.0;
     2388  else
     2389    killFactor = 1.0e5;
    23502390  for (int iColumn=0;iColumn<numberRows_+numberColumns_;iColumn++) {
    23512391    if (!flagged(iColumn)) {
     
    24702510          maximumBoundInfeasibility=infeasibility;
    24712511        }
    2472         if (lowerSlack[iColumn]<=1.0e5*kill&&fabs(newPrimal-lower[iColumn])<=1.0e5*kill) {
     2512        if (lowerSlack[iColumn]<=kill*killFactor&&fabs(newPrimal-lower[iColumn])<=kill*killFactor) {
    24732513          double step = min(actualPrimalStep_*1.1,1.0);
    24742514          double newPrimal2=primal[iColumn]+step*thisWeight;
     
    24762516            newPrimal=lower[iColumn];
    24772517            lowerSlack[iColumn]=0.0;
    2478             printf("fixing %d to lower\n",iColumn);
     2518            //printf("fixing %d to lower\n",iColumn);
    24792519          }
    24802520        }
     
    25422582          maximumBoundInfeasibility=infeasibility;
    25432583        }
    2544         if (upperSlack[iColumn]<=1.0e5*kill&&fabs(newPrimal-upper[iColumn])<=1.0e5*kill) {
     2584        if (upperSlack[iColumn]<=kill*killFactor&&fabs(newPrimal-upper[iColumn])<=kill*killFactor) {
    25452585          double step = min(actualPrimalStep_*1.1,1.0);
    25462586          double newPrimal2=primal[iColumn]+step*thisWeight;
     
    25482588            newPrimal=upper[iColumn];
    25492589            upperSlack[iColumn]=0.0;
    2550             printf("fixing %d to upper\n",iColumn);
     2590            //printf("fixing %d to upper\n",iColumn);
    25512591          }
    25522592        }
  • trunk/ClpSolve.cpp

    r379 r382  
    950950    int barrierStatus=barrier.status();
    951951    double gap = barrier.complementarityGap();
    952     // could get which variables are fixed - would help crossover *****
     952    // get which variables are fixed
     953    double * saveLower=NULL;
     954    double * saveUpper=NULL;
     955    ClpPresolve pinfo2;
     956    ClpSimplex * saveModel2=NULL;
     957    int numberFixed = barrier.numberFixed();
     958    if (numberFixed*20>barrier.numberRows()&&numberFixed>5000) {
     959      // may as well do presolve
     960      int numberRows = barrier.numberRows();
     961      int numberColumns = barrier.numberColumns();
     962      int numberTotal = numberRows+numberColumns;
     963      saveLower = new double [numberTotal];
     964      saveUpper = new double [numberTotal];
     965      memcpy(saveLower,barrier.columnLower(),numberColumns*sizeof(double));
     966      memcpy(saveLower+numberColumns,barrier.rowLower(),numberRows*sizeof(double));
     967      memcpy(saveUpper,barrier.columnUpper(),numberColumns*sizeof(double));
     968      memcpy(saveUpper+numberColumns,barrier.rowUpper(),numberRows*sizeof(double));
     969      barrier.fixFixed();
     970      saveModel2=model2;
     971    }
    953972#ifdef BORROW   
    954973    barrier.returnModel(*model2);
     
    9811000                  numberColumns,model2->dualColumnSolution());
    9821001#endif
     1002    if (saveModel2) {
     1003      // do presolve
     1004      model2 = pinfo2.presolvedModel(*model2,1.0e-8,
     1005                                    false,5,true);
     1006    }
    9831007    if (maxIts&&barrierStatus<4) {
    9841008      printf("***** crossover - needs more thought on difficult models\n");
     
    9931017      // throw some into basis
    9941018      {
     1019        int numberRows = model2->numberRows();
     1020        int numberColumns = model2->numberColumns();
    9951021        double * dsort = new double[numberColumns];
    9961022        int * sort = new int[numberColumns];
     
    10281054      }
    10291055      if (gap<1.0e-3*((double) (numberRows+numberColumns))) {
     1056        int numberRows = model2->numberRows();
     1057        int numberColumns = model2->numberColumns();
    10301058        // just primal values pass
    10311059        model2->primal(2);
     
    11171145    delete [] columnDual;
    11181146#endif
     1147    if (saveLower) {
     1148      pinfo2.postsolve(true);
     1149      delete model2;
     1150      model2=saveModel2;
     1151      int numberRows = model2->numberRows();
     1152      int numberColumns = model2->numberColumns();
     1153      memcpy(model2->columnLower(),saveLower,numberColumns*sizeof(double));
     1154      memcpy(model2->rowLower(),saveLower+numberColumns,numberRows*sizeof(double));
     1155      delete [] saveLower;
     1156      memcpy(model2->columnUpper(),saveUpper,numberColumns*sizeof(double));
     1157      memcpy(model2->rowUpper(),saveUpper+numberColumns,numberRows*sizeof(double));
     1158      delete [] saveUpper;
     1159      model2->primal(1);
     1160    }
    11191161    model2->setPerturbation(savePerturbation);
    11201162    time2 = CoinCpuTime();
  • trunk/include/ClpInterior.hpp

    r378 r382  
    209209  /// Set cholesky (and delete present one)
    210210  void setCholesky(ClpCholeskyBase * cholesky);
     211  /// Return number fixed to see if worth presolving
     212  int numberFixed() const;
     213  /// fix variables interior says should be
     214  void fixFixed();
    211215  //@}
    212216
Note: See TracChangeset for help on using the changeset viewer.