 Timestamp:
 May 2, 2019 11:52:43 PM (19 months ago)
 File:

 1 edited
Legend:
 Unmodified
 Added
 Removed

trunk/Clp/src/CbcOrClpParam.cpp
r2466 r2467 1539 1539 CbcOrClpParam p("allow!ableGap", "Stop when gap between best possible and \ 1540 1540 best less than this", 1541 0.0, 1.0e20, CBC_PARAM_DBL_ALLOWABLEGAP);1541 0.0, COIN_DBL_MAX, CBC_PARAM_DBL_ALLOWABLEGAP); 1542 1542 p.setDoubleValue(0.0); 1543 1543 p.setLonghelp( … … 1560 1560 { 1561 1561 CbcOrClpParam p("artif!icialCost", "Costs >= this treated as artificials in feasibility pump", 1562 0.0, 1.0e100, CBC_PARAM_DBL_ARTIFICIALCOST, 1);1562 0.0, COIN_DBL_MAX, CBC_PARAM_DBL_ARTIFICIALCOST, 1); 1563 1563 p.setDoubleValue(0.0); 1564 1564 p.setLonghelp( … … 1846 1846 "Interior point algorithms do not obtain a basic solution.\ 1847 1847 This option will crossover to a basic solution suitable for ranging or branch and cut. With the current state \ 1848 of quadratic it may be a good idea to switch off crossover for quadratic(and maybe \1848 of the solver for quadratic programs it may be a good idea to switch off crossover for this case (and maybe \ 1849 1849 presolve as well)  the option 'maybe' does this."); 1850 1850 parameters.push_back(p); … … 1863 1863 { 1864 1864 CbcOrClpParam p("cutD!epth", "Depth in tree at which to do cuts", 1865 1, 999999, CBC_PARAM_INT_CUTDEPTH);1865 1, COIN_INT_MAX, CBC_PARAM_INT_CUTDEPTH); 1866 1866 p.setLonghelp( 1867 1867 "Cut generators may be off, on, on only at the root node, or on if they look useful. \ … … 1884 1884 { 1885 1885 CbcOrClpParam p("cuto!ff", "Bound on the objective value for all solutions", 1886  1.0e100, 1.0e100, CBC_PARAM_DBL_CUTOFF);1886 COIN_DBL_MAX, COIN_DBL_MAX, CBC_PARAM_DBL_CUTOFF); 1887 1887 p.setDoubleValue(1.0e50); 1888 1888 p.setLonghelp( … … 1958 1958 { 1959 1959 CbcOrClpParam p("dextra3", "Extra double parameter 3", 1960  1.0e100, 1.0e100, CBC_PARAM_DBL_DEXTRA3, 0);1960 COIN_DBL_MAX, COIN_DBL_MAX, CBC_PARAM_DBL_DEXTRA3, 0); 1961 1961 p.setDoubleValue(0.0); 1962 1962 parameters.push_back(p); … … 1964 1964 { 1965 1965 CbcOrClpParam p("dextra4", "Extra double parameter 4", 1966  1.0e100, 1.0e100, CBC_PARAM_DBL_DEXTRA4, 0);1966 COIN_DBL_MAX, COIN_DBL_MAX, CBC_PARAM_DBL_DEXTRA4, 0); 1967 1967 p.setDoubleValue(0.0); 1968 1968 parameters.push_back(p); … … 1970 1970 { 1971 1971 CbcOrClpParam p("dextra4", "Extra double parameter 5", 1972  1.0e100, 1.0e100, CBC_PARAM_DBL_DEXTRA5, 0);1972 COIN_DBL_MAX, COIN_DBL_MAX, CBC_PARAM_DBL_DEXTRA5, 0); 1973 1973 p.setDoubleValue(0.0); 1974 1974 parameters.push_back(p); … … 2204 2204 CbcOrClpParam p("dualT!olerance", "For an optimal solution \ 2205 2205 no dual infeasibility may exceed this value", 2206 1.0e20, 1.0e12, CLP_PARAM_DBL_DUALTOLERANCE);2206 1.0e20, COIN_DBL_MAX, CLP_PARAM_DBL_DUALTOLERANCE); 2207 2207 p.setLonghelp( 2208 2208 "Normally the default tolerance is fine, but one may want to increase it a\ … … 2396 2396 CbcOrClpParam p("fix!OnDj", "Try heuristic based on fixing variables with \ 2397 2397 reduced costs greater than this", 2398  1.0e20, 1.0e20, CBC_PARAM_DBL_DJFIX, 1);2398 COIN_DBL_MAX, COIN_DBL_MAX, CBC_PARAM_DBL_DJFIX, 1); 2399 2399 p.setLonghelp( 2400 2400 "If this is set integer variables with reduced costs greater than this will be fixed \ … … 2545 2545 { 2546 2546 CbcOrClpParam p("hOp!tions", "Heuristic options", 2547  9999999, 9999999, CBC_PARAM_INT_HOPTIONS, 1);2547 COIN_INT_MAX, COIN_INT_MAX, CBC_PARAM_INT_HOPTIONS, 1); 2548 2548 p.setIntValue(0); 2549 2549 p.setLonghelp( … … 2564 2564 { 2565 2565 CbcOrClpParam p("idiot!Crash", "Whether to try idiot crash", 2566 1, 99999999, CLP_PARAM_INT_IDIOT);2566 1, COIN_INT_MAX, CLP_PARAM_INT_IDIOT); 2567 2567 2568 2568 p.setLonghelp( … … 2589 2589 CbcOrClpParam p("inc!rement", "A valid solution must be at least this \ 2590 2590 much better than last integer solution", 2591  1.0e20, 1.0e20, CBC_PARAM_DBL_INCREMENT);2591 COIN_DBL_MAX, COIN_DBL_MAX, CBC_PARAM_DBL_INCREMENT); 2592 2592 2593 2593 p.setLonghelp( … … 2602 2602 CbcOrClpParam p("inf!easibilityWeight", "Each integer infeasibility is expected \ 2603 2603 to cost this much", 2604 0.0, 1.0e20, CBC_PARAM_DBL_INFEASIBILITYWEIGHT, 1);2604 0.0, COIN_DBL_MAX, CBC_PARAM_DBL_INFEASIBILITYWEIGHT, 1); 2605 2605 p.setLonghelp( 2606 2606 "A primitive way of deciding which node to explore next. Satisfying each integer infeasibility is \ … … 2735 2735 #ifndef COIN_HAS_CBC 2736 2736 CbcOrClpParam p("log!Level", "Level of detail in Solver output", 2737 1, 999999, CLP_PARAM_INT_SOLVERLOGLEVEL);2737 1, COIN_INT_MAX, CLP_PARAM_INT_SOLVERLOGLEVEL); 2738 2738 parameters.push_back(p); 2739 2739 #else … … 2759 2759 CbcOrClpParam p("maxF!actor", "Maximum number of iterations between \ 2760 2760 refactorizations", 2761 1, 999999, CLP_PARAM_INT_MAXFACTOR);2761 1, COIN_INT_MAX, CLP_PARAM_INT_MAXFACTOR); 2762 2762 p.setLonghelp( 2763 2763 "If this is left at its default value of 200 then CLP will guess a\ … … 2768 2768 CbcOrClpParam p("maxIt!erations", "Maximum number of iterations before \ 2769 2769 stopping", 2770 0, 2147483647, CLP_PARAM_INT_MAXITERATION);2770 0, COIN_INT_MAX, CLP_PARAM_INT_MAXITERATION); 2771 2771 p.setLonghelp( 2772 2772 "This can be used for testing purposes. The corresponding library call\n\ … … 2779 2779 { 2780 2780 CbcOrClpParam p("maxN!odes", "Maximum number of nodes to do", 2781 1, 2147483647, CBC_PARAM_INT_MAXNODES);2781 1, COIN_INT_MAX, CBC_PARAM_INT_MAXNODES); 2782 2782 p.setLonghelp( 2783 2783 "This is a repeatable way to limit search. Normally using time is easier \ … … 2787 2787 { 2788 2788 CbcOrClpParam p("maxSaved!Solutions", "Maximum number of solutions to save", 2789 0, 2147483647, CBC_PARAM_INT_MAXSAVEDSOLS);2789 0, COIN_INT_MAX, CBC_PARAM_INT_MAXSAVEDSOLS); 2790 2790 p.setLonghelp( 2791 2791 "Number of solutions to save."); … … 2794 2794 { 2795 2795 CbcOrClpParam p("maxSo!lutions", "Maximum number of feasible solutions to get", 2796 1, 2147483647, CBC_PARAM_INT_MAXSOLS);2796 1, COIN_INT_MAX, CBC_PARAM_INT_MAXSOLS); 2797 2797 p.setLonghelp( 2798 2798 "You may want to stop after (say) two solutions or an hour. \ … … 2930 2930 { 2931 2931 CbcOrClpParam p("multiple!RootPasses", "Do multiple root passes to collect cuts and solutions", 2932 0, 100000000, CBC_PARAM_INT_MULTIPLEROOTS, 0);2932 0, COIN_INT_MAX, CBC_PARAM_INT_MULTIPLEROOTS, 0); 2933 2933 p.setIntValue(0); 2934 2934 p.setLonghelp( … … 3052 3052 { 3053 3053 CbcOrClpParam p("objective!Scale", "Scale factor to apply to objective", 3054  1.0e20, 1.0e20, CLP_PARAM_DBL_OBJSCALE, 1);3054 COIN_DBL_MAX, COIN_DBL_MAX, CLP_PARAM_DBL_OBJSCALE, 1); 3055 3055 p.setLonghelp( 3056 3056 "If the objective function has some very large values, you may wish to scale them\ … … 3133 3133 { 3134 3134 CbcOrClpParam p("passC!uts", "Number of rounds that cut generators are applied in the root node", 3135  9999999, 9999999, CBC_PARAM_INT_CUTPASS);3135 COIN_INT_MAX, COIN_INT_MAX, CBC_PARAM_INT_CUTPASS); 3136 3136 3137 3137 p.setIntValue(20); … … 3163 3163 { 3164 3164 CbcOrClpParam p("passT!reeCuts", "Number of rounds that cut generators are applied in the tree", 3165  9999999, 9999999, CBC_PARAM_INT_CUTPASSINTREE);3165 COIN_INT_MAX, COIN_INT_MAX, CBC_PARAM_INT_CUTPASSINTREE); 3166 3166 p.setIntValue(1); 3167 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."); … … 3282 3282 { 3283 3283 CbcOrClpParam p("preT!olerance", "Tolerance to use in presolve", 3284 1.0e20, 1.0e12, CLP_PARAM_DBL_PRESOLVETOLERANCE);3284 1.0e20, COIN_DBL_MAX, CLP_PARAM_DBL_PRESOLVETOLERANCE); 3285 3285 p.setLonghelp( 3286 3286 "One may want to increase this tolerance if presolve says the problem is \ … … 3327 3327 CbcOrClpParam p("primalT!olerance", "For a feasible solution \ 3328 3328 no primal infeasibility, i.e., constraint violation, may exceed this value", 3329 1.0e20, 1.0e12, CLP_PARAM_DBL_PRIMALTOLERANCE);3329 1.0e20, COIN_DBL_MAX, CLP_PARAM_DBL_PRIMALTOLERANCE); 3330 3330 p.setLonghelp( 3331 3331 "Normally the default tolerance is fine, but one may want to increase it a\ … … 3337 3337 CbcOrClpParam p("primalW!eight", "Initially algorithm acts as if it \ 3338 3338 costs this much to be infeasible", 3339 1.0e20, 1.0e20, CLP_PARAM_DBL_PRIMALWEIGHT);3339 1.0e20, COIN_DBL_MAX, CLP_PARAM_DBL_PRIMALWEIGHT); 3340 3340 p.setLonghelp( 3341 3341 "The primal algorithm in Clp is a single phase algorithm as opposed to a two phase\ … … 3464 3464 { 3465 3465 CbcOrClpParam p("pumpC!utoff", "Fake cutoff for use in feasibility pump", 3466  1.0e100, 1.0e100, CBC_PARAM_DBL_FAKECUTOFF);3466 COIN_DBL_MAX, COIN_DBL_MAX, CBC_PARAM_DBL_FAKECUTOFF); 3467 3467 p.setDoubleValue(0.0); 3468 3468 p.setLonghelp( … … 3473 3473 { 3474 3474 CbcOrClpParam p("pumpI!ncrement", "Fake increment for use in feasibility pump", 3475  1.0e100, 1.0e100, CBC_PARAM_DBL_FAKEINCREMENT, 1);3475 COIN_DBL_MAX, COIN_DBL_MAX, CBC_PARAM_DBL_FAKEINCREMENT, 1); 3476 3476 p.setDoubleValue(0.0); 3477 3477 p.setLonghelp( … … 3544 3544 CbcOrClpParam p("ratio!Gap", "Stop when gap between best possible and \ 3545 3545 best known is less than this fraction of larger of two", 3546 0.0, 1.0e20, CBC_PARAM_DBL_GAPRATIO);3546 0.0, COIN_DBL_MAX, CBC_PARAM_DBL_GAPRATIO); 3547 3547 p.setDoubleValue(0.0); 3548 3548 p.setLonghelp( … … 3573 3573 { 3574 3574 CbcOrClpParam p("reallyO!bjectiveScale", "Scale factor to apply to objective in place", 3575  1.0e20, 1.0e20, CLP_PARAM_DBL_OBJSCALE2, 0);3575 COIN_DBL_MAX, COIN_DBL_MAX, CLP_PARAM_DBL_OBJSCALE2, 0); 3576 3576 p.setLonghelp("You can set this to 1.0 to test maximization or other to stress code"); 3577 3577 p.setDoubleValue(1.0); … … 3646 3646 { 3647 3647 CbcOrClpParam p("rhs!Scale", "Scale factor to apply to rhs and bounds", 3648  1.0e20, 1.0e20, CLP_PARAM_DBL_RHSSCALE, 0);3648 COIN_DBL_MAX, COIN_DBL_MAX, CLP_PARAM_DBL_RHSSCALE, 0); 3649 3649 p.setLonghelp( 3650 3650 "If the rhs or bounds have some very large meaningful values, you may wish to scale them\ … … 3736 3736 { 3737 3737 CbcOrClpParam p("sec!onds", "Maximum seconds", 3738 1.0, 1.0e12, CLP_PARAM_DBL_TIMELIMIT);3738 1.0, COIN_DBL_MAX, CLP_PARAM_DBL_TIMELIMIT); 3739 3739 3740 3740 p.setLonghelp("After this many seconds clp will act as if maximum iterations had been reached \ … … 3745 3745 { 3746 3746 CbcOrClpParam p("sec!onds", "maximum seconds", 3747 1.0, 1.0e100, CBC_PARAM_DBL_TIMELIMIT_BAB);3747 1.0, COIN_DBL_MAX, CBC_PARAM_DBL_TIMELIMIT_BAB); 3748 3748 p.setLonghelp( 3749 3749 "After this many seconds coin solver will act as if maximum nodes had been reached."); … … 3864 3864 { 3865 3865 CbcOrClpParam p("sprint!Crash", "Whether to try sprint crash", 3866 1, 5000000, CLP_PARAM_INT_SPRINT);3866 1, COIN_INT_MAX, CLP_PARAM_INT_SPRINT); 3867 3867 p.setLonghelp( 3868 3868 "For long and thin problems this method may solve a series of small problems\ … … 3960 3960 CbcOrClpParam p("tighten!Factor", "Tighten bounds using this times largest \ 3961 3961 activity at continuous solution", 3962 1.0e3, 1.0e20, CBC_PARAM_DBL_TIGHTENFACTOR, 0);3962 1.0e3, COIN_DBL_MAX, CBC_PARAM_DBL_TIGHTENFACTOR, 0); 3963 3963 p.setLonghelp( 3964 3964 "This sleazy trick can help on some problems."); … … 3986 3986 { 3987 3987 CbcOrClpParam p("trust!PseudoCosts", "Number of branches before we trust pseudocosts", 3988 3, 2000000000, CBC_PARAM_INT_NUMBERBEFORE);3988 3, COIN_INT_MAX, CBC_PARAM_INT_NUMBERBEFORE); 3989 3989 p.setLonghelp( 3990 3990 "Using strong branching computes pseudocosts. This parameter determines after how many branches for a variable we just \ … … 3997 3997 { 3998 3998 CbcOrClpParam p("tune!PreProcess", "Dubious tuning parameters", 3999 0, 2000000000, CLP_PARAM_INT_PROCESSTUNE, 1);3999 0, COIN_INT_MAX, CLP_PARAM_INT_PROCESSTUNE, 1); 4000 4000 p.setLonghelp( 4001 4001 "Format aabbcccc  \n If aa then this is number of major passes (i.e. with presolve) \n \
Note: See TracChangeset
for help on using the changeset viewer.