Changeset 1474 for branches


Ignore:
Timestamp:
Dec 6, 2009 4:19:23 PM (10 years ago)
Author:
bjarni
Message:

Renamed parameter constants in CbcOrClpParam? and ClpMain? to make them more readable/search-able

Location:
branches/sandbox/Clp/src
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • branches/sandbox/Clp/src/CbcOrClpParam.cpp

    r1463 r1474  
    6060//-------------------------------------------------------------------
    6161CbcOrClpParam::CbcOrClpParam ()
    62   : type_(INVALID),
     62  : type_(CBC_PARAM_NOTUSED_INVALID),
    6363    lowerDoubleValue_(0.0),
    6464    upperDoubleValue_(0.0),
     
    7171    shortHelp_(),
    7272    longHelp_(),
    73     action_(INVALID),
     73    action_(CBC_PARAM_NOTUSED_INVALID),
    7474    currentKeyWord_(-1),
    7575    display_(0),
     
    407407  if (type_>=1&&type_<400) {
    408408    CoinReadPrintit(longHelp_.c_str());
    409     if (type_<SOLVERLOGLEVEL) {
     409    if (type_<CLP_PARAM_INT_SOLVERLOGLEVEL) {
    410410      printf("<Range of values is %g to %g;\n\tcurrent %g>\n",lowerDoubleValue_,upperDoubleValue_, doubleValue_);
    411411      assert (upperDoubleValue_>lowerDoubleValue_);
    412     } else if (type_<DIRECTION) {
     412    } else if (type_<CLP_PARAM_STR_DIRECTION) {
    413413      printf("<Range of values is %d to %d;\n\tcurrent %d>\n",lowerIntValue_,upperIntValue_,intValue_);
    414414      assert (upperIntValue_>lowerIntValue_);
    415     } else if (type_<DIRECTORY) {
     415    } else if (type_<CLP_PARAM_ACTION_DIRECTORY) {
    416416      printOptions();
    417417    }
     
    443443    doubleValue_=value;
    444444    switch(type_) {
    445     case DUALTOLERANCE:
     445    case CLP_PARAM_DBL_DUALTOLERANCE:
    446446      model->getDblParam(OsiDualTolerance,oldValue);
    447447      model->setDblParam(OsiDualTolerance,value);
    448448      break;
    449     case PRIMALTOLERANCE:
     449    case CLP_PARAM_DBL_PRIMALTOLERANCE:
    450450      model->getDblParam(OsiPrimalTolerance,oldValue);
    451451      model->setDblParam(OsiPrimalTolerance,value);
     
    486486    doubleValue_=value;
    487487    switch(type_) {
    488     case DUALTOLERANCE:
     488    case CLP_PARAM_DBL_DUALTOLERANCE:
    489489      model->setDualTolerance(value);
    490490      break;
    491     case PRIMALTOLERANCE:
     491    case CLP_PARAM_DBL_PRIMALTOLERANCE:
    492492      model->setPrimalTolerance(value);
    493493      break;
    494     case DUALBOUND:
     494    case CLP_PARAM_DBL_DUALBOUND:
    495495      model->setDualBound(value);
    496496      break;
    497     case PRIMALWEIGHT:
     497    case CLP_PARAM_DBL_PRIMALWEIGHT:
    498498      model->setInfeasibilityCost(value);
    499499      break;
    500500#ifndef COIN_HAS_CBC
    501     case TIMELIMIT:
     501    case CLP_PARAM_DBL_TIMELIMIT:
    502502      model->setMaximumSeconds(value);
    503503      break;
    504504#endif
    505     case OBJSCALE:
     505    case CLP_PARAM_DBL_OBJSCALE:
    506506      model->setObjectiveScale(value);
    507507      break;
    508     case RHSSCALE:
     508    case CLP_PARAM_DBL_RHSSCALE:
    509509      model->setRhsScale(value);
    510510      break;
    511     case PRESOLVETOLERANCE:
     511    case CLP_PARAM_DBL_PRESOLVETOLERANCE:
    512512      model->setDblParam(ClpPresolveTolerance,value);
    513513      break;
     
    524524  switch(type_) {
    525525#ifndef COIN_HAS_CBC
    526   case DUALTOLERANCE:
     526  case CLP_PARAM_DBL_DUALTOLERANCE:
    527527    value=model->dualTolerance();
    528528    break;
    529   case PRIMALTOLERANCE:
     529  case CLP_PARAM_DBL_PRIMALTOLERANCE:
    530530    value=model->primalTolerance();
    531531    break;
    532532#endif
    533   case DUALBOUND:
     533  case CLP_PARAM_DBL_DUALBOUND:
    534534    value=model->dualBound();
    535535    break;
    536   case PRIMALWEIGHT:
     536  case CLP_PARAM_DBL_PRIMALWEIGHT:
    537537    value=model->infeasibilityCost();
    538538    break;
    539539#ifndef COIN_HAS_CBC
    540   case TIMELIMIT:
     540  case CLP_PARAM_DBL_TIMELIMIT:
    541541    value=model->maximumSeconds();
    542542    break;
    543543#endif
    544   case OBJSCALE:
     544  case CLP_PARAM_DBL_OBJSCALE:
    545545    value=model->objectiveScale();
    546546    break;
    547   case RHSSCALE:
     547  case CLP_PARAM_DBL_RHSSCALE:
    548548    value=model->rhsScale();
    549549    break;
     
    578578    returnCode = 0;
    579579    switch(type_) {
    580     case SOLVERLOGLEVEL:
     580    case CLP_PARAM_INT_SOLVERLOGLEVEL:
    581581      model->setLogLevel(value);
    582582      if (value>2)
     
    585585        model->factorization()->messageLevel(0);
    586586      break;
    587     case MAXFACTOR:
     587    case CLP_PARAM_INT_MAXFACTOR:
    588588      model->factorization()->maximumPivots(value);
    589589      break;
    590     case PERTVALUE:
     590    case CLP_PARAM_INT_PERTVALUE:
    591591      model->setPerturbation(value);
    592592      break;
    593     case MAXITERATION:
     593    case CLP_PARAM_INT_MAXITERATION:
    594594      model->setMaximumIterations(value);
    595595      break;
    596     case SPECIALOPTIONS:
     596    case CLP_PARAM_INT_SPECIALOPTIONS:
    597597      model->setSpecialOptions(value);
    598598#ifndef COIN_HAS_CBC
    599599#ifdef CBC_THREAD
    600     case THREADS:
     600    case CBC_PARAM_INT_THREADS:
    601601      model->setNumberThreads(value);
    602602      break;
     
    615615  switch(type_) {
    616616#ifndef COIN_HAS_CBC
    617   case SOLVERLOGLEVEL:
     617  case CLP_PARAM_INT_SOLVERLOGLEVEL:
    618618    value=model->logLevel();
    619619    break;
    620620#endif
    621   case MAXFACTOR:
     621  case CLP_PARAM_INT_MAXFACTOR:
    622622    value=model->factorization()->maximumPivots();
    623623    break;
    624624    break;
    625   case PERTVALUE:
     625  case CLP_PARAM_INT_PERTVALUE:
    626626    value=model->perturbation();
    627627    break;
    628   case MAXITERATION:
     628  case CLP_PARAM_INT_MAXITERATION:
    629629    value=model->maximumIterations();
    630630    break;
    631   case SPECIALOPTIONS:
     631  case CLP_PARAM_INT_SPECIALOPTIONS:
    632632    value=model->specialOptions();
    633633    break;
    634634#ifndef COIN_HAS_CBC
    635635#ifdef CBC_THREAD
    636   case THREADS:
     636  case CBC_PARAM_INT_THREADS:
    637637    value = model->numberThreads();
    638638#endif
     
    667667  double value=0.0;
    668668  switch(type_) {
    669   case DUALTOLERANCE:
     669  case CLP_PARAM_DBL_DUALTOLERANCE:
    670670    assert(model->getDblParam(OsiDualTolerance,value));
    671671    break;
    672   case PRIMALTOLERANCE:
     672  case CLP_PARAM_DBL_PRIMALTOLERANCE:
    673673    assert(model->getDblParam(OsiPrimalTolerance,value));
    674674    break;
     
    700700    intValue_=oldValue;
    701701    switch(type_) {
    702     case SOLVERLOGLEVEL:
     702    case CLP_PARAM_INT_SOLVERLOGLEVEL:
    703703      model->messageHandler()->setLogLevel(value);
    704704      break;
     
    717717  int value=0;
    718718  switch(type_) {
    719   case SOLVERLOGLEVEL:
     719  case CLP_PARAM_INT_SOLVERLOGLEVEL:
    720720    value=model->messageHandler()->logLevel();
    721721    break;
     
    747747    doubleValue_ = value;
    748748    switch(type_) {
    749     case INFEASIBILITYWEIGHT:
     749    case CBC_PARAM_DBL_INFEASIBILITYWEIGHT:
    750750      oldValue=model.getDblParam(CbcModel::CbcInfeasibilityWeight);
    751751      model.setDblParam(CbcModel::CbcInfeasibilityWeight,value);
    752752      break;
    753     case INTEGERTOLERANCE:
     753    case CBC_PARAM_DBL_INTEGERTOLERANCE:
    754754      oldValue=model.getDblParam(CbcModel::CbcIntegerTolerance);
    755755      model.setDblParam(CbcModel::CbcIntegerTolerance,value);
    756756      break;
    757     case INCREMENT:
     757    case CBC_PARAM_DBL_INCREMENT:
    758758      oldValue=model.getDblParam(CbcModel::CbcCutoffIncrement);
    759759      model.setDblParam(CbcModel::CbcCutoffIncrement,value);
    760     case ALLOWABLEGAP:
     760    case CBC_PARAM_DBL_ALLOWABLEGAP:
    761761      oldValue=model.getDblParam(CbcModel::CbcAllowableGap);
    762762      model.setDblParam(CbcModel::CbcAllowableGap,value);
    763763      break;
    764     case GAPRATIO:
     764    case CBC_PARAM_DBL_GAPRATIO:
    765765      oldValue=model.getDblParam(CbcModel::CbcAllowableFractionGap);
    766766      model.setDblParam(CbcModel::CbcAllowableFractionGap,value);
    767767      break;
    768     case CUTOFF:
     768    case CBC_PARAM_DBL_CUTOFF:
    769769      oldValue=model.getCutoff();
    770770      model.setCutoff(value);
    771771      break;
    772     case TIMELIMIT_BAB:
     772    case CBC_PARAM_DBL_TIMELIMIT_BAB:
    773773      oldValue = model.getDblParam(CbcModel::CbcMaximumSeconds) ;
    774774      {
     
    779779      }
    780780      break ;
    781     case DUALTOLERANCE:
    782     case PRIMALTOLERANCE:
     781    case CLP_PARAM_DBL_DUALTOLERANCE:
     782    case CLP_PARAM_DBL_PRIMALTOLERANCE:
    783783      setDoubleParameter(model.solver(),value);
    784784      return 0; // to avoid message
     
    797797  double value;
    798798  switch(type_) {
    799   case INFEASIBILITYWEIGHT:
     799  case CBC_PARAM_DBL_INFEASIBILITYWEIGHT:
    800800    value=model.getDblParam(CbcModel::CbcInfeasibilityWeight);
    801801    break;
    802   case INTEGERTOLERANCE:
     802  case CBC_PARAM_DBL_INTEGERTOLERANCE:
    803803    value=model.getDblParam(CbcModel::CbcIntegerTolerance);
    804804    break;
    805   case INCREMENT:
     805  case CBC_PARAM_DBL_INCREMENT:
    806806    value=model.getDblParam(CbcModel::CbcCutoffIncrement);
    807807    break;
    808   case ALLOWABLEGAP:
     808  case CBC_PARAM_DBL_ALLOWABLEGAP:
    809809    value=model.getDblParam(CbcModel::CbcAllowableGap);
    810810    break;
    811   case GAPRATIO:
     811  case CBC_PARAM_DBL_GAPRATIO:
    812812    value=model.getDblParam(CbcModel::CbcAllowableFractionGap);
    813813    break;
    814   case CUTOFF:
     814  case CBC_PARAM_DBL_CUTOFF:
    815815    value=model.getCutoff();
    816816    break;
    817   case TIMELIMIT_BAB:
     817  case CBC_PARAM_DBL_TIMELIMIT_BAB:
    818818    value = model.getDblParam(CbcModel::CbcMaximumSeconds) ;
    819819    break ;
    820   case DUALTOLERANCE:
    821   case PRIMALTOLERANCE:
     820  case CLP_PARAM_DBL_DUALTOLERANCE:
     821  case CLP_PARAM_DBL_PRIMALTOLERANCE:
    822822    value=doubleParameter(model.solver());
    823823    break;
     
    849849    intValue_ = value;
    850850    switch(type_) {
    851     case LOGLEVEL:
     851    case CLP_PARAM_INT_LOGLEVEL:
    852852      oldValue = model.messageHandler()->logLevel();
    853853      model.messageHandler()->setLogLevel(CoinAbs(value));
    854854      break;
    855     case SOLVERLOGLEVEL:
     855    case CLP_PARAM_INT_SOLVERLOGLEVEL:
    856856      oldValue = model.solver()->messageHandler()->logLevel();
    857857      model.solver()->messageHandler()->setLogLevel(value);
    858858      break;
    859     case MAXNODES:
     859    case CBC_PARAM_INT_MAXNODES:
    860860      oldValue=model.getIntParam(CbcModel::CbcMaxNumNode);
    861861      model.setIntParam(CbcModel::CbcMaxNumNode,value);
    862862      break;
    863     case MAXSOLS:
     863    case CBC_PARAM_INT_MAXSOLS:
    864864      oldValue=model.getIntParam(CbcModel::CbcMaxNumSol);
    865865      model.setIntParam(CbcModel::CbcMaxNumSol,value);
    866866      break;
    867     case STRONGBRANCHING:
     867    case CBC_PARAM_INT_STRONGBRANCHING:
    868868      oldValue=model.numberStrong();
    869869      model.setNumberStrong(value);
    870870      break;
    871     case NUMBERBEFORE:
     871    case CBC_PARAM_INT_NUMBERBEFORE:
    872872      oldValue=model.numberBeforeTrust();
    873873      model.setNumberBeforeTrust(value);
    874874      break;
    875     case NUMBERANALYZE:
     875    case CBC_PARAM_INT_NUMBERANALYZE:
    876876      oldValue=model.numberAnalyzeIterations();
    877877      model.setNumberAnalyzeIterations(value);
    878878      break;
    879     case CUTPASSINTREE:
     879    case CBC_PARAM_INT_CUTPASSINTREE:
    880880      oldValue=model.getMaximumCutPasses();
    881881      model.setMaximumCutPasses(value);
    882882      break;
    883     case CUTPASS:
     883    case CBC_PARAM_INT_CUTPASS:
    884884      oldValue=model.getMaximumCutPassesAtRoot();
    885885      model.setMaximumCutPassesAtRoot(value);
     
    887887#ifdef COIN_HAS_CBC
    888888#ifdef CBC_THREAD
    889     case THREADS:
     889    case CBC_PARAM_INT_THREADS:
    890890      oldValue=model.getNumberThreads();
    891891      model.setNumberThreads(value);
     
    907907  int value;
    908908  switch(type_) {
    909   case LOGLEVEL:
     909  case CLP_PARAM_INT_LOGLEVEL:
    910910    value = model.messageHandler()->logLevel();
    911911      break;
    912   case SOLVERLOGLEVEL:
     912  case CLP_PARAM_INT_SOLVERLOGLEVEL:
    913913    value = model.solver()->messageHandler()->logLevel();
    914914      break;
    915   case MAXNODES:
     915  case CBC_PARAM_INT_MAXNODES:
    916916    value = model.getIntParam(CbcModel::CbcMaxNumNode);
    917917    break;
    918   case MAXSOLS:
     918  case CBC_PARAM_INT_MAXSOLS:
    919919    value = model.getIntParam(CbcModel::CbcMaxNumSol);
    920920    break;
    921   case STRONGBRANCHING:
     921  case CBC_PARAM_INT_STRONGBRANCHING:
    922922    value=model.numberStrong();
    923923    break;
    924   case NUMBERBEFORE:
     924  case CBC_PARAM_INT_NUMBERBEFORE:
    925925    value=model.numberBeforeTrust();
    926926    break;
    927   case NUMBERANALYZE:
     927  case CBC_PARAM_INT_NUMBERANALYZE:
    928928    value=model.numberAnalyzeIterations();
    929929    break;
    930   case CUTPASSINTREE:
     930  case CBC_PARAM_INT_CUTPASSINTREE:
    931931    value=model.getMaximumCutPasses();
    932932    break;
    933   case CUTPASS:
     933  case CBC_PARAM_INT_CUTPASS:
    934934    value=model.getMaximumCutPassesAtRoot();
    935935    break;
    936936#ifdef COIN_HAS_CBC
    937937#ifdef CBC_THREAD
    938   case THREADS:
     938  case CBC_PARAM_INT_THREADS:
    939939    value = model.getNumberThreads();
    940940#endif
     
    12951295  numberParameters=0;
    12961296  parameters[numberParameters++]=
    1297     CbcOrClpParam("?","For help",GENERALQUERY,7,0);
    1298   parameters[numberParameters++]=
    1299     CbcOrClpParam("???","For help",FULLGENERALQUERY,7,0);
     1297    CbcOrClpParam("?","For help",CBC_PARAM_GENERALQUERY,7,0);
     1298  parameters[numberParameters++]=
     1299    CbcOrClpParam("???","For help",CBC_PARAM_FULLGENERALQUERY,7,0);
    13001300  parameters[numberParameters++]=
    13011301    CbcOrClpParam("-","From stdin",
    1302                   STDIN,3,0);
     1302                  CLP_PARAM_ACTION_STDIN,3,0);
    13031303  parameters[numberParameters++]=
    13041304    CbcOrClpParam("allC!ommands","Whether to print less used commands",
    1305                   "no",ALLCOMMANDS);
     1305                  "no",CLP_PARAM_STR_ALLCOMMANDS);
    13061306  parameters[numberParameters-1].append("more");
    13071307  parameters[numberParameters-1].append("all");
     
    13151315      CbcOrClpParam("allow!ableGap","Stop when gap between best possible and \
    13161316best less than this",
    1317               0.0,1.0e20,ALLOWABLEGAP);
     1317              0.0,1.0e20,CBC_PARAM_DBL_ALLOWABLEGAP);
    13181318  parameters[numberParameters-1].setDoubleValue(0.0);
    13191319  parameters[numberParameters-1].setLonghelp
     
    13261326  parameters[numberParameters++]=
    13271327    CbcOrClpParam("allS!lack","Set basis back to all slack and reset solution",
    1328                   ALLSLACK,3);
     1328                  CLP_PARAM_ACTION_ALLSLACK,3);
    13291329  parameters[numberParameters-1].setLonghelp
    13301330    (
     
    13361336  parameters[numberParameters++]=
    13371337    CbcOrClpParam("artif!icialCost","Costs >= this treated as artificials in feasibility pump",
    1338                   0.0,COIN_DBL_MAX,ARTIFICIALCOST,1);
     1338                  0.0,COIN_DBL_MAX,CBC_PARAM_DBL_ARTIFICIALCOST,1);
    13391339  parameters[numberParameters-1].setDoubleValue(0.0);
    13401340    parameters[numberParameters-1].setLonghelp
     
    13461346  parameters[numberParameters++]=
    13471347    CbcOrClpParam("auto!Scale","Whether to scale objective, rhs and bounds of problem if they look odd",
    1348                   "off",AUTOSCALE,7,0);
     1348                  "off",CLP_PARAM_STR_AUTOSCALE,7,0);
    13491349  parameters[numberParameters-1].append("on");
    13501350  parameters[numberParameters-1].setLonghelp
     
    13561356  parameters[numberParameters++]=
    13571357    CbcOrClpParam("barr!ier","Solve using primal dual predictor corrector algorithm",
    1358                   BARRIER);
     1358                  CLP_PARAM_ACTION_BARRIER);
    13591359  parameters[numberParameters-1].setLonghelp
    13601360    (
     
    13671367  parameters[numberParameters++]=
    13681368    CbcOrClpParam("basisI!n","Import basis from bas file",
    1369                   BASISIN,3);
     1369                  CLP_PARAM_ACTION_BASISIN,3);
    13701370  parameters[numberParameters-1].setLonghelp
    13711371    (
     
    13771377  parameters[numberParameters++]=
    13781378    CbcOrClpParam("basisO!ut","Export basis as bas file",
    1379                   BASISOUT);
     1379                  CLP_PARAM_ACTION_BASISOUT);
    13801380  parameters[numberParameters-1].setLonghelp
    13811381    (
     
    13861386  parameters[numberParameters++]=
    13871387    CbcOrClpParam("biasLU","Whether factorization biased towards U",
    1388                   "UU",BIASLU,2,0);
     1388                  "UU",CLP_PARAM_STR_BIASLU,2,0);
    13891389  parameters[numberParameters-1].append("UX");
    13901390  parameters[numberParameters-1].append("LX");
     
    13951395  parameters[numberParameters++]=
    13961396    CbcOrClpParam("branch!AndCut","Do Branch and Cut",
    1397                   BAB);
     1397                  CBC_PARAM_ACTION_BAB);
    13981398  parameters[numberParameters-1].setLonghelp
    13991399    (
     
    14171417  parameters[numberParameters++]=
    14181418    CbcOrClpParam("bscale","Whether to scale in barrier (and ordering speed)",
    1419                   "off",BARRIERSCALE,7,0);
     1419                  "off",CLP_PARAM_STR_BARRIERSCALE,7,0);
    14201420  parameters[numberParameters-1].append("on");
    14211421  parameters[numberParameters-1].append("off1");
     
    14251425  parameters[numberParameters++]=
    14261426    CbcOrClpParam("chol!esky","Which cholesky algorithm",
    1427                   "native",CHOLESKY,7);
     1427                  "native",CLP_PARAM_STR_CHOLESKY,7);
    14281428  parameters[numberParameters-1].append("dense");
    14291429  //#ifdef FOREIGN_BARRIER
     
    14611461  parameters[numberParameters++]=
    14621462    CbcOrClpParam("clique!Cuts","Whether to use Clique cuts",
    1463                   "off",CLIQUECUTS);
     1463                  "off",CBC_PARAM_STR_CLIQUECUTS);
    14641464  parameters[numberParameters-1].append("on");
    14651465  parameters[numberParameters-1].append("root");
     
    14741474  parameters[numberParameters++]=
    14751475    CbcOrClpParam("combine!Solutions","Whether to use combine solution heuristic",
    1476                   "off",COMBINE);
     1476                  "off",CBC_PARAM_STR_COMBINE);
    14771477  parameters[numberParameters-1].append("on");
    14781478  parameters[numberParameters-1].append("both");
     
    14871487  parameters[numberParameters++]=
    14881488    CbcOrClpParam("combine2!Solutions","Whether to use crossover solution heuristic",
    1489                   "off",CROSSOVER2);
     1489                  "off",CBC_PARAM_STR_CROSSOVER2);
    14901490  parameters[numberParameters-1].append("on");
    14911491  parameters[numberParameters-1].append("both");
     
    15001500  parameters[numberParameters++]=
    15011501    CbcOrClpParam("cost!Strategy","How to use costs as priorities",
    1502                   "off",COSTSTRATEGY);
     1502                  "off",CBC_PARAM_STR_COSTSTRATEGY);
    15031503  parameters[numberParameters-1].append("pri!orities");
    15041504  parameters[numberParameters-1].append("column!Order?");
     
    15141514  parameters[numberParameters++]=
    15151515    CbcOrClpParam("cplex!Use","Whether to use Cplex!",
    1516                   "off",CPX);
     1516                  "off",CBC_PARAM_STR_CPX);
    15171517  parameters[numberParameters-1].append("on");
    15181518  parameters[numberParameters-1].setLonghelp
     
    15291529  parameters[numberParameters++]=
    15301530    CbcOrClpParam("cpp!Generate","Generates C++ code",
    1531                   -1,50000,CPP,1);
     1531                  -1,50000,CLP_PARAM_INT_CPP,1);
    15321532  parameters[numberParameters-1].setLonghelp
    15331533    (
     
    15431543  parameters[numberParameters++]=
    15441544    CbcOrClpParam("crash","Whether to create basis for problem",
    1545                   "off",CRASH);
     1545                  "off",CLP_PARAM_STR_CRASH);
    15461546  parameters[numberParameters-1].append("on");
    15471547  parameters[numberParameters-1].append("so!low_halim");
     
    15571557  parameters[numberParameters++]=
    15581558    CbcOrClpParam("cross!over","Whether to get a basic solution after barrier",
    1559                   "on",CROSSOVER);
     1559                  "on",CLP_PARAM_STR_CROSSOVER);
    15601560  parameters[numberParameters-1].append("off");
    15611561  parameters[numberParameters-1].append("maybe");
     
    15731573  parameters[numberParameters++]=
    15741574    CbcOrClpParam("csv!Statistics","Create one line of statistics",
    1575                   CSVSTATISTICS,2,1);
     1575                  CLP_PARAM_ACTION_CSVSTATISTICS,2,1);
    15761576  parameters[numberParameters-1].setLonghelp
    15771577    (
     
    15821582  parameters[numberParameters++]=
    15831583    CbcOrClpParam("cutD!epth","Depth in tree at which to do cuts",
    1584                   -1,999999,CUTDEPTH);
     1584                  -1,999999,CBC_PARAM_INT_CUTDEPTH);
    15851585  parameters[numberParameters-1].setLonghelp
    15861586    (
     
    15941594  parameters[numberParameters++]=
    15951595    CbcOrClpParam("cutL!ength","Length of a cut",
    1596                   -1,COIN_INT_MAX,CUTLENGTH);
     1596                  -1,COIN_INT_MAX,CBC_PARAM_INT_CUTLENGTH);
    15971597  parameters[numberParameters-1].setLonghelp
    15981598    (
     
    16061606  parameters[numberParameters++]=
    16071607    CbcOrClpParam("cuto!ff","All solutions must be better than this",
    1608                   -1.0e60,1.0e60,CUTOFF);
     1608                  -1.0e60,1.0e60,CBC_PARAM_DBL_CUTOFF);
    16091609  parameters[numberParameters-1].setDoubleValue(1.0e50);
    16101610  parameters[numberParameters-1].setLonghelp
     
    16161616  parameters[numberParameters++]=
    16171617    CbcOrClpParam("cuts!OnOff","Switches all cuts on or off",
    1618                   "off",CUTSSTRATEGY);
     1618                  "off",CBC_PARAM_STR_CUTSSTRATEGY);
    16191619  parameters[numberParameters-1].append("on");
    16201620  parameters[numberParameters-1].append("root");
     
    16291629  parameters[numberParameters++]=
    16301630    CbcOrClpParam("debug!In","read valid solution from file",
    1631                   DEBUG,7,1);
     1631                  CLP_PARAM_ACTION_DEBUG,7,1);
    16321632  parameters[numberParameters-1].setLonghelp
    16331633    (
     
    16451645  parameters[numberParameters++]=
    16461646    CbcOrClpParam("dense!Threshold","Whether to use dense factorization",
    1647                   -1,10000,DENSE,1);
     1647                  -1,10000,CBC_PARAM_INT_DENSE,1);
    16481648  parameters[numberParameters-1].setLonghelp
    16491649    (
     
    16561656  parameters[numberParameters++]=
    16571657    CbcOrClpParam("depth!MiniBab","Depth at which to try mini BAB",
    1658                   -COIN_INT_MAX,COIN_INT_MAX,DEPTHMINIBAB);
     1658                  -COIN_INT_MAX,COIN_INT_MAX,CBC_PARAM_INT_DEPTHMINIBAB);
    16591659  parameters[numberParameters-1].setIntValue(-1);
    16601660  parameters[numberParameters-1].setLonghelp
     
    16651665  parameters[numberParameters++]=
    16661666    CbcOrClpParam("dextra3","Extra double parameter 3",
    1667                   -COIN_DBL_MAX,COIN_DBL_MAX,DEXTRA3,0);
     1667                  -COIN_DBL_MAX,COIN_DBL_MAX,CBC_PARAM_DBL_DEXTRA3,0);
    16681668  parameters[numberParameters-1].setDoubleValue(0.0);
    16691669  parameters[numberParameters++]=
    16701670    CbcOrClpParam("dextra4","Extra double parameter 4",
    1671                   -COIN_DBL_MAX,COIN_DBL_MAX,DEXTRA4,0);
     1671                  -COIN_DBL_MAX,COIN_DBL_MAX,CBC_PARAM_DBL_DEXTRA4,0);
    16721672  parameters[numberParameters-1].setDoubleValue(0.0);
    16731673  parameters[numberParameters++]=
    16741674    CbcOrClpParam("dextra5","Extra double parameter 5",
    1675                   -COIN_DBL_MAX,COIN_DBL_MAX,DEXTRA5,0);
     1675                  -COIN_DBL_MAX,COIN_DBL_MAX,CBC_PARAM_DBL_DEXTRA5,0);
    16761676  parameters[numberParameters-1].setDoubleValue(0.0);
    16771677  parameters[numberParameters++]=
    16781678      CbcOrClpParam("Dins","Whether to try Distance Induced Neighborhood Search",
    1679                     "off",DINS);
     1679                    "off",CBC_PARAM_STR_DINS);
    16801680  parameters[numberParameters-1].append("on");
    16811681  parameters[numberParameters-1].append("both");
     
    16901690  parameters[numberParameters++]=
    16911691    CbcOrClpParam("direction","Minimize or Maximize",
    1692                   "min!imize",DIRECTION);
     1692                  "min!imize",CLP_PARAM_STR_DIRECTION);
    16931693  parameters[numberParameters-1].append("max!imize");
    16941694  parameters[numberParameters-1].append("zero");
     
    17001700  parameters[numberParameters++]=
    17011701    CbcOrClpParam("directory","Set Default directory for import etc.",
    1702                   DIRECTORY);
     1702                  CLP_PARAM_ACTION_DIRECTORY);
    17031703  parameters[numberParameters-1].setLonghelp
    17041704    (
     
    17081708  parameters[numberParameters++]=
    17091709    CbcOrClpParam("dirSample","Set directory where the COIN-OR sample problems are.",
    1710                   DIRSAMPLE,7,1);
     1710                  CLP_PARAM_ACTION_DIRSAMPLE,7,1);
    17111711  parameters[numberParameters-1].setLonghelp
    17121712    (
     
    17181718  parameters[numberParameters++]=
    17191719    CbcOrClpParam("dirNetlib","Set directory where the netlib problems are.",
    1720                   DIRNETLIB,7,1);
     1720                  CLP_PARAM_ACTION_DIRNETLIB,7,1);
    17211721  parameters[numberParameters-1].setLonghelp
    17221722    (
     
    17301730  parameters[numberParameters++]=
    17311731    CbcOrClpParam("dirMiplib","Set directory where the miplib 2003 problems are.",
    1732                   DIRMIPLIB,7,1);
     1732                  CBC_PARAM_ACTION_DIRMIPLIB,7,1);
    17331733  parameters[numberParameters-1].setLonghelp
    17341734    (
     
    17431743  parameters[numberParameters++]=
    17441744    CbcOrClpParam("diveO!pt","Diving options",
    1745                   -1,200000,DIVEOPT,1);
     1745                  -1,200000,CBC_PARAM_INT_DIVEOPT,1);
    17461746  parameters[numberParameters-1].setLonghelp
    17471747    (
     
    17561756  parameters[numberParameters++]=
    17571757      CbcOrClpParam("DivingS!ome","Whether to try Diving heuristics",
    1758                     "off",DIVINGS);
     1758                    "off",CBC_PARAM_STR_DIVINGS);
    17591759  parameters[numberParameters-1].append("on");
    17601760  parameters[numberParameters-1].append("both");
     
    17691769  parameters[numberParameters++]=
    17701770      CbcOrClpParam("DivingC!oefficient","Whether to try DiveCoefficient",
    1771                     "off",DIVINGC);
     1771                    "off",CBC_PARAM_STR_DIVINGC);
    17721772  parameters[numberParameters-1].append("on");
    17731773  parameters[numberParameters-1].append("both");
     
    17751775  parameters[numberParameters++]=
    17761776      CbcOrClpParam("DivingF!ractional","Whether to try DiveFractional",
    1777                     "off",DIVINGF);
     1777                    "off",CBC_PARAM_STR_DIVINGF);
    17781778  parameters[numberParameters-1].append("on");
    17791779  parameters[numberParameters-1].append("both");
     
    17811781  parameters[numberParameters++]=
    17821782      CbcOrClpParam("DivingG!uided","Whether to try DiveGuided",
    1783                     "off",DIVINGG);
     1783                    "off",CBC_PARAM_STR_DIVINGG);
    17841784  parameters[numberParameters-1].append("on");
    17851785  parameters[numberParameters-1].append("both");
     
    17871787  parameters[numberParameters++]=
    17881788      CbcOrClpParam("DivingL!ineSearch","Whether to try DiveLineSearch",
    1789                     "off",DIVINGL);
     1789                    "off",CBC_PARAM_STR_DIVINGL);
    17901790  parameters[numberParameters-1].append("on");
    17911791  parameters[numberParameters-1].append("both");
     
    17931793  parameters[numberParameters++]=
    17941794      CbcOrClpParam("DivingP!seudoCost","Whether to try DivePseudoCost",
    1795                     "off",DIVINGP);
     1795                    "off",CBC_PARAM_STR_DIVINGP);
    17961796  parameters[numberParameters-1].append("on");
    17971797  parameters[numberParameters-1].append("both");
     
    17991799  parameters[numberParameters++]=
    18001800      CbcOrClpParam("DivingV!ectorLength","Whether to try DiveVectorLength",
    1801                     "off",DIVINGV);
     1801                    "off",CBC_PARAM_STR_DIVINGV);
    18021802  parameters[numberParameters-1].append("on");
    18031803  parameters[numberParameters-1].append("both");
     
    18051805  parameters[numberParameters++]=
    18061806    CbcOrClpParam("doH!euristic","Do heuristics before any preprocessing",
    1807                   DOHEURISTIC,3);
     1807                  CBC_PARAM_ACTION_DOHEURISTIC,3);
    18081808  parameters[numberParameters-1].setLonghelp
    18091809    (
     
    18171817    CbcOrClpParam("dualB!ound","Initially algorithm acts as if no \
    18181818gap between bounds exceeds this value",
    1819                   1.0e-20,1.0e12,DUALBOUND);
     1819                  1.0e-20,1.0e12,CLP_PARAM_DBL_DUALBOUND);
    18201820  parameters[numberParameters-1].setLonghelp
    18211821    (
     
    18321832  parameters[numberParameters++]=
    18331833    CbcOrClpParam("dualize","Solves dual reformulation",
    1834                   0,3,DUALIZE,1);
     1834                  0,3,CLP_PARAM_INT_DUALIZE,1);
    18351835  parameters[numberParameters-1].setLonghelp
    18361836    (
     
    18391839  parameters[numberParameters++]=
    18401840    CbcOrClpParam("dualP!ivot","Dual pivot choice algorithm",
    1841                   "auto!matic",DUALPIVOT,7,1);
     1841                  "auto!matic",CLP_PARAM_STR_DUALPIVOT,7,1);
    18421842  parameters[numberParameters-1].append("dant!zig");
    18431843  parameters[numberParameters-1].append("partial");
     
    18541854  parameters[numberParameters++]=
    18551855    CbcOrClpParam("dualS!implex","Do dual simplex algorithm",
    1856                   DUALSIMPLEX);
     1856                  CLP_PARAM_ACTION_DUALSIMPLEX);
    18571857  parameters[numberParameters-1].setLonghelp
    18581858    (
     
    18651865    CbcOrClpParam("dualT!olerance","For an optimal solution \
    18661866no dual infeasibility may exceed this value",
    1867                   1.0e-20,1.0e12,DUALTOLERANCE);
     1867                  1.0e-20,1.0e12,CLP_PARAM_DBL_DUALTOLERANCE);
    18681868  parameters[numberParameters-1].setLonghelp
    18691869    (
     
    18761876  parameters[numberParameters++]=
    18771877    CbcOrClpParam("either!Simplex","Do dual or primal simplex algorithm",
    1878                   EITHERSIMPLEX);
     1878                  CLP_PARAM_ACTION_EITHERSIMPLEX);
    18791879  parameters[numberParameters-1].setLonghelp
    18801880    (
     
    18851885  parameters[numberParameters++]=
    18861886    CbcOrClpParam("end","Stops clp execution",
    1887                   EXIT);
     1887                  CLP_PARAM_ACTION_EXIT);
    18881888  parameters[numberParameters-1].setLonghelp
    18891889    (
     
    18921892  parameters[numberParameters++]=
    18931893    CbcOrClpParam("environ!ment","Read commands from environment",
    1894                   ENVIRONMENT,7,0);
     1894                  CLP_PARAM_ACTION_ENVIRONMENT,7,0);
    18951895  parameters[numberParameters-1].setLonghelp
    18961896    (
     
    18991899  parameters[numberParameters++]=
    19001900    CbcOrClpParam("error!sAllowed","Whether to allow import errors",
    1901                   "off",ERRORSALLOWED,3);
     1901                  "off",CLP_PARAM_STR_ERRORSALLOWED,3);
    19021902  parameters[numberParameters-1].append("on");
    19031903  parameters[numberParameters-1].setLonghelp
     
    19101910  parameters[numberParameters++]=
    19111911    CbcOrClpParam("exit","Stops clp execution",
    1912                   EXIT);
     1912                  CLP_PARAM_ACTION_EXIT);
    19131913  parameters[numberParameters-1].setLonghelp
    19141914    (
     
    19181918  parameters[numberParameters++]=
    19191919    CbcOrClpParam("exp!eriment","Whether to use testing features",
    1920                   -1,200,EXPERIMENT,0);
     1920                  -1,200,CBC_PARAM_INT_EXPERIMENT,0);
    19211921  parameters[numberParameters-1].setLonghelp
    19221922    (
     
    19281928  parameters[numberParameters++]=
    19291929    CbcOrClpParam("export","Export model as mps file",
    1930                   EXPORT);
     1930                  CLP_PARAM_ACTION_EXPORT);
    19311931  parameters[numberParameters-1].setLonghelp
    19321932    (
     
    19391939  parameters[numberParameters++]=
    19401940    CbcOrClpParam("extra1","Extra integer parameter 1",
    1941                   -COIN_INT_MAX,COIN_INT_MAX,EXTRA1,0);
     1941                  -COIN_INT_MAX,COIN_INT_MAX,CBC_PARAM_INT_EXTRA1,0);
    19421942  parameters[numberParameters-1].setIntValue(-1);
    19431943  parameters[numberParameters++]=
    19441944    CbcOrClpParam("extra2","Extra integer parameter 2",
    1945                   -100,COIN_INT_MAX,EXTRA2,0);
     1945                  -100,COIN_INT_MAX,CBC_PARAM_INT_EXTRA2,0);
    19461946  parameters[numberParameters-1].setIntValue(-1);
    19471947  parameters[numberParameters++]=
    19481948    CbcOrClpParam("extra3","Extra integer parameter 3",
    1949                   -1,COIN_INT_MAX,EXTRA3,0);
     1949                  -1,COIN_INT_MAX,CBC_PARAM_INT_EXTRA3,0);
    19501950  parameters[numberParameters-1].setIntValue(-1);
    19511951  parameters[numberParameters++]=
    19521952    CbcOrClpParam("extra4","Extra integer parameter 4",
    1953                   -1,COIN_INT_MAX,EXTRA4,0);
     1953                  -1,COIN_INT_MAX,CBC_PARAM_INT_EXTRA4,0);
    19541954  parameters[numberParameters-1].setIntValue(-1);
    19551955  parameters[numberParameters-1].setLonghelp
     
    19681968  parameters[numberParameters++]=
    19691969    CbcOrClpParam("fact!orization","Which factorization to use",
    1970                   "normal",FACTORIZATION);
     1970                  "normal",CLP_PARAM_STR_FACTORIZATION);
    19711971  parameters[numberParameters-1].append("dense");
    19721972  parameters[numberParameters-1].append("simple");
     
    19791979  parameters[numberParameters++]=
    19801980    CbcOrClpParam("fakeB!ound","All bounds <= this value - DEBUG",
    1981                   1.0,1.0e15,FAKEBOUND,0);
     1981                  1.0,1.0e15,CLP_PARAM_ACTION_FAKEBOUND,0);
    19821982#ifdef COIN_HAS_CBC
    19831983  parameters[numberParameters++]=
    19841984    CbcOrClpParam("feas!ibilityPump","Whether to try Feasibility Pump",
    1985                   "off",FPUMP);
     1985                  "off",CBC_PARAM_STR_FPUMP);
    19861986  parameters[numberParameters-1].append("on");
    19871987  parameters[numberParameters-1].append("both");
     
    19971997    CbcOrClpParam("fix!OnDj","Try heuristic based on fixing variables with \
    19981998reduced costs greater than this",
    1999                   -1.0e20,1.0e20,DJFIX,1);
     1999                  -1.0e20,1.0e20,CBC_PARAM_DBL_DJFIX,1);
    20002000  parameters[numberParameters-1].setLonghelp
    20012001    (
     
    20052005    parameters[numberParameters++]=
    20062006      CbcOrClpParam("flow!CoverCuts","Whether to use Flow Cover cuts",
    2007                     "off",FLOWCUTS);
     2007                    "off",CBC_PARAM_STR_FLOWCUTS);
    20082008    parameters[numberParameters-1].append("on");
    20092009    parameters[numberParameters-1].append("root");
     
    20182018    parameters[numberParameters++]=
    20192019      CbcOrClpParam("force!Solution","Whether to use given solution as crash for BAB",
    2020                     -1,20000000,USESOLUTION);
     2020                    -1,20000000,CLP_PARAM_INT_USESOLUTION);
    20212021    parameters[numberParameters-1].setIntValue(-1);
    20222022    parameters[numberParameters-1].setLonghelp
     
    20282028  parameters[numberParameters++]=
    20292029    CbcOrClpParam("fraction!forBAB","Fraction in feasibility pump",
    2030                   1.0e-5,1.1,SMALLBAB,1);
     2030                  1.0e-5,1.1,CBC_PARAM_DBL_SMALLBAB,1);
    20312031  parameters[numberParameters-1].setDoubleValue(0.5);
    20322032  parameters[numberParameters-1].setLonghelp
     
    20392039  parameters[numberParameters++]=
    20402040    CbcOrClpParam("gamma!(Delta)","Whether to regularize barrier",
    2041                   "off",GAMMA,7,1);
     2041                  "off",CLP_PARAM_STR_GAMMA,7,1);
    20422042  parameters[numberParameters-1].append("on");
    20432043  parameters[numberParameters-1].append("gamma");
     
    20502050  parameters[numberParameters++]=
    20512051    CbcOrClpParam("gomory!Cuts","Whether to use Gomory cuts",
    2052                   "off",GOMORYCUTS);
     2052                  "off",CBC_PARAM_STR_GOMORYCUTS);
    20532053  parameters[numberParameters-1].append("on");
    20542054  parameters[numberParameters-1].append("root");
     
    20692069  parameters[numberParameters++]=
    20702070    CbcOrClpParam("greedy!Heuristic","Whether to use a greedy heuristic",
    2071                   "off",GREEDY);
     2071                  "off",CBC_PARAM_STR_GREEDY);
    20722072  parameters[numberParameters-1].append("on");
    20732073  parameters[numberParameters-1].append("both");
     
    20822082  parameters[numberParameters++]=
    20832083    CbcOrClpParam("heur!isticsOnOff","Switches most heuristics on or off",
    2084                   "off",HEURISTICSTRATEGY);
     2084                  "off",CBC_PARAM_STR_HEURISTICSTRATEGY);
    20852085  parameters[numberParameters-1].append("on");
    20862086  parameters[numberParameters-1].setLonghelp
     
    20932093  parameters[numberParameters++]=
    20942094    CbcOrClpParam("help","Print out version, non-standard options and some help",
    2095                   HELP,3);
     2095                  CLP_PARAM_ACTION_HELP,3);
    20962096  parameters[numberParameters-1].setLonghelp
    20972097    (
     
    21022102  parameters[numberParameters++]=
    21032103    CbcOrClpParam("hOp!tions","Heuristic options",
    2104                   -9999999,9999999,HOPTIONS,1);
     2104                  -9999999,9999999,CBC_PARAM_INT_HOPTIONS,1);
    21052105  parameters[numberParameters-1].setLonghelp
    21062106    (
     
    21142114  parameters[numberParameters++]=
    21152115    CbcOrClpParam("hot!StartMaxIts","Maximum iterations on hot start",
    2116                   0,COIN_INT_MAX,MAXHOTITS);
     2116                  0,COIN_INT_MAX,CBC_PARAM_INT_MAXHOTITS);
    21172117#endif
    21182118#ifdef COIN_HAS_CLP
    21192119  parameters[numberParameters++]=
    21202120    CbcOrClpParam("idiot!Crash","Whether to try idiot crash",
    2121                   -1,99999999,IDIOT);
     2121                  -1,99999999,CLP_PARAM_INT_IDIOT);
    21222122  parameters[numberParameters-1].setLonghelp
    21232123    (
     
    21302130  parameters[numberParameters++]=
    21312131    CbcOrClpParam("import","Import model from mps file",
    2132                   IMPORT,3);
     2132                  CLP_PARAM_ACTION_IMPORT,3);
    21332133  parameters[numberParameters-1].setLonghelp
    21342134    (
     
    21432143    CbcOrClpParam("inc!rement","A valid solution must be at least this \
    21442144much better than last integer solution",
    2145                   -1.0e20,1.0e20,INCREMENT);
     2145                  -1.0e20,1.0e20,CBC_PARAM_DBL_INCREMENT);
    21462146  parameters[numberParameters-1].setLonghelp
    21472147    (
     
    21542154    CbcOrClpParam("inf!easibilityWeight","Each integer infeasibility is expected \
    21552155to cost this much",
    2156                   0.0,1.0e20,INFEASIBILITYWEIGHT,1);
     2156                  0.0,1.0e20,CBC_PARAM_DBL_INFEASIBILITYWEIGHT,1);
    21572157  parameters[numberParameters-1].setLonghelp
    21582158    (
     
    21622162  parameters[numberParameters++]=
    21632163    CbcOrClpParam("initialS!olve","Solve to continuous",
    2164                   SOLVECONTINUOUS);
     2164                  CLP_PARAM_ACTION_SOLVECONTINUOUS);
    21652165  parameters[numberParameters-1].setLonghelp
    21662166    (
     
    21702170    CbcOrClpParam("integerT!olerance","For an optimal solution \
    21712171no integer variable may be this away from an integer value",
    2172               1.0e-20,0.5,INTEGERTOLERANCE);
     2172              1.0e-20,0.5,CBC_PARAM_DBL_INTEGERTOLERANCE);
    21732173  parameters[numberParameters-1].setLonghelp
    21742174    (
     
    21792179  parameters[numberParameters++]=
    21802180    CbcOrClpParam("keepN!ames","Whether to keep names from import",
    2181                   "on",KEEPNAMES);
     2181                  "on",CLP_PARAM_STR_KEEPNAMES);
    21822182  parameters[numberParameters-1].append("off");
    21832183  parameters[numberParameters-1].setLonghelp
     
    21882188  parameters[numberParameters++]=
    21892189    CbcOrClpParam("KKT","Whether to use KKT factorization",
    2190                   "off",KKT,7,1);
     2190                  "off",CLP_PARAM_STR_KKT,7,1);
    21912191  parameters[numberParameters-1].append("on");
    21922192#endif
     
    21942194  parameters[numberParameters++]=
    21952195    CbcOrClpParam("knapsack!Cuts","Whether to use Knapsack cuts",
    2196                   "off",KNAPSACKCUTS);
     2196                  "off",CBC_PARAM_STR_KNAPSACKCUTS);
    21972197  parameters[numberParameters-1].append("on");
    21982198  parameters[numberParameters-1].append("root");
     
    22082208  parameters[numberParameters++]=
    22092209    CbcOrClpParam("lift!AndProjectCuts","Whether to use Lift and Project cuts",
    2210                   "off",LANDPCUTS);
     2210                  "off",CBC_PARAM_STR_LANDPCUTS);
    22112211  parameters[numberParameters-1].append("on");
    22122212  parameters[numberParameters-1].append("root");
     
    22202220  parameters[numberParameters++]=
    22212221    CbcOrClpParam("local!TreeSearch","Whether to use local treesearch",
    2222                   "off",LOCALTREE);
     2222                  "off",CBC_PARAM_STR_LOCALTREE);
    22232223  parameters[numberParameters-1].append("on");
    22242224  parameters[numberParameters-1].setLonghelp
     
    22332233  parameters[numberParameters++]=
    22342234    CbcOrClpParam("log!Level","Level of detail in Solver output",
    2235                   -1,63,SOLVERLOGLEVEL);
     2235                  -1,63,CLP_PARAM_INT_SOLVERLOGLEVEL);
    22362236#else
    22372237  parameters[numberParameters++]=
    22382238    CbcOrClpParam("log!Level","Level of detail in Coin branch and Cut output",
    2239                   -63,63,LOGLEVEL);
     2239                  -63,63,CLP_PARAM_INT_LOGLEVEL);
    22402240  parameters[numberParameters-1].setIntValue(1);
    22412241#endif
     
    22472247  parameters[numberParameters++]=
    22482248    CbcOrClpParam("max!imize","Set optimization direction to maximize",
    2249                   MAXIMIZE,7);
     2249                  CLP_PARAM_ACTION_MAXIMIZE,7);
    22502250  parameters[numberParameters-1].setLonghelp
    22512251    (
     
    22572257    CbcOrClpParam("maxF!actor","Maximum number of iterations between \
    22582258refactorizations",
    2259                   1,999999,MAXFACTOR);
     2259                  1,999999,CLP_PARAM_INT_MAXFACTOR);
    22602260  parameters[numberParameters-1].setLonghelp
    22612261    (
     
    22672267    CbcOrClpParam("maxIt!erations","Maximum number of iterations before \
    22682268stopping",
    2269                   0,2147483647,MAXITERATION);
     2269                  0,2147483647,CLP_PARAM_INT_MAXITERATION);
    22702270  parameters[numberParameters-1].setLonghelp
    22712271    (
     
    22782278  parameters[numberParameters++]=
    22792279    CbcOrClpParam("maxN!odes","Maximum number of nodes to do",
    2280                   -1,2147483647,MAXNODES);
     2280                  -1,2147483647,CBC_PARAM_INT_MAXNODES);
    22812281  parameters[numberParameters-1].setLonghelp
    22822282    (
     
    22862286  parameters[numberParameters++]=
    22872287    CbcOrClpParam("maxS!olutions","Maximum number of solutions to get",
    2288                   1,2147483647,MAXSOLS);
     2288                  1,2147483647,CBC_PARAM_INT_MAXSOLS);
    22892289  parameters[numberParameters-1].setLonghelp
    22902290    (
     
    22952295  parameters[numberParameters++]=
    22962296    CbcOrClpParam("min!imize","Set optimization direction to minimize",
    2297                   MINIMIZE,7);
     2297                  CLP_PARAM_ACTION_MINIMIZE,7);
    22982298  parameters[numberParameters-1].setLonghelp
    22992299    (
     
    23052305  parameters[numberParameters++]=
    23062306    CbcOrClpParam("mipO!ptions","Dubious options for mip",
    2307                   0,COIN_INT_MAX,MIPOPTIONS,0);
     2307                  0,COIN_INT_MAX,CBC_PARAM_INT_MIPOPTIONS,0);
    23082308  parameters[numberParameters++]=
    23092309    CbcOrClpParam("more!MipOptions","More dubious options for mip",
    2310                   -1,COIN_INT_MAX,MOREMIPOPTIONS,0);
     2310                  -1,COIN_INT_MAX,CBC_PARAM_INT_MOREMIPOPTIONS,0);
    23112311  parameters[numberParameters++]=
    23122312    CbcOrClpParam("mixed!IntegerRoundingCuts","Whether to use Mixed Integer Rounding cuts",
    2313                   "off",MIXEDCUTS);
     2313                  "off",CBC_PARAM_STR_MIXEDCUTS);
    23142314  parameters[numberParameters-1].append("on");
    23152315  parameters[numberParameters-1].append("root");
     
    23252325  parameters[numberParameters++]=
    23262326    CbcOrClpParam("mess!ages","Controls if Clpnnnn is printed",
    2327                   "off",MESSAGES);
     2327                  "off",CLP_PARAM_STR_MESSAGES);
    23282328  parameters[numberParameters-1].append("on");
    23292329  parameters[numberParameters-1].setLonghelp
     
    23372337  parameters[numberParameters++]=
    23382338    CbcOrClpParam("moreT!une","Yet more dubious ideas for feasibility pump",
    2339                   0,100000000,FPUMPTUNE2,0);
     2339                  0,100000000,CBC_PARAM_INT_FPUMPTUNE2,0);
    23402340  parameters[numberParameters-1].setLonghelp
    23412341    (
     
    23522352  parameters[numberParameters++]=
    23532353    CbcOrClpParam("miplib","Do some of miplib test set",
    2354                   MIPLIB,3,1);
     2354                  CBC_PARAM_ACTION_MIPLIB,3,1);
    23552355  parameters[numberParameters++]=
    23562356      CbcOrClpParam("naive!Heuristics","Whether to try some stupid heuristic",
    2357                     "off",NAIVE,7,1);
     2357                    "off",CBC_PARAM_STR_NAIVE,7,1);
    23582358  parameters[numberParameters-1].append("on");
    23592359  parameters[numberParameters-1].append("both");
     
    23672367  parameters[numberParameters++]=
    23682368    CbcOrClpParam("netlib","Solve entire netlib test set",
    2369                   NETLIB_EITHER,3,1);
     2369                  CLP_PARAM_ACTION_NETLIB_EITHER,3,1);
    23702370  parameters[numberParameters-1].setLonghelp
    23712371    (
     
    23752375  parameters[numberParameters++]=
    23762376    CbcOrClpParam("netlibB!arrier","Solve entire netlib test set with barrier",
    2377                   NETLIB_BARRIER,3,1);
     2377                  CLP_PARAM_ACTION_NETLIB_BARRIER,3,1);
    23782378  parameters[numberParameters-1].setLonghelp
    23792379    (
     
    23832383  parameters[numberParameters++]=
    23842384    CbcOrClpParam("netlibD!ual","Solve entire netlib test set (dual)",
    2385                   NETLIB_DUAL,3,1);
     2385                  CLP_PARAM_ACTION_NETLIB_DUAL,3,1);
    23862386  parameters[numberParameters-1].setLonghelp
    23872387    (
     
    23912391  parameters[numberParameters++]=
    23922392    CbcOrClpParam("netlibP!rimal","Solve entire netlib test set (primal)",
    2393                   NETLIB_PRIMAL,3,1);
     2393                  CLP_PARAM_ACTION_NETLIB_PRIMAL,3,1);
    23942394  parameters[numberParameters-1].setLonghelp
    23952395    (
     
    23992399  parameters[numberParameters++]=
    24002400    CbcOrClpParam("netlibT!une","Solve entire netlib test set with 'best' algorithm",
    2401                   NETLIB_TUNE,3,1);
     2401                  CLP_PARAM_ACTION_NETLIB_TUNE,3,1);
    24022402  parameters[numberParameters-1].setLonghelp
    24032403    (
     
    24092409  parameters[numberParameters++]=
    24102410    CbcOrClpParam("network","Tries to make network matrix",
    2411                   NETWORK,7,0);
     2411                  CLP_PARAM_ACTION_NETWORK,7,0);
    24122412  parameters[numberParameters-1].setLonghelp
    24132413    (
     
    24202420  parameters[numberParameters++]=
    24212421    CbcOrClpParam("node!Strategy","What strategy to use to select nodes",
    2422                   "hybrid",NODESTRATEGY);
     2422                  "hybrid",CBC_PARAM_STR_NODESTRATEGY);
    24232423  parameters[numberParameters-1].append("fewest");
    24242424  parameters[numberParameters-1].append("depth");
     
    24362436  parameters[numberParameters++]=
    24372437    CbcOrClpParam("numberA!nalyze","Number of analysis iterations",
    2438                   -COIN_INT_MAX,COIN_INT_MAX,NUMBERANALYZE,0);
     2438                  -COIN_INT_MAX,COIN_INT_MAX,CBC_PARAM_INT_NUMBERANALYZE,0);
    24392439  parameters[numberParameters-1].setLonghelp
    24402440    (
     
    24452445  parameters[numberParameters++]=
    24462446    CbcOrClpParam("objective!Scale","Scale factor to apply to objective",
    2447                   -1.0e20,1.0e20,OBJSCALE,1);
     2447                  -1.0e20,1.0e20,CLP_PARAM_DBL_OBJSCALE,1);
    24482448  parameters[numberParameters-1].setLonghelp
    24492449    (
     
    24562456  parameters[numberParameters++]=
    24572457    CbcOrClpParam("outDup!licates","takes duplicate rows etc out of integer model",
    2458                   OUTDUPROWS,7,0);
     2458                  CLP_PARAM_ACTION_OUTDUPROWS,7,0);
    24592459#endif
    24602460  parameters[numberParameters++]=
    24612461    CbcOrClpParam("output!Format","Which output format to use",
    2462                   1,6,OUTPUTFORMAT);
     2462                  1,6,CLP_PARAM_INT_OUTPUTFORMAT);
    24632463  parameters[numberParameters-1].setLonghelp
    24642464    (
     
    24732473  parameters[numberParameters++]=
    24742474    CbcOrClpParam("passC!uts","Number of cut passes at root node",
    2475                   -9999999,9999999,CUTPASS);
     2475                  -9999999,9999999,CBC_PARAM_INT_CUTPASS);
    24762476  parameters[numberParameters-1].setLonghelp
    24772477    (
     
    24812481  parameters[numberParameters++]=
    24822482    CbcOrClpParam("passF!easibilityPump","How many passes in feasibility pump",
    2483                   0,10000,FPUMPITS);
     2483                  0,10000,CBC_PARAM_INT_FPUMPITS);
    24842484  parameters[numberParameters-1].setLonghelp
    24852485    (
     
    24912491  parameters[numberParameters++]=
    24922492    CbcOrClpParam("passP!resolve","How many passes in presolve",
    2493                   -200,100,PRESOLVEPASS,1);
     2493                  -200,100,CLP_PARAM_INT_PRESOLVEPASS,1);
    24942494  parameters[numberParameters-1].setLonghelp
    24952495    (
     
    25022502  parameters[numberParameters++]=
    25032503    CbcOrClpParam("passT!reeCuts","Number of cut passes in tree",
    2504                   -9999999,9999999,CUTPASSINTREE);
     2504                  -9999999,9999999,CBC_PARAM_INT_CUTPASSINTREE);
    25052505  parameters[numberParameters-1].setLonghelp
    25062506    (
     
    25112511  parameters[numberParameters++]=
    25122512    CbcOrClpParam("pertV!alue","Method of perturbation",
    2513                   -5000,102,PERTVALUE,1);
     2513                  -5000,102,CLP_PARAM_INT_PERTVALUE,1);
    25142514  parameters[numberParameters++]=
    25152515    CbcOrClpParam("perturb!ation","Whether to perturb problem",
    2516                   "on",PERTURBATION);
     2516                  "on",CLP_PARAM_STR_PERTURBATION);
    25172517  parameters[numberParameters-1].append("off");
    25182518  parameters[numberParameters-1].setLonghelp
     
    25252525  parameters[numberParameters++]=
    25262526    CbcOrClpParam("PFI","Whether to use Product Form of Inverse in simplex",
    2527                   "off",PFI,7,0);
     2527                  "off",CLP_PARAM_STR_PFI,7,0);
    25282528  parameters[numberParameters-1].append("on");
    25292529  parameters[numberParameters-1].setLonghelp
     
    25352535  parameters[numberParameters++]=
    25362536      CbcOrClpParam("pivotAndC!omplement","Whether to try Pivot and Complement heuristic",
    2537                     "off",PIVOTANDCOMPLEMENT);
     2537                    "off",CBC_PARAM_STR_PIVOTANDCOMPLEMENT);
    25382538  parameters[numberParameters-1].append("on");
    25392539  parameters[numberParameters-1].append("both");
     
    25452545  parameters[numberParameters++]=
    25462546      CbcOrClpParam("pivotAndF!ix","Whether to try Pivot and Fix heuristic",
    2547                     "off",PIVOTANDFIX);
     2547                    "off",CBC_PARAM_STR_PIVOTANDFIX);
    25482548  parameters[numberParameters-1].append("on");
    25492549  parameters[numberParameters-1].append("both");
     
    25572557  parameters[numberParameters++]=
    25582558    CbcOrClpParam("plus!Minus","Tries to make +- 1 matrix",
    2559                   PLUSMINUS,7,0);
     2559                  CLP_PARAM_ACTION_PLUSMINUS,7,0);
    25602560  parameters[numberParameters-1].setLonghelp
    25612561    (
     
    25662566  parameters[numberParameters++]=
    25672567    CbcOrClpParam("pO!ptions","Dubious print options",
    2568                   0,COIN_INT_MAX,PRINTOPTIONS,1);
     2568                  0,COIN_INT_MAX,CLP_PARAM_INT_PRINTOPTIONS,1);
    25692569  parameters[numberParameters-1].setIntValue(0);
    25702570  parameters[numberParameters-1].setLonghelp
     
    25742574  parameters[numberParameters++]=
    25752575    CbcOrClpParam("preO!pt","Presolve options",
    2576                   0,COIN_INT_MAX,PRESOLVEOPTIONS,0);
     2576                  0,COIN_INT_MAX,CLP_PARAM_INT_PRESOLVEOPTIONS,0);
    25772577#endif
    25782578  parameters[numberParameters++]=
    25792579    CbcOrClpParam("presolve","Whether to presolve problem",
    2580                   "on",PRESOLVE);
     2580                  "on",CLP_PARAM_STR_PRESOLVE);
    25812581  parameters[numberParameters-1].append("off");
    25822582  parameters[numberParameters-1].append("more");
     
    25932593  parameters[numberParameters++]=
    25942594    CbcOrClpParam("preprocess","Whether to use integer preprocessing",
    2595                   "off",PREPROCESS);
     2595                  "off",CBC_PARAM_STR_PREPROCESS);
    25962596  parameters[numberParameters-1].append("on");
    25972597  parameters[numberParameters-1].append("save");
     
    26172617  parameters[numberParameters++]=
    26182618    CbcOrClpParam("preT!olerance","Tolerance to use in presolve",
    2619                   1.0e-20,1.0e12,PRESOLVETOLERANCE);
     2619                  1.0e-20,1.0e12,CLP_PARAM_DBL_PRESOLVETOLERANCE);
    26202620  parameters[numberParameters-1].setLonghelp
    26212621    (
     
    26252625  parameters[numberParameters++]=
    26262626    CbcOrClpParam("primalP!ivot","Primal pivot choice algorithm",
    2627                   "auto!matic",PRIMALPIVOT,7,1);
     2627                  "auto!matic",CLP_PARAM_STR_PRIMALPIVOT,7,1);
    26282628  parameters[numberParameters-1].append("exa!ct");
    26292629  parameters[numberParameters-1].append("dant!zig");
     
    26432643  parameters[numberParameters++]=
    26442644    CbcOrClpParam("primalS!implex","Do primal simplex algorithm",
    2645                   PRIMALSIMPLEX);
     2645                  CLP_PARAM_ACTION_PRIMALSIMPLEX);
    26462646  parameters[numberParameters-1].setLonghelp
    26472647    (
     
    26552655    CbcOrClpParam("primalT!olerance","For an optimal solution \
    26562656no primal infeasibility may exceed this value",
    2657                   1.0e-20,1.0e12,PRIMALTOLERANCE);
     2657                  1.0e-20,1.0e12,CLP_PARAM_DBL_PRIMALTOLERANCE);
    26582658  parameters[numberParameters-1].setLonghelp
    26592659    (
     
    26652665    CbcOrClpParam("primalW!eight","Initially algorithm acts as if it \
    26662666costs this much to be infeasible",
    2667                   1.0e-20,1.0e20,PRIMALWEIGHT);
     2667                  1.0e-20,1.0e20,CLP_PARAM_DBL_PRIMALWEIGHT);
    26682668  parameters[numberParameters-1].setLonghelp
    26692669    (
     
    26792679  parameters[numberParameters++]=
    26802680    CbcOrClpParam("printi!ngOptions","Print options",
    2681                   "normal",INTPRINT,3);
     2681                  "normal",CLP_PARAM_STR_INTPRINT,3);
    26822682  parameters[numberParameters-1].append("integer");
    26832683  parameters[numberParameters-1].append("special");
     
    26972697  parameters[numberParameters++]=
    26982698    CbcOrClpParam("printM!ask","Control printing of solution on a  mask",
    2699                   PRINTMASK,3);
     2699                  CLP_PARAM_ACTION_PRINTMASK,3);
    27002700  parameters[numberParameters-1].setLonghelp
    27012701    (
     
    27082708  parameters[numberParameters++]=
    27092709    CbcOrClpParam("prio!rityIn","Import priorities etc from file",
    2710                   PRIORITYIN,3);
     2710                  CBC_PARAM_ACTION_PRIORITYIN,3);
    27112711  parameters[numberParameters-1].setLonghelp
    27122712    (
     
    27192719  parameters[numberParameters++]=
    27202720    CbcOrClpParam("probing!Cuts","Whether to use Probing cuts",
    2721                   "off",PROBINGCUTS);
     2721                  "off",CBC_PARAM_STR_PROBINGCUTS);
    27222722  parameters[numberParameters-1].append("on");
    27232723  parameters[numberParameters-1].append("root");
     
    27382738  parameters[numberParameters++]=
    27392739    CbcOrClpParam("pumpC!utoff","Fake cutoff for use in feasibility pump",
    2740                   -COIN_DBL_MAX,COIN_DBL_MAX,FAKECUTOFF);
     2740                  -COIN_DBL_MAX,COIN_DBL_MAX,CBC_PARAM_DBL_FAKECUTOFF);
    27412741  parameters[numberParameters-1].setDoubleValue(0.0);
    27422742  parameters[numberParameters-1].setLonghelp
     
    27472747  parameters[numberParameters++]=
    27482748    CbcOrClpParam("pumpI!ncrement","Fake increment for use in feasibility pump",
    2749                   -COIN_DBL_MAX,COIN_DBL_MAX,FAKEINCREMENT,1);
     2749                  -COIN_DBL_MAX,COIN_DBL_MAX,CBC_PARAM_DBL_FAKEINCREMENT,1);
    27502750  parameters[numberParameters-1].setDoubleValue(0.0);
    27512751  parameters[numberParameters-1].setLonghelp
     
    27562756  parameters[numberParameters++]=
    27572757    CbcOrClpParam("pumpT!une","Dubious ideas for feasibility pump",
    2758                   0,100000000,FPUMPTUNE);
     2758                  0,100000000,CBC_PARAM_INT_FPUMPTUNE);
    27592759  parameters[numberParameters-1].setLonghelp
    27602760    (
     
    27732773  parameters[numberParameters++]=
    27742774    CbcOrClpParam("quit","Stops clp execution",
    2775                   EXIT);
     2775                  CLP_PARAM_ACTION_EXIT);
    27762776  parameters[numberParameters-1].setLonghelp
    27772777    (
     
    27812781  parameters[numberParameters++]=
    27822782      CbcOrClpParam("rand!omizedRounding","Whether to try randomized rounding heuristic",
    2783                     "off",RANDROUND);
     2783                    "off",CBC_PARAM_STR_RANDROUND);
    27842784  parameters[numberParameters-1].append("on");
    27852785  parameters[numberParameters-1].append("both");
     
    27922792    CbcOrClpParam("ratio!Gap","Stop when gap between best possible and \
    27932793best less than this fraction of larger of two",
    2794                   0.0,1.0e20,GAPRATIO);
     2794                  0.0,1.0e20,CBC_PARAM_DBL_GAPRATIO);
    27952795  parameters[numberParameters-1].setDoubleValue(0.0);
    27962796  parameters[numberParameters-1].setLonghelp
     
    28022802  parameters[numberParameters++]=
    28032803    CbcOrClpParam("readS!tored","Import stored cuts from file",
    2804                   STOREDFILE,3,0);
     2804                  CLP_PARAM_ACTION_STOREDFILE,3,0);
    28052805#endif
    28062806#ifdef COIN_HAS_CLP
    28072807  parameters[numberParameters++]=
    28082808    CbcOrClpParam("reallyO!bjectiveScale","Scale factor to apply to objective in place",
    2809                   -1.0e20,1.0e20,OBJSCALE2,0);
     2809                  -1.0e20,1.0e20,CLP_PARAM_DBL_OBJSCALE2,0);
    28102810  parameters[numberParameters-1].setLonghelp
    28112811    (
     
    28152815  parameters[numberParameters++]=
    28162816    CbcOrClpParam("reallyS!cale","Scales model in place",
    2817                   REALLY_SCALE,7,0);
     2817                  CLP_PARAM_ACTION_REALLY_SCALE,7,0);
    28182818#endif
    28192819#ifdef COIN_HAS_CBC
    28202820    parameters[numberParameters++]=
    28212821      CbcOrClpParam("reduce!AndSplitCuts","Whether to use Reduce-and-Split cuts",
    2822               "off",REDSPLITCUTS);
     2822              "off",CBC_PARAM_STR_REDSPLITCUTS);
    28232823    parameters[numberParameters-1].append("on");
    28242824    parameters[numberParameters-1].append("root");
     
    28322832  parameters[numberParameters++]=
    28332833    CbcOrClpParam("residual!CapacityCuts","Whether to use Residual Capacity cuts",
    2834                   "off",RESIDCUTS);
     2834                  "off",CBC_PARAM_STR_RESIDCUTS);
    28352835  parameters[numberParameters-1].append("on");
    28362836  parameters[numberParameters-1].append("root");
     
    28462846  parameters[numberParameters++]=
    28472847    CbcOrClpParam("restore!Model","Restore model from binary file",
    2848                   RESTORE,7,1);
     2848                  CLP_PARAM_ACTION_RESTORE,7,1);
    28492849  parameters[numberParameters-1].setLonghelp
    28502850    (
     
    28552855  parameters[numberParameters++]=
    28562856    CbcOrClpParam("reverse","Reverses sign of objective",
    2857                   REVERSE,7,0);
     2857                  CLP_PARAM_ACTION_REVERSE,7,0);
    28582858  parameters[numberParameters-1].setLonghelp
    28592859    (
     
    28622862  parameters[numberParameters++]=
    28632863    CbcOrClpParam("rhs!Scale","Scale factor to apply to rhs and bounds",
    2864                   -1.0e20,1.0e20,RHSSCALE,0);
     2864                  -1.0e20,1.0e20,CLP_PARAM_DBL_RHSSCALE,0);
    28652865  parameters[numberParameters-1].setLonghelp
    28662866    (
     
    28732873  parameters[numberParameters++]=
    28742874      CbcOrClpParam("Rens","Whether to try Relaxation Enforced Neighborhood Search",
    2875                     "off",RENS);
     2875                    "off",CBC_PARAM_STR_RENS);
    28762876    parameters[numberParameters-1].append("on");
    28772877    parameters[numberParameters-1].append("both");
     
    28882888  parameters[numberParameters++]=
    28892889      CbcOrClpParam("Rins","Whether to try Relaxed Induced Neighborhood Search",
    2890                     "off",RINS);
     2890                    "off",CBC_PARAM_STR_RINS);
    28912891    parameters[numberParameters-1].append("on");
    28922892    parameters[numberParameters-1].append("both");
     
    28992899  parameters[numberParameters++]=
    29002900    CbcOrClpParam("round!ingHeuristic","Whether to use Rounding heuristic",
    2901                   "off",ROUNDING);
     2901                  "off",CBC_PARAM_STR_ROUNDING);
    29022902  parameters[numberParameters-1].append("on");
    29032903  parameters[numberParameters-1].append("both");
     
    29142914  parameters[numberParameters++]=
    29152915    CbcOrClpParam("saveM!odel","Save model to binary file",
    2916                   SAVE,7,1);
     2916                  CLP_PARAM_ACTION_SAVE,7,1);
    29172917  parameters[numberParameters-1].setLonghelp
    29182918    (
     
    29242924  parameters[numberParameters++]=
    29252925    CbcOrClpParam("saveS!olution","saves solution to file",
    2926                   SAVESOL);
     2926                  CLP_PARAM_ACTION_SAVESOL);
    29272927  parameters[numberParameters-1].setLonghelp
    29282928    (
     
    29362936  parameters[numberParameters++]=
    29372937    CbcOrClpParam("scal!ing","Whether to scale problem",
    2938                   "off",SCALING);
     2938                  "off",CLP_PARAM_STR_SCALING);
    29392939  parameters[numberParameters-1].append("equi!librium");
    29402940  parameters[numberParameters-1].append("geo!metric");
     
    29532953  parameters[numberParameters++]=
    29542954    CbcOrClpParam("sec!onds","Maximum seconds",
    2955                   -1.0,1.0e12,TIMELIMIT);
     2955                  -1.0,1.0e12,CLP_PARAM_DBL_TIMELIMIT);
    29562956  parameters[numberParameters-1].setLonghelp
    29572957    (
     
    29622962  parameters[numberParameters++]=
    29632963    CbcOrClpParam("sec!onds","maximum seconds",
    2964                   -1.0,1.0e12,TIMELIMIT_BAB);
     2964                  -1.0,1.0e12,CBC_PARAM_DBL_TIMELIMIT_BAB);
    29652965  parameters[numberParameters-1].setLonghelp
    29662966    (
     
    29702970  parameters[numberParameters++]=
    29712971    CbcOrClpParam("sleep","for debug",
    2972                   DUMMY,7,0);
     2972                  CLP_PARAM_ACTION_DUMMY,7,0);
    29732973  parameters[numberParameters-1].setLonghelp
    29742974    (
     
    29782978  parameters[numberParameters++]=
    29792979    CbcOrClpParam("slp!Value","Number of slp passes before primal",
    2980                   -1,50000,SLPVALUE,1);
     2980                  -1,50000,CLP_PARAM_INT_SLPVALUE,1);
    29812981  parameters[numberParameters-1].setLonghelp
    29822982    (
     
    29872987  parameters[numberParameters++]=
    29882988    CbcOrClpParam("small!Factorization","Whether to use small factorization",
    2989                   -1,10000,SMALLFACT,1);
     2989                  -1,10000,CBC_PARAM_INT_SMALLFACT,1);
    29902990  parameters[numberParameters-1].setLonghelp
    29912991    (
     
    29972997  parameters[numberParameters++]=
    29982998    CbcOrClpParam("solu!tion","Prints solution to file",
    2999                   SOLUTION);
     2999                  CLP_PARAM_ACTION_SOLUTION);
    30003000  parameters[numberParameters-1].setLonghelp
    30013001    (
     
    30083008  parameters[numberParameters++]=
    30093009    CbcOrClpParam("solv!e","Solve problem",
    3010                   BAB);
     3010                  CBC_PARAM_ACTION_BAB);
    30113011  parameters[numberParameters-1].setLonghelp
    30123012    (
     
    30163016  parameters[numberParameters++]=
    30173017    CbcOrClpParam("sos!Options","Whether to use SOS from AMPL",
    3018                   "off",SOS);
     3018                  "off",CBC_PARAM_STR_SOS);
    30193019  parameters[numberParameters-1].append("on");
    30203020  parameters[numberParameters-1].setCurrentOption("on");
     
    30263026  parameters[numberParameters++]=
    30273027    CbcOrClpParam("slog!Level","Level of detail in (LP) Solver output",
    3028                   -1,63,SOLVERLOGLEVEL);
     3028                  -1,63,CLP_PARAM_INT_SOLVERLOGLEVEL);
    30293029  parameters[numberParameters-1].setLonghelp
    30303030    (
     
    30363036  parameters[numberParameters++]=
    30373037    CbcOrClpParam("solv!e","Solve problem using dual simplex",
    3038                   BAB);
     3038                  CBC_PARAM_ACTION_BAB);
    30393039  parameters[numberParameters-1].setLonghelp
    30403040    (
     
    30463046  parameters[numberParameters++]=
    30473047    CbcOrClpParam("spars!eFactor","Whether factorization treated as sparse",
    3048                   "on",SPARSEFACTOR,7,0);
     3048                  "on",CLP_PARAM_STR_SPARSEFACTOR,7,0);
    30493049  parameters[numberParameters-1].append("off");
    30503050  parameters[numberParameters++]=
    30513051    CbcOrClpParam("special!Options","Dubious options for Simplex - see ClpSimplex.hpp",
    3052                   0,COIN_INT_MAX,SPECIALOPTIONS,0);
     3052                  0,COIN_INT_MAX,CLP_PARAM_INT_SPECIALOPTIONS,0);
    30533053  parameters[numberParameters++]=
    30543054    CbcOrClpParam("sprint!Crash","Whether to try sprint crash",
    3055                   -1,5000000,SPRINT);
     3055                  -1,5000000,CLP_PARAM_INT_SPRINT);
    30563056  parameters[numberParameters-1].setLonghelp
    30573057    (
     
    30633063  parameters[numberParameters++]=
    30643064    CbcOrClpParam("stat!istics","Print some statistics",
    3065                   STATISTICS);
     3065                  CLP_PARAM_ACTION_STATISTICS);
    30663066  parameters[numberParameters-1].setLonghelp
    30673067    (
     
    30733073  parameters[numberParameters++]=
    30743074    CbcOrClpParam("stop","Stops clp execution",
    3075                   EXIT);
     3075                  CLP_PARAM_ACTION_EXIT);
    30763076  parameters[numberParameters-1].setLonghelp
    30773077    (
     
    30813081  parameters[numberParameters++]=
    30823082    CbcOrClpParam("strat!egy","Switches on groups of features",
    3083                   0,2,STRATEGY);
     3083                  0,2,CBC_PARAM_INT_STRATEGY);
    30843084  parameters[numberParameters-1].setLonghelp
    30853085    (
     
    30963096  parameters[numberParameters++]=
    30973097    CbcOrClpParam("strengthen","Create strengthened problem",
    3098                   STRENGTHEN,3);
     3098                  CBC_PARAM_ACTION_STRENGTHEN,3);
    30993099  parameters[numberParameters-1].setLonghelp
    31003100    (
     
    31053105  parameters[numberParameters++]=
    31063106    CbcOrClpParam("strong!Branching","Number of variables to look at in strong branching",
    3107                   0,999999,STRONGBRANCHING);
     3107                  0,999999,CBC_PARAM_INT_STRONGBRANCHING);
    31083108  parameters[numberParameters-1].setLonghelp
    31093109    (
     
    31173117  parameters[numberParameters++]=
    31183118    CbcOrClpParam("subs!titution","How long a column to substitute for in presolve",
    3119                   0,10000,SUBSTITUTION,0);
     3119                  0,10000,CLP_PARAM_INT_SUBSTITUTION,0);
    31203120  parameters[numberParameters-1].setLonghelp
    31213121    (
     
    31283128  parameters[numberParameters++]=
    31293129    CbcOrClpParam("testO!si","Test OsiObject stuff",
    3130                   -1,COIN_INT_MAX,TESTOSI,0);
     3130                  -1,COIN_INT_MAX,CBC_PARAM_INT_TESTOSI,0);
    31313131#endif
    31323132#ifdef CBC_THREAD
    31333133  parameters[numberParameters++]=
    31343134    CbcOrClpParam("thread!s","Number of threads to try and use",
    3135                   -100,100000,THREADS,1);
     3135                  -100,100000,CBC_PARAM_INT_THREADS,1);
    31363136  parameters[numberParameters-1].setLonghelp
    31373137    (
     
    31463146    CbcOrClpParam("tighten!Factor","Tighten bounds using this times largest \
    31473147activity at continuous solution",
    3148                   1.0e-3,1.0e20,TIGHTENFACTOR,0);
     3148                  1.0e-3,1.0e20,CBC_PARAM_DBL_TIGHTENFACTOR,0);
    31493149  parameters[numberParameters-1].setLonghelp
    31503150    (
     
    31553155  parameters[numberParameters++]=
    31563156    CbcOrClpParam("tightLP","Poor person's preSolve for now",
    3157                   TIGHTEN,7,0);
     3157                  CLP_PARAM_ACTION_TIGHTEN,7,0);
    31583158#endif
    31593159#ifdef COIN_HAS_CBC
    31603160  parameters[numberParameters++]=
    31613161    CbcOrClpParam("trust!PseudoCosts","Number of branches before we trust pseudocosts",
    3162                   -3,2000000,NUMBERBEFORE);
     3162                  -3,2000000,CBC_PARAM_INT_NUMBERBEFORE);
    31633163  parameters[numberParameters-1].setLonghelp
    31643164    (
     
    31703170  parameters[numberParameters++]=
    31713171    CbcOrClpParam("tune!PreProcess","Dubious tuning parameters",
    3172                   0,20000000,PROCESSTUNE,1);
     3172                  0,20000000,CLP_PARAM_INT_PROCESSTUNE,1);
    31733173  parameters[numberParameters-1].setLonghelp
    31743174    (
     
    31833183  parameters[numberParameters++]=
    31843184    CbcOrClpParam("two!MirCuts","Whether to use Two phase Mixed Integer Rounding cuts",
    3185                   "off",TWOMIRCUTS);
     3185                  "off",CBC_PARAM_STR_TWOMIRCUTS);
    31863186  parameters[numberParameters-1].append("on");
    31873187  parameters[numberParameters-1].append("root");
     
    31993199  parameters[numberParameters++]=
    32003200    CbcOrClpParam("unitTest","Do unit test",
    3201                   UNITTEST,3,1);
     3201                  CLP_PARAM_ACTION_UNITTEST,3,1);
    32023202  parameters[numberParameters-1].setLonghelp
    32033203    (
     
    32063206  parameters[numberParameters++]=
    32073207    CbcOrClpParam("userClp","Hand coded Clp stuff",
    3208                   USERCLP,0,0);
     3208                  CLP_PARAM_ACTION_USERCLP,0,0);
    32093209  parameters[numberParameters-1].setLonghelp
    32103210    (
     
    32153215  parameters[numberParameters++]=
    32163216    CbcOrClpParam("userCbc","Hand coded Cbc stuff",
    3217                   USERCBC,0,0);
     3217                  CBC_PARAM_ACTION_USERCBC,0,0);
    32183218  parameters[numberParameters-1].setLonghelp
    32193219    (
     
    32243224  parameters[numberParameters++]=
    32253225      CbcOrClpParam("Vnd!VariableNeighborhoodSearch","Whether to try Variable Neighborhood Search",
    3226                     "off",VND);
     3226                    "off",CBC_PARAM_STR_VND);
    32273227    parameters[numberParameters-1].append("on");
    32283228    parameters[numberParameters-1].append("both");
     
    32363236  parameters[numberParameters++]=
    32373237    CbcOrClpParam("vector","Whether to use vector? Form of matrix in simplex",
    3238                   "off",VECTOR,7,0);
     3238                  "off",CLP_PARAM_STR_VECTOR,7,0);
    32393239  parameters[numberParameters-1].append("on");
    32403240  parameters[numberParameters-1].setLonghelp
     
    32443244  parameters[numberParameters++]=
    32453245    CbcOrClpParam("verbose","Switches on longer help on single ?",
    3246                   0,31,VERBOSE,0);
     3246                  0,31,CLP_PARAM_INT_VERBOSE,0);
    32473247  parameters[numberParameters-1].setLonghelp
    32483248    (
     
    32533253  parameters[numberParameters++]=
    32543254    CbcOrClpParam("vub!heuristic","Type of vub heuristic",
    3255                   -2,20,VUBTRY,0);
     3255                  -2,20,CBC_PARAM_INT_VUBTRY,0);
    32563256  parameters[numberParameters-1].setLonghelp
    32573257    (
     
    32623262  parameters[numberParameters++]=
    32633263    CbcOrClpParam("zero!HalfCuts","Whether to use zero half cuts",
    3264                   "off",ZEROHALFCUTS);
     3264                  "off",CBC_PARAM_STR_ZEROHALFCUTS);
    32653265  parameters[numberParameters-1].append("on");
    32663266  parameters[numberParameters-1].append("root");
  • branches/sandbox/Clp/src/CbcOrClpParam.hpp

    r1458 r1474  
    4646enum CbcOrClpParameterType
    4747
    48   { GENERALQUERY = -100,FULLGENERALQUERY,
     48  { CBC_PARAM_GENERALQUERY = -100,
     49    CBC_PARAM_FULLGENERALQUERY,
    4950   
    50     PRIMALTOLERANCE = 1, DUALTOLERANCE, TIMELIMIT,
    51     DUALBOUND, PRIMALWEIGHT,  OBJSCALE, RHSSCALE,
     51    CLP_PARAM_DBL_PRIMALTOLERANCE = 1,
     52        CLP_PARAM_DBL_DUALTOLERANCE,
     53        CLP_PARAM_DBL_TIMELIMIT,
     54    CLP_PARAM_DBL_DUALBOUND,
     55        CLP_PARAM_DBL_PRIMALWEIGHT, 
     56        CLP_PARAM_DBL_OBJSCALE,
     57        CLP_PARAM_DBL_RHSSCALE,
    5258   
    53     INFEASIBILITYWEIGHT = 51, CUTOFF, INTEGERTOLERANCE,INCREMENT,ALLOWABLEGAP,
    54     TIMELIMIT_BAB, GAPRATIO,
     59    CBC_PARAM_DBL_INFEASIBILITYWEIGHT = 51,
     60        CBC_PARAM_DBL_CUTOFF,
     61        CBC_PARAM_DBL_INTEGERTOLERANCE,
     62        CBC_PARAM_DBL_INCREMENT,
     63        CBC_PARAM_DBL_ALLOWABLEGAP,
     64    CBC_PARAM_DBL_TIMELIMIT_BAB,
     65        CBC_PARAM_DBL_GAPRATIO,
    5566   
    56     DJFIX = 81, TIGHTENFACTOR,PRESOLVETOLERANCE,OBJSCALE2,
    57     FAKEINCREMENT, FAKECUTOFF, ARTIFICIALCOST,DEXTRA3, SMALLBAB, DEXTRA4, DEXTRA5,
    58 
    59     SOLVERLOGLEVEL=101,
     67    CBC_PARAM_DBL_DJFIX = 81,
     68        CBC_PARAM_DBL_TIGHTENFACTOR,
     69        CLP_PARAM_DBL_PRESOLVETOLERANCE,
     70        CLP_PARAM_DBL_OBJSCALE2,
     71    CBC_PARAM_DBL_FAKEINCREMENT,
     72        CBC_PARAM_DBL_FAKECUTOFF,
     73        CBC_PARAM_DBL_ARTIFICIALCOST,
     74        CBC_PARAM_DBL_DEXTRA3,
     75        CBC_PARAM_DBL_SMALLBAB,
     76        CBC_PARAM_DBL_DEXTRA4,
     77        CBC_PARAM_DBL_DEXTRA5,
     78
     79    CLP_PARAM_INT_SOLVERLOGLEVEL=101,
    6080#ifndef COIN_HAS_CBC
    61     LOGLEVEL = 101,
     81    CLP_PARAM_INT_LOGLEVEL = 101,
    6282#endif
    63     MAXFACTOR,PERTVALUE,MAXITERATION,PRESOLVEPASS,IDIOT,SPRINT,
    64     OUTPUTFORMAT,SLPVALUE,PRESOLVEOPTIONS,PRINTOPTIONS,SPECIALOPTIONS,
    65     SUBSTITUTION,DUALIZE,VERBOSE,CPP,PROCESSTUNE,USESOLUTION,
    66 
    67     STRONGBRANCHING=151,CUTDEPTH, MAXNODES,NUMBERBEFORE,NUMBERANALYZE,
    68     MIPOPTIONS,MOREMIPOPTIONS,MAXHOTITS,FPUMPITS,MAXSOLS,
    69     FPUMPTUNE,TESTOSI,EXTRA1,EXTRA2,EXTRA3,EXTRA4,DEPTHMINIBAB,CUTPASSINTREE,
    70     THREADS,CUTPASS,VUBTRY,DENSE,EXPERIMENT,DIVEOPT,STRATEGY,SMALLFACT,
    71     HOPTIONS,CUTLENGTH,FPUMPTUNE2,
     83    CLP_PARAM_INT_MAXFACTOR,
     84        CLP_PARAM_INT_PERTVALUE,
     85        CLP_PARAM_INT_MAXITERATION,
     86        CLP_PARAM_INT_PRESOLVEPASS,
     87        CLP_PARAM_INT_IDIOT,
     88        CLP_PARAM_INT_SPRINT,
     89    CLP_PARAM_INT_OUTPUTFORMAT,
     90        CLP_PARAM_INT_SLPVALUE,
     91        CLP_PARAM_INT_PRESOLVEOPTIONS,
     92        CLP_PARAM_INT_PRINTOPTIONS,
     93        CLP_PARAM_INT_SPECIALOPTIONS,
     94    CLP_PARAM_INT_SUBSTITUTION,
     95        CLP_PARAM_INT_DUALIZE,
     96        CLP_PARAM_INT_VERBOSE,
     97        CLP_PARAM_INT_CPP,
     98        CLP_PARAM_INT_PROCESSTUNE,
     99        CLP_PARAM_INT_USESOLUTION,
     100
     101    CBC_PARAM_INT_STRONGBRANCHING=151,
     102        CBC_PARAM_INT_CUTDEPTH,
     103        CBC_PARAM_INT_MAXNODES,
     104        CBC_PARAM_INT_NUMBERBEFORE,
     105        CBC_PARAM_INT_NUMBERANALYZE,
     106    CBC_PARAM_INT_MIPOPTIONS,
     107        CBC_PARAM_INT_MOREMIPOPTIONS,
     108        CBC_PARAM_INT_MAXHOTITS,
     109        CBC_PARAM_INT_FPUMPITS,
     110        CBC_PARAM_INT_MAXSOLS,
     111    CBC_PARAM_INT_FPUMPTUNE,
     112        CBC_PARAM_INT_TESTOSI,
     113        CBC_PARAM_INT_EXTRA1,
     114        CBC_PARAM_INT_EXTRA2,
     115        CBC_PARAM_INT_EXTRA3,
     116        CBC_PARAM_INT_EXTRA4,
     117        CBC_PARAM_INT_DEPTHMINIBAB,
     118        CBC_PARAM_INT_CUTPASSINTREE,
     119    CBC_PARAM_INT_THREADS,
     120        CBC_PARAM_INT_CUTPASS,
     121        CBC_PARAM_INT_VUBTRY,
     122        CBC_PARAM_INT_DENSE,
     123        CBC_PARAM_INT_EXPERIMENT,
     124        CBC_PARAM_INT_DIVEOPT,
     125        CBC_PARAM_INT_STRATEGY,
     126        CBC_PARAM_INT_SMALLFACT,
     127    CBC_PARAM_INT_HOPTIONS,
     128        CBC_PARAM_INT_CUTLENGTH,
     129        CBC_PARAM_INT_FPUMPTUNE2,
    72130#ifdef COIN_HAS_CBC
    73     LOGLEVEL ,
     131    CLP_PARAM_INT_LOGLEVEL ,
    74132#endif
    75133 
    76     DIRECTION=201,DUALPIVOT,SCALING,ERRORSALLOWED,KEEPNAMES,SPARSEFACTOR,
    77     PRIMALPIVOT,PRESOLVE,CRASH,BIASLU,PERTURBATION,MESSAGES,AUTOSCALE,
    78     CHOLESKY,KKT,BARRIERSCALE,GAMMA,CROSSOVER,PFI,INTPRINT,VECTOR,
    79     FACTORIZATION,ALLCOMMANDS,
     134    CLP_PARAM_STR_DIRECTION=201,
     135        CLP_PARAM_STR_DUALPIVOT,
     136        CLP_PARAM_STR_SCALING,
     137        CLP_PARAM_STR_ERRORSALLOWED,
     138        CLP_PARAM_STR_KEEPNAMES,
     139        CLP_PARAM_STR_SPARSEFACTOR,
     140    CLP_PARAM_STR_PRIMALPIVOT,
     141        CLP_PARAM_STR_PRESOLVE,
     142        CLP_PARAM_STR_CRASH,
     143        CLP_PARAM_STR_BIASLU,
     144        CLP_PARAM_STR_PERTURBATION,
     145        CLP_PARAM_STR_MESSAGES,
     146        CLP_PARAM_STR_AUTOSCALE,
     147    CLP_PARAM_STR_CHOLESKY,
     148        CLP_PARAM_STR_KKT,
     149        CLP_PARAM_STR_BARRIERSCALE,
     150        CLP_PARAM_STR_GAMMA,
     151        CLP_PARAM_STR_CROSSOVER,
     152        CLP_PARAM_STR_PFI,
     153        CLP_PARAM_STR_INTPRINT,
     154        CLP_PARAM_STR_VECTOR,
     155    CLP_PARAM_STR_FACTORIZATION,
     156        CLP_PARAM_STR_ALLCOMMANDS,
    80157   
    81     NODESTRATEGY = 251,BRANCHSTRATEGY,CUTSSTRATEGY,HEURISTICSTRATEGY,
    82     GOMORYCUTS,PROBINGCUTS,KNAPSACKCUTS,REDSPLITCUTS,
    83     ROUNDING,SOLVER,CLIQUECUTS,COSTSTRATEGY,FLOWCUTS,MIXEDCUTS,
    84     TWOMIRCUTS,PREPROCESS,FPUMP,GREEDY,COMBINE,LOCALTREE,SOS,
    85     LANDPCUTS,RINS,RESIDCUTS,RENS,DIVINGS,DIVINGC,DIVINGF,DIVINGG,DIVINGL,
    86     DIVINGP,DIVINGV,DINS,PIVOTANDFIX,RANDROUND,NAIVE,ZEROHALFCUTS,CPX,
    87     CROSSOVER2,PIVOTANDCOMPLEMENT,VND,
     158    CBC_PARAM_STR_NODESTRATEGY = 251,
     159        CBC_PARAM_STR_BRANCHSTRATEGY,
     160        CBC_PARAM_STR_CUTSSTRATEGY,
     161        CBC_PARAM_STR_HEURISTICSTRATEGY,
     162    CBC_PARAM_STR_GOMORYCUTS,
     163        CBC_PARAM_STR_PROBINGCUTS,
     164        CBC_PARAM_STR_KNAPSACKCUTS,
     165        CBC_PARAM_STR_REDSPLITCUTS,
     166    CBC_PARAM_STR_ROUNDING,
     167        CBC_PARAM_STR_SOLVER,
     168        CBC_PARAM_STR_CLIQUECUTS,
     169        CBC_PARAM_STR_COSTSTRATEGY,
     170        CBC_PARAM_STR_FLOWCUTS,
     171        CBC_PARAM_STR_MIXEDCUTS,
     172    CBC_PARAM_STR_TWOMIRCUTS,
     173        CBC_PARAM_STR_PREPROCESS,
     174        CBC_PARAM_STR_FPUMP,
     175        CBC_PARAM_STR_GREEDY,
     176        CBC_PARAM_STR_COMBINE,
     177        CBC_PARAM_STR_LOCALTREE,
     178        CBC_PARAM_STR_SOS,
     179    CBC_PARAM_STR_LANDPCUTS,
     180        CBC_PARAM_STR_RINS,
     181        CBC_PARAM_STR_RESIDCUTS,
     182        CBC_PARAM_STR_RENS,
     183        CBC_PARAM_STR_DIVINGS,
     184        CBC_PARAM_STR_DIVINGC,
     185        CBC_PARAM_STR_DIVINGF,
     186        CBC_PARAM_STR_DIVINGG,
     187        CBC_PARAM_STR_DIVINGL,
     188    CBC_PARAM_STR_DIVINGP,
     189        CBC_PARAM_STR_DIVINGV,
     190        CBC_PARAM_STR_DINS,
     191        CBC_PARAM_STR_PIVOTANDFIX,
     192        CBC_PARAM_STR_RANDROUND,
     193        CBC_PARAM_STR_NAIVE,
     194        CBC_PARAM_STR_ZEROHALFCUTS,
     195        CBC_PARAM_STR_CPX,
     196    CBC_PARAM_STR_CROSSOVER2,
     197        CBC_PARAM_STR_PIVOTANDCOMPLEMENT,
     198        CBC_PARAM_STR_VND,
    88199   
    89     DIRECTORY=301,DIRSAMPLE,DIRNETLIB,DIRMIPLIB,IMPORT,EXPORT,RESTORE,SAVE,DUALSIMPLEX,PRIMALSIMPLEX,EITHERSIMPLEX,
    90     MAXIMIZE,MINIMIZE,EXIT,STDIN,UNITTEST,NETLIB_EITHER,NETLIB_DUAL,NETLIB_PRIMAL,SOLUTION,SAVESOL,
    91     TIGHTEN,FAKEBOUND,HELP,PLUSMINUS,NETWORK,ALLSLACK,REVERSE,BARRIER,NETLIB_BARRIER,NETLIB_TUNE,
    92     REALLY_SCALE,BASISIN,BASISOUT,SOLVECONTINUOUS,CLEARCUTS,VERSION,STATISTICS,DEBUG,DUMMY,PRINTMASK,
    93     OUTDUPROWS,USERCLP,MODELIN,CSVSTATISTICS,STOREDFILE,ENVIRONMENT,
    94 
    95     BAB=351,MIPLIB,STRENGTHEN,PRIORITYIN,USERCBC,DOHEURISTIC,
    96 
    97     OSLSTUFF = 401,CBCSTUFF,
    98 
    99     INVALID = 1000 } ;
     200    CLP_PARAM_ACTION_DIRECTORY=301,
     201        CLP_PARAM_ACTION_DIRSAMPLE,
     202        CLP_PARAM_ACTION_DIRNETLIB,
     203        CBC_PARAM_ACTION_DIRMIPLIB,
     204        CLP_PARAM_ACTION_IMPORT,
     205        CLP_PARAM_ACTION_EXPORT,
     206        CLP_PARAM_ACTION_RESTORE,
     207        CLP_PARAM_ACTION_SAVE,
     208        CLP_PARAM_ACTION_DUALSIMPLEX,
     209        CLP_PARAM_ACTION_PRIMALSIMPLEX,
     210        CLP_PARAM_ACTION_EITHERSIMPLEX,
     211    CLP_PARAM_ACTION_MAXIMIZE,
     212        CLP_PARAM_ACTION_MINIMIZE,
     213        CLP_PARAM_ACTION_EXIT,
     214        CLP_PARAM_ACTION_STDIN,
     215        CLP_PARAM_ACTION_UNITTEST,
     216        CLP_PARAM_ACTION_NETLIB_EITHER,
     217        CLP_PARAM_ACTION_NETLIB_DUAL,
     218        CLP_PARAM_ACTION_NETLIB_PRIMAL,
     219        CLP_PARAM_ACTION_SOLUTION,
     220        CLP_PARAM_ACTION_SAVESOL,
     221    CLP_PARAM_ACTION_TIGHTEN,
     222        CLP_PARAM_ACTION_FAKEBOUND,
     223        CLP_PARAM_ACTION_HELP,
     224        CLP_PARAM_ACTION_PLUSMINUS,
     225        CLP_PARAM_ACTION_NETWORK,
     226        CLP_PARAM_ACTION_ALLSLACK,
     227        CLP_PARAM_ACTION_REVERSE,
     228        CLP_PARAM_ACTION_BARRIER,
     229        CLP_PARAM_ACTION_NETLIB_BARRIER,
     230        CLP_PARAM_ACTION_NETLIB_TUNE,
     231    CLP_PARAM_ACTION_REALLY_SCALE,
     232        CLP_PARAM_ACTION_BASISIN,
     233        CLP_PARAM_ACTION_BASISOUT,
     234        CLP_PARAM_ACTION_SOLVECONTINUOUS,
     235        CLP_PARAM_ACTION_CLEARCUTS,
     236        CLP_PARAM_ACTION_VERSION,
     237        CLP_PARAM_ACTION_STATISTICS,
     238        CLP_PARAM_ACTION_DEBUG,
     239        CLP_PARAM_ACTION_DUMMY,
     240        CLP_PARAM_ACTION_PRINTMASK,
     241    CLP_PARAM_ACTION_OUTDUPROWS,
     242        CLP_PARAM_ACTION_USERCLP,
     243        CLP_PARAM_ACTION_MODELIN,
     244        CLP_PARAM_ACTION_CSVSTATISTICS,
     245        CLP_PARAM_ACTION_STOREDFILE,
     246        CLP_PARAM_ACTION_ENVIRONMENT,
     247
     248    CBC_PARAM_ACTION_BAB=351,
     249        CBC_PARAM_ACTION_MIPLIB,
     250        CBC_PARAM_ACTION_STRENGTHEN,
     251        CBC_PARAM_ACTION_PRIORITYIN,
     252        CBC_PARAM_ACTION_USERCBC,
     253        CBC_PARAM_ACTION_DOHEURISTIC,
     254
     255    CBC_PARAM_NOTUSED_OSLSTUFF = 401,
     256        CBC_PARAM_NOTUSED_CBCSTUFF,
     257
     258    CBC_PARAM_NOTUSED_INVALID = 1000 } ;
    100259#include <vector>
    101260#include <string>
  • branches/sandbox/Clp/src/ClpMain.cpp

    r1458 r1474  
    153153    int numberParameters ;
    154154    establishParams(numberParameters,parameters) ;
    155     parameters[whichParam(BASISIN,numberParameters,parameters)].setStringValue(importBasisFile);
    156     parameters[whichParam(BASISOUT,numberParameters,parameters)].setStringValue(exportBasisFile);
    157     parameters[whichParam(PRINTMASK,numberParameters,parameters)].setStringValue(printMask);
    158     parameters[whichParam(DIRECTORY,numberParameters,parameters)].setStringValue(directory);
    159     parameters[whichParam(DIRSAMPLE,numberParameters,parameters)].setStringValue(dirSample);
    160     parameters[whichParam(DIRNETLIB,numberParameters,parameters)].setStringValue(dirNetlib);
    161     parameters[whichParam(DIRMIPLIB,numberParameters,parameters)].setStringValue(dirMiplib);
    162     parameters[whichParam(DUALBOUND,numberParameters,parameters)].setDoubleValue(models->dualBound());
    163     parameters[whichParam(DUALTOLERANCE,numberParameters,parameters)].setDoubleValue(models->dualTolerance());
    164     parameters[whichParam(EXPORT,numberParameters,parameters)].setStringValue(exportFile);
    165     parameters[whichParam(IDIOT,numberParameters,parameters)].setIntValue(doIdiot);
    166     parameters[whichParam(IMPORT,numberParameters,parameters)].setStringValue(importFile);
    167     parameters[whichParam(SOLVERLOGLEVEL,numberParameters,parameters)].setIntValue(models->logLevel());
    168     parameters[whichParam(MAXFACTOR,numberParameters,parameters)].setIntValue(models->factorizationFrequency());
    169     parameters[whichParam(MAXITERATION,numberParameters,parameters)].setIntValue(models->maximumIterations());
    170     parameters[whichParam(OUTPUTFORMAT,numberParameters,parameters)].setIntValue(outputFormat);
    171     parameters[whichParam(PRESOLVEPASS,numberParameters,parameters)].setIntValue(preSolve);
    172     parameters[whichParam(PERTVALUE,numberParameters,parameters)].setIntValue(models->perturbation());
    173     parameters[whichParam(PRIMALTOLERANCE,numberParameters,parameters)].setDoubleValue(models->primalTolerance());
    174     parameters[whichParam(PRIMALWEIGHT,numberParameters,parameters)].setDoubleValue(models->infeasibilityCost());
    175     parameters[whichParam(RESTORE,numberParameters,parameters)].setStringValue(restoreFile);
    176     parameters[whichParam(SAVE,numberParameters,parameters)].setStringValue(saveFile);
    177     parameters[whichParam(TIMELIMIT,numberParameters,parameters)].setDoubleValue(models->maximumSeconds());
    178     parameters[whichParam(SOLUTION,numberParameters,parameters)].setStringValue(solutionFile);
    179     parameters[whichParam(SAVESOL,numberParameters,parameters)].setStringValue(solutionSaveFile);
    180     parameters[whichParam(SPRINT,numberParameters,parameters)].setIntValue(doSprint);
    181     parameters[whichParam(SUBSTITUTION,numberParameters,parameters)].setIntValue(substitution);
    182     parameters[whichParam(DUALIZE,numberParameters,parameters)].setIntValue(dualize);
    183     parameters[whichParam(PRESOLVETOLERANCE,numberParameters,parameters)].setDoubleValue(1.0e-8);
     155    parameters[whichParam(CLP_PARAM_ACTION_BASISIN,numberParameters,parameters)].setStringValue(importBasisFile);
     156    parameters[whichParam(CLP_PARAM_ACTION_BASISOUT,numberParameters,parameters)].setStringValue(exportBasisFile);
     157    parameters[whichParam(CLP_PARAM_ACTION_PRINTMASK,numberParameters,parameters)].setStringValue(printMask);
     158    parameters[whichParam(CLP_PARAM_ACTION_DIRECTORY,numberParameters,parameters)].setStringValue(directory);
     159    parameters[whichParam(CLP_PARAM_ACTION_DIRSAMPLE,numberParameters,parameters)].setStringValue(dirSample);
     160    parameters[whichParam(CLP_PARAM_ACTION_DIRNETLIB,numberParameters,parameters)].setStringValue(dirNetlib);
     161    parameters[whichParam(CBC_PARAM_ACTION_DIRMIPLIB,numberParameters,parameters)].setStringValue(dirMiplib);
     162    parameters[whichParam(CLP_PARAM_DBL_DUALBOUND,numberParameters,parameters)].setDoubleValue(models->dualBound());
     163    parameters[whichParam(CLP_PARAM_DBL_DUALTOLERANCE,numberParameters,parameters)].setDoubleValue(models->dualTolerance());
     164    parameters[whichParam(CLP_PARAM_ACTION_EXPORT,numberParameters,parameters)].setStringValue(exportFile);
     165    parameters[whichParam(CLP_PARAM_INT_IDIOT,numberParameters,parameters)].setIntValue(doIdiot);
     166    parameters[whichParam(CLP_PARAM_ACTION_IMPORT,numberParameters,parameters)].setStringValue(importFile);
     167    parameters[whichParam(CLP_PARAM_INT_SOLVERLOGLEVEL,numberParameters,parameters)].setIntValue(models->logLevel());
     168    parameters[whichParam(CLP_PARAM_INT_MAXFACTOR,numberParameters,parameters)].setIntValue(models->factorizationFrequency());
     169    parameters[whichParam(CLP_PARAM_INT_MAXITERATION,numberParameters,parameters)].setIntValue(models->maximumIterations());
     170    parameters[whichParam(CLP_PARAM_INT_OUTPUTFORMAT,numberParameters,parameters)].setIntValue(outputFormat);
     171    parameters[whichParam(CLP_PARAM_INT_PRESOLVEPASS,numberParameters,parameters)].setIntValue(preSolve);
     172    parameters[whichParam(CLP_PARAM_INT_PERTVALUE,numberParameters,parameters)].setIntValue(models->perturbation());
     173    parameters[whichParam(CLP_PARAM_DBL_PRIMALTOLERANCE,numberParameters,parameters)].setDoubleValue(models->primalTolerance());
     174    parameters[whichParam(CLP_PARAM_DBL_PRIMALWEIGHT,numberParameters,parameters)].setDoubleValue(models->infeasibilityCost());
     175    parameters[whichParam(CLP_PARAM_ACTION_RESTORE,numberParameters,parameters)].setStringValue(restoreFile);
     176    parameters[whichParam(CLP_PARAM_ACTION_SAVE,numberParameters,parameters)].setStringValue(saveFile);
     177    parameters[whichParam(CLP_PARAM_DBL_TIMELIMIT,numberParameters,parameters)].setDoubleValue(models->maximumSeconds());
     178    parameters[whichParam(CLP_PARAM_ACTION_SOLUTION,numberParameters,parameters)].setStringValue(solutionFile);
     179    parameters[whichParam(CLP_PARAM_ACTION_SAVESOL,numberParameters,parameters)].setStringValue(solutionSaveFile);
     180    parameters[whichParam(CLP_PARAM_INT_SPRINT,numberParameters,parameters)].setIntValue(doSprint);
     181    parameters[whichParam(CLP_PARAM_INT_SUBSTITUTION,numberParameters,parameters)].setIntValue(substitution);
     182    parameters[whichParam(CLP_PARAM_INT_DUALIZE,numberParameters,parameters)].setIntValue(dualize);
     183    parameters[whichParam(CLP_PARAM_DBL_PRESOLVETOLERANCE,numberParameters,parameters)].setDoubleValue(1.0e-8);
    184184    int verbose=0;
    185185   
     
    191191    int choleskyType = 0;
    192192    int gamma=0;
    193     parameters[whichParam(BARRIERSCALE,numberParameters,parameters)].setCurrentOption(2);
     193    parameters[whichParam(CLP_PARAM_STR_BARRIERSCALE,numberParameters,parameters)].setCurrentOption(2);
    194194    int scaleBarrier=2;
    195195    int doKKT=0;
     
    273273        int valid;
    274274        numberGoodCommands++;
    275         if (type==GENERALQUERY) {
     275        if (type==CBC_PARAM_GENERALQUERY) {
    276276          std::cout<<"In argument list keywords have leading - "
    277277            ", -stdin or just - switches to stdin"<<std::endl;
     
    285285          bool evenHidden=false;
    286286          int printLevel =
    287             parameters[whichParam(ALLCOMMANDS,
     287            parameters[whichParam(CLP_PARAM_STR_ALLCOMMANDS,
    288288                                   numberParameters,parameters)].currentOptionAsInteger();
    289289          int convertP[]={2,1,0};
     
    352352              std::cout<<std::endl;
    353353          }
    354         } else if (type==FULLGENERALQUERY) {
     354        } else if (type==CBC_PARAM_FULLGENERALQUERY) {
    355355          std::cout<<"Full list of commands is:"<<std::endl;
    356356          int maxAcross=5;
     
    398398          int value = CoinReadGetIntField(argc,argv,&valid);
    399399          if (!valid) {
    400             if (parameters[iParam].type()==PRESOLVEPASS)
     400            if (parameters[iParam].type()==CLP_PARAM_INT_PRESOLVEPASS)
    401401              preSolve = value;
    402             else if (parameters[iParam].type()==IDIOT)
     402            else if (parameters[iParam].type()==CLP_PARAM_INT_IDIOT)
    403403              doIdiot = value;
    404             else if (parameters[iParam].type()==SPRINT)
     404            else if (parameters[iParam].type()==CLP_PARAM_INT_SPRINT)
    405405              doSprint = value;
    406             else if (parameters[iParam].type()==OUTPUTFORMAT)
     406            else if (parameters[iParam].type()==CLP_PARAM_INT_OUTPUTFORMAT)
    407407              outputFormat = value;
    408             else if (parameters[iParam].type()==SLPVALUE)
     408            else if (parameters[iParam].type()==CLP_PARAM_INT_SLPVALUE)
    409409              slpValue = value;
    410             else if (parameters[iParam].type()==CPP)
     410            else if (parameters[iParam].type()==CLP_PARAM_INT_CPP)
    411411              cppValue = value;
    412             else if (parameters[iParam].type()==PRESOLVEOPTIONS)
     412            else if (parameters[iParam].type()==CLP_PARAM_INT_PRESOLVEOPTIONS)
    413413              presolveOptions = value;
    414             else if (parameters[iParam].type()==PRINTOPTIONS)
     414            else if (parameters[iParam].type()==CLP_PARAM_INT_PRINTOPTIONS)
    415415              printOptions = value;
    416             else if (parameters[iParam].type()==SUBSTITUTION)
     416            else if (parameters[iParam].type()==CLP_PARAM_INT_SUBSTITUTION)
    417417              substitution = value;
    418             else if (parameters[iParam].type()==DUALIZE)
     418            else if (parameters[iParam].type()==CLP_PARAM_INT_DUALIZE)
    419419              dualize = value;
    420             else if (parameters[iParam].type()==VERBOSE)
     420            else if (parameters[iParam].type()==CLP_PARAM_INT_VERBOSE)
    421421              verbose = value;
    422422            parameters[iParam].setIntParameter(models+iModel,value);
     
    445445            // for now hard wired
    446446            switch (type) {
    447             case DIRECTION:
     447            case CLP_PARAM_STR_DIRECTION:
    448448              if (action==0)
    449449                models[iModel].setOptimizationDirection(1);
     
    453453                models[iModel].setOptimizationDirection(0);
    454454              break;
    455             case DUALPIVOT:
     455            case CLP_PARAM_STR_DUALPIVOT:
    456456              if (action==0) {
    457457                ClpDualRowSteepest steep(3);
     
    470470              }
    471471              break;
    472             case PRIMALPIVOT:
     472            case CLP_PARAM_STR_PRIMALPIVOT:
    473473              if (action==0) {
    474474                ClpPrimalColumnSteepest steep(3);
     
    494494              }
    495495              break;
    496             case SCALING:
     496            case CLP_PARAM_STR_SCALING:
    497497              models[iModel].scaling(action);
    498498              break;
    499             case AUTOSCALE:
     499            case CLP_PARAM_STR_AUTOSCALE:
    500500              models[iModel].setAutomaticScaling(action!=0);
    501501              break;
    502             case SPARSEFACTOR:
     502            case CLP_PARAM_STR_SPARSEFACTOR:
    503503              models[iModel].setSparseFactorization((1-action)!=0);
    504504              break;
    505             case BIASLU:
     505            case CLP_PARAM_STR_BIASLU:
    506506              models[iModel].factorization()->setBiasLU(action);
    507507              break;
    508             case PERTURBATION:
     508            case CLP_PARAM_STR_PERTURBATION:
    509509              if (action==0)
    510510                models[iModel].setPerturbation(50);
     
    512512                models[iModel].setPerturbation(100);
    513513              break;
    514             case ERRORSALLOWED:
     514            case CLP_PARAM_STR_ERRORSALLOWED:
    515515              allowImportErrors = action;
    516516              break;
    517             case INTPRINT:
     517            case CLP_PARAM_STR_INTPRINT:
    518518              printMode=action;
    519519              break;
    520             case KEEPNAMES:
     520            case CLP_PARAM_STR_KEEPNAMES:
    521521              keepImportNames = 1-action;
    522522              break;
    523             case PRESOLVE:
     523            case CLP_PARAM_STR_PRESOLVE:
    524524              if (action==0)
    525525                preSolve = 5;
     
    531531                preSolveFile=true;
    532532              break;
    533             case PFI:
     533            case CLP_PARAM_STR_PFI:
    534534              models[iModel].factorization()->setForrestTomlin(action==0);
    535535              break;
    536             case FACTORIZATION:
     536            case CLP_PARAM_STR_FACTORIZATION:
    537537              models[iModel].factorization()->forceOtherFactorization(action);
    538538              break;
    539             case CRASH:
     539            case CLP_PARAM_STR_CRASH:
    540540              doCrash=action;
    541541              break;
    542             case VECTOR:
     542            case CLP_PARAM_STR_VECTOR:
    543543              doVector=action;
    544544              break;
    545             case MESSAGES:
     545            case CLP_PARAM_STR_MESSAGES:
    546546              models[iModel].messageHandler()->setPrefix(action!=0);
    547547              break;
    548             case CHOLESKY:
     548            case CLP_PARAM_STR_CHOLESKY:
    549549              choleskyType = action;
    550550              break;
    551             case GAMMA:
     551            case CLP_PARAM_STR_GAMMA:
    552552              gamma=action;
    553553              break;
    554             case BARRIERSCALE:
     554            case CLP_PARAM_STR_BARRIERSCALE:
    555555              scaleBarrier=action;
    556556              break;
    557             case KKT:
     557            case CLP_PARAM_STR_KKT:
    558558              doKKT=action;
    559559              break;
    560             case CROSSOVER:
     560            case CLP_PARAM_STR_CROSSOVER:
    561561              crossover=action;
    562562              break;
     
    568568        } else {
    569569          // action
    570           if (type==EXIT)
     570          if (type==CLP_PARAM_ACTION_EXIT)
    571571            break; // stop all
    572572          switch (type) {
    573           case DUALSIMPLEX:
    574           case PRIMALSIMPLEX:
    575           case EITHERSIMPLEX:
    576           case BARRIER:
     573          case CLP_PARAM_ACTION_DUALSIMPLEX:
     574          case CLP_PARAM_ACTION_PRIMALSIMPLEX:
     575          case CLP_PARAM_ACTION_EITHERSIMPLEX:
     576          case CLP_PARAM_ACTION_BARRIER:
    577577            // synonym for dual
    578           case BAB:
     578          case CBC_PARAM_ACTION_BAB:
    579579            if (goodModels[iModel]) {
    580580              double objScale =
    581                 parameters[whichParam(OBJSCALE2,numberParameters,parameters)].doubleValue();
     581                parameters[whichParam(CLP_PARAM_DBL_OBJSCALE2,numberParameters,parameters)].doubleValue();
    582582              if (objScale!=1.0) {
    583583                int iColumn;
     
    658658              }
    659659              solveOptions.setPresolveType(presolveType,preSolve);
    660               if (type==DUALSIMPLEX||type==BAB) {
     660              if (type==CLP_PARAM_ACTION_DUALSIMPLEX ||
     661                          type==CBC_PARAM_ACTION_BAB) {
    661662                method=ClpSolve::useDual;
    662               } else if (type==PRIMALSIMPLEX) {
     663              } else if (type==CLP_PARAM_ACTION_PRIMALSIMPLEX) {
    663664                method=ClpSolve::usePrimalorSprint;
    664               } else if (type==EITHERSIMPLEX) {
     665              } else if (type==CLP_PARAM_ACTION_EITHERSIMPLEX) {
    665666                method=ClpSolve::automatic;
    666667              } else {
     
    758759              }
    759760#ifdef CLP_MULTIPLE_FACTORIZATIONS   
    760               int denseCode = parameters[whichParam(DENSE,numberParameters,parameters)].intValue();
     761              int denseCode = parameters[whichParam(CBC_PARAM_INT_DENSE,numberParameters,parameters)].intValue();
    761762              model2->factorization()->setGoDenseThreshold(denseCode);
    762               int smallCode = parameters[whichParam(SMALLFACT,numberParameters,parameters)].intValue();
     763              int smallCode = parameters[whichParam(CBC_PARAM_INT_SMALLFACT,numberParameters,parameters)].intValue();
    763764              model2->factorization()->setGoSmallThreshold(smallCode);
    764765              model2->factorization()->goDenseOrSmall(model2->numberRows());
     
    790791            }
    791792            break;
    792           case STATISTICS:
     793          case CLP_PARAM_ACTION_STATISTICS:
    793794            if (goodModels[iModel]) {
    794795              // If presolve on look at presolved
     
    804805                  pinfo.statistics();
    805806                double presolveTolerance =
    806                   parameters[whichParam(PRESOLVETOLERANCE,numberParameters,parameters)].doubleValue();
     807                  parameters[whichParam(CLP_PARAM_DBL_PRESOLVETOLERANCE,numberParameters,parameters)].doubleValue();
    807808                model2 =
    808809                  pinfo.presolvedModel(models[iModel],presolveTolerance,
     
    826827            }
    827828            break;
    828           case TIGHTEN:
     829          case CLP_PARAM_ACTION_TIGHTEN:
    829830            if (goodModels[iModel]) {
    830831              int numberInfeasibilities = models[iModel].tightenPrimalBounds();
     
    835836            }
    836837            break;
    837           case PLUSMINUS:
     838          case CLP_PARAM_ACTION_PLUSMINUS:
    838839            if (goodModels[iModel]) {
    839840              ClpMatrixBase * saveMatrix = models[iModel].clpMatrix();
     
    856857            }
    857858            break;
    858           case NETWORK:
     859          case CLP_PARAM_ACTION_NETWORK:
    859860            if (goodModels[iModel]) {
    860861              ClpMatrixBase * saveMatrix = models[iModel].clpMatrix();
     
    877878            }
    878879            break;
    879           case IMPORT:
     880          case CLP_PARAM_ACTION_IMPORT:
    880881            {
    881882              // get next field
     
    10011002            }
    10021003            break;
    1003           case EXPORT:
     1004          case CLP_PARAM_ACTION_EXPORT:
    10041005            if (goodModels[iModel]) {
    10051006              double objScale =
    1006                 parameters[whichParam(OBJSCALE2,numberParameters,parameters)].doubleValue();
     1007                parameters[whichParam(CLP_PARAM_DBL_OBJSCALE2,numberParameters,parameters)].doubleValue();
    10071008              if (objScale!=1.0) {
    10081009                int iColumn;
     
    10801081                    pinfo.statistics();
    10811082                  double presolveTolerance =
    1082                     parameters[whichParam(PRESOLVETOLERANCE,numberParameters,parameters)].doubleValue();
     1083                    parameters[whichParam(CLP_PARAM_DBL_PRESOLVETOLERANCE,numberParameters,parameters)].doubleValue();
    10831084                  model2 =
    10841085                    pinfo.presolvedModel(models[iModel],presolveTolerance,
     
    11771178            }
    11781179            break;
    1179           case BASISIN:
     1180          case CLP_PARAM_ACTION_BASISIN:
    11801181            if (goodModels[iModel]) {
    11811182              // get next field
     
    12301231            }
    12311232            break;
    1232           case PRINTMASK:
     1233          case CLP_PARAM_ACTION_PRINTMASK:
    12331234            // get next field
    12341235            {
     
    12421243            }
    12431244            break;
    1244           case BASISOUT:
     1245          case CLP_PARAM_ACTION_BASISOUT:
    12451246            if (goodModels[iModel]) {
    12461247              // get next field
     
    12891290            }
    12901291            break;
    1291           case SAVE:
     1292          case CLP_PARAM_ACTION_SAVE:
    12921293            {
    12931294              // get next field
     
    13331334                  ClpPresolve pinfo;
    13341335                  double presolveTolerance =
    1335                     parameters[whichParam(PRESOLVETOLERANCE,numberParameters,parameters)].doubleValue();
     1336                    parameters[whichParam(CLP_PARAM_DBL_PRESOLVETOLERANCE,numberParameters,parameters)].doubleValue();
    13361337                  model2 =
    13371338                    pinfo.presolvedModel(models[iModel],presolveTolerance,
     
    13671368            }
    13681369            break;
    1369           case RESTORE:
     1370          case CLP_PARAM_ACTION_RESTORE:
    13701371            {
    13711372              // get next field
     
    14171418            }
    14181419            break;
    1419           case MAXIMIZE:
     1420          case CLP_PARAM_ACTION_MAXIMIZE:
    14201421            models[iModel].setOptimizationDirection(-1);
    14211422            break;
    1422           case MINIMIZE:
     1423          case CLP_PARAM_ACTION_MINIMIZE:
    14231424            models[iModel].setOptimizationDirection(1);
    14241425            break;
    1425           case ALLSLACK:
     1426          case CLP_PARAM_ACTION_ALLSLACK:
    14261427            models[iModel].allSlackBasis(true);
    14271428            break;
    1428           case REVERSE:
     1429          case CLP_PARAM_ACTION_REVERSE:
    14291430            if (goodModels[iModel]) {
    14301431              int iColumn;
     
    14501451            }
    14511452            break;
    1452           case DIRECTORY:
     1453          case CLP_PARAM_ACTION_DIRECTORY:
    14531454            {
    14541455              std::string name = CoinReadGetString(argc,argv);
     
    14661467            }
    14671468            break;
    1468           case DIRSAMPLE:
     1469          case CLP_PARAM_ACTION_DIRSAMPLE:
    14691470            {
    14701471              std::string name = CoinReadGetString(argc,argv);
     
    14821483            }
    14831484            break;
    1484           case DIRNETLIB:
     1485          case CLP_PARAM_ACTION_DIRNETLIB:
    14851486            {
    14861487              std::string name = CoinReadGetString(argc,argv);
     
    14981499            }
    14991500            break;
    1500           case DIRMIPLIB:
     1501          case CBC_PARAM_ACTION_DIRMIPLIB:
    15011502            {
    15021503              std::string name = CoinReadGetString(argc,argv);
     
    15141515            }
    15151516            break;
    1516           case STDIN:
     1517          case CLP_PARAM_ACTION_STDIN:
    15171518            CbcOrClpRead_mode=-1;
    15181519            break;
    1519           case NETLIB_DUAL:
    1520           case NETLIB_EITHER:
    1521           case NETLIB_BARRIER:
    1522           case NETLIB_PRIMAL:
    1523           case NETLIB_TUNE:
     1520          case CLP_PARAM_ACTION_NETLIB_DUAL:
     1521          case CLP_PARAM_ACTION_NETLIB_EITHER:
     1522          case CLP_PARAM_ACTION_NETLIB_BARRIER:
     1523          case CLP_PARAM_ACTION_NETLIB_PRIMAL:
     1524          case CLP_PARAM_ACTION_NETLIB_TUNE:
    15241525            {
    15251526              // create fields for unitTest
     
    15351536              fields[3]="-netlib";
    15361537              int algorithm;
    1537               if (type==NETLIB_DUAL) {
     1538              if (type==CLP_PARAM_ACTION_NETLIB_DUAL) {
    15381539                std::cerr<<"Doing netlib with dual algorithm"<<std::endl;
    15391540                algorithm =0;
    1540               } else if (type==NETLIB_BARRIER) {
     1541              } else if (type==CLP_PARAM_ACTION_NETLIB_BARRIER) {
    15411542                std::cerr<<"Doing netlib with barrier algorithm"<<std::endl;
    15421543                algorithm =2;
    1543               } else if (type==NETLIB_EITHER) {
     1544              } else if (type==CLP_PARAM_ACTION_NETLIB_EITHER) {
    15441545                std::cerr<<"Doing netlib with dual or primal algorithm"<<std::endl;
    15451546                algorithm =3;
    1546               } else if (type==NETLIB_TUNE) {
     1547              } else if (type==CLP_PARAM_ACTION_NETLIB_TUNE) {
    15471548                std::cerr<<"Doing netlib with best algorithm!"<<std::endl;
    15481549                algorithm =5;
     
    15861587            }
    15871588            break;
    1588           case UNITTEST:
     1589          case CLP_PARAM_ACTION_UNITTEST:
    15891590            {
    15901591              // create fields for unitTest
     
    16111612            }
    16121613            break;
    1613           case FAKEBOUND:
     1614          case CLP_PARAM_ACTION_FAKEBOUND:
    16141615            if (goodModels[iModel]) {
    16151616              // get bound
     
    16491650            }
    16501651            break;
    1651           case REALLY_SCALE:
     1652          case CLP_PARAM_ACTION_REALLY_SCALE:
    16521653            if (goodModels[iModel]) {
    16531654              ClpSimplex newModel(models[iModel],
     
    16571658            }
    16581659            break;
    1659           case USERCLP:
     1660          case CLP_PARAM_ACTION_USERCLP:
    16601661            // Replace the sample code by whatever you want
    16611662            if (goodModels[iModel]) {
     
    16651666            }
    16661667            break;
    1667           case HELP:
     1668          case CLP_PARAM_ACTION_HELP:
    16681669            std::cout<<"Coin LP version "<<CLPVERSION
    16691670                     <<", build "<<__DATE__<<std::endl;
     
    16821683                    );
    16831684            break;
    1684           case SOLUTION:
     1685          case CLP_PARAM_ACTION_SOLUTION:
    16851686            if (goodModels[iModel]) {
    16861687              // get next field
     
    19461947         
    19471948            break;
    1948           case SAVESOL:
     1949          case CLP_PARAM_ACTION_SAVESOL:
    19491950            if (goodModels[iModel]) {
    19501951              // get next field
     
    19791980            }
    19801981            break;
    1981           case ENVIRONMENT:
     1982          case CLP_PARAM_ACTION_ENVIRONMENT:
    19821983            CbcOrClpEnvironmentIndex=0;
    19831984            break;
Note: See TracChangeset for help on using the changeset viewer.