Changeset 2468 for stable/1.17


Ignore:
Timestamp:
May 3, 2019 12:31:14 AM (6 months ago)
Author:
stefan
Message:

sync with trunk r2467

  • leave out MSVisualStudio/v15 for now: someone may still want to look into this; can wait until 1.18
Location:
stable/1.17
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • stable/1.17

  • stable/1.17/.travis.yml

    r2365 r2468  
    1 \language: cpp
     1"\\language": cpp
    22env:
    3   global:
    4     - secure: "DlFscEcRlvw4CQsk0zyJxsvW0QQ1MBobX+/ucMPkHy6JLCg2n608pdKF5L04BrwOQoTg/4xcyrIAfPPVld7LeVc/2MTmdb/Hn6jnyfEP0LdeEDQi1yuN7tUk/Rkid/CWFng4j+5I+GNQqAvoCqWwNCt8VtMO8DJWI20/ZNVDuaU="
    5    
     3  global:
     4  - secure: dNf+ddgmbhuzrGHsO6eWuEQ9rTZbIQjdBX47TDnGulwWpOS8LyEoZNFz3IAvf9HJBY2L/pM3F6BvSfXpumX+qX2BVZLUETX54lk07i8PnGWgq0O0ylW5sB3xM0bNGPALiH3sBJEHeimEoRIAkbg+bXafLWo4cDFtQ7IT4mg6fQxq+MGNyr5GnSBkTRK7TdXef1dOylF0R2OV/xXVTr0xEkCb4ONB32ljZ1YZrYw0RzeDWX+rp674S1DnqhC3cYuOjK0Yl3h0uDHEI/rdvJmTahii9C5AILA8eB8Lc4jBlQmXlXYHy7Rr10KIwK7qYNFal6WyS4SbyBLZ6t3bNFrXe3ayMnhllVs0RsreMgMaJ78nGuHmpdQ8FJWlOIEWOYEFO6j/WnQwN7d6U4cgmB0mWmQJoO59qGuw1FsRTMssTJNeOd5t8WVi3AyNSV+GE4n+ZE1Bh4KIhmmhWno+w5iHKIHpr0SocxhPB5jQ2mEm1GhG8ZvM+wAollabkXCfeF9brGCh5IbTib10UpAkDkoeLYSpHO4Blshu5Tkpu0OXe1zcTwfUewbrZ1NZIS6LWdau6ISiPLQSnL+BwgZcIMJ/ZqUEmCtaBE79gQ/h730/Ekxkmdfr9KuvqnF+UTqXtRJeru/uZ0n2LTj7xrjpct2eFHZzGJlp2sAfQWfLK7EWg5A=
    65matrix:
    76  include:
    8     - os: linux
    9       addons:
    10         apt:
    11           packages:
    12             - gfortran
    13     - os: osx
    14       osx_image: xcode10
    15       env: OSX=10.13
    16       compiler: clang
    17     - os: osx
    18       osx_image: xcode9.2
    19       env: OSX=10.12
    20       compiler: clang
    21     - os: osx
    22       osx_image: xcode8
    23       env: OSX=10.11
    24       compiler: clang
     7  - os: linux
     8    addons:
     9      apt:
     10        packages:
     11        - gfortran
     12  - os: osx
     13    osx_image: xcode10
     14    env: OSX=10.13
     15    compiler: clang
     16  - os: osx
     17    osx_image: xcode9.2
     18    env: OSX=10.12
     19    compiler: clang
     20  - os: osx
     21    osx_image: xcode8
     22    env: OSX=10.11
     23    compiler: clang
    2524  allow_failures:
    26     - os: osx
    27 
     25  - os: osx
    2826before_script:
    29   - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then  export PLATFORM=osx$OSX-x86_64-clang`clang -dumpversion`; fi
    30   - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew update; brew install bash gcc; brew link --overwrite gcc; gfortran --version; fi
    31   - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then export PLATFORM=linux-x86_64-gcc`gcc -dumpversion`; fi
    32   - git clone https://github.com/coin-or/COIN-OR-OptimizationSuite COIN
    33   - cd COIN
    34   - export PROJECT=`echo $TRAVIS_REPO_SLUG | cut -d "/" -f 2`
    35   - bash ./coin.install.sh fetch --no-prompt --main-proj=$PROJECT > /dev/null
    36 
     27- if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then  export PLATFORM=osx$OSX-x86_64-clang`clang
     28  -dumpversion`; fi
     29- if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew update; brew install bash gcc; brew
     30  link --overwrite gcc; gfortran --version; fi
     31- if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then export PLATFORM=linux-x86_64-gcc`gcc
     32  -dumpversion`; fi
     33- git clone https://github.com/coin-or/coinbrew COIN
     34- cd COIN
     35- export PROJECT=`echo $TRAVIS_REPO_SLUG | cut -d "/" -f 2`
     36- bash ./coinbrew fetch --no-prompt $PROJECT > /dev/null
    3737script:
    38   - bash ./coin.install.sh build --no-prompt --main-proj=$PROJECT --verbosity=2 --test
    39 
     38- bash ./coinbrew build --no-prompt $PROJECT --enable-static --disable-shared --verbosity 2 --test
    4039after_script:
    41   - if [ $TRAVIS_BRANCH = "master" ]; then export VERSION=trunk; else export VERSION=`echo $TRAVIS_BRANCH | cut -d "/" -f 2`; fi
    42   - export TGZ_FILE=$PROJECT-$VERSION-$PLATFORM.tgz
    43   - echo $TGZ_FILE
    44   - tar -czvf $TGZ_FILE build/lib/* build/bin/* build/include/* build/share/* $PROJECT/README $PROJECT/INSTALL $PROJECT/LICENSE $PROJECT/$PROJECT/AUTHORS
    45   - curl -T $TGZ_FILE -utkralphs:$BINTRAY_API -H "X-Bintray-Publish:1" -H "X-Bintray-Override:1" https://api.bintray.com/content/coin-or/download/$PROJECT/$VERSION/$TGZ_FILE
    46 
     40- if [ $TRAVIS_BRANCH = "master" ]; then export VERSION=master; else export VERSION=`echo
     41  $TRAVIS_BRANCH | cut -d "/" -f 2`; fi
     42- export TGZ_FILE=$PROJECT-$VERSION-$PLATFORM.tgz
     43- echo $TGZ_FILE
     44- cp $PROJECT/README.md $PROJECT/LICENSE $PROJECT/$PROJECT/AUTHORS build
     45- cd build
     46- tar -czvf $TGZ_FILE lib/* bin/* include/* share/* README.md LICENSE AUTHORS
     47- curl -T $TGZ_FILE -utkralphs:$BINTRAY_API -H "X-Bintray-Publish:1" -H "X-Bintray-Override:1"
     48  https://api.bintray.com/content/coin-or/download/$PROJECT/$VERSION/$TGZ_FILE
  • stable/1.17/Clp

  • stable/1.17/Clp/src

  • stable/1.17/Clp/src/CbcOrClpParam.cpp

    r2449 r2468  
    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
     
    482482void CbcOrClpParam::printLongHelp() const
    483483{
    484   if (type_ >= 1 && type_ < 400) {
     484  if (type_ >= 1 && type_ < 600) {
    485485    CoinReadPrintit(longHelp_.c_str());
    486486    if (type_ < CLP_PARAM_INT_SOLVERLOGLEVEL) {
     
    626626  case CLP_PARAM_DBL_RHSSCALE:
    627627    value = model->rhsScale();
     628    break;
     629  case CLP_PARAM_DBL_PRESOLVETOLERANCE:
     630    value = model->presolveTolerance();
    628631    break;
    629632  default:
     
    761764#ifdef COIN_HAS_CBC
    762765double
    763 CbcOrClpParam::doubleParameter(OsiSolverInterface *
    764 #ifndef NDEBUG
    765     model
    766 #endif
    767   ) const
     766CbcOrClpParam::doubleParameter(OsiSolverInterface *model) const
    768767{
    769768  double value = 0.0;
    770769  switch (type_) {
    771770  case CLP_PARAM_DBL_DUALTOLERANCE:
    772     assert(model->getDblParam(OsiDualTolerance, value));
     771    model->getDblParam(OsiDualTolerance, value);
    773772    break;
    774773  case CLP_PARAM_DBL_PRIMALTOLERANCE:
    775     assert(model->getDblParam(OsiPrimalTolerance, value));
     774    model->getDblParam(OsiPrimalTolerance, value);
    776775    break;
    777776  default:
     
    14961495  parameters.push_back(CbcOrClpParam("-", "From stdin", CLP_PARAM_ACTION_STDIN, 3, 0));
    14971496
     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
    14981508#if defined(ABC_INHERIT) || ABOCA_LITE
    14991509  CbcOrClpParam paramAboca("abc", "Whether to visit Aboca", "off", CLP_PARAM_STR_ABCWANTED, 7, 0);
     
    15291539    CbcOrClpParam p("allow!ableGap", "Stop when gap between best possible and \
    15301540best less than this",
    1531       0.0, 1.0e20, CBC_PARAM_DBL_ALLOWABLEGAP);
     1541      0.0, COIN_DBL_MAX, CBC_PARAM_DBL_ALLOWABLEGAP);
    15321542    p.setDoubleValue(0.0);
    15331543    p.setLonghelp(
    1534       "If the gap between best solution and best possible solution is less than this \
    1535 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.");
    15361546    parameters.push_back(p);
    15371547  }
     
    15501560  {
    15511561    CbcOrClpParam p("artif!icialCost", "Costs >= this treated as artificials in feasibility pump",
    1552       0.0, 1.0e100, CBC_PARAM_DBL_ARTIFICIALCOST, 1);
     1562      0.0, COIN_DBL_MAX, CBC_PARAM_DBL_ARTIFICIALCOST, 1);
    15531563    p.setDoubleValue(0.0);
    15541564    p.setLonghelp(
     
    16181628Look at output to see which cuts were effective and then do some tuning.  You will see that the \
    16191629options for cuts are off, on, root and ifmove, forceon.  Off is \
    1620 obvious, on means that this cut generator will be tried in the branch and cut tree (you can fine tune using \
    1621 'depth').  Root means just at the root node while 'ifmove' means that cuts will be used in the tree if they \
    1622 look as if they are doing some good and moving the objective value.  Forceon is same as on but forces code to use \
    1623 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.  \
    16241631If pre-processing reduced the size of the \
    16251632problem or strengthened many coefficients then it is probably wise to leave it on.  Switch off heuristics \
     
    17041711    p.append("forceOn");
    17051712    p.append("onglobal");
    1706     p.setLonghelp(
    1707       "This switches on clique cuts (either at root or in entire tree) \
    1708 See branchAndCut for information on options.");
     1713    p.setLonghelp(CUTS_LONGHELP
     1714     " Reference: https://github.com/coin-or/Cgl/wiki/CglClique");
    17091715
    17101716    parameters.push_back(p);
     
    17211727    p.append("beforequick");
    17221728    p.setLonghelp(
    1723       "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 \
    17241730using variables which have appeared in one or more solutions. \
    1725 It obviously only tries after two or more solutions. \
    1726 See Rounding for meaning of on,both,before");
     1731It is obviously only tried after two or more solutions have been found. "
     1732      HEURISTICS_LONGHELP);
    17271733
    17281734    parameters.push_back(p);
     
    17351741    p.append("before");
    17361742    p.setLonghelp(
    1737       "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 \
    17381744fixing variables which have same value in two or more solutions. \
    1739 It obviously only tries after two or more solutions. \
    1740 See Rounding for meaning of on,both,before");
     1745It obviously only tries after two or more solutions. "
     1746      HEURISTICS_LONGHELP);
    17411747    parameters.push_back(p);
    17421748  }
     
    17501756    p.append("conflict");
    17511757    p.setLonghelp(
    1752       "This adds the objective as a constraint with best solution as RHS");
    1753     parameters.push_back(p);
    1754   }
    1755   {
    1756     CbcOrClpParam p("cost!Strategy", "How to use costs as priorities",
     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",
    17571764      "off", CBC_PARAM_STR_COSTSTRATEGY);
    17581765
     
    17661773    p.append("general!Force?");
    17671774    p.setLonghelp(
    1768       "This orders the variables in order of their absolute costs - with largest cost ones being branched on \
    1769 first.  This primitive strategy can be surprsingly effective.  The column order\
    1770  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. ");
    17711779
    17721780    parameters.push_back(p);
     
    18221830#endif
    18231831    p.setLonghelp(
    1824       "If crash is set on and there is an all slack basis then Clp will flip or put structural\
    1825      variables into basis with the aim of getting dual feasible.  On the whole dual seems to be\
    1826      better without it and there are alternative types of 'crash' for primal e.g. 'idiot' or 'sprint'. \
    1827     I have also added a variant due to Solow and Halim which is as on but just flip.");
    1828 
    1829     parameters.push_back(p);
    1830   }
    1831   {
    1832     CbcOrClpParam p("cross!over", "Whether to get a basic solution after barrier",
     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",
    18331841      "on", CLP_PARAM_STR_CROSSOVER);
    18341842    p.append("off");
     
    18361844    p.append("presolve");
    18371845    p.setLonghelp(
    1838       "Interior point algorithms do not obtain a basic solution (and \
    1839 the feasibility criterion is a bit suspect (JJF)).  This option will crossover \
    1840 to a basic solution suitable for ranging or branch and cut.  With the current state \
    1841 of quadratic it may be a good idea to switch off crossover for quadratic (and maybe \
    1842 presolve as well) - the option maybe does this.");
     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 \
     1848of the solver for quadratic programs it may be a good idea to switch off crossover for this case (and maybe \
     1849presolve as well) - the option 'maybe' does this.");
    18431850    parameters.push_back(p);
    18441851  }
     
    18561863  {
    18571864    CbcOrClpParam p("cutD!epth", "Depth in tree at which to do cuts",
    1858       -1, 999999, CBC_PARAM_INT_CUTDEPTH);
    1859     p.setLonghelp(
    1860       "Cut generators may be - off, on only at root, on if they look possible \
    1861 and on.  If they are done every node then that is that, but it may be worth doing them \
    1862 every so often.  The original method was every so many nodes but it is more logical \
    1863 to do it whenever depth in tree is a multiple of K.  This option does that and defaults \
    1864 to -1 (off -> code decides).");
     1865      -1, COIN_INT_MAX, CBC_PARAM_INT_CUTDEPTH);
     1866    p.setLonghelp(
     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.");
    18651870    p.setIntValue(-1);
    18661871    parameters.push_back(p);
     
    18781883  }
    18791884  {
    1880     CbcOrClpParam p("cuto!ff", "All solutions must be better than this",
    1881       -1.0e60, 1.0e60, CBC_PARAM_DBL_CUTOFF);
     1885    CbcOrClpParam p("cuto!ff", "Bound on the objective value for all solutions",
     1886      -COIN_DBL_MAX, COIN_DBL_MAX, CBC_PARAM_DBL_CUTOFF);
    18821887    p.setDoubleValue(1.0e50);
    18831888    p.setLonghelp(
    1884       "All solutions must be better than this value (in a minimization sense).  \
    1885 This is also set by code whenever it obtains a solution and is set to value of \
    1886 objective for solution minus cutoff increment.");
    1887     parameters.push_back(p);
    1888   }
    1889   {
    1890     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",
    18911896      "off", CBC_PARAM_STR_CUTSSTRATEGY);
    18921897    p.append("on");
     
    18951900    p.append("forceOn");
    18961901    p.setLonghelp(
    1897       "This can be used to switch on or off all cuts (apart from Reduce and Split).  Then you can do \
    1898 individual ones off or on \
    1899 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);
    19001905    parameters.push_back(p);
    19011906  }
     
    19531958  {
    19541959    CbcOrClpParam p("dextra3", "Extra double parameter 3",
    1955       -1.0e100, 1.0e100, CBC_PARAM_DBL_DEXTRA3, 0);
     1960      -COIN_DBL_MAX, COIN_DBL_MAX, CBC_PARAM_DBL_DEXTRA3, 0);
    19561961    p.setDoubleValue(0.0);
    19571962    parameters.push_back(p);
     
    19591964  {
    19601965    CbcOrClpParam p("dextra4", "Extra double parameter 4",
    1961       -1.0e100, 1.0e100, CBC_PARAM_DBL_DEXTRA4, 0);
     1966      -COIN_DBL_MAX, COIN_DBL_MAX, CBC_PARAM_DBL_DEXTRA4, 0);
    19621967    p.setDoubleValue(0.0);
    19631968    parameters.push_back(p);
     
    19651970  {
    19661971    CbcOrClpParam p("dextra4", "Extra double parameter 5",
    1967       -1.0e100, 1.0e100, CBC_PARAM_DBL_DEXTRA5, 0);
     1972      -COIN_DBL_MAX, COIN_DBL_MAX, CBC_PARAM_DBL_DEXTRA5, 0);
    19681973    p.setDoubleValue(0.0);
    19691974    parameters.push_back(p);
     
    19771982    p.append("before");
    19781983    p.append("often");
    1979     p.setLonghelp(
    1980       "This switches on Distance induced neighborhood Search. \
    1981 See Rounding for meaning of on,both,before");
     1984    p.setLonghelp(HEURISTICS_LONGHELP);
    19821985    parameters.push_back(p);
    19831986  }
     
    20762079    p.setLonghelp(
    20772080      "This switches on a random diving heuristic at various times. \
    2078 C - Coefficient, F - Fractional, G - Guided, L - LineSearch, P - PseudoCost, V - VectorLength. \
    2079 You may prefer to use individual on/off \
    2080 See Rounding for meaning of on,both,before");
    2081     parameters.push_back(p);
    2082   }
    2083   {
    2084     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",
    20852088      "off", CBC_PARAM_STR_DIVINGC);
    20862089    p.append("on");
    20872090    p.append("both");
    20882091    p.append("before");
    2089     parameters.push_back(p);
    2090   }
    2091   {
    2092     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",
    20932097      "off", CBC_PARAM_STR_DIVINGF);
    20942098    p.append("on");
    20952099    p.append("both");
    20962100    p.append("before");
    2097     parameters.push_back(p);
    2098   }
    2099   {
    2100     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",
    21012106      "off", CBC_PARAM_STR_DIVINGG);
    21022107    p.append("on");
    21032108    p.append("both");
    21042109    p.append("before");
    2105     parameters.push_back(p);
    2106   }
    2107   {
    2108     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",
    21092115      "off", CBC_PARAM_STR_DIVINGL);
    21102116    p.append("on");
    21112117    p.append("both");
    21122118    p.append("before");
    2113     parameters.push_back(p);
    2114   }
    2115   {
    2116     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",
    21172124      "off", CBC_PARAM_STR_DIVINGP);
    21182125    p.append("on");
    21192126    p.append("both");
    21202127    p.append("before");
    2121     parameters.push_back(p);
    2122   }
    2123   {
    2124     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",
    21252133      "off", CBC_PARAM_STR_DIVINGV);
    21262134    p.append("on");
    21272135    p.append("both");
    21282136    p.append("before");
     2137    p.setLonghelp(HEURISTICS_LONGHELP);
    21292138    parameters.push_back(p);
    21302139  }
     
    21742183    p.append("PEdantzig");
    21752184    p.setLonghelp(
    2176       "Clp can use any pivot selection algorithm which the user codes as long as it\
    2177  implements the features in the abstract pivot base class.  The Dantzig method is implemented\
    2178  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\
    21792186 are two variants which keep all weights updated but only scan a subset each iteration.\
    21802187 Partial switches this on while automatic decides at each iteration based on information\
    2181  about the factorization. \n\
    2182 ** NEWS - the Positive Edge criterion has been added. \
    2183 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.");
    21842191    parameters.push_back(p);
    21852192  }
     
    21972204    CbcOrClpParam p("dualT!olerance", "For an optimal solution \
    21982205no dual infeasibility may exceed this value",
    2199       1.0e-20, 1.0e12, CLP_PARAM_DBL_DUALTOLERANCE);
    2200     p.setLonghelp(
    2201       "Normally the default tolerance is fine, but you may want to increase it a\
    2202  bit if a dual run seems to be having a hard time.  One method which can be faster is \
    2203 to use a large tolerance e.g. 1.0e-4 and dual and then clean up problem using primal and the \
     2206      1.0e-20, COIN_DBL_MAX, CLP_PARAM_DBL_DUALTOLERANCE);
     2207    p.setLonghelp(
     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 \
    22042211correct tolerance (remembering to switch off presolve for this final short clean up phase).");
    22052212    parameters.push_back(p);
     
    22072214#ifdef COIN_HAS_CBC
    22082215  {
    2209     CbcOrClpParam p("dw!Heuristic", "Whether to try DW heuristic",
     2216    CbcOrClpParam p("dw!Heuristic", "Whether to try Dantzig Wolfe heuristic",
    22102217      "off", CBC_PARAM_STR_DW);
    22112218    p.append("on");
     
    22132220    p.append("before");
    22142221    p.setLonghelp(
    2215       "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);
    22162224    parameters.push_back(p);
    22172225  }
     
    23412349    p.setIntValue(0);
    23422350    p.setLonghelp(
    2343       "This switches on creation of extra integer variables \
    2344 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.");
    23452352    parameters.push_back(p);
    23462353  }
     
    23732380#ifdef COIN_HAS_CBC
    23742381  {
    2375     CbcOrClpParam p("feas!ibilityPump", "Whether to try Feasibility Pump",
     2382    CbcOrClpParam p("feas!ibilityPump", "Whether to try the Feasibility Pump heuristic",
    23762383      "off", CBC_PARAM_STR_FPUMP);
    23772384
     
    23802387    p.append("before");
    23812388    p.setLonghelp(
    2382       "This switches on feasibility pump heuristic at root. This is due to Fischetti, Lodi and Glover \
    2383 and uses a sequence of Lps to try and get an integer feasible solution. \
    2384 Some fine tuning is available by passFeasibilityPump and also pumpTune. \
    2385 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);
    23862393    parameters.push_back(p);
    23872394  }
     
    23892396    CbcOrClpParam p("fix!OnDj", "Try heuristic based on fixing variables with \
    23902397reduced costs greater than this",
    2391       -1.0e20, 1.0e20, CBC_PARAM_DBL_DJFIX, 1);
     2398      -COIN_DBL_MAX, COIN_DBL_MAX, CBC_PARAM_DBL_DJFIX, 1);
    23922399    p.setLonghelp(
    23932400      "If this is set integer variables with reduced costs greater than this will be fixed \
     
    24042411    p.append("onglobal");
    24052412    p.setFakeKeyWord(3);
    2406     p.setLonghelp(
    2407       "This switches on flow cover cuts (either at root or in entire tree) \
    2408 See branchAndCut for information on options. \
    2409 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)
    24102415    parameters.push_back(p);
    24112416  }
     
    24592464    p.append("forceLongOn");
    24602465    p.append("longendonly");
    2461     p.setLonghelp(
    2462       "This switches on an alternative Gomory cut generator \
    2463 (either at root or in entire tree) \
    2464 This version is by Giacomo Nannicini and may be more robust \
    2465 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.");
    24662468    parameters.push_back(p);
    24672469  }
     
    24832485with other cuts.  They will almost always give cuts (although in this executable \
    24842486they are limited as to number of variables in cut).  However the cuts may be dense \
    2485 so it is worth experimenting (Long allows any length). See branchAndCut for \
    2486 information on options.");
     2487so it is worth experimenting (Long allows any length). "
     2488    CUTS_LONGHELP
     2489    " Reference: https://github.com/coin-or/Cgl/wiki/CglGomory");
    24872490    parameters.push_back(p);
    24882491  }
     
    24962499    //p.append("root");
    24972500    p.setLonghelp(
    2498       "Switches on a greedy heuristic which will try and obtain a solution. \
    2499 It may just fix a percentage of variables and then try a small branch and cut run. \
    2500 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);
    25012503    parameters.push_back(p);
    25022504  }
     
    25222524#ifdef COIN_HAS_CBC
    25232525  {
    2524     CbcOrClpParam p("heur!isticsOnOff", "Switches most heuristics on or off",
     2526    CbcOrClpParam p("heur!isticsOnOff", "Switches most primal heuristics on or off",
    25252527      "off", CBC_PARAM_STR_HEURISTICSTRATEGY);
    25262528    p.append("on");
    25272529    p.setLonghelp(
    2528       "This can be used to switch on or off all heuristics.  Then you can do \
    2529 individual ones off or on.  CbcTreeLocal is not included as it dramatically \
    2530 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.");
    25312533    parameters.push_back(p);
    25322534  }
     
    25432545  {
    25442546    CbcOrClpParam p("hOp!tions", "Heuristic options",
    2545       -9999999, 9999999, CBC_PARAM_INT_HOPTIONS, 1);
     2547      -COIN_INT_MAX, COIN_INT_MAX, CBC_PARAM_INT_HOPTIONS, 1);
    25462548    p.setIntValue(0);
    25472549    p.setLonghelp(
     
    25622564  {
    25632565    CbcOrClpParam p("idiot!Crash", "Whether to try idiot crash",
    2564       -1, 99999999, CLP_PARAM_INT_IDIOT);
     2566      -1, COIN_INT_MAX, CLP_PARAM_INT_IDIOT);
    25652567
    25662568    p.setLonghelp(
    25672569      "This is a type of 'crash' which works well on some homogeneous problems.\
    25682570 It works best on problems with unit elements and rhs but will do something to any \
    2569  model.  It should only be used before primal.  It can be set to -1 when the code \
    2570  decides for itself whether to use it, 0 to switch off or n > 0 to do n passes.");
     2571 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.");
    25712573    parameters.push_back(p);
    25722574  }
     
    25872589    CbcOrClpParam p("inc!rement", "A valid solution must be at least this \
    25882590much better than last integer solution",
    2589       -1.0e20, 1.0e20, CBC_PARAM_DBL_INCREMENT);
    2590 
    2591     p.setLonghelp(
    2592       "Whenever a solution is found the bound on solutions is set to solution (in a minimization\
    2593 sense) plus this.  If it is not set then the code will try and work one out e.g. if \
     2591      -COIN_DBL_MAX, COIN_DBL_MAX, CBC_PARAM_DBL_INCREMENT);
     2592
     2593    p.setLonghelp(
     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 \
    25942596all objective coefficients are multiples of 0.01 and only integer variables have entries in \
    2595 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!");
    25962598
    25972599    parameters.push_back(p);
     
    26002602    CbcOrClpParam p("inf!easibilityWeight", "Each integer infeasibility is expected \
    26012603to cost this much",
    2602       0.0, 1.0e20, CBC_PARAM_DBL_INFEASIBILITYWEIGHT, 1);
     2604      0.0, COIN_DBL_MAX, CBC_PARAM_DBL_INFEASIBILITYWEIGHT, 1);
    26032605    p.setLonghelp(
    26042606      "A primitive way of deciding which node to explore next.  Satisfying each integer infeasibility is \
     
    26152617  }
    26162618  {
    2617     CbcOrClpParam p("integerT!olerance", "For an optimal solution \
    2618 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",
    26192621      1.0e-20, 0.5, CBC_PARAM_DBL_INTEGERTOLERANCE);
    26202622    p.setLonghelp(
    2621       "Beware of setting this smaller than the primal tolerance.");
     2623      "Beware of setting this smaller than the primal feasibility tolerance.");
    26222624    parameters.push_back(p);
    26232625  }
     
    26512653    p.append("onglobal");
    26522654    p.append("forceandglobal");
    2653     p.setLonghelp(
    2654       "This switches on knapsack cuts (either at root or in entire tree) \
    2655 See branchAndCut for information on options.");
     2655    p.setLonghelp(CUTS_LONGHELP
     2656      " Reference: https://github.com/coin-or/Cgl/wiki/CglKnapsackCover");
    26562657    parameters.push_back(p);
    26572658  }
     
    27162717    p.append("forceOn");
    27172718    p.setLonghelp(
    2718       "Lift and project cuts. \
    2719 May be slow \
    2720 See branchAndCut for information on options.");
    2721     parameters.push_back(p);
    2722   }
    2723   {
    2724     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",
    27252726      "off", CBC_PARAM_STR_LOCALTREE);
    27262727    p.append("on");
    27272728    p.setLonghelp(
    2728       "This switches on a local search algorithm when a solution is found.  This is from \
    2729 Fischetti and Lodi and is not really a heuristic although it can be used as one. \
    2730 When used from Coin solve it has limited functionality.  It is not switched on when \
    2731 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.");
    27322731    parameters.push_back(p);
    27332732  }
     
    27362735#ifndef COIN_HAS_CBC
    27372736    CbcOrClpParam p("log!Level", "Level of detail in Solver output",
    2738       -1, 999999, CLP_PARAM_INT_SOLVERLOGLEVEL);
     2737      -1, COIN_INT_MAX, CLP_PARAM_INT_SOLVERLOGLEVEL);
    27392738    parameters.push_back(p);
    27402739#else
     
    27602759    CbcOrClpParam p("maxF!actor", "Maximum number of iterations between \
    27612760refactorizations",
    2762       1, 999999, CLP_PARAM_INT_MAXFACTOR);
    2763     p.setLonghelp(
    2764       "If this is at its initial value of 200 then in this executable clp will guess at a\
    2765  value to use.  Otherwise the user can set a value.  The code may decide to re-factorize\
    2766  earlier for accuracy.");
     2761      1, COIN_INT_MAX, CLP_PARAM_INT_MAXFACTOR);
     2762    p.setLonghelp(
     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.");
    27672765    parameters.push_back(p);
    27682766  }
     
    27702768    CbcOrClpParam p("maxIt!erations", "Maximum number of iterations before \
    27712769stopping",
    2772       0, 2147483647, CLP_PARAM_INT_MAXITERATION);
     2770      0, COIN_INT_MAX, CLP_PARAM_INT_MAXITERATION);
    27732771    p.setLonghelp(
    27742772      "This can be used for testing purposes.  The corresponding library call\n\
     
    27812779  {
    27822780    CbcOrClpParam p("maxN!odes", "Maximum number of nodes to do",
    2783       -1, 2147483647, CBC_PARAM_INT_MAXNODES);
     2781      -1, COIN_INT_MAX, CBC_PARAM_INT_MAXNODES);
    27842782    p.setLonghelp(
    27852783      "This is a repeatable way to limit search.  Normally using time is easier \
     
    27892787  {
    27902788    CbcOrClpParam p("maxSaved!Solutions", "Maximum number of solutions to save",
    2791       0, 2147483647, CBC_PARAM_INT_MAXSAVEDSOLS);
     2789      0, COIN_INT_MAX, CBC_PARAM_INT_MAXSAVEDSOLS);
    27922790    p.setLonghelp(
    27932791      "Number of solutions to save.");
     
    27952793  }
    27962794  {
    2797     CbcOrClpParam p("maxSo!lutions", "Maximum number of solutions to get",
    2798       1, 2147483647, CBC_PARAM_INT_MAXSOLS);
     2795    CbcOrClpParam p("maxSo!lutions", "Maximum number of feasible solutions to get",
     2796      1, COIN_INT_MAX, CBC_PARAM_INT_MAXSOLS);
    27992797    p.setLonghelp(
    28002798      "You may want to stop after (say) two solutions or an hour.  \
     
    28392837    p.append("forceOn");
    28402838    p.append("onglobal");
    2841     p.setLonghelp(
    2842       "This switches on mixed integer rounding cuts (either at root or in entire tree) \
    2843 See branchAndCut for information on options.");
     2839    p.setLonghelp(CUTS_LONGHELP
     2840      " Reference: https://github.com/coin-or/Cgl/wiki/CglMixedIntegerRounding2");
    28442841    parameters.push_back(p);
    28452842  }
     
    28992896a feasible solution. \
    29002897\n\n\
     2898Silly options added.  If filename ends .low then integers not mentioned \
     2899are set low - also .high, .lowcheap, .highcheap, .lowexpensive, .highexpensive \
     2900where .lowexpensive sets costed ones to make expensive others low. Also if \
     2901filename starts empty. then no file is read at all - just actions done. \
     2902\n\n\
    29012903Question and suggestions regarding MIPStart can be directed to\n\
    29022904haroldo.santos@gmail.com. ");
     
    29282930  {
    29292931    CbcOrClpParam p("multiple!RootPasses", "Do multiple root passes to collect cuts and solutions",
    2930       0, 100000000, CBC_PARAM_INT_MULTIPLEROOTS, 0);
     2932      0, COIN_INT_MAX, CBC_PARAM_INT_MULTIPLEROOTS, 0);
    29312933    p.setIntValue(0);
    29322934    p.setLonghelp(
    2933       "Do (in parallel if threads enabled) the root phase this number of times \
    2934  and collect all solutions and cuts generated.  The actual format is aabbcc \
    2935 where aa is number of extra passes, if bb is non zero \
    2936 then it is number of threads to use (otherwise uses threads setting) and \
    2937 cc is number of times to do root phase.  Yet another one from the Italian idea factory \
    2938 (This time - Andrea Lodi , Matteo Fischetti , Michele Monaci , Domenico Salvagnin , \
    2939 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. \
    29402940The solvers do not interact with each other.  However if extra passes are specified \
    2941 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.");
    29422944    parameters.push_back(p);
    29432945  }
     
    29502952    p.append("before");
    29512953    p.setLonghelp(
    2952       "Really silly stuff e.g. fix all integers with costs to zero!. \
    2953 Doh option does heuristic before preprocessing");
     2954      "This is naive heuristics which, e.g., fix all integers with costs to zero!. "
     2955      HEURISTICS_LONGHELP);
    29542956    parameters.push_back(p);
    29552957  }
     
    30233025  }
    30243026  {
    3025     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",
    30263028      "hybrid", CBC_PARAM_STR_NODESTRATEGY);
    30273029    p.append("fewest");
     
    30323034    p.append("downdepth");
    30333035    p.setLonghelp(
    3034       "Normally before a solution the code will choose node with fewest infeasibilities. \
    3035 You can choose depth as the criterion.  You can also say if up or down branch must \
    3036 be done first (the up down choice will carry on after solution). \
    3037 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'.");
    30383041    parameters.push_back(p);
    30393042  }
     
    30493052  {
    30503053    CbcOrClpParam p("objective!Scale", "Scale factor to apply to objective",
    3051       -1.0e20, 1.0e20, CLP_PARAM_DBL_OBJSCALE, 1);
     3054      -COIN_DBL_MAX, COIN_DBL_MAX, CLP_PARAM_DBL_OBJSCALE, 1);
    30523055    p.setLonghelp(
    30533056      "If the objective function has some very large values, you may wish to scale them\
     
    31293132#ifdef COIN_HAS_CBC
    31303133  {
    3131     CbcOrClpParam p("passC!uts", "Number of cut passes at root node",
    3132       -9999999, 9999999, CBC_PARAM_INT_CUTPASS);
     3134    CbcOrClpParam p("passC!uts", "Number of rounds that cut generators are applied in the root node",
     3135      -COIN_INT_MAX, COIN_INT_MAX, CBC_PARAM_INT_CUTPASS);
    31333136
    31343137    p.setIntValue(20);
    31353138    p.setLonghelp(
    3136       "The default is 100 passes if less than 500 columns, 100 passes (but \
    3137 stop if drop small if less than 5000 columns, 20 otherwise");
    3138     parameters.push_back(p);
    3139   }
    3140   {
    3141     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",
    31423146      0, 10000, CBC_PARAM_INT_FPUMPITS);
    3143     p.setLonghelp(
    3144       "This fine tunes Feasibility Pump by doing more or fewer passes.");
    31453147    p.setIntValue(20);
    31463148    parameters.push_back(p);
     
    31603162#ifdef COIN_HAS_CBC
    31613163  {
    3162     CbcOrClpParam p("passT!reeCuts", "Number of cut passes in tree",
    3163       -9999999, 9999999, CBC_PARAM_INT_CUTPASSINTREE);
     3164    CbcOrClpParam p("passT!reeCuts", "Number of rounds that cut generators are applied in the tree",
     3165      -COIN_INT_MAX, COIN_INT_MAX, CBC_PARAM_INT_CUTPASSINTREE);
    31643166    p.setIntValue(1);
    3165     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.");
    31663168    parameters.push_back(p);
    31673169  }
     
    31743176  }
    31753177  {
    3176     CbcOrClpParam p("perturb!ation", "Whether to perturb problem",
     3178    CbcOrClpParam p("perturb!ation", "Whether to perturb the problem",
    31773179      "on", CLP_PARAM_STR_PERTURBATION);
    31783180    p.append("off");
    31793181    p.setLonghelp(
    3180       "Perturbation helps to stop cycling, but Clp uses other measures for this.\
    3181   However large problems and especially ones with unit elements and unit rhs or costs\
    3182  benefit from perturbation.  Normally Clp tries to be intelligent, but you can switch this off.\
    3183   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.
    31843186    parameters.push_back(p);
    31853187  }
     
    32013203    p.append("both");
    32023204    p.append("before");
    3203     p.setLonghelp(
    3204       "stuff needed. \
    3205 Doh option does heuristic before preprocessing");
     3205    p.setLonghelp(HEURISTICS_LONGHELP);
    32063206    parameters.push_back(p);
    32073207  }
     
    32123212    p.append("both");
    32133213    p.append("before");
    3214     p.setLonghelp(
    3215       "stuff needed. \
    3216 Doh option does heuristic before preprocessing");
     3214    p.setLonghelp(HEURISTICS_LONGHELP);
    32173215    parameters.push_back(p);
    32183216  }
     
    32493247    p.append("file");
    32503248    p.setLonghelp("Presolve analyzes the model to find such things as redundant equations, equations\
    3251  which fix some variables, equations which can be transformed into bounds etc etc.  For the\
    3252  initial solve of any problem this is worth doing unless you know that it will have no effect.  \
    3253 on will normally do 5 passes while using 'more' will do 10.  If the problem is very large you may need \
    3254 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'.");
    32553253    parameters.push_back(p);
    32563254  }
     
    32733271      "This tries to reduce size of model in a similar way to presolve and \
    32743272it also tries to strengthen the model - this can be very useful and is worth trying. \
    3275  Save option saves on file presolved.mps.  equal will turn <= cliques into \
    3276 ==.  sos will create sos sets if all 0-1 in sets (well one extra is allowed) \
    3277 and no overlaps.  trysos is same but allows any number extra.  equalall will turn all \
    3278 valid inequalities into equalities with integer slacks.  strategy is as \
    3279 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.
    32803278    parameters.push_back(p);
    32813279  }
     
    32843282  {
    32853283    CbcOrClpParam p("preT!olerance", "Tolerance to use in presolve",
    3286       1.0e-20, 1.0e12, CLP_PARAM_DBL_PRESOLVETOLERANCE);
    3287     p.setLonghelp(
    3288       "The default is 1.0e-8 - you may wish to try 1.0e-7 if presolve says the problem is \
    3289 infeasible and you have awkward numbers and you are sure the problem is really feasible.");
     3284      1.0e-20, COIN_DBL_MAX, CLP_PARAM_DBL_PRESOLVETOLERANCE);
     3285    p.setLonghelp(
     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.");
    32903288    parameters.push_back(p);
    32913289  }
     
    33033301    p.append("PEdantzig");
    33043302    p.setLonghelp(
    3305       "Clp can use any pivot selection algorithm which the user codes as long as it\
    3306  implements the features in the abstract pivot base class.  The Dantzig method is implemented\
    3307  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\
    33083304 are two variants which keep all weights updated but only scan a subset each iteration.\
    3309  Partial switches this on while change initially does dantzig until the factorization\
    3310  becomes denser.  This is still a work in progress. \n\
    3311 ** NEWS - the Positive Edge criterion has been added. \
    3312 This selects incoming variables to try and avoid degenerate moves. Code \
    3313 donated by Jeremy Omer.  See \
    3314 Towhidi, M., Desrosiers, J., Soumis, F., The positive edge criterion within COIN-OR’s CLP. and \
    3315 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.");
    33163311
    33173312    parameters.push_back(p);
     
    33303325#endif
    33313326  {
    3332     CbcOrClpParam p("primalT!olerance", "For an optimal solution \
    3333 no primal infeasibility may exceed this value",
    3334       1.0e-20, 1.0e12, CLP_PARAM_DBL_PRIMALTOLERANCE);
    3335     p.setLonghelp(
    3336       "Normally the default tolerance is fine, but you may want to increase it a\
    3337  bit if a primal run seems to be having a hard time");
     3327    CbcOrClpParam p("primalT!olerance", "For a feasible solution \
     3328no primal infeasibility, i.e., constraint violation, may exceed this value",
     3329      1.0e-20, COIN_DBL_MAX, CLP_PARAM_DBL_PRIMALTOLERANCE);
     3330    p.setLonghelp(
     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.");
    33383333    parameters.push_back(p);
    33393334  }
     
    33423337    CbcOrClpParam p("primalW!eight", "Initially algorithm acts as if it \
    33433338costs this much to be infeasible",
    3344       1.0e-20, 1.0e20, CLP_PARAM_DBL_PRIMALWEIGHT);
     3339      1.0e-20, COIN_DBL_MAX, CLP_PARAM_DBL_PRIMALWEIGHT);
    33453340    p.setLonghelp(
    33463341      "The primal algorithm in Clp is a single phase algorithm as opposed to a two phase\
     
    34383433    p.append("forceOnButStrong");
    34393434    p.append("strongRoot");
    3440     p.setLonghelp(
    3441       "This switches on probing cuts (either at root or in entire tree) \
    3442     See branchAndCut for information on options. \
    3443 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");
    34443440    parameters.push_back(p);
    34453441  }
     
    34573453    p.setFakeKeyWord(1);
    34583454    p.setLonghelp(
    3459       "This switches on a heuristic which looks for a solution close \
    3460 to incumbent solution (Fischetti and Monaci). \
    3461 See Rounding for meaning of on,both,before. \
    3462 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)).
    34633462    parameters.push_back(p);
    34643463  }
    34653464  {
    34663465    CbcOrClpParam p("pumpC!utoff", "Fake cutoff for use in feasibility pump",
    3467       -1.0e100, 1.0e100, CBC_PARAM_DBL_FAKECUTOFF);
     3466      -COIN_DBL_MAX, COIN_DBL_MAX, CBC_PARAM_DBL_FAKECUTOFF);
    34683467    p.setDoubleValue(0.0);
    34693468    p.setLonghelp(
     
    34743473  {
    34753474    CbcOrClpParam p("pumpI!ncrement", "Fake increment for use in feasibility pump",
    3476       -1.0e100, 1.0e100, CBC_PARAM_DBL_FAKEINCREMENT, 1);
     3475      -COIN_DBL_MAX, COIN_DBL_MAX, CBC_PARAM_DBL_FAKEINCREMENT, 1);
    34773476    p.setDoubleValue(0.0);
    34783477    p.setLonghelp(
     
    35133512
    35143513    p.setLonghelp(
    3515       "This sets a random seed for Cbc \
    3516 - 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.");
    35173516    p.setIntValue(-1);
    35183517    parameters.push_back(p);
     
    35243523    p.append("both");
    35253524    p.append("before");
    3526     p.setLonghelp(
    3527       "stuff needed. \
    3528 Doh option does heuristic before preprocessing");
     3525    p.setLonghelp(HEURISTICS_LONGHELP);
    35293526    parameters.push_back(p);
    35303527  }
     
    35363533
    35373534    p.setLonghelp(
    3538       "This sets a random seed for Clp \
    3539 - 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.");
    35403538    p.setIntValue(1234567);
    35413539    parameters.push_back(p);
     
    35453543  {
    35463544    CbcOrClpParam p("ratio!Gap", "Stop when gap between best possible and \
    3547 best less than this fraction of larger of two",
    3548       0.0, 1.0e20, CBC_PARAM_DBL_GAPRATIO);
     3545best known is less than this fraction of larger of two",
     3546      0.0, COIN_DBL_MAX, CBC_PARAM_DBL_GAPRATIO);
    35493547    p.setDoubleValue(0.0);
    35503548    p.setLonghelp(
    3551       "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 \
    35523550of the objective value at the root node then the search will terminate.  See 'allowableGap' for a \
    35533551way of using absolute value rather than fraction.");
     
    35753573  {
    35763574    CbcOrClpParam p("reallyO!bjectiveScale", "Scale factor to apply to objective in place",
    3577       -1.0e20, 1.0e20, CLP_PARAM_DBL_OBJSCALE2, 0);
     3575      -COIN_DBL_MAX, COIN_DBL_MAX, CLP_PARAM_DBL_OBJSCALE2, 0);
    35783576    p.setLonghelp("You can set this to -1.0 to test maximization or other to stress code");
    35793577    p.setDoubleValue(1.0);
     
    35963594    p.append("forceOn");
    35973595    p.setLonghelp(
    3598       "This switches on reduce and split  cuts (either at root or in entire tree). \
    3599 May be slow \
    3600 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");
    36013599    parameters.push_back(p);
    36023600  }
     
    36083606    p.append("longOn");
    36093607    p.append("longRoot");
    3610     p.setLonghelp("This switches on reduce and split  cuts (either at root or in entire tree) \
    3611 This version is by Giacomo Nannicini based on Francois Margot's version \
    3612 Standard setting only uses rows in tableau <=256, long uses all \
    3613 May be slow \
    3614 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.");
    36153613    parameters.push_back(p);
    36163614  }
     
    36223620    p.append("ifmove");
    36233621    p.append("forceOn");
    3624     p.setLonghelp(
    3625       "Residual capacity cuts. \
    3626 See branchAndCut for information on options.");
     3622    p.setLonghelp(CUTS_LONGHELP
     3623      " Reference: https://github.com/coin-or/Cgl/wiki/CglResidualCapacity");
    36273624
    36283625    parameters.push_back(p);
     
    36493646  {
    36503647    CbcOrClpParam p("rhs!Scale", "Scale factor to apply to rhs and bounds",
    3651       -1.0e20, 1.0e20, CLP_PARAM_DBL_RHSSCALE, 0);
     3648      -COIN_DBL_MAX, COIN_DBL_MAX, CLP_PARAM_DBL_RHSSCALE, 0);
    36523649    p.setLonghelp(
    36533650      "If the rhs or bounds have some very large meaningful values, you may wish to scale them\
     
    36703667    p.append("djbefore");
    36713668    p.append("usesolution");
    3672     p.setLonghelp(
    3673       "This switches on Relaxation enforced neighborhood Search. \
    3674 on just does 50 nodes \
    3675 200 or 1000 does that many nodes. \
    3676 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.");
    36773671    parameters.push_back(p);
    36783672  }
     
    36843678    p.append("before");
    36853679    p.append("often");
    3686     p.setLonghelp(
    3687       "This switches on Relaxed induced neighborhood Search. \
    3688 Doh option does heuristic before preprocessing");
    3689     parameters.push_back(p);
    3690   }
    3691   {
    3692     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",
    36933685      "off", CBC_PARAM_STR_ROUNDING);
    36943686    p.append("on");
    36953687    p.append("both");
    36963688    p.append("before");
    3697     p.setLonghelp(
    3698       "This switches on a simple (but effective) rounding heuristic at each node of tree.  \
    3699 On means do in solve i.e. after preprocessing, \
    3700 Before means do if doHeuristics used, off otherwise, \
    3701 and both means do if doHeuristics and in solve.");
     3689    p.setLonghelp(HEURISTICS_LONGHELP);
    37023690    parameters.push_back(p);
    37033691  }
     
    37373725      "Scaling can help in solving problems which might otherwise fail because of lack of\
    37383726 accuracy.  It can also reduce the number of iterations.  It is not applied if the range\
    3739  of elements is small.  When unscaled it is possible that there may be small primal and/or\
    3740  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.");
    37413732    p.setCurrentOption(3); // say auto
    37423733    parameters.push_back(p);
     
    37453736  {
    37463737    CbcOrClpParam p("sec!onds", "Maximum seconds",
    3747       -1.0, 1.0e12, CLP_PARAM_DBL_TIMELIMIT);
     3738      -1.0, COIN_DBL_MAX, CLP_PARAM_DBL_TIMELIMIT);
    37483739
    37493740    p.setLonghelp("After this many seconds clp will act as if maximum iterations had been reached \
     
    37543745  {
    37553746    CbcOrClpParam p("sec!onds", "maximum seconds",
    3756       -1.0, 1.0e12, CBC_PARAM_DBL_TIMELIMIT_BAB);
     3747      -1.0, COIN_DBL_MAX, CBC_PARAM_DBL_TIMELIMIT_BAB);
    37573748    p.setLonghelp(
    37583749      "After this many seconds coin solver will act as if maximum nodes had been reached.");
     
    37703761#ifdef COIN_HAS_CBC
    37713762  {
    3772     CbcOrClpParam p("slow!cutpasses", "Maximum number of tries for slower cuts",
     3763    CbcOrClpParam p("slow!cutpasses", "Maximum number of rounds for slower cut generators",
    37733764      -1, COIN_INT_MAX, CBC_PARAM_INT_MAX_SLOW_CUTS);
    37743765    p.setLonghelp(
    3775       "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.");
    37763768    p.setIntValue(10);
    37773769    parameters.push_back(p);
     
    38723864  {
    38733865    CbcOrClpParam p("sprint!Crash", "Whether to try sprint crash",
    3874       -1, 5000000, CLP_PARAM_INT_SPRINT);
    3875     p.setLonghelp(
    3876       "For long and thin problems this program may solve a series of small problems\
    3877  created by taking a subset of the columns.  I introduced the idea as 'Sprint' after\
     3866      -1, COIN_INT_MAX, CLP_PARAM_INT_SPRINT);
     3867    p.setLonghelp(
     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\
    38783870 an LP code of that name of the 60's which tried the same tactic (not totally successfully).\
    3879   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");
    38803872    parameters.push_back(p);
    38813873  }
     
    39043896      "This turns on newer features. \
    39053897Use 0 for easy problems, 1 is default, 2 is aggressive. \
    3906 1 uses Gomory cuts using tolerance of 0.01 at root, \
    3907 does a possible restart after 100 nodes if can fix many \
    3908 and activates a diving and RINS heuristic and makes feasibility pump \
    3909 more aggressive. \
    3910 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
    39113902    p.setIntValue(1);
    39123903    parameters.push_back(p);
     
    39283919    p.setLonghelp(
    39293920      "In order to decide which variable to branch on, the code will choose up to this number \
    3930 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. \
    39313922If a variable is branched on many times then the previous average up and down costs may be used - \
    3932 see number before trust.");
     3923see also option trustPseudoCosts.");
    39333924    parameters.push_back(p);
    39343925  }
     
    39693960    CbcOrClpParam p("tighten!Factor", "Tighten bounds using this times largest \
    39703961activity at continuous solution",
    3971       1.0e-3, 1.0e20, CBC_PARAM_DBL_TIGHTENFACTOR, 0);
     3962      1.0e-3, COIN_DBL_MAX, CBC_PARAM_DBL_TIGHTENFACTOR, 0);
    39723963    p.setLonghelp(
    39733964      "This sleazy trick can help on some problems.");
     
    39953986  {
    39963987    CbcOrClpParam p("trust!PseudoCosts", "Number of branches before we trust pseudocosts",
    3997       -3, 2000000000, CBC_PARAM_INT_NUMBERBEFORE);
    3998     p.setLonghelp(
    3999       "Using strong branching computes pseudo-costs.  After this many times for a variable we just \
     3988      -3, COIN_INT_MAX, CBC_PARAM_INT_NUMBERBEFORE);
     3989    p.setLonghelp(
     3990      "Using strong branching computes pseudo-costs.  This parameter determines after how many branches for a variable we just \
    40003991trust the pseudo costs and do not do any more strong branching.");
    40013992    p.setIntValue(10);
     
    40063997  {
    40073998    CbcOrClpParam p("tune!PreProcess", "Dubious tuning parameters",
    4008       0, 2000000000, CLP_PARAM_INT_PROCESSTUNE, 1);
     3999      0, COIN_INT_MAX, CLP_PARAM_INT_PROCESSTUNE, 1);
    40094000    p.setLonghelp(
    40104001      "Format aabbcccc - \n If aa then this is number of major passes (i.e. with presolve) \n \
     
    40294020    p.append("forceandglobal");
    40304021    p.append("forceLongOn");
    4031     p.setLonghelp(
    4032       "This switches on two phase mixed integer rounding  cuts (either at root or in entire tree) \
    4033 See branchAndCut for information on options.");
     4022    p.setLonghelp(CUTS_LONGHELP
     4023      " Reference: https://github.com/coin-or/Cgl/wiki/CglTwomir");
    40344024    parameters.push_back(p);
    40354025  }
     
    40824072    p.append("before");
    40834073    p.append("intree");
    4084     p.setLonghelp(
    4085       "This switches on variable neighborhood Search. \
    4086 Doh option does heuristic before preprocessing");
     4074    p.setLonghelp(HEURISTICS_LONGHELP);
    40874075    parameters.push_back(p);
    40884076  }
     
    41064094#ifdef COIN_HAS_CBC
    41074095  {
    4108     CbcOrClpParam p("vub!heuristic", "Type of vub heuristic",
     4096    CbcOrClpParam p("vub!heuristic", "Type of VUB heuristic",
    41094097      -2, 20, CBC_PARAM_INT_VUBTRY, 0);
    41104098    p.setLonghelp(
    4111       "If set will try and fix some integer variables");
     4099      "This heuristic tries and fix some integer variables.");
    41124100    p.setIntValue(-1);
    41134101    parameters.push_back(p);
     
    41214109    p.append("forceOn");
    41224110    p.append("onglobal");
    4123     p.setLonghelp(
    4124       "This switches on zero-half cuts (either at root or in entire tree) \
    4125 See branchAndCut for information on options.  This implementation was written by \
    4126 Alberto Caprara.");
     4111    p.setLonghelp(CUTS_LONGHELP
     4112      " This implementation was written by Alberto Caprara.");
    41274113    parameters.push_back(p);
    41284114  }
  • stable/1.17/Clp/src/CbcOrClpParam.hpp

    r2389 r2468  
    3232  Parameter type ranges are allocated as follows
    3333  <ul>
    34     <li>   1 -- 100     double parameters
    35     <li> 101 -- 200     integer parameters
    36     <li> 201 -- 250     string parameters
    37     <li> 251 -- 300     cuts etc(string but broken out for clarity)
    38     <li> 301 -- 400     `actions'
     34    <li>   1 -- 100  double parameters
     35    <li> 101 -- 200  integer parameters
     36    <li> 201 -- 300  Clp string parameters
     37    <li> 301 -- 400  Cbc string parameters
     38    <li> 401 -- 500  (mostly) Clp actions
     39    <li> 501 -- 600  (mostly) Cbc actions
    3940  </ul>
    4041
     
    337338  {
    338339    return shortHelp_;
     340  }
     341  /// Returns long help
     342  inline std::string longHelp() const
     343  {
     344    return longHelp_;
     345  }
     346  /// Returns set of valid strings
     347  inline const std::vector<std::string>& definedKeywords() const
     348  {
     349    return definedKeyWords_;
     350  }
     351  /// Returns the lower bound for a double-valued parameter
     352  inline double lowerDoubleValue() const
     353  {
     354     return lowerDoubleValue_;
     355  }
     356  /// Returns the upper bound for a double-valued parameter
     357  inline double upperDoubleValue() const
     358  {
     359     return upperDoubleValue_;
     360  }
     361  /// Returns the lower bound for an int-valued parameter
     362  inline int lowerIntValue() const
     363  {
     364     return lowerIntValue_;
     365  }
     366  /// Returns the upper bound for an int-valued parameter
     367  inline int upperIntValue() const
     368  {
     369     return upperIntValue_;
    339370  }
    340371  /// Sets a double parameter (nonzero code if error)
  • stable/1.17/Clp/src/ClpPackedMatrix.cpp

    r2385 r2468  
    67506750#ifdef _MSC_VER
    67516751#include <intrin.h>
     6752#elif defined(__arm__)
     6753#include <arm_neon.h>
    67526754#else
    67536755#include <immintrin.h>
  • stable/1.17/Clp/src/ClpSimplexDual.cpp

    r2453 r2468  
    35573557#ifdef _MSC_VER
    35583558#include <intrin.h>
     3559#elif defined(__arm__)
     3560#include <arm_neon.h>
    35593561#else
    35603562#include <immintrin.h>
  • stable/1.17/appveyor.yml

    r2365 r2468  
    3333
    3434install:
    35   - for /f "delims=" %%i in ('C:\msys64\usr\bin\bash -lc "if [ $APPVEYOR_REPO_BRANCH = 'master' ]; then echo 'trunk'; else echo $APPVEYOR_REPO_BRANCH | cut -d "/" -f 2; fi"') do set VERSION=%%i
     35  - for /f "delims=" %%i in ('C:\msys64\usr\bin\bash -lc "if [ $APPVEYOR_REPO_BRANCH = 'master' ]; then echo 'master'; else echo $APPVEYOR_REPO_BRANCH | cut -d "/" -f 2; fi"') do set VERSION=%%i
    3636  - IF %ARCH%==win32-msvc9 (CALL C:\"Program Files (x86)\Microsoft Visual Studio 9.0\VC\vcvarsall.bat")
    3737  - IF %ARCH%==win32-msvc14 (CALL C:\"Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat")
     
    4040
    4141build_script:
    42   - C:\msys64\usr\bin\bash -lc "cd $APPVEYOR_BUILD_FOLDER; git clone https://github.com/coin-or/COIN-OR-OptimizationSuite COIN"
    43   - C:\msys64\usr\bin\bash -lc "cd $APPVEYOR_BUILD_FOLDER/COIN; ./coin.install.sh fetch --no-prompt --main-proj=%APPVEYOR_PROJECT_NAME% --no-third-party"
    44   - C:\msys64\usr\bin\bash -lc "cd $APPVEYOR_BUILD_FOLDER/COIN; export PATH=$ADD_PATH:$PATH; ./coin.install.sh build --no-prompt --main-proj=%APPVEYOR_PROJECT_NAME% --no-third-party --build=x86_64-w64-mingw32 $HOST_ARCH_ARG --verbosity=2 --test"
     42  - C:\msys64\usr\bin\bash -lc "cd C:\projects; wget https://raw.githubusercontent.com/coin-or/coinbrew/master/coinbrew"
     43  - C:\msys64\usr\bin\bash -lc "cd C:\projects; ./coinbrew fetch %APPVEYOR_PROJECT_NAME% --no-prompt --skip-update --no-third-party"
     44  - C:\msys64\usr\bin\bash -lc "cd C:\projects; export PATH=$ADD_PATH:$PATH; ./coinbrew build %APPVEYOR_PROJECT_NAME% --no-prompt --no-third-party --build=x86_64-w64-mingw32 $HOST_ARCH_ARG --verbosity=2 --test"
    4545
    4646after_build:
    47   - 7z a %APPVEYOR_PROJECT_NAME%-%VERSION%-%ARCH%.zip %APPVEYOR_BUILD_FOLDER%\COIN\build\bin
    48   - 7z a %APPVEYOR_PROJECT_NAME%-%VERSION%-%ARCH%.zip %APPVEYOR_BUILD_FOLDER%\COIN\build\include
    49   - 7z a %APPVEYOR_PROJECT_NAME%-%VERSION%-%ARCH%.zip %APPVEYOR_BUILD_FOLDER%\COIN\build\lib
    50   - 7z a %APPVEYOR_PROJECT_NAME%-%VERSION%-%ARCH%.zip %APPVEYOR_BUILD_FOLDER%\COIN\build\share
    51   - 7z a %APPVEYOR_PROJECT_NAME%-%VERSION%-%ARCH%.zip %APPVEYOR_BUILD_FOLDER%\COIN\%APPVEYOR_PROJECT_NAME%\README
    52   - 7z a %APPVEYOR_PROJECT_NAME%-%VERSION%-%ARCH%.zip %APPVEYOR_BUILD_FOLDER%\COIN\%APPVEYOR_PROJECT_NAME%\LICENSE
    53   - 7z a %APPVEYOR_PROJECT_NAME%-%VERSION%-%ARCH%.zip %APPVEYOR_BUILD_FOLDER%\COIN\%APPVEYOR_PROJECT_NAME%\INSTALL
    54   - 7z a %APPVEYOR_PROJECT_NAME%-%VERSION%-%ARCH%.zip %APPVEYOR_BUILD_FOLDER%\COIN\%APPVEYOR_PROJECT_NAME%\%APPVEYOR_PROJECT_NAME%\AUTHORS
     47  - 7z a %APPVEYOR_PROJECT_NAME%-%VERSION%-%ARCH%.zip C:\projects\build\bin
     48  - 7z a %APPVEYOR_PROJECT_NAME%-%VERSION%-%ARCH%.zip C:\projects\build\include
     49  - 7z a %APPVEYOR_PROJECT_NAME%-%VERSION%-%ARCH%.zip C:\projects\build\lib
     50  - 7z a %APPVEYOR_PROJECT_NAME%-%VERSION%-%ARCH%.zip C:\projects\build\share
     51  - 7z a %APPVEYOR_PROJECT_NAME%-%VERSION%-%ARCH%.zip C:\projects\%APPVEYOR_PROJECT_NAME%\README.md
     52  - 7z a %APPVEYOR_PROJECT_NAME%-%VERSION%-%ARCH%.zip C:\projects\%APPVEYOR_PROJECT_NAME%\LICENSE
     53  - 7z a %APPVEYOR_PROJECT_NAME%-%VERSION%-%ARCH%.zip C:\projects\%APPVEYOR_PROJECT_NAME%\%APPVEYOR_PROJECT_NAME%\AUTHORS
    5554  - curl -T %APPVEYOR_PROJECT_NAME%-%VERSION%-%ARCH%.zip -utkralphs:%BINTRAY_API% -H "X-Bintray-Publish:1" -H "X-Bintray-Override:1" https://api.bintray.com/content/coin-or/download/%APPVEYOR_PROJECT_NAME%/%VERSION%/%APPVEYOR_PROJECT_NAME%-%VERSION%-%ARCH%.zip
    5655
    57 #on_finish:
    5856#  - ps: $blockRdp = $true; iex ((new-object net.webclient).DownloadString('https://raw.githubusercontent.com/appveyor/ci/master/scripts/enable-rdp.ps1'))
Note: See TracChangeset for help on using the changeset viewer.