Changeset 266


Ignore:
Timestamp:
Dec 3, 2003 4:54:26 PM (16 years ago)
Author:
forrest
Message:

Trying to improve cycling and more barrier stuff

Location:
trunk
Files:
1 added
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/ClpCholeskyDense.cpp

    r263 r266  
    197197/* Uses factorization to solve. */
    198198void
    199 ClpCholeskyDense::solve (double * region) const
     199ClpCholeskyDense::solve (double * region)
    200200{
    201201  int iColumn;
  • trunk/ClpDualRowSteepest.cpp

    r256 r266  
    677677      alternateWeights_->reserve(numberRows+
    678678                                 model_->factorization()->maximumPivots());
    679       if (!mode_||mode_==2||mode==5) {
     679      if (mode_!=1||mode==5) {
    680680        // initialize to 1.0 (can we do better?)
    681681        for (i=0;i<numberRows;i++) {
  • trunk/ClpInterior.cpp

    r263 r266  
    913913  }
    914914}
     915// Set cholesky (and delete present one)
     916void
     917ClpInterior::setCholesky(ClpCholeskyBase * cholesky)
     918{
     919  delete cholesky_;
     920  cholesky_= cholesky;
     921}
  • trunk/ClpSimplex.cpp

    r264 r266  
    12041204  if (hitMaximumIterations())
    12051205    return 2;
    1206 #if 0
     1206#if 1
     1207  //if (numberIterations_>14000)
     1208  //handler_->setLogLevel(63);
     1209  //if (numberIterations_>24000)
     1210  //exit(77);
    12071211  // check for small cycles
    12081212  int cycle=progress_->cycle(sequenceIn_,sequenceOut_,
    12091213                            directionIn_,directionOut_);
    12101214  if (cycle>0) {
    1211     printf("Cycle of %d\n",cycle);
     1215    if (handler_->logLevel()>=63)
     1216      printf("Cycle of %d\n",cycle);
    12121217    // reset
    12131218    progress_->startCheck();
     
    12221227        iSequence = sequenceOut_;
    12231228      char x = isColumn(iSequence) ? 'C' :'R';
    1224       handler_->message(CLP_SIMPLEX_FLAG,messages_)
    1225         <<x<<sequenceWithin(iSequence)
    1226         <<CoinMessageEol;
     1229      if (handler_->logLevel()>=63)
     1230        handler_->message(CLP_SIMPLEX_FLAG,messages_)
     1231          <<x<<sequenceWithin(iSequence)
     1232          <<CoinMessageEol;
    12271233      setFlagged(iSequence);
    1228       printf("flagging %d\n",iSequence);
     1234      //printf("flagging %d\n",iSequence);
    12291235    }
    12301236    return 1;
     
    46314637  }
    46324638  for (i=0;i<CLP_CYCLE;i++) {
    4633     obj_[i]=COIN_DBL_MAX;
     4639    //obj_[i]=COIN_DBL_MAX;
    46344640    in_[i]=-1;
    46354641    out_[i]=-1;
     
    46594665  }
    46604666  for (i=0;i<CLP_CYCLE;i++) {
    4661     obj_[i]=rhs.obj_[i];
     4667    //obj_[i]=rhs.obj_[i];
    46624668    in_[i]=rhs.in_[i];
    46634669    out_[i]=rhs.out_[i];
     
    46844690  }
    46854691  for (i=0;i<CLP_CYCLE;i++) {
    4686     obj_[i]=COIN_DBL_MAX;
     4692    //obj_[i]=COIN_DBL_MAX;
    46874693    in_[i]=-1;
    46884694    out_[i]=-1;
     
    47064712    }
    47074713    for (i=0;i<CLP_CYCLE;i++) {
    4708       obj_[i]=rhs.obj_[i];
     4714      //obj_[i]=rhs.obj_[i];
    47094715      in_[i]=rhs.in_[i];
    47104716      out_[i]=rhs.out_[i];
     
    48024808      // make factorize every iteration
    48034809      model_->forceFactorization(1);
    4804       if (model_->algorithm()<0) {
    4805         // dual - change tolerance
    4806         model_->setCurrentDualTolerance(model_->currentDualTolerance()*1.05);
    4807         // if infeasible increase dual bound
    4808         if (model_->dualBound()<1.0e17) {
    4809           model_->setDualBound(model_->dualBound()*1.1);
     4810      if (numberBadTimes_<2) {
     4811        startCheck(); // clear other loop check
     4812        if (model_->algorithm()<0) {
     4813          // dual - change tolerance
     4814          model_->setCurrentDualTolerance(model_->currentDualTolerance()*1.05);
     4815          // if infeasible increase dual bound
     4816          if (model_->dualBound()<1.0e17) {
     4817            model_->setDualBound(model_->dualBound()*1.1);
     4818          }
     4819        } else {
     4820          // primal - change tolerance 
     4821          if (numberBadTimes_>3)
     4822            model_->setCurrentPrimalTolerance(model_->currentPrimalTolerance()*1.05);
     4823          // if infeasible increase infeasibility cost
     4824          if (model_->nonLinearCost()->numberInfeasibilities()&&
     4825              model_->infeasibilityCost()<1.0e17) {
     4826            model_->setInfeasibilityCost(model_->infeasibilityCost()*1.1);
     4827          }
    48104828        }
    48114829      } else {
    4812         // primal - change tolerance   
    4813         if (numberBadTimes_>3)
    4814           model_->setCurrentPrimalTolerance(model_->currentPrimalTolerance()*1.05);
    4815         // if infeasible increase infeasibility cost
    4816         if (model_->nonLinearCost()->numberInfeasibilities()&&
    4817             model_->infeasibilityCost()<1.0e17) {
    4818           model_->setInfeasibilityCost(model_->infeasibilityCost()*1.1);
     4830        // flag
     4831        int iSequence;
     4832        if (model_->algorithm()<0) {
     4833          // dual
     4834          if (model_->dualBound()>1.0e14)
     4835            model_->setDualBound(1.0e14);
     4836          iSequence=in_[CLP_CYCLE-1];
     4837        } else {
     4838          // primal
     4839          if (model_->infeasibilityCost()>1.0e14)
     4840            model_->setInfeasibilityCost(1.0e14);
     4841          iSequence=out_[CLP_CYCLE-1];
    48194842        }
     4843        if (iSequence>=0) {
     4844          char x = model_->isColumn(iSequence) ? 'C' :'R';
     4845          if (model_->messageHandler()->logLevel()>=63)
     4846            model_->messageHandler()->message(CLP_SIMPLEX_FLAG,model_->messages())
     4847              <<x<<model_->sequenceWithin(iSequence)
     4848              <<CoinMessageEol;
     4849          model_->setFlagged(iSequence);
     4850          //printf("flagging %d from loop\n",iSequence);
     4851          startCheck();
     4852        } else {
     4853          printf("-1 sequence\n");
     4854        }
     4855        // reset
     4856        numberBadTimes_=2;
    48204857      }
    48214858      return -2;
     
    48604897  int i;
    48614898  for (i=0;i<CLP_CYCLE;i++) {
    4862     obj_[i]=COIN_DBL_MAX;
     4899    //obj_[i]=COIN_DBL_MAX;
    48634900    in_[i]=-1;
    48644901    out_[i]=-1;
     
    48804917    }
    48814918  }
     4919#if 0
    48824920  if (!matched||in_[0]<0) {
    48834921    // can't be cycle
    48844922    for (i=0;i<CLP_CYCLE-1;i++) {
    4885       obj_[i]=obj_[i+1];
     4923      //obj_[i]=obj_[i+1];
    48864924      in_[i]=in_[i+1];
    48874925      out_[i]=out_[i+1];
     
    48994937      for(k=i+1;k<CLP_CYCLE;k++) {
    49004938        if (inThis==in_[k]&&outThis==out_[k]&&wayThis==way_[k]) {
    4901           if (k+(k-i)<CLP_CYCLE) {
     4939          int distance = k-i;
     4940          if (k+distance<CLP_CYCLE) {
    49024941            // See if repeats
    4903             int j=k+(k-i);
     4942            int j=k+distance;
    49044943            if (inThis==in_[j]&&outThis==out_[j]&&wayThis==way_[j]) {
    4905               matched=k-i;
     4944              matched=distance;
    49064945              break;
    49074946            }
    49084947          } else {
    4909             matched=k-i;
     4948            matched=distance;
    49104949            break;
    49114950          }
    49124951        }
    49134952      }
    4914       obj_[i]=obj_[i+1];
     4953      //obj_[i]=obj_[i+1];
    49154954      in_[i]=in_[i+1];
    49164955      out_[i]=out_[i+1];
     
    49184957    }
    49194958  }
     4959#else
     4960  if (matched&&in_[0]>=0) {
     4961    // possible cycle - only check [0] against all
     4962    matched=0;
     4963    char way0 = way_[0];
     4964    int in0 = in_[0];
     4965    int out0 = out_[0];
     4966    //double obj0 = obj_[i];
     4967    for(int k=1;k<CLP_CYCLE-4;k++) {
     4968      if (in0==in_[k]&&out0==out_[k]&&way0==way_[k]) {
     4969        // See if repeats
     4970        int end = CLP_CYCLE-k;
     4971        int j;
     4972        for ( j=1;j<end;j++) {
     4973          if (in_[j+k]!=in_[j]||out_[j+k]!=out_[j]||way_[j+k]!=way_[j])
     4974            break;
     4975        }
     4976        if (j==end) {
     4977          matched=k;
     4978          break;
     4979        }
     4980      }
     4981    }
     4982  }
     4983  for (i=0;i<CLP_CYCLE-1;i++) {
     4984    //obj_[i]=obj_[i+1];
     4985    in_[i]=in_[i+1];
     4986    out_[i]=out_[i+1];
     4987    way_[i]=way_[i+1];
     4988  }
     4989#endif
    49204990  char way = 1-wayIn+4*(1-wayOut);
    4921   obj_[i]=model_->objectiveValue();
     4991  //obj_[i]=model_->objectiveValue();
    49224992  in_[CLP_CYCLE-1]=in;
    49234993  out_[CLP_CYCLE-1]=out;
  • trunk/ClpSimplexPrimal.cpp

    r263 r266  
    864864          // back off weight
    865865          infeasibilityCost_ = 1.0e13;
    866           goToDual=unPerturb(); // stop any further perturbation
     866          unPerturb(); // stop any further perturbation
    867867        }
    868868        //we need infeasiblity cost changed
  • trunk/ClpSolve.cpp

    r263 r266  
    1515#include "ClpSimplex.hpp"
    1616#include "ClpInterior.hpp"
     17#include "ClpCholeskyWssmp.hpp"
    1718#include "ClpSolve.hpp"
    1819#include "ClpPackedMatrix.hpp"
     
    864865    printf("***** experimental pretty crude barrier\n");
    865866    ClpInterior barrier(*model2);
     867    //ClpCholeskyWssmp * cholesky = new ClpCholeskyWssmp();
     868    //barrier.setCholesky(cholesky);
    866869    barrier.primalDual();
    867870    time2 = CoinCpuTime();
Note: See TracChangeset for help on using the changeset viewer.