Changeset 2389
 Timestamp:
 Feb 7, 2019 2:48:00 PM (18 months ago)
 Location:
 trunk/Clp/src
 Files:

 3 edited
Legend:
 Unmodified
 Added
 Removed

trunk/Clp/src/CbcOrClpParam.cpp
r2385 r2389 1489 1489 class CbcOrClpParam for details. Pulled from C..Main() for clarity. 1490 1490 */ 1491 void establishParams( int &numberParameters, CbcOrClpParam *constparameters)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); 1491 void establishParams(std::vector< CbcOrClpParam > ¶meters) 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 1498 1498 #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( 1513 1512 "Decide whether to use A Basic Optimization Code (Accelerated?) \ 1514 1513 and 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 \ 1522 1524 are 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 \ 1525 1530 best 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 \ 1530 1535 then the search will be terminated. Also see ratioGap."); 1536 parameters.push_back(p); 1537 } 1531 1538 #endif 1532 1539 #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 \ 1537 1545 basis 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 } 1545 1558 #endif 1546 1559 #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\ 1552 1566 it may be worth setting this true. It is still experimental and you may prefer\ 1553 1567 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 \ 1558 1575 corrector algorithm. You may want to link in an alternative \ 1559 1576 ordering 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\ 1577 with 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\ 1567 1585 directory given by 'directory'. A name of '$' will use the previous value for the name. This\ 1568 1586 is initialized to '', i.e. it must be set. If you have libz then it can read compressed\ 1569 1587 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\ 1574 1596 directory given by 'directory'. A name of '$' will use the previous value for the name. This\ 1575 1597 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. \ 1588 1617 First just try with default settings and look carefully at the log file. Did cuts help? Did they take too long? \ 1589 1618 Look at output to see which cuts were effective and then do some tuning. You will see that the \ … … 1600 1629 and trustPseudoCosts parameters. If cuts did a good job, then you may wish to \ 1601 1630 have 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 } 1610 1644 #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 1622 1662 #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"); 1625 1665 #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"); 1628 1668 #endif 1629 1669 #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"); 1631 1671 #else 1632 parameters[numberParameters  1].append("Uni!versityOfFlorida_dummy");1672 p.append("Uni!versityOfFlorida_dummy"); 1633 1673 #endif 1634 1674 #ifdef TAUCS_BARRIER 1635 parameters[numberParameters  1].append("Taucs");1675 p.append("Taucs"); 1636 1676 #else 1637 parameters[numberParameters  1].append("Taucs_dummy");1677 p.append("Taucs_dummy"); 1638 1678 #endif 1639 1679 #ifdef COIN_HAS_MUMPS 1640 parameters[numberParameters  1].append("Mumps");1680 p.append("Mumps"); 1641 1681 #else 1642 parameters[numberParameters  1].append("Mumps_dummy");1682 p.append("Mumps_dummy"); 1643 1683 #endif 1644 1684 #ifdef PARDISO_BARRIER 1645 parameters[numberParameters  1].append("Pardiso");1685 p.append("Pardiso"); 1646 1686 #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. \ 1651 1691 The native ordering and factorization is not state of the art, although acceptable. \ 1652 1692 You may want to link in one from another source. See Makefile.locations for some \ 1653 1693 possibilities."); 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) \ 1665 1708 See 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 \ 1676 1724 using variables which have appeared in one or more solutions. \ 1677 1725 It obviously only tries after two or more solutions. \ 1678 1726 See 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 \ 1686 1738 fixing variables which have same value in two or more solutions. \ 1687 1739 It obviously only tries after two or more solutions. \ 1688 1740 See 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 \ 1709 1769 first. This primitive strategy can be surprsingly effective. The column order\ 1710 1770 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 \ 1716 1780 then you can! If this is on, then Cbc will get to the root node and then \ 1717 1781 hand over to Cplex. If heuristics find a solution this can be significantly \ … … 1720 1784 off preprocessing, although for difficult problems it is worth trying \ 1721 1785 both."); 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 standalone 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 standalone solver does then this allows \ 1727 1794 you to generate user_driver.cpp which approximates the code. \ 1728 1795 0 gives simplest driver, 1 generates saves and restores, 2 \ … … 1731 1798 This is now deprecated as you can call standalone solver  see \ 1732 1799 Cbc/examples/driver4.cpp."); 1800 parameters.push_back(p); 1801 } 1733 1802 #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"); 1739 1810 #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"); 1743 1814 #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 \ 1764 1839 the feasibility criterion is a bit suspect (JJF)). This option will crossover \ 1765 1840 to a basic solution suitable for ranging or branch and cut. With the current state \ 1766 1841 of quadratic it may be a good idea to switch off crossover for quadratic (and maybe \ 1767 1842 presolve 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\ 1774 1852 directory given by 'directory'. A name of '$' will use the previous value for the name. This\ 1775 1853 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 \ 1780 1861 and on. If they are done every node then that is that, but it may be worth doing them \ 1781 1862 every so often. The original method was every so many nodes but it is more logical \ 1782 1863 to do it whenever depth in tree is a multiple of K. This option does that and defaults \ 1783 1864 to 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. \ 1789 1872 Any value >0 says that all cuts <= this length can be generated both at \ 1790 1873 root node and in tree. 0 says to use some dynamic lengths. If value >=10,000,000 \ 1791 1874 then the length in tree is value%10000000  so 10000100 means unlimited length \ 1792 1875 at 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). \ 1799 1885 This is also set by code whenever it obtains a solution and is set to value of \ 1800 1886 objective 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 \ 1809 1898 individual ones off or on \ 1810 1899 See 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\ 1815 1908 directory given by 'directory'. A name of '$' will use the previous value for the name. This\ 1816 1909 is initialized to '', i.e. it must be set.\n\n\ … … 1819 1912 you can do a good run with debug set to 'create' and then switch on the cuts you suspect and \ 1820 1913 rerun with debug set to 'debug.file' The create case has same effect as saveSolution."); 1914 parameters.push_back(p); 1915 } 1821 1916 #endif 1822 1917 #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 \ 1827 1923 Dantzig Wolfe if primal, Benders if dual \ 1828 1924  uses sprint pass for number of passes"); 1829 parameters[numberParameters  1].setIntValue(0); 1925 p.setIntValue(0); 1926 parameters.push_back(p); 1927 } 1830 1928 #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>= value2 (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 \ 1947 means use Cplex if it is linked in. Otherwise if negative then go into depth first complete search fast branch and bound when depth>= value2 \ 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 \ 1949 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. \ 1950 The 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. \ 1862 1981 See 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\ 1870 1992 You 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.\ 1875 2000 It is initialized to './'"); 1876 parameters[numberParameters++] = CbcOrClpParam("dirSample", "Set directory where the COINOR sample problems are.", 1877 CLP_PARAM_ACTION_DIRSAMPLE, 7, 1); 1878 parameters[numberParameters  1].setLonghelp( 1879 "This sets the directory where the COINOR sample problems reside. It is\ 2001 parameters.push_back(p); 2002 } 2003 { 2004 CbcOrClpParam p("dirSample", "Set directory where the COINOR sample problems are.", 2005 CLP_PARAM_ACTION_DIRSAMPLE, 7, 1); 2006 2007 p.setLonghelp( 2008 "This sets the directory where the COINOR sample problems reside. It is\ 1880 2009 used only when unitTest is passed to clp. clp will pick up the test problems\ 1881 2010 from this directory.\ 1882 2011 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\ 1887 2020 the netlib problems from COINOR or from the main netlib site. This\ 1888 2021 parameter is used only when netlib is passed to clp. clp will pick up the\ … … 1890 2023 then the problems must be uncompressed.\ 1891 2024 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\ 1896 2033 get the miplib problems from COINOR or from the main miplib site. This\ 1897 2034 parameter is used only when miplib is passed to cbc. cbc will pick up the\ … … 1899 2036 then the problems must be uncompressed.\ 1900 2037 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  \ 1906 2046 \n\t3 only at root and if no solution, \ 1907 2047 \n\t4 only at root and if this heuristic has not got solution, \ … … 1911 2051 \n\t>10 All only at root (DivingC normal as value10), \ 1912 2052 \n\t>20 All with value20)."); 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 \ 1918 2062 and used for extra options  \ 1919 2063 \n\t13 allow fixing of satisfied integers (but not at bound) \ 1920 2064 \n\t1 switch off above for that dive if goes infeasible \ 1921 2065 \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. \ 1930 2078 C  Coefficient, F  Fractional, G  Guided, L  LineSearch, P  PseudoCost, V  VectorLength. \ 1931 2079 You may prefer to use individual on/off \ 1932 2080 See 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. \ 1967 2136 Only those heuristics with 'both' or 'before' set will run. \ 1968 2137 Doing this may also set cutoff, which can help with preprocessing."); 2138 parameters.push_back(p); 2139 } 1969 2140 #endif 1970 2141 #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 \ 1972 2144 gap between bounds exceeds this value", 1973 1.0e20, 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.0e20, 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\ 1976 2148 algorithm where you first get feasible then optimal. If a problem has both upper and\ 1977 2149 lower bounds then it is trivial to get dual feasible by setting non basic variables\ … … 1982 2154 the code may go all the way and then have to increase the bounds. OSL had a heuristic to\ 1983 2155 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\ 1997 2177 implements the features in the abstract pivot base class. The Dantzig method is implemented\ 1998 2178 to show a simple method but its use is deprecated. Steepest is the method of choice and there\ … … 2002 2182 ** NEWS  the Positive Edge criterion has been added. \ 2003 2183 This 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.\ 2008 2191 The time and iterations may be affected by settings such as presolve, scaling, crash\ 2009 2192 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 \ 2012 2198 no dual infeasibility may exceed this value", 2013 1.0e20, 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.0e20, 1.0e12, CLP_PARAM_DBL_DUALTOLERANCE); 2200 p.setLonghelp( 2201 "Normally the default tolerance is fine, but you may want to increase it a\ 2016 2202 bit if a dual run seems to be having a hard time. One method which can be faster is \ 2017 2203 to use a large tolerance e.g. 1.0e4 and dual and then clean up problem using primal and the \ 2018 2204 correct 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 } 2027 2218 #endif 2028 2219 #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,\ 2033 2225 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.\ 2048 2250 Setting this to 'on' will allow all errors from which the code can recover\ 2049 2251 simply by ignoring the error. There are some errors from which the code can not recover \ 2050 2252 e.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. \ 2060 2268 0 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\ 2066 2279 \n\t0  normal\n\ 2067 2280 \n\twhen to do all fractional\n\ … … 2073 2286 \n\t10  root node etc.\n\ 2074 2287 \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\ 2081 2298 directory given by 'directory'. A name of '$' will use the previous value for the name. This\ 2082 2299 is initialized to 'default.mps'. \ 2083 2300 It 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!! \ 2099 2329 The bottom digit is a strategy when to used shadow price stuff e.g. 3 \ 2100 2330 means use until a solution is found. The next two digits say what sort \ … … 2104 2334 \n\t8000  increase minimum drop gradually\n\ 2105 2335 \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 \ 2111 2344 to gather all variables with same cost."); 2345 parameters.push_back(p); 2346 } 2112 2347 #endif 2113 2348 #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( 2120 2356 #ifndef ABC_INHERIT 2121 "The default is to use the normal CoinFactorization, but \2357 "The default is to use the normal CoinFactorization, but \ 2122 2358 other choices are a dense one, osl's or one designed for small problems." 2123 2359 #else 2124 "Normally the default is to use the normal CoinFactorization, but \2360 "Normally the default is to use the normal CoinFactorization, but \ 2125 2361 other choices are a dense one, osl's or one designed for small problems. \ 2126 2362 However if at Aboca then the default is CoinAbcFactorization and other choices are \ 2127 2363 a dense one, one designed for small problems or if enabled a long factorization." 2128 2364 #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 \ 2140 2383 and uses a sequence of Lps to try and get an integer feasible solution. \ 2141 2384 Some fine tuning is available by passFeasibilityPump and also pumpTune. \ 2142 2385 See 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 \ 2144 2390 reduced 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 \ 2148 2394 before 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) \ 2159 2408 See branchAndCut for information on options. \ 2160 2409 Can 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. \ 2166 2418 If 0 then just tries to set as best solution \ 2167 2419 If >1 then also does that many nodes on fixed problem."); 2168 parameters[numberParameters++] = CbcOrClpParam("fraction!forBAB", "Fraction in feasibility pump", 2169 1.0e5, 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.0e5, 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 \ 2173 2428 about 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) \ 2429 of branch and bound are done on reduced problem. Small problem has to be \ 2430 less 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) \ 2200 2464 This version is by Giacomo Nannicini and may be more robust \ 2201 2465 See 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[numberParameters1].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, \ 2482 they are now more fashionable as LP solvers are more robust and they interact well \ 2483 with other cuts. They will almost always give cuts (although in this executable \ 2484 they are limited as to number of variables in cut). However the cuts may be dense \ 2485 so it is worth experimenting (Long allows any length). See branchAndCut for \ 2486 information 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. \ 2499 It may just fix a percentage of variables and then try a small branch and cut run. \ 2227 2500 See 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 \ 2510 directory given by 'directory'. A name of '$' will use the previous value for the \ 2511 name. This is initialized to 'stdout' (this defaults to ordinary solution if stdout). \ 2235 2512 If 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( 2239 2518 "This looks at model statistics and does an initial solve \ 2240 2519 setting 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 \ 2247 2529 individual ones off or on. CbcTreeLocal is not included as it dramatically \ 2248 2530 alters search."); 2249 #endif 2250 parameters[numberParameters++] = CbcOrClpParam("help", "Print out version, nonstandard 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, nonstandard 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 \ 2254 2538 you 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. \ 2260 2549 Others are for feasibility pump  \ 2261 2550 2 says do exact number of passes given, \ 2262 2551 4 only applies if initial cutoff given and says relax after 50 passes, \ 2263 2552 while 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 } 2267 2560 #endif 2268 2561 #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\ 2281 2579 directory given by 'directory'. A name of '$' will use the previous value for the name. This\ 2282 2580 is initialized to '', i.e. it must be set. If you have libgz then it can read compressed\ 2283 2581 files 'xxxxxxxx.gz' or 'xxxxxxxx.bz2'. \ 2284 2582 If '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 \ 2287 2588 much 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\ 2291 2593 sense) plus this. If it is not set then the code will try and work one out e.g. if \ 2292 2594 all objective coefficients are multiples of 0.01 and only integer variables have entries in \ 2293 2595 objective 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 \ 2295 2601 to 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 \ 2299 2605 expected 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 \ 2305 2618 no integer variable may be this away from an integer value", 2306 1.0e20, 0.5, CBC_PARAM_DBL_INTEGERTOLERANCE); 2307 parameters[numberParameters  1].setLonghelp( 2308 "Beware of setting this smaller than the primal tolerance."); 2619 1.0e20, 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 } 2309 2624 #endif 2310 2625 #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. \ 2316 2632 This 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) \ 2332 2655 See 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 RelaxandCut Framework for Gomory's MixedInteger 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 RelaxandCut Framework for Gomory's MixedInteger Cuts' \ 2352 2678 by Matteo Fischetti & Domenico Salvagnin. This simplification \ 2353 2679 just uses original constraints while modifying objective using other cuts. \ … … 2358 2684 does a few passes. \ 2359 2685 The 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. \ 2385 2719 May be slow \ 2386 2720 See 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 \ 2392 2729 Fischetti and Lodi and is not really a heuristic although it can be used as one. \ 2393 2730 When used from Coin solve it has limited functionality. It is not switched on when \ 2394 2731 heuristics are switched on."); 2395 #endif 2732 parameters.push_back(p); 2733 } 2734 #endif 2735 { 2396 2736 #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); 2399 2740 #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\ 2406 2747 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\ 2411 2755 You can also use the parameters 'direction maximize'."); 2756 parameters.push_back(p); 2757 } 2412 2758 #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 \ 2414 2761 refactorizations", 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\ 2418 2765 value to use. Otherwise the user can set a value. The code may decide to refactorize\ 2419 2766 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 \ 2421 2771 stopping", 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\ 2425 2775 \tsetMaximumIterations(value)\n can be useful. If the code stops on\ 2426 2776 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 \ 2433 2786 but 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. \ 2442 2801 This 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\ 2448 2810 This should only be necessary if you have previously set maximization \ 2449 2811 You 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) \ 2467 2842 See 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\ 2473 2852 Clp0005 2261 Objective 109.024 Primal infeas 944413 (758)\n\ 2474 2853 but this program turns this off to make it look more friendly. It can be useful\ 2475 2854 to turn them back on if you want to be able to 'grep' for particular messages or if\ 2476 2855 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("\ 2483 2868 The MIPStart allows one to enter an initial integer feasible solution \ 2484 2869 to CBC. Values of the main decision variables which are active (have \ … … 2514 2899 \n\n\ 2515 2900 Question 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\ 2901 haroldo.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\ 2526 2917 \t/100000 == 1 use box constraints and original obj in cleanup\n\ 2527 2918 \t/1000 == 1 Pump will run twice if no solution found\n\ … … 2531 2922 \t/100 == 2,3.. allow more iterations per pass\n\ 2532 2923 \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 \ 2539 2933 and collect all solutions and cuts generated. The actual format is aabbcc \ 2540 2934 where aa is number of extra passes, if bb is non zero \ … … 2545 2939 The solvers do not interact with each other. However if extra passes are specified \ 2546 2940 then 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!. \ 2554 2952 Doh option does heuristic before preprocessing"); 2953 parameters.push_back(p); 2954 } 2555 2955 #endif 2556 2956 #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.\ 2561 2962 The 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.\ 2566 2970 The 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.\ 2571 2979 The 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.\ 2576 2987 The 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 \ 2581 2995 works best. I know this is cheating but it also stresses the code better by doing a \ 2582 2996 mixture of stuff. The best algorithm was chosen on a Linux ThinkPad using native cholesky \ 2583 2997 with 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\ 2588 3005 operations may be a bit faster with more efficient storage, but the main advantage\ 2589 3006 comes from using a network factorization. It will probably not be as fast as a \ 2590 3007 specialized 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) \ 2596 3017 and then deletes it. \ 2597 3018 This will write a primitive solution file to the given file name. It will use the default\ 2598 3019 directory given by 'directory'. A name of '$' will use the previous value for the name. This\ 2599 3020 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. \ 2610 3034 You can choose depth as the criterion. You can also say if up or down branch must \ 2611 3035 be done first (the up down choice will carry on after solution). \ 2612 3036 Default 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. \ 2617 3044 This 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\ 2623 3053 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 } 2625 3057 #endif 2626 3058 #ifdef COIN_HAS_CBC 2627 3059 #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. \ 2636 3069 On 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 preprocessed 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 preprocessed 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...\ 2643 3079 Setting 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\ 2652 3094 per line. You may want to do just one per line (for grep or suchlike) and you may wish\ 2653 3095 to save with absolute accuracy using a coded version of the IEEE value. A value of 2 is normal.\ … … 2655 3097 gives greater precision, while 5,6 give IEEE values. When used for exporting a basis 1 does not save \ 2656 3098 values, 2 saves values, 3 with greater accuracy and 4 in IEEE."); 3099 parameters.push_back(p); 3100 } 2657 3101 #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 \ 2662 3107 and then do parametrics. It will use the default\ 2663 3108 directory given by 'directory'. A name of '$' will use the previous value for the name. This\ … … 2678 3123 Exactly one of name and number must be given for either section and \ 2679 3124 missing 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 \ 2686 3135 stop 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 } 2692 3146 #endif 2693 3147 #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\ 2698 3153 more lightweight or do more if improvements are still being made. As Presolve will return\ 2699 3154 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 } 2706 3165 #endif 2707 3166 #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.\ 2715 3178 However large problems and especially ones with unit elements and unit rhs or costs\ 2716 3179 benefit from perturbation. Normally Clp tries to be intelligent, but you can switch this off.\ 2717 3180 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 ForrestTomlin LU 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 ForrestTomlin LU 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. \ 2732 3202 Doh 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. \ 2740 3213 Doh option does heuristic before preprocessing"); 3214 parameters.push_back(p); 3215 } 2741 3216 #endif 2742 3217 #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\ 2747 3223 not stored and are known to be unit. The main advantage is memory use. Clp may automatically\ 2748 3224 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\ 2764 3248 which fix some variables, equations which can be transformed into bounds etc etc. For the\ 2765 3249 initial solve of any problem this is worth doing unless you know that it will have no effect. \ 2766 3250 on will normally do 5 passes while using 'more' will do 10. If the problem is very large you may need \ 2767 3251 to 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 \ 2783 3271 it also tries to strengthen the model  this can be very useful and is worth trying. \ 2784 3272 Save option saves on file presolved.mps. equal will turn <= cliques into \ … … 2787 3275 valid inequalities into equalities with integer slacks. strategy is as \ 2788 3276 on but uses CbcStrategy."); 3277 parameters.push_back(p); 3278 } 2789 3279 #endif 2790 3280 #ifdef COIN_HAS_CLP 2791 parameters[numberParameters++] = CbcOrClpParam("preT!olerance", "Tolerance to use in presolve", 2792 1.0e20, 1.0e12, CLP_PARAM_DBL_PRESOLVETOLERANCE); 2793 parameters[numberParameters  1].setLonghelp( 2794 "The default is 1.0e8  you may wish to try 1.0e7 if presolve says the problem is \ 3281 { 3282 CbcOrClpParam p("preT!olerance", "Tolerance to use in presolve", 3283 1.0e20, 1.0e12, CLP_PARAM_DBL_PRESOLVETOLERANCE); 3284 p.setLonghelp( 3285 "The default is 1.0e8  you may wish to try 1.0e7 if presolve says the problem is \ 2795 3286 infeasible 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\ 2808 3303 implements the features in the abstract pivot base class. The Dantzig method is implemented\ 2809 3304 to show a simple method but its use is deprecated. Exact devex is the method of choice and there\ … … 2816 3311 Towhidi, M., Desrosiers, J., Soumis, F., The positive edge criterion within COINORâs CLP. and \ 2817 3312 Omer, 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.\ 2822 3322 The default is to use exact devex.\ 2823 3323 The time and iterations may be affected by settings such as presolve, scaling, crash\ 2824 3324 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 \ 2827 3330 no primal infeasibility may exceed this value", 2828 1.0e20, 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.0e20, 1.0e12, CLP_PARAM_DBL_PRIMALTOLERANCE); 3332 p.setLonghelp( 3333 "Normally the default tolerance is fine, but you may want to increase it a\ 2831 3334 bit if a primal run seems to be having a hard time"); 3335 parameters.push_back(p); 3336 } 2832 3337 #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 \ 2834 3340 costs this much to be infeasible", 2835 1.0e20, 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.0e20, 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\ 2838 3344 algorithm where you first get feasible then optimal. So Clp is minimizing this weight times\ 2839 3345 the sum of primal infeasibilities plus the true objective function (in minimization sense).\ … … 2842 3348 OSL had a heuristic to\ 2843 3349 adjust bounds, maybe we need that here."); 2844 parameters[numberParameters++] = CbcOrClpParam("psi", "Twodimension 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", "Twodimension 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 \ 2849 3359 select incoming variables to try and avoid degenerate moves. \ 2850 3360 Variables not in promising set have their infeasibility weight multiplied by psi \ … … 2858 3368 Towhidi, M., Desrosiers, J., Soumis, F., The positive edge criterion within COINORâs CLP. and \ 2859 3369 Omer, 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\ 2876 3389 integer  nonzero integer column variables\n\ 2877 3390 special  in format suitable for OsiRowCutDebugger\n\ … … 2880 3393 \nFor noninteger problems 'integer' and 'special' act like 'normal'. \ 2881 3394 Also 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. \ 2886 3403 '?' matches any character and '*' matches any set of characters. \ 2887 3404 The default is '' i.e. unset so all variables are printed. \ 2888 3405 This 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\ 2894 3415 directory given by 'directory'. A name of '$' will use the previous value for the name. This\ 2895 3416 is initialized to '', i.e. it must be set. This can not read from compressed files. \ 2896 3417 File is in csv format with allowed headings  name, number, priority, direction, up, down, solution. Exactly one of\ 2897 3418 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. \ 2913 3438 but 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 \ 2926 3455 to incumbent solution (Fischetti and Monaci). \ 2927 3456 See Rounding for meaning of on,both,before. \ 2928 3457 Can 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\ 2934 3466 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 \ 2940 3475 when 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\ 2945 3483 \t>=10000000 use as objective weight switch\n\ 2946 3484 \t>=1000000 use as accumulate switch\n\ … … 2951 3489 If accumulate is on then after a major pass, variables which have not moved \ 2952 3490 are 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 \ 2964 3510  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. \ 2973 3522 Doh option does heuristic before preprocessing"); 3523 parameters.push_back(p); 3524 } 2974 3525 #endif 2975 3526 #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 \ 2980 3533  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 \ 2985 3541 best 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 \ 2990 3546 of the objective value at the root node then the search will terminate. See 'allowableGap' for a \ 2991 3547 way 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\ 2997 3557 directory given by 'directory'. A name of '$' will use the previous value for the name. This\ 2998 3558 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 } 3002 3567 #endif 3003 3568 #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 ReduceandSplit 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 ReduceandSplit 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). \ 3021 3593 May be slow \ 3022 3594 See branchAndCut for information on options."); 3023 parameters[numberParameters++] = CbcOrClpParam("reduce2!AndSplitCuts", "Whether to use ReduceandSplit 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 ReduceandSplit 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) \ 3031 3605 This version is by Giacomo Nannicini based on Francois Margot's version \ 3032 3606 Standard setting only uses rows in tableau <=256, long uses all \ 3033 3607 May be slow \ 3034 3608 See branchAndCut for information on options."); 3035 parameters[numberParameters++] = CbcOrClpParam("reduce2!AndSplitCuts", "Whether to use ReduceandSplit 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. \ 3045 3620 See 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 } 3055 3624 #endif 3056 3625 #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\ 3061 3631 directory given by 'directory'. A name of '$' will use the previous value for the name. This\ 3062 3632 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\ 3071 3648 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. \ 3088 3668 on just does 50 nodes \ 3089 3669 200 or 1000 does that many nodes. \ 3090 3670 Doh 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. \ 3099 3682 Doh 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. \ 3107 3693 On means do in solve i.e. after preprocessing, \ 3108 3694 Before means do if doHeuristics used, off otherwise, \ 3109 3695 and 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\ 3116 3704 by restoreModel. It will use the default\ 3117 3705 directory given by 'directory'. A name of '$' will use the previous value for the name. This\ 3118 3706 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\ 3123 3715 directory given by 'directory'. A name of '$' will use the previous value for the name. This\ 3124 3716 is initialized to 'solution.file'. To read the file use fread(int) twice to pick up number of rows \ … … 3126 3718 activities and reduced costs  see bottom of CbcOrClpParam.cpp for code that reads or writes file. \ 3127 3719 If 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\ 3137 3732 accuracy. It can also reduce the number of iterations. It is not applied if the range\ 3138 3733 of elements is small. When unscaled it is possible that there may be small primal and/or\ 3139 3734 infeasibilities."); 3140 parameters[numberParameters  1].setCurrentOption(3); // say auto 3735 p.setCurrentOption(3); // say auto 3736 parameters.push_back(p); 3737 } 3141 3738 #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 \ 3146 3744 (if value >=0)."); 3745 parameters.push_back(p); 3746 } 3147 3747 #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 } 3163 3773 #endif 3164 3774 #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 \ 3169 3780 sequential Lps to get a good approximate solution."); 3781 parameters.push_back(p); 3782 } 3170 3783 #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\ 3182 3799 directory given by 'directory'. A name of '$' will use the previous value for the name. This\ 3183 3800 is initialized to 'stdout'. The amount of output can be varied using printi!ngOptions or printMask."); 3801 parameters.push_back(p); 3802 } 3184 3803 #ifdef COIN_HAS_CLP 3185 3804 #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 \ 3810 this 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\ 3213 3826 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 } 3214 3843 #else 3215 3844 // 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 } 3220 3852 #endif 3221 3853 #endif 3222 3854 #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\ 3232 3871 created by taking a subset of the columns. I introduced the idea as 'Sprint' after\ 3233 3872 an LP code of that name of the 60's which tried the same tactic (not totally successfully).\ 3234 3873 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.\ 3239 3881 If log level >1 then more is printed.\ 3240 3882 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. \ 3251 3899 Use 0 for easy problems, 1 is default, 2 is aggressive. \ 3252 3900 1 uses Gomory cuts using tolerance of 0.01 at root, \ … … 3255 3903 more aggressive. \ 3256 3904 This 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 } 3258 3908 #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 \ 3263 3914 will 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 \ 3269 3923 of unsatisfied variables to do mini up and down branches on. Then the most effective one is chosen. \ 3270 3924 If a variable is branched on many times then the previous average up and down costs may be used  \ 3271 3925 see number before trust."); 3926 parameters.push_back(p); 3927 } 3272 3928 #endif 3273 3929 #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 \ 3278 3935 variables in column. If you increase this the number of rows may decrease but number of \ 3279 3936 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 } 3284 3946 #endif 3285 3947 #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 \ 3290 3953 to use one or two more than number of cpus available. If 100+n then n threads and \ 3291 3954 search is repeatable (maybe be somewhat slower), \ 3292 3955 if 200+n use threads for root cuts, 400+n threads used in subtrees."); 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 \ 3296 3962 activity at continuous solution", 3297 1.0e3, 1.0e20, CBC_PARAM_DBL_TIGHTENFACTOR, 0); 3298 parameters[numberParameters  1].setLonghelp( 3299 "This sleazy trick can help on some problems."); 3963 1.0e3, 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 3300 3969 #endif 3301 3970 #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. \ 3310 3983 (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 pseudocosts. 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 pseudocosts. After this many times for a variable we just \ 3316 3992 trust 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 \ 3323 4002 If bb and bb>0 then this is number of minor passes (if unset or 0 then 10) \n \ 3324 4003 cccc is bit set \n 0  1 Heavy probing \n 1  2 Make variables integer if possible (if obj value)\n \ … … 3328 4007 11  2048 Try probing before creating cliques\n \ 3329 4008 12  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) \ 3341 4023 See 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. \ 3351 4039 Look 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. \ 3357 4048 Look for USERCBC in main driver and modify sample code. \ 3358 4049 It is possible you can get same effect by using example driver4.cpp."); 4050 parameters.push_back(p); 4051 } 3359 4052 #endif 3360 4053 #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. \ 3365 4059 Uses avx2 or avx512 instructions. Uses different storage for matrix  can be \ 3366 4060 of benefit without instruction set on some problems. \ 3367 4061 Being 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. \ 3379 4076 Doh 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 zerohalf 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 zerohalf cuts (either at root or in entire tree) \ 3406 4115 See branchAndCut for information on options. This implementation was written by \ 3407 4116 Alberto 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 \ 3410 4122 whose absolute value is less than this value", 3411 1.0e100, 1.0e5, CLP_PARAM_DBL_ZEROTOLERANCE);3412 parameters[numberParameters  1].setLonghelp(3413 "This applies to reading mps files (and also lp files \4123 1.0e100, 1.0e5, CLP_PARAM_DBL_ZEROTOLERANCE); 4124 p.setLonghelp( 4125 "This applies to reading mps files (and also lp files \ 3414 4126 if KILL_ZERO_READLP defined)"); 3415 parameters[numberParameters  1].setDoubleValue(1.0e20); 3416 assert(numberParameters < CBCMAXPARAMETERS); 4127 p.setDoubleValue(1.0e20); 4128 parameters.push_back(p); 4129 } 3417 4130 } 3418 4131 // 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++) { 4132 int whichParam(const CbcOrClpParameterType &name, 4133 const std::vector< CbcOrClpParam > ¶meters) 4134 { 4135 for (int i = 0; i < (int)parameters.size(); i++) { 3424 4136 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 3429 4140 } 3430 4141 #ifdef COIN_HAS_CLP 
trunk/Clp/src/CbcOrClpParam.hpp
r2385 r2389 542 542 class CbcOrClpParam for details. Pulled from C..Main() for clarity. 543 543 */ 544 void establishParams( int &numberParameters, CbcOrClpParam *const parameters);544 void establishParams(std::vector< CbcOrClpParam > ¶ms); 545 545 // Given a parameter type  returns its number in list 546 int whichParam( CbcOrClpParameterTypename,547 int numberParameters, CbcOrClpParam *constparameters);546 int whichParam(const CbcOrClpParameterType &name, 547 const std::vector< CbcOrClpParam > ¶meters); 548 548 // Dump/restore a solution to file 549 549 void saveSolution(const ClpSimplex *lpSolver, std::string fileName); 
trunk/Clp/src/ClpSolver.cpp
r2385 r2389 270 270 std::string solutionSaveFile = "solution.file"; 271 271 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.0e8); 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.0e8); 304 303 int verbose = 0; 305 304 … … 418 417 int choleskyType = 0; 419 418 int gamma = 0; 420 parameters[whichParam(CLP_PARAM_STR_BARRIERSCALE, numberParameters,parameters)].setCurrentOption(2);419 parameters[whichParam(CLP_PARAM_STR_BARRIERSCALE, parameters)].setCurrentOption(2); 421 420 int scaleBarrier = 2; 422 421 int doKKT = 0; … … 471 470 int numberMatches = 0; 472 471 int firstMatch = 1; 473 for (iParam = 0; iParam < numberParameters; iParam++) {472 for (iParam = 0; iParam < (int)parameters.size(); iParam++) { 474 473 int match = parameters[iParam].matches(field); 475 474 if (match == 1) { … … 484 483 } 485 484 ClpSimplex *thisModel = models + iModel; 486 if (iParam < numberParameters&& !numberQuery) {485 if (iParam < (int)parameters.size() && !numberQuery) { 487 486 // found 488 487 CbcOrClpParam found = parameters[iParam]; … … 503 502 bool evenHidden = false; 504 503 int printLevel = parameters[whichParam(CLP_PARAM_STR_ALLCOMMANDS, 505 numberParameters,parameters)]504 parameters)] 506 505 .currentOptionAsInteger(); 507 506 int convertP[] = { 2, 1, 0 }; … … 533 532 if ((verbose & 2) != 0) 534 533 std::cout << std::endl; 535 for (iParam = 0; iParam < numberParameters; iParam++) {534 for (iParam = 0; iParam < (int)parameters.size(); iParam++) { 536 535 int type = parameters[iParam].type(); 537 536 //printf("%d type %d limits %d %d display %d\n",iParam, … … 587 586 int across = 0; 588 587 std::cout << types[iType] << std::endl; 589 for (iParam = 0; iParam < numberParameters; iParam++) {588 for (iParam = 0; iParam < (int)parameters.size(); iParam++) { 590 589 int type = parameters[iParam].type(); 591 590 if (type >= limits[iType] … … 713 712 } else if (action == 4) { 714 713 // 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())); 716 715 thisModel>setDualRowPivotAlgorithm(p); 717 716 } else if (action == 5) { 718 717 // 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())); 720 719 thisModel>setDualRowPivotAlgorithm(p); 721 720 } … … 745 744 } else if (action == 7) { 746 745 // 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())); 748 747 thisModel>setPrimalColumnPivotAlgorithm(p); 749 748 } else if (action == 8) { 750 749 // 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())); 752 751 thisModel>setPrimalColumnPivotAlgorithm(p); 753 752 } … … 871 870 //openblas_set_num_threads(4); 872 871 // 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(); 874 873 if (psi > 0.0) { 875 874 ClpDualRowPivot *dualp = clpModel>dualRowPivot(); … … 896 895 if (type == CLP_PARAM_ACTION_EITHERSIMPLEX  type == CBC_PARAM_ACTION_BAB) 897 896 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(); 899 898 if (objScale != 1.0) { 900 899 int iColumn; … … 1110 1109 } 1111 1110 #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(); 1113 1112 if (denseCode != 1) 1114 1113 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(); 1116 1115 if (smallCode != 1) 1117 1116 model2>factorization()>setGoSmallThreshold(smallCode); … … 1322 1321 // switch off (user can switch back on) 1323 1322 parameters[whichParam(CLP_PARAM_INT_DUALIZE, 1324 numberParameters,parameters)]1323 parameters)] 1325 1324 .setIntValue(dualize); 1326 1325 } … … 1344 1343 if ((printOptions & 1) != 0) 1345 1344 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(); 1347 1346 model2 = pinfo.presolvedModel(models[iModel], presolveTolerance, 1348 1347 true, preSolve); … … 1557 1556 case CLP_PARAM_ACTION_EXPORT: 1558 1557 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(); 1560 1559 if (objScale != 1.0) { 1561 1560 int iColumn; … … 1631 1630 if ((printOptions & 1) != 0) 1632 1631 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(); 1634 1633 model2 = pinfo.presolvedModel(models[iModel], presolveTolerance, 1635 1634 true, preSolve, false, false); … … 1917 1916 if (preSolve) { 1918 1917 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(); 1920 1919 model2 = pinfo.presolvedModel(models[iModel], presolveTolerance, 1921 1920 false, preSolve); … … 2923 2922 else 2924 2923 std::cout << "Completions of " << field << ":" << std::endl; 2925 for (iParam = 0; iParam < numberParameters; iParam++) {2924 for (iParam = 0; iParam < (int)parameters.size(); iParam++) { 2926 2925 int match = parameters[iParam].matches(field); 2927 2926 if (match && parameters[iParam].displayThis()) {
Note: See TracChangeset
for help on using the changeset viewer.