diff --git a/.clang-format b/.clang-format index 283961b4..1dd236cb 100644 --- a/.clang-format +++ b/.clang-format @@ -1,216 +1,3 @@ --- Language: Cpp -# BasedOnStyle: WebKit -AccessModifierOffset: -4 -AlignAfterOpenBracket: DontAlign -AlignArrayOfStructures: None -AlignConsecutiveAssignments: - Enabled: false - AcrossEmptyLines: false - AcrossComments: false - AlignCompound: false - PadOperators: true -AlignConsecutiveBitFields: - Enabled: false - AcrossEmptyLines: false - AcrossComments: false - AlignCompound: false - PadOperators: false -AlignConsecutiveDeclarations: - Enabled: false - AcrossEmptyLines: false - AcrossComments: false - AlignCompound: false - PadOperators: false -AlignConsecutiveMacros: - Enabled: false - AcrossEmptyLines: false - AcrossComments: false - AlignCompound: false - PadOperators: false -AlignEscapedNewlines: Right -AlignOperands: DontAlign -AlignTrailingComments: false -AllowAllArgumentsOnNextLine: true -AllowAllParametersOfDeclarationOnNextLine: true -AllowShortEnumsOnASingleLine: true -AllowShortBlocksOnASingleLine: Empty -AllowShortCaseLabelsOnASingleLine: false -AllowShortFunctionsOnASingleLine: All -AllowShortLambdasOnASingleLine: All -AllowShortIfStatementsOnASingleLine: Never -AllowShortLoopsOnASingleLine: false -AlwaysBreakAfterDefinitionReturnType: None -AlwaysBreakAfterReturnType: None -AlwaysBreakBeforeMultilineStrings: false -AlwaysBreakTemplateDeclarations: MultiLine -AttributeMacros: - - __capability -BinPackArguments: true -BinPackParameters: true -BraceWrapping: - AfterCaseLabel: false - AfterClass: false - AfterControlStatement: Never - AfterEnum: false - AfterFunction: true - AfterNamespace: false - AfterObjCDeclaration: false - AfterStruct: false - AfterUnion: false - AfterExternBlock: false - BeforeCatch: false - BeforeElse: false - BeforeLambdaBody: false - BeforeWhile: false - IndentBraces: false - SplitEmptyFunction: true - SplitEmptyRecord: true - SplitEmptyNamespace: true -BreakBeforeBinaryOperators: All -BreakBeforeConceptDeclarations: Always -BreakBeforeBraces: WebKit -BreakBeforeInheritanceComma: false -BreakInheritanceList: BeforeColon -BreakBeforeTernaryOperators: true -BreakConstructorInitializersBeforeComma: false -BreakConstructorInitializers: BeforeComma -BreakAfterJavaFieldAnnotations: false -BreakStringLiterals: true -ColumnLimit: 0 -CommentPragmas: '^ IWYU pragma:' -QualifierAlignment: Leave -CompactNamespaces: false -ConstructorInitializerIndentWidth: 4 -ContinuationIndentWidth: 4 -Cpp11BracedListStyle: false -DeriveLineEnding: true -DerivePointerAlignment: false -DisableFormat: false -EmptyLineAfterAccessModifier: Never -EmptyLineBeforeAccessModifier: LogicalBlock -ExperimentalAutoDetectBinPacking: false -PackConstructorInitializers: BinPack -BasedOnStyle: '' -ConstructorInitializerAllOnOneLineOrOnePerLine: false -AllowAllConstructorInitializersOnNextLine: true -FixNamespaceComments: false -ForEachMacros: - - foreach - - Q_FOREACH - - BOOST_FOREACH -IfMacros: - - KJ_IF_MAYBE -IncludeBlocks: Preserve -IncludeCategories: - - Regex: '^"(llvm|llvm-c|clang|clang-c)/' - Priority: 2 - SortPriority: 0 - CaseSensitive: false - - Regex: '^(<|"(gtest|gmock|isl|json)/)' - Priority: 3 - SortPriority: 0 - CaseSensitive: false - - Regex: '.*' - Priority: 1 - SortPriority: 0 - CaseSensitive: false -IncludeIsMainRegex: '(Test)?$' -IncludeIsMainSourceRegex: '' -IndentAccessModifiers: false -IndentCaseLabels: false -IndentCaseBlocks: false -IndentGotoLabels: true -IndentPPDirectives: None -IndentExternBlock: AfterExternBlock -IndentRequiresClause: true -IndentWidth: 4 -IndentWrappedFunctionNames: false -InsertBraces: false -InsertTrailingCommas: None -JavaScriptQuotes: Leave -JavaScriptWrapImports: true -KeepEmptyLinesAtTheStartOfBlocks: true -LambdaBodyIndentation: Signature -MacroBlockBegin: '' -MacroBlockEnd: '' -MaxEmptyLinesToKeep: 1 -NamespaceIndentation: Inner -ObjCBinPackProtocolList: Auto -ObjCBlockIndentWidth: 4 -ObjCBreakBeforeNestedBlockParam: true -ObjCSpaceAfterProperty: true -ObjCSpaceBeforeProtocolList: true -PenaltyBreakAssignment: 2 -PenaltyBreakBeforeFirstCallParameter: 19 -PenaltyBreakComment: 300 -PenaltyBreakFirstLessLess: 120 -PenaltyBreakOpenParenthesis: 0 -PenaltyBreakString: 1000 -PenaltyBreakTemplateDeclaration: 10 -PenaltyExcessCharacter: 1000000 -PenaltyReturnTypeOnItsOwnLine: 60 -PenaltyIndentedWhitespace: 0 -PointerAlignment: Left -PPIndentWidth: -1 -ReferenceAlignment: Pointer -ReflowComments: true -RemoveBracesLLVM: false -RequiresClausePosition: OwnLine -SeparateDefinitionBlocks: Leave -ShortNamespaceLines: 1 -SortIncludes: CaseSensitive -SortJavaStaticImport: Before -SortUsingDeclarations: true -SpaceAfterCStyleCast: false -SpaceAfterLogicalNot: false -SpaceAfterTemplateKeyword: true -SpaceBeforeAssignmentOperators: true -SpaceBeforeCaseColon: false -SpaceBeforeCpp11BracedList: true -SpaceBeforeCtorInitializerColon: true -SpaceBeforeInheritanceColon: true -SpaceBeforeParens: ControlStatements -SpaceBeforeParensOptions: - AfterControlStatements: true - AfterForeachMacros: true - AfterFunctionDefinitionName: false - AfterFunctionDeclarationName: false - AfterIfMacros: true - AfterOverloadedOperator: false - AfterRequiresInClause: false - AfterRequiresInExpression: false - BeforeNonEmptyParentheses: false -SpaceAroundPointerQualifiers: Default -SpaceBeforeRangeBasedForLoopColon: true -SpaceInEmptyBlock: true -SpaceInEmptyParentheses: false -SpacesBeforeTrailingComments: 1 -SpacesInAngles: Never -SpacesInConditionalStatement: false -SpacesInContainerLiterals: true -SpacesInCStyleCastParentheses: false -SpacesInLineCommentPrefix: - Minimum: 1 - Maximum: -1 -SpacesInParentheses: false -SpacesInSquareBrackets: false -SpaceBeforeSquareBrackets: false -BitFieldColonSpacing: Both -Standard: c++17 -StatementAttributeLikeMacros: - - Q_EMIT -StatementMacros: - - Q_UNUSED - - QT_REQUIRE_VERSION -TabWidth: 8 -UseCRLF: false -UseTab: Never -WhitespaceSensitiveMacros: - - STRINGIZE - - PP_STRINGIZE - - BOOST_PP_STRINGIZE - - NS_SWIFT_NAME - - CF_SWIFT_NAME -... - +BasedOnStyle: WebKit diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 3ff5330a..6a2c02b1 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -65,9 +65,9 @@ jobs: boost_version: 1.84.0 - name: Install SCIP run: | - wget https://github.com/scipopt/scip/releases/download/v901/SCIPOptSuite-9.0.1-Linux-ubuntu22.sh - chmod +x SCIPOptSuite-9.0.1-Linux-ubuntu22.sh - ./SCIPOptSuite-9.0.1-Linux-ubuntu22.sh --skip-license + wget https://github.com/scipopt/scip/releases/download/v920/SCIPOptSuite-9.2.0-Linux-ubuntu22.sh + chmod +x SCIPOptSuite-9.2.0-Linux-ubuntu22.sh + ./SCIPOptSuite-9.2.0-Linux-ubuntu22.sh --skip-license - name: Build SCIP++ run: | CMAKE_PREFIX_PATH=./lib/cmake/scip:./boost/boost/lib/cmake/Boost-1.84.0 cmake -DBUILD_TESTS=ON . @@ -77,7 +77,7 @@ jobs: test_release_inx: strategy: matrix: - os: [ ubuntu-latest, macos-11 ] + os: [ ubuntu-latest, macos-13 ] runs-on: ${{ matrix.os }} steps: - uses: actions/checkout@v3 @@ -88,7 +88,7 @@ jobs: pushd ~/.conan2/profiles sed -i'' -e 's/gnu17/17/g' * popd - conan install -of . -o with_tests=True . + conan install -of . -o with_tests=True --build=missing . - name: Run CMake run: cmake --preset conan-release . - name: Compile @@ -119,14 +119,14 @@ jobs: with: source: source include test extensions: 'hpp,cpp' - clangFormatVersion: 16 + clangFormatVersion: 17 doxygen: runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 - uses: ssciwr/doxygen-install@v1 with: - version: "1.10.0" + version: "1.12.0" - uses: ts-graphviz/setup-graphviz@v1 - name: Prepare Doxygen Config run: echo "PROJECT_NUMBER = ${GITHUB_REF}" >> Doxyfile @@ -135,7 +135,7 @@ jobs: - name: Zip HTML Docu run: zip -q -9 -r html.zip html - name: Store HTML Docu - uses: actions/upload-artifact@v3 + uses: actions/upload-artifact@v4 with: name: doxygen-html path: html.zip diff --git a/.github/workflows/pages.yml b/.github/workflows/pages.yml index c94b4b18..5d6283b2 100644 --- a/.github/workflows/pages.yml +++ b/.github/workflows/pages.yml @@ -11,7 +11,7 @@ jobs: - uses: actions/checkout@v3 - uses: ssciwr/doxygen-install@v1 with: - version: "1.9.6" + version: "1.20.0" - uses: ts-graphviz/setup-graphviz@v1 - name: Prepare Doxygen Config run: echo "PROJECT_NUMBER = ${GITHUB_REF}" >> Doxyfile diff --git a/.gitignore b/.gitignore index 035b34f6..e2eea20f 100644 --- a/.gitignore +++ b/.gitignore @@ -10,3 +10,6 @@ build # CMake presets generated by Conan CMakeUserPresets.json + +# CLion IDE files (seem to store local (non-shareable) settings since Nova is out) +**/.idea diff --git a/.idea/.gitignore b/.idea/.gitignore deleted file mode 100644 index 180445c3..00000000 --- a/.idea/.gitignore +++ /dev/null @@ -1,6 +0,0 @@ -# Default ignored files -/shelf/ -/workspace.xml -# Editor-based HTTP Client requests -/httpRequests/ -sonarlint diff --git a/.idea/.name b/.idea/.name deleted file mode 100644 index 65f4a7aa..00000000 --- a/.idea/.name +++ /dev/null @@ -1 +0,0 @@ -SCIP++ diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml deleted file mode 100644 index f285367e..00000000 --- a/.idea/codeStyles/Project.xml +++ /dev/null @@ -1,15 +0,0 @@ - - - - \ No newline at end of file diff --git a/.idea/codeStyles/codeStyleConfig.xml b/.idea/codeStyles/codeStyleConfig.xml deleted file mode 100644 index 79ee123c..00000000 --- a/.idea/codeStyles/codeStyleConfig.xml +++ /dev/null @@ -1,5 +0,0 @@ - - - - \ No newline at end of file diff --git a/.idea/jsonSchemas.xml b/.idea/jsonSchemas.xml deleted file mode 100644 index b7c07b63..00000000 --- a/.idea/jsonSchemas.xml +++ /dev/null @@ -1,28 +0,0 @@ - - - - - - - - - - - - - - - - \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml deleted file mode 100644 index 79b3c948..00000000 --- a/.idea/misc.xml +++ /dev/null @@ -1,4 +0,0 @@ - - - - \ No newline at end of file diff --git a/.idea/modules.xml b/.idea/modules.xml deleted file mode 100644 index 3127a538..00000000 --- a/.idea/modules.xml +++ /dev/null @@ -1,8 +0,0 @@ - - - - - - - - \ No newline at end of file diff --git a/.idea/scippp-external.iml b/.idea/scippp-external.iml deleted file mode 100644 index f08604bb..00000000 --- a/.idea/scippp-external.iml +++ /dev/null @@ -1,2 +0,0 @@ - - \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml deleted file mode 100644 index 35eb1ddf..00000000 --- a/.idea/vcs.xml +++ /dev/null @@ -1,6 +0,0 @@ - - - - - - \ No newline at end of file diff --git a/changelog.md b/changelog.md index 224deb57..6a1c2b9c 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 + +- [PR27](https://github.com/scipopt/SCIPpp/pull/27) Update to SCIP 9.2.0. + ## [1.2.0] - 2024-05-21 ### Changed diff --git a/conanfile.py b/conanfile.py index 5b746c62..f6f89ca3 100644 --- a/conanfile.py +++ b/conanfile.py @@ -67,13 +67,13 @@ def set_version(self): try: self.version = git.run("describe --tags --dirty=-d").strip() except: - self.version = "1.2.0" + self.version = "1.3.0-alpha" def layout(self): cmake_layout(self) def requirements(self): - self.requires("scip/9.0.1", transitive_headers=True) + self.requires("scip/9.2.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 ff0b16da..f356a074 100644 --- a/include/scippp/parameters.hpp +++ b/include/scippp/parameters.hpp @@ -1,5 +1,8 @@ #pragma once +// This file is automatically generated using gen_constexpr_parameters from the utils +// updated for SCIP 9.2.0 + #include "scippp/param.hpp" #undef INFINITY @@ -44,7 +47,7 @@ namespace BENDERS::DEFAULT { constexpr Param SUBPROBFRAC { "benders/default/subprobfrac" }; //! should the auxiliary variable bound be updated by solving the subproblem? constexpr Param UPDATEAUXVARBOUND { "benders/default/updateauxvarbound" }; - //! if the subproblem objective is integer, then define the auxiliary variables as implied integers? + //! if the subproblem objective is integer, then define the auxiliary variables as implicit integers? constexpr Param AUXVARSIMPLINT { "benders/default/auxvarsimplint" }; //! should Benders' cuts be generated while checking solutions? constexpr Param CUTCHECK { "benders/default/cutcheck" }; @@ -71,6 +74,8 @@ namespace BENDERS::DEFAULT { constexpr Param MAXSLACKVARCOEF { "benders/default/maxslackvarcoef" }; //! should the constraints of the subproblems be checked for convexity? constexpr Param CHECKCONSCONVEXITY { "benders/default/checkconsconvexity" }; + //! iteration limit for NLP solver + constexpr Param NLPITERLIMIT { "benders/default/nlpiterlimit" }; } //! Parameters with prefix benders/default/benderscut/feas namespace BENDERS::DEFAULT::BENDERSCUT::FEAS { @@ -223,6 +228,28 @@ namespace BRANCHING::FULLSTRONG { //! should strong branching be applied even if there is just a single candidate? constexpr Param FORCESTRONGBRANCH { "branching/fullstrong/forcestrongbranch" }; } +//! Parameters with prefix branching/gomory +namespace BRANCHING::GOMORY { + //! priority of branching rule \ + constexpr Param PRIORITY { "branching/gomory/priority" }; + //! maximal depth level, up to which branching rule \ should be used (-1 for no limit) + constexpr Param MAXDEPTH { "branching/gomory/maxdepth" }; + //! maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for + //! applying branching rule (0.0: only on current best node, 1.0: on all nodes) + constexpr Param MAXBOUNDDIST { "branching/gomory/maxbounddist" }; + //! maximum amount of branching candidates to generate Gomory cuts for (-1: all candidates) + constexpr Param MAXNCANDS { "branching/gomory/maxncands" }; + //! weight of efficacy in the weighted sum cut scoring rule + constexpr Param EFFICACYWEIGHT { "branching/gomory/efficacyweight" }; + //! weight of objective parallelism in the weighted sum cut scoring rule + constexpr Param OBJPARALLELWEIGHT { "branching/gomory/objparallelweight" }; + //! weight of integer support in the weighted sum cut scoring rule + constexpr Param INTSUPPORTWEIGHT { "branching/gomory/intsupportweight" }; + //! whether relpscost branching should be called without branching (used for bound inferences and conflicts) + constexpr Param PERFORMRELPSCOST { "branching/gomory/performrelpscost" }; + //! use weaker cuts that are exactly derived from the branching split disjunction + constexpr Param USEWEAKERCUTS { "branching/gomory/useweakercuts" }; +} //! Parameters with prefix branching/inference namespace BRANCHING::INFERENCE { //! priority of branching rule \ @@ -436,6 +463,10 @@ namespace BRANCHING::RELPSCOST { constexpr Param INFERENCEWEIGHT { "branching/relpscost/inferenceweight" }; //! weight in score calculations for cutoff score constexpr Param CUTOFFWEIGHT { "branching/relpscost/cutoffweight" }; + //! weight in score calculations for average GMI cuts normalized efficacy + constexpr Param GMIAVGEFFWEIGHT { "branching/relpscost/gmiavgeffweight" }; + //! weight in score calculations for last GMI cuts normalized efficacy + constexpr Param GMILASTEFFWEIGHT { "branching/relpscost/gmilasteffweight" }; //! weight in score calculations for pseudo cost score constexpr Param PSCOSTWEIGHT { "branching/relpscost/pscostweight" }; //! weight in score calculations for nlcount score @@ -945,8 +976,12 @@ namespace CONSTRAINTS::COMPONENTS { constexpr Param MINRELSIZE { "constraints/components/minrelsize" }; //! maximum number of nodes to be solved in subproblems during presolving constexpr Param NODELIMIT { "constraints/components/nodelimit" }; + //! the maximum weight of a component, in terms of the used factors + constexpr Param MAXCOMPWEIGHT { "constraints/components/maxcompweight" }; //! the weight of an integer variable compared to binary variables constexpr Param INTFACTOR { "constraints/components/intfactor" }; + //! the weight of a continuous variable compared to binary variables + constexpr Param CONTFACTOR { "constraints/components/contfactor" }; //! factor to increase the feasibility tolerance of the main SCIP in all sub-SCIPs, default value 1.0 constexpr Param FEASTOLFACTOR { "constraints/components/feastolfactor" }; } @@ -1084,6 +1119,32 @@ 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/fixedvar +namespace CONSTRAINTS::FIXEDVAR { + //! frequency for separating cuts (-1: never, 0: only in root node) + constexpr Param SEPAFREQ { "constraints/fixedvar/sepafreq" }; + //! frequency for propagating domains (-1: never, 0: only in root node) + constexpr Param PROPFREQ { "constraints/fixedvar/propfreq" }; + //! timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS) + constexpr Param PROPTIMING { "constraints/fixedvar/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/fixedvar/eagerfreq" }; + //! maximal number of presolving rounds the constraint handler participates in (-1: no limit) + constexpr Param MAXPREROUNDS { "constraints/fixedvar/maxprerounds" }; + //! should separation method be delayed, if other separators found cuts? + constexpr Param DELAYSEPA { "constraints/fixedvar/delaysepa" }; + //! should propagation method be delayed, if other propagators found reductions? + constexpr Param DELAYPROP { "constraints/fixedvar/delayprop" }; + //! timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) + constexpr Param PRESOLTIMING { "constraints/fixedvar/presoltiming" }; + //! whether to check and enforce bounds on fixed variables + constexpr Param ENABLED { "constraints/fixedvar/enabled" }; + //! whether to act on subSCIPs + constexpr Param SUBSCIPS { "constraints/fixedvar/subscips" }; + //! whether to prefer separation over tightening LP feastol in enforcement + constexpr Param PREFERCUT { "constraints/fixedvar/prefercut" }; +} //! Parameters with prefix constraints/indicator namespace CONSTRAINTS::INDICATOR { //! frequency for separating cuts (-1: never, 0: only in root node) @@ -1160,6 +1221,8 @@ namespace CONSTRAINTS::INDICATOR { constexpr Param TRYSOLFROMCOVER { "constraints/indicator/trysolfromcover" }; //! Try to upgrade linear constraints to indicator constraints? constexpr Param UPGRADELINEAR { "constraints/indicator/upgradelinear" }; + //! Use same slack variable for indicator constraints with common binary variable? + constexpr Param USESAMESLACKVAR { "constraints/indicator/usesameslackvar" }; //! Separate using the alternative LP? constexpr Param SEPAALTERNATIVELP { "constraints/indicator/sepaalternativelp" }; //! Force restart if absolute gap is 1 or enough binary variables have been fixed? @@ -1499,6 +1562,8 @@ namespace CONSTRAINTS::NONLINEAR::BRANCHING { constexpr Param HIGHSCOREFACTOR { "constraints/nonlinear/branching/highscorefactor" }; //! weight by how much to consider the violation assigned to a variable for its branching score constexpr Param VIOLWEIGHT { "constraints/nonlinear/branching/violweight" }; + //! weight by how much to consider fractionality of integer variables in branching score for spatial branching + constexpr Param FRACWEIGHT { "constraints/nonlinear/branching/fracweight" }; //! weight by how much to consider the dual values of rows that contain a variable for its branching score constexpr Param DUALWEIGHT { "constraints/nonlinear/branching/dualweight" }; //! weight by how much to consider the pseudo cost of a variable for its branching score @@ -1515,6 +1580,9 @@ namespace CONSTRAINTS::NONLINEAR::BRANCHING { constexpr Param VIOLSPLIT { "constraints/nonlinear/branching/violsplit" }; //! minimum pseudo-cost update count required to consider pseudo-costs reliable constexpr Param PSCOSTRELIABLE { "constraints/nonlinear/branching/pscostreliable" }; + //! minimal average pseudo cost count for discrete variables at which to start considering spatial branching before + //! branching on fractional integer variables + constexpr Param MIXFRACTIONAL { "constraints/nonlinear/branching/mixfractional" }; } //! Parameters with prefix constraints/nonlinear/upgrade namespace CONSTRAINTS::NONLINEAR::UPGRADE { @@ -1618,9 +1686,9 @@ namespace CONSTRAINTS::PSEUDOBOOLEAN { constexpr Param DELAYPROP { "constraints/pseudoboolean/delayprop" }; //! timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) constexpr Param PRESOLTIMING { "constraints/pseudoboolean/presoltiming" }; - //! decompose all normal pseudo boolean constraint into a "linear" constraint and "and" constraints + //! decompose every normal pseudo boolean constraint into a "linear" constraint and "and" constraints constexpr Param DECOMPOSENORMAL { "constraints/pseudoboolean/decomposenormal" }; - //! decompose all indicator pseudo boolean constraint into a "linear" constraint and "and" constraints + //! decompose every soft pseudo boolean constraint into "indicator" constraints and "and" constraints constexpr Param DECOMPOSEINDICATOR { "constraints/pseudoboolean/decomposeindicator" }; //! should the nonlinear constraints be separated during LP processing? constexpr Param NLCSEPARATE { "constraints/pseudoboolean/nlcseparate" }; @@ -1892,6 +1960,80 @@ namespace CONSTRAINTS::XOR { //! frequency for applying the Gauss propagator constexpr Param GAUSSPROPFREQ { "constraints/xor/gausspropfreq" }; } +//! Parameters with prefix cutselection/dynamic +namespace CUTSELECTION::DYNAMIC { + //! priority of cut selection rule \ + constexpr Param PRIORITY { "cutselection/dynamic/priority" }; + //! weight of efficacy in cut score calculation + constexpr Param EFFICACYWEIGHT { "cutselection/dynamic/efficacyweight" }; + //! weight of directed cutoff distance in cut score calculation + constexpr Param DIRCUTOFFDISTWEIGHT { "cutselection/dynamic/dircutoffdistweight" }; + //! weight of objective parallelism in cut score calculation + constexpr Param OBJPARALWEIGHT { "cutselection/dynamic/objparalweight" }; + //! weight of integral support in cut score calculation + constexpr Param INTSUPPORTWEIGHT { "cutselection/dynamic/intsupportweight" }; + //! minimal efficacy gain for a cut to enter the LP + constexpr Param MINGAIN { "cutselection/dynamic/mingain" }; + //! filtering strategy during cut selection + constexpr Param FILTERMODE { "cutselection/dynamic/filtermode" }; + //! minimal orthogonality for a cut to enter the LP + constexpr Param MINORTHO { "cutselection/dynamic/minortho" }; + //! maximum depth at which this cutselector is employed + constexpr Param MAXDEPTH { "cutselection/dynamic/maxdepth" }; +} +//! Parameters with prefix cutselection/ensemble +namespace CUTSELECTION::ENSEMBLE { + //! priority of cut selection rule \ + constexpr Param PRIORITY { "cutselection/ensemble/priority" }; + //! weight of normed-efficacy in cut score calculation + constexpr Param EFFICACYWEIGHT { "cutselection/ensemble/efficacyweight" }; + //! weight of normed-directed cutoff distance in cut score calculation + constexpr Param DIRCUTOFFDISTWEIGHT { "cutselection/ensemble/dircutoffdistweight" }; + //! weight of objective parallelism in cut score calculation + constexpr Param OBJPARALWEIGHT { "cutselection/ensemble/objparalweight" }; + //! weight of integral support in cut score calculation + constexpr Param INTSUPPORTWEIGHT { "cutselection/ensemble/intsupportweight" }; + //! weight of normed-expected obj improvement in cut score calculation + constexpr Param EXPIMPROVWEIGHT { "cutselection/ensemble/expimprovweight" }; + //! minimum score s.t. a cut can be added + constexpr Param MINSCORE { "cutselection/ensemble/minscore" }; + //! weight of normed-pseudo-costs in cut score calculation + constexpr Param PSCOSTWEIGHT { "cutselection/ensemble/pscostweight" }; + //! weight of normed-num-locks in cut score calculation + constexpr Param LOCKSWEIGHT { "cutselection/ensemble/locksweight" }; + //! weight of maximum sparsity reward in cut score calculation + constexpr Param MAXSPARSITYBONUS { "cutselection/ensemble/maxsparsitybonus" }; + //! weight of good numerics bonus (ratio of coefficients) in cut score calculation + constexpr Param GOODNUMERICSBONUS { "cutselection/ensemble/goodnumericsbonus" }; + //! max sparsity value for which a bonus is applied in cut score calculation + constexpr Param ENDSPARSITYBONUS { "cutselection/ensemble/endsparsitybonus" }; + //! threshold for when two cuts are considered parallel to each other + constexpr Param MAXPARAL { "cutselection/ensemble/maxparal" }; + //! penalty for weaker of two parallel cuts if penalising parallel cuts + constexpr Param PARALPENALTY { "cutselection/ensemble/paralpenalty" }; + //! max allowed cut density if filtering dense cuts + constexpr Param MAXCUTDENSITY { "cutselection/ensemble/maxcutdensity" }; + //! max non-zeros per round applied cuts (root). multiple num LP cols. + constexpr Param MAXNONZEROROOTROUND { "cutselection/ensemble/maxnonzerorootround" }; + //! max non-zeros per round applied cuts (tree). multiple num LP cols. + constexpr Param MAXNONZEROTREEROUND { "cutselection/ensemble/maxnonzerotreeround" }; + //! should cuts be filtered so no two parallel cuts are added + constexpr Param FILTERPARALCUTS { "cutselection/ensemble/filterparalcuts" }; + //! should two parallel cuts be penalised instead of outright filtered + constexpr Param PENALISEPARALCUTS { "cutselection/ensemble/penaliseparalcuts" }; + //! should cuts over a given density threshold be filtered + constexpr Param FILTERDENSECUTS { "cutselection/ensemble/filterdensecuts" }; + //! should the number of locks be penalised instead of rewarded + constexpr Param PENALISELOCKS { "cutselection/ensemble/penaliselocks" }; + //! should objective parallelism be penalised instead of rewarded + constexpr Param PENALISEOBJPARAL { "cutselection/ensemble/penaliseobjparal" }; + //! max coefficient ratio for which numeric bonus is applied. + constexpr Param MAXCOEFRATIOBONUS { "cutselection/ensemble/maxcoefratiobonus" }; + //! max number of cuts such that cut selector is applied. + constexpr Param MAXCUTS { "cutselection/ensemble/maxcuts" }; + //! max number of variables such that cut selector is applied. + constexpr Param MAXNUMVARS { "cutselection/ensemble/maxnumvars" }; +} //! Parameters with prefix cutselection/hybrid namespace CUTSELECTION::HYBRID { //! priority of cut selection rule \ @@ -2235,6 +2377,15 @@ namespace EXPR::LOG { namespace EXPR::POW { //! minimal distance from zero to enforce for child in bound tightening constexpr Param MINZERODISTANCE { "expr/pow/minzerodistance" }; + //! maximal exponent when to expand power of sum in simplify + constexpr Param EXPANDMAXEXPONENT { "expr/pow/expandmaxexponent" }; + //! whether a fractional exponent is distributed onto factors on power of product + constexpr Param DISTRIBFRACEXPONENT { "expr/pow/distribfracexponent" }; +} +//! Parameters with prefix expr/prod +namespace EXPR::PROD { + //! whether to expand products of a sum and several factors in simplify + constexpr Param EXPANDALWAYS { "expr/prod/expandalways" }; } //! Parameters with prefix heuristics namespace HEURISTICS { @@ -2339,7 +2490,7 @@ namespace HEURISTICS::ALNS { constexpr Param MINIMPROVEHIGH { "heuristics/alns/minimprovehigh" }; //! limit on the number of improving solutions in a sub-SCIP call constexpr Param NSOLSLIM { "heuristics/alns/nsolslim" }; - //! the bandit algorithm: (u)pper confidence bounds, (e)xp.3, epsilon (g)reedy + //! the bandit algorithm: (u)pper confidence bounds, (e)xp.3, epsilon (g)reedy, exp.3-(i)x constexpr Param BANDITALGO { "heuristics/alns/banditalgo" }; //! weight between uniform (gamma ~ 1) and weight driven (gamma ~ 0) probability distribution for exp3 constexpr Param GAMMA { "heuristics/alns/gamma" }; @@ -2823,6 +2974,10 @@ namespace HEURISTICS::DPS { constexpr Param REOPTIMIZE { "heuristics/dps/reoptimize" }; //! should solutions get reused in subproblems? constexpr Param REUSE { "heuristics/dps/reuse" }; + //! should strict limits for reoptimization be set? + constexpr Param REOPTLIMITS { "heuristics/dps/reoptlimits" }; + //! should the heuristic run before or after the processing of the node? (0: before, 1: after, 2: both) + constexpr Param TIMING { "heuristics/dps/timing" }; } //! Parameters with prefix heuristics/dualval namespace HEURISTICS::DUALVAL { @@ -3118,6 +3273,54 @@ namespace HEURISTICS::INDICATOR { //! Try to improve other solutions by one-opt? constexpr Param IMPROVESOLS { "heuristics/indicator/improvesols" }; } +//! Parameters with prefix heuristics/indicatordiving +namespace HEURISTICS::INDICATORDIVING { + //! priority of heuristic \ + constexpr Param PRIORITY { "heuristics/indicatordiving/priority" }; + //! frequency for calling primal heuristic \ (-1: never, 0: only at depth freqofs) + constexpr Param FREQ { "heuristics/indicatordiving/freq" }; + //! frequency offset for calling primal heuristic \ + constexpr Param FREQOFS { "heuristics/indicatordiving/freqofs" }; + //! maximal depth level to call primal heuristic \ (-1: no limit) + constexpr Param MAXDEPTH { "heuristics/indicatordiving/maxdepth" }; + //! minimal relative depth to start diving + constexpr Param MINRELDEPTH { "heuristics/indicatordiving/minreldepth" }; + //! maximal relative depth to start diving + constexpr Param MAXRELDEPTH { "heuristics/indicatordiving/maxreldepth" }; + //! maximal fraction of diving LP iterations compared to node LP iterations + constexpr Param MAXLPITERQUOT { "heuristics/indicatordiving/maxlpiterquot" }; + //! additional number of allowed LP iterations + constexpr Param MAXLPITEROFS { "heuristics/indicatordiving/maxlpiterofs" }; + //! maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0.0: no + //! limit) + constexpr Param MAXDIVEUBQUOT { "heuristics/indicatordiving/maxdiveubquot" }; + //! maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed (0.0: no + //! limit) + constexpr Param MAXDIVEAVGQUOT { "heuristics/indicatordiving/maxdiveavgquot" }; + //! maximal UBQUOT when no solution was found yet (0.0: no limit) + constexpr Param MAXDIVEUBQUOTNOSOL { "heuristics/indicatordiving/maxdiveubquotnosol" }; + //! maximal AVGQUOT when no solution was found yet (0.0: no limit) + constexpr Param MAXDIVEAVGQUOTNOSOL { "heuristics/indicatordiving/maxdiveavgquotnosol" }; + //! use one level of backtracking if infeasibility is encountered? + constexpr Param BACKTRACK { "heuristics/indicatordiving/backtrack" }; + //! percentage of immediate domain changes during probing to trigger LP resolve + constexpr Param LPRESOLVEDOMCHGQUOT { "heuristics/indicatordiving/lpresolvedomchgquot" }; + //! LP solve frequency for diving heuristics (0: only after enough domain changes have been found) + constexpr Param LPSOLVEFREQ { "heuristics/indicatordiving/lpsolvefreq" }; + //! should only LP branching candidates be considered instead of the slower but more general constraint handler + //! diving variable selection? + constexpr Param ONLYLPBRANCHCANDS { "heuristics/indicatordiving/onlylpbranchcands" }; + //! in violation case all fractional below this value are fixed to constant + constexpr Param ROUNDINGFRAC { "heuristics/indicatordiving/roundingfrac" }; + //! decides which roundingmode is selected (0: conservative, 1: aggressive) + constexpr Param ROUNDINGMODE { "heuristics/indicatordiving/roundingmode" }; + //! which values of semi-continuous variables should get a high score? (0: low, 1: middle, 2: high) + constexpr Param SEMICONTSCOREMODE { "heuristics/indicatordiving/semicontscoremode" }; + //! should varbound constraints be considered? + constexpr Param USEVARBOUNDS { "heuristics/indicatordiving/usevarbounds" }; + //! should heur run if there are no indicator constraints modeling semicont. vars? + constexpr Param RUNWITHOUTSCINDS { "heuristics/indicatordiving/runwithoutscinds" }; +} //! Parameters with prefix heuristics/intdiving namespace HEURISTICS::INTDIVING { //! priority of heuristic \ @@ -3850,6 +4053,196 @@ namespace HEURISTICS::ROUNDING { //! should the heuristic only be called once per node? constexpr Param ONCEPERNODE { "heuristics/rounding/oncepernode" }; } +//! Parameters with prefix heuristics/scheduler +namespace HEURISTICS::SCHEDULER { + //! priority of heuristic \ + constexpr Param PRIORITY { "heuristics/scheduler/priority" }; + //! frequency for calling primal heuristic \ (-1: never, 0: only at depth freqofs) + constexpr Param FREQ { "heuristics/scheduler/freq" }; + //! frequency offset for calling primal heuristic \ + constexpr Param FREQOFS { "heuristics/scheduler/freqofs" }; + //! maximal depth level to call primal heuristic \ (-1: no limit) + constexpr Param MAXDEPTH { "heuristics/scheduler/maxdepth" }; + //! maximum number of nodes to regard in the subproblem + constexpr Param MAXNODES { "heuristics/scheduler/maxnodes" }; + //! offset added to the nodes budget + constexpr Param NODESOFS { "heuristics/scheduler/nodesofs" }; + //! minimum number of nodes required to start a sub-SCIP + constexpr Param MINNODES { "heuristics/scheduler/minnodes" }; + //! number of nodes since last incumbent solution that the heuristic should wait + constexpr Param WAITINGNODES { "heuristics/scheduler/waitingnodes" }; + //! initial node limit for LNS heuristics + constexpr Param INITLNSNODELIMIT { "heuristics/scheduler/initlnsnodelimit" }; + //! initial node limit for diving heuristics + constexpr Param INITDIVINGNODELIMIT { "heuristics/scheduler/initdivingnodelimit" }; + //! fraction of nodes compared to the main SCIP for budget computation + constexpr Param NODESQUOT { "heuristics/scheduler/nodesquot" }; + //! lower bound fraction of nodes compared to the main SCIP for budget computation + constexpr Param NODESQUOTMIN { "heuristics/scheduler/nodesquotmin" }; + //! limit on the number of improving solutions in a sub-SCIP call + constexpr Param NSOLSLIM { "heuristics/scheduler/nsolslim" }; + //! the bandit algorithm: (u)pper confidence bounds, (e)xp.3, epsilon (g)reedy, exp.3-(i)x + constexpr Param BANDITALGO { "heuristics/scheduler/banditalgo" }; + //! weight between uniform (gamma ~ 1) and weight driven (gamma ~ 0) probability distribution for exp3 + constexpr Param GAMMA { "heuristics/scheduler/gamma" }; + //! reward offset between 0 and 1 at every observation for Exp.3 + constexpr Param BETA { "heuristics/scheduler/beta" }; + //! parameter to increase the confidence width in UCB + constexpr Param ALPHA { "heuristics/scheduler/alpha" }; + //! distances from fixed variables be used for variable prioritization + constexpr Param USEDISTANCES { "heuristics/scheduler/usedistances" }; + //! should reduced cost scores be used for variable prioritization? + constexpr Param USEREDCOST { "heuristics/scheduler/useredcost" }; + //! should pseudo cost scores be used for variable priorization? + constexpr Param USEPSCOST { "heuristics/scheduler/usepscost" }; + //! should local reduced costs be used for generic (un)fixing? + constexpr Param USELOCALREDCOST { "heuristics/scheduler/uselocalredcost" }; + //! should the heuristic activate other sub-SCIP heuristics during its search? + constexpr Param USESUBSCIPHEURS { "heuristics/scheduler/usesubscipheurs" }; + //! factor by which target node number is eventually increased + constexpr Param TARGETNODEFACTOR { "heuristics/scheduler/targetnodefactor" }; + //! initial random seed for bandit algorithms and random decisions by neighborhoods + constexpr Param SEED { "heuristics/scheduler/seed" }; + //! number of allowed executions of the heuristic on the same incumbent solution (-1: no limit, 0: number of active + //! neighborhoods) + constexpr Param MAXCALLSSAMESOL { "heuristics/scheduler/maxcallssamesol" }; + //! increase exploration in epsilon-greedy bandit algorithm + constexpr Param EPS { "heuristics/scheduler/eps" }; + //! TRUE if modified version of the epsilon-greedy bandit algorithm should be used + constexpr Param EPSGREEDY_USEMOD { "heuristics/scheduler/epsgreedy_usemod" }; + //! weight by how much finding a new incumbent is rewarded in reward function + constexpr Param SOLREWARDWEIGHT { "heuristics/scheduler/solrewardweight" }; + //! weight by how much effort is rewarded in reward function + constexpr Param EFFORTREWARDWEIGHT { "heuristics/scheduler/effortrewardweight" }; + //! weight by how much quality of a new incumbent is rewarded in reward function + constexpr Param QUALREWARDWEIGHT { "heuristics/scheduler/qualrewardweight" }; + //! weight by how much number of conflicts found by diving is rewarded in reward function + constexpr Param CONFLICTREWARDWEIGHT { "heuristics/scheduler/conflictrewardweight" }; + //! should the bandit algorithms be reset when a new problem is read? + constexpr Param RESETWEIGHTS { "heuristics/scheduler/resetweights" }; + //! should random seeds of sub-SCIPs be altered to increase diversification? + constexpr Param SUBSCIPRANDSEEDS { "heuristics/scheduler/subsciprandseeds" }; + //! should cutting planes be copied to the sub-SCIP? + constexpr Param COPYCUTS { "heuristics/scheduler/copycuts" }; + //! tolerance by which the fixing rate may be missed without generic fixing + 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? + constexpr Param DEFAULTROOT { "heuristics/scheduler/defaultroot" }; + //! number of heuristics picked by the scheduler in one call (-1: number of controlled heuristics, 0: until new + //! incumbent is found) + constexpr Param NSELECTIONS { "heuristics/scheduler/nselections" }; +} +//! Parameters with prefix heuristics/scheduler/crossover +namespace HEURISTICS::SCHEDULER::CROSSOVER { + //! minimum fixing rate for this neighborhood + constexpr Param MINFIXINGRATE { "heuristics/scheduler/crossover/minfixingrate" }; + //! maximum fixing rate for this neighborhood + constexpr Param MAXFIXINGRATE { "heuristics/scheduler/crossover/maxfixingrate" }; + //! is this neighborhood active? + constexpr Param ACTIVE { "heuristics/scheduler/crossover/active" }; + //! positive call priority to initialize bandit algorithms + constexpr Param PRIORITY { "heuristics/scheduler/crossover/priority" }; + //! the number of solutions that crossover should combine + constexpr Param NSOLS { "heuristics/scheduler/crossover/nsols" }; +} +//! Parameters with prefix heuristics/scheduler/dins +namespace HEURISTICS::SCHEDULER::DINS { + //! minimum fixing rate for this neighborhood + constexpr Param MINFIXINGRATE { "heuristics/scheduler/dins/minfixingrate" }; + //! maximum fixing rate for this neighborhood + constexpr Param MAXFIXINGRATE { "heuristics/scheduler/dins/maxfixingrate" }; + //! is this neighborhood active? + constexpr Param ACTIVE { "heuristics/scheduler/dins/active" }; + //! positive call priority to initialize bandit algorithms + constexpr Param PRIORITY { "heuristics/scheduler/dins/priority" }; + //! number of pool solutions where binary solution values must agree + constexpr Param NPOOLSOLS { "heuristics/scheduler/dins/npoolsols" }; +} +//! Parameters with prefix heuristics/scheduler/localbranching +namespace HEURISTICS::SCHEDULER::LOCALBRANCHING { + //! minimum fixing rate for this neighborhood + constexpr Param MINFIXINGRATE { "heuristics/scheduler/localbranching/minfixingrate" }; + //! maximum fixing rate for this neighborhood + constexpr Param MAXFIXINGRATE { "heuristics/scheduler/localbranching/maxfixingrate" }; + //! is this neighborhood active? + constexpr Param ACTIVE { "heuristics/scheduler/localbranching/active" }; + //! positive call priority to initialize bandit algorithms + constexpr Param PRIORITY { "heuristics/scheduler/localbranching/priority" }; +} +//! Parameters with prefix heuristics/scheduler/mutation +namespace HEURISTICS::SCHEDULER::MUTATION { + //! minimum fixing rate for this neighborhood + constexpr Param MINFIXINGRATE { "heuristics/scheduler/mutation/minfixingrate" }; + //! maximum fixing rate for this neighborhood + constexpr Param MAXFIXINGRATE { "heuristics/scheduler/mutation/maxfixingrate" }; + //! is this neighborhood active? + constexpr Param ACTIVE { "heuristics/scheduler/mutation/active" }; + //! positive call priority to initialize bandit algorithms + constexpr Param PRIORITY { "heuristics/scheduler/mutation/priority" }; +} +//! Parameters with prefix heuristics/scheduler/proximity +namespace HEURISTICS::SCHEDULER::PROXIMITY { + //! minimum fixing rate for this neighborhood + constexpr Param MINFIXINGRATE { "heuristics/scheduler/proximity/minfixingrate" }; + //! maximum fixing rate for this neighborhood + constexpr Param MAXFIXINGRATE { "heuristics/scheduler/proximity/maxfixingrate" }; + //! is this neighborhood active? + constexpr Param ACTIVE { "heuristics/scheduler/proximity/active" }; + //! positive call priority to initialize bandit algorithms + constexpr Param PRIORITY { "heuristics/scheduler/proximity/priority" }; +} +//! Parameters with prefix heuristics/scheduler/rens +namespace HEURISTICS::SCHEDULER::RENS { + //! minimum fixing rate for this neighborhood + constexpr Param MINFIXINGRATE { "heuristics/scheduler/rens/minfixingrate" }; + //! maximum fixing rate for this neighborhood + constexpr Param MAXFIXINGRATE { "heuristics/scheduler/rens/maxfixingrate" }; + //! is this neighborhood active? + constexpr Param ACTIVE { "heuristics/scheduler/rens/active" }; + //! positive call priority to initialize bandit algorithms + constexpr Param PRIORITY { "heuristics/scheduler/rens/priority" }; +} +//! Parameters with prefix heuristics/scheduler/rins +namespace HEURISTICS::SCHEDULER::RINS { + //! minimum fixing rate for this neighborhood + constexpr Param MINFIXINGRATE { "heuristics/scheduler/rins/minfixingrate" }; + //! maximum fixing rate for this neighborhood + constexpr Param MAXFIXINGRATE { "heuristics/scheduler/rins/maxfixingrate" }; + //! is this neighborhood active? + constexpr Param ACTIVE { "heuristics/scheduler/rins/active" }; + //! positive call priority to initialize bandit algorithms + constexpr Param PRIORITY { "heuristics/scheduler/rins/priority" }; +} +//! Parameters with prefix heuristics/scheduler/trustregion +namespace HEURISTICS::SCHEDULER::TRUSTREGION { + //! minimum fixing rate for this neighborhood + constexpr Param MINFIXINGRATE { "heuristics/scheduler/trustregion/minfixingrate" }; + //! maximum fixing rate for this neighborhood + constexpr Param MAXFIXINGRATE { "heuristics/scheduler/trustregion/maxfixingrate" }; + //! is this neighborhood active? + constexpr Param ACTIVE { "heuristics/scheduler/trustregion/active" }; + //! positive call priority to initialize bandit algorithms + constexpr Param PRIORITY { "heuristics/scheduler/trustregion/priority" }; + //! the penalty for each change in the binary variables from the candidate solution + constexpr Param VIOLPENALTY { "heuristics/scheduler/trustregion/violpenalty" }; +} +//! Parameters with prefix heuristics/scheduler/zeroobjective +namespace HEURISTICS::SCHEDULER::ZEROOBJECTIVE { + //! minimum fixing rate for this neighborhood + constexpr Param MINFIXINGRATE { "heuristics/scheduler/zeroobjective/minfixingrate" }; + //! maximum fixing rate for this neighborhood + constexpr Param MAXFIXINGRATE { "heuristics/scheduler/zeroobjective/maxfixingrate" }; + //! is this neighborhood active? + constexpr Param ACTIVE { "heuristics/scheduler/zeroobjective/active" }; + //! positive call priority to initialize bandit algorithms + constexpr Param PRIORITY { "heuristics/scheduler/zeroobjective/priority" }; +} //! Parameters with prefix heuristics/shiftandpropagate namespace HEURISTICS::SHIFTANDPROPAGATE { //! priority of heuristic \ @@ -3886,7 +4279,7 @@ namespace HEURISTICS::SHIFTANDPROPAGATE { constexpr Param FIXBINLOCKS { "heuristics/shiftandpropagate/fixbinlocks" }; //! should binary variables with no locks be preferred in the ordering? constexpr Param BINLOCKSFIRST { "heuristics/shiftandpropagate/binlocksfirst" }; - //! should coefficients and left/right hand sides be normalized by max row coeff? + //! should coefficients be normalized by max row coeff for col norm? constexpr Param NORMALIZE { "heuristics/shiftandpropagate/normalize" }; //! should row weight be increased every time the row is violated? constexpr Param UPDATEWEIGHTS { "heuristics/shiftandpropagate/updateweights" }; @@ -4114,8 +4507,14 @@ namespace HEURISTICS::UNDERCOVER { constexpr Param ONLYCONVEXIFY { "heuristics/undercover/onlyconvexify" }; //! should the NLP heuristic be called to polish a feasible solution? constexpr Param POSTNLP { "heuristics/undercover/postnlp" }; + //! should and constraints be covered (or just copied)? + constexpr Param COVERAND { "heuristics/undercover/coverand" }; //! should bounddisjunction constraints be covered (or just copied)? constexpr Param COVERBD { "heuristics/undercover/coverbd" }; + //! should indicator constraints be covered (or just copied)? + constexpr Param COVERIND { "heuristics/undercover/coverind" }; + //! should nonlinear constraints be covered (or just copied)? + constexpr Param COVERNL { "heuristics/undercover/covernl" }; //! should all active cuts from cutpool be copied to constraints in subproblem? constexpr Param COPYCUTS { "heuristics/undercover/copycuts" }; //! shall the cover be reused if a conflict was added after an infeasible subproblem? @@ -4273,6 +4672,10 @@ 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) + constexpr Param PRIMAL { "limits/primal" }; + //! solving stops, if dual bound is at least as good as given value + constexpr Param DUAL { "limits/dual" }; //! solving stops, if the given number of solutions were found; this limit is first checked in presolving (-1: no //! limit) constexpr Param SOLUTIONS { "limits/solutions" }; @@ -4432,9 +4835,9 @@ 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: polyhedral (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 + //! 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. constexpr Param USESYMMETRY { "misc/usesymmetry" }; } @@ -4476,6 +4879,8 @@ namespace NLHDLR::CONVEX { constexpr Param DETECTSUM { "nlhdlr/convex/detectsum" }; //! whether to create extended formulations instead of looking for maximal convex expressions constexpr Param EXTENDEDFORM { "nlhdlr/convex/extendedform" }; + //! maximal relative perturbation of non-differentiable reference point + constexpr Param MAXPERTURB { "nlhdlr/convex/maxperturb" }; //! whether to use convexity check on quadratics constexpr Param CVXQUADRATIC { "nlhdlr/convex/cvxquadratic" }; //! whether to use convexity check on signomials @@ -4519,6 +4924,10 @@ namespace NLHDLR::QUADRATIC { constexpr Param USEINTERSECTIONCUTS { "nlhdlr/quadratic/useintersectioncuts" }; //! whether the strengthening should be used constexpr Param USESTRENGTHENING { "nlhdlr/quadratic/usestrengthening" }; + //! whether monoidal strengthening should be used + constexpr Param USEMONOIDAL { "nlhdlr/quadratic/usemonoidal" }; + //! whether the minimal representation of the S-free set should be used (instead of the gauge) + constexpr Param USEMINREP { "nlhdlr/quadratic/useminrep" }; //! use bounds of variables in quadratic as rays for intersection cuts constexpr Param USEBOUNDSASRAYS { "nlhdlr/quadratic/useboundsasrays" }; //! limit for number of cuts generated consecutively @@ -4536,16 +4945,29 @@ namespace NLHDLR::QUADRATIC { constexpr Param ATWHICHNODES { "nlhdlr/quadratic/atwhichnodes" }; //! limit for number of rays we do the strengthening for constexpr Param NSTRENGTHLIMIT { "nlhdlr/quadratic/nstrengthlimit" }; + //! should we try to sparisfy the intersection cut? + constexpr Param SPARSIFYCUTS { "nlhdlr/quadratic/sparsifycuts" }; //! should cut be generated even with bad numerics when restricting to ray? constexpr Param IGNOREBADRAYRESTRICTION { "nlhdlr/quadratic/ignorebadrayrestriction" }; //! should cut be added even when range / efficacy is large? constexpr Param IGNORENHIGHRE { "nlhdlr/quadratic/ignorenhighre" }; + //! for monoidal strengthening, should we track more statistics (more expensive)? + constexpr Param TRACKMORE { "nlhdlr/quadratic/trackmore" }; } //! Parameters with prefix nlhdlr/quotient namespace NLHDLR::QUOTIENT { //! should this nonlinear handler be used constexpr Param ENABLED { "nlhdlr/quotient/enabled" }; } +//! Parameters with prefix nlhdlr/signomial +namespace NLHDLR::SIGNOMIAL { + //! should this nonlinear handler be used + constexpr Param ENABLED { "nlhdlr/signomial/enabled" }; + //! maximum number of variables when underestimating a concave power function + constexpr Param MAXNUNDERVARS { "nlhdlr/signomial/maxnundervars" }; + //! minimum scale factor when scaling a cut + constexpr Param MINCUTSCALE { "nlhdlr/signomial/mincutscale" }; +} //! Parameters with prefix nlhdlr/soc namespace NLHDLR::SOC { //! should this nonlinear handler be used @@ -5119,8 +5541,12 @@ namespace PROPAGATING::OBBT { constexpr Param CONDITIONLIMIT { "propagating/obbt/conditionlimit" }; //! minimal relative improve for strengthening bounds constexpr Param BOUNDSTREPS { "propagating/obbt/boundstreps" }; + //! threshold whether upper bounds of vars of indicator conss are considered or tightened + constexpr Param INDICATORTHRESHOLD { "propagating/obbt/indicatorthreshold" }; //! only apply obbt on non-convex variables constexpr Param ONLYNONCONVEXVARS { "propagating/obbt/onlynonconvexvars" }; + //! apply obbt on variables of indicator constraints? (independent of convexity) + constexpr Param INDICATORS { "propagating/obbt/indicators" }; //! should integral bounds be tightened during the probing mode? constexpr Param TIGHTINTBOUNDSPROBING { "propagating/obbt/tightintboundsprobing" }; //! should continuous bounds be tightened during the probing mode? @@ -5280,20 +5706,23 @@ namespace PROPAGATING::SYMMETRY { constexpr Param CONSSADDLP { "propagating/symmetry/conssaddlp" }; //! Add inequalities for symresacks for each generator? constexpr Param ADDSYMRESACKS { "propagating/symmetry/addsymresacks" }; + //! Should we check whether the components of the symmetry group can be handled by double lex matrices? + constexpr Param DETECTDOUBLELEX { "propagating/symmetry/detectdoublelex" }; //! Should we check whether the components of the symmetry group can be handled by orbitopes? constexpr Param DETECTORBITOPES { "propagating/symmetry/detectorbitopes" }; //! Should we try to detect symmetric subgroups of the symmetry group on binary variables? constexpr Param DETECTSUBGROUPS { "propagating/symmetry/detectsubgroups" }; //! Should we add weak SBCs for enclosing orbit of symmetric subgroups? constexpr Param ADDWEAKSBCS { "propagating/symmetry/addweaksbcs" }; - //! timing of adding constraints (0 = before presolving, 1 = during presolving, 2 = after presolving) + //! timing of adding constraints (0 = before presolving, 1 = during presolving, 2 = after presolving) [disabled + //! parameter] constexpr Param ADDCONSSTIMING { "propagating/symmetry/addconsstiming" }; - //! timing of symmetry computation for orbital fixing (0 = before presolving, 1 = during presolving, 2 = at first - //! call) + //! timing of symmetry computation (0 = before presolving, 1 = during presolving, 2 = at first call) [disabled + //! parameter] constexpr Param OFSYMCOMPTIMING { "propagating/symmetry/ofsymcomptiming" }; - //! run orbital fixing during presolving? + //! run orbital fixing during presolving? (disabled) constexpr Param PERFORMPRESOLVING { "propagating/symmetry/performpresolving" }; - //! recompute symmetries after a restart has occured? (0 = never) + //! recompute symmetries after a restart has occurred? (0 = never) constexpr Param RECOMPUTERESTART { "propagating/symmetry/recomputerestart" }; //! Should non-affected variables be removed from permutation to save memory? constexpr Param COMPRESSSYMMETRIES { "propagating/symmetry/compresssymmetries" }; @@ -5303,15 +5732,14 @@ namespace PROPAGATING::SYMMETRY { constexpr Param USECOLUMNSPARSITY { "propagating/symmetry/usecolumnsparsity" }; //! maximum number of constraints up to which subgroup structures are detected constexpr Param MAXNCONSSSUBGROUP { "propagating/symmetry/maxnconsssubgroup" }; - //! whether dynamic propagation should be used for full orbitopes + //! whether dynamified symmetry handling constraint methods should be used constexpr Param USEDYNAMICPROP { "propagating/symmetry/usedynamicprop" }; //! Should strong SBCs for enclosing orbit of symmetric subgroups be added if orbitopes are not used? constexpr Param ADDSTRONGSBCS { "propagating/symmetry/addstrongsbcs" }; //! rule to select the orbit in Schreier Sims inequalities (variable in 0: minimum size orbit; 1: maximum size //! orbit; 2: orbit with most variables in conflict with leader) 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; - //! 3: var having most conflicting vars in problem) + //! 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 @@ -5322,12 +5750,25 @@ namespace PROPAGATING::SYMMETRY { constexpr Param SSTADDCUTS { "propagating/symmetry/sstaddcuts" }; //! Should Schreier Sims constraints be added if a symmetry component contains variables of different types? constexpr Param SSTMIXEDCOMPONENTS { "propagating/symmetry/sstmixedcomponents" }; - //! Whether all non-binary variables shall be not affected by symmetries if OF is active? + //! Whether all non-binary variables shall be not affected by symmetries if OF is active? (disabled) constexpr Param SYMFIXNONBINARYVARS { "propagating/symmetry/symfixnonbinaryvars" }; //! Is only symmetry on binary variables used? - constexpr Param ONLYBINARYSYMMETRY { "propagating/symmetry/onlybinarysymmetry" }; + constexpr Param ENFORCECOMPUTESYMMETRY { "propagating/symmetry/enforcecomputesymmetry" }; //! Shall orbitopes with less rows be preferred in detection? constexpr Param PREFERLESSROWS { "propagating/symmetry/preferlessrows" }; + //! Type of symmetries that shall be computed? + constexpr Param SYMTYPE { "propagating/symmetry/symtype" }; + //! 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" }; +} +//! Parameters with prefix propagating/symmetry/orbitopalreduction +namespace PROPAGATING::SYMMETRY::ORBITOPALREDUCTION { + //! The column ordering variant, respects enum SCIP_ColumnOrdering. + constexpr Param COLUMNORDERING { "propagating/symmetry/orbitopalreduction/columnordering" }; } //! Parameters with prefix propagating/vbounds namespace PROPAGATING::VBOUNDS { @@ -5407,8 +5848,6 @@ namespace READING::CNFREADER { } //! Parameters with prefix reading/gmsreader namespace READING::GMSREADER { - //! have integer variables no upper bound by default (depending on GAMS version)? - constexpr Param FREEINTS { "reading/gmsreader/freeints" }; //! shall characters '\#', '*', '+', '/', and '-' in variable and constraint names be replaced by '_'? constexpr Param REPLACEFORBIDDENCHARS { "reading/gmsreader/replaceforbiddenchars" }; //! default M value for big-M reformulation of indicator constraints in case no bound on slack variable is given @@ -5501,7 +5940,7 @@ namespace REOPTIMIZATION { constexpr Param REDUCETOFRONTIER { "reoptimization/reducetofrontier" }; //! force a restart if the last n optimal solutions were found by heuristic reoptsols constexpr Param FORCEHEURRESTART { "reoptimization/forceheurrestart" }; - //! save constraint propagations + //! save constraint and propagator propagations constexpr Param SAVECONSPROP { "reoptimization/saveconsprop" }; //! use constraints to reconstruct the subtree pruned be dual reduction when reactivating the node constexpr Param USESPLITCONS { "reoptimization/usesplitcons" }; @@ -5536,6 +5975,12 @@ namespace SEPARATING { constexpr Param MINEFFICACYROOT { "separating/minefficacyroot" }; //! minimum cut activity quotient to convert cuts into constraints during a restart (0.0: all cuts are converted) constexpr Param MINACTIVITYQUOT { "separating/minactivityquot" }; + //! factor w.r.t. maxcuts for maximal number of cuts generated per separation round (-1.0: no limit, \>= 0.0: valid + //! finite limit) + constexpr Param MAXCUTSGENFACTOR { "separating/maxcutsgenfactor" }; + //! factor w.r.t. maxcutsroot for maximal number of generated cuts per separation round at the root node (-1.0: no + //! limit, \>= 0.0: valid finite limit) + constexpr Param MAXCUTSROOTGENFACTOR { "separating/maxcutsrootgenfactor" }; //! function used for calc. scalar prod. in orthogonality test ('e'uclidean, 'd'iscrete) constexpr Param ORTHOFUNC { "separating/orthofunc" }; //! row norm to use for efficacy calculation ('e'uclidean, 'm'aximum, 's'um, 'd'iscrete) @@ -5564,7 +6009,7 @@ namespace SEPARATING { constexpr Param MAXSTALLROUNDSROOT { "separating/maxstallroundsroot" }; //! maximal number of cuts separated per separation round (0: disable local separation) constexpr Param MAXCUTS { "separating/maxcuts" }; - //! maximal number of separated cuts at the root node (0: disable root node separation) + //! maximal number of separated cuts per separation round at the root node (0: disable root node separation) constexpr Param MAXCUTSROOT { "separating/maxcutsroot" }; //! maximum age a cut can reach before it is deleted from the global cut pool, or -1 to keep all cuts constexpr Param CUTAGELIMIT { "separating/cutagelimit" }; @@ -6055,6 +6500,132 @@ namespace SEPARATING::KNAPSACKCOVER { //! multiple of frequency) constexpr Param EXPBACKOFF { "separating/knapsackcover/expbackoff" }; } +//! Parameters with prefix separating/lagromory +namespace SEPARATING::LAGROMORY { + //! priority of separator \ + constexpr Param PRIORITY { "separating/lagromory/priority" }; + //! frequency for calling separator \ (-1: never, 0: only in root node) + constexpr Param FREQ { "separating/lagromory/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/lagromory/maxbounddist" }; + //! should separator be delayed, if other separators found cuts? + constexpr Param DELAY { "separating/lagromory/delay" }; + //! base for exponential increase of frequency at which separator \ is called (1: call at each multiple + //! of frequency) + constexpr Param EXPBACKOFF { "separating/lagromory/expbackoff" }; + //! minimal integrality violation of a basis variable to try separation + constexpr Param AWAY { "separating/lagromory/away" }; + //! factor w.r.t. root node LP iterations for maximal separating LP iterations in the root node (negative for no + //! limit) + constexpr Param ROOTLPITERLIMITFACTOR { "separating/lagromory/rootlpiterlimitfactor" }; + //! factor w.r.t. root node LP iterations for maximal separating LP iterations in the tree (negative for no limit) + constexpr Param TOTALLPITERLIMITFACTOR { "separating/lagromory/totallpiterlimitfactor" }; + //! factor w.r.t. root node LP iterations for maximal separating LP iterations per separation round (negative for no + //! limit) + constexpr Param PERROUNDLPITERLIMITFACTOR { "separating/lagromory/perroundlpiterlimitfactor" }; + //! factor w.r.t. number of integer columns for number of cuts separated per separation round in root node + constexpr Param PERROUNDCUTSFACTORROOT { "separating/lagromory/perroundcutsfactorroot" }; + //! factor w.r.t. number of integer columns for number of cuts separated per separation round at a non-root node + constexpr Param PERROUNDCUTSFACTOR { "separating/lagromory/perroundcutsfactor" }; + //! factor w.r.t. number of integer columns for total number of cuts separated + constexpr Param TOTALCUTSFACTOR { "separating/lagromory/totalcutsfactor" }; + //! initial value of the mu parameter (factor for step length) + constexpr Param MUPARAMINIT { "separating/lagromory/muparaminit" }; + //! lower bound of the mu parameter (factor for step length) + constexpr Param MUPARAMLB { "separating/lagromory/muparamlb" }; + //! upper bound of the mu parameter (factor for step length) + constexpr Param MUPARAMUB { "separating/lagromory/muparamub" }; + //! factor of mu while backtracking the mu parameter (factor for step length) + constexpr Param MUBACKTRACKFACTOR { "separating/lagromory/mubacktrackfactor" }; + //! factor of mu parameter (factor for step length) for larger increment + constexpr Param MUSLAB1FACTOR { "separating/lagromory/muslab1factor" }; + //! factor of mu parameter (factor for step length) for smaller increment + constexpr Param MUSLAB2FACTOR { "separating/lagromory/muslab2factor" }; + //! factor of mu parameter (factor for step length) for reduction + constexpr Param MUSLAB3FACTOR { "separating/lagromory/muslab3factor" }; + //! factor of delta deciding larger increment of mu parameter (factor for step length) + constexpr Param DELTASLAB1UB { "separating/lagromory/deltaslab1ub" }; + //! factor of delta deciding smaller increment of mu parameter (factor for step length) + constexpr Param DELTASLAB2UB { "separating/lagromory/deltaslab2ub" }; + //! factor for positive upper bound used as an estimate for the optimal Lagrangian dual value + constexpr Param UBPARAMPOSFACTOR { "separating/lagromory/ubparamposfactor" }; + //! factor for negative upper bound used as an estimate for the optimal Lagrangian dual value + constexpr Param UBPARAMNEGFACTOR { "separating/lagromory/ubparamnegfactor" }; + //! factor w.r.t. root node LP iterations for iteration limit of each separating LP (negative for no limit) + constexpr Param PERROOTLPITERFACTOR { "separating/lagromory/perrootlpiterfactor" }; + //! factor w.r.t. non-root node LP iterations for iteration limit of each separating LP (negative for no limit) + constexpr Param PERLPITERFACTOR { "separating/lagromory/perlpiterfactor" }; + //! fraction of generated cuts per explored basis to accept from separator + constexpr Param CUTSFILTERFACTOR { "separating/lagromory/cutsfilterfactor" }; + //! initial radius of the ball used in stabilization of Lagrangian multipliers + constexpr Param RADIUSINIT { "separating/lagromory/radiusinit" }; + //! maximum radius of the ball used in stabilization of Lagrangian multipliers + constexpr Param RADIUSMAX { "separating/lagromory/radiusmax" }; + //! minimum radius of the ball used in stabilization of Lagrangian multipliers + constexpr Param RADIUSMIN { "separating/lagromory/radiusmin" }; + //! a constant for stablity center based stabilization of Lagrangian multipliers + constexpr Param CONSTANT { "separating/lagromory/constant" }; + //! multiplier to evaluate cut violation score used for updating ball radius + constexpr Param RADIUSUPDATEWEIGHT { "separating/lagromory/radiusupdateweight" }; + //! minimum dual degeneracy rate for separator execution + constexpr Param DUALDEGENERACYRATETHRESHOLD { "separating/lagromory/dualdegeneracyratethreshold" }; + //! minimum variable-constraint ratio on optimal face for separator execution + constexpr Param VARCONSRATIOTHRESHOLD { "separating/lagromory/varconsratiothreshold" }; + //! is the mu parameter (factor for step length) constant? + constexpr Param MUPARAMCONST { "separating/lagromory/muparamconst" }; + //! separate rows with integral slack? + constexpr Param SEPARATEROWS { "separating/lagromory/separaterows" }; + //! sort fractional integer columnsbased on fractionality? + constexpr Param SORTCUTOFFSOL { "separating/lagromory/sortcutoffsol" }; + //! choose side types of row (lhs/rhs) based on basis information? + constexpr Param SIDETYPEBASIS { "separating/lagromory/sidetypebasis" }; + //! should generated cuts be removed from LP if they are no longer tight? + constexpr Param DYNAMICCUTS { "separating/lagromory/dynamiccuts" }; + //! try to scale all cuts to integral coefficients? + constexpr Param MAKEINTEGRAL { "separating/lagromory/makeintegral" }; + //! force cuts to be added to the LP? + constexpr Param FORCECUTS { "separating/lagromory/forcecuts" }; + //! should cuts be added to the delayed cut pool + constexpr Param DELAYEDCUTS { "separating/lagromory/delayedcuts" }; + //! should locally valid cuts be generated? + constexpr Param ALLOWLOCAL { "separating/lagromory/allowlocal" }; + //! aggregate all generated cuts using the Lagrangian multipliers? + constexpr Param AGGREGATECUTS { "separating/lagromory/aggregatecuts" }; + //! maximal number of separation rounds per node (-1: unlimited) + constexpr Param MAXROUNDS { "separating/lagromory/maxrounds" }; + //! maximal number of separation rounds in the root node (-1: unlimited) + constexpr Param MAXROUNDSROOT { "separating/lagromory/maxroundsroot" }; + //! maximal number of separating LP iterations per separation round (-1: unlimited) + constexpr Param PERROUNDNMAXLPITERS { "separating/lagromory/perroundnmaxlpiters" }; + //! maximal number of cuts separated per Lagromory LP in the non-root node + constexpr Param NMAXCUTSPERLP { "separating/lagromory/nmaxcutsperlp" }; + //! maximal number of cuts separated per Lagromory LP in the root node + constexpr Param NMAXCUTSPERLPROOT { "separating/lagromory/nmaxcutsperlproot" }; + //! maximal number of main loop iterations of the relax-and-cut algorithm + constexpr Param NMAXMAINITERS { "separating/lagromory/nmaxmainiters" }; + //! maximal number of subgradient loop iterations of the relax-and-cut algorithm + constexpr Param NMAXSUBGRADIENTITERS { "separating/lagromory/nmaxsubgradientiters" }; + //! frequency of subgradient iterations for generating cuts + constexpr Param CUTGENFREQ { "separating/lagromory/cutgenfreq" }; + //! frequency of subgradient iterations for adding cuts to objective function + constexpr Param CUTADDFREQ { "separating/lagromory/cutaddfreq" }; + //! maximal number of iterations for rolling average of Lagrangian value + constexpr Param NMAXLAGRANGIANVALSFORAVG { "separating/lagromory/nmaxlagrangianvalsforavg" }; + //! consecutive number of iterations used to determine if mu needs to be backtracked + constexpr Param NMAXCONSECITERSFORMUUPDATE { "separating/lagromory/nmaxconsecitersformuupdate" }; + //! the ball into which the Lagrangian multipliers are projected for stabilization (0: no projection, 1: L1-norm + //! ball projection, 2: L2-norm ball projection, 3: L_inf-norm ball projection) + constexpr Param PROJECTIONTYPE { "separating/lagromory/projectiontype" }; + //! type of stability center for taking weighted average of Lagrangian multipliers for stabilization (0: no weighted + //! stabilization, 1: best Lagrangian multipliers) + constexpr Param STABILITYCENTERTYPE { "separating/lagromory/stabilitycentertype" }; + //! priority of the optimal face for separator execution (0: low priority, 1: medium priority, 2: high priority) + constexpr Param OPTIMALFACEPRIORITY { "separating/lagromory/optimalfacepriority" }; + //! minimum restart round for separator execution (0: from beginning of the instance solving, \>= n with n \>= 1: + //! from restart round n) + constexpr Param MINRESTART { "separating/lagromory/minrestart" }; +} //! Parameters with prefix separating/mcf namespace SEPARATING::MCF { //! priority of separator \ @@ -6537,11 +7108,6 @@ namespace TABLE::NLPI { //! is statistics table \ active constexpr Param ACTIVE { "table/nlpi/active" }; } -//! Parameters with prefix table/orbitalfixing -namespace TABLE::ORBITALFIXING { - //! is statistics table \ active - constexpr Param ACTIVE { "table/orbitalfixing/active" }; -} //! Parameters with prefix table/origprob namespace TABLE::ORIGPROB { //! is statistics table \ active @@ -6577,6 +7143,11 @@ namespace TABLE::ROOT { //! is statistics table \ active constexpr Param ACTIVE { "table/root/active" }; } +//! Parameters with prefix table/scheduler +namespace TABLE::SCHEDULER { + //! is statistics table \ active + constexpr Param ACTIVE { "table/scheduler/active" }; +} //! Parameters with prefix table/separator namespace TABLE::SEPARATOR { //! is statistics table \ active @@ -6592,6 +7163,11 @@ namespace TABLE::STATUS { //! is statistics table \ active constexpr Param ACTIVE { "table/status/active" }; } +//! Parameters with prefix table/symmetry +namespace TABLE::SYMMETRY { + //! is statistics table \ active + constexpr Param ACTIVE { "table/symmetry/active" }; +} //! Parameters with prefix table/timing namespace TABLE::TIMING { //! is statistics table \ active diff --git a/include/scippp/solving_statistics.hpp b/include/scippp/solving_statistics.hpp index 48099bd0..bc4a875e 100644 --- a/include/scippp/solving_statistics.hpp +++ b/include/scippp/solving_statistics.hpp @@ -5,6 +5,7 @@ #include // the content of this file is auto-generated by extract_solvingstats.py +// updated for SCIP 9.2.0 namespace scippp::statistics {