Changeset 204 for branches


Ignore:
Timestamp:
Sep 3, 2003 5:42:52 PM (16 years ago)
Author:
forrest
Message:

Faster?

Location:
branches/pre
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • branches/pre/ClpModel.cpp

    r200 r204  
    12621262  return newArray;
    12631263}
     1264// Replace Clp Matrix (current is not deleted)
     1265void
     1266ClpModel::replaceMatrix( ClpMatrixBase * matrix)
     1267{
     1268  matrix_=matrix;
     1269}
    12641270// Subproblem constructor
    12651271ClpModel::ClpModel ( const ClpModel * rhs,
  • branches/pre/ClpSimplex.cpp

    r199 r204  
    11291129  changeMade_++; // something has happened
    11301130  // incoming variable
    1131 
    11321131  handler_->message(CLP_SIMPLEX_HOUSE1,messages_)
    11331132    <<directionOut_
  • branches/pre/ClpSimplexDual.cpp

    r197 r204  
    28692869  if (perturbation_>100)
    28702870    return; //perturbed already
    2871   int iRow,iColumn;
     2871  bool modifyRowCosts=true;
    28722872  // dual perturbation
    28732873  double perturbation=1.0e-20;
    28742874  // maximum fraction of cost to perturb
    28752875  double maximumFraction = 1.0e-4;
     2876  double factor=1.0e-8;
     2877  // If > 70 then do not do rows
     2878  if (perturbation_>70) {
     2879    modifyRowCosts=false;
     2880    perturbation_ -= 20;
     2881    //printf("Row costs not modified, ");
     2882  }
     2883  if (perturbation_>50) {
     2884    // Experiment
     2885    // factor could be 1.0e-8 to 1.0 (51,56,61,66 are 1.0e-8)
     2886    // maximumFraction could be 1.0e-6 to 1.0e-3 (51-55 are 1.0e-6)
     2887    double f[]={1.0e-8,1.0e-6,1.0e-4,1.0e-2,1.0};
     2888    double m[]={1.0e-6,1.0e-5,1.0e-4,1.0e-3};
     2889    factor = f[((perturbation_-1)%5)];
     2890    maximumFraction = m[(perturbation_-51)/5];
     2891  }
     2892  int iRow,iColumn;
    28762893  if (perturbation_>=50) {
    2877     perturbation = 1.0e-4;
     2894    perturbation = 1.0e-8;
    28782895    for (iRow=0;iRow<numberRows_;iRow++) {
    2879       double value = fabs(rowObjectiveWork_[iRow]);
    2880       perturbation = max(perturbation,value);
     2896      if (rowLowerWork_[iRow]<rowUpperWork_[iRow]) {
     2897        double value = fabs(rowObjectiveWork_[iRow]);
     2898        perturbation = max(perturbation,value);
     2899        if (value)
     2900          modifyRowCosts=true;
     2901      }
    28812902    }
    28822903    for (iColumn=0;iColumn<numberColumns_;iColumn++) {
    2883       double value =
    2884         fabs(objectiveWork_[iColumn]);
    2885       perturbation = max(perturbation,value);
    2886     }
    2887     perturbation *= 1.0e-8;
    2888   } else if (perturbation_<100) {
    2889     perturbation = pow(10.0,perturbation_);
     2904      if (columnLowerWork_[iColumn]<columnUpperWork_[iColumn]) {
     2905        double value =
     2906          fabs(objectiveWork_[iColumn]);
     2907        perturbation = max(perturbation,value);
     2908      }
     2909    }
     2910    perturbation *= factor;
     2911  } else {
    28902912    // user is in charge
    28912913    maximumFraction = 1.0e100;
    2892   }
     2914    // but some experiments
     2915    if (perturbation_<=-900) {
     2916      modifyRowCosts=false;
     2917      perturbation_ += 1000;
     2918      //printf("Row costs not modified, ");
     2919    }
     2920    if (perturbation_<-50) {
     2921      maximumFraction = 1.0;
     2922      while (perturbation_<-50) {
     2923        perturbation_ += 100;
     2924        maximumFraction *= 1.0e-1;
     2925      }
     2926    }
     2927    perturbation = pow(10.0,perturbation_);
     2928  }
     2929  //printf("factor %g, maximumFraction %g\n",factor,maximumFraction);
    28932930  // modify costs
    28942931  handler_->message(CLP_SIMPLEX_PERTURB,messages_)
    28952932    <<perturbation
    28962933    <<CoinMessageEol;
    2897   for (iRow=0;iRow<numberRows_;iRow++) {
    2898     double value = perturbation;
    2899     double currentValue = rowObjectiveWork_[iRow];
    2900     value = min(value,maximumFraction*fabs(currentValue)+1.0e-6);
    2901     if (rowLowerWork_[iRow]>-largeValue_) {
    2902       if (fabs(rowLowerWork_[iRow])<fabs(rowUpperWork_[iRow]))
    2903         value *= CoinDrand48();
    2904       else
     2934  if (modifyRowCosts) {
     2935    for (iRow=0;iRow<numberRows_;iRow++) {
     2936      if (rowLowerWork_[iRow]<rowUpperWork_[iRow]) {
     2937        double value = perturbation;
     2938        double currentValue = rowObjectiveWork_[iRow];
     2939        value = min(value,maximumFraction*fabs(currentValue)+1.0e-6);
     2940        if (rowLowerWork_[iRow]>-largeValue_) {
     2941          if (fabs(rowLowerWork_[iRow])<fabs(rowUpperWork_[iRow]))
     2942            value *= CoinDrand48();
     2943          else
     2944            value *= -CoinDrand48();
     2945        } else if (rowUpperWork_[iRow]<largeValue_) {
     2946          value *= -CoinDrand48();
     2947        } else {
     2948          value=0.0;
     2949        }
     2950        rowObjectiveWork_[iRow] += value;
     2951      }
     2952    }
     2953  }
     2954  for (iColumn=0;iColumn<numberColumns_;iColumn++) {
     2955    if (columnLowerWork_[iColumn]<columnUpperWork_[iColumn]) {
     2956      double value = perturbation;
     2957      double currentValue = objectiveWork_[iColumn];
     2958      value = min(value,maximumFraction*fabs(currentValue)+1.0e-6);
     2959      if (columnLowerWork_[iColumn]>-largeValue_) {
     2960        if (fabs(columnLowerWork_[iColumn])<
     2961            fabs(columnUpperWork_[iColumn]))
     2962          value *= CoinDrand48();
     2963        else
     2964          value *= -CoinDrand48();
     2965      } else if (columnUpperWork_[iColumn]<largeValue_) {
    29052966        value *= -CoinDrand48();
    2906     } else if (rowUpperWork_[iRow]<largeValue_) {
    2907       value *= -CoinDrand48();
    2908     } else {
    2909       value=0.0;
    2910     }
    2911     rowObjectiveWork_[iRow] += value;
    2912   }
    2913   for (iColumn=0;iColumn<numberColumns_;iColumn++) {
    2914     double value = perturbation;
    2915     double currentValue = objectiveWork_[iColumn];
    2916     value = min(value,maximumFraction*fabs(currentValue)+1.0e-6);
    2917     if (columnLowerWork_[iColumn]>-largeValue_) {
    2918       if (fabs(columnLowerWork_[iColumn])<
    2919           fabs(columnUpperWork_[iColumn]))
    2920         value *= CoinDrand48();
    2921       else
    2922         value *= -CoinDrand48();
    2923     } else if (columnUpperWork_[iColumn]<largeValue_) {
    2924       value *= -CoinDrand48();
    2925     } else {
    2926       value=0.0;
    2927     }
    2928     objectiveWork_[iColumn] += value;
     2967      } else {
     2968        value=0.0;
     2969      }
     2970      objectiveWork_[iColumn] += value;
     2971    }
    29292972  }
    29302973  // and zero changes
  • branches/pre/ClpSimplexPrimal.cpp

    r190 r204  
    13251325          upperValue=0.0;
    13261326        double value = max(lowerValue,upperValue);
     1327        value = min(value,upper_[i]-lower_[i]);
    13271328        perturbation = max(perturbation,value);
    13281329      }
     
    13381339    <<perturbation
    13391340    <<CoinMessageEol;
    1340   for (i=0;i<numberColumns_+numberRows_;i++) {
     1341  for (i=0;i<numberColumns_;i++) {
    13411342    double lowerValue=lower_[i], upperValue=upper_[i];
    13421343    if (upperValue>lowerValue+primalTolerance_) {
    13431344      double value = CoinDrand48()*perturbation;
     1345      if (lowerValue>-1.0e20&&lowerValue)
     1346        lowerValue -= value * (max(1.0,1.0e-5*fabs(lowerValue)));
     1347      if (upperValue<1.0e20&&upperValue)
     1348        upperValue += value * (max(1.0,1.0e-5*fabs(upperValue)));
     1349    }
     1350    lower_[i]=lowerValue;
     1351    upper_[i]=upperValue;
     1352  }
     1353  for (;i<numberColumns_+numberRows_;i++) {
     1354    double lowerValue=lower_[i], upperValue=upper_[i];
     1355    double value = CoinDrand48()*perturbation;
     1356    if (upperValue>lowerValue+primalTolerance_) {
    13441357      if (lowerValue>-1.0e20)
    1345         lowerValue -= value * (max(1.0,1.0e-3*fabs(lowerValue)));
     1358        lowerValue -= value * (max(1.0,1.0e-5*fabs(lowerValue)));
    13461359      if (upperValue<1.0e20)
    1347         upperValue += value * (max(1.0,1.0e-3*fabs(upperValue)));
     1360        upperValue += value * (max(1.0,1.0e-5*fabs(upperValue)));
     1361    } else if (upperValue>0.0) {
     1362        lowerValue -= value * (max(1.0,1.0e-5*fabs(lowerValue)));
     1363        upperValue -= value * (max(1.0,1.0e-5*fabs(lowerValue)));
     1364    } else if (upperValue<0.0) {
     1365        lowerValue += value * (max(1.0,1.0e-5*fabs(lowerValue)));
     1366        upperValue += value * (max(1.0,1.0e-5*fabs(lowerValue)));
     1367    } else {
    13481368    }
    13491369    lower_[i]=lowerValue;
  • branches/pre/ClpSimplexPrimalQuadratic.cpp

    r203 r204  
    532532  ClpObjective * saveObj = objectiveAsObject();
    533533  setObjectivePointer(info->originalObjective());
     534  factorization_->setBiasLU(0);
    534535  if (!startup(1)) {
    535536
     
    998999          upperIn_=upper_[sequenceIn_];
    9991000          dualIn_=dj_[sequenceIn_];
    1000           valueIn_=solution_[sequenceIn_];
     1001          valueIn_=solution_[sequenceIn_];
    10011002          if (dualIn_>0.0)
    10021003            directionIn_ = -1;
  • branches/pre/Makefile.Clp

    r203 r204  
    11# Static or shared libraries should be built (STATIC or SHARED)?
    22LibType := SHARED
     3#LibType := STATIC
    34
    45# Select optimization (-O or -g). -O will be automatically bumped up to the
  • branches/pre/Test/ClpMain.cpp

    r196 r204  
    2020#include "ClpFactorization.hpp"
    2121#include "ClpSimplex.hpp"
     22#include "ClpPackedMatrix.hpp"
     23#include "ClpPlusMinusOneMatrix.hpp"
     24#include "ClpNetworkMatrix.hpp"
    2225#include "ClpDualRowSteepest.hpp"
    2326#include "ClpDualRowDantzig.hpp"
     
    5760 
    5861  DIRECTION=201,DUALPIVOT,SCALING,ERRORSALLOWED,KEEPNAMES,SPARSEFACTOR,
    59   PRIMALPIVOT,PRESOLVE,CRASH,
     62  PRIMALPIVOT,PRESOLVE,CRASH,BIASLU,
    6063 
    6164  DIRECTORY=301,IMPORT,EXPORT,RESTORE,SAVE,DUALSIMPLEX,PRIMALSIMPLEX,BAB,
    6265  MAXIMIZE,MINIMIZE,EXIT,STDIN,UNITTEST,NETLIB_DUAL,NETLIB_PRIMAL,SOLUTION,
    63   TIGHTEN,FAKEBOUND,VERSION,
     66  TIGHTEN,FAKEBOUND,VERSION,PLUSMINUS,NETWORK,
    6467
    6568  INVALID=1000
     
    758761    parameters[numberParameters++]=
    759762      ClpItem("pert!urbation","Method of perturbation",
    760               -50,102,PERTURBATION);
     763              -5000,102,PERTURBATION);
    761764    parameters[numberParameters++]=
    762765      ClpItem("direction","Minimize or Maximize",
     
    796799    parameters[numberParameters-1].append("off");
    797800    parameters[numberParameters++]=
     801      ClpItem("biasLU","Whether factorization biased towards U",
     802              "UU",BIASLU);
     803    parameters[numberParameters-1].append("UX");
     804    parameters[numberParameters-1].append("LX");
     805    parameters[numberParameters-1].append("LL");
     806    parameters[numberParameters++]=
    798807      ClpItem("error!sAllowed","Whether to allow import errors",
    799808              "off",ERRORSALLOWED);
     
    830839      ClpItem("tight!en","Poor person's preSolve for now",
    831840              TIGHTEN);
     841    parameters[numberParameters++]=
     842      ClpItem("plus!Minus","Tries to make +- 1",
     843              PLUSMINUS);
     844    parameters[numberParameters++]=
     845      ClpItem("network","Tries to make network",
     846              NETWORK);
    832847    parameters[numberParameters++]=
    833848      ClpItem("sol!ution","Prints solution to file",
     
    876891    ClpSimplex * models = new ClpSimplex[1];
    877892    bool * goodModels = new bool[1];
    878    
     893    int getNewMatrix=0;
     894    models->setPerturbation(73);
    879895#ifdef READLINE     
    880896    currentModel = models;
     
    10531069              models[iModel].setSparseFactorization((1-action)!=0);
    10541070              break;
     1071            case BIASLU:
     1072              models[iModel].factorization()->setBiasLU(action);
     1073              break;
    10551074            case ERRORSALLOWED:
    10561075              allowImportErrors = action;
     
    10781097            if (goodModels[iModel]) {
    10791098              int saveMaxIterations = models[iModel].maximumIterations();
     1099              int numberIterations=0;
    10801100              time1 = CoinCpuTime();
     1101              ClpMatrixBase * saveMatrix=NULL;
    10811102#ifdef USE_PRESOLVE
    10821103              ClpSimplex * model2 = models+iModel;
     
    11161137                }
    11171138              }
     1139              if (getNewMatrix) {
     1140                saveMatrix = model2->clpMatrix();
     1141                ClpPackedMatrix* clpMatrix =
     1142                  dynamic_cast< ClpPackedMatrix*>(saveMatrix);
     1143                if (clpMatrix) {
     1144                  if (getNewMatrix==1) {
     1145                    ClpPlusMinusOneMatrix * newMatrix = new ClpPlusMinusOneMatrix(*(clpMatrix->matrix()));
     1146                    if (newMatrix->getIndices()) {
     1147                      std::cout<<"** Matrix is valid +- one"<<std::endl;
     1148                      model2->replaceMatrix(newMatrix);
     1149                    } else {
     1150                      std::cout<<"** Matrix is NOT valid +- one"<<std::endl;
     1151                      saveMatrix=NULL;
     1152                      delete newMatrix;
     1153                    }
     1154                  } else if (getNewMatrix==2) {
     1155                    ClpNetworkMatrix * newMatrix = new ClpNetworkMatrix(*(clpMatrix->matrix()));
     1156                    if (newMatrix->getIndices()) {
     1157                      std::cout<<"** Matrix is valid network"<<std::endl;
     1158                      model2->replaceMatrix(newMatrix);
     1159                    } else {
     1160                      std::cout<<"** Matrix is NOT valid network"<<std::endl;
     1161                      saveMatrix=NULL;
     1162                      delete newMatrix;
     1163                    }
     1164                  }
     1165                } else {
     1166                  saveMatrix=NULL;
     1167                }
     1168              }
     1169              if (model2->factorizationFrequency()==200) {
     1170                // User did not touch preset
     1171                model2->setFactorizationFrequency(100+model2->numberRows()/100);
     1172              }
    11181173              if (type==DUALSIMPLEX) {
    11191174                if (doIdiot<0)
     
    11291184                }
    11301185#endif
     1186                int savePerturbation = model2->perturbation();
     1187                if (savePerturbation==73)
     1188                  model2->setPerturbation(100);
    11311189                model2->primal(1);
    1132               }
     1190                model2->setPerturbation(savePerturbation);
     1191              }
     1192              if (saveMatrix) {
     1193                // delete and replace
     1194                delete model2->clpMatrix();
     1195                model2->replaceMatrix(saveMatrix);
     1196              }
     1197              numberIterations = model2->numberIterations();
    11331198              if (preSolve) {
    11341199#if 0
     
    12631328                  models[iModel].primal(1);
    12641329                  models[iModel].setPerturbation(savePerturbation);
     1330                  numberIterations += models[iModel].numberIterations();
    12651331                }
    12661332#ifdef CLP_DEBUG_not
     
    12981364              std::cout<<"Result "<<models[iModel].status()<<
    12991365                " - "<<models[iModel].objectiveValue()<<
    1300                 " iterations "<<models[iModel].numberIterations()<<
     1366                " iterations "<<numberIterations<<
    13011367                " took "<<time2-time1<<" seconds - total "<<totalTime<<std::endl;
    13021368              if (models[iModel].status())
     
    13161382              std::cout<<"** Current model not valid"<<std::endl;
    13171383            }
     1384            break;
     1385          case PLUSMINUS:
     1386            getNewMatrix=1;
     1387            break;
     1388          case NETWORK:
     1389            getNewMatrix=2;
    13181390            break;
    13191391          case BAB:
  • branches/pre/Test/Makefile.test

    r203 r204  
    8888        @mkdir -p $(TARGETDIR)
    8989        @rm -f $@
     90#       $(CXX) -static $(CXXFLAGS) -o $@ $(TESTOBJ) $(LDFLAGS) $(SYSLD) -lm
    9091        $(CXX) $(CXXFLAGS) -o $@ $(TESTOBJ) $(LDFLAGS) $(SYSLD) -lm
    9192        ${CP} $@ ..
  • branches/pre/include/ClpModel.hpp

    r200 r204  
    317317   /// Clp Matrix
    318318   inline ClpMatrixBase * clpMatrix() const     { return matrix_; }
     319  /** Replace Clp Matrix (current is not deleted and new is used)
     320      So up to user to delete one
     321  */
     322   void replaceMatrix(ClpMatrixBase * matrix);
    319323   /// Objective value
    320324   inline double objectiveValue() const {
Note: See TracChangeset for help on using the changeset viewer.