Changeset 2466


Ignore:
Timestamp:
May 2, 2019 1:39:00 AM (3 weeks ago)
Author:
stefan
Message:

revise some option help texts

File:
1 edited

Legend:

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

    r2464 r2466  
    5050static bool doPrinting = true;
    5151static std::string afterEquals = "";
    52 static char printArray[200];
     52static char printArray[250];
    5353#if COIN_INT_MAX == 0
    5454#undef COIN_INT_MAX
     
    14951495  parameters.push_back(CbcOrClpParam("-", "From stdin", CLP_PARAM_ACTION_STDIN, 3, 0));
    14961496
     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
    14971508#if defined(ABC_INHERIT) || ABOCA_LITE
    14981509  CbcOrClpParam paramAboca("abc", "Whether to visit Aboca", "off", CLP_PARAM_STR_ABCWANTED, 7, 0);
     
    15311542    p.setDoubleValue(0.0);
    15321543    p.setLonghelp(
    1533       "If the gap between best solution and best 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 \
     1545value, then the search will be terminated.  Also see ratioGap.");
    15351546    parameters.push_back(p);
    15361547  }
     
    16171628Look at output to see which cuts were effective and then do some tuning.  You will see that the \
    16181629options 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.  \
     1630obvious. " CUTS_LONGHELP " For probing, forceonbut just does fixing probing in tree - not strengthening etc.  \
    16231631If pre-processing reduced the size of the \
    16241632problem or strengthened many coefficients then it is probably wise to leave it on.  Switch off heuristics \
     
    17031711    p.append("forceOn");
    17041712    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/coin-or/Cgl/wiki/CglClique");
    17081715
    17091716    parameters.push_back(p);
     
    17201727    p.append("beforequick");
    17211728    p.setLonghelp(
    1722       "This switches on a heuristic which does branch and cut on the problem given by just \
     1729      "This heuristic does branch and cut on given problem by just \
    17231730using 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");
     1731It is obviously only tried after two or more solutions have been found. "
     1732      HEURISTICS_LONGHELP);
    17261733
    17271734    parameters.push_back(p);
     
    17341741    p.append("before");
    17351742    p.setLonghelp(
    1736       "This switches on a heuristic which does branch and cut on the problem given by \
     1743      "This heuristic does branch and cut on the problem given by \
    17371744fixing 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");
     1745It obviously only tries after two or more solutions. "
     1746      HEURISTICS_LONGHELP);
    17401747    parameters.push_back(p);
    17411748  }
     
    17491756    p.append("conflict");
    17501757    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",
    17561764      "off", CBC_PARAM_STR_COSTSTRATEGY);
    17571765
     
    17651773    p.append("general!Force?");
    17661774    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. ");
    17701779
    17711780    parameters.push_back(p);
     
    18211830#endif
    18221831    p.setLonghelp(
    1823       "If crash is set on and 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",
    18321841      "on", CLP_PARAM_STR_CROSSOVER);
    18331842    p.append("off");
     
    18351844    p.append("presolve");
    18361845    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 \
    18401848of quadratic it may be a good idea to switch off crossover for quadratic (and maybe \
    1841 presolve as well) - the option maybe does this.");
     1849presolve as well) - the option 'maybe' does this.");
    18421850    parameters.push_back(p);
    18431851  }
     
    18571865      -1, 999999, CBC_PARAM_INT_CUTDEPTH);
    18581866    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.");
    18641870    p.setIntValue(-1);
    18651871    parameters.push_back(p);
     
    18771883  }
    18781884  {
    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",
    18801886      -1.0e100, 1.0e100, CBC_PARAM_DBL_CUTOFF);
    18811887    p.setDoubleValue(1.0e50);
    18821888    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 to value of \
    1885 objective for solution minus cutoff increment.");
    1886     parameters.push_back(p);
    1887   }
    1888   {
    1889     CbcOrClpParam p("cuts!OnOff", "Switches all cuts on or off",
     1889      "All solutions must have a better objective value (in a minimization sense) than the value of this option.  \
     1890CBC also updates this value whenever it obtains a solution to the value of \
     1891the 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",
    18901896      "off", CBC_PARAM_STR_CUTSSTRATEGY);
    18911897    p.append("on");
     
    18941900    p.append("forceOn");
    18951901    p.setLonghelp(
    1896       "This can be used to switch on or off all cuts (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);
    18991905    parameters.push_back(p);
    19001906  }
     
    19761982    p.append("before");
    19771983    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);
    19811985    parameters.push_back(p);
    19821986  }
     
    20752079    p.setLonghelp(
    20762080      "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",
     2081One 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",
    20842088      "off", CBC_PARAM_STR_DIVINGC);
    20852089    p.append("on");
    20862090    p.append("both");
    20872091    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",
    20922097      "off", CBC_PARAM_STR_DIVINGF);
    20932098    p.append("on");
    20942099    p.append("both");
    20952100    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",
    21002106      "off", CBC_PARAM_STR_DIVINGG);
    21012107    p.append("on");
    21022108    p.append("both");
    21032109    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",
    21082115      "off", CBC_PARAM_STR_DIVINGL);
    21092116    p.append("on");
    21102117    p.append("both");
    21112118    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",
    21162124      "off", CBC_PARAM_STR_DIVINGP);
    21172125    p.append("on");
    21182126    p.append("both");
    21192127    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",
    21242133      "off", CBC_PARAM_STR_DIVINGV);
    21252134    p.append("on");
    21262135    p.append("both");
    21272136    p.append("before");
     2137    p.setLonghelp(HEURISTICS_LONGHELP);
    21282138    parameters.push_back(p);
    21292139  }
     
    21732183    p.append("PEdantzig");
    21742184    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\
    21782186 are two variants which keep all weights updated but only scan a subset each iteration.\
    21792187 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 of psi.");
     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.");
    21832191    parameters.push_back(p);
    21842192  }
     
    21982206      1.0e-20, 1.0e12, CLP_PARAM_DBL_DUALTOLERANCE);
    21992207    p.setLonghelp(
    2200       "Normally the default tolerance is fine, but you may want to increase it a\
    2201  bit if a dual run seems to be having a hard time.  One method which can be faster is \
    2202 to use a large tolerance e.g. 1.0e-4 and dual and then clean up problem using primal and the \
     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 \
     2210to use a large tolerance e.g. 1.0e-4 and the dual simplex algorithm and then to clean up the problem using the primal simplex algorithm with the \
    22032211correct tolerance (remembering to switch off presolve for this final short clean up phase).");
    22042212    parameters.push_back(p);
     
    22062214#ifdef COIN_HAS_CBC
    22072215  {
    2208     CbcOrClpParam p("dw!Heuristic", "Whether to try DW heuristic",
     2216    CbcOrClpParam p("dw!Heuristic", "Whether to try Dantzig Wolfe heuristic",
    22092217      "off", CBC_PARAM_STR_DW);
    22102218    p.append("on");
     
    22122220    p.append("before");
    22132221    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);
    22152224    parameters.push_back(p);
    22162225  }
     
    23402349    p.setIntValue(0);
    23412350    p.setLonghelp(
    2342       "This switches on creation of extra integer variables \
    2343 to gather all variables with same cost.");
     2351      "Switches on a trivial re-formulation that introduces extra integer variables to group together variables with same cost.");
    23442352    parameters.push_back(p);
    23452353  }
     
    23722380#ifdef COIN_HAS_CBC
    23732381  {
    2374     CbcOrClpParam p("feas!ibilityPump", "Whether to try Feasibility Pump",
     2382    CbcOrClpParam p("feas!ibilityPump", "Whether to try the Feasibility Pump heuristic",
    23752383      "off", CBC_PARAM_STR_FPUMP);
    23762384
     
    23792387    p.append("before");
    23802388    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 Lps 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 \
     2390and uses a sequence of LPs to try and get an integer feasible solution. \
     2391Some fine tuning is available by options passFeasibilityPump and pumpTune. "
     2392      HEURISTICS_LONGHELP);
    23852393    parameters.push_back(p);
    23862394  }
     
    24032411    p.append("onglobal");
    24042412    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/coin-or/Cgl/wiki/CglFlowCover"); // Can also enter testing values by plusnn (==ifmove)
    24092415    parameters.push_back(p);
    24102416  }
     
    24582464    p.append("forceLongOn");
    24592465    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.");
    24652468    parameters.push_back(p);
    24662469  }
     
    24822485with other cuts.  They will almost always give cuts (although in this executable \
    24832486they 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.");
     2487so it is worth experimenting (Long allows any length). "
     2488    CUTS_LONGHELP
     2489    " Reference: https://github.com/coin-or/Cgl/wiki/CglGomory");
    24862490    parameters.push_back(p);
    24872491  }
     
    24952499    //p.append("root");
    24962500    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);
    25002503    parameters.push_back(p);
    25012504  }
     
    25212524#ifdef COIN_HAS_CBC
    25222525  {
    2523     CbcOrClpParam p("heur!isticsOnOff", "Switches most heuristics on or off",
     2526    CbcOrClpParam p("heur!isticsOnOff", "Switches most primal heuristics on or off",
    25242527      "off", CBC_PARAM_STR_HEURISTICSTRATEGY);
    25252528    p.append("on");
    25262529    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.");
    25302533    parameters.push_back(p);
    25312534  }
     
    25662569      "This is a type of 'crash' which works well on some homogeneous problems.\
    25672570 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.");
    25702573    parameters.push_back(p);
    25712574  }
     
    25892592
    25902593    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 out e.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 \
    25932596all 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!");
     2597the objective function, then the increment can be set to 0.01.  Be careful if setting this to a negative value!");
    25952598
    25962599    parameters.push_back(p);
     
    26142617  }
    26152618  {
    2616     CbcOrClpParam p("integerT!olerance", "For an optimal solution \
    2617 no integer variable may be this away from an integer value",
     2619    CbcOrClpParam p("integerT!olerance", "For a feasible solution \
     2620no integer variable may be more than this away from an integer value",
    26182621      1.0e-20, 0.5, CBC_PARAM_DBL_INTEGERTOLERANCE);
    26192622    p.setLonghelp(
    2620       "Beware of setting this smaller than the primal tolerance.");
     2623      "Beware of setting this smaller than the primal feasibility tolerance.");
    26212624    parameters.push_back(p);
    26222625  }
     
    26502653    p.append("onglobal");
    26512654    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/coin-or/Cgl/wiki/CglKnapsackCover");
    26552657    parameters.push_back(p);
    26562658  }
     
    27152717    p.append("forceOn");
    27162718    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 treesearch",
     2719      "These cuts may be expensive to compute. "
     2720      CUTS_LONGHELP
     2721      " Reference: https://github.com/coin-or/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",
    27242726      "off", CBC_PARAM_STR_LOCALTREE);
    27252727    p.append("on");
    27262728    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.");
    27312731    parameters.push_back(p);
    27322732  }
     
    27612761      1, 999999, CLP_PARAM_INT_MAXFACTOR);
    27622762    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 re-factorize\
    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 re-factorize earlier for accuracy.");
    27662765    parameters.push_back(p);
    27672766  }
     
    27942793  }
    27952794  {
    2796     CbcOrClpParam p("maxSo!lutions", "Maximum number of solutions to get",
     2795    CbcOrClpParam p("maxSo!lutions", "Maximum number of feasible solutions to get",
    27972796      1, 2147483647, CBC_PARAM_INT_MAXSOLS);
    27982797    p.setLonghelp(
     
    28382837    p.append("forceOn");
    28392838    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/coin-or/Cgl/wiki/CglMixedIntegerRounding2");
    28432841    parameters.push_back(p);
    28442842  }
     
    29352933    p.setIntValue(0);
    29362934    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. \
    29442940The 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.");
     2941then cuts are collected and used in later passes - so there is interaction there. \
     2942Some parts of this implementation have their origin in idea of \
     2943Andrea Lodi, Matteo Fischetti, Michele Monaci, Domenico Salvagnin, and Andrea Tramontani.");
    29462944    parameters.push_back(p);
    29472945  }
     
    29542952    p.append("before");
    29552953    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);
    29582956    parameters.push_back(p);
    29592957  }
     
    30273025  }
    30283026  {
    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",
    30303028      "hybrid", CBC_PARAM_STR_NODESTRATEGY);
    30313029    p.append("fewest");
     
    30363034    p.append("downdepth");
    30373035    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 tree-depth 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 \
     3039be selected first (the up-down choice will carry on after a first solution has been bound). \
     3040The default choice 'hybrid' does breadth first on small depth nodes and then switches to 'fewest'.");
    30423041    parameters.push_back(p);
    30433042  }
     
    31333132#ifdef COIN_HAS_CBC
    31343133  {
    3135     CbcOrClpParam p("passC!uts", "Number of cut passes at root node",
     3134    CbcOrClpParam p("passC!uts", "Number of rounds that cut generators are applied in the root node",
    31363135      -9999999, 9999999, CBC_PARAM_INT_CUTPASS);
    31373136
    31383137    p.setIntValue(20);
    31393138    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 \
     3140stop if the drop in the objective function value is small) if the problem has less than 5000 columns, and 20 passes otherwise. \
     3141A 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",
    31463146      0, 10000, CBC_PARAM_INT_FPUMPITS);
    3147     p.setLonghelp(
    3148       "This fine tunes Feasibility Pump by doing more or fewer passes.");
    31493147    p.setIntValue(20);
    31503148    parameters.push_back(p);
     
    31643162#ifdef COIN_HAS_CBC
    31653163  {
    3166     CbcOrClpParam p("passT!reeCuts", "Number of cut passes in tree",
     3164    CbcOrClpParam p("passT!reeCuts", "Number of rounds that cut generators are applied in the tree",
    31673165      -9999999, 9999999, CBC_PARAM_INT_CUTPASSINTREE);
    31683166    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.");
    31703168    parameters.push_back(p);
    31713169  }
     
    31783176  }
    31793177  {
    3180     CbcOrClpParam p("perturb!ation", "Whether to perturb problem",
     3178    CbcOrClpParam p("perturb!ation", "Whether to perturb the problem",
    31813179      "on", CLP_PARAM_STR_PERTURBATION);
    31823180    p.append("off");
    31833181    p.setLonghelp(
    3184       "Perturbation helps to stop cycling, but Clp uses other measures for this.\
    3185   However large problems and especially ones with unit elements and unit rhs or costs\
    3186  benefit from perturbation.  Normally Clp 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.
    31883186    parameters.push_back(p);
    31893187  }
     
    32053203    p.append("both");
    32063204    p.append("before");
    3207     p.setLonghelp(
    3208       "stuff needed. \
    3209 Doh option does heuristic before preprocessing");
     3205    p.setLonghelp(HEURISTICS_LONGHELP);
    32103206    parameters.push_back(p);
    32113207  }
     
    32163212    p.append("both");
    32173213    p.append("before");
    3218     p.setLonghelp(
    3219       "stuff needed. \
    3220 Doh option does heuristic before preprocessing");
     3214    p.setLonghelp(HEURISTICS_LONGHELP);
    32213215    parameters.push_back(p);
    32223216  }
     
    32533247    p.append("file");
    32543248    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 etc etc.  For the\
    3256  initial solve of any problem this is worth doing unless you know that 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 file using '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.  \
     3251Option 'on' will normally do 5 passes, while using 'more' will do 10.  If the problem is very large one can \
     3252let CLP write the original problem to file by using 'file'.");
    32593253    parameters.push_back(p);
    32603254  }
     
    32773271      "This tries to reduce size of model in a similar way to presolve and \
    32783272it 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 0-1 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 inequality-cliques 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.
    32843278    parameters.push_back(p);
    32853279  }
     
    32903284      1.0e-20, 1.0e12, CLP_PARAM_DBL_PRESOLVETOLERANCE);
    32913285    p.setLonghelp(
    3292       "The default is 1.0e-8 - you may wish to try 1.0e-7 if presolve says the problem is \
    3293 infeasible and you have awkward numbers and you are sure the problem is really feasible.");
     3286      "One may want to increase this tolerance if presolve says the problem is \
     3287infeasible and one has awkward numbers and is sure that the problem is really feasible.");
    32943288    parameters.push_back(p);
    32953289  }
     
    33073301    p.append("PEdantzig");
    33083302    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\
    33123304 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 COIN-OR’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 COIN-OR's CLP;\
     3310 Omer, J., Towhidi, M., Soumis, F., The positive edge pricing rule for the dual simplex.");
    33203311
    33213312    parameters.push_back(p);
     
    33343325#endif
    33353326  {
    3336     CbcOrClpParam p("primalT!olerance", "For an optimal solution \
    3337 no primal infeasibility may exceed this value",
     3327    CbcOrClpParam p("primalT!olerance", "For a feasible solution \
     3328no primal infeasibility, i.e., constraint violation, may exceed this value",
    33383329      1.0e-20, 1.0e12, CLP_PARAM_DBL_PRIMALTOLERANCE);
    33393330    p.setLonghelp(
    3340       "Normally the default tolerance is fine, but you may 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.");
    33423333    parameters.push_back(p);
    33433334  }
     
    34423433    p.append("forceOnButStrong");
    34433434    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/coin-or/Cgl/wiki/CglProbing");
    34483440    parameters.push_back(p);
    34493441  }
     
    34613453    p.setFakeKeyWord(1);
    34623454    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). \
     3456The idea is to define a sub-MIP without additional constraints but with a modified objective function intended to attract the search \
     3457in the proximity of the incumbent. \
     3458The approach works well for 0-1 MIPs whose solution landscape is not too irregular (meaning the there is reasonable probability of \
     3459finding an improved solution by flipping a small number of binary variables), in particular when it is applied to the first heuristic solutions \
     3460found at the root node. "
     3461      HEURISTICS_LONGHELP); // Can also set different maxNode settings by plusnnnn (and are 'on'(on==30)).
    34673462    parameters.push_back(p);
    34683463  }
     
    35173512
    35183513    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 pseudo-random 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.");
    35213516    p.setIntValue(-1);
    35223517    parameters.push_back(p);
     
    35283523    p.append("both");
    35293524    p.append("before");
    3530     p.setLonghelp(
    3531       "stuff needed. \
    3532 Doh option does heuristic before preprocessing");
     3525    p.setLonghelp(HEURISTICS_LONGHELP);
    35333526    parameters.push_back(p);
    35343527  }
     
    35403533
    35413534    p.setLonghelp(
    3542       "This sets a random seed for Clp \
    3543 - 0 says use time of day.");
     3535      "Initialization of the random seed for pseudo-random 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.");
    35443538    p.setIntValue(1234567);
    35453539    parameters.push_back(p);
     
    35493543  {
    35503544    CbcOrClpParam p("ratio!Gap", "Stop when gap between best possible and \
    3551 best less than this fraction of larger of two",
     3545best known is less than this fraction of larger of two",
    35523546      0.0, 1.0e20, CBC_PARAM_DBL_GAPRATIO);
    35533547    p.setDoubleValue(0.0);
    35543548    p.setLonghelp(
    3555       "If the gap between best solution and best 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 \
    35563550of the objective value at the root node then the search will terminate.  See 'allowableGap' for a \
    35573551way of using absolute value rather than fraction.");
     
    36003594    p.append("forceOn");
    36013595    p.setLonghelp(
    3602       "This 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/coin-or/Cgl/wiki/CglRedSplit");
    36053599    parameters.push_back(p);
    36063600  }
     
    36123606    p.append("longOn");
    36133607    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). \
     3609This version is by Giacomo Nannicini based on Francois Margot's version. \
     3610Standard setting only uses rows in tableau <= 256, long uses all. \
     3611These cuts may be expensive to generate. \
     3612See option cuts for more information on the possible values.");
    36193613    parameters.push_back(p);
    36203614  }
     
    36263620    p.append("ifmove");
    36273621    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/coin-or/Cgl/wiki/CglResidualCapacity");
    36313624
    36323625    parameters.push_back(p);
     
    36743667    p.append("djbefore");
    36753668    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.");
    36813671    parameters.push_back(p);
    36823672  }
     
    36883678    p.append("before");
    36893679    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",
    36973685      "off", CBC_PARAM_STR_ROUNDING);
    36983686    p.append("on");
    36993687    p.append("both");
    37003688    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);
    37063690    parameters.push_back(p);
    37073691  }
     
    37413725      "Scaling can help in solving problems which might otherwise fail because of lack of\
    37423726 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.");
    37453732    p.setCurrentOption(3); // say auto
    37463733    parameters.push_back(p);
     
    37743761#ifdef COIN_HAS_CBC
    37753762  {
    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",
    37773764      -1, COIN_INT_MAX, CBC_PARAM_INT_MAX_SLOW_CUTS);
    37783765    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.");
    37803768    p.setIntValue(10);
    37813769    parameters.push_back(p);
     
    38783866      -1, 5000000, CLP_PARAM_INT_SPRINT);
    38793867    p.setLonghelp(
    3880       "For long and thin problems this program may 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\
    38823870 an LP code of that name of the 60's which tried the same tactic (not totally successfully).\
    3883   Cplex 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");
    38843872    parameters.push_back(p);
    38853873  }
     
    39083896      "This turns on newer features. \
    39093897Use 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).");
     38981 uses Gomory cuts with a tolerance of 0.01 at the root node, \
     3899does a possible restart after 100 nodes if many variables could be fixed, \
     3900activates a diving and RINS heuristic, and makes the feasibility pump \
     3901more aggressive."); // This does not apply to unit tests (where 'experiment' may have similar effects
    39153902    p.setIntValue(1);
    39163903    parameters.push_back(p);
     
    39323919    p.setLonghelp(
    39333920      "In order to decide which variable to branch on, the code will choose up to this number \
    3934 of unsatisfied variables to do mini up and down branches on.  Then the most effective one is chosen. \
     3921of unsatisfied variables to try minimal up and down branches on.  Then the most effective one is chosen. \
    39353922If a variable is branched on many times then the previous average up and down costs may be used - \
    3936 see number before trust.");
     3923see also option trustPseudoCosts.");
    39373924    parameters.push_back(p);
    39383925  }
     
    40013988      -3, 2000000000, CBC_PARAM_INT_NUMBERBEFORE);
    40023989    p.setLonghelp(
    4003       "Using strong branching computes pseudo-costs.  After this many times for a variable we just \
     3990      "Using strong branching computes pseudo-costs.  This parameter determines after how many branches for a variable we just \
    40043991trust the pseudo costs and do not do any more strong branching.");
    40053992    p.setIntValue(10);
     
    40334020    p.append("forceandglobal");
    40344021    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/coin-or/Cgl/wiki/CglTwomir");
    40384024    parameters.push_back(p);
    40394025  }
     
    40864072    p.append("before");
    40874073    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);
    40914075    parameters.push_back(p);
    40924076  }
     
    41104094#ifdef COIN_HAS_CBC
    41114095  {
    4112     CbcOrClpParam p("vub!heuristic", "Type of vub heuristic",
     4096    CbcOrClpParam p("vub!heuristic", "Type of VUB heuristic",
    41134097      -2, 20, CBC_PARAM_INT_VUBTRY, 0);
    41144098    p.setLonghelp(
    4115       "If set will try and fix some integer variables");
     4099      "This heuristic tries and fix some integer variables.");
    41164100    p.setIntValue(-1);
    41174101    parameters.push_back(p);
     
    41254109    p.append("forceOn");
    41264110    p.append("onglobal");
    4127     p.setLonghelp(
    4128       "This switches on zero-half 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.");
    41314113    parameters.push_back(p);
    41324114  }
Note: See TracChangeset for help on using the changeset viewer.