Changeset 707


Ignore:
Timestamp:
Jan 13, 2006 11:35:56 AM (15 years ago)
Author:
forrest
Message:

add presolve tolerance

Location:
trunk
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/ClpSolve.cpp

    r701 r707  
    543543      // PreSolve to file - not fully tested
    544544      printf("Presolving to file - presolve.save\n");
    545       pinfo.presolvedModelToFile(*this,"presolve.save",1.0e-8,
     545      pinfo.presolvedModelToFile(*this,"presolve.save",dblParam_[ClpPresolveTolerance],
    546546                           false,numberPasses);
    547547      model2=this;
    548548    } else {
    549549#endif
    550       model2 = pinfo.presolvedModel(*this,1.0e-8,
     550      model2 = pinfo.presolvedModel(*this,dblParam_[ClpPresolveTolerance],
    551551                                    false,numberPasses,true,costedSlacks);
    552552#ifndef CLP_NO_STD
     
    935935      int numberRows = model2->numberRows();
    936936      double * saveObj = new double[numberColumns];
    937       memcpy(saveObj,model2->objective(),numberColumns*sizeof(double));
    938       memcpy(model2->dualColumnSolution(),model2->objective(),
    939              numberColumns*sizeof(double));
     937      CoinMemcpyN(model2->objective(),numberColumns,saveObj);
     938      CoinMemcpyN(model2->objective(),
     939             numberColumns,model2->dualColumnSolution());
    940940      model2->clpMatrix()->transposeTimes(-1.0,pi,model2->dualColumnSolution());
    941       memcpy(model2->objective(),model2->dualColumnSolution(),
    942              numberColumns*sizeof(double));
     941      CoinMemcpyN(model2->dualColumnSolution(),
     942             numberColumns,model2->objective());
    943943      const double * rowsol = model2->primalRowSolution();
    944944      double offset=0.0;
     
    961961      model2->dual(0);
    962962      model2->setDblParam(ClpObjOffset,value2);
    963       memcpy(model2->objective(),saveObj,numberColumns*sizeof(double));
     963      CoinMemcpyN(saveObj,numberColumns,model2->objective());
    964964      // zero out pi
    965965      //memset(pi,0,numberRows*sizeof(double));
     
    11471147        int iColumn;
    11481148        double * saveLower = new double[numberColumns];
    1149         memcpy(saveLower,model2->columnLower(),numberColumns*sizeof(double));
     1149        CoinMemcpyN(model2->columnLower(),numberColumns,saveLower);
    11501150        double * saveUpper = new double[numberColumns];
    1151         memcpy(saveUpper,model2->columnUpper(),numberColumns*sizeof(double));
     1151        CoinMemcpyN(model2->columnUpper(),numberColumns,saveUpper);
    11521152        printf("doing tighten before idiot\n");
    11531153        model2->tightenPrimalBounds();
     
    11631163            solution[iColumn]=0.0;
    11641164        }
    1165         memcpy(columnLower,saveLower,numberColumns*sizeof(double));
    1166         memcpy(columnUpper,saveUpper,numberColumns*sizeof(double));
     1165        CoinMemcpyN(saveLower,numberColumns,columnLower);
     1166        CoinMemcpyN(saveUpper,numberColumns,columnUpper);
    11671167        delete [] saveLower;
    11681168        delete [] saveUpper;
     
    12591259    // now see what that does to row solution
    12601260    double * rowSolution = model2->primalRowSolution();
    1261     memset (rowSolution,0,numberRows*sizeof(double));
     1261    CoinZeroN (rowSolution,numberRows);
    12621262    model2->times(1.0,columnSolution,rowSolution);
    12631263   
     
    13151315      model2->setPerturbation(100);
    13161316      saveLower = new double[numberRows];
    1317       memcpy(saveLower,model2->rowLower_,numberRows*sizeof(double));
     1317      CoinMemcpyN(model2->rowLower_,numberRows,saveLower);
    13181318      saveUpper = new double[numberRows];
    1319       memcpy(saveUpper,model2->rowUpper_,numberRows*sizeof(double));
     1319      CoinMemcpyN(model2->rowUpper_,numberRows,saveUpper);
    13201320      double * lower = model2->rowLower();
    13211321      double * upper = model2->rowUpper();
     
    13891389      double * rowSolution = model2->primalRowSolution();
    13901390      double * sumFixed = new double[numberRows];
    1391       memset (sumFixed,0,numberRows*sizeof(double));
     1391      CoinZeroN (sumFixed,numberRows);
    13921392      int iRow,iColumn;
    13931393      // zero out ones in small problem
     
    14281428      for (iRow=0;iRow<numberRows;iRow++)
    14291429        model2->setRowStatus(iRow,small.getRowStatus(iRow));
    1430       memcpy(model2->primalRowSolution(),small.primalRowSolution(),
    1431              numberRows*sizeof(double));
     1430      CoinMemcpyN(small.primalRowSolution(),
     1431             numberRows,model2->primalRowSolution());
    14321432      // get reduced cost for large problem
    1433       memcpy(weight,model2->objective(),numberColumns*sizeof(double));
     1433      CoinMemcpyN(model2->objective(),numberColumns,weight);
    14341434      model2->transposeTimes(-1.0,small.dualRowSolution(),weight);
    14351435      int numberNegative=0;
     
    16711671      saveLower = new double [numberTotal];
    16721672      saveUpper = new double [numberTotal];
    1673       memcpy(saveLower,barrier.columnLower(),numberColumns*sizeof(double));
    1674       memcpy(saveLower+numberColumns,barrier.rowLower(),numberRows*sizeof(double));
    1675       memcpy(saveUpper,barrier.columnUpper(),numberColumns*sizeof(double));
    1676       memcpy(saveUpper+numberColumns,barrier.rowUpper(),numberRows*sizeof(double));
     1673      CoinMemcpyN(barrier.columnLower(),numberColumns,saveLower);
     1674      CoinMemcpyN(barrier.rowLower(),numberRows,saveLower+numberColumns);
     1675      CoinMemcpyN(barrier.columnUpper(),numberColumns,saveUpper);
     1676      CoinMemcpyN(barrier.rowUpper(),numberRows,saveUpper+numberColumns);
    16771677      barrier.fixFixed();
    16781678      saveModel2=model2;
     
    17131713    if (saveModel2) {
    17141714      // do presolve
    1715       model2 = pinfo2.presolvedModel(*model2,1.0e-8,
     1715      model2 = pinfo2.presolvedModel(*model2,dblParam_[ClpPresolveTolerance],
    17161716                                    false,5,true);
    17171717      if (!model2) {
     
    18011801            double * cost = model2->objective();
    18021802            double * saveCost = new double[numberColumns];
    1803             memcpy(saveCost,cost,numberColumns*sizeof(double));
     1803            CoinMemcpyN(cost,numberColumns,saveCost);
    18041804            double * saveLower = new double[numberColumns];
    18051805            double * lower = model2->columnLower();
    1806             memcpy(saveLower,lower,numberColumns*sizeof(double));
     1806            CoinMemcpyN(lower,numberColumns,saveLower);
    18071807            double * saveUpper = new double[numberColumns];
    18081808            double * upper = model2->columnUpper();
    1809             memcpy(saveUpper,upper,numberColumns*sizeof(double));
     1809            CoinMemcpyN(upper,numberColumns,saveUpper);
    18101810            int i;
    18111811            double tolerance = 10.0*dualTolerance_;
     
    18411841            //model2->setFactorizationFrequency(1);
    18421842            model2->dual(2);
    1843             memcpy(cost,saveCost,numberColumns*sizeof(double));
     1843            CoinMemcpyN(saveCost,numberColumns,cost);
    18441844            delete [] saveCost;
    1845             memcpy(lower,saveLower,numberColumns*sizeof(double));
     1845            CoinMemcpyN(saveLower,numberColumns,lower);
    18461846            delete [] saveLower;
    1847             memcpy(upper,saveUpper,numberColumns*sizeof(double));
     1847            CoinMemcpyN(saveUpper,numberColumns,upper);
    18481848            delete [] saveUpper;
    18491849          }
     
    18901890      int numberRows = model2->numberRows();
    18911891      int numberColumns = model2->numberColumns();
    1892       memcpy(model2->columnLower(),saveLower,numberColumns*sizeof(double));
    1893       memcpy(model2->rowLower(),saveLower+numberColumns,numberRows*sizeof(double));
     1892      CoinMemcpyN(saveLower,numberColumns,model2->columnLower());
     1893      CoinMemcpyN(saveLower+numberColumns,numberRows,model2->rowLower());
    18941894      delete [] saveLower;
    1895       memcpy(model2->columnUpper(),saveUpper,numberColumns*sizeof(double));
    1896       memcpy(model2->rowUpper(),saveUpper+numberColumns,numberRows*sizeof(double));
     1895      CoinMemcpyN(saveUpper,numberColumns,model2->columnUpper());
     1896      CoinMemcpyN(saveUpper+numberColumns,numberRows,model2->rowUpper());
    18971897      delete [] saveUpper;
    18981898      model2->primal(1);
  • trunk/Test/CbcOrClpParam.cpp

    r704 r707  
    387387    return 1;
    388388  } else {
    389     double oldValue;
     389    double oldValue=doubleValue_;
     390    doubleValue_=value;
    390391    switch(type_) {
    391392    case DUALTOLERANCE:
     
    398399      break;
    399400    default:
    400       oldValue=0.0; // to avoid compiler message
    401       abort();
     401      break;
    402402    }
    403403    std::cout<<name_<<" was changed from "<<oldValue<<" to "
     
    411411CbcOrClpParam::setDoubleParameter (ClpSimplex * model,double value)
    412412{
    413   double oldValue = doubleParameter(model);
     413  double oldValue = doubleValue_;
    414414  if (value<lowerDoubleValue_||value>upperDoubleValue_) {
    415415    std::cout<<value<<" was provided for "<<name_<<
     
    420420    std::cout<<name_<<" was changed from "<<oldValue<<" to "
    421421             <<value<<std::endl;
     422    doubleValue_=value;
    422423    switch(type_) {
    423424#ifndef COIN_USE_CBC
     
    446447      model->setRhsScale(value);
    447448      break;
     449    case PRESOLVETOLERANCE:
     450      model->setDblParam(ClpPresolveTolerance,value);
     451      break;
    448452    default:
    449       abort();
     453      break;
    450454    }
    451455    return 0;
     
    483487    break;
    484488  default:
    485     abort();
     489    value=doubleValue_;
     490    break;
    486491  }
    487492  return value;
     
    490495CbcOrClpParam::setIntParameter (ClpSimplex * model,int value)
    491496{
    492   int oldValue = intParameter(model);
     497  int oldValue = intValue_;
    493498  if (value<lowerIntValue_||value>upperIntValue_) {
    494499    std::cout<<value<<" was provided for "<<name_<<
     
    497502    return 1;
    498503  } else {
     504    intValue_=value;
    499505    std::cout<<name_<<" was changed from "<<oldValue<<" to "
    500506             <<value<<std::endl;
     
    520526      break;
    521527    default:
    522       abort();
     528      break;
    523529    }
    524530    return 0;
     
    549555    break;
    550556  default:
    551     value=-1;
     557    value=intValue_;
    552558    break;
    553559  }
     
    580586    break;
    581587  default:
    582     abort();
     588    return doubleValue_;
     589    break;
    583590  }
    584591  return value;
     
    593600    return 1;
    594601  } else {
    595     int oldValue;
     602    int oldValue=intValue_;
     603    intValue_=oldValue;
    596604    switch(type_) {
    597605    case SOLVERLOGLEVEL:
     
    599607      break;
    600608    default:
    601       oldValue=0; // to avoid compiler message
    602       abort();
     609      break;
    603610    }
    604611    std::cout<<name_<<" was changed from "<<oldValue<<" to "
     
    616623    break;
    617624  default:
    618     abort();
     625    value=intValue_;
     626    break;
    619627  }
    620628  return value;
     
    629637    return 1;
    630638  } else {
    631     double oldValue;
    632     setDoubleValue(value);
     639    double oldValue=doubleValue_;
     640    doubleValue_ = value;
    633641    switch(type_) {
    634642    case INFEASIBILITYWEIGHT:
     
    665673      return 0; // to avoid message
    666674    default:
    667       oldValue=0.0; // to avoid compiler message
    668675      break;
    669676    }
     
    700707    break;
    701708  default:
    702     abort();
     709    value = doubleValue_;
     710    break;
    703711  }
    704712  return value;
     
    713721    return 1;
    714722  } else {
    715     setIntValue(value);
    716     int oldValue;
     723    int oldValue=intValue_;
     724    intValue_ = value;
    717725    switch(type_) {
    718726    case LOGLEVEL:
     
    745753      break;
    746754    default:
    747       oldValue=0; // to avoid compiler message
    748755      break;
    749756    }
     
    780787    break;
    781788  default:
    782     abort();
     789    value=intValue_;
     790    break;
    783791  }
    784792  return value;
     
    15811589                  0,INT_MAX,MIPOPTIONS,false);
    15821590  parameters[numberParameters++]=
     1591    CbcOrClpParam("more!MipOptions","More dubious options for mip",
     1592                  0,INT_MAX,MOREMIPOPTIONS,false);
     1593  parameters[numberParameters++]=
    15831594    CbcOrClpParam("mixed!IntegerRoundingCuts","Whether to use Mixed Integer Rounding cuts",
    15841595                  "off",MIXEDCUTS);
     
    18031814#endif
    18041815#ifdef COIN_USE_CLP
     1816  parameters[numberParameters++]=
     1817    CbcOrClpParam("preT!olerance","Tolerance to use in presolve",
     1818                  1.0e-20,1.0e12,PRESOLVETOLERANCE);
     1819  parameters[numberParameters-1].setLonghelp
     1820    (
     1821     "The default is 1.0e-8 - you may wish to try 1.0e-7"
     1822     );
    18051823  parameters[numberParameters++]=
    18061824    CbcOrClpParam("primalP!ivot","Primal pivot choice algorithm",
  • trunk/Test/CbcOrClpParam.hpp

    r704 r707  
    4646   
    4747    INFEASIBILITYWEIGHT = 51, CUTOFF, INTEGERTOLERANCE,INCREMENT,ALLOWABLEGAP,
    48     TIMELIMIT_BAB, 
    49    
    50     DJFIX = 81, GAPRATIO,TIGHTENFACTOR,
     48    TIMELIMIT_BAB,
     49   
     50    DJFIX = 81, GAPRATIO,TIGHTENFACTOR,PRESOLVETOLERANCE,
    5151
    5252    SOLVERLOGLEVEL=101,
     
    5959
    6060    STRONGBRANCHING=151,CUTDEPTH, MAXNODES,NUMBERBEFORE,NUMBERANALYZE,
    61     NUMBERMINI,MIPOPTIONS,
     61    NUMBERMINI,MIPOPTIONS,MOREMIPOPTIONS,
    6262#ifdef COIN_USE_CBC
    6363    LOGLEVEL ,
  • trunk/Test/ClpMain.cpp

    r703 r707  
    127127    parameters[whichParam(SUBSTITUTION,numberParameters,parameters)].setIntValue(substitution);
    128128    parameters[whichParam(DUALIZE,numberParameters,parameters)].setIntValue(dualize);
     129    parameters[whichParam(PRESOLVETOLERANCE,numberParameters,parameters)].setDoubleValue(1.0e-8);
    129130   
    130131    // total number of commands read
     
    280281          double value = CoinReadGetDoubleField(argc,argv,&valid);
    281282          if (!valid) {
    282             parameters[iParam].setDoubleValue(value);
    283283            parameters[iParam].setDoubleParameter(models+iModel,value);
    284284          } else if (valid==1) {
     
    292292          int value = CoinReadGetIntField(argc,argv,&valid);
    293293          if (!valid) {
    294             parameters[iParam].setIntValue(value);
    295294            if (parameters[iParam].type()==PRESOLVEPASS)
    296295              preSolve = value;
     
    311310            else if (parameters[iParam].type()==DUALIZE)
    312311              dualize = value;
    313             else
    314               parameters[iParam].setIntParameter(models+iModel,value);
     312            parameters[iParam].setIntParameter(models+iModel,value);
    315313          } else if (valid==1) {
    316314            abort();
     
    596594                if ((printOptions&1)!=0)
    597595                  pinfo.statistics();
     596                double presolveTolerance =
     597                  parameters[whichParam(PRESOLVETOLERANCE,numberParameters,parameters)].doubleValue();
    598598                model2 =
    599                   pinfo.presolvedModel(models[iModel],1.0e-8,
     599                  pinfo.presolvedModel(models[iModel],presolveTolerance,
    600600                                       true,preSolve);
    601601                if (model2) {
     
    831831                  if ((printOptions&1)!=0)
    832832                    pinfo.statistics();
     833                  double presolveTolerance =
     834                    parameters[whichParam(PRESOLVETOLERANCE,numberParameters,parameters)].doubleValue();
    833835                  model2 =
    834                     pinfo.presolvedModel(models[iModel],1.0e-8,
     836                    pinfo.presolvedModel(models[iModel],presolveTolerance,
    835837                                         true,preSolve,false,false);
    836838                  if (model2) {
     
    10781080                if (preSolve) {
    10791081                  ClpPresolve pinfo;
     1082                  double presolveTolerance =
     1083                    parameters[whichParam(PRESOLVETOLERANCE,numberParameters,parameters)].doubleValue();
    10801084                  model2 =
    1081                     pinfo.presolvedModel(models[iModel],1.0e-8,
     1085                    pinfo.presolvedModel(models[iModel],presolveTolerance,
    10821086                                         false,preSolve);
    10831087                  if (model2) {
  • trunk/include/ClpParameters.hpp

    r142 r707  
    4040  /// Maximum time in seconds - after this action is as max iterations
    4141  ClpMaxSeconds,
     42  /// Tolerance to use in presolve
     43  ClpPresolveTolerance,
    4244  /** Just a marker, so that we can allocate a static sized array to store
    4345      parameters. */
Note: See TracChangeset for help on using the changeset viewer.