diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 1fc003fc..97c2b095 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -64,27 +64,24 @@ jobs: CXX: g++-11 steps: - uses: actions/checkout@v3 - - name: Install parallelism library for C++ - run: sudo apt update && sudo apt install libtbb12 - - uses: MarkusJx/install-boost@v2.4.1 - with: - boost_version: 1.84.0 - name: Install SCIP run: | - wget https://github.com/scipopt/scip/releases/download/v923/SCIPOptSuite-9.2.3-Linux-ubuntu22.sh - chmod +x SCIPOptSuite-9.2.3-Linux-ubuntu22.sh - ./SCIPOptSuite-9.2.3-Linux-ubuntu22.sh --skip-license + wget -q https://github.com/scipopt/scip/releases/download/v10.0.0/scipoptsuite_10.0.0-1+jammy_amd64.deb + sudo apt update + sudo apt install -y ./scipoptsuite_10.0.0-1+jammy_amd64.deb + sudo apt install -y libmpfr-dev libboost-all-dev - name: Build SCIP++ run: | - CMAKE_PREFIX_PATH=./lib/cmake/scip:./boost/boost/lib/cmake/Boost-1.84.0 cmake -DBUILD_TESTS=ON . + cmake -DBUILD_TESTS=ON . make -j tests - name: Run tests run: ./test/tests test_release_mac: - runs-on: macos-13 + runs-on: macos-15 steps: - uses: actions/checkout@v3 - - uses: turtlebrowser/get-conan@main + - name: Install Conan + run: brew install conan - name: Run Conan Install run: | conan profile detect diff --git a/changelog.md b/changelog.md index da04a7a7..3c84d97e 100644 --- a/changelog.md +++ b/changelog.md @@ -4,6 +4,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ## [Unreleased] - [Doc:Unreleased] +### Changed + +- [PR38](https://github.com/scipopt/SCIPpp/pull/38) Update to SCIP 10.0.0. + ## [1.3.0] - 2025-10-08 ### Changed diff --git a/conanfile.py b/conanfile.py index b76c0e38..6df37b40 100644 --- a/conanfile.py +++ b/conanfile.py @@ -73,7 +73,7 @@ def layout(self): cmake_layout(self) def requirements(self): - self.requires("scip/9.2.3", transitive_headers=True) + self.requires("scip/10.0.0", transitive_headers=True) if self.options.with_tests: self.requires("boost/[>=1.84.0 <2]") # required only for tests diff --git a/include/scippp/parameters.hpp b/include/scippp/parameters.hpp index 62e1d721..6e077e16 100644 --- a/include/scippp/parameters.hpp +++ b/include/scippp/parameters.hpp @@ -1,7 +1,7 @@ #pragma once // This file is automatically generated using gen_constexpr_parameters from the utils -// updated for SCIP 9.2.3 +// updated for SCIP 10.0.0 #include "scippp/param.hpp" #undef INFINITY @@ -63,8 +63,6 @@ namespace BENDERS::DEFAULT { //! where should the strengthening interior point be sourced from ('l'p relaxation, 'f'irst solution, 'i'ncumbent //! solution, 'r'elative interior point, vector of 'o'nes, vector of 'z'eros) constexpr Param CUTSTRENGTHENINTPOINT { "benders/default/cutstrengthenintpoint" }; - //! the number of threads to use when solving the subproblems - constexpr Param NUMTHREADS { "benders/default/numthreads" }; //! should a feasibility phase be executed during the root node, i.e. adding slack variables to constraints to //! ensure feasibility constexpr Param EXECFEASPHASE { "benders/default/execfeasphase" }; @@ -144,6 +142,8 @@ namespace BRANCHING { constexpr Param DELAYPSCOSTUPDATE { "branching/delaypscostupdate" }; //! should pseudo costs be updated also in diving and probing mode? constexpr Param DIVINGPSCOST { "branching/divingpscost" }; + //! should ancestral pseudo costs be updated? + constexpr Param COLLECTANCPSCOST { "branching/collectancpscost" }; //! should all strong branching children be regarded even if one is detected to be infeasible? (only with //! propagation) constexpr Param FORCEALLCHILDREN { "branching/forceallchildren" }; @@ -433,6 +433,8 @@ namespace BRANCHING::PSCOST { constexpr Param NARYMINWIDTH { "branching/pscost/naryminwidth" }; //! factor of domain width in n-ary branching when creating nodes with increasing distance from branching value constexpr Param NARYWIDTHFACTOR { "branching/pscost/narywidthfactor" }; + //! discount factor for ancestral pseudo costs (0.0: disable discounted pseudo costs) + constexpr Param DISCOUNTFACTOR { "branching/pscost/discountfactor" }; } //! Parameters with prefix branching/random namespace BRANCHING::RANDOM { @@ -477,12 +479,18 @@ namespace BRANCHING::RELPSCOST { constexpr Param MAXRELIABLE { "branching/relpscost/maxreliable" }; //! maximal fraction of strong branching LP iterations compared to node relaxation LP iterations constexpr Param SBITERQUOT { "branching/relpscost/sbiterquot" }; + //! apply dynamic lookahead after this fraction maxlookahead is reached + constexpr Param DYNAMICLOOKAHEADQUOT { "branching/relpscost/dynamiclookaheadquot" }; //! additional number of allowed strong branching LP iterations constexpr Param SBITEROFS { "branching/relpscost/sbiterofs" }; //! maximal number of further variables evaluated without better score constexpr Param MAXLOOKAHEAD { "branching/relpscost/maxlookahead" }; + //! should we use a dynamic lookahead based on a tree size estimation of further strong branchings? + constexpr Param DYNAMICLOOKAHEAD { "branching/relpscost/dynamiclookahead" }; //! maximal number of candidates initialized with strong branching per node constexpr Param INITCAND { "branching/relpscost/initcand" }; + //! which distribution should be used for dynamic lookahead? 0=exponential, 1=Pareto, 2=log-normal? + constexpr Param DYNAMICLOOKDISTRIBUTION { "branching/relpscost/dynamiclookdistribution" }; //! iteration limit for strong branching initializations of pseudo cost entries (0: auto) constexpr Param INITITER { "branching/relpscost/inititer" }; //! maximal number of bound tightenings before the node is reevaluated (-1: unlimited) @@ -524,10 +532,14 @@ namespace BRANCHING::RELPSCOST { constexpr Param DEGENERACYAWARE { "branching/relpscost/degeneracyaware" }; //! start seed for random number generation constexpr Param STARTRANDSEED { "branching/relpscost/startrandseed" }; + //! minimum sample size to estimate the tree size for dynamic lookahead + constexpr Param MINSAMPLESIZE { "branching/relpscost/minsamplesize" }; //! Use symmetry to filter branching candidates? constexpr Param FILTERCANDSSYM { "branching/relpscost/filtercandssym" }; //! Transfer pscost information to symmetric variables? constexpr Param TRANSSYMPSCOST { "branching/relpscost/transsympscost" }; + //! discount factor for ancestral pseudo costs (0.0: disable discounted pseudo costs) + constexpr Param DISCOUNTFACTOR { "branching/relpscost/discountfactor" }; } //! Parameters with prefix branching/treemodel namespace BRANCHING::TREEMODEL { @@ -687,18 +699,26 @@ namespace CONFLICT { constexpr Param USELOCALROWS { "conflict/uselocalrows" }; //! should propagation conflict analysis be used? constexpr Param USEPROP { "conflict/useprop" }; + //! should generalized resolution conflict analysis be used? + constexpr Param USEGENRES { "conflict/usegenres" }; //! should infeasible LP conflict analysis be used? ('o'ff, 'c'onflict graph, 'd'ual ray, 'b'oth conflict graph and //! dual ray) constexpr Param USEINFLP { "conflict/useinflp" }; //! should bound exceeding LP conflict analysis be used? ('o'ff, 'c'onflict graph, 'd'ual ray, 'b'oth conflict graph //! and dual ray) constexpr Param USEBOUNDLP { "conflict/useboundlp" }; + //! which tightening reduction should be used? ('o'ff, 'm'ir) + constexpr Param REDUCTION { "conflict/reduction" }; + //! should apply the mixed binary reduction? + constexpr Param MBREDUCTION { "conflict/mbreduction" }; //! should infeasible/bound exceeding strong branching conflict analysis be used? constexpr Param USESB { "conflict/usesb" }; //! should pseudo solution conflict analysis be used? constexpr Param USEPSEUDO { "conflict/usepseudo" }; //! maximal fraction of variables involved in a conflict constraint constexpr Param MAXVARSFAC { "conflict/maxvarsfac" }; + //! maximal fraction of variables involved in a resolution conflict constraint + constexpr Param MAXVARSFRACRES { "conflict/maxvarsfracres" }; //! minimal absolute maximum of variables involved in a conflict constraint constexpr Param MINMAXVARS { "conflict/minmaxvars" }; //! maximal number of LP resolving loops during conflict analysis (-1: no limit) @@ -707,6 +727,8 @@ namespace CONFLICT { constexpr Param LPITERATIONS { "conflict/lpiterations" }; //! number of depth levels up to which first UIP's are used in conflict analysis (-1: use All-FirstUIP rule) constexpr Param FUIPLEVELS { "conflict/fuiplevels" }; + //! number of depth levels up to which first UIP's are used in conflict analysis (-1: use All-FirstUIP rule) + constexpr Param RESFUIPLEVELS { "conflict/resfuiplevels" }; //! maximal number of intermediate conflict constraints generated in conflict graph (-1: use every intermediate //! constraint) constexpr Param INTERCONSS { "conflict/interconss" }; @@ -736,6 +758,8 @@ namespace CONFLICT { constexpr Param DYNAMIC { "conflict/dynamic" }; //! should the conflict's relaxations be subject to LP aging and cleanup? constexpr Param REMOVABLE { "conflict/removable" }; + //! should we fix unresolvable bound changes and continue? + constexpr Param FIXANDCONTINUE { "conflict/fixandcontinue" }; //! score factor for impact on acticity in bound relaxation heuristic constexpr Param PROOFSCOREFAC { "conflict/proofscorefac" }; //! score factor for up locks in bound relaxation heuristic @@ -768,6 +792,8 @@ namespace CONFLICT { constexpr Param WEIGHTREPROPDEPTH { "conflict/weightrepropdepth" }; //! weight of the valid depth of a conflict used in score calculation constexpr Param WEIGHTVALIDDEPTH { "conflict/weightvaliddepth" }; + //! largest allowed quotient of max, min coefficient in a conflict constraint generated by generalized resolution + constexpr Param MAXCOEFQUOT { "conflict/maxcoefquot" }; //! apply cut generating functions to construct alternative proofs constexpr Param SEPAALTPROOFS { "conflict/sepaaltproofs" }; } @@ -841,7 +867,7 @@ namespace CONSTRAINTS::AND { constexpr Param ENFORCECUTS { "constraints/and/enforcecuts" }; //! should an aggregated linearization be used? constexpr Param AGGRLINEARIZATION { "constraints/and/aggrlinearization" }; - //! should all binary resultant variables be upgraded to implicit binary variables? + //! should implied integrality of resultant variables be detected? constexpr Param UPGRADERESULTANT { "constraints/and/upgraderesultant" }; //! should dual presolving be performed? constexpr Param DUALPRESOLVING { "constraints/and/dualpresolving" }; @@ -1054,6 +1080,8 @@ namespace CONSTRAINTS::CUMULATIVE { constexpr Param DELAYPROP { "constraints/cumulative/delayprop" }; //! timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) constexpr Param PRESOLTIMING { "constraints/cumulative/presoltiming" }; + //! maximum range for time horizon + constexpr Param MAXTIME { "constraints/cumulative/maxtime" }; //! should time-table (core-times) propagator be used to infer bounds? constexpr Param TTINFER { "constraints/cumulative/ttinfer" }; //! should edge-finding be used to detect an overload? @@ -1119,6 +1147,78 @@ namespace CONSTRAINTS::DISJUNCTION { //! alawys perform branching if one of the constraints is violated, otherwise only if all integers are fixed constexpr Param ALWAYSBRANCH { "constraints/disjunction/alwaysbranch" }; } +//! Parameters with prefix constraints/exactlinear +namespace CONSTRAINTS::EXACTLINEAR { + //! frequency for separating cuts (-1: never, 0: only in root node) + constexpr Param SEPAFREQ { "constraints/exactlinear/sepafreq" }; + //! frequency for propagating domains (-1: never, 0: only in root node) + constexpr Param PROPFREQ { "constraints/exactlinear/propfreq" }; + //! timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS) + constexpr Param PROPTIMING { "constraints/exactlinear/proptiming" }; + //! frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: + //! never, 0: only in first evaluation) + constexpr Param EAGERFREQ { "constraints/exactlinear/eagerfreq" }; + //! maximal number of presolving rounds the constraint handler participates in (-1: no limit) + constexpr Param MAXPREROUNDS { "constraints/exactlinear/maxprerounds" }; + //! should separation method be delayed, if other separators found cuts? + constexpr Param DELAYSEPA { "constraints/exactlinear/delaysepa" }; + //! should propagation method be delayed, if other propagators found reductions? + constexpr Param DELAYPROP { "constraints/exactlinear/delayprop" }; + //! timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) + constexpr Param PRESOLTIMING { "constraints/exactlinear/presoltiming" }; + //! multiplier on propagation frequency, how often the bounds are tightened (-1: never, 0: only at root) + constexpr Param TIGHTENBOUNDSFREQ { "constraints/exactlinear/tightenboundsfreq" }; + //! maximal number of separation rounds per node (-1: unlimited) + constexpr Param MAXROUNDS { "constraints/exactlinear/maxrounds" }; + //! maximal number of separation rounds per node in the root node (-1: unlimited) + constexpr Param MAXROUNDSROOT { "constraints/exactlinear/maxroundsroot" }; + //! maximal number of cuts separated per separation round + constexpr Param MAXSEPACUTS { "constraints/exactlinear/maxsepacuts" }; + //! maximal number of cuts separated per separation round in the root node + constexpr Param MAXSEPACUTSROOT { "constraints/exactlinear/maxsepacutsroot" }; + //! apply binaries sorting in decr. order of coeff abs value? + constexpr Param SORTVARS { "constraints/exactlinear/sortvars" }; + //! should bounds on continuous variables be tightened by propagation? + constexpr Param PROPCONT { "constraints/exactlinear/propcont" }; + //! should denominators of rational bounds on continuous variables be controlled? + constexpr Param LIMITDENOM { "constraints/exactlinear/limitdenom" }; + //! maximal denominator for rational bounds on continuous variables after propagation + constexpr Param BOUNDMAXDENOM { "constraints/exactlinear/boundmaxdenom" }; +} +//! Parameters with prefix constraints/exactsol +namespace CONSTRAINTS::EXACTSOL { + //! frequency for separating cuts (-1: never, 0: only in root node) + constexpr Param SEPAFREQ { "constraints/exactsol/sepafreq" }; + //! frequency for propagating domains (-1: never, 0: only in root node) + constexpr Param PROPFREQ { "constraints/exactsol/propfreq" }; + //! timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS) + constexpr Param PROPTIMING { "constraints/exactsol/proptiming" }; + //! frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: + //! never, 0: only in first evaluation) + constexpr Param EAGERFREQ { "constraints/exactsol/eagerfreq" }; + //! maximal number of presolving rounds the constraint handler participates in (-1: no limit) + constexpr Param MAXPREROUNDS { "constraints/exactsol/maxprerounds" }; + //! should separation method be delayed, if other separators found cuts? + constexpr Param DELAYSEPA { "constraints/exactsol/delaysepa" }; + //! should propagation method be delayed, if other propagators found reductions? + constexpr Param DELAYPROP { "constraints/exactsol/delayprop" }; + //! timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) + constexpr Param PRESOLTIMING { "constraints/exactsol/presoltiming" }; + //! should a solution be checked in floating-point arithmetic prior to being processed? + constexpr Param CHECKFPFEASIBILITY { "constraints/exactsol/checkfpfeasibility" }; + //! should integrality of continuous implied integral variables be ensured? + constexpr Param CHECKCONTIMPLINT { "constraints/exactsol/checkcontimplint" }; + //! fractionality of enforced integral value above which reparation is aborted + constexpr Param ABORTFRAC { "constraints/exactsol/abortfrac" }; + //! fractionality of weakly implied value up to which reparation fixes variable + constexpr Param UNFIXFRAC { "constraints/exactsol/unfixfrac" }; + //! maximal number of consecutive repair calls without success + constexpr Param MAXSTALLS { "constraints/exactsol/maxstalls" }; + //! size of solution buffer + constexpr Param SOLBUFSIZE { "constraints/exactsol/solbufsize" }; + //! minimal percentage of primal improvement to trigger solution processing + constexpr Param MINIMPROVE { "constraints/exactsol/minimprove" }; +} //! Parameters with prefix constraints/fixedvar namespace CONSTRAINTS::FIXEDVAR { //! frequency for separating cuts (-1: never, 0: only in root node) @@ -1544,7 +1644,7 @@ namespace CONSTRAINTS::NONLINEAR { //! whether tight linearizations of nonlinear constraints should be added to cutpool when some heuristics finds a //! new solution ('o'ff, on new 'i'ncumbents, on 'e'very solution) constexpr Param LINEARIZEHEURSOL { "constraints/nonlinear/linearizeheursol" }; - //! whether to assume that any constraint is convex + //! whether to assume that any constraint in the presolved problem is convex constexpr Param ASSUMECONVEX { "constraints/nonlinear/assumeconvex" }; } //! Parameters with prefix constraints/nonlinear/branching @@ -1641,31 +1741,49 @@ namespace CONSTRAINTS::ORBISACK { //! Whether orbisack constraints should be forced to be copied to sub SCIPs. constexpr Param FORCECONSCOPY { "constraints/orbisack/forceconscopy" }; } -//! Parameters with prefix constraints/orbitope -namespace CONSTRAINTS::ORBITOPE { +//! Parameters with prefix constraints/orbitope_full +namespace CONSTRAINTS::ORBITOPE_FULL { + //! frequency for separating cuts (-1: never, 0: only in root node) + constexpr Param SEPAFREQ { "constraints/orbitope_full/sepafreq" }; + //! frequency for propagating domains (-1: never, 0: only in root node) + constexpr Param PROPFREQ { "constraints/orbitope_full/propfreq" }; + //! timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS) + constexpr Param PROPTIMING { "constraints/orbitope_full/proptiming" }; + //! frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: + //! never, 0: only in first evaluation) + constexpr Param EAGERFREQ { "constraints/orbitope_full/eagerfreq" }; + //! maximal number of presolving rounds the constraint handler participates in (-1: no limit) + constexpr Param MAXPREROUNDS { "constraints/orbitope_full/maxprerounds" }; + //! should separation method be delayed, if other separators found cuts? + constexpr Param DELAYSEPA { "constraints/orbitope_full/delaysepa" }; + //! should propagation method be delayed, if other propagators found reductions? + constexpr Param DELAYPROP { "constraints/orbitope_full/delayprop" }; + //! timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) + constexpr Param PRESOLTIMING { "constraints/orbitope_full/presoltiming" }; + //! Whether orbitope constraints should be forced to be copied to sub SCIPs. + constexpr Param FORCECONSCOPY { "constraints/orbitope_full/forceconscopy" }; +} +//! Parameters with prefix constraints/orbitope_pp +namespace CONSTRAINTS::ORBITOPE_PP { //! frequency for separating cuts (-1: never, 0: only in root node) - constexpr Param SEPAFREQ { "constraints/orbitope/sepafreq" }; + constexpr Param SEPAFREQ { "constraints/orbitope_pp/sepafreq" }; //! frequency for propagating domains (-1: never, 0: only in root node) - constexpr Param PROPFREQ { "constraints/orbitope/propfreq" }; + constexpr Param PROPFREQ { "constraints/orbitope_pp/propfreq" }; //! timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS) - constexpr Param PROPTIMING { "constraints/orbitope/proptiming" }; + constexpr Param PROPTIMING { "constraints/orbitope_pp/proptiming" }; //! frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: //! never, 0: only in first evaluation) - constexpr Param EAGERFREQ { "constraints/orbitope/eagerfreq" }; + constexpr Param EAGERFREQ { "constraints/orbitope_pp/eagerfreq" }; //! maximal number of presolving rounds the constraint handler participates in (-1: no limit) - constexpr Param MAXPREROUNDS { "constraints/orbitope/maxprerounds" }; + constexpr Param MAXPREROUNDS { "constraints/orbitope_pp/maxprerounds" }; //! should separation method be delayed, if other separators found cuts? - constexpr Param DELAYSEPA { "constraints/orbitope/delaysepa" }; + constexpr Param DELAYSEPA { "constraints/orbitope_pp/delaysepa" }; //! should propagation method be delayed, if other propagators found reductions? - constexpr Param DELAYPROP { "constraints/orbitope/delayprop" }; + constexpr Param DELAYPROP { "constraints/orbitope_pp/delayprop" }; //! timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) - constexpr Param PRESOLTIMING { "constraints/orbitope/presoltiming" }; - //! Strengthen orbitope constraints to packing/partioning orbitopes? - constexpr Param CHECKPPORBITOPE { "constraints/orbitope/checkpporbitope" }; - //! Whether we separate inequalities for full orbitopes? - constexpr Param SEPAFULLORBITOPE { "constraints/orbitope/sepafullorbitope" }; + constexpr Param PRESOLTIMING { "constraints/orbitope_pp/presoltiming" }; //! Whether orbitope constraints should be forced to be copied to sub SCIPs. - constexpr Param FORCECONSCOPY { "constraints/orbitope/forceconscopy" }; + constexpr Param FORCECONSCOPY { "constraints/orbitope_pp/forceconscopy" }; } //! Parameters with prefix constraints/pseudoboolean namespace CONSTRAINTS::PSEUDOBOOLEAN { @@ -2954,6 +3072,55 @@ namespace HEURISTICS::DISTRIBUTIONDIVING { //! highest c.p.('w'), 'r'evolving constexpr Param SCOREPARAM { "heuristics/distributiondiving/scoreparam" }; } +//! Parameters with prefix heuristics/dks +namespace HEURISTICS::DKS { + //! priority of heuristic \ + constexpr Param PRIORITY { "heuristics/dks/priority" }; + //! frequency for calling primal heuristic \ (-1: never, 0: only at depth freqofs) + constexpr Param FREQ { "heuristics/dks/freq" }; + //! frequency offset for calling primal heuristic \ + constexpr Param FREQOFS { "heuristics/dks/freqofs" }; + //! maximal depth level to call primal heuristic \ (-1: no limit) + constexpr Param MAXDEPTH { "heuristics/dks/maxdepth" }; + //! maximal number of buckets to be investigated + constexpr Param MAXBUCKS { "heuristics/dks/maxbucks" }; + //! factor with which the initial kernel size can grow max + constexpr Param KERNELSIZEFACTOR { "heuristics/dks/kernelsizefactor" }; + //! should a constraint be added ensuring that bucket variables are used? + constexpr Param ADDUSECONSS { "heuristics/dks/addUseConss" }; + //! should the linking variables in the kernel influence the size of the buckets? + constexpr Param LINKBUCKSIZE { "heuristics/dks/linkbucksize" }; + //! should a variable with different lower bound in transformed and original problem be in the kernel? + constexpr Param TRANSLBKERNEL { "heuristics/dks/translbkernel" }; + //! should a variable with max one uplock and one downlock be in the kernel? + constexpr Param LESSLOCKSKERNEL { "heuristics/dks/lesslockskernel" }; + //! should dks use the transformed problem? + constexpr Param USETRANSPROB { "heuristics/dks/usetransprob" }; + //! defines the maximum mipgap a bucket can be solved to + constexpr Param BUCKMAXGAP { "heuristics/dks/buckmaxgap" }; + //! defines a bound to the linkscore of the decomp + constexpr Param MAXLINKSCORE { "heuristics/dks/maxlinkscore" }; + //! defines a maximal share of bin/int variables for a bucket to be respected + constexpr Param MAXBUCKFRAC { "heuristics/dks/maxbuckfrac" }; + //! maximum number of nodes to regard in all subproblems + constexpr Param MAXNODES { "heuristics/dks/maxnodes" }; + //! should a two level bucket structure be used if possible? + constexpr Param USETWOLEVEL { "heuristics/dks/usetwolevel" }; + //! should a decomposition be used if given? + constexpr Param USEDECOMP { "heuristics/dks/usedecomp" }; + //! should the best solution instead of the LP solution be used? + constexpr Param USEBESTSOL { "heuristics/dks/usebestsol" }; + //! should the bucket variables be sorted by reduced costs in the LP solution? + constexpr Param REDCOSTSORT { "heuristics/dks/redcostsort" }; + //! should the heuristic terminate after the first primal solution is found? + constexpr Param PRIMALONLY { "heuristics/dks/primalonly" }; + //! should the bucket variables be sorted logarithmically by reduced costs in the LP solution? + constexpr Param REDCOSTLOGSORT { "heuristics/dks/redcostlogsort" }; + //! should the next solution at least satisfy the old objective? + constexpr Param OBJCUTOFF { "heuristics/dks/objcutoff" }; + //! should the heuristic be used only for binary problems or problems with integer and binary variables? + constexpr Param RUNBINPROBSONLY { "heuristics/dks/runbinprobsonly" }; +} //! Parameters with prefix heuristics/dps namespace HEURISTICS::DPS { //! priority of heuristic \ @@ -4128,8 +4295,6 @@ namespace HEURISTICS::SCHEDULER { constexpr Param FIXTOL { "heuristics/scheduler/fixtol" }; //! tolerance by which the fixing rate may be exceeded without generic unfixing constexpr Param UNFIXTOL { "heuristics/scheduler/unfixtol" }; - //! time limit for a single heuristic run - constexpr Param HEURTIMELIMIT { "heuristics/scheduler/heurtimelimit" }; //! should the heuristic be executed multiple times during the root node? constexpr Param INITDURINGROOT { "heuristics/scheduler/initduringroot" }; //! should the default priorities be used at the root node? @@ -4654,6 +4819,55 @@ namespace HISTORY { //! should variable histories be transferred to initialize SCIP copies? constexpr Param ALLOWTRANSFER { "history/allowtransfer" }; } +//! Parameters with prefix iis +namespace IIS { + //! should the resultant infeasible set be irreducible, i.e., an IIS not an IS + constexpr Param IRREDUCIBLE { "iis/irreducible" }; + //! should bounds of the problem be considered for removal + constexpr Param REMOVEBOUNDS { "iis/removebounds" }; + //! should the IIS finders be run silently and output suppressed + constexpr Param SILENT { "iis/silent" }; + //! should the IIS search stop after a single IIS finder is run (excluding post processing) + constexpr Param STOPAFTERONE { "iis/stopafterone" }; + //! should vars that do not feature in any constraints be removed at the end of the IIS process + constexpr Param REMOVEUNUSEDVARS { "iis/removeunusedvars" }; + //! maximal time in seconds for all IIS finders to run + constexpr Param TIME { "iis/time" }; + //! maximal number of nodes to process for all IIS finders (-1: no limit) + constexpr Param NODES { "iis/nodes" }; +} +//! Parameters with prefix iis/greedy +namespace IIS::GREEDY { + //! priority of iis generation rule \ + constexpr Param PRIORITY { "iis/greedy/priority" }; + //! time limit of optimization process for each individual subproblem + constexpr Param TIMELIMPERITER { "iis/greedy/timelimperiter" }; + //! node limit of optimization process for each individual subproblem + constexpr Param NODELIMPERITER { "iis/greedy/nodelimperiter" }; + //! should an additive constraint approach be used instead of deletion + constexpr Param ADDITIVE { "iis/greedy/additive" }; + //! should an unsolved problem (by e.g. user interrupt, node limit, time limit) be considered feasible when deleting + //! constraints + constexpr Param CONSERVATIVE { "iis/greedy/conservative" }; + //! should the deletion routine be performed after the addition routine (in the case of additive) + constexpr Param DELAFTERADD { "iis/greedy/delafteradd" }; + //! should satisfied constraints outside the batch of an intermediate solve be added during the additive method + constexpr Param DYNAMICREORDERING { "iis/greedy/dynamicreordering" }; + //! the initial batchsize for the first iteration, ignored if initrelbatchsize is positive + constexpr Param INITBATCHSIZE { "iis/greedy/initbatchsize" }; + //! the initial batchsize relative to the original problem for the first iteration (0.0: use initbatchsize) + constexpr Param INITRELBATCHSIZE { "iis/greedy/initrelbatchsize" }; + //! the maximum batchsize per iteration + constexpr Param MAXBATCHSIZE { "iis/greedy/maxbatchsize" }; + //! the maximum batchsize relative to the original problem per iteration + constexpr Param MAXRELBATCHSIZE { "iis/greedy/maxrelbatchsize" }; + //! the factor with which the batchsize is multiplied in every update + constexpr Param BATCHINGFACTOR { "iis/greedy/batchingfactor" }; + //! the offset which is added to the multiplied batchsize in every update + constexpr Param BATCHINGOFFSET { "iis/greedy/batchingoffset" }; + //! the number of iterations to run with a constant batchsize before updating (1: always update) + constexpr Param BATCHUPDATEINTERVAL { "iis/greedy/batchupdateinterval" }; +} //! Parameters with prefix limits namespace LIMITS { //! maximal time in seconds to run @@ -4672,7 +4886,7 @@ namespace LIMITS { constexpr Param GAP { "limits/gap" }; //! solving stops, if the absolute gap = |primalbound - dualbound| is below the given value constexpr Param ABSGAP { "limits/absgap" }; - //! solving stops, if primal bound is at least as good as given value (alias objectivestop) + //! solving stops, if primal bound is at least as good as given value constexpr Param PRIMAL { "limits/primal" }; //! solving stops, if dual bound is at least as good as given value constexpr Param DUAL { "limits/dual" }; @@ -4703,6 +4917,8 @@ namespace LP { constexpr Param ROOTITERLIM { "lp/rootiterlim" }; //! maximal depth for solving LP at the nodes (-1: no depth limit) constexpr Param SOLVEDEPTH { "lp/solvedepth" }; + //! minimal depth for solving LP at the nodes + constexpr Param MINSOLVEDEPTH { "lp/minsolvedepth" }; //! LP algorithm for solving initial LP relaxations (automatic 's'implex, 'p'rimal simplex, 'd'ual simplex, //! 'b'arrier, barrier with 'c'rossover) constexpr Param INITALGORITHM { "lp/initalgorithm" }; @@ -4835,10 +5051,11 @@ namespace MISC { constexpr Param SHOWDIVINGSTATS { "misc/showdivingstats" }; //! objective value for reference purposes constexpr Param REFERENCEVALUE { "misc/referencevalue" }; - //! bitset describing used symmetry handling technique: (0: off; 1: constraint-based (orbitopes and/or symresacks); - //! 2: orbital fixing; 3: orbitopes and orbital fixing; 4: Schreier Sims cuts; 5: Schreier Sims cuts and orbitopes; - //! 6: Schreier Sims cuts and orbital fixing; 7: Schreier Sims cuts, orbitopes, and orbital fixing) See - //! type_symmetry.h. + //! bitset describing used symmetry handling technique: (0: off; 1: constraint-based (orbitopes, symresacks); + //! lexicographic and orbitopal reduction) if dynamic; 2: orbital reduction; 3: orbitopes and symresacks, and + //! lexicographic/orbital reduction; 4: Schreier Sims cuts; 5: Schreier Sims cuts, orbitopes, symresacks, and/or + //! lexicographic reduction; 6: Schreier Sims cuts, orbital reduction; 7: Schreier Sims cuts, orbitopes, symresacks, + //! and/or lexicographic/orbital reduction;) See type_symmetry.h. constexpr Param USESYMMETRY { "misc/usesymmetry" }; } //! Parameters with prefix nlhdlr/bilinear @@ -5290,6 +5507,22 @@ namespace PRESOLVING::IMPLICS { //! timing mask of presolver \ (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) constexpr Param TIMING { "presolving/implics/timing" }; } +//! Parameters with prefix presolving/implint +namespace PRESOLVING::IMPLINT { + //! priority of presolver \ + constexpr Param PRIORITY { "presolving/implint/priority" }; + //! maximal number of presolving rounds the presolver participates in (-1: no limit) + constexpr Param MAXROUNDS { "presolving/implint/maxrounds" }; + //! timing mask of presolver \ (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) + constexpr Param TIMING { "presolving/implint/timing" }; + //! should implied integrality also be detected for enforced integral variables? + constexpr Param CONVERTINTEGERS { "presolving/implint/convertintegers" }; + //! use the network row addition algorithm when the column to row ratio becomes larger than this threshold + constexpr Param COLUMNROWRATIO { "presolving/implint/columnrowratio" }; + //! a row that contains variables with coefficients that are greater in absolute value than this limit is not + //! considered for implied integrality detection + constexpr Param NUMERICSLIMIT { "presolving/implint/numericslimit" }; +} //! Parameters with prefix presolving/inttobinary namespace PRESOLVING::INTTOBINARY { //! priority of presolver \ @@ -5702,6 +5935,8 @@ namespace PROPAGATING::SYMMETRY { constexpr Param DISPLAYNORBITVARS { "propagating/symmetry/displaynorbitvars" }; //! Double equations to positive/negative version? constexpr Param DOUBLEEQUATIONS { "propagating/symmetry/doubleequations" }; + //! Shall symmetry information be printed to the terminal? + constexpr Param DISPSYMINFO { "propagating/symmetry/dispsyminfo" }; //! Should the symmetry breaking constraints be added to the LP? constexpr Param CONSSADDLP { "propagating/symmetry/conssaddlp" }; //! Add inequalities for symresacks for each generator? @@ -5741,8 +5976,8 @@ namespace PROPAGATING::SYMMETRY { constexpr Param SSTTIEBREAKRULE { "propagating/symmetry/ssttiebreakrule" }; //! rule to select the leader in an orbit (0: first var; 1: last var; 2: var having most conflicting vars in orbit) constexpr Param SSTLEADERRULE { "propagating/symmetry/sstleaderrule" }; - //! bitset encoding which variable types can be leaders (1: binary; 2: integer; 4: impl. int; 8: continuous);if - //! multiple types are allowed, take the one with most affected vars + //! bitset encoding which variable types can be leaders (1: binary; 2: integer; 4: continuous);if multiple types are + //! allowed, take the one with most affected vars constexpr Param SSTLEADERVARTYPE { "propagating/symmetry/sstleadervartype" }; //! Should Schreier Sims constraints be added if we use a conflict based rule? constexpr Param ADDCONFLICTCUTS { "propagating/symmetry/addconflictcuts" }; @@ -5758,12 +5993,17 @@ namespace PROPAGATING::SYMMETRY { constexpr Param PREFERLESSROWS { "propagating/symmetry/preferlessrows" }; //! Type of symmetries that shall be computed? constexpr Param SYMTYPE { "propagating/symmetry/symtype" }; + //! Should orbitopes on which proper signed permutations act be handled? + constexpr Param HANDLESIGNEDORBITOPES { "propagating/symmetry/handlesignedorbitopes" }; + //! Should components consisting of a single full reflection be handled? + constexpr Param USESIMPLESGNCOMP { "propagating/symmetry/usesimplesgncomp" }; //! timing of symmetry computation and handling (0 = before presolving, 1 = during presolving, 2 = after presolving) constexpr Param SYMTIMING { "propagating/symmetry/symtiming" }; - //! terminate symmetry detection using Nauty when number of cells in color refinment is at least this number - constexpr Param NAUTYMAXNCELLS { "propagating/symmetry/nautymaxncells" }; - //! terminate symmetry detection using Nauty when its search tree has at least this number of nodes - constexpr Param NAUTYMAXNNODES { "propagating/symmetry/nautymaxnnodes" }; + //! maximum number of newly generated involutions per symmetry component + constexpr Param MAXNNEWIVOLUS { "propagating/symmetry/maxnnewivolus" }; + //! terminate symmetry detection using Nauty when depth level of Nauty's search tree exceeds this number (-1: + //! unlimited) + constexpr Param NAUTYMAXLEVEL { "propagating/symmetry/nautymaxlevel" }; } //! Parameters with prefix propagating/symmetry/orbitopalreduction namespace PROPAGATING::SYMMETRY::ORBITOPALREDUCTION { @@ -5811,6 +6051,9 @@ namespace PROPAGATING::VBOUNDS { namespace RANDOMIZATION { //! global shift of all random seeds in the plugins and the LP random seed constexpr Param RANDOMSEEDSHIFT { "randomization/randomseedshift" }; + //! multiplier for global shift of all random seeds in the plugins and the LP random seed; this multiplier will be + //! changed with every SCIP major release + constexpr Param RANDOMSEEDSHIFTMULTIPLIER { "randomization/randomseedshiftmultiplier" }; //! seed value for permuting the problem after reading/transformation (0: no permutation) constexpr Param PERMUTATIONSEED { "randomization/permutationseed" }; //! should order of constraints be permuted (depends on permutationseed)? @@ -5854,8 +6097,6 @@ namespace READING::GMSREADER { constexpr Param BIGMDEFAULT { "reading/gmsreader/bigmdefault" }; //! which reformulation to use for indicator constraints: 'b'ig-M, 's'os1 constexpr Param INDICATORREFORM { "reading/gmsreader/indicatorreform" }; - //! is it allowed to use the gams function signpower(x,a)? - constexpr Param SIGNPOWER { "reading/gmsreader/signpower" }; } //! Parameters with prefix reading/lpreader namespace READING::LPREADER { @@ -5871,12 +6112,22 @@ namespace READING::MPSREADER { //! should an aggregated linearization for and constraints be used? constexpr Param AGGRLINEARIZATION_ANDS { "reading/mpsreader/aggrlinearization-ands" }; } +//! Parameters with prefix reading/nlreader +namespace READING::NLREADER { + //! should nl files be written in binary format + constexpr Param BINARY { "reading/nlreader/binary" }; + //! should comments be written to nl files + constexpr Param COMMENTS { "reading/nlreader/comments" }; +} //! Parameters with prefix reading/opbreader namespace READING::OPBREADER { //! should model constraints be subject to aging? constexpr Param DYNAMICCONSS { "reading/opbreader/dynamicconss" }; //! use '*' between coefficients and variables by writing to problem? constexpr Param MULTISYMBOL { "reading/opbreader/multisymbol" }; + //! maximum allowed 'intsize' (i.e. the number of bits required to represent the sum of absolute values of all + //! integers that appear in a constraint or objective function) or -1 for unlimited + constexpr Param MAXINTSIZE { "reading/opbreader/maxintsize" }; } //! Parameters with prefix reading/pbmreader namespace READING::PBMREADER { @@ -5903,6 +6154,18 @@ namespace READING::STOREADER { //! should Benders' decomposition be used? constexpr Param USEBENDERS { "reading/storeader/usebenders" }; } +//! Parameters with prefix relaxing/benders +namespace RELAXING::BENDERS { + //! priority of relaxation handler \ + constexpr Param PRIORITY { "relaxing/benders/priority" }; + //! frequency for calling relaxation handler \ (-1: never, 0: only in root node) + constexpr Param FREQ { "relaxing/benders/freq" }; + //! continue solving the original SCIP instance if the optimal solution is not found by Benders' decomposition + constexpr Param CONTINUEORIG { "relaxing/benders/continueorig" }; + //! the node limit applied only to the Benders' decomposition solve (-1 indicates that the original SCIP node limit + //! is used). + constexpr Param NODELIMIT { "relaxing/benders/nodelimit" }; +} //! Parameters with prefix reoptimization namespace REOPTIMIZATION { //! should reoptimization used? @@ -6351,6 +6614,39 @@ namespace SEPARATING::FLOWCOVER { //! of frequency) constexpr Param EXPBACKOFF { "separating/flowcover/expbackoff" }; } +//! Parameters with prefix separating/flower +namespace SEPARATING::FLOWER { + //! priority of separator \ + constexpr Param PRIORITY { "separating/flower/priority" }; + //! frequency for calling separator \ (-1: never, 0: only in root node) + constexpr Param FREQ { "separating/flower/freq" }; + //! maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for + //! applying separator \ (0.0: only on current best node, 1.0: on all nodes) + constexpr Param MAXBOUNDDIST { "separating/flower/maxbounddist" }; + //! should separator be delayed, if other separators found cuts? + constexpr Param DELAY { "separating/flower/delay" }; + //! base for exponential increase of frequency at which separator \ is called (1: call at each multiple of + //! frequency) + constexpr Param EXPBACKOFF { "separating/flower/expbackoff" }; + //! Whether to scan AND constraints when constructing hypergraph + constexpr Param SCANAND { "separating/flower/scanand" }; + //! Whether to scan product expressions when constructing hypergraph + constexpr Param SCANPRODUCT { "separating/flower/scanproduct" }; + //! Maximum number of standard relaxation inequalities per cut round + constexpr Param MAXSTANDARD { "separating/flower/maxstandard" }; + //! Maximum number of 1-flower inequalities per cut round + constexpr Param MAXONEFLOWER { "separating/flower/maxoneflower" }; + //! Maximum number of 2-flower inequalities per cut round + constexpr Param MAXTWOFLOWER { "separating/flower/maxtwoflower" }; + //! Minimum number of overlaps necessary to try separation + constexpr Param MINNOVERLAPS { "separating/flower/minnoverlaps" }; + //! Whether to only generate standard inequalities if also flowers were generated + constexpr Param DELAYSTANDARD { "separating/flower/delaystandard" }; + //! Number of useless separation rounds after which we stop separating 1-flowers + constexpr Param MAXUSELESSONEFLOWER { "separating/flower/maxuselessoneflower" }; + //! Number of useless separation rounds after which we stop separating 2-flowers + constexpr Param MAXUSELESSTWOFLOWER { "separating/flower/maxuselesstwoflower" }; +} //! Parameters with prefix separating/gauge namespace SEPARATING::GAUGE { //! priority of separator \ @@ -7216,6 +7512,10 @@ namespace WRITE { constexpr Param PRINTZEROS { "write/printzeros" }; //! when writing a generic problem the index for the first variable should start with? constexpr Param GENERICNAMESOFFSET { "write/genericnamesoffset" }; + //! should integrality constraints (i.c.) be written for implied integral variables? (0: use original i.c., 1: add + //! i.c. to strongly implied integral vars, 2: add i.c. to all implied integral vars, -1: remove i.c. from strongly + //! implied integral vars, -2: remove i.c. from all implied integral vars) + constexpr Param IMPLINTLEVEL { "write/implintlevel" }; } // NOLINTEND(readability-identifier-naming)