Changeset 2389


Ignore:
Timestamp:
Feb 7, 2019 2:48:00 PM (3 months ago)
Author:
unxusr
Message:

store Cbc and Clp parameters in a vector to simplify code

Location:
trunk/Clp/src
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/Clp/src/CbcOrClpParam.cpp

    r2385 r2389  
    14891489  class CbcOrClpParam for details. Pulled from C..Main() for clarity.
    14901490*/
    1491 void establishParams(int &numberParameters, CbcOrClpParam *const parameters)
    1492 {
    1493   numberParameters = 0;
    1494   parameters[numberParameters++] = CbcOrClpParam("?", "For help", CBC_PARAM_GENERALQUERY, 7, 0);
    1495   parameters[numberParameters++] = CbcOrClpParam("???", "For help", CBC_PARAM_FULLGENERALQUERY, 7, 0);
    1496   parameters[numberParameters++] = CbcOrClpParam("-", "From stdin",
    1497     CLP_PARAM_ACTION_STDIN, 3, 0);
     1491void establishParams(std::vector< CbcOrClpParam > &parameters)
     1492{
     1493  parameters.clear();
     1494  parameters.push_back(CbcOrClpParam("?", "For help", CBC_PARAM_GENERALQUERY, 7, 0));
     1495  parameters.push_back(CbcOrClpParam("???", "For help", CBC_PARAM_FULLGENERALQUERY, 7, 0));
     1496  parameters.push_back(CbcOrClpParam("-", "From stdin", CLP_PARAM_ACTION_STDIN, 3, 0));
     1497
    14981498#if defined(ABC_INHERIT) || ABOCA_LITE
    1499   parameters[numberParameters++] = CbcOrClpParam("abc", "Whether to visit Aboca",
    1500     "off", CLP_PARAM_STR_ABCWANTED, 7, 0);
    1501   parameters[numberParameters - 1].append("one");
    1502   parameters[numberParameters - 1].append("two");
    1503   parameters[numberParameters - 1].append("three");
    1504   parameters[numberParameters - 1].append("four");
    1505   parameters[numberParameters - 1].append("five");
    1506   parameters[numberParameters - 1].append("six");
    1507   parameters[numberParameters - 1].append("seven");
    1508   parameters[numberParameters - 1].append("eight");
    1509   parameters[numberParameters - 1].append("on");
    1510   parameters[numberParameters - 1].append("decide");
    1511   parameters[numberParameters - 1].setFakeKeyWord(10);
    1512   parameters[numberParameters - 1].setLonghelp(
     1499  CbcOrClpParam paramAboca("abc", "Whether to visit Aboca", "off", CLP_PARAM_STR_ABCWANTED, 7, 0);
     1500  paramAboca.append("one");
     1501  paramAboca.append("two");
     1502  paramAboca.append("three");
     1503  paramAboca.append("four");
     1504  paramAboca.append("five");
     1505  paramAboca.append("six");
     1506  paramAboca.append("seven");
     1507  paramAboca.append("eight");
     1508  paramAboca.append("on");
     1509  paramAboca.append("decide");
     1510  paramAboca.setFakeKeyWord(10);
     1511  paramAboca.setLonghelp(
    15131512    "Decide whether to use A Basic Optimization Code (Accelerated?) \
    15141513and whether to try going parallel!");
    1515 #endif
    1516   parameters[numberParameters++] = CbcOrClpParam("allC!ommands", "Whether to print less used commands",
    1517     "no", CLP_PARAM_STR_ALLCOMMANDS);
    1518   parameters[numberParameters - 1].append("more");
    1519   parameters[numberParameters - 1].append("all");
    1520   parameters[numberParameters - 1].setLonghelp(
    1521     "For the sake of your sanity, only the more useful and simple commands \
     1514  parameters.push_back(paramAboca);
     1515#endif
     1516  {
     1517    CbcOrClpParam p("allC!ommands", "Whether to print less used commands",
     1518      "no", CLP_PARAM_STR_ALLCOMMANDS);
     1519
     1520    p.append("more");
     1521    p.append("all");
     1522    p.setLonghelp(
     1523      "For the sake of your sanity, only the more useful and simple commands \
    15221524are printed out on ?.");
    1523 #ifdef COIN_HAS_CBC
    1524   parameters[numberParameters++] = CbcOrClpParam("allow!ableGap", "Stop when gap between best possible and \
     1525    parameters.push_back(p);
     1526  }
     1527#ifdef COIN_HAS_CBC
     1528  {
     1529    CbcOrClpParam p("allow!ableGap", "Stop when gap between best possible and \
    15251530best less than this",
    1526     0.0, 1.0e20, CBC_PARAM_DBL_ALLOWABLEGAP);
    1527   parameters[numberParameters - 1].setDoubleValue(0.0);
    1528   parameters[numberParameters - 1].setLonghelp(
    1529     "If the gap between best solution and best possible solution is less than this \
     1531      0.0, 1.0e20, CBC_PARAM_DBL_ALLOWABLEGAP);
     1532    p.setDoubleValue(0.0);
     1533    p.setLonghelp(
     1534      "If the gap between best solution and best possible solution is less than this \
    15301535then the search will be terminated.  Also see ratioGap.");
     1536    parameters.push_back(p);
     1537  }
    15311538#endif
    15321539#ifdef COIN_HAS_CLP
    1533   parameters[numberParameters++] = CbcOrClpParam("allS!lack", "Set basis back to all slack and reset solution",
    1534     CLP_PARAM_ACTION_ALLSLACK, 3);
    1535   parameters[numberParameters - 1].setLonghelp(
    1536     "Mainly useful for tuning purposes.  Normally the first dual or primal will be using an all slack \
     1540  {
     1541    CbcOrClpParam p("allS!lack", "Set basis back to all slack and reset solution",
     1542      CLP_PARAM_ACTION_ALLSLACK, 3);
     1543    p.setLonghelp(
     1544      "Mainly useful for tuning purposes.  Normally the first dual or primal will be using an all slack \
    15371545basis anyway.");
    1538 #endif
    1539 #ifdef COIN_HAS_CBC
    1540   parameters[numberParameters++] = CbcOrClpParam("artif!icialCost", "Costs >= this treated as artificials in feasibility pump",
    1541     0.0, 1.0e100, CBC_PARAM_DBL_ARTIFICIALCOST, 1);
    1542   parameters[numberParameters - 1].setDoubleValue(0.0);
    1543   parameters[numberParameters - 1].setLonghelp(
    1544     "0.0 off - otherwise variables with costs >= this are treated as artificials and fixed to lower bound in feasibility pump");
     1546    parameters.push_back(p);
     1547  }
     1548#endif
     1549#ifdef COIN_HAS_CBC
     1550  {
     1551    CbcOrClpParam p("artif!icialCost", "Costs >= this treated as artificials in feasibility pump",
     1552      0.0, 1.0e100, CBC_PARAM_DBL_ARTIFICIALCOST, 1);
     1553    p.setDoubleValue(0.0);
     1554    p.setLonghelp(
     1555      "0.0 off - otherwise variables with costs >= this are treated as artificials and fixed to lower bound in feasibility pump");
     1556    parameters.push_back(p);
     1557  }
    15451558#endif
    15461559#ifdef COIN_HAS_CLP
    1547   parameters[numberParameters++] = CbcOrClpParam("auto!Scale", "Whether to scale objective, rhs and bounds of problem if they look odd",
    1548     "off", CLP_PARAM_STR_AUTOSCALE, 7, 0);
    1549   parameters[numberParameters - 1].append("on");
    1550   parameters[numberParameters - 1].setLonghelp(
    1551     "If you think you may get odd objective values or large equality rows etc then\
     1560  {
     1561    CbcOrClpParam p("auto!Scale", "Whether to scale objective, rhs and bounds of problem if they look odd",
     1562      "off", CLP_PARAM_STR_AUTOSCALE, 7, 0);
     1563    p.append("on");
     1564    p.setLonghelp(
     1565      "If you think you may get odd objective values or large equality rows etc then\
    15521566 it may be worth setting this true.  It is still experimental and you may prefer\
    15531567 to use objective!Scale and rhs!Scale.");
    1554   parameters[numberParameters++] = CbcOrClpParam("barr!ier", "Solve using primal dual predictor corrector algorithm",
    1555     CLP_PARAM_ACTION_BARRIER);
    1556   parameters[numberParameters - 1].setLonghelp(
    1557     "This command solves the current model using the  primal dual predictor \
     1568    parameters.push_back(p);
     1569  }
     1570  {
     1571    CbcOrClpParam p("barr!ier", "Solve using primal dual predictor corrector algorithm",
     1572      CLP_PARAM_ACTION_BARRIER);
     1573    p.setLonghelp(
     1574      "This command solves the current model using the  primal dual predictor \
    15581575corrector algorithm.  You may want to link in an alternative \
    15591576ordering and factorization.  It will also solve models \
    1560 with quadratic objectives."
    1561 
    1562   );
    1563   parameters[numberParameters++] = CbcOrClpParam("basisI!n", "Import basis from bas file",
    1564     CLP_PARAM_ACTION_BASISIN, 3);
    1565   parameters[numberParameters - 1].setLonghelp(
    1566     "This will read an MPS format basis file from the given file name.  It will use the default\
     1577with quadratic objectives.");
     1578    parameters.push_back(p);
     1579  }
     1580  {
     1581    CbcOrClpParam p("basisI!n", "Import basis from bas file",
     1582      CLP_PARAM_ACTION_BASISIN, 3);
     1583    p.setLonghelp(
     1584      "This will read an MPS format basis file from the given file name.  It will use the default\
    15671585 directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
    15681586 is initialized to '', i.e. it must be set.  If you have libz then it can read compressed\
    15691587 files 'xxxxxxxx.gz' or xxxxxxxx.bz2.");
    1570   parameters[numberParameters++] = CbcOrClpParam("basisO!ut", "Export basis as bas file",
    1571     CLP_PARAM_ACTION_BASISOUT);
    1572   parameters[numberParameters - 1].setLonghelp(
    1573     "This will write an MPS format basis file to the given file name.  It will use the default\
     1588    parameters.push_back(p);
     1589  }
     1590  {
     1591    CbcOrClpParam p("basisO!ut", "Export basis as bas file",
     1592      CLP_PARAM_ACTION_BASISOUT);
     1593
     1594    p.setLonghelp(
     1595      "This will write an MPS format basis file to the given file name.  It will use the default\
    15741596 directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
    15751597 is initialized to 'default.bas'.");
    1576   parameters[numberParameters++] = CbcOrClpParam("biasLU", "Whether factorization biased towards U",
    1577     "UU", CLP_PARAM_STR_BIASLU, 2, 0);
    1578   parameters[numberParameters - 1].append("UX");
    1579   parameters[numberParameters - 1].append("LX");
    1580   parameters[numberParameters - 1].append("LL");
    1581   parameters[numberParameters - 1].setCurrentOption("LX");
    1582 #endif
    1583 #ifdef COIN_HAS_CBC
    1584   parameters[numberParameters++] = CbcOrClpParam("branch!AndCut", "Do Branch and Cut",
    1585     CBC_PARAM_ACTION_BAB);
    1586   parameters[numberParameters - 1].setLonghelp(
    1587     "This does branch and cut.  There are many parameters which can affect the performance.  \
     1598    parameters.push_back(p);
     1599  }
     1600  {
     1601    CbcOrClpParam p("biasLU", "Whether factorization biased towards U",
     1602      "UU", CLP_PARAM_STR_BIASLU, 2, 0);
     1603
     1604    p.append("UX");
     1605    p.append("LX");
     1606    p.append("LL");
     1607    p.setCurrentOption("LX");
     1608    parameters.push_back(p);
     1609  }
     1610#endif
     1611#ifdef COIN_HAS_CBC
     1612  {
     1613    CbcOrClpParam p("branch!AndCut", "Do Branch and Cut",
     1614      CBC_PARAM_ACTION_BAB);
     1615    p.setLonghelp(
     1616      "This does branch and cut.  There are many parameters which can affect the performance.  \
    15881617First just try with default settings and look carefully at the log file.  Did cuts help?  Did they take too long?  \
    15891618Look at output to see which cuts were effective and then do some tuning.  You will see that the \
     
    16001629and trustPseudoCosts parameters.  If cuts did a good job, then you may wish to \
    16011630have more rounds of cuts - see passC!uts and passT!ree.");
    1602 #endif
    1603   parameters[numberParameters++] = CbcOrClpParam("bscale", "Whether to scale in barrier (and ordering speed)",
    1604     "off", CLP_PARAM_STR_BARRIERSCALE, 7, 0);
    1605   parameters[numberParameters - 1].append("on");
    1606   parameters[numberParameters - 1].append("off1");
    1607   parameters[numberParameters - 1].append("on1");
    1608   parameters[numberParameters - 1].append("off2");
    1609   parameters[numberParameters - 1].append("on2");
     1631    parameters.push_back(p);
     1632  }
     1633#endif
     1634  {
     1635    CbcOrClpParam p("bscale", "Whether to scale in barrier (and ordering speed)",
     1636      "off", CLP_PARAM_STR_BARRIERSCALE, 7, 0);
     1637    p.append("on");
     1638    p.append("off1");
     1639    p.append("on1");
     1640    p.append("off2");
     1641    p.append("on2");
     1642    parameters.push_back(p);
     1643  }
    16101644#if FLUSH_PRINT_BUFFER > 2
    1611   parameters[numberParameters++] = CbcOrClpParam("buff!eredMode", "Whether to flush print buffer",
    1612     "on", CLP_PARAM_STR_BUFFER_MODE);
    1613   parameters[numberParameters - 1].append("off");
    1614   parameters[numberParameters - 1].setLonghelp(
    1615     "Default is on, off switches on unbuffered output");
    1616   parameters[numberParameters - 1].setIntValue(0);
    1617 #endif
    1618   parameters[numberParameters++] = CbcOrClpParam("chol!esky", "Which cholesky algorithm",
    1619     "native", CLP_PARAM_STR_CHOLESKY, 7);
    1620   parameters[numberParameters - 1].append("dense");
    1621   //#ifdef FOREIGN_BARRIER
     1645  {
     1646    CbcOrClpParam p("buff!eredMode", "Whether to flush print buffer",
     1647      "on", CLP_PARAM_STR_BUFFER_MODE);
     1648
     1649    p.append("off");
     1650    p.setLonghelp(
     1651      "Default is on, off switches on unbuffered output");
     1652    p.setIntValue(0);
     1653    parameters.push_back(p);
     1654  }
     1655#endif
     1656  {
     1657    CbcOrClpParam p("chol!esky", "Which cholesky algorithm",
     1658      "native", CLP_PARAM_STR_CHOLESKY, 7);
     1659
     1660    p.append("dense");
     1661    //#ifdef FOREIGN_BARRIER
    16221662#ifdef COIN_HAS_WSMP
    1623   parameters[numberParameters - 1].append("fudge!Long");
    1624   parameters[numberParameters - 1].append("wssmp");
     1663    p.append("fudge!Long");
     1664    p.append("wssmp");
    16251665#else
    1626   parameters[numberParameters - 1].append("fudge!Long_dummy");
    1627   parameters[numberParameters - 1].append("wssmp_dummy");
     1666    p.append("fudge!Long_dummy");
     1667    p.append("wssmp_dummy");
    16281668#endif
    16291669#if defined(COIN_HAS_AMD) || defined(COIN_HAS_CHOLMOD) || defined(COIN_HAS_GLPK)
    1630   parameters[numberParameters - 1].append("Uni!versityOfFlorida");
     1670    p.append("Uni!versityOfFlorida");
    16311671#else
    1632   parameters[numberParameters - 1].append("Uni!versityOfFlorida_dummy");
     1672    p.append("Uni!versityOfFlorida_dummy");
    16331673#endif
    16341674#ifdef TAUCS_BARRIER
    1635   parameters[numberParameters - 1].append("Taucs");
     1675    p.append("Taucs");
    16361676#else
    1637   parameters[numberParameters - 1].append("Taucs_dummy");
     1677    p.append("Taucs_dummy");
    16381678#endif
    16391679#ifdef COIN_HAS_MUMPS
    1640   parameters[numberParameters - 1].append("Mumps");
     1680    p.append("Mumps");
    16411681#else
    1642   parameters[numberParameters - 1].append("Mumps_dummy");
     1682    p.append("Mumps_dummy");
    16431683#endif
    16441684#ifdef PARDISO_BARRIER
    1645   parameters[numberParameters - 1].append("Pardiso");
     1685    p.append("Pardiso");
    16461686#else
    1647   parameters[numberParameters - 1].append("Pardiso_dummy");
    1648 #endif
    1649   parameters[numberParameters - 1].setLonghelp(
    1650     "For a barrier code to be effective it needs a good Cholesky ordering and factorization.  \
     1687    p.append("Pardiso_dummy");
     1688#endif
     1689    p.setLonghelp(
     1690      "For a barrier code to be effective it needs a good Cholesky ordering and factorization.  \
    16511691The native ordering and factorization is not state of the art, although acceptable.  \
    16521692You may want to link in one from another source.  See Makefile.locations for some \
    16531693possibilities.");
    1654   //#endif
    1655 #ifdef COIN_HAS_CBC
    1656   parameters[numberParameters++] = CbcOrClpParam("clique!Cuts", "Whether to use Clique cuts",
    1657     "off", CBC_PARAM_STR_CLIQUECUTS);
    1658   parameters[numberParameters - 1].append("on");
    1659   parameters[numberParameters - 1].append("root");
    1660   parameters[numberParameters - 1].append("ifmove");
    1661   parameters[numberParameters - 1].append("forceOn");
    1662   parameters[numberParameters - 1].append("onglobal");
    1663   parameters[numberParameters - 1].setLonghelp(
    1664     "This switches on clique cuts (either at root or in entire tree) \
     1694
     1695    parameters.push_back(p);
     1696  }
     1697#ifdef COIN_HAS_CBC
     1698 {
     1699    CbcOrClpParam p("clique!Cuts", "Whether to use Clique cuts",
     1700      "off", CBC_PARAM_STR_CLIQUECUTS);
     1701    p.append("on");
     1702    p.append("root");
     1703    p.append("ifmove");
     1704    p.append("forceOn");
     1705    p.append("onglobal");
     1706    p.setLonghelp(
     1707      "This switches on clique cuts (either at root or in entire tree) \
    16651708See branchAndCut for information on options.");
    1666   parameters[numberParameters++] = CbcOrClpParam("combine!Solutions", "Whether to use combine solution heuristic",
    1667     "off", CBC_PARAM_STR_COMBINE);
    1668   parameters[numberParameters - 1].append("on");
    1669   parameters[numberParameters - 1].append("both");
    1670   parameters[numberParameters - 1].append("before");
    1671   parameters[numberParameters - 1].append("onquick");
    1672   parameters[numberParameters - 1].append("bothquick");
    1673   parameters[numberParameters - 1].append("beforequick");
    1674   parameters[numberParameters - 1].setLonghelp(
    1675     "This switches on a heuristic which does branch and cut on the problem given by just \
     1709
     1710    parameters.push_back(p);
     1711  }
     1712  {
     1713    CbcOrClpParam p("combine!Solutions", "Whether to use combine solution heuristic",
     1714      "off", CBC_PARAM_STR_COMBINE);
     1715
     1716    p.append("on");
     1717    p.append("both");
     1718    p.append("before");
     1719    p.append("onquick");
     1720    p.append("bothquick");
     1721    p.append("beforequick");
     1722    p.setLonghelp(
     1723      "This switches on a heuristic which does branch and cut on the problem given by just \
    16761724using variables which have appeared in one or more solutions. \
    16771725It obviously only tries after two or more solutions. \
    16781726See Rounding for meaning of on,both,before");
    1679   parameters[numberParameters++] = CbcOrClpParam("combine2!Solutions", "Whether to use crossover solution heuristic",
    1680     "off", CBC_PARAM_STR_CROSSOVER2);
    1681   parameters[numberParameters - 1].append("on");
    1682   parameters[numberParameters - 1].append("both");
    1683   parameters[numberParameters - 1].append("before");
    1684   parameters[numberParameters - 1].setLonghelp(
    1685     "This switches on a heuristic which does branch and cut on the problem given by \
     1727
     1728    parameters.push_back(p);
     1729  }
     1730  {
     1731    CbcOrClpParam p("combine2!Solutions", "Whether to use crossover solution heuristic",
     1732      "off", CBC_PARAM_STR_CROSSOVER2);
     1733    p.append("on");
     1734    p.append("both");
     1735    p.append("before");
     1736    p.setLonghelp(
     1737      "This switches on a heuristic which does branch and cut on the problem given by \
    16861738fixing variables which have same value in two or more solutions. \
    16871739It obviously only tries after two or more solutions. \
    16881740See Rounding for meaning of on,both,before");
    1689   parameters[numberParameters++] = CbcOrClpParam("constraint!fromCutoff", "Whether to use cutoff as constraint",
    1690     "off", CBC_PARAM_STR_CUTOFF_CONSTRAINT);
    1691   parameters[numberParameters - 1].append("on");
    1692   parameters[numberParameters - 1].append("variable");
    1693   parameters[numberParameters - 1].append("forcevariable");
    1694   parameters[numberParameters - 1].append("conflict");
    1695   parameters[numberParameters - 1].setLonghelp(
    1696     "This adds the objective as a constraint with best solution as RHS");
    1697   parameters[numberParameters++] = CbcOrClpParam("cost!Strategy", "How to use costs as priorities",
    1698     "off", CBC_PARAM_STR_COSTSTRATEGY);
    1699   parameters[numberParameters - 1].append("pri!orities");
    1700   parameters[numberParameters - 1].append("column!Order?");
    1701   parameters[numberParameters - 1].append("01f!irst?");
    1702   parameters[numberParameters - 1].append("01l!ast?");
    1703   parameters[numberParameters - 1].append("length!?");
    1704   parameters[numberParameters - 1].append("singletons");
    1705   parameters[numberParameters - 1].append("nonzero");
    1706   parameters[numberParameters - 1].append("general!Force?");
    1707   parameters[numberParameters - 1].setLonghelp(
    1708     "This orders the variables in order of their absolute costs - with largest cost ones being branched on \
     1741    parameters.push_back(p);
     1742  }
     1743  {
     1744    CbcOrClpParam p("constraint!fromCutoff", "Whether to use cutoff as constraint",
     1745      "off", CBC_PARAM_STR_CUTOFF_CONSTRAINT);
     1746
     1747    p.append("on");
     1748    p.append("variable");
     1749    p.append("forcevariable");
     1750    p.append("conflict");
     1751    p.setLonghelp(
     1752      "This adds the objective as a constraint with best solution as RHS");
     1753    parameters.push_back(p);
     1754  }
     1755  {
     1756    CbcOrClpParam p("cost!Strategy", "How to use costs as priorities",
     1757      "off", CBC_PARAM_STR_COSTSTRATEGY);
     1758
     1759    p.append("pri!orities");
     1760    p.append("column!Order?");
     1761    p.append("01f!irst?");
     1762    p.append("01l!ast?");
     1763    p.append("length!?");
     1764    p.append("singletons");
     1765    p.append("nonzero");
     1766    p.append("general!Force?");
     1767    p.setLonghelp(
     1768      "This orders the variables in order of their absolute costs - with largest cost ones being branched on \
    17091769first.  This primitive strategy can be surprsingly effective.  The column order\
    17101770 option is obviously not on costs but easy to code here.");
    1711   parameters[numberParameters++] = CbcOrClpParam("cplex!Use", "Whether to use Cplex!",
    1712     "off", CBC_PARAM_STR_CPX);
    1713   parameters[numberParameters - 1].append("on");
    1714   parameters[numberParameters - 1].setLonghelp(
    1715     " If the user has Cplex, but wants to use some of Cbc's heuristics \
     1771
     1772    parameters.push_back(p);
     1773  }
     1774  {
     1775    CbcOrClpParam p("cplex!Use", "Whether to use Cplex!",
     1776      "off", CBC_PARAM_STR_CPX);
     1777    p.append("on");
     1778    p.setLonghelp(
     1779      " If the user has Cplex, but wants to use some of Cbc's heuristics \
    17161780then you can!  If this is on, then Cbc will get to the root node and then \
    17171781hand over to Cplex.  If heuristics find a solution this can be significantly \
     
    17201784off preprocessing, although for difficult problems it is worth trying \
    17211785both.");
    1722 #endif
    1723   parameters[numberParameters++] = CbcOrClpParam("cpp!Generate", "Generates C++ code",
    1724     -1, 50000, CLP_PARAM_INT_CPP, 1);
    1725   parameters[numberParameters - 1].setLonghelp(
    1726     "Once you like what the stand-alone solver does then this allows \
     1786    parameters.push_back(p);
     1787  }
     1788#endif
     1789  {
     1790    CbcOrClpParam p("cpp!Generate", "Generates C++ code",
     1791      -1, 50000, CLP_PARAM_INT_CPP, 1);
     1792    p.setLonghelp(
     1793      "Once you like what the stand-alone solver does then this allows \
    17271794you to generate user_driver.cpp which approximates the code.  \
    172817950 gives simplest driver, 1 generates saves and restores, 2 \
     
    17311798This is now deprecated as you can call stand-alone solver - see \
    17321799Cbc/examples/driver4.cpp.");
     1800    parameters.push_back(p);
     1801  }
    17331802#ifdef COIN_HAS_CLP
    1734   parameters[numberParameters++] = CbcOrClpParam("crash", "Whether to create basis for problem",
    1735     "off", CLP_PARAM_STR_CRASH);
    1736   parameters[numberParameters - 1].append("on");
    1737   parameters[numberParameters - 1].append("so!low_halim");
    1738   parameters[numberParameters - 1].append("lots");
     1803  {
     1804    CbcOrClpParam p("crash", "Whether to create basis for problem",
     1805      "off", CLP_PARAM_STR_CRASH);
     1806
     1807    p.append("on");
     1808    p.append("so!low_halim");
     1809    p.append("lots");
    17391810#ifdef CLP_INHERIT_MODE
    1740   parameters[numberParameters - 1].append("dual");
    1741   parameters[numberParameters - 1].append("dw");
    1742   parameters[numberParameters - 1].append("idiot");
     1811    p.append("dual");
     1812    p.append("dw");
     1813    p.append("idiot");
    17431814#else
    1744   parameters[numberParameters - 1].append("idiot1");
    1745   parameters[numberParameters - 1].append("idiot2");
    1746   parameters[numberParameters - 1].append("idiot3");
    1747   parameters[numberParameters - 1].append("idiot4");
    1748   parameters[numberParameters - 1].append("idiot5");
    1749   parameters[numberParameters - 1].append("idiot6");
    1750   parameters[numberParameters - 1].append("idiot7");
    1751 #endif
    1752   parameters[numberParameters - 1].setLonghelp(
    1753     "If crash is set on and there is an all slack basis then Clp will flip or put structural\
    1754  variables into basis with the aim of getting dual feasible.  On the whole dual seems to be\
    1755  better without it and there are alternative types of 'crash' for primal e.g. 'idiot' or 'sprint'. \
    1756 I have also added a variant due to Solow and Halim which is as on but just flip.");
    1757   parameters[numberParameters++] = CbcOrClpParam("cross!over", "Whether to get a basic solution after barrier",
    1758     "on", CLP_PARAM_STR_CROSSOVER);
    1759   parameters[numberParameters - 1].append("off");
    1760   parameters[numberParameters - 1].append("maybe");
    1761   parameters[numberParameters - 1].append("presolve");
    1762   parameters[numberParameters - 1].setLonghelp(
    1763     "Interior point algorithms do not obtain a basic solution (and \
     1815    p.append("idiot1");
     1816    p.append("idiot2");
     1817    p.append("idiot3");
     1818    p.append("idiot4");
     1819    p.append("idiot5");
     1820    p.append("idiot6");
     1821    p.append("idiot7");
     1822#endif
     1823    p.setLonghelp(
     1824      "If crash is set on and there is an all slack basis then Clp will flip or put structural\
     1825     variables into basis with the aim of getting dual feasible.  On the whole dual seems to be\
     1826     better without it and there are alternative types of 'crash' for primal e.g. 'idiot' or 'sprint'. \
     1827    I have also added a variant due to Solow and Halim which is as on but just flip.");
     1828
     1829    parameters.push_back(p);
     1830  }
     1831  {
     1832    CbcOrClpParam p("cross!over", "Whether to get a basic solution after barrier",
     1833      "on", CLP_PARAM_STR_CROSSOVER);
     1834    p.append("off");
     1835    p.append("maybe");
     1836    p.append("presolve");
     1837    p.setLonghelp(
     1838      "Interior point algorithms do not obtain a basic solution (and \
    17641839the feasibility criterion is a bit suspect (JJF)).  This option will crossover \
    17651840to a basic solution suitable for ranging or branch and cut.  With the current state \
    17661841of quadratic it may be a good idea to switch off crossover for quadratic (and maybe \
    17671842presolve as well) - the option maybe does this.");
    1768 #endif
    1769 #ifdef COIN_HAS_CBC
    1770   parameters[numberParameters++] = CbcOrClpParam("csv!Statistics", "Create one line of statistics",
    1771     CLP_PARAM_ACTION_CSVSTATISTICS, 2, 1);
    1772   parameters[numberParameters - 1].setLonghelp(
    1773     "This appends statistics to given file name.  It will use the default\
     1843    parameters.push_back(p);
     1844  }
     1845#endif
     1846#ifdef COIN_HAS_CBC
     1847  {
     1848    CbcOrClpParam p("csv!Statistics", "Create one line of statistics",
     1849      CLP_PARAM_ACTION_CSVSTATISTICS, 2, 1);
     1850    p.setLonghelp(
     1851      "This appends statistics to given file name.  It will use the default\
    17741852 directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
    17751853 is initialized to '', i.e. it must be set.  Adds header if file empty or does not exist.");
    1776   parameters[numberParameters++] = CbcOrClpParam("cutD!epth", "Depth in tree at which to do cuts",
    1777     -1, 999999, CBC_PARAM_INT_CUTDEPTH);
    1778   parameters[numberParameters - 1].setLonghelp(
    1779     "Cut generators may be - off, on only at root, on if they look possible \
     1854    parameters.push_back(p);
     1855  }
     1856  {
     1857    CbcOrClpParam p("cutD!epth", "Depth in tree at which to do cuts",
     1858      -1, 999999, CBC_PARAM_INT_CUTDEPTH);
     1859    p.setLonghelp(
     1860      "Cut generators may be - off, on only at root, on if they look possible \
    17801861and on.  If they are done every node then that is that, but it may be worth doing them \
    17811862every so often.  The original method was every so many nodes but it is more logical \
    17821863to do it whenever depth in tree is a multiple of K.  This option does that and defaults \
    17831864to -1 (off -> code decides).");
    1784   parameters[numberParameters - 1].setIntValue(-1);
    1785   parameters[numberParameters++] = CbcOrClpParam("cutL!ength", "Length of a cut",
    1786     -1, COIN_INT_MAX, CBC_PARAM_INT_CUTLENGTH);
    1787   parameters[numberParameters - 1].setLonghelp(
    1788     "At present this only applies to Gomory cuts. -1 (default) leaves as is. \
     1865    p.setIntValue(-1);
     1866    parameters.push_back(p);
     1867  }
     1868  {
     1869    CbcOrClpParam p("cutL!ength", "Length of a cut",
     1870      -1, COIN_INT_MAX, CBC_PARAM_INT_CUTLENGTH);
     1871    p.setLonghelp("At present this only applies to Gomory cuts. -1 (default) leaves as is. \
    17891872Any value >0 says that all cuts <= this length can be generated both at \
    17901873root node and in tree. 0 says to use some dynamic lengths.  If value >=10,000,000 \
    17911874then the length in tree is value%10000000 - so 10000100 means unlimited length \
    17921875at root and 100 in tree.");
    1793   parameters[numberParameters - 1].setIntValue(-1);
    1794   parameters[numberParameters++] = CbcOrClpParam("cuto!ff", "All solutions must be better than this",
    1795     -1.0e60, 1.0e60, CBC_PARAM_DBL_CUTOFF);
    1796   parameters[numberParameters - 1].setDoubleValue(1.0e50);
    1797   parameters[numberParameters - 1].setLonghelp(
    1798     "All solutions must be better than this value (in a minimization sense).  \
     1876    p.setIntValue(-1);
     1877    parameters.push_back(p);
     1878  }
     1879  {
     1880    CbcOrClpParam p("cuto!ff", "All solutions must be better than this",
     1881      -1.0e60, 1.0e60, CBC_PARAM_DBL_CUTOFF);
     1882    p.setDoubleValue(1.0e50);
     1883    p.setLonghelp(
     1884      "All solutions must be better than this value (in a minimization sense).  \
    17991885This is also set by code whenever it obtains a solution and is set to value of \
    18001886objective for solution minus cutoff increment.");
    1801   parameters[numberParameters++] = CbcOrClpParam("cuts!OnOff", "Switches all cuts on or off",
    1802     "off", CBC_PARAM_STR_CUTSSTRATEGY);
    1803   parameters[numberParameters - 1].append("on");
    1804   parameters[numberParameters - 1].append("root");
    1805   parameters[numberParameters - 1].append("ifmove");
    1806   parameters[numberParameters - 1].append("forceOn");
    1807   parameters[numberParameters - 1].setLonghelp(
    1808     "This can be used to switch on or off all cuts (apart from Reduce and Split).  Then you can do \
     1887    parameters.push_back(p);
     1888  }
     1889  {
     1890    CbcOrClpParam p("cuts!OnOff", "Switches all cuts on or off",
     1891      "off", CBC_PARAM_STR_CUTSSTRATEGY);
     1892    p.append("on");
     1893    p.append("root");
     1894    p.append("ifmove");
     1895    p.append("forceOn");
     1896    p.setLonghelp(
     1897      "This can be used to switch on or off all cuts (apart from Reduce and Split).  Then you can do \
    18091898individual ones off or on \
    18101899See branchAndCut for information on options.");
    1811   parameters[numberParameters++] = CbcOrClpParam("debug!In", "read valid solution from file",
    1812     CLP_PARAM_ACTION_DEBUG, 7, 1);
    1813   parameters[numberParameters - 1].setLonghelp(
    1814     "This will read a solution file from the given file name.  It will use the default\
     1900    parameters.push_back(p);
     1901  }
     1902  {
     1903    CbcOrClpParam p("debug!In", "read valid solution from file",
     1904      CLP_PARAM_ACTION_DEBUG, 7, 1);
     1905
     1906    p.setLonghelp(
     1907      "This will read a solution file from the given file name.  It will use the default\
    18151908 directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
    18161909 is initialized to '', i.e. it must be set.\n\n\
     
    18191912you can do a good run with debug set to 'create' and then switch on the cuts you suspect and \
    18201913re-run with debug set to 'debug.file'  The create case has same effect as saveSolution.");
     1914    parameters.push_back(p);
     1915  }
    18211916#endif
    18221917#ifdef COIN_HAS_CLP
    1823   parameters[numberParameters++] = CbcOrClpParam("decomp!ose", "Whether to try decomposition",
    1824     -COIN_INT_MAX, COIN_INT_MAX, CLP_PARAM_INT_DECOMPOSE_BLOCKS, 1);
    1825   parameters[numberParameters - 1].setLonghelp(
    1826     "0 - off, 1 choose blocks >1 use as blocks \
     1918  {
     1919    CbcOrClpParam p("decomp!ose", "Whether to try decomposition",
     1920      -COIN_INT_MAX, COIN_INT_MAX, CLP_PARAM_INT_DECOMPOSE_BLOCKS, 1);
     1921    p.setLonghelp(
     1922      "0 - off, 1 choose blocks >1 use as blocks \
    18271923Dantzig Wolfe if primal, Benders if dual \
    18281924- uses sprint pass for number of passes");
    1829   parameters[numberParameters - 1].setIntValue(0);
     1925    p.setIntValue(0);
     1926    parameters.push_back(p);
     1927  }
    18301928#if CLP_MULTIPLE_FACTORIZATIONS > 0
    1831   parameters[numberParameters++] = CbcOrClpParam("dense!Threshold", "Whether to use dense factorization",
    1832     -1, 10000, CBC_PARAM_INT_DENSE, 1);
    1833   parameters[numberParameters - 1].setLonghelp(
    1834     "If processed problem <= this use dense factorization");
    1835   parameters[numberParameters - 1].setIntValue(-1);
    1836 #endif
    1837 #endif
    1838 #ifdef COIN_HAS_CBC
    1839   parameters[numberParameters++] = CbcOrClpParam("depth!MiniBab", "Depth at which to try mini BAB",
    1840     -COIN_INT_MAX, COIN_INT_MAX, CBC_PARAM_INT_DEPTHMINIBAB);
    1841   parameters[numberParameters - 1].setIntValue(-1);
    1842   parameters[numberParameters - 1].setLonghelp(
    1843     "Rather a complicated parameter but can be useful. -1 means off for large problems but on as if -12 for problems where rows+columns<500, -2 \
    1844 means use Cplex if it is linked in.  Otherwise if negative then go into depth first complete search fast branch and bound when depth>= -value-2 (so -3 will use this at depth>=1).  This mode is only switched on after 500 nodes.  If you really want to switch it off for small problems then set this to -999.  If >=0 the value doesn't matter very much.  The code will do approximately 100 nodes of fast branch and bound every now and then at depth>=5.  The actual logic is too twisted to describe here.");
    1845   parameters[numberParameters++] = CbcOrClpParam("dextra3", "Extra double parameter 3",
    1846     -1.0e100, 1.0e100, CBC_PARAM_DBL_DEXTRA3, 0);
    1847   parameters[numberParameters - 1].setDoubleValue(0.0);
    1848   parameters[numberParameters++] = CbcOrClpParam("dextra4", "Extra double parameter 4",
    1849     -1.0e100, 1.0e100, CBC_PARAM_DBL_DEXTRA4, 0);
    1850   parameters[numberParameters - 1].setDoubleValue(0.0);
    1851   parameters[numberParameters++] = CbcOrClpParam("dextra5", "Extra double parameter 5",
    1852     -1.0e100, 1.0e100, CBC_PARAM_DBL_DEXTRA5, 0);
    1853   parameters[numberParameters - 1].setDoubleValue(0.0);
    1854   parameters[numberParameters++] = CbcOrClpParam("Dins", "Whether to try Distance Induced Neighborhood Search",
    1855     "off", CBC_PARAM_STR_DINS);
    1856   parameters[numberParameters - 1].append("on");
    1857   parameters[numberParameters - 1].append("both");
    1858   parameters[numberParameters - 1].append("before");
    1859   parameters[numberParameters - 1].append("often");
    1860   parameters[numberParameters - 1].setLonghelp(
    1861     "This switches on Distance induced neighborhood Search. \
     1929  {
     1930    CbcOrClpParam p("dense!Threshold", "Whether to use dense factorization",
     1931      -1, 10000, CBC_PARAM_INT_DENSE, 1);
     1932    p.setLonghelp(
     1933      "If processed problem <= this use dense factorization");
     1934    p.setIntValue(-1);
     1935    parameters.push_back(p);
     1936  }
     1937#endif
     1938#endif
     1939#ifdef COIN_HAS_CBC
     1940  {
     1941    CbcOrClpParam p("depth!MiniBab", "Depth at which to try mini BAB",
     1942      -COIN_INT_MAX, COIN_INT_MAX, CBC_PARAM_INT_DEPTHMINIBAB);
     1943
     1944    p.setIntValue(-1);
     1945    p.setLonghelp(
     1946      "Rather a complicated parameter but can be useful. -1 means off for large problems but on as if -12 for problems where rows+columns<500, -2 \
     1947means use Cplex if it is linked in.  Otherwise if negative then go into depth first complete search fast branch and bound when depth>= -value-2 \
     1948(so -3 will use this at depth>=1).  This mode is only switched on after 500 nodes.  If you really want to switch it off for small problems then set \
     1949this to -999.  If >=0 the value doesn't matter very much.  The code will do approximately 100 nodes of fast branch and bound every now and then at depth>=5.  \
     1950The actual logic is too twisted to describe here.");
     1951    parameters.push_back(p);
     1952  }
     1953  {
     1954    CbcOrClpParam p("dextra3", "Extra double parameter 3",
     1955      -1.0e100, 1.0e100, CBC_PARAM_DBL_DEXTRA3, 0);
     1956    p.setDoubleValue(0.0);
     1957    parameters.push_back(p);
     1958  }
     1959  {
     1960    CbcOrClpParam p("dextra4", "Extra double parameter 4",
     1961      -1.0e100, 1.0e100, CBC_PARAM_DBL_DEXTRA4, 0);
     1962    p.setDoubleValue(0.0);
     1963    parameters.push_back(p);
     1964  }
     1965  {
     1966    CbcOrClpParam p("dextra4", "Extra double parameter 5",
     1967      -1.0e100, 1.0e100, CBC_PARAM_DBL_DEXTRA5, 0);
     1968    p.setDoubleValue(0.0);
     1969    parameters.push_back(p);
     1970  }
     1971  {
     1972    CbcOrClpParam p("Dins", "Whether to try Distance Induced Neighborhood Search",
     1973      "off", CBC_PARAM_STR_DINS);
     1974
     1975    p.append("on");
     1976    p.append("both");
     1977    p.append("before");
     1978    p.append("often");
     1979    p.setLonghelp(
     1980      "This switches on Distance induced neighborhood Search. \
    18621981See Rounding for meaning of on,both,before");
    1863 #endif
    1864   parameters[numberParameters++] = CbcOrClpParam("direction", "Minimize or Maximize",
    1865     "min!imize", CLP_PARAM_STR_DIRECTION);
    1866   parameters[numberParameters - 1].append("max!imize");
    1867   parameters[numberParameters - 1].append("zero");
    1868   parameters[numberParameters - 1].setLonghelp(
    1869     "The default is minimize - use 'direction maximize' for maximization.\n\
     1982    parameters.push_back(p);
     1983  }
     1984#endif
     1985  {
     1986    CbcOrClpParam p("direction", "Minimize or Maximize",
     1987      "min!imize", CLP_PARAM_STR_DIRECTION);
     1988    p.append("max!imize");
     1989    p.append("zero");
     1990    p.setLonghelp(
     1991      "The default is minimize - use 'direction maximize' for maximization.\n\
    18701992You can also use the parameters 'maximize' or 'minimize'.");
    1871   parameters[numberParameters++] = CbcOrClpParam("directory", "Set Default directory for import etc.",
    1872     CLP_PARAM_ACTION_DIRECTORY);
    1873   parameters[numberParameters - 1].setLonghelp(
    1874     "This sets the directory which import, export, saveModel, restoreModel etc will use.\
     1993    parameters.push_back(p);
     1994  }
     1995  {
     1996    CbcOrClpParam p("directory", "Set Default directory for import etc.",
     1997      CLP_PARAM_ACTION_DIRECTORY);
     1998    p.setLonghelp(
     1999      "This sets the directory which import, export, saveModel, restoreModel etc will use.\
    18752000  It is initialized to './'");
    1876   parameters[numberParameters++] = CbcOrClpParam("dirSample", "Set directory where the COIN-OR sample problems are.",
    1877     CLP_PARAM_ACTION_DIRSAMPLE, 7, 1);
    1878   parameters[numberParameters - 1].setLonghelp(
    1879     "This sets the directory where the COIN-OR sample problems reside. It is\
     2001    parameters.push_back(p);
     2002  }
     2003  {
     2004    CbcOrClpParam p("dirSample", "Set directory where the COIN-OR sample problems are.",
     2005      CLP_PARAM_ACTION_DIRSAMPLE, 7, 1);
     2006
     2007    p.setLonghelp(
     2008      "This sets the directory where the COIN-OR sample problems reside. It is\
    18802009 used only when -unitTest is passed to clp. clp will pick up the test problems\
    18812010 from this directory.\
    18822011 It is initialized to '../../Data/Sample'");
    1883   parameters[numberParameters++] = CbcOrClpParam("dirNetlib", "Set directory where the netlib problems are.",
    1884     CLP_PARAM_ACTION_DIRNETLIB, 7, 1);
    1885   parameters[numberParameters - 1].setLonghelp(
    1886     "This sets the directory where the netlib problems reside. One can get\
     2012    parameters.push_back(p);
     2013  }
     2014  {
     2015    CbcOrClpParam p("dirNetlib", "Set directory where the netlib problems are.",
     2016      CLP_PARAM_ACTION_DIRNETLIB, 7, 1);
     2017
     2018    p.setLonghelp(
     2019      "This sets the directory where the netlib problems reside. One can get\
    18872020 the netlib problems from COIN-OR or from the main netlib site. This\
    18882021 parameter is used only when -netlib is passed to clp. clp will pick up the\
     
    18902023 then the problems must be uncompressed.\
    18912024 It is initialized to '../../Data/Netlib'");
    1892   parameters[numberParameters++] = CbcOrClpParam("dirMiplib", "Set directory where the miplib 2003 problems are.",
    1893     CBC_PARAM_ACTION_DIRMIPLIB, 7, 1);
    1894   parameters[numberParameters - 1].setLonghelp(
    1895     "This sets the directory where the miplib 2003 problems reside. One can\
     2025    parameters.push_back(p);
     2026  }
     2027  {
     2028    CbcOrClpParam p("dirMiplib", "Set directory where the miplib 2003 problems are.",
     2029      CBC_PARAM_ACTION_DIRMIPLIB, 7, 1);
     2030
     2031    p.setLonghelp(
     2032      "This sets the directory where the miplib 2003 problems reside. One can\
    18962033 get the miplib problems from COIN-OR or from the main miplib site. This\
    18972034 parameter is used only when -miplib is passed to cbc. cbc will pick up the\
     
    18992036 then the problems must be uncompressed.\
    19002037 It is initialized to '../../Data/miplib3'");
    1901 #ifdef COIN_HAS_CBC
    1902   parameters[numberParameters++] = CbcOrClpParam("diveO!pt", "Diving options",
    1903     -1, 200000, CBC_PARAM_INT_DIVEOPT, 1);
    1904   parameters[numberParameters - 1].setLonghelp(
    1905     "If >2 && <20 then modify diving options - \
     2038    parameters.push_back(p);
     2039  }
     2040#ifdef COIN_HAS_CBC
     2041  {
     2042    CbcOrClpParam p("diveO!pt", "Diving options",
     2043      -1, 200000, CBC_PARAM_INT_DIVEOPT, 1);
     2044    p.setLonghelp(
     2045      "If >2 && <20 then modify diving options - \
    19062046         \n\t3 only at root and if no solution,  \
    19072047         \n\t4 only at root and if this heuristic has not got solution, \
     
    19112051         \n\t>10 All only at root (DivingC normal as value-10), \
    19122052         \n\t>20 All with value-20).");
    1913   parameters[numberParameters - 1].setIntValue(-1);
    1914   parameters[numberParameters++] = CbcOrClpParam("diveS!olves", "Diving solve option",
    1915     -1, 200000, CBC_PARAM_INT_DIVEOPTSOLVES, 1);
    1916   parameters[numberParameters - 1].setLonghelp(
    1917     "If >0 then do up to this many solves.  Last digit is ignored \
     2053    p.setIntValue(-1);
     2054    parameters.push_back(p);
     2055  }
     2056  {
     2057    CbcOrClpParam p("diveS!olves", "Diving solve option",
     2058      -1, 200000, CBC_PARAM_INT_DIVEOPTSOLVES, 1);
     2059
     2060    p.setLonghelp(
     2061      "If >0 then do up to this many solves.  Last digit is ignored \
    19182062and used for extra options - \
    19192063         \n\t1-3 allow fixing of satisfied integers (but not at bound) \
    19202064         \n\t1 switch off above for that dive if goes infeasible \
    19212065         \n\t2 switch off above permanently if goes infeasible");
    1922   parameters[numberParameters - 1].setIntValue(100);
    1923   parameters[numberParameters++] = CbcOrClpParam("DivingS!ome", "Whether to try Diving heuristics",
    1924     "off", CBC_PARAM_STR_DIVINGS);
    1925   parameters[numberParameters - 1].append("on");
    1926   parameters[numberParameters - 1].append("both");
    1927   parameters[numberParameters - 1].append("before");
    1928   parameters[numberParameters - 1].setLonghelp(
    1929     "This switches on a random diving heuristic at various times. \
     2066    p.setIntValue(100);
     2067    parameters.push_back(p);
     2068  }
     2069  {
     2070    CbcOrClpParam p("DivingS!ome", "Whether to try Diving heuristics",
     2071      "off", CBC_PARAM_STR_DIVINGS);
     2072
     2073    p.append("on");
     2074    p.append("both");
     2075    p.append("before");
     2076    p.setLonghelp(
     2077      "This switches on a random diving heuristic at various times. \
    19302078C - Coefficient, F - Fractional, G - Guided, L - LineSearch, P - PseudoCost, V - VectorLength. \
    19312079You may prefer to use individual on/off \
    19322080See Rounding for meaning of on,both,before");
    1933   parameters[numberParameters++] = CbcOrClpParam("DivingC!oefficient", "Whether to try DiveCoefficient",
    1934     "off", CBC_PARAM_STR_DIVINGC);
    1935   parameters[numberParameters - 1].append("on");
    1936   parameters[numberParameters - 1].append("both");
    1937   parameters[numberParameters - 1].append("before");
    1938   parameters[numberParameters++] = CbcOrClpParam("DivingF!ractional", "Whether to try DiveFractional",
    1939     "off", CBC_PARAM_STR_DIVINGF);
    1940   parameters[numberParameters - 1].append("on");
    1941   parameters[numberParameters - 1].append("both");
    1942   parameters[numberParameters - 1].append("before");
    1943   parameters[numberParameters++] = CbcOrClpParam("DivingG!uided", "Whether to try DiveGuided",
    1944     "off", CBC_PARAM_STR_DIVINGG);
    1945   parameters[numberParameters - 1].append("on");
    1946   parameters[numberParameters - 1].append("both");
    1947   parameters[numberParameters - 1].append("before");
    1948   parameters[numberParameters++] = CbcOrClpParam("DivingL!ineSearch", "Whether to try DiveLineSearch",
    1949     "off", CBC_PARAM_STR_DIVINGL);
    1950   parameters[numberParameters - 1].append("on");
    1951   parameters[numberParameters - 1].append("both");
    1952   parameters[numberParameters - 1].append("before");
    1953   parameters[numberParameters++] = CbcOrClpParam("DivingP!seudoCost", "Whether to try DivePseudoCost",
    1954     "off", CBC_PARAM_STR_DIVINGP);
    1955   parameters[numberParameters - 1].append("on");
    1956   parameters[numberParameters - 1].append("both");
    1957   parameters[numberParameters - 1].append("before");
    1958   parameters[numberParameters++] = CbcOrClpParam("DivingV!ectorLength", "Whether to try DiveVectorLength",
    1959     "off", CBC_PARAM_STR_DIVINGV);
    1960   parameters[numberParameters - 1].append("on");
    1961   parameters[numberParameters - 1].append("both");
    1962   parameters[numberParameters - 1].append("before");
    1963   parameters[numberParameters++] = CbcOrClpParam("doH!euristic", "Do heuristics before any preprocessing",
    1964     CBC_PARAM_ACTION_DOHEURISTIC, 3);
    1965   parameters[numberParameters - 1].setLonghelp(
    1966     "Normally heuristics are done in branch and bound.  It may be useful to do them outside. \
     2081    parameters.push_back(p);
     2082  }
     2083  {
     2084    CbcOrClpParam p("DivingC!oefficient", "Whether to try DiveCoefficient",
     2085      "off", CBC_PARAM_STR_DIVINGC);
     2086    p.append("on");
     2087    p.append("both");
     2088    p.append("before");
     2089    parameters.push_back(p);
     2090  }
     2091  {
     2092    CbcOrClpParam p("DivingF!ractional", "Whether to try DiveFractional",
     2093      "off", CBC_PARAM_STR_DIVINGF);
     2094    p.append("on");
     2095    p.append("both");
     2096    p.append("before");
     2097    parameters.push_back(p);
     2098  }
     2099  {
     2100    CbcOrClpParam p("DivingG!uided", "Whether to try DiveGuided",
     2101      "off", CBC_PARAM_STR_DIVINGG);
     2102    p.append("on");
     2103    p.append("both");
     2104    p.append("before");
     2105    parameters.push_back(p);
     2106  }
     2107  {
     2108    CbcOrClpParam p("DivingL!ineSearch", "Whether to try DiveLineSearch",
     2109      "off", CBC_PARAM_STR_DIVINGL);
     2110    p.append("on");
     2111    p.append("both");
     2112    p.append("before");
     2113    parameters.push_back(p);
     2114  }
     2115  {
     2116    CbcOrClpParam p("DivingP!seudoCost", "Whether to try DivePseudoCost",
     2117      "off", CBC_PARAM_STR_DIVINGP);
     2118    p.append("on");
     2119    p.append("both");
     2120    p.append("before");
     2121    parameters.push_back(p);
     2122  }
     2123  {
     2124    CbcOrClpParam p("DivingV!ectorLength", "Whether to try DiveVectorLength",
     2125      "off", CBC_PARAM_STR_DIVINGV);
     2126    p.append("on");
     2127    p.append("both");
     2128    p.append("before");
     2129    parameters.push_back(p);
     2130  }
     2131  {
     2132    CbcOrClpParam p("doH!euristic", "Do heuristics before any preprocessing",
     2133      CBC_PARAM_ACTION_DOHEURISTIC, 3);
     2134    p.setLonghelp(
     2135      "Normally heuristics are done in branch and bound.  It may be useful to do them outside. \
    19672136Only those heuristics with 'both' or 'before' set will run.  \
    19682137Doing this may also set cutoff, which can help with preprocessing.");
     2138    parameters.push_back(p);
     2139  }
    19692140#endif
    19702141#ifdef COIN_HAS_CLP
    1971   parameters[numberParameters++] = CbcOrClpParam("dualB!ound", "Initially algorithm acts as if no \
     2142  {
     2143    CbcOrClpParam p("dualB!ound", "Initially algorithm acts as if no \
    19722144gap between bounds exceeds this value",
    1973     1.0e-20, 1.0e12, CLP_PARAM_DBL_DUALBOUND);
    1974   parameters[numberParameters - 1].setLonghelp(
    1975     "The dual algorithm in Clp is a single phase algorithm as opposed to a two phase\
     2145      1.0e-20, 1.0e12, CLP_PARAM_DBL_DUALBOUND);
     2146    p.setLonghelp(
     2147      "The dual algorithm in Clp is a single phase algorithm as opposed to a two phase\
    19762148 algorithm where you first get feasible then optimal.  If a problem has both upper and\
    19772149 lower bounds then it is trivial to get dual feasible by setting non basic variables\
     
    19822154 the code may go all the way and then have to increase the bounds.  OSL had a heuristic to\
    19832155 adjust bounds, maybe we need that here.");
    1984   parameters[numberParameters++] = CbcOrClpParam("dualize", "Solves dual reformulation",
    1985     0, 4, CLP_PARAM_INT_DUALIZE, 1);
    1986   parameters[numberParameters - 1].setLonghelp(
    1987     "Don't even think about it.");
    1988   parameters[numberParameters++] = CbcOrClpParam("dualP!ivot", "Dual pivot choice algorithm",
    1989     "auto!matic", CLP_PARAM_STR_DUALPIVOT, 7, 1);
    1990   parameters[numberParameters - 1].append("dant!zig");
    1991   parameters[numberParameters - 1].append("partial");
    1992   parameters[numberParameters - 1].append("steep!est");
    1993   parameters[numberParameters - 1].append("PEsteep!est");
    1994   parameters[numberParameters - 1].append("PEdantzig");
    1995   parameters[numberParameters - 1].setLonghelp(
    1996     "Clp can use any pivot selection algorithm which the user codes as long as it\
     2156
     2157    parameters.push_back(p);
     2158  }
     2159  {
     2160    CbcOrClpParam p("dualize", "Solves dual reformulation",
     2161      0, 4, CLP_PARAM_INT_DUALIZE, 1);
     2162    p.setLonghelp(
     2163      "Don't even think about it.");
     2164
     2165    parameters.push_back(p);
     2166  }
     2167  {
     2168    CbcOrClpParam p("dualP!ivot", "Dual pivot choice algorithm",
     2169      "auto!matic", CLP_PARAM_STR_DUALPIVOT, 7, 1);
     2170    p.append("dant!zig");
     2171    p.append("partial");
     2172    p.append("steep!est");
     2173    p.append("PEsteep!est");
     2174    p.append("PEdantzig");
     2175    p.setLonghelp(
     2176      "Clp can use any pivot selection algorithm which the user codes as long as it\
    19972177 implements the features in the abstract pivot base class.  The Dantzig method is implemented\
    19982178 to show a simple method but its use is deprecated.  Steepest is the method of choice and there\
     
    20022182** NEWS - the Positive Edge criterion has been added. \
    20032183This selects incoming variables to try and avoid degenerate moves. See definition of psi.");
    2004   parameters[numberParameters++] = CbcOrClpParam("dualS!implex", "Do dual simplex algorithm",
    2005     CLP_PARAM_ACTION_DUALSIMPLEX);
    2006   parameters[numberParameters - 1].setLonghelp(
    2007     "This command solves the continuous relaxation of the current model using the dual steepest edge algorithm.\
     2184    parameters.push_back(p);
     2185  }
     2186  {
     2187    CbcOrClpParam p("dualS!implex", "Do dual simplex algorithm",
     2188      CLP_PARAM_ACTION_DUALSIMPLEX);
     2189    p.setLonghelp(
     2190      "This command solves the continuous relaxation of the current model using the dual steepest edge algorithm.\
    20082191The time and iterations may be affected by settings such as presolve, scaling, crash\
    20092192 and also by dual pivot method, fake bound on variables and dual and primal tolerances.");
    2010 #endif
    2011   parameters[numberParameters++] = CbcOrClpParam("dualT!olerance", "For an optimal solution \
     2193    parameters.push_back(p);
     2194  }
     2195#endif
     2196  {
     2197    CbcOrClpParam p("dualT!olerance", "For an optimal solution \
    20122198no dual infeasibility may exceed this value",
    2013     1.0e-20, 1.0e12, CLP_PARAM_DBL_DUALTOLERANCE);
    2014   parameters[numberParameters - 1].setLonghelp(
    2015     "Normally the default tolerance is fine, but you may want to increase it a\
     2199      1.0e-20, 1.0e12, CLP_PARAM_DBL_DUALTOLERANCE);
     2200    p.setLonghelp(
     2201      "Normally the default tolerance is fine, but you may want to increase it a\
    20162202 bit if a dual run seems to be having a hard time.  One method which can be faster is \
    20172203to use a large tolerance e.g. 1.0e-4 and dual and then clean up problem using primal and the \
    20182204correct tolerance (remembering to switch off presolve for this final short clean up phase).");
    2019 #ifdef COIN_HAS_CBC
    2020   parameters[numberParameters++] = CbcOrClpParam("dw!Heuristic", "Whether to try DW heuristic",
    2021     "off", CBC_PARAM_STR_DW);
    2022   parameters[numberParameters - 1].append("on");
    2023   parameters[numberParameters - 1].append("both");
    2024   parameters[numberParameters - 1].append("before");
    2025   parameters[numberParameters - 1].setLonghelp(
    2026     "See Rounding for meaning of on,both,before");
     2205    parameters.push_back(p);
     2206  }
     2207#ifdef COIN_HAS_CBC
     2208  {
     2209    CbcOrClpParam p("dw!Heuristic", "Whether to try DW heuristic",
     2210      "off", CBC_PARAM_STR_DW);
     2211    p.append("on");
     2212    p.append("both");
     2213    p.append("before");
     2214    p.setLonghelp(
     2215      "See Rounding for meaning of on,both,before");
     2216    parameters.push_back(p);
     2217  }
    20272218#endif
    20282219#ifdef COIN_HAS_CLP
    2029   parameters[numberParameters++] = CbcOrClpParam("either!Simplex", "Do dual or primal simplex algorithm",
    2030     CLP_PARAM_ACTION_EITHERSIMPLEX);
    2031   parameters[numberParameters - 1].setLonghelp(
    2032     "This command solves the continuous relaxation of the current model using the dual or primal algorithm,\
     2220  {
     2221    CbcOrClpParam p("either!Simplex", "Do dual or primal simplex algorithm",
     2222      CLP_PARAM_ACTION_EITHERSIMPLEX);
     2223    p.setLonghelp(
     2224      "This command solves the continuous relaxation of the current model using the dual or primal algorithm,\
    20332225 based on a dubious analysis of model.");
    2034 #endif
    2035   parameters[numberParameters++] = CbcOrClpParam("end", "Stops clp execution",
    2036     CLP_PARAM_ACTION_EXIT);
    2037   parameters[numberParameters - 1].setLonghelp(
    2038     "This stops execution ; end, exit, quit and stop are synonyms");
    2039   parameters[numberParameters++] = CbcOrClpParam("environ!ment", "Read commands from environment",
    2040     CLP_PARAM_ACTION_ENVIRONMENT, 7, 0);
    2041   parameters[numberParameters - 1].setLonghelp(
    2042     "This starts reading from environment variable CBC_CLP_ENVIRONMENT.");
    2043   parameters[numberParameters++] = CbcOrClpParam("error!sAllowed", "Whether to allow import errors",
    2044     "off", CLP_PARAM_STR_ERRORSALLOWED, 3);
    2045   parameters[numberParameters - 1].append("on");
    2046   parameters[numberParameters - 1].setLonghelp(
    2047     "The default is not to use any model which had errors when reading the mps file.\
     2226    parameters.push_back(p);
     2227  }
     2228#endif
     2229  {
     2230    CbcOrClpParam p("end", "Stops clp execution",
     2231      CLP_PARAM_ACTION_EXIT);
     2232    p.setLonghelp(
     2233      "This stops execution ; end, exit, quit and stop are synonyms");
     2234    parameters.push_back(p);
     2235  }
     2236  {
     2237    CbcOrClpParam p("environ!ment", "Read commands from environment",
     2238      CLP_PARAM_ACTION_ENVIRONMENT, 7, 0);
     2239    p.setLonghelp(
     2240      "This starts reading from environment variable CBC_CLP_ENVIRONMENT.");
     2241    parameters.push_back(p);
     2242  }
     2243  {
     2244    CbcOrClpParam p("error!sAllowed", "Whether to allow import errors",
     2245      "off", CLP_PARAM_STR_ERRORSALLOWED, 3);
     2246
     2247    p.append("on");
     2248    p.setLonghelp(
     2249      "The default is not to use any model which had errors when reading the mps file.\
    20482250  Setting this to 'on' will allow all errors from which the code can recover\
    20492251 simply by ignoring the error.  There are some errors from which the code can not recover \
    20502252e.g. no ENDATA.  This has to be set before import i.e. -errorsAllowed on -import xxxxxx.mps.");
    2051   parameters[numberParameters++] = CbcOrClpParam("exit", "Stops clp execution",
    2052     CLP_PARAM_ACTION_EXIT);
    2053   parameters[numberParameters - 1].setLonghelp(
    2054     "This stops the execution of Clp, end, exit, quit and stop are synonyms");
    2055 #ifdef COIN_HAS_CBC
    2056   parameters[numberParameters++] = CbcOrClpParam("exper!iment", "Whether to use testing features",
    2057     -1, 200000, CBC_PARAM_INT_EXPERIMENT, 0);
    2058   parameters[numberParameters - 1].setLonghelp(
    2059     "Defines how adventurous you want to be in using new ideas. \
     2253    parameters.push_back(p);
     2254  }
     2255  {
     2256    CbcOrClpParam p("exit", "Stops clp execution",
     2257      CLP_PARAM_ACTION_EXIT);
     2258    p.setLonghelp(
     2259      "This stops the execution of Clp, end, exit, quit and stop are synonyms");
     2260    parameters.push_back(p);
     2261  }
     2262#ifdef COIN_HAS_CBC
     2263  {
     2264    CbcOrClpParam p("exper!iment", "Whether to use testing features",
     2265      -1, 200000, CBC_PARAM_INT_EXPERIMENT, 0);
     2266    p.setLonghelp(
     2267      "Defines how adventurous you want to be in using new ideas. \
    206022680 then no new ideas, 1 fairly sensible, 2 a bit dubious, 3 you are on your own!");
    2061   parameters[numberParameters - 1].setIntValue(0);
    2062   parameters[numberParameters++] = CbcOrClpParam("expensive!Strong", "Whether to do even more strong branching",
    2063     0, COIN_INT_MAX, CBC_PARAM_INT_STRONG_STRATEGY, 0);
    2064   parameters[numberParameters - 1].setLonghelp(
    2065     "Strategy for extra strong branching \n\
     2269
     2270    p.setIntValue(0);
     2271    parameters.push_back(p);
     2272  }
     2273  {
     2274    CbcOrClpParam p("expensive!Strong", "Whether to do even more strong branching",
     2275      0, COIN_INT_MAX, CBC_PARAM_INT_STRONG_STRATEGY, 0);
     2276
     2277    p.setLonghelp(
     2278      "Strategy for extra strong branching \n\
    20662279\n\t0 - normal\n\
    20672280\n\twhen to do all fractional\n\
     
    20732286\n\t10 - root node etc.\n\
    20742287\n\tIf >=100 then do when depth <= strategy/100 (otherwise 5)");
    2075   parameters[numberParameters - 1].setIntValue(0);
    2076 #endif
    2077   parameters[numberParameters++] = CbcOrClpParam("export", "Export model as mps file",
    2078     CLP_PARAM_ACTION_EXPORT);
    2079   parameters[numberParameters - 1].setLonghelp(
    2080     "This will write an MPS format file to the given file name.  It will use the default\
     2288    p.setIntValue(0);
     2289    parameters.push_back(p);
     2290  }
     2291#endif
     2292  {
     2293    CbcOrClpParam p("export", "Export model as mps file",
     2294      CLP_PARAM_ACTION_EXPORT);
     2295
     2296    p.setLonghelp(
     2297      "This will write an MPS format file to the given file name.  It will use the default\
    20812298 directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
    20822299 is initialized to 'default.mps'.  \
    20832300It can be useful to get rid of the original names and go over to using Rnnnnnnn and Cnnnnnnn.  This can be done by setting 'keepnames' off before importing mps file.");
    2084 #ifdef COIN_HAS_CBC
    2085   parameters[numberParameters++] = CbcOrClpParam("extra1", "Extra integer parameter 1",
    2086     -COIN_INT_MAX, COIN_INT_MAX, CBC_PARAM_INT_EXTRA1, 0);
    2087   parameters[numberParameters - 1].setIntValue(-1);
    2088   parameters[numberParameters++] = CbcOrClpParam("extra2", "Extra integer parameter 2",
    2089     -100, COIN_INT_MAX, CBC_PARAM_INT_EXTRA2, 0);
    2090   parameters[numberParameters - 1].setIntValue(-1);
    2091   parameters[numberParameters++] = CbcOrClpParam("extra3", "Extra integer parameter 3",
    2092     -1, COIN_INT_MAX, CBC_PARAM_INT_EXTRA3, 0);
    2093   parameters[numberParameters - 1].setIntValue(-1);
    2094   parameters[numberParameters++] = CbcOrClpParam("extra4", "Extra integer parameter 4",
    2095     -1, COIN_INT_MAX, CBC_PARAM_INT_EXTRA4, 0);
    2096   parameters[numberParameters - 1].setIntValue(-1);
    2097   parameters[numberParameters - 1].setLonghelp(
    2098     "This switches on yet more special options!! \
     2301    parameters.push_back(p);
     2302  }
     2303#ifdef COIN_HAS_CBC
     2304  {
     2305    CbcOrClpParam p("extra1", "Extra integer parameter 1",
     2306      -COIN_INT_MAX, COIN_INT_MAX, CBC_PARAM_INT_EXTRA1, 0);
     2307    p.setIntValue(-1);
     2308    parameters.push_back(p);
     2309  }
     2310  {
     2311    CbcOrClpParam p("extra2", "Extra integer parameter 2",
     2312      -COIN_INT_MAX, COIN_INT_MAX, CBC_PARAM_INT_EXTRA2, 0);
     2313    p.setIntValue(-1);
     2314    parameters.push_back(p);
     2315  }
     2316  {
     2317    CbcOrClpParam p("extra3", "Extra integer parameter 3",
     2318      -COIN_INT_MAX, COIN_INT_MAX, CBC_PARAM_INT_EXTRA3, 0);
     2319    p.setIntValue(-1);
     2320    parameters.push_back(p);
     2321  }
     2322  {
     2323    CbcOrClpParam p("extra4", "Extra integer parameter 4",
     2324      -1, COIN_INT_MAX, CBC_PARAM_INT_EXTRA4, 0);
     2325
     2326    p.setIntValue(-1);
     2327    p.setLonghelp(
     2328      "This switches on yet more special options!! \
    20992329The bottom digit is a strategy when to used shadow price stuff e.g. 3 \
    21002330means use until a solution is found.  The next two digits say what sort \
     
    21042334\n\t8000 - increase minimum drop gradually\n\
    21052335\n\t16000 - switches on alternate gomory criterion");
    2106   parameters[numberParameters++] = CbcOrClpParam("extraV!ariables", "Allow creation of extra integer variables",
    2107     -COIN_INT_MAX, COIN_INT_MAX, CBC_PARAM_INT_EXTRA_VARIABLES, 0);
    2108   parameters[numberParameters - 1].setIntValue(0);
    2109   parameters[numberParameters - 1].setLonghelp(
    2110     "This switches on creation of extra integer variables \
     2336    parameters.push_back(p);
     2337  }
     2338  {
     2339    CbcOrClpParam p("extraV!ariables", "Allow creation of extra integer variables",
     2340      -COIN_INT_MAX, COIN_INT_MAX, CBC_PARAM_INT_EXTRA_VARIABLES, 0);
     2341    p.setIntValue(0);
     2342    p.setLonghelp(
     2343      "This switches on creation of extra integer variables \
    21112344to gather all variables with same cost.");
     2345    parameters.push_back(p);
     2346  }
    21122347#endif
    21132348#ifdef COIN_HAS_CLP
    2114   parameters[numberParameters++] = CbcOrClpParam("fact!orization", "Which factorization to use",
    2115     "normal", CLP_PARAM_STR_FACTORIZATION);
    2116   parameters[numberParameters - 1].append("dense");
    2117   parameters[numberParameters - 1].append("simple");
    2118   parameters[numberParameters - 1].append("osl");
    2119   parameters[numberParameters - 1].setLonghelp(
     2349  {
     2350    CbcOrClpParam p("fact!orization", "Which factorization to use",
     2351      "normal", CLP_PARAM_STR_FACTORIZATION);
     2352    p.append("dense");
     2353    p.append("simple");
     2354    p.append("osl");
     2355    p.setLonghelp(
    21202356#ifndef ABC_INHERIT
    2121     "The default is to use the normal CoinFactorization, but \
     2357      "The default is to use the normal CoinFactorization, but \
    21222358other choices are a dense one, osl's or one designed for small problems."
    21232359#else
    2124     "Normally the default is to use the normal CoinFactorization, but \
     2360      "Normally the default is to use the normal CoinFactorization, but \
    21252361other choices are a dense one, osl's or one designed for small problems. \
    21262362However if at Aboca then the default is CoinAbcFactorization and other choices are \
    21272363a dense one, one designed for small problems or if enabled a long factorization."
    21282364#endif
    2129   );
    2130   parameters[numberParameters++] = CbcOrClpParam("fakeB!ound", "All bounds <= this value - DEBUG",
    2131     1.0, 1.0e15, CLP_PARAM_ACTION_FAKEBOUND, 0);
    2132 #ifdef COIN_HAS_CBC
    2133   parameters[numberParameters++] = CbcOrClpParam("feas!ibilityPump", "Whether to try Feasibility Pump",
    2134     "off", CBC_PARAM_STR_FPUMP);
    2135   parameters[numberParameters - 1].append("on");
    2136   parameters[numberParameters - 1].append("both");
    2137   parameters[numberParameters - 1].append("before");
    2138   parameters[numberParameters - 1].setLonghelp(
    2139     "This switches on feasibility pump heuristic at root. This is due to Fischetti, Lodi and Glover \
     2365    );
     2366    parameters.push_back(p);
     2367  }
     2368  {
     2369    CbcOrClpParam p("fakeB!ound", "All bounds <= this value - DEBUG",
     2370      1.0, 1.0e15, CLP_PARAM_ACTION_FAKEBOUND, 0);
     2371    parameters.push_back(p);
     2372  }
     2373#ifdef COIN_HAS_CBC
     2374  {
     2375    CbcOrClpParam p("feas!ibilityPump", "Whether to try Feasibility Pump",
     2376      "off", CBC_PARAM_STR_FPUMP);
     2377
     2378    p.append("on");
     2379    p.append("both");
     2380    p.append("before");
     2381    p.setLonghelp(
     2382      "This switches on feasibility pump heuristic at root. This is due to Fischetti, Lodi and Glover \
    21402383and uses a sequence of Lps to try and get an integer feasible solution. \
    21412384Some fine tuning is available by passFeasibilityPump and also pumpTune. \
    21422385See Rounding for meaning of on,both,before");
    2143   parameters[numberParameters++] = CbcOrClpParam("fix!OnDj", "Try heuristic based on fixing variables with \
     2386    parameters.push_back(p);
     2387  }
     2388  {
     2389    CbcOrClpParam p("fix!OnDj", "Try heuristic based on fixing variables with \
    21442390reduced costs greater than this",
    2145     -1.0e20, 1.0e20, CBC_PARAM_DBL_DJFIX, 1);
    2146   parameters[numberParameters - 1].setLonghelp(
    2147     "If this is set integer variables with reduced costs greater than this will be fixed \
     2391      -1.0e20, 1.0e20, CBC_PARAM_DBL_DJFIX, 1);
     2392    p.setLonghelp(
     2393      "If this is set integer variables with reduced costs greater than this will be fixed \
    21482394before branch and bound - use with extreme caution!");
    2149   parameters[numberParameters++] = CbcOrClpParam("flow!CoverCuts", "Whether to use Flow Cover cuts",
    2150     "off", CBC_PARAM_STR_FLOWCUTS);
    2151   parameters[numberParameters - 1].append("on");
    2152   parameters[numberParameters - 1].append("root");
    2153   parameters[numberParameters - 1].append("ifmove");
    2154   parameters[numberParameters - 1].append("forceOn");
    2155   parameters[numberParameters - 1].append("onglobal");
    2156   parameters[numberParameters - 1].setFakeKeyWord(3);
    2157   parameters[numberParameters - 1].setLonghelp(
    2158     "This switches on flow cover cuts (either at root or in entire tree) \
     2395    parameters.push_back(p);
     2396  }
     2397  {
     2398    CbcOrClpParam p("flow!CoverCuts", "Whether to use Flow Cover cuts",
     2399      "off", CBC_PARAM_STR_FLOWCUTS);
     2400    p.append("on");
     2401    p.append("root");
     2402    p.append("ifmove");
     2403    p.append("forceOn");
     2404    p.append("onglobal");
     2405    p.setFakeKeyWord(3);
     2406    p.setLonghelp(
     2407      "This switches on flow cover cuts (either at root or in entire tree) \
    21592408See branchAndCut for information on options. \
    21602409Can also enter testing values by plusnn (==ifmove)");
    2161   parameters[numberParameters++] = CbcOrClpParam("force!Solution", "Whether to use given solution as crash for BAB",
    2162     -1, 20000000, CLP_PARAM_INT_USESOLUTION);
    2163   parameters[numberParameters - 1].setIntValue(-1);
    2164   parameters[numberParameters - 1].setLonghelp(
    2165     "-1 off.  If 1 then tries to branch to solution given by AMPL or priorities file. \
     2410    parameters.push_back(p);
     2411  }
     2412  {
     2413    CbcOrClpParam p("force!Solution", "Whether to use given solution as crash for BAB",
     2414      -1, 20000000, CLP_PARAM_INT_USESOLUTION);
     2415    p.setIntValue(-1);
     2416    p.setLonghelp(
     2417      "-1 off.  If 1 then tries to branch to solution given by AMPL or priorities file. \
    21662418If 0 then just tries to set as best solution \
    21672419If >1 then also does that many nodes on fixed problem.");
    2168   parameters[numberParameters++] = CbcOrClpParam("fraction!forBAB", "Fraction in feasibility pump",
    2169     1.0e-5, 1.1, CBC_PARAM_DBL_SMALLBAB, 1);
    2170   parameters[numberParameters - 1].setDoubleValue(0.5);
    2171   parameters[numberParameters - 1].setLonghelp(
    2172     "After a pass in feasibility pump, variables which have not moved \
     2420    parameters.push_back(p);
     2421  }
     2422  {
     2423    CbcOrClpParam p("fraction!forBAB", "Fraction in feasibility pump",
     2424      1.0e-5, 1.1, CBC_PARAM_DBL_SMALLBAB, 1);
     2425    p.setDoubleValue(0.5);
     2426    p.setLonghelp(
     2427      "After a pass in feasibility pump, variables which have not moved \
    21732428about are fixed and if the preprocessed model is small enough a few nodes \
    2174 of branch and bound are done on reduced problem.  Small problem has to be less than this fraction of original.");
    2175 #endif
    2176   parameters[numberParameters++] = CbcOrClpParam("gamma!(Delta)", "Whether to regularize barrier",
    2177     "off", CLP_PARAM_STR_GAMMA, 7, 1);
    2178   parameters[numberParameters - 1].append("on");
    2179   parameters[numberParameters - 1].append("gamma");
    2180   parameters[numberParameters - 1].append("delta");
    2181   parameters[numberParameters - 1].append("onstrong");
    2182   parameters[numberParameters - 1].append("gammastrong");
    2183   parameters[numberParameters - 1].append("deltastrong");
    2184 #endif
    2185 #ifdef COIN_HAS_CBC
    2186   parameters[numberParameters++] = CbcOrClpParam("GMI!Cuts", "Whether to use alternative Gomory cuts",
    2187     "off", CBC_PARAM_STR_GMICUTS);
    2188   parameters[numberParameters - 1].append("on");
    2189   parameters[numberParameters - 1].append("root");
    2190   parameters[numberParameters - 1].append("ifmove");
    2191   parameters[numberParameters - 1].append("forceOn");
    2192   parameters[numberParameters - 1].append("endonly");
    2193   parameters[numberParameters - 1].append("long");
    2194   parameters[numberParameters - 1].append("longroot");
    2195   parameters[numberParameters - 1].append("longifmove");
    2196   parameters[numberParameters - 1].append("forceLongOn");
    2197   parameters[numberParameters - 1].append("longendonly");
    2198   parameters[numberParameters - 1].setLonghelp(
    2199     "This switches on an alternative Gomory cut generator (either at root or in entire tree) \
     2429of branch and bound are done on reduced problem.  Small problem has to be \
     2430less than this fraction of original.");
     2431    parameters.push_back(p);
     2432  }
     2433#endif
     2434  {
     2435    CbcOrClpParam p("gamma!(Delta)", "Whether to regularize barrier",
     2436      "off", CLP_PARAM_STR_GAMMA, 7, 1);
     2437    p.append("on");
     2438    p.append("gamma");
     2439    p.append("delta");
     2440    p.append("onstrong");
     2441    p.append("gammastrong");
     2442    p.append("deltastrong");
     2443    parameters.push_back(p);
     2444  }
     2445#endif
     2446#ifdef COIN_HAS_CBC
     2447  {
     2448    CbcOrClpParam p("GMI!Cuts", "Whether to use alternative Gomory cuts",
     2449      "off", CBC_PARAM_STR_GMICUTS);
     2450
     2451    p.append("on");
     2452    p.append("root");
     2453    p.append("ifmove");
     2454    p.append("forceOn");
     2455    p.append("endonly");
     2456    p.append("long");
     2457    p.append("longroot");
     2458    p.append("longifmove");
     2459    p.append("forceLongOn");
     2460    p.append("longendonly");
     2461    p.setLonghelp(
     2462      "This switches on an alternative Gomory cut generator \
     2463(either at root or in entire tree) \
    22002464This version is by Giacomo Nannicini and may be more robust \
    22012465See branchAndCut for information on options.");
    2202   parameters[numberParameters++] = CbcOrClpParam("gomory!Cuts", "Whether to use Gomory cuts",
    2203     "off", CBC_PARAM_STR_GOMORYCUTS);
    2204   parameters[numberParameters - 1].append("on");
    2205   parameters[numberParameters - 1].append("root");
    2206   parameters[numberParameters - 1].append("ifmove");
    2207   parameters[numberParameters - 1].append("forceOn");
    2208   parameters[numberParameters - 1].append("onglobal");
    2209   parameters[numberParameters - 1].append("forceandglobal");
    2210   parameters[numberParameters - 1].append("forceLongOn");
    2211   parameters[numberParameters - 1].append("long");
    2212   parameters[numberParameters - 1].setLonghelp(
    2213     "The original cuts - beware of imitations!  Having gone out of favor, they are now more \
    2214 fashionable as LP solvers are more robust and they interact well with other cuts.  They will almost always \
    2215 give cuts (although in this executable they are limited as to number of variables in cut).  \
    2216 However the cuts may be dense so it is worth experimenting (Long allows any length). \
    2217 See branchAndCut for information on options.");
    2218   parameters[numberParameters++] = CbcOrClpParam("greedy!Heuristic", "Whether to use a greedy heuristic",
    2219     "off", CBC_PARAM_STR_GREEDY);
    2220   parameters[numberParameters - 1].append("on");
    2221   parameters[numberParameters - 1].append("both");
    2222   parameters[numberParameters - 1].append("before");
    2223   //parameters[numberParameters-1].append("root");
    2224   parameters[numberParameters - 1].setLonghelp(
    2225     "Switches on a greedy heuristic which will try and obtain a solution.  It may just fix a \
    2226 percentage of variables and then try a small branch and cut run. \
     2466    parameters.push_back(p);
     2467  }
     2468  {
     2469    CbcOrClpParam p("gomory!Cuts", "Whether to use Gomory cuts",
     2470      "off", CBC_PARAM_STR_GOMORYCUTS);
     2471
     2472    p.append("on");
     2473    p.append("root");
     2474    p.append("ifmove");
     2475    p.append("forceOn");
     2476    p.append("onglobal");
     2477    p.append("forceandglobal");
     2478    p.append("forceLongOn");
     2479    p.append("long");
     2480    p.setLonghelp(
     2481      "The original cuts - beware of imitations!  Having gone out of favor, \
     2482they are now more fashionable as LP solvers are more robust and they interact well \
     2483with other cuts.  They will almost always give cuts (although in this executable \
     2484they are limited as to number of variables in cut).  However the cuts may be dense \
     2485so it is worth experimenting (Long allows any length). See branchAndCut for \
     2486information on options.");
     2487    parameters.push_back(p);
     2488  }
     2489  {
     2490    CbcOrClpParam p("greedy!Heuristic", "Whether to use a greedy heuristic",
     2491      "off", CBC_PARAM_STR_GREEDY);
     2492
     2493    p.append("on");
     2494    p.append("both");
     2495    p.append("before");
     2496    //p.append("root");
     2497    p.setLonghelp(
     2498      "Switches on a greedy heuristic which will try and obtain a solution. \
     2499It may just fix a percentage of variables and then try a small branch and cut run. \
    22272500See Rounding for meaning of on,both,before");
    2228 #endif
    2229   parameters[numberParameters++] = CbcOrClpParam("gsolu!tion", "Puts glpk solution to file",
    2230     CLP_PARAM_ACTION_GMPL_SOLUTION);
    2231   parameters[numberParameters - 1].setLonghelp(
    2232     "Will write a glpk solution file to the given file name.  It will use the default\
    2233  directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
    2234  is initialized to 'stdout' (this defaults to ordinary solution if stdout). \
     2501    parameters.push_back(p);
     2502  }
     2503#endif
     2504  {
     2505    CbcOrClpParam p("gsolu!tion", "Puts glpk solution to file",
     2506      CLP_PARAM_ACTION_GMPL_SOLUTION);
     2507
     2508    p.setLonghelp(
     2509      "Will write a glpk solution file to the given file name.  It will use the default \
     2510directory given by 'directory'.  A name of '$' will use the previous value for the \
     2511name.  This is initialized to 'stdout' (this defaults to ordinary solution if stdout). \
    22352512If problem created from gmpl model - will do any reports.");
    2236   parameters[numberParameters++] = CbcOrClpParam("guess", "Guesses at good parameters",
    2237     CLP_PARAM_ACTION_GUESS, 7);
    2238   parameters[numberParameters - 1].setLonghelp(
     2513    parameters.push_back(p);
     2514  }
     2515  {
     2516    CbcOrClpParam p("guess", "Guesses at good parameters", CLP_PARAM_ACTION_GUESS, 7);
     2517    p.setLonghelp(
    22392518    "This looks at model statistics and does an initial solve \
    22402519setting some parameters which may help you to think of possibilities.");
    2241 #ifdef COIN_HAS_CBC
    2242   parameters[numberParameters++] = CbcOrClpParam("heur!isticsOnOff", "Switches most heuristics on or off",
    2243     "off", CBC_PARAM_STR_HEURISTICSTRATEGY);
    2244   parameters[numberParameters - 1].append("on");
    2245   parameters[numberParameters - 1].setLonghelp(
    2246     "This can be used to switch on or off all heuristics.  Then you can do \
     2520    parameters.push_back(p);
     2521  }
     2522#ifdef COIN_HAS_CBC
     2523  {
     2524    CbcOrClpParam p("heur!isticsOnOff", "Switches most heuristics on or off",
     2525      "off", CBC_PARAM_STR_HEURISTICSTRATEGY);
     2526    p.append("on");
     2527    p.setLonghelp(
     2528      "This can be used to switch on or off all heuristics.  Then you can do \
    22472529individual ones off or on.  CbcTreeLocal is not included as it dramatically \
    22482530alters search.");
    2249 #endif
    2250   parameters[numberParameters++] = CbcOrClpParam("help", "Print out version, non-standard options and some help",
    2251     CLP_PARAM_ACTION_HELP, 3);
    2252   parameters[numberParameters - 1].setLonghelp(
    2253     "This prints out some help to get user started.  If you have printed this then \
     2531    parameters.push_back(p);
     2532  }
     2533  {
     2534    CbcOrClpParam p("help", "Print out version, non-standard options and some help",
     2535      CLP_PARAM_ACTION_HELP, 3);
     2536    p.setLonghelp(
     2537      "This prints out some help to get user started.  If you have printed this then \
    22542538you should be past that stage:-)");
    2255 #ifdef COIN_HAS_CBC
    2256   parameters[numberParameters++] = CbcOrClpParam("hOp!tions", "Heuristic options",
    2257     -9999999, 9999999, CBC_PARAM_INT_HOPTIONS, 1);
    2258   parameters[numberParameters - 1].setLonghelp(
    2259     "1 says stop heuristic immediately allowable gap reached. \
     2539    parameters.push_back(p);
     2540  }
     2541#endif
     2542#ifdef COIN_HAS_CBC
     2543  {
     2544    CbcOrClpParam p("hOp!tions", "Heuristic options",
     2545      -9999999, 9999999, CBC_PARAM_INT_HOPTIONS, 1);
     2546    p.setIntValue(0);
     2547    p.setLonghelp(
     2548      "1 says stop heuristic immediately allowable gap reached. \
    22602549Others are for feasibility pump - \
    226125502 says do exact number of passes given, \
    226225514 only applies if initial cutoff given and says relax after 50 passes, \
    22632552while 8 will adapt cutoff rhs after first solution if it looks as if code is stalling.");
    2264   parameters[numberParameters - 1].setIntValue(0);
    2265   parameters[numberParameters++] = CbcOrClpParam("hot!StartMaxIts", "Maximum iterations on hot start",
    2266     0, COIN_INT_MAX, CBC_PARAM_INT_MAXHOTITS);
     2553    parameters.push_back(p);
     2554  }
     2555  {
     2556    CbcOrClpParam p("hot!StartMaxIts", "Maximum iterations on hot start",
     2557      0, COIN_INT_MAX, CBC_PARAM_INT_MAXHOTITS);
     2558    parameters.push_back(p);
     2559  }
    22672560#endif
    22682561#ifdef COIN_HAS_CLP
    2269   parameters[numberParameters++] = CbcOrClpParam("idiot!Crash", "Whether to try idiot crash",
    2270     -1, 99999999, CLP_PARAM_INT_IDIOT);
    2271   parameters[numberParameters - 1].setLonghelp(
    2272     "This is a type of 'crash' which works well on some homogeneous problems.\
    2273  It works best on problems with unit elements and rhs but will do something to any model.  It should only be\
    2274  used before primal.  It can be set to -1 when the code decides for itself whether to use it,\
    2275  0 to switch off or n > 0 to do n passes.");
    2276 #endif
    2277   parameters[numberParameters++] = CbcOrClpParam("import", "Import model from mps file",
    2278     CLP_PARAM_ACTION_IMPORT, 3);
    2279   parameters[numberParameters - 1].setLonghelp(
    2280     "This will read an MPS format file from the given file name.  It will use the default\
     2562  {
     2563    CbcOrClpParam p("idiot!Crash", "Whether to try idiot crash",
     2564      -1, 99999999, CLP_PARAM_INT_IDIOT);
     2565
     2566    p.setLonghelp(
     2567      "This is a type of 'crash' which works well on some homogeneous problems.\
     2568 It works best on problems with unit elements and rhs but will do something to any \
     2569 model.  It should only be used before primal.  It can be set to -1 when the code \
     2570 decides for itself whether to use it, 0 to switch off or n > 0 to do n passes.");
     2571    parameters.push_back(p);
     2572  }
     2573#endif
     2574  {
     2575    CbcOrClpParam p("import", "Import model from mps file",
     2576      CLP_PARAM_ACTION_IMPORT, 3);
     2577    p.setLonghelp(
     2578      "This will read an MPS format file from the given file name.  It will use the default\
    22812579 directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
    22822580 is initialized to '', i.e. it must be set.  If you have libgz then it can read compressed\
    22832581 files 'xxxxxxxx.gz' or 'xxxxxxxx.bz2'.  \
    22842582If 'keepnames' is off, then names are dropped -> Rnnnnnnn and Cnnnnnnn.");
    2285 #ifdef COIN_HAS_CBC
    2286   parameters[numberParameters++] = CbcOrClpParam("inc!rement", "A valid solution must be at least this \
     2583    parameters.push_back(p);
     2584  }
     2585#ifdef COIN_HAS_CBC
     2586  {
     2587    CbcOrClpParam p("inc!rement", "A valid solution must be at least this \
    22872588much better than last integer solution",
    2288     -1.0e20, 1.0e20, CBC_PARAM_DBL_INCREMENT);
    2289   parameters[numberParameters - 1].setLonghelp(
    2290     "Whenever a solution is found the bound on solutions is set to solution (in a minimization\
     2589      -1.0e20, 1.0e20, CBC_PARAM_DBL_INCREMENT);
     2590
     2591    p.setLonghelp(
     2592      "Whenever a solution is found the bound on solutions is set to solution (in a minimization\
    22912593sense) plus this.  If it is not set then the code will try and work one out e.g. if \
    22922594all objective coefficients are multiples of 0.01 and only integer variables have entries in \
    22932595objective then this can be set to 0.01.  Be careful if you set this negative!");
    2294   parameters[numberParameters++] = CbcOrClpParam("inf!easibilityWeight", "Each integer infeasibility is expected \
     2596
     2597    parameters.push_back(p);
     2598  }
     2599  {
     2600    CbcOrClpParam p("inf!easibilityWeight", "Each integer infeasibility is expected \
    22952601to cost this much",
    2296     0.0, 1.0e20, CBC_PARAM_DBL_INFEASIBILITYWEIGHT, 1);
    2297   parameters[numberParameters - 1].setLonghelp(
    2298     "A primitive way of deciding which node to explore next.  Satisfying each integer infeasibility is \
     2602      0.0, 1.0e20, CBC_PARAM_DBL_INFEASIBILITYWEIGHT, 1);
     2603    p.setLonghelp(
     2604      "A primitive way of deciding which node to explore next.  Satisfying each integer infeasibility is \
    22992605expected to cost this much.");
    2300   parameters[numberParameters++] = CbcOrClpParam("initialS!olve", "Solve to continuous",
    2301     CLP_PARAM_ACTION_SOLVECONTINUOUS);
    2302   parameters[numberParameters - 1].setLonghelp(
    2303     "This just solves the problem to continuous - without adding any cuts");
    2304   parameters[numberParameters++] = CbcOrClpParam("integerT!olerance", "For an optimal solution \
     2606    parameters.push_back(p);
     2607  }
     2608  {
     2609    CbcOrClpParam p("initialS!olve", "Solve to continuous",
     2610      CLP_PARAM_ACTION_SOLVECONTINUOUS);
     2611
     2612    p.setLonghelp(
     2613      "This just solves the problem to continuous - without adding any cuts");
     2614    parameters.push_back(p);
     2615  }
     2616  {
     2617    CbcOrClpParam p("integerT!olerance", "For an optimal solution \
    23052618no integer variable may be this away from an integer value",
    2306     1.0e-20, 0.5, CBC_PARAM_DBL_INTEGERTOLERANCE);
    2307   parameters[numberParameters - 1].setLonghelp(
    2308     "Beware of setting this smaller than the primal tolerance.");
     2619      1.0e-20, 0.5, CBC_PARAM_DBL_INTEGERTOLERANCE);
     2620    p.setLonghelp(
     2621      "Beware of setting this smaller than the primal tolerance.");
     2622    parameters.push_back(p);
     2623  }
    23092624#endif
    23102625#ifdef COIN_HAS_CLP
    2311   parameters[numberParameters++] = CbcOrClpParam("keepN!ames", "Whether to keep names from import",
    2312     "on", CLP_PARAM_STR_KEEPNAMES);
    2313   parameters[numberParameters - 1].append("off");
    2314   parameters[numberParameters - 1].setLonghelp(
    2315     "It saves space to get rid of names so if you need to you can set this to off.  \
     2626  {
     2627    CbcOrClpParam p("keepN!ames", "Whether to keep names from import",
     2628      "on", CLP_PARAM_STR_KEEPNAMES);
     2629    p.append("off");
     2630    p.setLonghelp(
     2631      "It saves space to get rid of names so if you need to you can set this to off.  \
    23162632This needs to be set before the import of model - so -keepnames off -import xxxxx.mps.");
    2317   parameters[numberParameters++] = CbcOrClpParam("KKT", "Whether to use KKT factorization",
    2318     "off", CLP_PARAM_STR_KKT, 7, 1);
    2319   parameters[numberParameters - 1].append("on");
    2320 #endif
    2321 #ifdef COIN_HAS_CBC
    2322   parameters[numberParameters++] = CbcOrClpParam("knapsack!Cuts", "Whether to use Knapsack cuts",
    2323     "off", CBC_PARAM_STR_KNAPSACKCUTS);
    2324   parameters[numberParameters - 1].append("on");
    2325   parameters[numberParameters - 1].append("root");
    2326   parameters[numberParameters - 1].append("ifmove");
    2327   parameters[numberParameters - 1].append("forceOn");
    2328   parameters[numberParameters - 1].append("onglobal");
    2329   parameters[numberParameters - 1].append("forceandglobal");
    2330   parameters[numberParameters - 1].setLonghelp(
    2331     "This switches on knapsack cuts (either at root or in entire tree) \
     2633    parameters.push_back(p);
     2634  }
     2635  {
     2636    CbcOrClpParam p("KKT", "Whether to use KKT factorization",
     2637      "off", CLP_PARAM_STR_KKT, 7, 1);
     2638    p.append("on");
     2639    parameters.push_back(p);
     2640  }
     2641#endif
     2642#ifdef COIN_HAS_CBC
     2643  {
     2644    CbcOrClpParam p("knapsack!Cuts", "Whether to use Knapsack cuts",
     2645      "off", CBC_PARAM_STR_KNAPSACKCUTS);
     2646
     2647    p.append("on");
     2648    p.append("root");
     2649    p.append("ifmove");
     2650    p.append("forceOn");
     2651    p.append("onglobal");
     2652    p.append("forceandglobal");
     2653    p.setLonghelp(
     2654      "This switches on knapsack cuts (either at root or in entire tree) \
    23322655See branchAndCut for information on options.");
    2333   parameters[numberParameters++] = CbcOrClpParam("lagomory!Cuts", "Whether to use Lagrangean Gomory cuts",
    2334     "off", CBC_PARAM_STR_LAGOMORYCUTS);
    2335   parameters[numberParameters - 1].append("endonlyroot");
    2336   parameters[numberParameters - 1].append("endcleanroot");
    2337   parameters[numberParameters - 1].append("root");
    2338   parameters[numberParameters - 1].append("endonly");
    2339   parameters[numberParameters - 1].append("endclean");
    2340   parameters[numberParameters - 1].append("endboth");
    2341   parameters[numberParameters - 1].append("onlyaswell");
    2342   parameters[numberParameters - 1].append("cleanaswell");
    2343   parameters[numberParameters - 1].append("bothaswell");
    2344   parameters[numberParameters - 1].append("onlyinstead");
    2345   parameters[numberParameters - 1].append("cleaninstead");
    2346   parameters[numberParameters - 1].append("bothinstead");
    2347   parameters[numberParameters - 1].append("onlyaswellroot");
    2348   parameters[numberParameters - 1].append("cleanaswellroot");
    2349   parameters[numberParameters - 1].append("bothaswellroot");
    2350   parameters[numberParameters - 1].setLonghelp(
    2351     "This is a gross simplification of 'A Relax-and-Cut Framework for Gomory's Mixed-Integer Cuts' \
     2656    parameters.push_back(p);
     2657  }
     2658  {
     2659    CbcOrClpParam p("lagomory!Cuts", "Whether to use Lagrangean Gomory cuts",
     2660      "off", CBC_PARAM_STR_LAGOMORYCUTS);
     2661    p.append("endonlyroot");
     2662    p.append("endcleanroot");
     2663    p.append("root");
     2664    p.append("endonly");
     2665    p.append("endclean");
     2666    p.append("endboth");
     2667    p.append("onlyaswell");
     2668    p.append("cleanaswell");
     2669    p.append("bothaswell");
     2670    p.append("onlyinstead");
     2671    p.append("cleaninstead");
     2672    p.append("bothinstead");
     2673    p.append("onlyaswellroot");
     2674    p.append("cleanaswellroot");
     2675    p.append("bothaswellroot");
     2676    p.setLonghelp(
     2677      "This is a gross simplification of 'A Relax-and-Cut Framework for Gomory's Mixed-Integer Cuts' \
    23522678by Matteo Fischetti & Domenico Salvagnin.  This simplification \
    23532679just uses original constraints while modifying objective using other cuts. \
     
    23582684does a few passes. \
    23592685The length options for gomory cuts are used.");
    2360   parameters[numberParameters++] = CbcOrClpParam("latwomir!Cuts", "Whether to use Lagrangean TwoMir cuts",
    2361     "off", CBC_PARAM_STR_LATWOMIRCUTS);
    2362   parameters[numberParameters - 1].append("endonlyroot");
    2363   parameters[numberParameters - 1].append("endcleanroot");
    2364   parameters[numberParameters - 1].append("endbothroot");
    2365   parameters[numberParameters - 1].append("endonly");
    2366   parameters[numberParameters - 1].append("endclean");
    2367   parameters[numberParameters - 1].append("endboth");
    2368   parameters[numberParameters - 1].append("onlyaswell");
    2369   parameters[numberParameters - 1].append("cleanaswell");
    2370   parameters[numberParameters - 1].append("bothaswell");
    2371   parameters[numberParameters - 1].append("onlyinstead");
    2372   parameters[numberParameters - 1].append("cleaninstead");
    2373   parameters[numberParameters - 1].append("bothinstead");
    2374   parameters[numberParameters - 1].setLonghelp(
    2375     "This is a lagrangean relaxation for TwoMir cuts.  See \
    2376 lagomoryCuts for description of options.");
    2377   parameters[numberParameters++] = CbcOrClpParam("lift!AndProjectCuts", "Whether to use Lift and Project cuts",
    2378     "off", CBC_PARAM_STR_LANDPCUTS);
    2379   parameters[numberParameters - 1].append("on");
    2380   parameters[numberParameters - 1].append("root");
    2381   parameters[numberParameters - 1].append("ifmove");
    2382   parameters[numberParameters - 1].append("forceOn");
    2383   parameters[numberParameters - 1].setLonghelp(
    2384     "Lift and project cuts. \
     2686    parameters.push_back(p);
     2687  }
     2688  {
     2689    CbcOrClpParam p("latwomir!Cuts", "Whether to use Lagrangean TwoMir cuts",
     2690      "off", CBC_PARAM_STR_LATWOMIRCUTS);
     2691
     2692    p.append("endonlyroot");
     2693    p.append("endcleanroot");
     2694    p.append("endbothroot");
     2695    p.append("endonly");
     2696    p.append("endclean");
     2697    p.append("endboth");
     2698    p.append("onlyaswell");
     2699    p.append("cleanaswell");
     2700    p.append("bothaswell");
     2701    p.append("onlyinstead");
     2702    p.append("cleaninstead");
     2703    p.append("bothinstead");
     2704    p.setLonghelp(
     2705      "This is a lagrangean relaxation for TwoMir cuts.  See \
     2706  lagomoryCuts for description of options.");
     2707    parameters.push_back(p);
     2708  }
     2709  {
     2710    CbcOrClpParam p("lift!AndProjectCuts", "Whether to use Lift and Project cuts",
     2711      "off", CBC_PARAM_STR_LANDPCUTS);
     2712
     2713    p.append("on");
     2714    p.append("root");
     2715    p.append("ifmove");
     2716    p.append("forceOn");
     2717    p.setLonghelp(
     2718      "Lift and project cuts. \
    23852719May be slow \
    23862720See branchAndCut for information on options.");
    2387   parameters[numberParameters++] = CbcOrClpParam("local!TreeSearch", "Whether to use local treesearch",
    2388     "off", CBC_PARAM_STR_LOCALTREE);
    2389   parameters[numberParameters - 1].append("on");
    2390   parameters[numberParameters - 1].setLonghelp(
    2391     "This switches on a local search algorithm when a solution is found.  This is from \
     2721    parameters.push_back(p);
     2722  }
     2723  {
     2724    CbcOrClpParam p("local!TreeSearch", "Whether to use local treesearch",
     2725      "off", CBC_PARAM_STR_LOCALTREE);
     2726    p.append("on");
     2727    p.setLonghelp(
     2728      "This switches on a local search algorithm when a solution is found.  This is from \
    23922729Fischetti and Lodi and is not really a heuristic although it can be used as one. \
    23932730When used from Coin solve it has limited functionality.  It is not switched on when \
    23942731heuristics are switched on.");
    2395 #endif
     2732    parameters.push_back(p);
     2733  }
     2734#endif
     2735  {
    23962736#ifndef COIN_HAS_CBC
    2397   parameters[numberParameters++] = CbcOrClpParam("log!Level", "Level of detail in Solver output",
    2398     -1, 999999, CLP_PARAM_INT_SOLVERLOGLEVEL);
     2737    CbcOrClpParam p("log!Level", "Level of detail in Solver output",
     2738      -1, 999999, CLP_PARAM_INT_SOLVERLOGLEVEL);
     2739    parameters.push_back(p);
    23992740#else
    2400   parameters[numberParameters++] = CbcOrClpParam("log!Level", "Level of detail in Coin branch and Cut output",
    2401     -63, 63, CLP_PARAM_INT_LOGLEVEL);
    2402   parameters[numberParameters - 1].setIntValue(1);
    2403 #endif
    2404   parameters[numberParameters - 1].setLonghelp(
    2405     "If 0 then there should be no output in normal circumstances.  1 is probably the best\
     2741    CbcOrClpParam p("log!Level", "Level of detail in Coin branch and Cut output",
     2742      -63, 63, CLP_PARAM_INT_LOGLEVEL);
     2743    p.setIntValue(1);
     2744#endif
     2745    p.setLonghelp(
     2746      "If 0 then there should be no output in normal circumstances.  1 is probably the best\
    24062747 value for most uses, while 2 and 3 give more information.");
    2407   parameters[numberParameters++] = CbcOrClpParam("max!imize", "Set optimization direction to maximize",
    2408     CLP_PARAM_ACTION_MAXIMIZE, 7);
    2409   parameters[numberParameters - 1].setLonghelp(
    2410     "The default is minimize - use 'maximize' for maximization.\n\
     2748    parameters.push_back(p);
     2749  }
     2750  {
     2751    CbcOrClpParam p("max!imize", "Set optimization direction to maximize",
     2752      CLP_PARAM_ACTION_MAXIMIZE, 7);
     2753    p.setLonghelp(
     2754      "The default is minimize - use 'maximize' for maximization.\n\
    24112755You can also use the parameters 'direction maximize'.");
     2756    parameters.push_back(p);
     2757  }
    24122758#ifdef COIN_HAS_CLP
    2413   parameters[numberParameters++] = CbcOrClpParam("maxF!actor", "Maximum number of iterations between \
     2759  {
     2760    CbcOrClpParam p("maxF!actor", "Maximum number of iterations between \
    24142761refactorizations",
    2415     1, 999999, CLP_PARAM_INT_MAXFACTOR);
    2416   parameters[numberParameters - 1].setLonghelp(
    2417     "If this is at its initial value of 200 then in this executable clp will guess at a\
     2762      1, 999999, CLP_PARAM_INT_MAXFACTOR);
     2763    p.setLonghelp(
     2764      "If this is at its initial value of 200 then in this executable clp will guess at a\
    24182765 value to use.  Otherwise the user can set a value.  The code may decide to re-factorize\
    24192766 earlier for accuracy.");
    2420   parameters[numberParameters++] = CbcOrClpParam("maxIt!erations", "Maximum number of iterations before \
     2767    parameters.push_back(p);
     2768  }
     2769  {
     2770    CbcOrClpParam p("maxIt!erations", "Maximum number of iterations before \
    24212771stopping",
    2422     0, 2147483647, CLP_PARAM_INT_MAXITERATION);
    2423   parameters[numberParameters - 1].setLonghelp(
    2424     "This can be used for testing purposes.  The corresponding library call\n\
     2772      0, 2147483647, CLP_PARAM_INT_MAXITERATION);
     2773    p.setLonghelp(
     2774      "This can be used for testing purposes.  The corresponding library call\n\
    24252775      \tsetMaximumIterations(value)\n can be useful.  If the code stops on\
    24262776 seconds or by an interrupt this will be treated as stopping on maximum iterations.  This is ignored in branchAndCut - use maxN!odes.");
    2427 #endif
    2428 #ifdef COIN_HAS_CBC
    2429   parameters[numberParameters++] = CbcOrClpParam("maxN!odes", "Maximum number of nodes to do",
    2430     -1, 2147483647, CBC_PARAM_INT_MAXNODES);
    2431   parameters[numberParameters - 1].setLonghelp(
    2432     "This is a repeatable way to limit search.  Normally using time is easier \
     2777    parameters.push_back(p);
     2778  }
     2779#endif
     2780#ifdef COIN_HAS_CBC
     2781  {
     2782    CbcOrClpParam p("maxN!odes", "Maximum number of nodes to do",
     2783      -1, 2147483647, CBC_PARAM_INT_MAXNODES);
     2784    p.setLonghelp(
     2785      "This is a repeatable way to limit search.  Normally using time is easier \
    24332786but then the results may not be repeatable.");
    2434   parameters[numberParameters++] = CbcOrClpParam("maxSaved!Solutions", "Maximum number of solutions to save",
    2435     0, 2147483647, CBC_PARAM_INT_MAXSAVEDSOLS);
    2436   parameters[numberParameters - 1].setLonghelp(
    2437     "Number of solutions to save.");
    2438   parameters[numberParameters++] = CbcOrClpParam("maxSo!lutions", "Maximum number of solutions to get",
    2439     1, 2147483647, CBC_PARAM_INT_MAXSOLS);
    2440   parameters[numberParameters - 1].setLonghelp(
    2441     "You may want to stop after (say) two solutions or an hour.  \
     2787    parameters.push_back(p);
     2788  }
     2789  {
     2790    CbcOrClpParam p("maxSaved!Solutions", "Maximum number of solutions to save",
     2791      0, 2147483647, CBC_PARAM_INT_MAXSAVEDSOLS);
     2792    p.setLonghelp(
     2793      "Number of solutions to save.");
     2794    parameters.push_back(p);
     2795  }
     2796  {
     2797    CbcOrClpParam p("maxSo!lutions", "Maximum number of solutions to get",
     2798      1, 2147483647, CBC_PARAM_INT_MAXSOLS);
     2799    p.setLonghelp(
     2800      "You may want to stop after (say) two solutions or an hour.  \
    24422801This is checked every node in tree, so it is possible to get more solutions from heuristics.");
    2443 #endif
    2444   parameters[numberParameters++] = CbcOrClpParam("min!imize", "Set optimization direction to minimize",
    2445     CLP_PARAM_ACTION_MINIMIZE, 7);
    2446   parameters[numberParameters - 1].setLonghelp(
    2447     "The default is minimize - use 'maximize' for maximization.\n\
     2802    parameters.push_back(p);
     2803  }
     2804#endif
     2805  {
     2806    CbcOrClpParam p("min!imize", "Set optimization direction to minimize",
     2807      CLP_PARAM_ACTION_MINIMIZE, 7);
     2808    p.setLonghelp(
     2809      "The default is minimize - use 'maximize' for maximization.\n\
    24482810This should only be necessary if you have previously set maximization \
    24492811You can also use the parameters 'direction minimize'.");
    2450 #ifdef COIN_HAS_CBC
    2451   parameters[numberParameters++] = CbcOrClpParam("mipO!ptions", "Dubious options for mip",
    2452     0, COIN_INT_MAX, CBC_PARAM_INT_MIPOPTIONS, 0);
    2453   parameters[numberParameters++] = CbcOrClpParam("more!MipOptions", "More dubious options for mip",
    2454     -1, COIN_INT_MAX, CBC_PARAM_INT_MOREMIPOPTIONS, 0);
    2455   parameters[numberParameters++] = CbcOrClpParam("more2!MipOptions", "More more dubious options for mip",
    2456     -1, COIN_INT_MAX, CBC_PARAM_INT_MOREMOREMIPOPTIONS, 0);
    2457   parameters[numberParameters - 1].setIntValue(0);
    2458   parameters[numberParameters++] = CbcOrClpParam("mixed!IntegerRoundingCuts", "Whether to use Mixed Integer Rounding cuts",
    2459     "off", CBC_PARAM_STR_MIXEDCUTS);
    2460   parameters[numberParameters - 1].append("on");
    2461   parameters[numberParameters - 1].append("root");
    2462   parameters[numberParameters - 1].append("ifmove");
    2463   parameters[numberParameters - 1].append("forceOn");
    2464   parameters[numberParameters - 1].append("onglobal");
    2465   parameters[numberParameters - 1].setLonghelp(
    2466     "This switches on mixed integer rounding cuts (either at root or in entire tree) \
     2812    parameters.push_back(p);
     2813  }
     2814#ifdef COIN_HAS_CBC
     2815  {
     2816    CbcOrClpParam p("mipO!ptions", "Dubious options for mip",
     2817      0, COIN_INT_MAX, CBC_PARAM_INT_MIPOPTIONS, 0);
     2818    parameters.push_back(p);
     2819  }
     2820  {
     2821    CbcOrClpParam p("more!MipOptions", "More dubious options for mip",
     2822      -1, COIN_INT_MAX, CBC_PARAM_INT_MOREMIPOPTIONS, 0);
     2823    parameters.push_back(p);
     2824  }
     2825  {
     2826    CbcOrClpParam p("more2!MipOptions", "More more dubious options for mip",
     2827      -1, COIN_INT_MAX, CBC_PARAM_INT_MOREMOREMIPOPTIONS, 0);
     2828    p.setIntValue(0);
     2829    parameters.push_back(p);
     2830  }
     2831  {
     2832    CbcOrClpParam p("mixed!IntegerRoundingCuts", "Whether to use Mixed Integer Rounding cuts",
     2833      "off", CBC_PARAM_STR_MIXEDCUTS);
     2834
     2835    p.append("on");
     2836    p.append("root");
     2837    p.append("ifmove");
     2838    p.append("forceOn");
     2839    p.append("onglobal");
     2840    p.setLonghelp(
     2841      "This switches on mixed integer rounding cuts (either at root or in entire tree) \
    24672842See branchAndCut for information on options.");
    2468 #endif
    2469   parameters[numberParameters++] = CbcOrClpParam("mess!ages", "Controls if Clpnnnn is printed",
    2470     "off", CLP_PARAM_STR_MESSAGES);
    2471   parameters[numberParameters - 1].append("on");
    2472   parameters[numberParameters - 1].setLonghelp("The default behavior is to put out messages such as:\n\
     2843    parameters.push_back(p);
     2844  }
     2845#endif
     2846  {
     2847    CbcOrClpParam p("mess!ages", "Controls if Clpnnnn is printed",
     2848      "off", CLP_PARAM_STR_MESSAGES);
     2849
     2850    p.append("on");
     2851    p.setLonghelp("The default behavior is to put out messages such as:\n\
    24732852   Clp0005 2261  Objective 109.024 Primal infeas 944413 (758)\n\
    24742853but this program turns this off to make it look more friendly.  It can be useful\
    24752854 to turn them back on if you want to be able to 'grep' for particular messages or if\
    24762855 you intend to override the behavior of a particular message.  This only affects Clp not Cbc.");
    2477   parameters[numberParameters++] = CbcOrClpParam("miplib", "Do some of miplib test set",
    2478     CBC_PARAM_ACTION_MIPLIB, 3, 1);
    2479 #ifdef COIN_HAS_CBC
    2480   parameters[numberParameters++] = CbcOrClpParam("mips!tart", "reads an initial feasible solution from file",
    2481     CBC_PARAM_ACTION_MIPSTART);
    2482   parameters[numberParameters - 1].setLonghelp("\
     2856    parameters.push_back(p);
     2857  }
     2858  {
     2859    CbcOrClpParam p("miplib", "Do some of miplib test set",
     2860      CBC_PARAM_ACTION_MIPLIB, 3, 1);
     2861    parameters.push_back(p);
     2862  }
     2863#ifdef COIN_HAS_CBC
     2864  {
     2865    CbcOrClpParam p("mips!tart", "reads an initial feasible solution from file",
     2866      CBC_PARAM_ACTION_MIPSTART);
     2867    p.setLonghelp("\
    24832868The MIPStart allows one to enter an initial integer feasible solution \
    24842869to CBC. Values of the main decision variables which are active (have \
     
    25142899\n\n\
    25152900Question and suggestions regarding MIPStart can be directed to\n\
    2516 haroldo.santos@gmail.com.\
    2517 ");
    2518 #endif
    2519   parameters[numberParameters++] = CbcOrClpParam("moreS!pecialOptions", "Yet more dubious options for Simplex - see ClpSimplex.hpp",
    2520     0, COIN_INT_MAX, CLP_PARAM_INT_MORESPECIALOPTIONS, 0);
    2521 #ifdef COIN_HAS_CBC
    2522   parameters[numberParameters++] = CbcOrClpParam("moreT!une", "Yet more dubious ideas for feasibility pump",
    2523     0, 100000000, CBC_PARAM_INT_FPUMPTUNE2, 0);
    2524   parameters[numberParameters - 1].setLonghelp(
    2525     "Yet more ideas for Feasibility Pump \n\
     2901haroldo.santos@gmail.com. ");
     2902    parameters.push_back(p);
     2903  }
     2904#endif
     2905  {
     2906    CbcOrClpParam p("moreS!pecialOptions", "Yet more dubious options for Simplex - see ClpSimplex.hpp",
     2907      0, COIN_INT_MAX, CLP_PARAM_INT_MORESPECIALOPTIONS, 0);
     2908    parameters.push_back(p);
     2909  }
     2910#ifdef COIN_HAS_CBC
     2911  {
     2912    CbcOrClpParam p("moreT!une", "Yet more dubious ideas for feasibility pump",
     2913      0, 100000000, CBC_PARAM_INT_FPUMPTUNE2, 0);
     2914
     2915    p.setLonghelp(
     2916      "Yet more ideas for Feasibility Pump \n\
    25262917\t/100000 == 1 use box constraints and original obj in cleanup\n\
    25272918\t/1000 == 1 Pump will run twice if no solution found\n\
     
    25312922\t/100 == 2,3.. allow more iterations per pass\n\
    25322923\t n fix if value of variable same for last n iterations.");
    2533   parameters[numberParameters - 1].setIntValue(0);
    2534   parameters[numberParameters++] = CbcOrClpParam("multiple!RootPasses", "Do multiple root passes to collect cuts and solutions",
    2535     0, 100000000, CBC_PARAM_INT_MULTIPLEROOTS, 0);
    2536   parameters[numberParameters - 1].setIntValue(0);
    2537   parameters[numberParameters - 1].setLonghelp(
    2538     "Do (in parallel if threads enabled) the root phase this number of times \
     2924    p.setIntValue(0);
     2925    parameters.push_back(p);
     2926  }
     2927  {
     2928    CbcOrClpParam p("multiple!RootPasses", "Do multiple root passes to collect cuts and solutions",
     2929      0, 100000000, CBC_PARAM_INT_MULTIPLEROOTS, 0);
     2930    p.setIntValue(0);
     2931    p.setLonghelp(
     2932      "Do (in parallel if threads enabled) the root phase this number of times \
    25392933 and collect all solutions and cuts generated.  The actual format is aabbcc \
    25402934where aa is number of extra passes, if bb is non zero \
     
    25452939The solvers do not interact with each other.  However if extra passes are specified \
    25462940then cuts are collected and used in later passes - so there is interaction there.");
    2547   parameters[numberParameters++] = CbcOrClpParam("naive!Heuristics", "Whether to try some stupid heuristic",
    2548     "off", CBC_PARAM_STR_NAIVE, 7, 1);
    2549   parameters[numberParameters - 1].append("on");
    2550   parameters[numberParameters - 1].append("both");
    2551   parameters[numberParameters - 1].append("before");
    2552   parameters[numberParameters - 1].setLonghelp(
    2553     "Really silly stuff e.g. fix all integers with costs to zero!. \
     2941    parameters.push_back(p);
     2942  }
     2943  {
     2944    CbcOrClpParam p("naive!Heuristics", "Whether to try some stupid heuristic",
     2945      "off", CBC_PARAM_STR_NAIVE, 7, 1);
     2946
     2947    p.append("on");
     2948    p.append("both");
     2949    p.append("before");
     2950    p.setLonghelp(
     2951      "Really silly stuff e.g. fix all integers with costs to zero!. \
    25542952Doh option does heuristic before preprocessing");
     2953    parameters.push_back(p);
     2954  }
    25552955#endif
    25562956#ifdef COIN_HAS_CLP
    2557   parameters[numberParameters++] = CbcOrClpParam("netlib", "Solve entire netlib test set",
    2558     CLP_PARAM_ACTION_NETLIB_EITHER, 3, 1);
    2559   parameters[numberParameters - 1].setLonghelp(
    2560     "This exercises the unit test for clp and then solves the netlib test set using dual or primal.\
     2957  {
     2958    CbcOrClpParam p("netlib", "Solve entire netlib test set",
     2959      CLP_PARAM_ACTION_NETLIB_EITHER, 3, 1);
     2960    p.setLonghelp(
     2961      "This exercises the unit test for clp and then solves the netlib test set using dual or primal.\
    25612962The user can set options before e.g. clp -presolve off -netlib");
    2562   parameters[numberParameters++] = CbcOrClpParam("netlibB!arrier", "Solve entire netlib test set with barrier",
    2563     CLP_PARAM_ACTION_NETLIB_BARRIER, 3, 1);
    2564   parameters[numberParameters - 1].setLonghelp(
    2565     "This exercises the unit test for clp and then solves the netlib test set using barrier.\
     2963    parameters.push_back(p);
     2964  }
     2965  {
     2966    CbcOrClpParam p("netlibB!arrier", "Solve entire netlib test set with barrier",
     2967      CLP_PARAM_ACTION_NETLIB_BARRIER, 3, 1);
     2968    p.setLonghelp(
     2969      "This exercises the unit test for clp and then solves the netlib test set using barrier.\
    25662970The user can set options before e.g. clp -kkt on -netlib");
    2567   parameters[numberParameters++] = CbcOrClpParam("netlibD!ual", "Solve entire netlib test set (dual)",
    2568     CLP_PARAM_ACTION_NETLIB_DUAL, 3, 1);
    2569   parameters[numberParameters - 1].setLonghelp(
    2570     "This exercises the unit test for clp and then solves the netlib test set using dual.\
     2971    parameters.push_back(p);
     2972  }
     2973  {
     2974    CbcOrClpParam p("netlibD!ual", "Solve entire netlib test set (dual)",
     2975      CLP_PARAM_ACTION_NETLIB_DUAL, 3, 1);
     2976
     2977    p.setLonghelp(
     2978      "This exercises the unit test for clp and then solves the netlib test set using dual.\
    25712979The user can set options before e.g. clp -presolve off -netlib");
    2572   parameters[numberParameters++] = CbcOrClpParam("netlibP!rimal", "Solve entire netlib test set (primal)",
    2573     CLP_PARAM_ACTION_NETLIB_PRIMAL, 3, 1);
    2574   parameters[numberParameters - 1].setLonghelp(
    2575     "This exercises the unit test for clp and then solves the netlib test set using primal.\
     2980    parameters.push_back(p);
     2981  }
     2982  {
     2983    CbcOrClpParam p("netlibP!rimal", "Solve entire netlib test set (primal)",
     2984      CLP_PARAM_ACTION_NETLIB_PRIMAL, 3, 1);
     2985    p.setLonghelp(
     2986      "This exercises the unit test for clp and then solves the netlib test set using primal.\
    25762987The user can set options before e.g. clp -presolve off -netlibp");
    2577   parameters[numberParameters++] = CbcOrClpParam("netlibT!une", "Solve entire netlib test set with 'best' algorithm",
    2578     CLP_PARAM_ACTION_NETLIB_TUNE, 3, 1);
    2579   parameters[numberParameters - 1].setLonghelp(
    2580     "This exercises the unit test for clp and then solves the netlib test set using whatever \
     2988    parameters.push_back(p);
     2989  }
     2990  {
     2991    CbcOrClpParam p("netlibT!une", "Solve entire netlib test set with 'best' algorithm",
     2992      CLP_PARAM_ACTION_NETLIB_TUNE, 3, 1);
     2993    p.setLonghelp(
     2994      "This exercises the unit test for clp and then solves the netlib test set using whatever \
    25812995works best.  I know this is cheating but it also stresses the code better by doing a \
    25822996mixture of stuff.  The best algorithm was chosen on a Linux ThinkPad using native cholesky \
    25832997with University of Florida ordering.");
    2584   parameters[numberParameters++] = CbcOrClpParam("network", "Tries to make network matrix",
    2585     CLP_PARAM_ACTION_NETWORK, 7, 0);
    2586   parameters[numberParameters - 1].setLonghelp(
    2587     "Clp will go faster if the matrix can be converted to a network.  The matrix\
     2998    parameters.push_back(p);
     2999  }
     3000  {
     3001    CbcOrClpParam p("network", "Tries to make network matrix",
     3002      CLP_PARAM_ACTION_NETWORK, 7, 0);
     3003    p.setLonghelp(
     3004      "Clp will go faster if the matrix can be converted to a network.  The matrix\
    25883005 operations may be a bit faster with more efficient storage, but the main advantage\
    25893006 comes from using a network factorization.  It will probably not be as fast as a \
    25903007specialized network code.");
    2591 #ifdef COIN_HAS_CBC
    2592   parameters[numberParameters++] = CbcOrClpParam("nextB!estSolution", "Prints next best saved solution to file",
    2593     CLP_PARAM_ACTION_NEXTBESTSOLUTION);
    2594   parameters[numberParameters - 1].setLonghelp(
    2595     "To write best solution, just use solution.  This prints next best (if exists) \
     3008    parameters.push_back(p);
     3009  }
     3010#ifdef COIN_HAS_CBC
     3011  {
     3012    CbcOrClpParam p("nextB!estSolution", "Prints next best saved solution to file",
     3013      CLP_PARAM_ACTION_NEXTBESTSOLUTION);
     3014
     3015    p.setLonghelp(
     3016      "To write best solution, just use solution.  This prints next best (if exists) \
    25963017 and then deletes it. \
    25973018 This will write a primitive solution file to the given file name.  It will use the default\
    25983019 directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
    25993020 is initialized to 'stdout'.  The amount of output can be varied using printi!ngOptions or printMask.");
    2600   parameters[numberParameters++] = CbcOrClpParam("node!Strategy", "What strategy to use to select nodes",
    2601     "hybrid", CBC_PARAM_STR_NODESTRATEGY);
    2602   parameters[numberParameters - 1].append("fewest");
    2603   parameters[numberParameters - 1].append("depth");
    2604   parameters[numberParameters - 1].append("upfewest");
    2605   parameters[numberParameters - 1].append("downfewest");
    2606   parameters[numberParameters - 1].append("updepth");
    2607   parameters[numberParameters - 1].append("downdepth");
    2608   parameters[numberParameters - 1].setLonghelp(
    2609     "Normally before a solution the code will choose node with fewest infeasibilities. \
     3021    parameters.push_back(p);
     3022  }
     3023  {
     3024    CbcOrClpParam p("node!Strategy", "What strategy to use to select nodes",
     3025      "hybrid", CBC_PARAM_STR_NODESTRATEGY);
     3026    p.append("fewest");
     3027    p.append("depth");
     3028    p.append("upfewest");
     3029    p.append("downfewest");
     3030    p.append("updepth");
     3031    p.append("downdepth");
     3032    p.setLonghelp(
     3033      "Normally before a solution the code will choose node with fewest infeasibilities. \
    26103034You can choose depth as the criterion.  You can also say if up or down branch must \
    26113035be done first (the up down choice will carry on after solution). \
    26123036Default has now been changed to hybrid which is breadth first on small depth nodes then fewest.");
    2613   parameters[numberParameters++] = CbcOrClpParam("numberA!nalyze", "Number of analysis iterations",
    2614     -COIN_INT_MAX, COIN_INT_MAX, CBC_PARAM_INT_NUMBERANALYZE, 0);
    2615   parameters[numberParameters - 1].setLonghelp(
    2616     "This says how many iterations to spend at root node analyzing problem. \
     3037    parameters.push_back(p);
     3038  }
     3039  {
     3040    CbcOrClpParam p("numberA!nalyze", "Number of analysis iterations",
     3041      -COIN_INT_MAX, COIN_INT_MAX, CBC_PARAM_INT_NUMBERANALYZE, 0);
     3042    p.setLonghelp(
     3043      "This says how many iterations to spend at root node analyzing problem. \
    26173044This is a first try and will hopefully become more sophisticated.");
    2618 #endif
    2619   parameters[numberParameters++] = CbcOrClpParam("objective!Scale", "Scale factor to apply to objective",
    2620     -1.0e20, 1.0e20, CLP_PARAM_DBL_OBJSCALE, 1);
    2621   parameters[numberParameters - 1].setLonghelp(
    2622     "If the objective function has some very large values, you may wish to scale them\
     3045    parameters.push_back(p);
     3046  }
     3047#endif
     3048  {
     3049    CbcOrClpParam p("objective!Scale", "Scale factor to apply to objective",
     3050      -1.0e20, 1.0e20, CLP_PARAM_DBL_OBJSCALE, 1);
     3051    p.setLonghelp(
     3052      "If the objective function has some very large values, you may wish to scale them\
    26233053 internally by this amount.  It can also be set by autoscale.  It is applied after scaling.  You are unlikely to need this.");
    2624   parameters[numberParameters - 1].setDoubleValue(1.0);
     3054    p.setDoubleValue(1.0);
     3055    parameters.push_back(p);
     3056  }
    26253057#endif
    26263058#ifdef COIN_HAS_CBC
    26273059#ifdef COIN_HAS_NTY
    2628   parameters[numberParameters++] = CbcOrClpParam("Orbit!alBranching", "Whether to try orbital branching",
    2629     "off", CBC_PARAM_STR_ORBITAL);
    2630   parameters[numberParameters - 1].append("on");
    2631   parameters[numberParameters - 1].append("strong");
    2632   parameters[numberParameters - 1].append("force");
    2633   parameters[numberParameters - 1].append("simple");
    2634   parameters[numberParameters - 1].setLonghelp(
    2635     "This switches on Orbital branching. \
     3060  {
     3061    CbcOrClpParam p("Orbit!alBranching", "Whether to try orbital branching",
     3062      "off", CBC_PARAM_STR_ORBITAL);
     3063    p.append("on");
     3064    p.append("strong");
     3065    p.append("force");
     3066    p.append("simple");
     3067    p.setLonghelp(
     3068      "This switches on Orbital branching. \
    26363069On just adds orbital, strong tries extra fixing in strong branching");
    2637 #endif
    2638   parameters[numberParameters++] = CbcOrClpParam("PrepN!ames", "If column names will be kept in pre-processed model",
    2639     "off", CBC_PARAM_STR_PREPROCNAMES);
    2640   parameters[numberParameters - 1].append("on");
    2641   parameters[numberParameters - 1].setLonghelp(
    2642     "Normally the preprocessed model has column names replaced by new names C0000...\
     3070    parameters.push_back(p);
     3071  }
     3072#endif
     3073  {
     3074    CbcOrClpParam p("PrepN!ames", "If column names will be kept in pre-processed model",
     3075      "off", CBC_PARAM_STR_PREPROCNAMES);
     3076    p.append("on");
     3077    p.setLonghelp(
     3078      "Normally the preprocessed model has column names replaced by new names C0000...\
    26433079Setting this option to on keeps original names in variables which still exist in the preprocessed problem");
    2644 
    2645   parameters[numberParameters++] = CbcOrClpParam("outDup!licates", "takes duplicate rows etc out of integer model",
    2646     CLP_PARAM_ACTION_OUTDUPROWS, 7, 0);
    2647 #endif
    2648   parameters[numberParameters++] = CbcOrClpParam("output!Format", "Which output format to use",
    2649     1, 6, CLP_PARAM_INT_OUTPUTFORMAT);
    2650   parameters[numberParameters - 1].setLonghelp(
    2651     "Normally export will be done using normal representation for numbers and two values\
     3080    parameters.push_back(p);
     3081  }
     3082
     3083  {
     3084    CbcOrClpParam p("outDup!licates", "takes duplicate rows etc out of integer model",
     3085      CLP_PARAM_ACTION_OUTDUPROWS, 7, 0);
     3086    parameters.push_back(p);
     3087  }
     3088#endif
     3089  {
     3090    CbcOrClpParam p("output!Format", "Which output format to use",
     3091      1, 6, CLP_PARAM_INT_OUTPUTFORMAT);
     3092    p.setLonghelp(
     3093      "Normally export will be done using normal representation for numbers and two values\
    26523094 per line.  You may want to do just one per line (for grep or suchlike) and you may wish\
    26533095 to save with absolute accuracy using a coded version of the IEEE value. A value of 2 is normal.\
     
    26553097 gives greater precision, while 5,6 give IEEE values.  When used for exporting a basis 1 does not save \
    26563098values, 2 saves values, 3 with greater accuracy and 4 in IEEE.");
     3099    parameters.push_back(p);
     3100  }
    26573101#ifdef COIN_HAS_CLP
    2658   parameters[numberParameters++] = CbcOrClpParam("para!metrics", "Import data from file and do parametrics",
    2659     CLP_PARAM_ACTION_PARAMETRICS, 3);
    2660   parameters[numberParameters - 1].setLonghelp(
    2661     "This will read a file with parametric data from the given file name \
     3102  {
     3103    CbcOrClpParam p("para!metrics", "Import data from file and do parametrics",
     3104      CLP_PARAM_ACTION_PARAMETRICS, 3);
     3105    p.setLonghelp(
     3106      "This will read a file with parametric data from the given file name \
    26623107and then do parametrics.  It will use the default\
    26633108 directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
     
    26783123 Exactly one of name and number must be given for either section and \
    26793124missing ones have value 0.0.");
    2680 #endif
    2681 #ifdef COIN_HAS_CBC
    2682   parameters[numberParameters++] = CbcOrClpParam("passC!uts", "Number of cut passes at root node",
    2683     -9999999, 9999999, CBC_PARAM_INT_CUTPASS);
    2684   parameters[numberParameters - 1].setLonghelp(
    2685     "The default is 100 passes if less than 500 columns, 100 passes (but \
     3125    parameters.push_back(p);
     3126  }
     3127#endif
     3128#ifdef COIN_HAS_CBC
     3129  {
     3130    CbcOrClpParam p("passC!uts", "Number of cut passes at root node",
     3131      -9999999, 9999999, CBC_PARAM_INT_CUTPASS);
     3132
     3133    p.setLonghelp(
     3134      "The default is 100 passes if less than 500 columns, 100 passes (but \
    26863135stop if drop small if less than 5000 columns, 20 otherwise");
    2687   parameters[numberParameters++] = CbcOrClpParam("passF!easibilityPump", "How many passes in feasibility pump",
    2688     0, 10000, CBC_PARAM_INT_FPUMPITS);
    2689   parameters[numberParameters - 1].setLonghelp(
    2690     "This fine tunes Feasibility Pump by doing more or fewer passes.");
    2691   parameters[numberParameters - 1].setIntValue(20);
     3136    parameters.push_back(p);
     3137  }
     3138  {
     3139    CbcOrClpParam p("passF!easibilityPump", "How many passes in feasibility pump",
     3140      0, 10000, CBC_PARAM_INT_FPUMPITS);
     3141    p.setLonghelp(
     3142      "This fine tunes Feasibility Pump by doing more or fewer passes.");
     3143    p.setIntValue(20);
     3144    parameters.push_back(p);
     3145  }
    26923146#endif
    26933147#ifdef COIN_HAS_CLP
    2694   parameters[numberParameters++] = CbcOrClpParam("passP!resolve", "How many passes in presolve",
    2695     -200, 100, CLP_PARAM_INT_PRESOLVEPASS, 1);
    2696   parameters[numberParameters - 1].setLonghelp(
    2697     "Normally Presolve does 10 passes but you may want to do less to make it\
     3148  {
     3149    CbcOrClpParam p("passP!resolve", "How many passes in presolve",
     3150      -200, 100, CLP_PARAM_INT_PRESOLVEPASS, 1);
     3151    p.setLonghelp(
     3152      "Normally Presolve does 10 passes but you may want to do less to make it\
    26983153 more lightweight or do more if improvements are still being made.  As Presolve will return\
    26993154 if nothing is being taken out, you should not normally need to use this fine tuning.");
    2700 #endif
    2701 #ifdef COIN_HAS_CBC
    2702   parameters[numberParameters++] = CbcOrClpParam("passT!reeCuts", "Number of cut passes in tree",
    2703     -9999999, 9999999, CBC_PARAM_INT_CUTPASSINTREE);
    2704   parameters[numberParameters - 1].setLonghelp(
    2705     "The default is one pass");
     3155    parameters.push_back(p);
     3156  }
     3157#endif
     3158#ifdef COIN_HAS_CBC
     3159  {
     3160    CbcOrClpParam p("passT!reeCuts", "Number of cut passes in tree",
     3161      -9999999, 9999999, CBC_PARAM_INT_CUTPASSINTREE);
     3162    p.setLonghelp("The default is one pass");
     3163    parameters.push_back(p);
     3164  }
    27063165#endif
    27073166#ifdef COIN_HAS_CLP
    2708   parameters[numberParameters++] = CbcOrClpParam("pertV!alue", "Method of perturbation",
    2709     -5000, 102, CLP_PARAM_INT_PERTVALUE, 1);
    2710   parameters[numberParameters++] = CbcOrClpParam("perturb!ation", "Whether to perturb problem",
    2711     "on", CLP_PARAM_STR_PERTURBATION);
    2712   parameters[numberParameters - 1].append("off");
    2713   parameters[numberParameters - 1].setLonghelp(
    2714     "Perturbation helps to stop cycling, but Clp uses other measures for this.\
     3167  {
     3168    CbcOrClpParam p("pertV!alue", "Method of perturbation",
     3169      -5000, 102, CLP_PARAM_INT_PERTVALUE, 1);
     3170    parameters.push_back(p);
     3171  }
     3172  {
     3173    CbcOrClpParam p("perturb!ation", "Whether to perturb problem",
     3174      "on", CLP_PARAM_STR_PERTURBATION);
     3175    p.append("off");
     3176    p.setLonghelp(
     3177      "Perturbation helps to stop cycling, but Clp uses other measures for this.\
    27153178  However large problems and especially ones with unit elements and unit rhs or costs\
    27163179 benefit from perturbation.  Normally Clp tries to be intelligent, but you can switch this off.\
    27173180  The Clp library has this off by default.  This program has it on by default.");
    2718   parameters[numberParameters++] = CbcOrClpParam("PFI", "Whether to use Product Form of Inverse in simplex",
    2719     "off", CLP_PARAM_STR_PFI, 7, 0);
    2720   parameters[numberParameters - 1].append("on");
    2721   parameters[numberParameters - 1].setLonghelp(
    2722     "By default clp uses Forrest-Tomlin L-U update.  If you are masochistic you can switch it off.");
    2723 #endif
    2724 #ifdef COIN_HAS_CBC
    2725   parameters[numberParameters++] = CbcOrClpParam("pivotAndC!omplement", "Whether to try Pivot and Complement heuristic",
    2726     "off", CBC_PARAM_STR_PIVOTANDCOMPLEMENT);
    2727   parameters[numberParameters - 1].append("on");
    2728   parameters[numberParameters - 1].append("both");
    2729   parameters[numberParameters - 1].append("before");
    2730   parameters[numberParameters - 1].setLonghelp(
    2731     "stuff needed. \
     3181    parameters.push_back(p);
     3182  }
     3183  {
     3184    CbcOrClpParam p("PFI", "Whether to use Product Form of Inverse in simplex",
     3185      "off", CLP_PARAM_STR_PFI, 7, 0);
     3186    p.append("on");
     3187    p.setLonghelp(
     3188      "By default clp uses Forrest-Tomlin L-U update.  If you are masochistic you can switch it off.");
     3189    parameters.push_back(p);
     3190  }
     3191#endif
     3192#ifdef COIN_HAS_CBC
     3193  {
     3194    CbcOrClpParam p("pivotAndC!omplement", "Whether to try Pivot and Complement heuristic",
     3195      "off", CBC_PARAM_STR_PIVOTANDCOMPLEMENT);
     3196
     3197    p.append("on");
     3198    p.append("both");
     3199    p.append("before");
     3200    p.setLonghelp(
     3201      "stuff needed. \
    27323202Doh option does heuristic before preprocessing");
    2733   parameters[numberParameters++] = CbcOrClpParam("pivotAndF!ix", "Whether to try Pivot and Fix heuristic",
    2734     "off", CBC_PARAM_STR_PIVOTANDFIX);
    2735   parameters[numberParameters - 1].append("on");
    2736   parameters[numberParameters - 1].append("both");
    2737   parameters[numberParameters - 1].append("before");
    2738   parameters[numberParameters - 1].setLonghelp(
    2739     "stuff needed. \
     3203    parameters.push_back(p);
     3204  }
     3205  {
     3206    CbcOrClpParam p("pivotAndF!ix", "Whether to try Pivot and Fix heuristic",
     3207      "off", CBC_PARAM_STR_PIVOTANDFIX);
     3208    p.append("on");
     3209    p.append("both");
     3210    p.append("before");
     3211    p.setLonghelp(
     3212      "stuff needed. \
    27403213Doh option does heuristic before preprocessing");
     3214    parameters.push_back(p);
     3215  }
    27413216#endif
    27423217#ifdef COIN_HAS_CLP
    2743   parameters[numberParameters++] = CbcOrClpParam("plus!Minus", "Tries to make +- 1 matrix",
    2744     CLP_PARAM_ACTION_PLUSMINUS, 7, 0);
    2745   parameters[numberParameters - 1].setLonghelp(
    2746     "Clp will go slightly faster if the matrix can be converted so that the elements are\
     3218  {
     3219    CbcOrClpParam p("plus!Minus", "Tries to make +- 1 matrix",
     3220      CLP_PARAM_ACTION_PLUSMINUS, 7, 0);
     3221    p.setLonghelp(
     3222      "Clp will go slightly faster if the matrix can be converted so that the elements are\
    27473223 not stored and are known to be unit.  The main advantage is memory use.  Clp may automatically\
    27483224 see if it can convert the problem so you should not need to use this.");
    2749   parameters[numberParameters++] = CbcOrClpParam("pO!ptions", "Dubious print options",
    2750     0, COIN_INT_MAX, CLP_PARAM_INT_PRINTOPTIONS, 1);
    2751   parameters[numberParameters - 1].setIntValue(0);
    2752   parameters[numberParameters - 1].setLonghelp(
    2753     "If this is > 0 then presolve will give more information and branch and cut will give statistics");
    2754   parameters[numberParameters++] = CbcOrClpParam("preO!pt", "Presolve options",
    2755     0, COIN_INT_MAX, CLP_PARAM_INT_PRESOLVEOPTIONS, 0);
    2756 #endif
    2757   parameters[numberParameters++] = CbcOrClpParam("presolve", "Whether to presolve problem",
    2758     "on", CLP_PARAM_STR_PRESOLVE);
    2759   parameters[numberParameters - 1].append("off");
    2760   parameters[numberParameters - 1].append("more");
    2761   parameters[numberParameters - 1].append("file");
    2762   parameters[numberParameters - 1].setLonghelp(
    2763     "Presolve analyzes the model to find such things as redundant equations, equations\
     3225    parameters.push_back(p);
     3226  }
     3227  {
     3228    CbcOrClpParam p("pO!ptions", "Dubious print options",
     3229      0, COIN_INT_MAX, CLP_PARAM_INT_PRINTOPTIONS, 1);
     3230    p.setIntValue(0);
     3231    p.setLonghelp(
     3232      "If this is > 0 then presolve will give more information and branch and cut will give statistics");
     3233    parameters.push_back(p);
     3234  }
     3235  {
     3236    CbcOrClpParam p("preO!pt", "Presolve options",
     3237      0, COIN_INT_MAX, CLP_PARAM_INT_PRESOLVEOPTIONS, 0);
     3238    parameters.push_back(p);
     3239  }
     3240#endif
     3241  {
     3242    CbcOrClpParam p("presolve", "Whether to presolve problem",
     3243      "on", CLP_PARAM_STR_PRESOLVE);
     3244    p.append("off");
     3245    p.append("more");
     3246    p.append("file");
     3247    p.setLonghelp("Presolve analyzes the model to find such things as redundant equations, equations\
    27643248 which fix some variables, equations which can be transformed into bounds etc etc.  For the\
    27653249 initial solve of any problem this is worth doing unless you know that it will have no effect.  \
    27663250on will normally do 5 passes while using 'more' will do 10.  If the problem is very large you may need \
    27673251to write the original to file using 'file'.");
    2768 #ifdef COIN_HAS_CBC
    2769   parameters[numberParameters++] = CbcOrClpParam("preprocess", "Whether to use integer preprocessing",
    2770     "off", CBC_PARAM_STR_PREPROCESS);
    2771   parameters[numberParameters - 1].append("on");
    2772   parameters[numberParameters - 1].append("save");
    2773   parameters[numberParameters - 1].append("equal");
    2774   parameters[numberParameters - 1].append("sos");
    2775   parameters[numberParameters - 1].append("trysos");
    2776   parameters[numberParameters - 1].append("equalall");
    2777   parameters[numberParameters - 1].append("strategy");
    2778   parameters[numberParameters - 1].append("aggregate");
    2779   parameters[numberParameters - 1].append("forcesos");
    2780   parameters[numberParameters - 1].append("stop!aftersaving");
    2781   parameters[numberParameters - 1].setLonghelp(
    2782     "This tries to reduce size of model in a similar way to presolve and \
     3252    parameters.push_back(p);
     3253  }
     3254#ifdef COIN_HAS_CBC
     3255  {
     3256    CbcOrClpParam p("preprocess", "Whether to use integer preprocessing",
     3257      "off", CBC_PARAM_STR_PREPROCESS);
     3258
     3259    p.append("on");
     3260    p.append("save");
     3261    p.append("equal");
     3262    p.append("sos");
     3263    p.append("trysos");
     3264    p.append("equalall");
     3265    p.append("strategy");
     3266    p.append("aggregate");
     3267    p.append("forcesos");
     3268    p.append("stop!aftersaving");
     3269    p.setLonghelp(
     3270      "This tries to reduce size of model in a similar way to presolve and \
    27833271it also tries to strengthen the model - this can be very useful and is worth trying. \
    27843272 Save option saves on file presolved.mps.  equal will turn <= cliques into \
     
    27873275valid inequalities into equalities with integer slacks.  strategy is as \
    27883276on but uses CbcStrategy.");
     3277    parameters.push_back(p);
     3278  }
    27893279#endif
    27903280#ifdef COIN_HAS_CLP
    2791   parameters[numberParameters++] = CbcOrClpParam("preT!olerance", "Tolerance to use in presolve",
    2792     1.0e-20, 1.0e12, CLP_PARAM_DBL_PRESOLVETOLERANCE);
    2793   parameters[numberParameters - 1].setLonghelp(
    2794     "The default is 1.0e-8 - you may wish to try 1.0e-7 if presolve says the problem is \
     3281  {
     3282    CbcOrClpParam p("preT!olerance", "Tolerance to use in presolve",
     3283      1.0e-20, 1.0e12, CLP_PARAM_DBL_PRESOLVETOLERANCE);
     3284    p.setLonghelp(
     3285      "The default is 1.0e-8 - you may wish to try 1.0e-7 if presolve says the problem is \
    27953286infeasible and you have awkward numbers and you are sure the problem is really feasible.");
    2796   parameters[numberParameters++] = CbcOrClpParam("primalP!ivot", "Primal pivot choice algorithm",
    2797     "auto!matic", CLP_PARAM_STR_PRIMALPIVOT, 7, 1);
    2798   parameters[numberParameters - 1].append("exa!ct");
    2799   parameters[numberParameters - 1].append("dant!zig");
    2800   parameters[numberParameters - 1].append("part!ial");
    2801   parameters[numberParameters - 1].append("steep!est");
    2802   parameters[numberParameters - 1].append("change");
    2803   parameters[numberParameters - 1].append("sprint");
    2804   parameters[numberParameters - 1].append("PEsteep!est");
    2805   parameters[numberParameters - 1].append("PEdantzig");
    2806   parameters[numberParameters - 1].setLonghelp(
    2807     "Clp can use any pivot selection algorithm which the user codes as long as it\
     3287    parameters.push_back(p);
     3288  }
     3289  {
     3290    CbcOrClpParam p("primalP!ivot", "Primal pivot choice algorithm",
     3291      "auto!matic", CLP_PARAM_STR_PRIMALPIVOT, 7, 1);
     3292
     3293    p.append("exa!ct");
     3294    p.append("dant!zig");
     3295    p.append("part!ial");
     3296    p.append("steep!est");
     3297    p.append("change");
     3298    p.append("sprint");
     3299    p.append("PEsteep!est");
     3300    p.append("PEdantzig");
     3301    p.setLonghelp(
     3302      "Clp can use any pivot selection algorithm which the user codes as long as it\
    28083303 implements the features in the abstract pivot base class.  The Dantzig method is implemented\
    28093304 to show a simple method but its use is deprecated.  Exact devex is the method of choice and there\
     
    28163311Towhidi, M., Desrosiers, J., Soumis, F., The positive edge criterion within COIN-OR’s CLP. and \
    28173312Omer, J., Towhidi, M., Soumis, F., The positive edge pricing rule for the dual simplex.");
    2818   parameters[numberParameters++] = CbcOrClpParam("primalS!implex", "Do primal simplex algorithm",
    2819     CLP_PARAM_ACTION_PRIMALSIMPLEX);
    2820   parameters[numberParameters - 1].setLonghelp(
    2821     "This command solves the continuous relaxation of the current model using the primal algorithm.\
     3313
     3314    parameters.push_back(p);
     3315  }
     3316  {
     3317    CbcOrClpParam p("primalS!implex", "Do primal simplex algorithm",
     3318      CLP_PARAM_ACTION_PRIMALSIMPLEX);
     3319
     3320    p.setLonghelp(
     3321      "This command solves the continuous relaxation of the current model using the primal algorithm.\
    28223322  The default is to use exact devex.\
    28233323 The time and iterations may be affected by settings such as presolve, scaling, crash\
    28243324 and also by column selection  method, infeasibility weight and dual and primal tolerances.");
    2825 #endif
    2826   parameters[numberParameters++] = CbcOrClpParam("primalT!olerance", "For an optimal solution \
     3325    parameters.push_back(p);
     3326  }
     3327#endif
     3328  {
     3329    CbcOrClpParam p("primalT!olerance", "For an optimal solution \
    28273330no primal infeasibility may exceed this value",
    2828     1.0e-20, 1.0e12, CLP_PARAM_DBL_PRIMALTOLERANCE);
    2829   parameters[numberParameters - 1].setLonghelp(
    2830     "Normally the default tolerance is fine, but you may want to increase it a\
     3331      1.0e-20, 1.0e12, CLP_PARAM_DBL_PRIMALTOLERANCE);
     3332    p.setLonghelp(
     3333      "Normally the default tolerance is fine, but you may want to increase it a\
    28313334 bit if a primal run seems to be having a hard time");
     3335    parameters.push_back(p);
     3336  }
    28323337#ifdef COIN_HAS_CLP
    2833   parameters[numberParameters++] = CbcOrClpParam("primalW!eight", "Initially algorithm acts as if it \
     3338  {
     3339    CbcOrClpParam p("primalW!eight", "Initially algorithm acts as if it \
    28343340costs this much to be infeasible",
    2835     1.0e-20, 1.0e20, CLP_PARAM_DBL_PRIMALWEIGHT);
    2836   parameters[numberParameters - 1].setLonghelp(
    2837     "The primal algorithm in Clp is a single phase algorithm as opposed to a two phase\
     3341      1.0e-20, 1.0e20, CLP_PARAM_DBL_PRIMALWEIGHT);
     3342    p.setLonghelp(
     3343      "The primal algorithm in Clp is a single phase algorithm as opposed to a two phase\
    28383344 algorithm where you first get feasible then optimal.  So Clp is minimizing this weight times\
    28393345 the sum of primal infeasibilities plus the true objective function (in minimization sense).\
     
    28423348  OSL had a heuristic to\
    28433349 adjust bounds, maybe we need that here.");
    2844   parameters[numberParameters++] = CbcOrClpParam("psi", "Two-dimension pricing factor for Positive edge",
    2845     -1.1, 1.1, CLP_PARAM_DBL_PSI);
    2846   parameters[numberParameters - 1].setDoubleValue(-0.5);
    2847   parameters[numberParameters - 1].setLonghelp(
    2848     "The Positive Edge criterion has been added to \
     3350    parameters.push_back(p);
     3351  }
     3352  {
     3353    CbcOrClpParam p("psi", "Two-dimension pricing factor for Positive edge",
     3354      -1.1, 1.1, CLP_PARAM_DBL_PSI);
     3355
     3356    p.setDoubleValue(-0.5);
     3357    p.setLonghelp(
     3358      "The Positive Edge criterion has been added to \
    28493359select incoming variables to try and avoid degenerate moves. \
    28503360Variables not in promising set have their infeasibility weight multiplied by psi \
     
    28583368Towhidi, M., Desrosiers, J., Soumis, F., The positive edge criterion within COIN-OR’s CLP. and \
    28593369Omer, J., Towhidi, M., Soumis, F., The positive edge pricing rule for the dual simplex.");
    2860 #endif
    2861   parameters[numberParameters++] = CbcOrClpParam("printi!ngOptions", "Print options",
    2862     "normal", CLP_PARAM_STR_INTPRINT, 3);
    2863   parameters[numberParameters - 1].append("integer");
    2864   parameters[numberParameters - 1].append("special");
    2865   parameters[numberParameters - 1].append("rows");
    2866   parameters[numberParameters - 1].append("all");
    2867   parameters[numberParameters - 1].append("csv");
    2868   parameters[numberParameters - 1].append("bound!ranging");
    2869   parameters[numberParameters - 1].append("rhs!ranging");
    2870   parameters[numberParameters - 1].append("objective!ranging");
    2871   parameters[numberParameters - 1].append("stats");
    2872   parameters[numberParameters - 1].append("boundsint");
    2873   parameters[numberParameters - 1].append("boundsall");
    2874   parameters[numberParameters - 1].setLonghelp(
    2875     "This changes the amount and format of printing a solution:\nnormal - nonzero column variables \n\
     3370    parameters.push_back(p);
     3371  }
     3372#endif
     3373  {
     3374    CbcOrClpParam p("printi!ngOptions", "Print options",
     3375      "normal", CLP_PARAM_STR_INTPRINT, 3);
     3376    p.append("integer");
     3377    p.append("special");
     3378    p.append("rows");
     3379    p.append("all");
     3380    p.append("csv");
     3381    p.append("bound!ranging");
     3382    p.append("rhs!ranging");
     3383    p.append("objective!ranging");
     3384    p.append("stats");
     3385    p.append("boundsint");
     3386    p.append("boundsall");
     3387    p.setLonghelp(
     3388      "This changes the amount and format of printing a solution:\nnormal - nonzero column variables \n\
    28763389integer - nonzero integer column variables\n\
    28773390special - in format suitable for OsiRowCutDebugger\n\
     
    28803393\nFor non-integer problems 'integer' and 'special' act like 'normal'.  \
    28813394Also see printMask for controlling output.");
    2882   parameters[numberParameters++] = CbcOrClpParam("printM!ask", "Control printing of solution on a  mask",
    2883     CLP_PARAM_ACTION_PRINTMASK, 3);
    2884   parameters[numberParameters - 1].setLonghelp(
    2885     "If set then only those names which match mask are printed in a solution. \
     3395    parameters.push_back(p);
     3396  }
     3397  {
     3398    CbcOrClpParam p("printM!ask", "Control printing of solution on a  mask",
     3399      CLP_PARAM_ACTION_PRINTMASK, 3);
     3400
     3401    p.setLonghelp(
     3402      "If set then only those names which match mask are printed in a solution. \
    28863403'?' matches any character and '*' matches any set of characters. \
    28873404 The default is '' i.e. unset so all variables are printed. \
    28883405This is only active if model has names.");
    2889 #ifdef COIN_HAS_CBC
    2890   parameters[numberParameters++] = CbcOrClpParam("prio!rityIn", "Import priorities etc from file",
    2891     CBC_PARAM_ACTION_PRIORITYIN, 3);
    2892   parameters[numberParameters - 1].setLonghelp(
    2893     "This will read a file with priorities from the given file name.  It will use the default\
     3406    parameters.push_back(p);
     3407  }
     3408
     3409#ifdef COIN_HAS_CBC
     3410  {
     3411    CbcOrClpParam p("prio!rityIn", "Import priorities etc from file",
     3412      CBC_PARAM_ACTION_PRIORITYIN, 3);
     3413    p.setLonghelp(
     3414      "This will read a file with priorities from the given file name.  It will use the default\
    28943415 directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
    28953416 is initialized to '', i.e. it must be set.  This can not read from compressed files. \
    28963417File is in csv format with allowed headings - name, number, priority, direction, up, down, solution.  Exactly one of\
    28973418 name and number must be given.");
    2898   parameters[numberParameters++] = CbcOrClpParam("probing!Cuts", "Whether to use Probing cuts",
    2899     "off", CBC_PARAM_STR_PROBINGCUTS);
    2900   parameters[numberParameters - 1].append("on");
    2901   parameters[numberParameters - 1].append("root");
    2902   parameters[numberParameters - 1].append("ifmove");
    2903   parameters[numberParameters - 1].append("forceOn");
    2904   parameters[numberParameters - 1].append("onglobal");
    2905   parameters[numberParameters - 1].append("forceonglobal");
    2906   parameters[numberParameters - 1].append("forceOnBut");
    2907   parameters[numberParameters - 1].append("forceOnStrong");
    2908   parameters[numberParameters - 1].append("forceOnButStrong");
    2909   parameters[numberParameters - 1].append("strongRoot");
    2910   parameters[numberParameters - 1].setLonghelp(
    2911     "This switches on probing cuts (either at root or in entire tree) \
    2912 See branchAndCut for information on options. \
     3419    parameters.push_back(p);
     3420  }
     3421
     3422  {
     3423    CbcOrClpParam p("probing!Cuts", "Whether to use Probing cuts",
     3424      "off", CBC_PARAM_STR_PROBINGCUTS);
     3425    p.append("on");
     3426    p.append("root");
     3427    p.append("ifmove");
     3428    p.append("forceOn");
     3429    p.append("onglobal");
     3430    p.append("forceonglobal");
     3431    p.append("forceOnBut");
     3432    p.append("forceOnStrong");
     3433    p.append("forceOnButStrong");
     3434    p.append("strongRoot");
     3435    p.setLonghelp(
     3436      "This switches on probing cuts (either at root or in entire tree) \
     3437    See branchAndCut for information on options. \
    29133438but strong options do more probing");
    2914   parameters[numberParameters++] = CbcOrClpParam("proximity!Search", "Whether to do proximity search heuristic",
    2915     "off", CBC_PARAM_STR_PROXIMITY);
    2916   parameters[numberParameters - 1].append("on");
    2917   parameters[numberParameters - 1].append("both");
    2918   parameters[numberParameters - 1].append("before");
    2919   parameters[numberParameters - 1].append("10");
    2920   parameters[numberParameters - 1].append("100");
    2921   parameters[numberParameters - 1].append("300");
    2922   // but allow numbers after this (returning 1)
    2923   parameters[numberParameters - 1].setFakeKeyWord(1);
    2924   parameters[numberParameters - 1].setLonghelp(
    2925     "This switches on a heuristic which looks for a solution close \
     3439    parameters.push_back(p);
     3440  }
     3441  {
     3442    CbcOrClpParam p("proximity!Search", "Whether to do proximity search heuristic",
     3443      "off", CBC_PARAM_STR_PROXIMITY);
     3444
     3445    p.append("on");
     3446    p.append("both");
     3447    p.append("before");
     3448    p.append("10");
     3449    p.append("100");
     3450    p.append("300");
     3451    // but allow numbers after this (returning 1)
     3452    p.setFakeKeyWord(1);
     3453    p.setLonghelp(
     3454      "This switches on a heuristic which looks for a solution close \
    29263455to incumbent solution (Fischetti and Monaci). \
    29273456See Rounding for meaning of on,both,before. \
    29283457Can also set different maxNode settings by plusnnnn (and are 'on'(on==30)).");
    2929   parameters[numberParameters++] = CbcOrClpParam("pumpC!utoff", "Fake cutoff for use in feasibility pump",
    2930     -1.0e100, 1.0e100, CBC_PARAM_DBL_FAKECUTOFF);
    2931   parameters[numberParameters - 1].setDoubleValue(0.0);
    2932   parameters[numberParameters - 1].setLonghelp(
    2933     "0.0 off - otherwise add a constraint forcing objective below this value\
     3458    parameters.push_back(p);
     3459  }
     3460  {
     3461    CbcOrClpParam p("pumpC!utoff", "Fake cutoff for use in feasibility pump",
     3462      -1.0e100, 1.0e100, CBC_PARAM_DBL_FAKECUTOFF);
     3463    p.setDoubleValue(0.0);
     3464    p.setLonghelp(
     3465      "0.0 off - otherwise add a constraint forcing objective below this value\
    29343466 in feasibility pump");
    2935   parameters[numberParameters++] = CbcOrClpParam("pumpI!ncrement", "Fake increment for use in feasibility pump",
    2936     -1.0e100, 1.0e100, CBC_PARAM_DBL_FAKEINCREMENT, 1);
    2937   parameters[numberParameters - 1].setDoubleValue(0.0);
    2938   parameters[numberParameters - 1].setLonghelp(
    2939     "0.0 off - otherwise use as absolute increment to cutoff \
     3467    parameters.push_back(p);
     3468  }
     3469  {
     3470    CbcOrClpParam p("pumpI!ncrement", "Fake increment for use in feasibility pump",
     3471      -1.0e100, 1.0e100, CBC_PARAM_DBL_FAKEINCREMENT, 1);
     3472    p.setDoubleValue(0.0);
     3473    p.setLonghelp(
     3474      "0.0 off - otherwise use as absolute increment to cutoff \
    29403475when solution found in feasibility pump");
    2941   parameters[numberParameters++] = CbcOrClpParam("pumpT!une", "Dubious ideas for feasibility pump",
    2942     0, 100000000, CBC_PARAM_INT_FPUMPTUNE);
    2943   parameters[numberParameters - 1].setLonghelp(
    2944     "This fine tunes Feasibility Pump \n\
     3476    parameters.push_back(p);
     3477  }
     3478  {
     3479    CbcOrClpParam p("pumpT!une", "Dubious ideas for feasibility pump",
     3480      0, 100000000, CBC_PARAM_INT_FPUMPTUNE);
     3481    p.setLonghelp(
     3482      "This fine tunes Feasibility Pump \n\
    29453483\t>=10000000 use as objective weight switch\n\
    29463484\t>=1000000 use as accumulate switch\n\
     
    29513489If accumulate is on then after a major pass, variables which have not moved \
    29523490are fixed and a small branch and bound is tried.");
    2953   parameters[numberParameters - 1].setIntValue(0);
    2954 #endif
    2955   parameters[numberParameters++] = CbcOrClpParam("quit", "Stops clp execution",
    2956     CLP_PARAM_ACTION_EXIT);
    2957   parameters[numberParameters - 1].setLonghelp(
    2958     "This stops the execution of Clp, end, exit, quit and stop are synonyms");
    2959 #ifdef COIN_HAS_CBC
    2960   parameters[numberParameters++] = CbcOrClpParam("randomC!bcSeed", "Random seed for Cbc",
    2961     -1, COIN_INT_MAX, CBC_PARAM_INT_RANDOMSEED);
    2962   parameters[numberParameters - 1].setLonghelp(
    2963     "This sets a random seed for Cbc \
     3491    p.setIntValue(0);
     3492    parameters.push_back(p);
     3493  }
     3494#endif
     3495  {
     3496    CbcOrClpParam p("quit", "Stops clp execution",
     3497      CLP_PARAM_ACTION_EXIT);
     3498    p.setLonghelp(
     3499      "This stops the execution of Clp, end, exit, quit and stop are synonyms");
     3500
     3501    parameters.push_back(p);
     3502  }
     3503#ifdef COIN_HAS_CBC
     3504  {
     3505    CbcOrClpParam p("randomC!bcSeed", "Random seed for Cbc",
     3506      -1, COIN_INT_MAX, CBC_PARAM_INT_RANDOMSEED);
     3507
     3508    p.setLonghelp(
     3509      "This sets a random seed for Cbc \
    29643510- 0 says use time of day, -1 is as now.");
    2965   parameters[numberParameters - 1].setIntValue(-1);
    2966   parameters[numberParameters++] = CbcOrClpParam("randomi!zedRounding", "Whether to try randomized rounding heuristic",
    2967     "off", CBC_PARAM_STR_RANDROUND);
    2968   parameters[numberParameters - 1].append("on");
    2969   parameters[numberParameters - 1].append("both");
    2970   parameters[numberParameters - 1].append("before");
    2971   parameters[numberParameters - 1].setLonghelp(
    2972     "stuff needed. \
     3511    p.setIntValue(-1);
     3512    parameters.push_back(p);
     3513  }
     3514  {
     3515    CbcOrClpParam p("randomi!zedRounding", "Whether to try randomized rounding heuristic",
     3516      "off", CBC_PARAM_STR_RANDROUND);
     3517    p.append("on");
     3518    p.append("both");
     3519    p.append("before");
     3520    p.setLonghelp(
     3521      "stuff needed. \
    29733522Doh option does heuristic before preprocessing");
     3523    parameters.push_back(p);
     3524  }
    29743525#endif
    29753526#ifdef COIN_HAS_CLP
    2976   parameters[numberParameters++] = CbcOrClpParam("randomS!eed", "Random seed for Clp",
    2977     0, COIN_INT_MAX, CLP_PARAM_INT_RANDOMSEED);
    2978   parameters[numberParameters - 1].setLonghelp(
    2979     "This sets a random seed for Clp \
     3527  {
     3528    CbcOrClpParam p("randomS!eed", "Random seed for Clp",
     3529      0, COIN_INT_MAX, CLP_PARAM_INT_RANDOMSEED);
     3530
     3531    p.setLonghelp(
     3532      "This sets a random seed for Clp \
    29803533- 0 says use time of day.");
    2981   parameters[numberParameters - 1].setIntValue(1234567);
    2982 #endif
    2983 #ifdef COIN_HAS_CBC
    2984   parameters[numberParameters++] = CbcOrClpParam("ratio!Gap", "Stop when gap between best possible and \
     3534    p.setIntValue(1234567);
     3535    parameters.push_back(p);
     3536  }
     3537#endif
     3538#ifdef COIN_HAS_CBC
     3539  {
     3540    CbcOrClpParam p("ratio!Gap", "Stop when gap between best possible and \
    29853541best less than this fraction of larger of two",
    2986     0.0, 1.0e20, CBC_PARAM_DBL_GAPRATIO);
    2987   parameters[numberParameters - 1].setDoubleValue(0.0);
    2988   parameters[numberParameters - 1].setLonghelp(
    2989     "If the gap between best solution and best possible solution is less than this fraction \
     3542      0.0, 1.0e20, CBC_PARAM_DBL_GAPRATIO);
     3543    p.setDoubleValue(0.0);
     3544    p.setLonghelp(
     3545      "If the gap between best solution and best possible solution is less than this fraction \
    29903546of the objective value at the root node then the search will terminate.  See 'allowableGap' for a \
    29913547way of using absolute value rather than fraction.");
    2992 #endif
    2993   parameters[numberParameters++] = CbcOrClpParam("restoreS!olution", "reads solution from file",
    2994     CLP_PARAM_ACTION_RESTORESOL);
    2995   parameters[numberParameters - 1].setLonghelp(
    2996     "This will read a binary solution file from the given file name.  It will use the default\
     3548    parameters.push_back(p);
     3549  }
     3550#endif
     3551  {
     3552    CbcOrClpParam p("restoreS!olution", "reads solution from file",
     3553      CLP_PARAM_ACTION_RESTORESOL);
     3554
     3555    p.setLonghelp(
     3556      "This will read a binary solution file from the given file name.  It will use the default\
    29973557 directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
    29983558 is initialized to 'solution.file'.  This reads in a file from saveSolution");
    2999 #ifdef COIN_HAS_CBC
    3000   parameters[numberParameters++] = CbcOrClpParam("readSt!ored", "Import stored cuts from file",
    3001     CLP_PARAM_ACTION_STOREDFILE, 3, 0);
     3559    parameters.push_back(p);
     3560  }
     3561#ifdef COIN_HAS_CBC
     3562  {
     3563    CbcOrClpParam p("readSt!ored", "Import stored cuts from file",
     3564      CLP_PARAM_ACTION_STOREDFILE, 3, 0);
     3565    parameters.push_back(p);
     3566  }
    30023567#endif
    30033568#ifdef COIN_HAS_CLP
    3004   parameters[numberParameters++] = CbcOrClpParam("reallyO!bjectiveScale", "Scale factor to apply to objective in place",
    3005     -1.0e20, 1.0e20, CLP_PARAM_DBL_OBJSCALE2, 0);
    3006   parameters[numberParameters - 1].setLonghelp(
    3007     "You can set this to -1.0 to test maximization or other to stress code");
    3008   parameters[numberParameters - 1].setDoubleValue(1.0);
    3009   parameters[numberParameters++] = CbcOrClpParam("reallyS!cale", "Scales model in place",
    3010     CLP_PARAM_ACTION_REALLY_SCALE, 7, 0);
    3011 #endif
    3012 #ifdef COIN_HAS_CBC
    3013   parameters[numberParameters++] = CbcOrClpParam("reduce!AndSplitCuts", "Whether to use Reduce-and-Split cuts",
    3014     "off", CBC_PARAM_STR_REDSPLITCUTS);
    3015   parameters[numberParameters - 1].append("on");
    3016   parameters[numberParameters - 1].append("root");
    3017   parameters[numberParameters - 1].append("ifmove");
    3018   parameters[numberParameters - 1].append("forceOn");
    3019   parameters[numberParameters - 1].setLonghelp(
    3020     "This switches on reduce and split  cuts (either at root or in entire tree). \
     3569  {
     3570    CbcOrClpParam p("reallyO!bjectiveScale", "Scale factor to apply to objective in place",
     3571      -1.0e20, 1.0e20, CLP_PARAM_DBL_OBJSCALE2, 0);
     3572    p.setLonghelp("You can set this to -1.0 to test maximization or other to stress code");
     3573    p.setDoubleValue(1.0);
     3574    parameters.push_back(p);
     3575  }
     3576  {
     3577    CbcOrClpParam p("reallyS!cale", "Scales model in place",
     3578      CLP_PARAM_ACTION_REALLY_SCALE, 7, 0);
     3579    parameters.push_back(p);
     3580  }
     3581#endif
     3582#ifdef COIN_HAS_CBC
     3583  {
     3584    CbcOrClpParam p("reduce!AndSplitCuts", "Whether to use Reduce-and-Split cuts",
     3585      "off", CBC_PARAM_STR_REDSPLITCUTS);
     3586
     3587    p.append("on");
     3588    p.append("root");
     3589    p.append("ifmove");
     3590    p.append("forceOn");
     3591    p.setLonghelp(
     3592      "This switches on reduce and split  cuts (either at root or in entire tree). \
    30213593May be slow \
    30223594See branchAndCut for information on options.");
    3023   parameters[numberParameters++] = CbcOrClpParam("reduce2!AndSplitCuts", "Whether to use Reduce-and-Split cuts - style 2",
    3024     "off", CBC_PARAM_STR_REDSPLIT2CUTS);
    3025   parameters[numberParameters - 1].append("on");
    3026   parameters[numberParameters - 1].append("root");
    3027   parameters[numberParameters - 1].append("longOn");
    3028   parameters[numberParameters - 1].append("longRoot");
    3029   parameters[numberParameters - 1].setLonghelp(
    3030     "This switches on reduce and split  cuts (either at root or in entire tree) \
     3595    parameters.push_back(p);
     3596  }
     3597  {
     3598    CbcOrClpParam p("reduce2!AndSplitCuts", "Whether to use Reduce-and-Split cuts - style 2",
     3599      "off", CBC_PARAM_STR_REDSPLIT2CUTS);
     3600    p.append("on");
     3601    p.append("root");
     3602    p.append("longOn");
     3603    p.append("longRoot");
     3604    p.setLonghelp("This switches on reduce and split  cuts (either at root or in entire tree) \
    30313605This version is by Giacomo Nannicini based on Francois Margot's version \
    30323606Standard setting only uses rows in tableau <=256, long uses all \
    30333607May be slow \
    30343608See branchAndCut for information on options.");
    3035   parameters[numberParameters++] = CbcOrClpParam("reduce2!AndSplitCuts", "Whether to use Reduce-and-Split cuts - style 2",
    3036     "off", CBC_PARAM_STR_REDSPLIT2CUTS);
    3037   parameters[numberParameters - 1].append("on");
    3038   parameters[numberParameters - 1].append("root");
    3039   parameters[numberParameters - 1].append("longOn");
    3040   parameters[numberParameters - 1].append("longRoot");
    3041   parameters[numberParameters - 1].setLonghelp(
    3042     "This switches on reduce and split  cuts (either at root or in entire tree) \
    3043 This version is by Giacomo Nannicini based on Francois Margot's version \
    3044 Standard setting only uses rows in tableau <=256, long uses all \
     3609    parameters.push_back(p);
     3610  }
     3611  {
     3612    CbcOrClpParam p("residual!CapacityCuts", "Whether to use Residual Capacity cuts",
     3613      "off", CBC_PARAM_STR_RESIDCUTS);
     3614    p.append("on");
     3615    p.append("root");
     3616    p.append("ifmove");
     3617    p.append("forceOn");
     3618    p.setLonghelp(
     3619      "Residual capacity cuts. \
    30453620See branchAndCut for information on options.");
    3046   parameters[numberParameters++] = CbcOrClpParam("residual!CapacityCuts", "Whether to use Residual Capacity cuts",
    3047     "off", CBC_PARAM_STR_RESIDCUTS);
    3048   parameters[numberParameters - 1].append("on");
    3049   parameters[numberParameters - 1].append("root");
    3050   parameters[numberParameters - 1].append("ifmove");
    3051   parameters[numberParameters - 1].append("forceOn");
    3052   parameters[numberParameters - 1].setLonghelp(
    3053     "Residual capacity cuts. \
    3054 See branchAndCut for information on options.");
     3621
     3622    parameters.push_back(p);
     3623  }
    30553624#endif
    30563625#ifdef COIN_HAS_CLP
    3057   parameters[numberParameters++] = CbcOrClpParam("restore!Model", "Restore model from binary file",
    3058     CLP_PARAM_ACTION_RESTORE, 7, 1);
    3059   parameters[numberParameters - 1].setLonghelp(
    3060     "This reads data save by saveModel from the given file.  It will use the default\
     3626  {
     3627    CbcOrClpParam p("restore!Model", "Restore model from binary file",
     3628      CLP_PARAM_ACTION_RESTORE, 7, 1);
     3629    p.setLonghelp(
     3630      "This reads data save by saveModel from the given file.  It will use the default\
    30613631 directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
    30623632 is initialized to 'default.prob'.");
    3063   parameters[numberParameters++] = CbcOrClpParam("reverse", "Reverses sign of objective",
    3064     CLP_PARAM_ACTION_REVERSE, 7, 0);
    3065   parameters[numberParameters - 1].setLonghelp(
    3066     "Useful for testing if maximization works correctly");
    3067   parameters[numberParameters++] = CbcOrClpParam("rhs!Scale", "Scale factor to apply to rhs and bounds",
    3068     -1.0e20, 1.0e20, CLP_PARAM_DBL_RHSSCALE, 0);
    3069   parameters[numberParameters - 1].setLonghelp(
    3070     "If the rhs or bounds have some very large meaningful values, you may wish to scale them\
     3633
     3634    parameters.push_back(p);
     3635  }
     3636  {
     3637    CbcOrClpParam p("reverse", "Reverses sign of objective",
     3638      CLP_PARAM_ACTION_REVERSE, 7, 0);
     3639    p.setLonghelp(
     3640      "Useful for testing if maximization works correctly");
     3641    parameters.push_back(p);
     3642  }
     3643  {
     3644    CbcOrClpParam p("rhs!Scale", "Scale factor to apply to rhs and bounds",
     3645      -1.0e20, 1.0e20, CLP_PARAM_DBL_RHSSCALE, 0);
     3646    p.setLonghelp(
     3647      "If the rhs or bounds have some very large meaningful values, you may wish to scale them\
    30713648 internally by this amount.  It can also be set by autoscale.  This should not be needed.");
    3072   parameters[numberParameters - 1].setDoubleValue(1.0);
    3073 #endif
    3074 #ifdef COIN_HAS_CBC
    3075   parameters[numberParameters++] = CbcOrClpParam("Rens", "Whether to try Relaxation Enforced Neighborhood Search",
    3076     "off", CBC_PARAM_STR_RENS);
    3077   parameters[numberParameters - 1].append("on");
    3078   parameters[numberParameters - 1].append("both");
    3079   parameters[numberParameters - 1].append("before");
    3080   parameters[numberParameters - 1].append("200");
    3081   parameters[numberParameters - 1].append("1000");
    3082   parameters[numberParameters - 1].append("10000");
    3083   parameters[numberParameters - 1].append("dj");
    3084   parameters[numberParameters - 1].append("djbefore");
    3085   parameters[numberParameters - 1].append("usesolution");
    3086   parameters[numberParameters - 1].setLonghelp(
    3087     "This switches on Relaxation enforced neighborhood Search. \
     3649    p.setDoubleValue(1.0);
     3650    parameters.push_back(p);
     3651  }
     3652#endif
     3653#ifdef COIN_HAS_CBC
     3654  {
     3655    CbcOrClpParam p("Rens", "Whether to try Relaxation Enforced Neighborhood Search",
     3656      "off", CBC_PARAM_STR_RENS);
     3657    p.append("on");
     3658    p.append("both");
     3659    p.append("before");
     3660    p.append("200");
     3661    p.append("1000");
     3662    p.append("10000");
     3663    p.append("dj");
     3664    p.append("djbefore");
     3665    p.append("usesolution");
     3666    p.setLonghelp(
     3667      "This switches on Relaxation enforced neighborhood Search. \
    30883668on just does 50 nodes \
    30893669200 or 1000 does that many nodes. \
    30903670Doh option does heuristic before preprocessing");
    3091   parameters[numberParameters++] = CbcOrClpParam("Rins", "Whether to try Relaxed Induced Neighborhood Search",
    3092     "off", CBC_PARAM_STR_RINS);
    3093   parameters[numberParameters - 1].append("on");
    3094   parameters[numberParameters - 1].append("both");
    3095   parameters[numberParameters - 1].append("before");
    3096   parameters[numberParameters - 1].append("often");
    3097   parameters[numberParameters - 1].setLonghelp(
    3098     "This switches on Relaxed induced neighborhood Search. \
     3671    parameters.push_back(p);
     3672  }
     3673  {
     3674    CbcOrClpParam p("Rins", "Whether to try Relaxed Induced Neighborhood Search",
     3675      "off", CBC_PARAM_STR_RINS);
     3676    p.append("on");
     3677    p.append("both");
     3678    p.append("before");
     3679    p.append("often");
     3680    p.setLonghelp(
     3681      "This switches on Relaxed induced neighborhood Search. \
    30993682Doh option does heuristic before preprocessing");
    3100   parameters[numberParameters++] = CbcOrClpParam("round!ingHeuristic", "Whether to use Rounding heuristic",
    3101     "off", CBC_PARAM_STR_ROUNDING);
    3102   parameters[numberParameters - 1].append("on");
    3103   parameters[numberParameters - 1].append("both");
    3104   parameters[numberParameters - 1].append("before");
    3105   parameters[numberParameters - 1].setLonghelp(
    3106     "This switches on a simple (but effective) rounding heuristic at each node of tree.  \
     3683    parameters.push_back(p);
     3684  }
     3685  {
     3686    CbcOrClpParam p("round!ingHeuristic", "Whether to use Rounding heuristic",
     3687      "off", CBC_PARAM_STR_ROUNDING);
     3688    p.append("on");
     3689    p.append("both");
     3690    p.append("before");
     3691    p.setLonghelp(
     3692      "This switches on a simple (but effective) rounding heuristic at each node of tree.  \
    31073693On means do in solve i.e. after preprocessing, \
    31083694Before means do if doHeuristics used, off otherwise, \
    31093695and both means do if doHeuristics and in solve.");
    3110 
    3111 #endif
    3112   parameters[numberParameters++] = CbcOrClpParam("saveM!odel", "Save model to binary file",
    3113     CLP_PARAM_ACTION_SAVE, 7, 1);
    3114   parameters[numberParameters - 1].setLonghelp(
    3115     "This will save the problem to the given file name for future use\
     3696    parameters.push_back(p);
     3697  }
     3698#endif
     3699  {
     3700    CbcOrClpParam p("saveM!odel", "Save model to binary file",
     3701      CLP_PARAM_ACTION_SAVE, 7, 1);
     3702    p.setLonghelp(
     3703      "This will save the problem to the given file name for future use\
    31163704 by restoreModel.  It will use the default\
    31173705 directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
    31183706 is initialized to 'default.prob'.");
    3119   parameters[numberParameters++] = CbcOrClpParam("saveS!olution", "saves solution to file",
    3120     CLP_PARAM_ACTION_SAVESOL);
    3121   parameters[numberParameters - 1].setLonghelp(
    3122     "This will write a binary solution file to the given file name.  It will use the default\
     3707    parameters.push_back(p);
     3708  }
     3709  {
     3710    CbcOrClpParam p("saveS!olution", "saves solution to file",
     3711      CLP_PARAM_ACTION_SAVESOL);
     3712
     3713    p.setLonghelp(
     3714      "This will write a binary solution file to the given file name.  It will use the default\
    31233715 directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
    31243716 is initialized to 'solution.file'.  To read the file use fread(int) twice to pick up number of rows \
     
    31263718activities and reduced costs - see bottom of CbcOrClpParam.cpp for code that reads or writes file. \
    31273719If name contains '_fix_read_' then does not write but reads and will fix all variables");
    3128   parameters[numberParameters++] = CbcOrClpParam("scal!ing", "Whether to scale problem",
    3129     "off", CLP_PARAM_STR_SCALING);
    3130   parameters[numberParameters - 1].append("equi!librium");
    3131   parameters[numberParameters - 1].append("geo!metric");
    3132   parameters[numberParameters - 1].append("auto!matic");
    3133   parameters[numberParameters - 1].append("dynamic");
    3134   parameters[numberParameters - 1].append("rows!only");
    3135   parameters[numberParameters - 1].setLonghelp(
    3136     "Scaling can help in solving problems which might otherwise fail because of lack of\
     3720    parameters.push_back(p);
     3721  }
     3722  {
     3723    CbcOrClpParam p("scal!ing", "Whether to scale problem",
     3724      "off", CLP_PARAM_STR_SCALING);
     3725    p.append("equi!librium");
     3726    p.append("geo!metric");
     3727    p.append("auto!matic");
     3728    p.append("dynamic");
     3729    p.append("rows!only");
     3730    p.setLonghelp(
     3731      "Scaling can help in solving problems which might otherwise fail because of lack of\
    31373732 accuracy.  It can also reduce the number of iterations.  It is not applied if the range\
    31383733 of elements is small.  When unscaled it is possible that there may be small primal and/or\
    31393734 infeasibilities.");
    3140   parameters[numberParameters - 1].setCurrentOption(3); // say auto
     3735    p.setCurrentOption(3); // say auto
     3736    parameters.push_back(p);
     3737  }
    31413738#ifndef COIN_HAS_CBC
    3142   parameters[numberParameters++] = CbcOrClpParam("sec!onds", "Maximum seconds",
    3143     -1.0, 1.0e12, CLP_PARAM_DBL_TIMELIMIT);
    3144   parameters[numberParameters - 1].setLonghelp(
    3145     "After this many seconds clp will act as if maximum iterations had been reached \
     3739  {
     3740    CbcOrClpParam p("sec!onds", "Maximum seconds",
     3741      -1.0, 1.0e12, CLP_PARAM_DBL_TIMELIMIT);
     3742
     3743    p.setLonghelp("After this many seconds clp will act as if maximum iterations had been reached \
    31463744(if value >=0).");
     3745    parameters.push_back(p);
     3746  }
    31473747#else
    3148   parameters[numberParameters++] = CbcOrClpParam("sec!onds", "maximum seconds",
    3149     -1.0, 1.0e12, CBC_PARAM_DBL_TIMELIMIT_BAB);
    3150   parameters[numberParameters - 1].setLonghelp(
    3151     "After this many seconds coin solver will act as if maximum nodes had been reached.");
    3152 #endif
    3153   parameters[numberParameters++] = CbcOrClpParam("sleep", "for debug",
    3154     CLP_PARAM_ACTION_DUMMY, 7, 0);
    3155   parameters[numberParameters - 1].setLonghelp(
    3156     "If passed to solver fom ampl, then ampl will wait so that you can copy .nl file for debug.");
    3157 #ifdef COIN_HAS_CBC
    3158   parameters[numberParameters++] = CbcOrClpParam("slow!cutpasses", "Maximum number of tries for slower cuts",
    3159     -1, COIN_INT_MAX, CBC_PARAM_INT_MAX_SLOW_CUTS);
    3160   parameters[numberParameters - 1].setLonghelp(
    3161     "Some cut generators are fairly slow - this limits the number of times they are tried.");
    3162   parameters[numberParameters - 1].setIntValue(10);
     3748  {
     3749    CbcOrClpParam p("sec!onds", "maximum seconds",
     3750      -1.0, 1.0e12, CBC_PARAM_DBL_TIMELIMIT_BAB);
     3751    p.setLonghelp(
     3752      "After this many seconds coin solver will act as if maximum nodes had been reached.");
     3753    parameters.push_back(p);
     3754  }
     3755#endif
     3756  {
     3757    CbcOrClpParam p("sleep", "for debug",
     3758      CLP_PARAM_ACTION_DUMMY, 7, 0);
     3759
     3760    p.setLonghelp(
     3761      "If passed to solver fom ampl, then ampl will wait so that you can copy .nl file for debug.");
     3762    parameters.push_back(p);
     3763  }
     3764#ifdef COIN_HAS_CBC
     3765  {
     3766    CbcOrClpParam p("slow!cutpasses", "Maximum number of tries for slower cuts",
     3767      -1, COIN_INT_MAX, CBC_PARAM_INT_MAX_SLOW_CUTS);
     3768    p.setLonghelp(
     3769      "Some cut generators are fairly slow - this limits the number of times they are tried.");
     3770    p.setIntValue(10);
     3771    parameters.push_back(p);
     3772  }
    31633773#endif
    31643774#ifdef COIN_HAS_CLP
    3165   parameters[numberParameters++] = CbcOrClpParam("slp!Value", "Number of slp passes before primal",
    3166     -50000, 50000, CLP_PARAM_INT_SLPVALUE, 1);
    3167   parameters[numberParameters - 1].setLonghelp(
    3168     "If you are solving a quadratic problem using primal then it may be helpful to do some \
     3775  {
     3776    CbcOrClpParam p("slp!Value", "Number of slp passes before primal",
     3777      -50000, 50000, CLP_PARAM_INT_SLPVALUE, 1);
     3778    p.setLonghelp(
     3779      "If you are solving a quadratic problem using primal then it may be helpful to do some \
    31693780sequential Lps to get a good approximate solution.");
     3781    parameters.push_back(p);
     3782  }
    31703783#if CLP_MULTIPLE_FACTORIZATIONS > 0
    3171   parameters[numberParameters++] = CbcOrClpParam("small!Factorization", "Whether to use small factorization",
    3172     -1, 10000, CBC_PARAM_INT_SMALLFACT, 1);
    3173   parameters[numberParameters - 1].setLonghelp(
    3174     "If processed problem <= this use small factorization");
    3175   parameters[numberParameters - 1].setIntValue(-1);
    3176 #endif
    3177 #endif
    3178   parameters[numberParameters++] = CbcOrClpParam("solu!tion", "Prints solution to file",
    3179     CLP_PARAM_ACTION_SOLUTION);
    3180   parameters[numberParameters - 1].setLonghelp(
    3181     "This will write a primitive solution file to the given file name.  It will use the default\
     3784  {
     3785    CbcOrClpParam p("small!Factorization", "Whether to use small factorization",
     3786      -1, 10000, CBC_PARAM_INT_SMALLFACT, 1);
     3787    p.setLonghelp(
     3788      "If processed problem <= this use small factorization");
     3789    p.setIntValue(-1);
     3790    parameters.push_back(p);
     3791  }
     3792#endif
     3793#endif
     3794  {
     3795    CbcOrClpParam p("solu!tion", "Prints solution to file",
     3796      CLP_PARAM_ACTION_SOLUTION);
     3797    p.setLonghelp(
     3798      "This will write a primitive solution file to the given file name.  It will use the default\
    31823799 directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
    31833800 is initialized to 'stdout'.  The amount of output can be varied using printi!ngOptions or printMask.");
     3801    parameters.push_back(p);
     3802  }
    31843803#ifdef COIN_HAS_CLP
    31853804#ifdef COIN_HAS_CBC
    3186   parameters[numberParameters++] = CbcOrClpParam("solv!e", "Solve problem",
    3187     CBC_PARAM_ACTION_BAB);
    3188   parameters[numberParameters - 1].setLonghelp(
    3189     "If there are no integer variables then this just solves LP.  If there are integer variables \
    3190 this does branch and cut.");
    3191   parameters[numberParameters++] = CbcOrClpParam("sosO!ptions", "Whether to use SOS from AMPL",
    3192     "off", CBC_PARAM_STR_SOS);
    3193   parameters[numberParameters - 1].append("on");
    3194   parameters[numberParameters - 1].setCurrentOption("on");
    3195   parameters[numberParameters - 1].setLonghelp(
    3196     "Normally if AMPL says there are SOS variables they should be used, but sometime sthey should\
    3197  be turned off - this does so.");
    3198   // Due to James Howey
    3199   parameters[numberParameters++] = CbcOrClpParam("sosP!rioritize", "How to deal with SOS priorities",
    3200     "off", CBC_PARAM_STR_SOSPRIORITIZE);
    3201   parameters[numberParameters - 1].append("high");
    3202   parameters[numberParameters - 1].append("low");
    3203   parameters[numberParameters - 1].append("orderhigh");
    3204   parameters[numberParameters - 1].append("orderlow");
    3205   parameters[numberParameters - 1].setLonghelp(
    3206     "This sets priorities for SOS.  The first two just set priority \
    3207 relative to integers.  Orderhigh gives first set highest priority and integers \
    3208 a low priority.  Orderlow gives integers high priority then SOS in order.");
    3209   parameters[numberParameters++] = CbcOrClpParam("slog!Level", "Level of detail in (LP) Solver output",
    3210     -1, 63, CLP_PARAM_INT_SOLVERLOGLEVEL);
    3211   parameters[numberParameters - 1].setLonghelp(
    3212     "If 0 then there should be no output in normal circumstances.  1 is probably the best\
     3805  {
     3806    CbcOrClpParam p("solv!e", "Solve problem",
     3807      CBC_PARAM_ACTION_BAB);
     3808         p.setLonghelp(
     3809          "If there are no integer variables then this just solves LP.  If there are integer variables \
     3810this does branch and cut." );
     3811         parameters.push_back( p );
     3812  }
     3813  {
     3814    CbcOrClpParam p("sosO!ptions", "Whether to use SOS from AMPL",  "off", CBC_PARAM_STR_SOS);
     3815    p.append("on");
     3816    p.setCurrentOption("on");
     3817         p.setLonghelp(
     3818          "Normally if AMPL says there are SOS variables they should be used, but sometime sthey should\
     3819 be turned off - this does so." );
     3820         parameters.push_back( p );
     3821  }
     3822  {
     3823    CbcOrClpParam p("slog!Level", "Level of detail in (LP) Solver output", -1, 63, CLP_PARAM_INT_SOLVERLOGLEVEL);
     3824    p.setLonghelp(
     3825      "If 0 then there should be no output in normal circumstances.  1 is probably the best\
    32133826 value for most uses, while 2 and 3 give more information.  This parameter is only used inside MIP - for Clp use 'log'");
     3827    parameters.push_back(p);
     3828  }
     3829  {
     3830     // Due to James Howey
     3831     CbcOrClpParam p("sosP!rioritize", "How to deal with SOS priorities",
     3832       "off", CBC_PARAM_STR_SOSPRIORITIZE);
     3833     p.append("high");
     3834     p.append("low");
     3835     p.append("orderhigh");
     3836     p.append("orderlow");
     3837     p.setLonghelp(
     3838       "This sets priorities for SOS.  The first two just set priority \
     3839    relative to integers.  Orderhigh gives first set highest priority and integers \
     3840    a low priority.  Orderlow gives integers high priority then SOS in order.");
     3841    parameters.push_back(p);
     3842  }
    32143843#else
    32153844  // allow solve as synonym for possible dual
    3216   parameters[numberParameters++] = CbcOrClpParam("solv!e", "Solve problem using dual simplex (probably)",
    3217     CLP_PARAM_ACTION_EITHERSIMPLEX);
    3218   parameters[numberParameters - 1].setLonghelp(
    3219     "Just so can use solve for clp as well as in cbc");
     3845  {
     3846    CbcOrClpParam p("solv!e", "Solve problem using dual simplex (probably)",
     3847      CLP_PARAM_ACTION_EITHERSIMPLEX);
     3848    p.setLonghelp(
     3849      "Just so can use solve for clp as well as in cbc");
     3850    parameters.push_back(p);
     3851  }
    32203852#endif
    32213853#endif
    32223854#ifdef COIN_HAS_CLP
    3223   parameters[numberParameters++] = CbcOrClpParam("spars!eFactor", "Whether factorization treated as sparse",
    3224     "on", CLP_PARAM_STR_SPARSEFACTOR, 7, 0);
    3225   parameters[numberParameters - 1].append("off");
    3226   parameters[numberParameters++] = CbcOrClpParam("special!Options", "Dubious options for Simplex - see ClpSimplex.hpp",
    3227     0, COIN_INT_MAX, CLP_PARAM_INT_SPECIALOPTIONS, 0);
    3228   parameters[numberParameters++] = CbcOrClpParam("sprint!Crash", "Whether to try sprint crash",
    3229     -1, 5000000, CLP_PARAM_INT_SPRINT);
    3230   parameters[numberParameters - 1].setLonghelp(
    3231     "For long and thin problems this program may solve a series of small problems\
     3855  {
     3856    CbcOrClpParam p("spars!eFactor", "Whether factorization treated as sparse",
     3857      "on", CLP_PARAM_STR_SPARSEFACTOR, 7, 0);
     3858    p.append("off");
     3859    parameters.push_back(p);
     3860  }
     3861  {
     3862    CbcOrClpParam p("special!Options", "Dubious options for Simplex - see ClpSimplex.hpp",
     3863      0, COIN_INT_MAX, CLP_PARAM_INT_SPECIALOPTIONS, 0);
     3864    parameters.push_back(p);
     3865  }
     3866  {
     3867    CbcOrClpParam p("sprint!Crash", "Whether to try sprint crash",
     3868      -1, 5000000, CLP_PARAM_INT_SPRINT);
     3869    p.setLonghelp(
     3870      "For long and thin problems this program may solve a series of small problems\
    32323871 created by taking a subset of the columns.  I introduced the idea as 'Sprint' after\
    32333872 an LP code of that name of the 60's which tried the same tactic (not totally successfully).\
    32343873  Cplex calls it 'sifting'.  -1 is automatic choice, 0 is off, n is number of passes");
    3235   parameters[numberParameters++] = CbcOrClpParam("stat!istics", "Print some statistics",
    3236     CLP_PARAM_ACTION_STATISTICS);
    3237   parameters[numberParameters - 1].setLonghelp(
    3238     "This command prints some statistics for the current model.\
     3874    parameters.push_back(p);
     3875  }
     3876  {
     3877    CbcOrClpParam p("stat!istics", "Print some statistics",
     3878      CLP_PARAM_ACTION_STATISTICS);
     3879    p.setLonghelp(
     3880      "This command prints some statistics for the current model.\
    32393881 If log level >1 then more is printed.\
    32403882 These are for presolved model if presolve on (and unscaled).");
    3241 #endif
    3242   parameters[numberParameters++] = CbcOrClpParam("stop", "Stops clp execution",
    3243     CLP_PARAM_ACTION_EXIT);
    3244   parameters[numberParameters - 1].setLonghelp(
    3245     "This stops the execution of Clp, end, exit, quit and stop are synonyms");
    3246 #ifdef COIN_HAS_CBC
    3247   parameters[numberParameters++] = CbcOrClpParam("strat!egy", "Switches on groups of features",
    3248     0, 2, CBC_PARAM_INT_STRATEGY);
    3249   parameters[numberParameters - 1].setLonghelp(
    3250     "This turns on newer features. \
     3883    parameters.push_back(p);
     3884  }
     3885#endif
     3886  {
     3887    CbcOrClpParam p("stop", "Stops clp execution",
     3888      CLP_PARAM_ACTION_EXIT);
     3889    p.setLonghelp(
     3890      "This stops the execution of Clp, end, exit, quit and stop are synonyms");
     3891    parameters.push_back(p);
     3892  }
     3893#ifdef COIN_HAS_CBC
     3894  {
     3895    CbcOrClpParam p("strat!egy", "Switches on groups of features",
     3896      0, 2, CBC_PARAM_INT_STRATEGY);
     3897    p.setLonghelp(
     3898      "This turns on newer features. \
    32513899Use 0 for easy problems, 1 is default, 2 is aggressive. \
    325239001 uses Gomory cuts using tolerance of 0.01 at root, \
     
    32553903more aggressive. \
    32563904This does not apply to unit tests (where 'experiment' may have similar effects).");
    3257   parameters[numberParameters - 1].setIntValue(1);
     3905    p.setIntValue(1);
     3906    parameters.push_back(p);
     3907  }
    32583908#ifdef CBC_KEEP_DEPRECATED
    3259   parameters[numberParameters++] = CbcOrClpParam("strengthen", "Create strengthened problem",
    3260     CBC_PARAM_ACTION_STRENGTHEN, 3);
    3261   parameters[numberParameters - 1].setLonghelp(
    3262     "This creates a new problem by applying the root node cuts.  All tight constraints \
     3909  {
     3910    CbcOrClpParam p("strengthen", "Create strengthened problem",
     3911      CBC_PARAM_ACTION_STRENGTHEN, 3);
     3912    p.setLonghelp(
     3913      "This creates a new problem by applying the root node cuts.  All tight constraints \
    32633914will be in resulting problem");
    3264 #endif
    3265   parameters[numberParameters++] = CbcOrClpParam("strong!Branching", "Number of variables to look at in strong branching",
    3266     0, COIN_INT_MAX, CBC_PARAM_INT_STRONGBRANCHING);
    3267   parameters[numberParameters - 1].setLonghelp(
    3268     "In order to decide which variable to branch on, the code will choose up to this number \
     3915    parameters.push_back(p);
     3916  }
     3917#endif
     3918  {
     3919    CbcOrClpParam p("strong!Branching", "Number of variables to look at in strong branching",
     3920      0, COIN_INT_MAX, CBC_PARAM_INT_STRONGBRANCHING);
     3921    p.setLonghelp(
     3922      "In order to decide which variable to branch on, the code will choose up to this number \
    32693923of unsatisfied variables to do mini up and down branches on.  Then the most effective one is chosen. \
    32703924If a variable is branched on many times then the previous average up and down costs may be used - \
    32713925see number before trust.");
     3926    parameters.push_back(p);
     3927  }
    32723928#endif
    32733929#ifdef COIN_HAS_CLP
    3274   parameters[numberParameters++] = CbcOrClpParam("subs!titution", "How long a column to substitute for in presolve",
    3275     0, 10000, CLP_PARAM_INT_SUBSTITUTION, 0);
    3276   parameters[numberParameters - 1].setLonghelp(
    3277     "Normally Presolve gets rid of 'free' variables when there are no more than 3 \
     3930  {
     3931    CbcOrClpParam p("subs!titution", "How long a column to substitute for in presolve",
     3932      0, 10000, CLP_PARAM_INT_SUBSTITUTION, 0);
     3933    p.setLonghelp(
     3934      "Normally Presolve gets rid of 'free' variables when there are no more than 3 \
    32783935 variables in column.  If you increase this the number of rows may decrease but number of \
    32793936 elements may increase.");
    3280 #endif
    3281 #ifdef COIN_HAS_CBC
    3282   parameters[numberParameters++] = CbcOrClpParam("testO!si", "Test OsiObject stuff",
    3283     -1, COIN_INT_MAX, CBC_PARAM_INT_TESTOSI, 0);
     3937    parameters.push_back(p);
     3938  }
     3939#endif
     3940#ifdef COIN_HAS_CBC
     3941  {
     3942    CbcOrClpParam p("testO!si", "Test OsiObject stuff",
     3943      -1, COIN_INT_MAX, CBC_PARAM_INT_TESTOSI, 0);
     3944    parameters.push_back(p);
     3945  }
    32843946#endif
    32853947#ifdef CBC_THREAD
    3286   parameters[numberParameters++] = CbcOrClpParam("thread!s", "Number of threads to try and use",
    3287     -100, 100000, CBC_PARAM_INT_THREADS, 1);
    3288   parameters[numberParameters - 1].setLonghelp(
    3289     "To use multiple threads, set threads to number wanted.  It may be better \
     3948  {
     3949    CbcOrClpParam p("thread!s", "Number of threads to try and use",
     3950      -100, 100000, CBC_PARAM_INT_THREADS, 1);
     3951    p.setLonghelp(
     3952      "To use multiple threads, set threads to number wanted.  It may be better \
    32903953to use one or two more than number of cpus available.  If 100+n then n threads and \
    32913954search is repeatable (maybe be somewhat slower), \
    32923955if 200+n use threads for root cuts, 400+n threads used in sub-trees.");
    3293 #endif
    3294 #ifdef COIN_HAS_CBC
    3295   parameters[numberParameters++] = CbcOrClpParam("tighten!Factor", "Tighten bounds using this times largest \
     3956    parameters.push_back(p);
     3957  }
     3958#endif
     3959#ifdef COIN_HAS_CBC
     3960  {
     3961    CbcOrClpParam p("tighten!Factor", "Tighten bounds using this times largest \
    32963962activity at continuous solution",
    3297     1.0e-3, 1.0e20, CBC_PARAM_DBL_TIGHTENFACTOR, 0);
    3298   parameters[numberParameters - 1].setLonghelp(
    3299     "This sleazy trick can help on some problems.");
     3963      1.0e-3, 1.0e20, CBC_PARAM_DBL_TIGHTENFACTOR, 0);
     3964    p.setLonghelp(
     3965      "This sleazy trick can help on some problems.");
     3966    parameters.push_back(p);
     3967  }
     3968
    33003969#endif
    33013970#ifdef COIN_HAS_CLP
    3302   parameters[numberParameters++] = CbcOrClpParam("tightLP", "Poor person's preSolve for now",
    3303     CLP_PARAM_ACTION_TIGHTEN, 7, 0);
    3304 #endif
    3305   parameters[numberParameters++] = CbcOrClpParam("timeM!ode", "Whether to use CPU or elapsed time",
    3306     "cpu", CLP_PARAM_STR_TIME_MODE);
    3307   parameters[numberParameters - 1].append("elapsed");
    3308   parameters[numberParameters - 1].setLonghelp(
    3309     "cpu uses CPU time for stopping, while elapsed uses elapsed time. \
     3971  {
     3972    CbcOrClpParam p("tightLP", "Poor person's preSolve for now",
     3973      CLP_PARAM_ACTION_TIGHTEN, 7, 0);
     3974    parameters.push_back(p);
     3975  }
     3976#endif
     3977  {
     3978    CbcOrClpParam p("timeM!ode", "Whether to use CPU or elapsed time",
     3979      "cpu", CLP_PARAM_STR_TIME_MODE);
     3980    p.append("elapsed");
     3981    p.setLonghelp(
     3982      "cpu uses CPU time for stopping, while elapsed uses elapsed time. \
    33103983(On Windows, elapsed time is always used).");
    3311 #ifdef COIN_HAS_CBC
    3312   parameters[numberParameters++] = CbcOrClpParam("trust!PseudoCosts", "Number of branches before we trust pseudocosts",
    3313     -3, 2000000000, CBC_PARAM_INT_NUMBERBEFORE);
    3314   parameters[numberParameters - 1].setLonghelp(
    3315     "Using strong branching computes pseudo-costs.  After this many times for a variable we just \
     3984    parameters.push_back(p);
     3985  }
     3986#ifdef COIN_HAS_CBC
     3987  {
     3988    CbcOrClpParam p("trust!PseudoCosts", "Number of branches before we trust pseudocosts",
     3989      -3, 2000000000, CBC_PARAM_INT_NUMBERBEFORE);
     3990    p.setLonghelp(
     3991      "Using strong branching computes pseudo-costs.  After this many times for a variable we just \
    33163992trust the pseudo costs and do not do any more strong branching.");
    3317 #endif
    3318 #ifdef COIN_HAS_CBC
    3319   parameters[numberParameters++] = CbcOrClpParam("tune!PreProcess", "Dubious tuning parameters",
    3320     0, 2000000000, CLP_PARAM_INT_PROCESSTUNE, 1);
    3321   parameters[numberParameters - 1].setLonghelp(
    3322     "Format aabbcccc - \n If aa then this is number of major passes (i.e. with presolve) \n \
     3993    parameters.push_back(p);
     3994  }
     3995#endif
     3996#ifdef COIN_HAS_CBC
     3997  {
     3998    CbcOrClpParam p("tune!PreProcess", "Dubious tuning parameters",
     3999      0, 2000000000, CLP_PARAM_INT_PROCESSTUNE, 1);
     4000    p.setLonghelp(
     4001      "Format aabbcccc - \n If aa then this is number of major passes (i.e. with presolve) \n \
    33234002If bb and bb>0 then this is number of minor passes (if unset or 0 then 10) \n \
    33244003cccc is bit set \n 0 - 1 Heavy probing \n 1 - 2 Make variables integer if possible (if obj value)\n \
     
    3328400711 - 2048 Try probing before creating cliques\n \
    3329400812 - 4096 Switch off duplicate column checking for integers");
    3330   parameters[numberParameters++] = CbcOrClpParam("two!MirCuts", "Whether to use Two phase Mixed Integer Rounding cuts",
    3331     "off", CBC_PARAM_STR_TWOMIRCUTS);
    3332   parameters[numberParameters - 1].append("on");
    3333   parameters[numberParameters - 1].append("root");
    3334   parameters[numberParameters - 1].append("ifmove");
    3335   parameters[numberParameters - 1].append("forceOn");
    3336   parameters[numberParameters - 1].append("onglobal");
    3337   parameters[numberParameters - 1].append("forceandglobal");
    3338   parameters[numberParameters - 1].append("forceLongOn");
    3339   parameters[numberParameters - 1].setLonghelp(
    3340     "This switches on two phase mixed integer rounding  cuts (either at root or in entire tree) \
     4009    parameters.push_back(p);
     4010  }
     4011  {
     4012    CbcOrClpParam p("two!MirCuts", "Whether to use Two phase Mixed Integer Rounding cuts",
     4013      "off", CBC_PARAM_STR_TWOMIRCUTS);
     4014    p.append("on");
     4015    p.append("root");
     4016    p.append("ifmove");
     4017    p.append("forceOn");
     4018    p.append("onglobal");
     4019    p.append("forceandglobal");
     4020    p.append("forceLongOn");
     4021    p.setLonghelp(
     4022      "This switches on two phase mixed integer rounding  cuts (either at root or in entire tree) \
    33414023See branchAndCut for information on options.");
    3342 #endif
    3343   parameters[numberParameters++] = CbcOrClpParam("unitTest", "Do unit test",
    3344     CLP_PARAM_ACTION_UNITTEST, 3, 1);
    3345   parameters[numberParameters - 1].setLonghelp(
    3346     "This exercises the unit test for clp");
    3347   parameters[numberParameters++] = CbcOrClpParam("userClp", "Hand coded Clp stuff",
    3348     CLP_PARAM_ACTION_USERCLP, 0, 0);
    3349   parameters[numberParameters - 1].setLonghelp(
    3350     "There are times e.g. when using AMPL interface when you may wish to do something unusual.  \
     4024    parameters.push_back(p);
     4025  }
     4026#endif
     4027  {
     4028    CbcOrClpParam p("unitTest", "Do unit test",
     4029      CLP_PARAM_ACTION_UNITTEST, 3, 1);
     4030    p.setLonghelp(
     4031      "This exercises the unit test for clp");
     4032    parameters.push_back(p);
     4033  }
     4034  {
     4035    CbcOrClpParam p("userClp", "Hand coded Clp stuff",
     4036      CLP_PARAM_ACTION_USERCLP, 0, 0);
     4037    p.setLonghelp(
     4038      "There are times e.g. when using AMPL interface when you may wish to do something unusual.  \
    33514039Look for USERCLP in main driver and modify sample code.");
    3352 #ifdef COIN_HAS_CBC
    3353   parameters[numberParameters++] = CbcOrClpParam("userCbc", "Hand coded Cbc stuff",
    3354     CBC_PARAM_ACTION_USERCBC, 0, 0);
    3355   parameters[numberParameters - 1].setLonghelp(
    3356     "There are times e.g. when using AMPL interface when you may wish to do something unusual.  \
     4040    parameters.push_back(p);
     4041  }
     4042#ifdef COIN_HAS_CBC
     4043  {
     4044    CbcOrClpParam p("userCbc", "Hand coded Cbc stuff",
     4045      CBC_PARAM_ACTION_USERCBC, 0, 0);
     4046    p.setLonghelp(
     4047      "There are times e.g. when using AMPL interface when you may wish to do something unusual.  \
    33574048Look for USERCBC in main driver and modify sample code. \
    33584049It is possible you can get same effect by using example driver4.cpp.");
     4050    parameters.push_back(p);
     4051  }
    33594052#endif
    33604053#ifdef COIN_AVX2
    3361   parameters[numberParameters++] = CbcOrClpParam("vector!Mode", "Try and use vector instructions",
    3362     0, 11, CLP_PARAM_INT_VECTOR_MODE);
    3363   parameters[numberParameters - 1].setLonghelp(
    3364     "At present only for Intel architectures - but could be extended.  \
     4054  {
     4055    CbcOrClpParam p("vector!Mode", "Try and use vector instructions",
     4056      0, 11, CLP_PARAM_INT_VECTOR_MODE);
     4057    p.setLonghelp(
     4058      "At present only for Intel architectures - but could be extended.  \
    33654059Uses avx2 or avx512 instructions. Uses different storage for matrix - can be \
    33664060of benefit without instruction set on some problems.  \
    33674061Being lazy I have used 10 to switch on a pool matrix (11 may come later)");
    3368   parameters[numberParameters - 1].setIntValue(0);
    3369 #endif
    3370 #ifdef COIN_HAS_CBC
    3371   parameters[numberParameters++] = CbcOrClpParam("Vnd!VariableNeighborhoodSearch", "Whether to try Variable Neighborhood Search",
    3372     "off", CBC_PARAM_STR_VND);
    3373   parameters[numberParameters - 1].append("on");
    3374   parameters[numberParameters - 1].append("both");
    3375   parameters[numberParameters - 1].append("before");
    3376   parameters[numberParameters - 1].append("intree");
    3377   parameters[numberParameters - 1].setLonghelp(
    3378     "This switches on variable neighborhood Search. \
     4062    p.setIntValue(0);
     4063    parameters.push_back(p);
     4064  }
     4065#endif
     4066#ifdef COIN_HAS_CBC
     4067  {
     4068    CbcOrClpParam p("Vnd!VariableNeighborhoodSearch", "Whether to try Variable Neighborhood Search",
     4069      "off", CBC_PARAM_STR_VND);
     4070    p.append("on");
     4071    p.append("both");
     4072    p.append("before");
     4073    p.append("intree");
     4074    p.setLonghelp(
     4075      "This switches on variable neighborhood Search. \
    33794076Doh option does heuristic before preprocessing");
    3380 #endif
    3381   parameters[numberParameters++] = CbcOrClpParam("vector", "Whether to use vector? Form of matrix in simplex",
    3382     "off", CLP_PARAM_STR_VECTOR, 7, 0);
    3383   parameters[numberParameters - 1].append("on");
    3384   parameters[numberParameters - 1].setLonghelp(
    3385     "If this is on ClpPackedMatrix uses extra column copy in odd format.");
    3386   parameters[numberParameters++] = CbcOrClpParam("verbose", "Switches on longer help on single ?",
    3387     0, 31, CLP_PARAM_INT_VERBOSE, 0);
    3388   parameters[numberParameters - 1].setLonghelp(
    3389     "Set to 1 to get short help with ? list, 2 to get long help, 3 for both.  (add 4 to just get ampl ones).");
    3390   parameters[numberParameters - 1].setIntValue(0);
    3391 #ifdef COIN_HAS_CBC
    3392   parameters[numberParameters++] = CbcOrClpParam("vub!heuristic", "Type of vub heuristic",
    3393     -2, 20, CBC_PARAM_INT_VUBTRY, 0);
    3394   parameters[numberParameters - 1].setLonghelp(
    3395     "If set will try and fix some integer variables");
    3396   parameters[numberParameters - 1].setIntValue(-1);
    3397   parameters[numberParameters++] = CbcOrClpParam("zero!HalfCuts", "Whether to use zero half cuts",
    3398     "off", CBC_PARAM_STR_ZEROHALFCUTS);
    3399   parameters[numberParameters - 1].append("on");
    3400   parameters[numberParameters - 1].append("root");
    3401   parameters[numberParameters - 1].append("ifmove");
    3402   parameters[numberParameters - 1].append("forceOn");
    3403   parameters[numberParameters - 1].append("onglobal");
    3404   parameters[numberParameters - 1].setLonghelp(
    3405     "This switches on zero-half cuts (either at root or in entire tree) \
     4077    parameters.push_back(p);
     4078  }
     4079#endif
     4080  {
     4081    CbcOrClpParam p("vector", "Whether to use vector? Form of matrix in simplex",
     4082      "off", CLP_PARAM_STR_VECTOR, 7, 0);
     4083    p.append("on");
     4084    p.setLonghelp(
     4085      "If this is on ClpPackedMatrix uses extra column copy in odd format.");
     4086    parameters.push_back(p);
     4087  }
     4088  {
     4089    CbcOrClpParam p("verbose", "Switches on longer help on single ?",
     4090      0, 31, CLP_PARAM_INT_VERBOSE, 0);
     4091    p.setLonghelp(
     4092      "Set to 1 to get short help with ? list, 2 to get long help, 3 for both.  (add 4 to just get ampl ones).");
     4093    p.setIntValue(0);
     4094    parameters.push_back(p);
     4095  }
     4096#ifdef COIN_HAS_CBC
     4097  {
     4098    CbcOrClpParam p("vub!heuristic", "Type of vub heuristic",
     4099      -2, 20, CBC_PARAM_INT_VUBTRY, 0);
     4100    p.setLonghelp(
     4101      "If set will try and fix some integer variables");
     4102    p.setIntValue(-1);
     4103    parameters.push_back(p);
     4104  }
     4105  {
     4106    CbcOrClpParam p("zero!HalfCuts", "Whether to use zero half cuts",
     4107      "off", CBC_PARAM_STR_ZEROHALFCUTS);
     4108    p.append("on");
     4109    p.append("root");
     4110    p.append("ifmove");
     4111    p.append("forceOn");
     4112    p.append("onglobal");
     4113    p.setLonghelp(
     4114      "This switches on zero-half cuts (either at root or in entire tree) \
    34064115See branchAndCut for information on options.  This implementation was written by \
    34074116Alberto Caprara.");
    3408 #endif
    3409   parameters[numberParameters++] = CbcOrClpParam("zeroT!olerance", "Kill all coefficients \
     4117    parameters.push_back(p);
     4118  }
     4119#endif
     4120  {
     4121    CbcOrClpParam p("zeroT!olerance", "Kill all coefficients \
    34104122whose absolute value is less than this value",
    3411     1.0e-100, 1.0e-5, CLP_PARAM_DBL_ZEROTOLERANCE);
    3412   parameters[numberParameters - 1].setLonghelp(
    3413     "This applies to reading mps files (and also lp files \
     4123      1.0e-100, 1.0e-5, CLP_PARAM_DBL_ZEROTOLERANCE);
     4124    p.setLonghelp(
     4125      "This applies to reading mps files (and also lp files \
    34144126if KILL_ZERO_READLP defined)");
    3415   parameters[numberParameters - 1].setDoubleValue(1.0e-20);
    3416   assert(numberParameters < CBCMAXPARAMETERS);
     4127    p.setDoubleValue(1.0e-20);
     4128    parameters.push_back(p);
     4129  }
    34174130}
    34184131// Given a parameter type - returns its number in list
    3419 int whichParam(CbcOrClpParameterType name,
    3420   int numberParameters, CbcOrClpParam *const parameters)
    3421 {
    3422   int i;
    3423   for (i = 0; i < numberParameters; i++) {
     4132int whichParam(const CbcOrClpParameterType &name,
     4133  const std::vector< CbcOrClpParam > &parameters)
     4134{
     4135  for (int i = 0; i < (int)parameters.size(); i++) {
    34244136    if (parameters[i].type() == name)
    3425       break;
    3426   }
    3427   assert(i < numberParameters);
    3428   return i;
     4137      return i;
     4138  }
     4139  return std::numeric_limits< int >::max(); // should not arrive here
    34294140}
    34304141#ifdef COIN_HAS_CLP
  • trunk/Clp/src/CbcOrClpParam.hpp

    r2385 r2389  
    542542  class CbcOrClpParam for details. Pulled from C..Main() for clarity.
    543543*/
    544 void establishParams(int &numberParameters, CbcOrClpParam *const parameters);
     544void establishParams(std::vector< CbcOrClpParam > &params);
    545545// Given a parameter type - returns its number in list
    546 int whichParam(CbcOrClpParameterType name,
    547   int numberParameters, CbcOrClpParam *const parameters);
     546int whichParam(const CbcOrClpParameterType &name,
     547  const std::vector< CbcOrClpParam > &parameters);
    548548// Dump/restore a solution to file
    549549void saveSolution(const ClpSimplex *lpSolver, std::string fileName);
  • trunk/Clp/src/ClpSolver.cpp

    r2385 r2389  
    270270  std::string solutionSaveFile = "solution.file";
    271271  std::string printMask = "";
    272   CbcOrClpParam parameters[CBCMAXPARAMETERS];
    273   int numberParameters;
    274   establishParams(numberParameters, parameters);
    275   parameters[whichParam(CLP_PARAM_ACTION_BASISIN, numberParameters, parameters)].setStringValue(importBasisFile);
    276   parameters[whichParam(CLP_PARAM_ACTION_BASISOUT, numberParameters, parameters)].setStringValue(exportBasisFile);
    277   parameters[whichParam(CLP_PARAM_ACTION_PRINTMASK, numberParameters, parameters)].setStringValue(printMask);
    278   parameters[whichParam(CLP_PARAM_ACTION_DIRECTORY, numberParameters, parameters)].setStringValue(directory);
    279   parameters[whichParam(CLP_PARAM_ACTION_DIRSAMPLE, numberParameters, parameters)].setStringValue(dirSample);
    280   parameters[whichParam(CLP_PARAM_ACTION_DIRNETLIB, numberParameters, parameters)].setStringValue(dirNetlib);
    281   parameters[whichParam(CBC_PARAM_ACTION_DIRMIPLIB, numberParameters, parameters)].setStringValue(dirMiplib);
    282   parameters[whichParam(CLP_PARAM_DBL_DUALBOUND, numberParameters, parameters)].setDoubleValue(models->dualBound());
    283   parameters[whichParam(CLP_PARAM_DBL_DUALTOLERANCE, numberParameters, parameters)].setDoubleValue(models->dualTolerance());
    284   parameters[whichParam(CLP_PARAM_ACTION_EXPORT, numberParameters, parameters)].setStringValue(exportFile);
    285   parameters[whichParam(CLP_PARAM_INT_IDIOT, numberParameters, parameters)].setIntValue(doIdiot);
    286   parameters[whichParam(CLP_PARAM_ACTION_IMPORT, numberParameters, parameters)].setStringValue(importFile);
    287   parameters[whichParam(CLP_PARAM_INT_SOLVERLOGLEVEL, numberParameters, parameters)].setIntValue(models->logLevel());
    288   parameters[whichParam(CLP_PARAM_INT_MAXFACTOR, numberParameters, parameters)].setIntValue(models->factorizationFrequency());
    289   parameters[whichParam(CLP_PARAM_INT_MAXITERATION, numberParameters, parameters)].setIntValue(models->maximumIterations());
    290   parameters[whichParam(CLP_PARAM_INT_OUTPUTFORMAT, numberParameters, parameters)].setIntValue(outputFormat);
    291   parameters[whichParam(CLP_PARAM_INT_PRESOLVEPASS, numberParameters, parameters)].setIntValue(preSolve);
    292   parameters[whichParam(CLP_PARAM_INT_PERTVALUE, numberParameters, parameters)].setIntValue(models->perturbation());
    293   parameters[whichParam(CLP_PARAM_DBL_PRIMALTOLERANCE, numberParameters, parameters)].setDoubleValue(models->primalTolerance());
    294   parameters[whichParam(CLP_PARAM_DBL_PRIMALWEIGHT, numberParameters, parameters)].setDoubleValue(models->infeasibilityCost());
    295   parameters[whichParam(CLP_PARAM_ACTION_RESTORE, numberParameters, parameters)].setStringValue(restoreFile);
    296   parameters[whichParam(CLP_PARAM_ACTION_SAVE, numberParameters, parameters)].setStringValue(saveFile);
    297   parameters[whichParam(CLP_PARAM_DBL_TIMELIMIT, numberParameters, parameters)].setDoubleValue(models->maximumSeconds());
    298   parameters[whichParam(CLP_PARAM_ACTION_SOLUTION, numberParameters, parameters)].setStringValue(solutionFile);
    299   parameters[whichParam(CLP_PARAM_ACTION_SAVESOL, numberParameters, parameters)].setStringValue(solutionSaveFile);
    300   parameters[whichParam(CLP_PARAM_INT_SPRINT, numberParameters, parameters)].setIntValue(doSprint);
    301   parameters[whichParam(CLP_PARAM_INT_SUBSTITUTION, numberParameters, parameters)].setIntValue(substitution);
    302   parameters[whichParam(CLP_PARAM_INT_DUALIZE, numberParameters, parameters)].setIntValue(dualize);
    303   parameters[whichParam(CLP_PARAM_DBL_PRESOLVETOLERANCE, numberParameters, parameters)].setDoubleValue(1.0e-8);
     272  std::vector< CbcOrClpParam > parameters;
     273  establishParams(parameters);
     274  parameters[whichParam(CLP_PARAM_ACTION_BASISIN, parameters)].setStringValue(importBasisFile);
     275  parameters[whichParam(CLP_PARAM_ACTION_BASISOUT, parameters)].setStringValue(exportBasisFile);
     276  parameters[whichParam(CLP_PARAM_ACTION_PRINTMASK, parameters)].setStringValue(printMask);
     277  parameters[whichParam(CLP_PARAM_ACTION_DIRECTORY, parameters)].setStringValue(directory);
     278  parameters[whichParam(CLP_PARAM_ACTION_DIRSAMPLE, parameters)].setStringValue(dirSample);
     279  parameters[whichParam(CLP_PARAM_ACTION_DIRNETLIB, parameters)].setStringValue(dirNetlib);
     280  parameters[whichParam(CBC_PARAM_ACTION_DIRMIPLIB, parameters)].setStringValue(dirMiplib);
     281  parameters[whichParam(CLP_PARAM_DBL_DUALBOUND, parameters)].setDoubleValue(models->dualBound());
     282  parameters[whichParam(CLP_PARAM_DBL_DUALTOLERANCE, parameters)].setDoubleValue(models->dualTolerance());
     283  parameters[whichParam(CLP_PARAM_ACTION_EXPORT, parameters)].setStringValue(exportFile);
     284  parameters[whichParam(CLP_PARAM_INT_IDIOT, parameters)].setIntValue(doIdiot);
     285  parameters[whichParam(CLP_PARAM_ACTION_IMPORT, parameters)].setStringValue(importFile);
     286  parameters[whichParam(CLP_PARAM_INT_SOLVERLOGLEVEL, parameters)].setIntValue(models->logLevel());
     287  parameters[whichParam(CLP_PARAM_INT_MAXFACTOR, parameters)].setIntValue(models->factorizationFrequency());
     288  parameters[whichParam(CLP_PARAM_INT_MAXITERATION, parameters)].setIntValue(models->maximumIterations());
     289  parameters[whichParam(CLP_PARAM_INT_OUTPUTFORMAT, parameters)].setIntValue(outputFormat);
     290  parameters[whichParam(CLP_PARAM_INT_PRESOLVEPASS, parameters)].setIntValue(preSolve);
     291  parameters[whichParam(CLP_PARAM_INT_PERTVALUE, parameters)].setIntValue(models->perturbation());
     292  parameters[whichParam(CLP_PARAM_DBL_PRIMALTOLERANCE, parameters)].setDoubleValue(models->primalTolerance());
     293  parameters[whichParam(CLP_PARAM_DBL_PRIMALWEIGHT, parameters)].setDoubleValue(models->infeasibilityCost());
     294  parameters[whichParam(CLP_PARAM_ACTION_RESTORE, parameters)].setStringValue(restoreFile);
     295  parameters[whichParam(CLP_PARAM_ACTION_SAVE, parameters)].setStringValue(saveFile);
     296  parameters[whichParam(CLP_PARAM_DBL_TIMELIMIT, parameters)].setDoubleValue(models->maximumSeconds());
     297  parameters[whichParam(CLP_PARAM_ACTION_SOLUTION, parameters)].setStringValue(solutionFile);
     298  parameters[whichParam(CLP_PARAM_ACTION_SAVESOL, parameters)].setStringValue(solutionSaveFile);
     299  parameters[whichParam(CLP_PARAM_INT_SPRINT, parameters)].setIntValue(doSprint);
     300  parameters[whichParam(CLP_PARAM_INT_SUBSTITUTION, parameters)].setIntValue(substitution);
     301  parameters[whichParam(CLP_PARAM_INT_DUALIZE, parameters)].setIntValue(dualize);
     302  parameters[whichParam(CLP_PARAM_DBL_PRESOLVETOLERANCE, parameters)].setDoubleValue(1.0e-8);
    304303  int verbose = 0;
    305304
     
    418417  int choleskyType = 0;
    419418  int gamma = 0;
    420   parameters[whichParam(CLP_PARAM_STR_BARRIERSCALE, numberParameters, parameters)].setCurrentOption(2);
     419  parameters[whichParam(CLP_PARAM_STR_BARRIERSCALE, parameters)].setCurrentOption(2);
    421420  int scaleBarrier = 2;
    422421  int doKKT = 0;
     
    471470    int numberMatches = 0;
    472471    int firstMatch = -1;
    473     for (iParam = 0; iParam < numberParameters; iParam++) {
     472    for (iParam = 0; iParam < (int)parameters.size(); iParam++) {
    474473      int match = parameters[iParam].matches(field);
    475474      if (match == 1) {
     
    484483    }
    485484    ClpSimplex *thisModel = models + iModel;
    486     if (iParam < numberParameters && !numberQuery) {
     485    if (iParam < (int)parameters.size() && !numberQuery) {
    487486      // found
    488487      CbcOrClpParam found = parameters[iParam];
     
    503502        bool evenHidden = false;
    504503        int printLevel = parameters[whichParam(CLP_PARAM_STR_ALLCOMMANDS,
    505                                       numberParameters, parameters)]
     504                                      parameters)]
    506505                           .currentOptionAsInteger();
    507506        int convertP[] = { 2, 1, 0 };
     
    533532          if ((verbose & 2) != 0)
    534533            std::cout << std::endl;
    535           for (iParam = 0; iParam < numberParameters; iParam++) {
     534          for (iParam = 0; iParam < (int)parameters.size(); iParam++) {
    536535            int type = parameters[iParam].type();
    537536            //printf("%d type %d limits %d %d display %d\n",iParam,
     
    587586          int across = 0;
    588587          std::cout << types[iType] << std::endl;
    589           for (iParam = 0; iParam < numberParameters; iParam++) {
     588          for (iParam = 0; iParam < (int)parameters.size(); iParam++) {
    590589            int type = parameters[iParam].type();
    591590            if (type >= limits[iType]
     
    713712            } else if (action == 4) {
    714713              // Positive edge steepest
    715               ClpPEDualRowSteepest p(fabs(parameters[whichParam(CLP_PARAM_DBL_PSI, numberParameters, parameters)].doubleValue()));
     714              ClpPEDualRowSteepest p(fabs(parameters[whichParam(CLP_PARAM_DBL_PSI, parameters)].doubleValue()));
    716715              thisModel->setDualRowPivotAlgorithm(p);
    717716            } else if (action == 5) {
    718717              // Positive edge Dantzig
    719               ClpPEDualRowDantzig p(fabs(parameters[whichParam(CLP_PARAM_DBL_PSI, numberParameters, parameters)].doubleValue()));
     718              ClpPEDualRowDantzig p(fabs(parameters[whichParam(CLP_PARAM_DBL_PSI, parameters)].doubleValue()));
    720719              thisModel->setDualRowPivotAlgorithm(p);
    721720            }
     
    745744            } else if (action == 7) {
    746745              // Positive edge steepest
    747               ClpPEPrimalColumnSteepest p(fabs(parameters[whichParam(CLP_PARAM_DBL_PSI, numberParameters, parameters)].doubleValue()));
     746              ClpPEPrimalColumnSteepest p(fabs(parameters[whichParam(CLP_PARAM_DBL_PSI, parameters)].doubleValue()));
    748747              thisModel->setPrimalColumnPivotAlgorithm(p);
    749748            } else if (action == 8) {
    750749              // Positive edge Dantzig
    751               ClpPEPrimalColumnDantzig p(fabs(parameters[whichParam(CLP_PARAM_DBL_PSI, numberParameters, parameters)].doubleValue()));
     750              ClpPEPrimalColumnDantzig p(fabs(parameters[whichParam(CLP_PARAM_DBL_PSI, parameters)].doubleValue()));
    752751              thisModel->setPrimalColumnPivotAlgorithm(p);
    753752            }
     
    871870            //openblas_set_num_threads(4);
    872871            // deal with positive edge
    873             double psi = parameters[whichParam(CLP_PARAM_DBL_PSI, numberParameters, parameters)].doubleValue();
     872            double psi = parameters[whichParam(CLP_PARAM_DBL_PSI, parameters)].doubleValue();
    874873            if (psi > 0.0) {
    875874              ClpDualRowPivot *dualp = clpModel->dualRowPivot();
     
    896895            if (type == CLP_PARAM_ACTION_EITHERSIMPLEX || type == CBC_PARAM_ACTION_BAB)
    897896              models[iModel].setMoreSpecialOptions(16384 | models[iModel].moreSpecialOptions());
    898             double objScale = parameters[whichParam(CLP_PARAM_DBL_OBJSCALE2, numberParameters, parameters)].doubleValue();
     897            double objScale = parameters[whichParam(CLP_PARAM_DBL_OBJSCALE2, parameters)].doubleValue();
    899898            if (objScale != 1.0) {
    900899              int iColumn;
     
    11101109            }
    11111110#ifdef CLP_MULTIPLE_FACTORIZATIONS
    1112             int denseCode = parameters[whichParam(CBC_PARAM_INT_DENSE, numberParameters, parameters)].intValue();
     1111            int denseCode = parameters[whichParam(CBC_PARAM_INT_DENSE, parameters)].intValue();
    11131112            if (denseCode != -1)
    11141113              model2->factorization()->setGoDenseThreshold(denseCode);
    1115             int smallCode = parameters[whichParam(CBC_PARAM_INT_SMALLFACT, numberParameters, parameters)].intValue();
     1114            int smallCode = parameters[whichParam(CBC_PARAM_INT_SMALLFACT, parameters)].intValue();
    11161115            if (smallCode != -1)
    11171116              model2->factorization()->setGoSmallThreshold(smallCode);
     
    13221321              // switch off (user can switch back on)
    13231322              parameters[whichParam(CLP_PARAM_INT_DUALIZE,
    1324                            numberParameters, parameters)]
     1323                           parameters)]
    13251324                .setIntValue(dualize);
    13261325            }
     
    13441343              if ((printOptions & 1) != 0)
    13451344                pinfo.statistics();
    1346               double presolveTolerance = parameters[whichParam(CLP_PARAM_DBL_PRESOLVETOLERANCE, numberParameters, parameters)].doubleValue();
     1345              double presolveTolerance = parameters[whichParam(CLP_PARAM_DBL_PRESOLVETOLERANCE, parameters)].doubleValue();
    13471346              model2 = pinfo.presolvedModel(models[iModel], presolveTolerance,
    13481347                true, preSolve);
     
    15571556        case CLP_PARAM_ACTION_EXPORT:
    15581557          if (goodModels[iModel]) {
    1559             double objScale = parameters[whichParam(CLP_PARAM_DBL_OBJSCALE2, numberParameters, parameters)].doubleValue();
     1558            double objScale = parameters[whichParam(CLP_PARAM_DBL_OBJSCALE2, parameters)].doubleValue();
    15601559            if (objScale != 1.0) {
    15611560              int iColumn;
     
    16311630                if ((printOptions & 1) != 0)
    16321631                  pinfo.statistics();
    1633                 double presolveTolerance = parameters[whichParam(CLP_PARAM_DBL_PRESOLVETOLERANCE, numberParameters, parameters)].doubleValue();
     1632                double presolveTolerance = parameters[whichParam(CLP_PARAM_DBL_PRESOLVETOLERANCE, parameters)].doubleValue();
    16341633                model2 = pinfo.presolvedModel(models[iModel], presolveTolerance,
    16351634                  true, preSolve, false, false);
     
    19171916            if (preSolve) {
    19181917              ClpPresolve pinfo;
    1919               double presolveTolerance = parameters[whichParam(CLP_PARAM_DBL_PRESOLVETOLERANCE, numberParameters, parameters)].doubleValue();
     1918              double presolveTolerance = parameters[whichParam(CLP_PARAM_DBL_PRESOLVETOLERANCE, parameters)].doubleValue();
    19201919              model2 = pinfo.presolvedModel(models[iModel], presolveTolerance,
    19211920                false, preSolve);
     
    29232922      else
    29242923        std::cout << "Completions of " << field << ":" << std::endl;
    2925       for (iParam = 0; iParam < numberParameters; iParam++) {
     2924      for (iParam = 0; iParam < (int)parameters.size(); iParam++) {
    29262925        int match = parameters[iParam].matches(field);
    29272926        if (match && parameters[iParam].displayThis()) {
Note: See TracChangeset for help on using the changeset viewer.