Changeset 2466
 Timestamp:
 May 2, 2019 1:39:00 AM (18 months ago)
 File:

 1 edited
Legend:
 Unmodified
 Added
 Removed

trunk/Clp/src/CbcOrClpParam.cpp
r2464 r2466 50 50 static bool doPrinting = true; 51 51 static std::string afterEquals = ""; 52 static char printArray[2 00];52 static char printArray[250]; 53 53 #if COIN_INT_MAX == 0 54 54 #undef COIN_INT_MAX … … 1495 1495 parameters.push_back(CbcOrClpParam("", "From stdin", CLP_PARAM_ACTION_STDIN, 3, 0)); 1496 1496 1497 // some help strings that repeat for many options 1498 #define CUTS_LONGHELP \ 1499 "Value 'on' enables the cut generator and CBC will try it in the branch and cut tree (see cutDepth on how to fine tune the behavior). " \ 1500 "Value 'root' lets CBC run the cut generator generate only at the root node. " \ 1501 "Value 'ifmove' lets CBC use the cut generator in the tree if it looks as if it is doing some good and moves the objective value. " \ 1502 "Value 'forceon' turns on the cut generator and forces CBC to use it at every node." 1503 #define HEURISTICS_LONGHELP \ 1504 "Value 'on' means to use the heuristic in each node of the tree, i.e. after preprocessing. " \ 1505 "Value 'before' means use the heuristic only if option doHeuristics is used. " \ 1506 "Value 'both' means to use the heuristic if option doHeuristics is used and during solve." 1507 1497 1508 #if defined(ABC_INHERIT)  ABOCA_LITE 1498 1509 CbcOrClpParam paramAboca("abc", "Whether to visit Aboca", "off", CLP_PARAM_STR_ABCWANTED, 7, 0); … … 1531 1542 p.setDoubleValue(0.0); 1532 1543 p.setLonghelp( 1533 "If the gap between best solution andbest possible solution is less than this \1534 then the search will be terminated. Also see ratioGap.");1544 "If the gap between best known solution and the best possible solution is less than this \ 1545 value, then the search will be terminated. Also see ratioGap."); 1535 1546 parameters.push_back(p); 1536 1547 } … … 1617 1628 Look at output to see which cuts were effective and then do some tuning. You will see that the \ 1618 1629 options for cuts are off, on, root and ifmove, forceon. Off is \ 1619 obvious, on means that this cut generator will be tried in the branch and cut tree (you can fine tune using \ 1620 'depth'). Root means just at the root node while 'ifmove' means that cuts will be used in the tree if they \ 1621 look as if they are doing some good and moving the objective value. Forceon is same as on but forces code to use \ 1622 cut generator at every node. For probing forceonbut just does fixing probing in tree  not strengthening etc. \ 1630 obvious. " CUTS_LONGHELP " For probing, forceonbut just does fixing probing in tree  not strengthening etc. \ 1623 1631 If preprocessing reduced the size of the \ 1624 1632 problem or strengthened many coefficients then it is probably wise to leave it on. Switch off heuristics \ … … 1703 1711 p.append("forceOn"); 1704 1712 p.append("onglobal"); 1705 p.setLonghelp( 1706 "This switches on clique cuts (either at root or in entire tree) \ 1707 See branchAndCut for information on options."); 1713 p.setLonghelp(CUTS_LONGHELP 1714 " Reference: https://github.com/coinor/Cgl/wiki/CglClique"); 1708 1715 1709 1716 parameters.push_back(p); … … 1720 1727 p.append("beforequick"); 1721 1728 p.setLonghelp( 1722 "This switches on a heuristic which does branch and cut on the problem givenby just \1729 "This heuristic does branch and cut on given problem by just \ 1723 1730 using variables which have appeared in one or more solutions. \ 1724 It obviously only tries after two or more solutions. \1725 See Rounding for meaning of on,both,before");1731 It is obviously only tried after two or more solutions have been found. " 1732 HEURISTICS_LONGHELP); 1726 1733 1727 1734 parameters.push_back(p); … … 1734 1741 p.append("before"); 1735 1742 p.setLonghelp( 1736 "This switches on a heuristic whichdoes branch and cut on the problem given by \1743 "This heuristic does branch and cut on the problem given by \ 1737 1744 fixing variables which have same value in two or more solutions. \ 1738 It obviously only tries after two or more solutions. \1739 See Rounding for meaning of on,both,before");1745 It obviously only tries after two or more solutions. " 1746 HEURISTICS_LONGHELP); 1740 1747 parameters.push_back(p); 1741 1748 } … … 1749 1756 p.append("conflict"); 1750 1757 p.setLonghelp( 1751 "This adds the objective as a constraint with best solution as RHS"); 1752 parameters.push_back(p); 1753 } 1754 { 1755 CbcOrClpParam p("cost!Strategy", "How to use costs as priorities", 1758 "For some problems, cut generators and general branching work better if the problem would be infeasible if the cost is too high. " 1759 "If this option is enabled, the objective function is added as a constraint which right hand side is set to the current cutoff value (objective value of best known solution)"); 1760 parameters.push_back(p); 1761 } 1762 { 1763 CbcOrClpParam p("cost!Strategy", "How to use costs for branching priorities", 1756 1764 "off", CBC_PARAM_STR_COSTSTRATEGY); 1757 1765 … … 1765 1773 p.append("general!Force?"); 1766 1774 p.setLonghelp( 1767 "This orders the variables in order of their absolute costs  with largest cost ones being branched on \ 1768 first. This primitive strategy can be surprsingly effective. The column order\ 1769 option is obviously not on costs but easy to code here."); 1775 "Value 'priorities' assigns highest priority to variables with largest absolute cost. This primitive strategy can be surprisingly effective. " 1776 "Value 'columnorder' assigns the priorities 1, 2, 3, ... with respect to the column ordering. " 1777 "Value '01first' ('01last') assignes two sets of priorities such that binary variables get high (low) priority. " 1778 "Value 'length' assigns high priority to variables that occur in many equations. "); 1770 1779 1771 1780 parameters.push_back(p); … … 1821 1830 #endif 1822 1831 p.setLonghelp( 1823 "If crash is set onand there is an all slack basis then Clp will flip or put structural\1824 variables into basis with the aim of getting dual feasible. On the whole dual seems to be\1825 better without it and there are alternative types of 'crash' for primal e.g. 'idiot' or 'sprint'. \1826 I have also added a variant due to Solow and Halim which is as on but just flip.");1827 1828 parameters.push_back(p); 1829 } 1830 { 1831 CbcOrClpParam p("cross!over", "Whether to get a basic solution after barrier",1832 "If crash is set to 'on' and there is an all slack basis then Clp will flip or put structural\ 1833 variables into the basis with the aim of getting dual feasible. On average, dual simplex seems to perform\ 1834 better without it and there are alternative types of 'crash' for primal simplex, e.g. 'idiot' or 'sprint'. \ 1835 A variant due to Solow and Halim which is as 'on' but just flips is also available."); 1836 1837 parameters.push_back(p); 1838 } 1839 { 1840 CbcOrClpParam p("cross!over", "Whether to get a basic solution with the simplex algorithm after the barrier algorithm finished", 1832 1841 "on", CLP_PARAM_STR_CROSSOVER); 1833 1842 p.append("off"); … … 1835 1844 p.append("presolve"); 1836 1845 p.setLonghelp( 1837 "Interior point algorithms do not obtain a basic solution (and \ 1838 the feasibility criterion is a bit suspect (JJF)). This option will crossover \ 1839 to a basic solution suitable for ranging or branch and cut. With the current state \ 1846 "Interior point algorithms do not obtain a basic solution.\ 1847 This option will crossover to a basic solution suitable for ranging or branch and cut. With the current state \ 1840 1848 of quadratic it may be a good idea to switch off crossover for quadratic (and maybe \ 1841 presolve as well)  the option maybedoes this.");1849 presolve as well)  the option 'maybe' does this."); 1842 1850 parameters.push_back(p); 1843 1851 } … … 1857 1865 1, 999999, CBC_PARAM_INT_CUTDEPTH); 1858 1866 p.setLonghelp( 1859 "Cut generators may be  off, on only at root, on if they look possible \ 1860 and on. If they are done every node then that is that, but it may be worth doing them \ 1861 every so often. The original method was every so many nodes but it is more logical \ 1862 to do it whenever depth in tree is a multiple of K. This option does that and defaults \ 1863 to 1 (off > code decides)."); 1867 "Cut generators may be off, on, on only at the root node, or on if they look useful. \ 1868 Setting this option to a positive value K let CBC call a cutgenerator on a node whenever the depth in the tree is a multiple of K. \ 1869 The default of 1 lets CBC decide."); 1864 1870 p.setIntValue(1); 1865 1871 parameters.push_back(p); … … 1877 1883 } 1878 1884 { 1879 CbcOrClpParam p("cuto!ff", " All solutions must be better than this",1885 CbcOrClpParam p("cuto!ff", "Bound on the objective value for all solutions", 1880 1886 1.0e100, 1.0e100, CBC_PARAM_DBL_CUTOFF); 1881 1887 p.setDoubleValue(1.0e50); 1882 1888 p.setLonghelp( 1883 "All solutions must be better than this value (in a minimization sense). \1884 This is also set by code whenever it obtains a solution and is set tovalue of \1885 objective for solution minuscutoff increment.");1886 parameters.push_back(p); 1887 } 1888 { 1889 CbcOrClpParam p("cuts!OnOff", "Switches all cut s on or off",1889 "All solutions must have a better objective value (in a minimization sense) than the value of this option. \ 1890 CBC also updates this value whenever it obtains a solution to the value of \ 1891 the objective function of the solution minus the cutoff increment."); 1892 parameters.push_back(p); 1893 } 1894 { 1895 CbcOrClpParam p("cuts!OnOff", "Switches all cut generators on or off", 1890 1896 "off", CBC_PARAM_STR_CUTSSTRATEGY); 1891 1897 p.append("on"); … … 1894 1900 p.append("forceOn"); 1895 1901 p.setLonghelp( 1896 "This can be used to switch on or off all cut s (apart from Reduce and Split). Then you can do \1897 individual ones off or on \ 1898 See branchAndCut for information on options.");1902 "This can be used to switch on or off all cut generators (apart from Reduce and Split). " 1903 "Then one can turn individual ones off or on. " 1904 CUTS_LONGHELP); 1899 1905 parameters.push_back(p); 1900 1906 } … … 1976 1982 p.append("before"); 1977 1983 p.append("often"); 1978 p.setLonghelp( 1979 "This switches on Distance induced neighborhood Search. \ 1980 See Rounding for meaning of on,both,before"); 1984 p.setLonghelp(HEURISTICS_LONGHELP); 1981 1985 parameters.push_back(p); 1982 1986 } … … 2075 2079 p.setLonghelp( 2076 2080 "This switches on a random diving heuristic at various times. \ 2077 C  Coefficient, F  Fractional, G  Guided, L  LineSearch, P  PseudoCost, V  VectorLength. \ 2078 You may prefer to use individual on/off \ 2079 See Rounding for meaning of on,both,before"); 2080 parameters.push_back(p); 2081 } 2082 { 2083 CbcOrClpParam p("DivingC!oefficient", "Whether to try DiveCoefficient",2081 One may prefer to individually turn diving heuristics on or off. " 2082 HEURISTICS_LONGHELP); 2083 // C  Coefficient, F  Fractional, G  Guided, L  LineSearch, P  PseudoCost, V  VectorLength. 2084 parameters.push_back(p); 2085 } 2086 { 2087 CbcOrClpParam p("DivingC!oefficient", "Whether to try Coefficient diving heuristic", 2084 2088 "off", CBC_PARAM_STR_DIVINGC); 2085 2089 p.append("on"); 2086 2090 p.append("both"); 2087 2091 p.append("before"); 2088 parameters.push_back(p); 2089 } 2090 { 2091 CbcOrClpParam p("DivingF!ractional", "Whether to try DiveFractional", 2092 p.setLonghelp(HEURISTICS_LONGHELP); 2093 parameters.push_back(p); 2094 } 2095 { 2096 CbcOrClpParam p("DivingF!ractional", "Whether to try Fractional diving heuristic", 2092 2097 "off", CBC_PARAM_STR_DIVINGF); 2093 2098 p.append("on"); 2094 2099 p.append("both"); 2095 2100 p.append("before"); 2096 parameters.push_back(p); 2097 } 2098 { 2099 CbcOrClpParam p("DivingG!uided", "Whether to try DiveGuided", 2101 p.setLonghelp(HEURISTICS_LONGHELP); 2102 parameters.push_back(p); 2103 } 2104 { 2105 CbcOrClpParam p("DivingG!uided", "Whether to try Guided diving heuristic", 2100 2106 "off", CBC_PARAM_STR_DIVINGG); 2101 2107 p.append("on"); 2102 2108 p.append("both"); 2103 2109 p.append("before"); 2104 parameters.push_back(p); 2105 } 2106 { 2107 CbcOrClpParam p("DivingL!ineSearch", "Whether to try DiveLineSearch", 2110 p.setLonghelp(HEURISTICS_LONGHELP); 2111 parameters.push_back(p); 2112 } 2113 { 2114 CbcOrClpParam p("DivingL!ineSearch", "Whether to try Linesearch diving heuristic", 2108 2115 "off", CBC_PARAM_STR_DIVINGL); 2109 2116 p.append("on"); 2110 2117 p.append("both"); 2111 2118 p.append("before"); 2112 parameters.push_back(p); 2113 } 2114 { 2115 CbcOrClpParam p("DivingP!seudoCost", "Whether to try DivePseudoCost", 2119 p.setLonghelp(HEURISTICS_LONGHELP); 2120 parameters.push_back(p); 2121 } 2122 { 2123 CbcOrClpParam p("DivingP!seudoCost", "Whether to try Pseudocost diving heuristic", 2116 2124 "off", CBC_PARAM_STR_DIVINGP); 2117 2125 p.append("on"); 2118 2126 p.append("both"); 2119 2127 p.append("before"); 2120 parameters.push_back(p); 2121 } 2122 { 2123 CbcOrClpParam p("DivingV!ectorLength", "Whether to try DiveVectorLength", 2128 p.setLonghelp(HEURISTICS_LONGHELP); 2129 parameters.push_back(p); 2130 } 2131 { 2132 CbcOrClpParam p("DivingV!ectorLength", "Whether to try Vectorlength diving heuristic", 2124 2133 "off", CBC_PARAM_STR_DIVINGV); 2125 2134 p.append("on"); 2126 2135 p.append("both"); 2127 2136 p.append("before"); 2137 p.setLonghelp(HEURISTICS_LONGHELP); 2128 2138 parameters.push_back(p); 2129 2139 } … … 2173 2183 p.append("PEdantzig"); 2174 2184 p.setLonghelp( 2175 "Clp can use any pivot selection algorithm which the user codes as long as it\ 2176 implements the features in the abstract pivot base class. The Dantzig method is implemented\ 2177 to show a simple method but its use is deprecated. Steepest is the method of choice and there\ 2185 "The Dantzig method is simple but its use is deprecated. Steepest is the method of choice and there\ 2178 2186 are two variants which keep all weights updated but only scan a subset each iteration.\ 2179 2187 Partial switches this on while automatic decides at each iteration based on information\ 2180 about the factorization. \n\2181 ** NEWS  the Positive Edge criterion has been added. \2182 This selects incoming variables to try and avoid degenerate moves. See definition ofpsi.");2188 about the factorization.\ 2189 The PE variants add the Positive Edge criterion. \ 2190 This selects incoming variables to try to avoid degenerate moves. See also option psi."); 2183 2191 parameters.push_back(p); 2184 2192 } … … 2198 2206 1.0e20, 1.0e12, CLP_PARAM_DBL_DUALTOLERANCE); 2199 2207 p.setLonghelp( 2200 "Normally the default tolerance is fine, but youmay want to increase it a\2201 bit if a dual runseems to be having a hard time. One method which can be faster is \2202 to use a large tolerance e.g. 1.0e4 and dual and then clean up problem using primal andthe \2208 "Normally the default tolerance is fine, but one may want to increase it a\ 2209 bit if the dual simplex algorithm seems to be having a hard time. One method which can be faster is \ 2210 to use a large tolerance e.g. 1.0e4 and the dual simplex algorithm and then to clean up the problem using the primal simplex algorithm with the \ 2203 2211 correct tolerance (remembering to switch off presolve for this final short clean up phase)."); 2204 2212 parameters.push_back(p); … … 2206 2214 #ifdef COIN_HAS_CBC 2207 2215 { 2208 CbcOrClpParam p("dw!Heuristic", "Whether to try D Wheuristic",2216 CbcOrClpParam p("dw!Heuristic", "Whether to try Dantzig Wolfe heuristic", 2209 2217 "off", CBC_PARAM_STR_DW); 2210 2218 p.append("on"); … … 2212 2220 p.append("before"); 2213 2221 p.setLonghelp( 2214 "See Rounding for meaning of on,both,before"); 2222 "This heuristic is very very compute intensive. It tries to find a Dantzig Wolfe structure and use that." 2223 HEURISTICS_LONGHELP); 2215 2224 parameters.push_back(p); 2216 2225 } … … 2340 2349 p.setIntValue(0); 2341 2350 p.setLonghelp( 2342 "This switches on creation of extra integer variables \ 2343 to gather all variables with same cost."); 2351 "Switches on a trivial reformulation that introduces extra integer variables to group together variables with same cost."); 2344 2352 parameters.push_back(p); 2345 2353 } … … 2372 2380 #ifdef COIN_HAS_CBC 2373 2381 { 2374 CbcOrClpParam p("feas!ibilityPump", "Whether to try Feasibility Pump",2382 CbcOrClpParam p("feas!ibilityPump", "Whether to try the Feasibility Pump heuristic", 2375 2383 "off", CBC_PARAM_STR_FPUMP); 2376 2384 … … 2379 2387 p.append("before"); 2380 2388 p.setLonghelp( 2381 "This switches on feasibility pump heuristic at root. This is due to Fischetti, Lodi and Glover\2382 and uses a sequence of L ps to try and get an integer feasible solution. \2383 Some fine tuning is available by passFeasibilityPump and also pumpTune. \2384 See Rounding for meaning of on,both,before");2389 "This heuristic is due to Fischetti, Glover, and Lodi \ 2390 and uses a sequence of LPs to try and get an integer feasible solution. \ 2391 Some fine tuning is available by options passFeasibilityPump and pumpTune. " 2392 HEURISTICS_LONGHELP); 2385 2393 parameters.push_back(p); 2386 2394 } … … 2403 2411 p.append("onglobal"); 2404 2412 p.setFakeKeyWord(3); 2405 p.setLonghelp( 2406 "This switches on flow cover cuts (either at root or in entire tree) \ 2407 See branchAndCut for information on options. \ 2408 Can also enter testing values by plusnn (==ifmove)"); 2413 p.setLonghelp(CUTS_LONGHELP 2414 " Reference: https://github.com/coinor/Cgl/wiki/CglFlowCover"); // Can also enter testing values by plusnn (==ifmove) 2409 2415 parameters.push_back(p); 2410 2416 } … … 2458 2464 p.append("forceLongOn"); 2459 2465 p.append("longendonly"); 2460 p.setLonghelp( 2461 "This switches on an alternative Gomory cut generator \ 2462 (either at root or in entire tree) \ 2463 This version is by Giacomo Nannicini and may be more robust \ 2464 See branchAndCut for information on options."); 2466 p.setLonghelp(CUTS_LONGHELP 2467 " This version is by Giacomo Nannicini and may be more robust than gomoryCuts."); 2465 2468 parameters.push_back(p); 2466 2469 } … … 2482 2485 with other cuts. They will almost always give cuts (although in this executable \ 2483 2486 they are limited as to number of variables in cut). However the cuts may be dense \ 2484 so it is worth experimenting (Long allows any length). See branchAndCut for \ 2485 information on options."); 2487 so it is worth experimenting (Long allows any length). " 2488 CUTS_LONGHELP 2489 " Reference: https://github.com/coinor/Cgl/wiki/CglGomory"); 2486 2490 parameters.push_back(p); 2487 2491 } … … 2495 2499 //p.append("root"); 2496 2500 p.setLonghelp( 2497 "Switches on a greedy heuristic which will try and obtain a solution. \ 2498 It may just fix a percentage of variables and then try a small branch and cut run. \ 2499 See Rounding for meaning of on,both,before"); 2501 "This heuristic tries to obtain a feasible solution by just fixing a percentage of variables and then try a small branch and cut run. " 2502 HEURISTICS_LONGHELP); 2500 2503 parameters.push_back(p); 2501 2504 } … … 2521 2524 #ifdef COIN_HAS_CBC 2522 2525 { 2523 CbcOrClpParam p("heur!isticsOnOff", "Switches most heuristics on or off",2526 CbcOrClpParam p("heur!isticsOnOff", "Switches most primal heuristics on or off", 2524 2527 "off", CBC_PARAM_STR_HEURISTICSTRATEGY); 2525 2528 p.append("on"); 2526 2529 p.setLonghelp( 2527 "This can be used to switch on or off all heuristics. Then you can do\2528 individual ones off or on. CbcTreeLocal is not included as it dramatically\2529 alters search.");2530 "This option can be used to switch on or off all heuristics that search for feasible solutions,\ 2531 except for the local tree search, as it dramatically alters the search.\ 2532 Then individual heuristics can be turned off or on."); 2530 2533 parameters.push_back(p); 2531 2534 } … … 2566 2569 "This is a type of 'crash' which works well on some homogeneous problems.\ 2567 2570 It works best on problems with unit elements and rhs but will do something to any \ 2568 model. It should only be used before primal. It can be set to 1 when the code \2569 decides for itself whether to use it, 0 to switch off or n > 0 to do n passes.");2571 model. It should only be used before the primal simplex algorithm. It can be set to 1 when the code \ 2572 decides for itself whether to use it, 0 to switch off, or n > 0 to do n passes."); 2570 2573 parameters.push_back(p); 2571 2574 } … … 2589 2592 2590 2593 p.setLonghelp( 2591 "Whenever a solution is found the bound on solutions is set to solution (in a minimization\2592 sense) plus this. If it is not set then the code will try and work one oute.g. if \2594 "Whenever a solution is found the bound on the objective value for new solutions is set to the\ 2595 objective function of the found solution (in a minimization sense) plus this. If it is not set then CBC will try and work one out, e.g. if \ 2593 2596 all objective coefficients are multiples of 0.01 and only integer variables have entries in \ 2594 objective then this can be set to 0.01. Be careful if you set this negative!");2597 the objective function, then the increment can be set to 0.01. Be careful if setting this to a negative value!"); 2595 2598 2596 2599 parameters.push_back(p); … … 2614 2617 } 2615 2618 { 2616 CbcOrClpParam p("integerT!olerance", "For a n optimalsolution \2617 no integer variable may be this away from an integer value",2619 CbcOrClpParam p("integerT!olerance", "For a feasible solution \ 2620 no integer variable may be more than this away from an integer value", 2618 2621 1.0e20, 0.5, CBC_PARAM_DBL_INTEGERTOLERANCE); 2619 2622 p.setLonghelp( 2620 "Beware of setting this smaller than the primal tolerance.");2623 "Beware of setting this smaller than the primal feasibility tolerance."); 2621 2624 parameters.push_back(p); 2622 2625 } … … 2650 2653 p.append("onglobal"); 2651 2654 p.append("forceandglobal"); 2652 p.setLonghelp( 2653 "This switches on knapsack cuts (either at root or in entire tree) \ 2654 See branchAndCut for information on options."); 2655 p.setLonghelp(CUTS_LONGHELP 2656 " Reference: https://github.com/coinor/Cgl/wiki/CglKnapsackCover"); 2655 2657 parameters.push_back(p); 2656 2658 } … … 2715 2717 p.append("forceOn"); 2716 2718 p.setLonghelp( 2717 " Lift and project cuts. \2718 May be slow \ 2719 See branchAndCut for information on options.");2720 parameters.push_back(p); 2721 } 2722 { 2723 CbcOrClpParam p("local!TreeSearch", "Whether to use local tree search",2719 "These cuts may be expensive to compute. " 2720 CUTS_LONGHELP 2721 " Reference: https://github.com/coinor/Cgl/wiki/CglLandP"); 2722 parameters.push_back(p); 2723 } 2724 { 2725 CbcOrClpParam p("local!TreeSearch", "Whether to use local tree search when a solution is found", 2724 2726 "off", CBC_PARAM_STR_LOCALTREE); 2725 2727 p.append("on"); 2726 2728 p.setLonghelp( 2727 "This switches on a local search algorithm when a solution is found. This is from \ 2728 Fischetti and Lodi and is not really a heuristic although it can be used as one. \ 2729 When used from Coin solve it has limited functionality. It is not switched on when \ 2730 heuristics are switched on."); 2729 "The heuristic is from Fischetti and Lodi and is not really a heuristic although it can be used as one \ 2730 (with limited functionality). It is not switched on when heuristics are switched on."); 2731 2731 parameters.push_back(p); 2732 2732 } … … 2761 2761 1, 999999, CLP_PARAM_INT_MAXFACTOR); 2762 2762 p.setLonghelp( 2763 "If this is at its initial value of 200 then in this executable clp will guess at a\ 2764 value to use. Otherwise the user can set a value. The code may decide to refactorize\ 2765 earlier for accuracy."); 2763 "If this is left at its default value of 200 then CLP will guess a\ 2764 value to use. CLP may decide to refactorize earlier for accuracy."); 2766 2765 parameters.push_back(p); 2767 2766 } … … 2794 2793 } 2795 2794 { 2796 CbcOrClpParam p("maxSo!lutions", "Maximum number of solutions to get",2795 CbcOrClpParam p("maxSo!lutions", "Maximum number of feasible solutions to get", 2797 2796 1, 2147483647, CBC_PARAM_INT_MAXSOLS); 2798 2797 p.setLonghelp( … … 2838 2837 p.append("forceOn"); 2839 2838 p.append("onglobal"); 2840 p.setLonghelp( 2841 "This switches on mixed integer rounding cuts (either at root or in entire tree) \ 2842 See branchAndCut for information on options."); 2839 p.setLonghelp(CUTS_LONGHELP 2840 " Reference: https://github.com/coinor/Cgl/wiki/CglMixedIntegerRounding2"); 2843 2841 parameters.push_back(p); 2844 2842 } … … 2935 2933 p.setIntValue(0); 2936 2934 p.setLonghelp( 2937 "Do (in parallel if threads enabled) the root phase this number of times \ 2938 and collect all solutions and cuts generated. The actual format is aabbcc \ 2939 where aa is number of extra passes, if bb is non zero \ 2940 then it is number of threads to use (otherwise uses threads setting) and \ 2941 cc is number of times to do root phase. Yet another one from the Italian idea factory \ 2942 (This time  Andrea Lodi , Matteo Fischetti , Michele Monaci , Domenico Salvagnin , \ 2943 and Andrea Tramontani). \ 2935 "Solve (in parallel, if enabled) the root phase this number of times, \ 2936 each with its own different seed, and collect all solutions and cuts generated. \ 2937 The actual format is aabbcc where aa is the number of extra passes; \ 2938 if bb is non zero, then it is number of threads to use (otherwise uses threads setting); \ 2939 and cc is the number of times to do root phase. \ 2944 2940 The solvers do not interact with each other. However if extra passes are specified \ 2945 then cuts are collected and used in later passes  so there is interaction there."); 2941 then cuts are collected and used in later passes  so there is interaction there. \ 2942 Some parts of this implementation have their origin in idea of \ 2943 Andrea Lodi, Matteo Fischetti, Michele Monaci, Domenico Salvagnin, and Andrea Tramontani."); 2946 2944 parameters.push_back(p); 2947 2945 } … … 2954 2952 p.append("before"); 2955 2953 p.setLonghelp( 2956 " Really silly stuff e.g. fix all integers with costs to zero!. \2957 Doh option does heuristic before preprocessing");2954 "This is naive heuristics which, e.g., fix all integers with costs to zero!. " 2955 HEURISTICS_LONGHELP); 2958 2956 parameters.push_back(p); 2959 2957 } … … 3027 3025 } 3028 3026 { 3029 CbcOrClpParam p("node!Strategy", "What strategy to use to select nodes",3027 CbcOrClpParam p("node!Strategy", "What strategy to use to select the next node from the branch and cut tree", 3030 3028 "hybrid", CBC_PARAM_STR_NODESTRATEGY); 3031 3029 p.append("fewest"); … … 3036 3034 p.append("downdepth"); 3037 3035 p.setLonghelp( 3038 "Normally before a solution the code will choose node with fewest infeasibilities. \ 3039 You can choose depth as the criterion. You can also say if up or down branch must \ 3040 be done first (the up down choice will carry on after solution). \ 3041 Default has now been changed to hybrid which is breadth first on small depth nodes then fewest."); 3036 "Normally before a feasible solution is found, CBC will choose a node with fewest infeasibilities. \ 3037 Alternatively, one may choose treedepth as the criterion. This requires the minimal amount of memory, but may take a long time to find the best solution.\ 3038 Additionally, one may specify whether up or down branches must \ 3039 be selected first (the updown choice will carry on after a first solution has been bound). \ 3040 The default choice 'hybrid' does breadth first on small depth nodes and then switches to 'fewest'."); 3042 3041 parameters.push_back(p); 3043 3042 } … … 3133 3132 #ifdef COIN_HAS_CBC 3134 3133 { 3135 CbcOrClpParam p("passC!uts", "Number of cut passes atroot node",3134 CbcOrClpParam p("passC!uts", "Number of rounds that cut generators are applied in the root node", 3136 3135 9999999, 9999999, CBC_PARAM_INT_CUTPASS); 3137 3136 3138 3137 p.setIntValue(20); 3139 3138 p.setLonghelp( 3140 "The default is 100 passes if less than 500 columns, 100 passes (but \ 3141 stop if drop small if less than 5000 columns, 20 otherwise"); 3142 parameters.push_back(p); 3143 } 3144 { 3145 CbcOrClpParam p("passF!easibilityPump", "How many passes in feasibility pump", 3139 "The default is to do 100 passes if the problem has less than 500 columns, 100 passes (but \ 3140 stop if the drop in the objective function value is small) if the problem has less than 5000 columns, and 20 passes otherwise. \ 3141 A negative value n means that n passes are also applied if the objective does not drop."); 3142 parameters.push_back(p); 3143 } 3144 { 3145 CbcOrClpParam p("passF!easibilityPump", "How many passes to do in the Feasibility Pump heuristic", 3146 3146 0, 10000, CBC_PARAM_INT_FPUMPITS); 3147 p.setLonghelp(3148 "This fine tunes Feasibility Pump by doing more or fewer passes.");3149 3147 p.setIntValue(20); 3150 3148 parameters.push_back(p); … … 3164 3162 #ifdef COIN_HAS_CBC 3165 3163 { 3166 CbcOrClpParam p("passT!reeCuts", "Number of cut passes intree",3164 CbcOrClpParam p("passT!reeCuts", "Number of rounds that cut generators are applied in the tree", 3167 3165 9999999, 9999999, CBC_PARAM_INT_CUTPASSINTREE); 3168 3166 p.setIntValue(1); 3169 p.setLonghelp("The default is one pass");3167 p.setLonghelp("The default is to do one pass. A negative value n means that n passes are also applied if the objective does not drop."); 3170 3168 parameters.push_back(p); 3171 3169 } … … 3178 3176 } 3179 3177 { 3180 CbcOrClpParam p("perturb!ation", "Whether to perturb problem",3178 CbcOrClpParam p("perturb!ation", "Whether to perturb the problem", 3181 3179 "on", CLP_PARAM_STR_PERTURBATION); 3182 3180 p.append("off"); 3183 3181 p.setLonghelp( 3184 "Perturbation helps to stop cycling, but C lpuses other measures for this.\3185 However large problems and especially ones with unit elements and unit rhs or costs\3186 benefit from perturbation. Normally C lp tries to be intelligent, but you can switch this off.\3187 The Clp library has this off by default. This program has it on by default.");3182 "Perturbation helps to stop cycling, but CLP uses other measures for this.\ 3183 However, large problems and especially ones with unit elements and unit right hand sides or costs\ 3184 benefit from perturbation. Normally CLP tries to be intelligent, but one can switch this off."); 3185 // The Clp library has this off by default. This program has it on by default. 3188 3186 parameters.push_back(p); 3189 3187 } … … 3205 3203 p.append("both"); 3206 3204 p.append("before"); 3207 p.setLonghelp( 3208 "stuff needed. \ 3209 Doh option does heuristic before preprocessing"); 3205 p.setLonghelp(HEURISTICS_LONGHELP); 3210 3206 parameters.push_back(p); 3211 3207 } … … 3216 3212 p.append("both"); 3217 3213 p.append("before"); 3218 p.setLonghelp( 3219 "stuff needed. \ 3220 Doh option does heuristic before preprocessing"); 3214 p.setLonghelp(HEURISTICS_LONGHELP); 3221 3215 parameters.push_back(p); 3222 3216 } … … 3253 3247 p.append("file"); 3254 3248 p.setLonghelp("Presolve analyzes the model to find such things as redundant equations, equations\ 3255 which fix some variables, equations which can be transformed into bounds etcetc. For the\3256 initial solve of any problem this is worth doing unless you knowthat it will have no effect. \3257 on will normally do 5 passes while using 'more' will do 10. If the problem is very large you may need\3258 to write the original to fileusing 'file'.");3249 which fix some variables, equations which can be transformed into bounds, etc. For the\ 3250 initial solve of any problem this is worth doing unless one knows that it will have no effect. \ 3251 Option 'on' will normally do 5 passes, while using 'more' will do 10. If the problem is very large one can \ 3252 let CLP write the original problem to file by using 'file'."); 3259 3253 parameters.push_back(p); 3260 3254 } … … 3277 3271 "This tries to reduce size of model in a similar way to presolve and \ 3278 3272 it also tries to strengthen the model  this can be very useful and is worth trying. \ 3279 Save option saves on file presolved.mps. equal will turn <= cliques into\3280 ==. sos will create sos sets if all 01 in sets (well one extra is allowed)\3281 and no overlaps. trysos is same but allows any number extra. equalall will turn all\3282 valid inequalities into equalities with integer slacks. strategy is as\3283 on but uses CbcStrategy."); 3273 Value 'save' saves the presolved problem to a file presolved.mps.\ 3274 Value 'equal' will turn inequalitycliques into equalities.\ 3275 Value 'sos' lets CBC search for rows with upper bound 1 and where all nonzero coefficients are 1 and creates special ordered sets if the sets are not overlapping and all integer variables (except for at most one) are in the sets.\ 3276 Value 'trysos' is same as 'sos', but allows any number of integer variables outside of sets.\ 3277 Value 'equalall' lets CBC turn all valid inequalities into equalities by adding integer slack variables."); // Value 'strategy' is as on but uses CbcStrategy. 3284 3278 parameters.push_back(p); 3285 3279 } … … 3290 3284 1.0e20, 1.0e12, CLP_PARAM_DBL_PRESOLVETOLERANCE); 3291 3285 p.setLonghelp( 3292 " The default is 1.0e8  you may wish to try 1.0e7if presolve says the problem is \3293 infeasible and you have awkward numbers and you are surethe problem is really feasible.");3286 "One may want to increase this tolerance if presolve says the problem is \ 3287 infeasible and one has awkward numbers and is sure that the problem is really feasible."); 3294 3288 parameters.push_back(p); 3295 3289 } … … 3307 3301 p.append("PEdantzig"); 3308 3302 p.setLonghelp( 3309 "Clp can use any pivot selection algorithm which the user codes as long as it\ 3310 implements the features in the abstract pivot base class. The Dantzig method is implemented\ 3311 to show a simple method but its use is deprecated. Exact devex is the method of choice and there\ 3303 "The Dantzig method is simple but its use is deprecated. Exact devex is the method of choice and there\ 3312 3304 are two variants which keep all weights updated but only scan a subset each iteration.\ 3313 Partial switches this on while change initially does dantzig until the factorization\ 3314 becomes denser. This is still a work in progress. \n\ 3315 ** NEWS  the Positive Edge criterion has been added. \ 3316 This selects incoming variables to try and avoid degenerate moves. Code \ 3317 donated by Jeremy Omer. See \ 3318 Towhidi, M., Desrosiers, J., Soumis, F., The positive edge criterion within COINORâs CLP. and \ 3319 Omer, J., Towhidi, M., Soumis, F., The positive edge pricing rule for the dual simplex."); 3305 Partial switches this on while 'change' initially does 'dantzig' until the factorization\ 3306 becomes denser. This is still a work in progress.\ 3307 The PE variants add the Positive Edge criterion.\ 3308 This selects incoming variables to try to avoid degenerate moves. \ 3309 See also Towhidi, M., Desrosiers, J., Soumis, F., The positive edge criterion within COINOR's CLP;\ 3310 Omer, J., Towhidi, M., Soumis, F., The positive edge pricing rule for the dual simplex."); 3320 3311 3321 3312 parameters.push_back(p); … … 3334 3325 #endif 3335 3326 { 3336 CbcOrClpParam p("primalT!olerance", "For a n optimalsolution \3337 no primal infeasibility may exceed this value",3327 CbcOrClpParam p("primalT!olerance", "For a feasible solution \ 3328 no primal infeasibility, i.e., constraint violation, may exceed this value", 3338 3329 1.0e20, 1.0e12, CLP_PARAM_DBL_PRIMALTOLERANCE); 3339 3330 p.setLonghelp( 3340 "Normally the default tolerance is fine, but youmay want to increase it a\3341 bit if a primal run seems to be having a hard time");3331 "Normally the default tolerance is fine, but one may want to increase it a\ 3332 bit if the primal simplex algorithm seems to be having a hard time."); 3342 3333 parameters.push_back(p); 3343 3334 } … … 3442 3433 p.append("forceOnButStrong"); 3443 3434 p.append("strongRoot"); 3444 p.setLonghelp( 3445 "This switches on probing cuts (either at root or in entire tree) \ 3446 See branchAndCut for information on options. \ 3447 but strong options do more probing"); 3435 p.setLonghelp(CUTS_LONGHELP 3436 " Value 'forceOnBut' turns on probing and forces CBC to do probing at every node, but does only probing, not strengthening etc. \ 3437 Value 'strong' forces CBC to strongly do probing at every node, that is, also when CBC would usually turn it off because it hasn't found something. \ 3438 Value 'forceonbutstrong' is like 'forceonstrong', but does only probing (column fixing) and turns off row strengthening, so the matrix will not change inside the branch and bound. \ 3439 Reference: https://github.com/coinor/Cgl/wiki/CglProbing"); 3448 3440 parameters.push_back(p); 3449 3441 } … … 3461 3453 p.setFakeKeyWord(1); 3462 3454 p.setLonghelp( 3463 "This switches on a heuristic which looks for a solution close \ 3464 to incumbent solution (Fischetti and Monaci). \ 3465 See Rounding for meaning of on,both,before. \ 3466 Can also set different maxNode settings by plusnnnn (and are 'on'(on==30))."); 3455 "This heuristic looks for a solution close to the incumbent solution (Fischetti and Monaci, 2012). \ 3456 The idea is to define a subMIP without additional constraints but with a modified objective function intended to attract the search \ 3457 in the proximity of the incumbent. \ 3458 The approach works well for 01 MIPs whose solution landscape is not too irregular (meaning the there is reasonable probability of \ 3459 finding an improved solution by flipping a small number of binary variables), in particular when it is applied to the first heuristic solutions \ 3460 found at the root node. " 3461 HEURISTICS_LONGHELP); // Can also set different maxNode settings by plusnnnn (and are 'on'(on==30)). 3467 3462 parameters.push_back(p); 3468 3463 } … … 3517 3512 3518 3513 p.setLonghelp( 3519 " This sets a random seed for Cbc \3520  0 says use time of day, 1 is as now.");3514 "Allows initialization of the random seed for pseudorandom numbers used in heuristics such as the Feasibility Pump to decide whether to round up or down. " 3515 "The special value of 0 lets Cbc use the time of the day for the initial seed."); 3521 3516 p.setIntValue(1); 3522 3517 parameters.push_back(p); … … 3528 3523 p.append("both"); 3529 3524 p.append("before"); 3530 p.setLonghelp( 3531 "stuff needed. \ 3532 Doh option does heuristic before preprocessing"); 3525 p.setLonghelp(HEURISTICS_LONGHELP); 3533 3526 parameters.push_back(p); 3534 3527 } … … 3540 3533 3541 3534 p.setLonghelp( 3542 "This sets a random seed for Clp \ 3543  0 says use time of day."); 3535 "Initialization of the random seed for pseudorandom numbers used to break ties in degenerate problems. " 3536 "This may yield a different continuous optimum and, in the context of Cbc, different cuts and heuristic solutions. " 3537 "The special value of 0 lets CLP use the time of the day for the initial seed."); 3544 3538 p.setIntValue(1234567); 3545 3539 parameters.push_back(p); … … 3549 3543 { 3550 3544 CbcOrClpParam p("ratio!Gap", "Stop when gap between best possible and \ 3551 best less than this fraction of larger of two",3545 best known is less than this fraction of larger of two", 3552 3546 0.0, 1.0e20, CBC_PARAM_DBL_GAPRATIO); 3553 3547 p.setDoubleValue(0.0); 3554 3548 p.setLonghelp( 3555 "If the gap between best solution andbest possible solution is less than this fraction \3549 "If the gap between the best known solution and the best possible solution is less than this fraction \ 3556 3550 of the objective value at the root node then the search will terminate. See 'allowableGap' for a \ 3557 3551 way of using absolute value rather than fraction."); … … 3600 3594 p.append("forceOn"); 3601 3595 p.setLonghelp( 3602 "Th is switches on reduce and split cuts (either at root or in entire tree). \3603 May be slow \ 3604 See branchAndCut for information on options.");3596 "These cuts may be expensive to generate. " 3597 CUTS_LONGHELP 3598 " Reference: https://github.com/coinor/Cgl/wiki/CglRedSplit"); 3605 3599 parameters.push_back(p); 3606 3600 } … … 3612 3606 p.append("longOn"); 3613 3607 p.append("longRoot"); 3614 p.setLonghelp("This switches on reduce and split cuts (either at root or in entire tree) \3615 This version is by Giacomo Nannicini based on Francois Margot's version \3616 Standard setting only uses rows in tableau <= 256, long uses all\3617 May be slow\3618 See branchAndCut for information on options.");3608 p.setLonghelp("This switches on reduce and split cuts (either at root or in entire tree). \ 3609 This version is by Giacomo Nannicini based on Francois Margot's version. \ 3610 Standard setting only uses rows in tableau <= 256, long uses all. \ 3611 These cuts may be expensive to generate. \ 3612 See option cuts for more information on the possible values."); 3619 3613 parameters.push_back(p); 3620 3614 } … … 3626 3620 p.append("ifmove"); 3627 3621 p.append("forceOn"); 3628 p.setLonghelp( 3629 "Residual capacity cuts. \ 3630 See branchAndCut for information on options."); 3622 p.setLonghelp(CUTS_LONGHELP 3623 " Reference: https://github.com/coinor/Cgl/wiki/CglResidualCapacity"); 3631 3624 3632 3625 parameters.push_back(p); … … 3674 3667 p.append("djbefore"); 3675 3668 p.append("usesolution"); 3676 p.setLonghelp( 3677 "This switches on Relaxation enforced neighborhood Search. \ 3678 on just does 50 nodes \ 3679 200 or 1000 does that many nodes. \ 3680 Doh option does heuristic before preprocessing"); 3669 p.setLonghelp(HEURISTICS_LONGHELP 3670 " Value 'on' just does 50 nodes. 200, 1000, and 10000 does that many nodes."); 3681 3671 parameters.push_back(p); 3682 3672 } … … 3688 3678 p.append("before"); 3689 3679 p.append("often"); 3690 p.setLonghelp( 3691 "This switches on Relaxed induced neighborhood Search. \ 3692 Doh option does heuristic before preprocessing"); 3693 parameters.push_back(p); 3694 } 3695 { 3696 CbcOrClpParam p("round!ingHeuristic", "Whether to use Rounding heuristic", 3680 p.setLonghelp(HEURISTICS_LONGHELP); 3681 parameters.push_back(p); 3682 } 3683 { 3684 CbcOrClpParam p("round!ingHeuristic", "Whether to use simple (but effective) Rounding heuristic", 3697 3685 "off", CBC_PARAM_STR_ROUNDING); 3698 3686 p.append("on"); 3699 3687 p.append("both"); 3700 3688 p.append("before"); 3701 p.setLonghelp( 3702 "This switches on a simple (but effective) rounding heuristic at each node of tree. \ 3703 On means do in solve i.e. after preprocessing, \ 3704 Before means do if doHeuristics used, off otherwise, \ 3705 and both means do if doHeuristics and in solve."); 3689 p.setLonghelp(HEURISTICS_LONGHELP); 3706 3690 parameters.push_back(p); 3707 3691 } … … 3741 3725 "Scaling can help in solving problems which might otherwise fail because of lack of\ 3742 3726 accuracy. It can also reduce the number of iterations. It is not applied if the range\ 3743 of elements is small. When unscaled it is possible that there may be small primal and/or\ 3744 infeasibilities."); 3727 of elements is small. When the solution is evaluated in the unscaled problem, it is possible that small primal and/or\ 3728 dual infeasibilities occur. " 3729 "Option 'equilibrium' uses the largest element for scaling. " 3730 "Option 'geometric' uses the squareroot of the product of largest and smallest element. " 3731 "Option 'auto' let CLP choose a method that gives the best ratio of the largest element to the smallest one."); 3745 3732 p.setCurrentOption(3); // say auto 3746 3733 parameters.push_back(p); … … 3774 3761 #ifdef COIN_HAS_CBC 3775 3762 { 3776 CbcOrClpParam p("slow!cutpasses", "Maximum number of tries for slower cuts",3763 CbcOrClpParam p("slow!cutpasses", "Maximum number of rounds for slower cut generators", 3777 3764 1, COIN_INT_MAX, CBC_PARAM_INT_MAX_SLOW_CUTS); 3778 3765 p.setLonghelp( 3779 "Some cut generators are fairly slow  this limits the number of times they are tried."); 3766 "Some cut generators are fairly slow  this limits the number of times they are tried.\ 3767 The cut generators identified as 'may be slow' at present are Lift and project cuts and both versions of Reduce and Split cuts."); 3780 3768 p.setIntValue(10); 3781 3769 parameters.push_back(p); … … 3878 3866 1, 5000000, CLP_PARAM_INT_SPRINT); 3879 3867 p.setLonghelp( 3880 "For long and thin problems this programmay solve a series of small problems\3881 created by taking a subset of the columns. I introduced the idea as 'Sprint'after\3868 "For long and thin problems this method may solve a series of small problems\ 3869 created by taking a subset of the columns. The idea as 'Sprint' was introduced by J. Forrest after\ 3882 3870 an LP code of that name of the 60's which tried the same tactic (not totally successfully).\ 3883 C plex calls it 'sifting'. 1 is automatic choice, 0 is off, n is number of passes");3871 CPLEX calls it 'sifting'. 1 lets CLP automatically choose the number of passes, 0 is off, n is number of passes"); 3884 3872 parameters.push_back(p); 3885 3873 } … … 3908 3896 "This turns on newer features. \ 3909 3897 Use 0 for easy problems, 1 is default, 2 is aggressive. \ 3910 1 uses Gomory cuts using tolerance of 0.01 at root, \ 3911 does a possible restart after 100 nodes if can fix many \ 3912 and activates a diving and RINS heuristic and makes feasibility pump \ 3913 more aggressive. \ 3914 This does not apply to unit tests (where 'experiment' may have similar effects)."); 3898 1 uses Gomory cuts with a tolerance of 0.01 at the root node, \ 3899 does a possible restart after 100 nodes if many variables could be fixed, \ 3900 activates a diving and RINS heuristic, and makes the feasibility pump \ 3901 more aggressive."); // This does not apply to unit tests (where 'experiment' may have similar effects 3915 3902 p.setIntValue(1); 3916 3903 parameters.push_back(p); … … 3932 3919 p.setLonghelp( 3933 3920 "In order to decide which variable to branch on, the code will choose up to this number \ 3934 of unsatisfied variables to do miniup and down branches on. Then the most effective one is chosen. \3921 of unsatisfied variables to try minimal up and down branches on. Then the most effective one is chosen. \ 3935 3922 If a variable is branched on many times then the previous average up and down costs may be used  \ 3936 see number before trust.");3923 see also option trustPseudoCosts."); 3937 3924 parameters.push_back(p); 3938 3925 } … … 4001 3988 3, 2000000000, CBC_PARAM_INT_NUMBERBEFORE); 4002 3989 p.setLonghelp( 4003 "Using strong branching computes pseudocosts. After this many times for a variable we just \3990 "Using strong branching computes pseudocosts. This parameter determines after how many branches for a variable we just \ 4004 3991 trust the pseudo costs and do not do any more strong branching."); 4005 3992 p.setIntValue(10); … … 4033 4020 p.append("forceandglobal"); 4034 4021 p.append("forceLongOn"); 4035 p.setLonghelp( 4036 "This switches on two phase mixed integer rounding cuts (either at root or in entire tree) \ 4037 See branchAndCut for information on options."); 4022 p.setLonghelp(CUTS_LONGHELP 4023 " Reference: https://github.com/coinor/Cgl/wiki/CglTwomir"); 4038 4024 parameters.push_back(p); 4039 4025 } … … 4086 4072 p.append("before"); 4087 4073 p.append("intree"); 4088 p.setLonghelp( 4089 "This switches on variable neighborhood Search. \ 4090 Doh option does heuristic before preprocessing"); 4074 p.setLonghelp(HEURISTICS_LONGHELP); 4091 4075 parameters.push_back(p); 4092 4076 } … … 4110 4094 #ifdef COIN_HAS_CBC 4111 4095 { 4112 CbcOrClpParam p("vub!heuristic", "Type of vubheuristic",4096 CbcOrClpParam p("vub!heuristic", "Type of VUB heuristic", 4113 4097 2, 20, CBC_PARAM_INT_VUBTRY, 0); 4114 4098 p.setLonghelp( 4115 " If set will try and fix some integer variables");4099 "This heuristic tries and fix some integer variables."); 4116 4100 p.setIntValue(1); 4117 4101 parameters.push_back(p); … … 4125 4109 p.append("forceOn"); 4126 4110 p.append("onglobal"); 4127 p.setLonghelp( 4128 "This switches on zerohalf cuts (either at root or in entire tree) \ 4129 See branchAndCut for information on options. This implementation was written by \ 4130 Alberto Caprara."); 4111 p.setLonghelp(CUTS_LONGHELP 4112 " This implementation was written by Alberto Caprara."); 4131 4113 parameters.push_back(p); 4132 4114 }
Note: See TracChangeset
for help on using the changeset viewer.