1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 2 /* */ 3 /* This file is part of the program and library */ 4 /* SCIP --- Solving Constraint Integer Programs */ 5 /* */ 6 /* Copyright (c) 2002-2023 Zuse Institute Berlin (ZIB) */ 7 /* */ 8 /* Licensed under the Apache License, Version 2.0 (the "License"); */ 9 /* you may not use this file except in compliance with the License. */ 10 /* You may obtain a copy of the License at */ 11 /* */ 12 /* http://www.apache.org/licenses/LICENSE-2.0 */ 13 /* */ 14 /* Unless required by applicable law or agreed to in writing, software */ 15 /* distributed under the License is distributed on an "AS IS" BASIS, */ 16 /* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */ 17 /* See the License for the specific language governing permissions and */ 18 /* limitations under the License. */ 19 /* */ 20 /* You should have received a copy of the Apache-2.0 license */ 21 /* along with SCIP; see the file LICENSE. If not visit scipopt.org. */ 22 /* */ 23 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 24 25 /**@file set.c 26 * @ingroup OTHER_CFILES 27 * @brief methods for global SCIP settings 28 * @author Tobias Achterberg 29 * @author Timo Berthold 30 * 31 * @todo Functions like SCIPsetFeastol() are misleading (it seems that the feasibility tolerance can be set). 32 * Rename all functions starting with SCIPsetXXX, e.g., SCIPsetGetFeastol() and SCIPsetSetFeastol(). 33 */ 34 35 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/ 36 37 #include <assert.h> 38 #include <string.h> 39 #include <math.h> 40 41 #include "scip/def.h" 42 #include "scip/set.h" 43 #include "scip/stat.h" 44 #include "scip/clock.h" 45 #include "scip/event.h" 46 #include "scip/lp.h" 47 #include "scip/paramset.h" 48 #include "scip/scip.h" 49 #include "scip/bandit.h" 50 #include "scip/branch.h" 51 #include "scip/conflict.h" 52 #include "scip/cons.h" 53 #include "scip/disp.h" 54 #include "scip/dialog.h" 55 #include "scip/heur.h" 56 #include "scip/concsolver.h" 57 #include "scip/compr.h" 58 #include "scip/nodesel.h" 59 #include "scip/presol.h" 60 #include "scip/pricer.h" 61 #include "scip/reader.h" 62 #include "scip/relax.h" 63 #include "scip/sepa.h" 64 #include "scip/cutsel.h" 65 #include "scip/table.h" 66 #include "scip/prop.h" 67 #include "scip/benders.h" 68 #include "scip/expr.h" 69 #include "scip/nlpi.h" 70 #include "scip/pub_nlpi.h" 71 #include "scip/struct_scip.h" /* for SCIPsetPrintDebugMessage() */ 72 73 /* 74 * Default settings 75 */ 76 77 78 /* Branching */ 79 80 #define SCIP_DEFAULT_BRANCH_SCOREFUNC 'p' /**< branching score function ('s'um, 'p'roduct) */ 81 #define SCIP_DEFAULT_BRANCH_SCOREFAC 0.167 /**< branching score factor to weigh downward and upward gain prediction 82 * in sum score function */ 83 #define SCIP_DEFAULT_BRANCH_PREFERBINARY FALSE /**< should branching on binary variables be preferred? */ 84 #define SCIP_DEFAULT_BRANCH_CLAMP 0.2 /**< minimal fractional distance of branching point to a continuous variable' 85 * bounds; a value of 0.5 leads to branching always in the middle of a bounded domain */ 86 #define SCIP_DEFAULT_BRANCH_MIDPULL 0.75 /**< fraction by which to move branching point of a continuous variable towards the middle of the domain */ 87 #define SCIP_DEFAULT_BRANCH_MIDPULLRELDOMTRIG 0.5 /**< multiply midpull by relative domain width if the latter is below this value */ 88 #define SCIP_DEFAULT_BRANCH_LPGAINNORMALIZE 's' /**< strategy for normalizing LP gain when updating pseudo costs of continuous variables */ 89 #define SCIP_DEFAULT_BRANCH_DELAYPSCOST TRUE /**< should updating pseudo costs of continuous variables be delayed to after separation */ 90 #define SCIP_DEFAULT_BRANCH_DIVINGPSCOST TRUE /**< should pseudo costs be updated also in diving and probing mode? */ 91 #define SCIP_DEFAULT_BRANCH_FORCEALL FALSE /**< should all strong branching children be regarded even if 92 * one is detected to be infeasible? (only with propagation) */ 93 #define SCIP_DEFAULT_BRANCH_FIRSTSBCHILD 'a' /**< child node to be regarded first during strong branching (only with propagation): 'u'p child, 'd'own child, 'h'istory-based, or 'a'utomatic */ 94 #define SCIP_DEFAULT_BRANCH_CHECKSBSOL TRUE /**< should LP solutions during strong branching with propagation be checked for feasibility? */ 95 #define SCIP_DEFAULT_BRANCH_ROUNDSBSOL TRUE /**< should LP solutions during strong branching with propagation be rounded? (only when checksbsol=TRUE) */ 96 #define SCIP_DEFAULT_BRANCH_SUMADJUSTSCORE FALSE /**< score adjustment near zero by adding epsilon (TRUE) or using maximum (FALSE) */ 97 98 /* Tree Compression */ 99 100 #define SCIP_DEFAULT_COMPR_ENABLE FALSE /**< should automatic tree compression in reoptimization after presolving be enabled? */ 101 102 103 /* Conflict Analysis (general) */ 104 105 #define SCIP_DEFAULT_CONF_ENABLE TRUE /**< conflict analysis be enabled? */ 106 #define SCIP_DEFAULT_CONF_MAXVARSFAC 0.15 /**< maximal fraction of variables involved in a conflict constraint */ 107 #define SCIP_DEFAULT_CONF_MINMAXVARS 0 /**< minimal absolute maximum of variables involved in a conflict constraint */ 108 #define SCIP_DEFAULT_CONF_MAXLPLOOPS 2 /**< maximal number of LP resolving loops during conflict analysis 109 * (-1: no limit) */ 110 #define SCIP_DEFAULT_CONF_LPITERATIONS 10 /**< maximal number of LP iterations in each LP resolving loop 111 * (-1: no limit) */ 112 #define SCIP_DEFAULT_CONF_USEPROP TRUE /**< should propagation conflict analysis be used? */ 113 #define SCIP_DEFAULT_CONF_USEINFLP 'b' /**< should infeasible LP conflict analysis be used? 114 * ('o'ff, 'c'onflict graph, 'd'ual ray, 'b'oth conflict graph and dual ray) 115 */ 116 #define SCIP_DEFAULT_CONF_USEBOUNDLP 'b' /**< should bound exceeding LP conflict analysis be used? 117 * ('o'ff, 'c'onflict graph, 'd'ual ray, 'b'oth conflict graph and dual solution) 118 */ 119 #define SCIP_DEFAULT_CONF_USESB TRUE /**< should infeasible/bound exceeding strong branching conflict analysis 120 * be used? */ 121 #define SCIP_DEFAULT_CONF_USEPSEUDO TRUE /**< should pseudo solution conflict analysis be used? */ 122 #define SCIP_DEFAULT_CONF_PREFINFPROOF TRUE /**< prefer infeasibility proof to boundexceeding proof */ 123 #define SCIP_DEFAULT_CONF_SEPARATE TRUE /**< should the conflict constraints be separated? */ 124 #define SCIP_DEFAULT_CONF_DYNAMIC TRUE /**< should the conflict constraints be subject to aging? */ 125 126 127 /* Conflict Analysis (conflict graph) */ 128 129 #define SCIP_DEFAULT_CONF_MAXSTORESIZE 10000 /**< maximal size of the conflict pool */ 130 #define SCIP_DEFAULT_CONF_RECONVLEVELS -1 /**< number of depth levels up to which UIP reconvergence constraints are 131 * generated (-1: generate reconvergence constraints in all depth levels) */ 132 #define SCIP_DEFAULT_CONF_CLEANBNDDEPEND TRUE /**< should conflicts based on an old cutoff bound removed? */ 133 #define SCIP_DEFAULT_CONF_FUIPLEVELS -1 /**< number of depth levels up to which first UIP's are used in conflict 134 * analysis (-1: use All-FirstUIP rule) */ 135 #define SCIP_DEFAULT_CONF_INTERCONSS -1 /**< maximal number of intermediate conflict constraints generated in 136 * conflict graph (-1: use every intermediate constraint) */ 137 #define SCIP_DEFAULT_CONF_MAXCONSS 10 /**< maximal number of conflict constraints accepted at an infeasible node 138 * (-1: use all generated conflict constraints) */ 139 #define SCIP_DEFAULT_CONF_PREFERBINARY FALSE /**< should binary conflicts be preferred? */ 140 #define SCIP_DEFAULT_CONF_ALLOWLOCAL TRUE /**< should conflict constraints be generated that are only valid locally? */ 141 #define SCIP_DEFAULT_CONF_SETTLELOCAL FALSE /**< should conflict constraints be attached only to the local subtree 142 * where they can be useful? */ 143 #define SCIP_DEFAULT_CONF_REPROPAGATE TRUE /**< should earlier nodes be repropagated in order to replace branching 144 * decisions by deductions? */ 145 #define SCIP_DEFAULT_CONF_KEEPREPROP TRUE /**< should constraints be kept for repropagation even if they are too long? */ 146 #define SCIP_DEFAULT_CONF_REMOVEABLE TRUE /**< should the conflict's relaxations be subject to LP aging and cleanup? */ 147 #define SCIP_DEFAULT_CONF_DEPTHSCOREFAC 1.0 /**< score factor for depth level in bound relaxation heuristic of LP analysis */ 148 #define SCIP_DEFAULT_CONF_PROOFSCOREFAC 1.0 /**< score factor for impact on acticity in bound relaxation heuristic of LP analysis */ 149 #define SCIP_DEFAULT_CONF_UPLOCKSCOREFAC 0.0 /**< score factor for up locks in bound relaxation heuristic of LP analysis */ 150 #define SCIP_DEFAULT_CONF_DOWNLOCKSCOREFAC 0.0 /**< score factor for down locks in bound relaxation heuristic of LP analysis */ 151 #define SCIP_DEFAULT_CONF_SCOREFAC 0.98 /**< factor to decrease importance of variables' earlier conflict scores */ 152 #define SCIP_DEFAULT_CONF_RESTARTNUM 0 /**< number of successful conflict analysis calls that trigger a restart 153 * (0: disable conflict restarts) */ 154 #define SCIP_DEFAULT_CONF_RESTARTFAC 1.5 /**< factor to increase restartnum with after each restart */ 155 #define SCIP_DEFAULT_CONF_IGNORERELAXEDBD FALSE /**< should relaxed bounds be ignored? */ 156 #define SCIP_DEFAULT_CONF_MAXVARSDETECTIMPLIEDBOUNDS 250 /**< maximal number of variables to try to detect global bound implications and shorten the whole conflict set (0: disabled) */ 157 #define SCIP_DEFAULT_CONF_FULLSHORTENCONFLICT TRUE /**< try to shorten the whole conflict set or terminate early (depending on the 'maxvarsdetectimpliedbounds' parameter) */ 158 #define SCIP_DEFAULT_CONF_CONFLITWEIGHT 0.0 /**< the weight the VSIDS score is weight by updating the VSIDS for a variable if it is part of a conflict */ 159 #define SCIP_DEFAULT_CONF_CONFLITGRAPHWEIGHT 1.0/**< the weight the VSIDS score is weight by updating the VSIDS for a variable if it is part of a conflict graph */ 160 #define SCIP_DEFAULT_CONF_WEIGHTSIZE 0.001 /**< weight of the size of a conflict used in score calculation */ 161 #define SCIP_DEFAULT_CONF_WEIGHTREPROPDEPTH 0.1 /**< weight of the repropagation depth of a conflict used in score calculation */ 162 #define SCIP_DEFAULT_CONF_WEIGHTVALIDDEPTH 1.0 /**< weight of the valid depth of a conflict used in score calculation */ 163 #define SCIP_DEFAULT_CONF_MINIMPROVE 0.05 /**< minimal improvement of primal bound to remove conflicts based on a previous incumbent */ 164 165 /* Conflict Analysis (dual ray) */ 166 167 #define SCIP_DEFAULT_CONF_SEPAALTPROOFS FALSE /**< apply cut generating functions to construct alternative proofs */ 168 #define SCIP_DEFAULT_CONF_USELOCALROWS TRUE /**< use local rows to construct infeasibility proofs */ 169 170 /* Constraints */ 171 172 #define SCIP_DEFAULT_CONS_AGELIMIT 0 /**< maximum age an unnecessary constraint can reach before it is deleted 173 * (0: dynamic adjustment, -1: constraints are never deleted) */ 174 #define SCIP_DEFAULT_CONS_OBSOLETEAGE -1 /**< age of a constraint after which it is marked obsolete 175 * (0: dynamic adjustment, -1: constraints are never marked obsolete) */ 176 #define SCIP_DEFAULT_CONS_DISABLEENFOPS FALSE /**< should enforcement of pseudo solution be disabled? */ 177 178 179 /* Display */ 180 181 #define SCIP_DEFAULT_DISP_VERBLEVEL SCIP_VERBLEVEL_HIGH /**< verbosity level of output */ 182 #define SCIP_DEFAULT_DISP_WIDTH 143 /**< maximal number of characters in a node information line */ 183 #define SCIP_DEFAULT_DISP_FREQ 100 /**< frequency for displaying node information lines */ 184 #define SCIP_DEFAULT_DISP_HEADERFREQ 15 /**< frequency for displaying header lines (every n'th node info line) */ 185 #define SCIP_DEFAULT_DISP_LPINFO FALSE /**< should the LP solver display status messages? */ 186 #define SCIP_DEFAULT_DISP_ALLVIOLS FALSE /**< display all violations of the best solution after the solving process finished? */ 187 #define SCIP_DEFAULT_DISP_RELEVANTSTATS TRUE /**< should the relevant statistics be displayed at the end of solving? */ 188 189 /* Heuristics */ 190 191 #define SCIP_DEFAULT_HEUR_USEUCTSUBSCIP FALSE /**< should setting of common subscip parameters include the activation of the UCT node selector? */ 192 193 /* History */ 194 195 #define SCIP_DEFAULT_HISTORY_VALUEBASED FALSE /**< should statistics be collected for variable domain value pairs */ 196 #define SCIP_DEFAULT_HISTORY_ALLOWMERGE FALSE /**< should variable histories be merged from sub-SCIPs whenever possible? */ 197 #define SCIP_DEFAULT_HISTORY_ALLOWTRANSFER FALSE /**< should variable histories be transferred to initialize SCIP copies? */ 198 199 /* Limits */ 200 201 #define SCIP_DEFAULT_LIMIT_TIME 1e+20 /**< maximal time in seconds to run */ 202 #define SCIP_DEFAULT_LIMIT_MEMORY SCIP_MEM_NOLIMIT/**< maximal memory usage in MB */ 203 #define SCIP_DEFAULT_LIMIT_GAP 0.0 /**< solving stops, if the gap is below the given value */ 204 #define SCIP_DEFAULT_LIMIT_ABSGAP 0.0 /**< solving stops, if the absolute difference between primal and dual 205 * bound reaches this value */ 206 #define SCIP_DEFAULT_LIMIT_OBJSTOP SCIP_INVALID /**< solving stops, if solution is found that is at least as good as given value */ 207 #define SCIP_DEFAULT_LIMIT_NODES -1LL /**< maximal number of nodes to process (-1: no limit) */ 208 #define SCIP_DEFAULT_LIMIT_STALLNODES -1LL /**< solving stops, if the given number of nodes was processed since the 209 * last improvement of the primal solution value (-1: no limit) */ 210 #define SCIP_DEFAULT_LIMIT_SOLUTIONS -1 /**< solving stops, if given number of sols were found (-1: no limit) */ 211 #define SCIP_DEFAULT_LIMIT_BESTSOL -1 /**< solving stops, if given number of solution improvements were found 212 * (-1: no limit) */ 213 #define SCIP_DEFAULT_LIMIT_MAXSOL 100 /**< maximal number of solutions to store in the solution storage */ 214 #define SCIP_DEFAULT_LIMIT_MAXORIGSOL 10 /**< maximal number of solutions candidates to store in the solution storage of the original problem */ 215 #define SCIP_DEFAULT_LIMIT_RESTARTS -1 /**< solving stops, if the given number of restarts was triggered (-1: no limit) */ 216 #define SCIP_DEFAULT_LIMIT_AUTORESTARTNODES -1 /**< if solve exceeds this number of nodes, an automatic restart is triggered (-1: no automatic restart)*/ 217 218 219 /* LP */ 220 221 #define SCIP_DEFAULT_LP_SOLVEFREQ 1 /**< frequency for solving LP at the nodes; -1: never; 0: only root LP */ 222 #define SCIP_DEFAULT_LP_ITERLIM -1LL /**< iteration limit for each single LP solve; -1: no limit */ 223 #define SCIP_DEFAULT_LP_ROOTITERLIM -1LL /**< iteration limit for initial root LP solve; -1: no limit */ 224 #define SCIP_DEFAULT_LP_SOLVEDEPTH -1 /**< maximal depth for solving LPs (-1: no depth limit) */ 225 #define SCIP_DEFAULT_LP_INITALGORITHM 's' /**< LP algorithm for solving initial LP relaxations ('s'implex, 'b'arrier, 226 * barrier with 'c'rossover) */ 227 #define SCIP_DEFAULT_LP_RESOLVEALGORITHM 's' /**< LP algorithm for resolving LP relaxations if a starting basis exists 228 * ('s'implex, 'b'arrier, barrier with 'c'rossover) */ 229 #define SCIP_DEFAULT_LP_PRICING 'l' /**< LP pricing strategy ('l'pi default, 'a'uto, 'f'ull pricing, 'p'artial, 230 * 's'teepest edge pricing, 'q'uickstart steepest edge pricing, 231 * 'd'evex pricing) */ 232 #define SCIP_DEFAULT_LP_CLEARINITIALPROBINGLP TRUE/**< should lp state be cleared at the end of probing mode when lp 233 * was initially unsolved, e.g., when called right after presolving? */ 234 #define SCIP_DEFAULT_LP_RESOLVERESTORE FALSE /**< should the LP be resolved to restore the state at start of diving (if FALSE we buffer the solution values)? */ 235 #define SCIP_DEFAULT_LP_FREESOLVALBUFFERS FALSE /**< should the buffers for storing LP solution values during diving be freed at end of diving? */ 236 #define SCIP_DEFAULT_LP_COLAGELIMIT 10 /**< maximum age a dynamic column can reach before it is deleted from SCIP_LP 237 * (-1: don't delete columns due to aging) */ 238 #define SCIP_DEFAULT_LP_ROWAGELIMIT 10 /**< maximum age a dynamic row can reach before it is deleted from SCIP_LP 239 * (-1: don't delete rows due to aging) */ 240 #define SCIP_DEFAULT_LP_CLEANUPCOLS FALSE /**< should new non-basic columns be removed after LP solving? */ 241 #define SCIP_DEFAULT_LP_CLEANUPCOLSROOT FALSE /**< should new non-basic columns be removed after root LP solving? */ 242 #define SCIP_DEFAULT_LP_CLEANUPROWS TRUE /**< should new basic rows be removed after LP solving? */ 243 #define SCIP_DEFAULT_LP_CLEANUPROWSROOT TRUE /**< should new basic rows be removed after root LP solving? */ 244 #define SCIP_DEFAULT_LP_CHECKSTABILITY TRUE /**< should LP solver's return status be checked for stability? */ 245 #define SCIP_DEFAULT_LP_CONDITIONLIMIT -1.0 /**< maximum condition number of LP basis counted as stable (-1.0: no limit) */ 246 #define SCIP_DEFAULT_LP_MARKOWITZ 0.01 /**< minimal Markowitz threshold to control sparsity/stability in LU factorization */ 247 #define SCIP_DEFAULT_LP_CHECKPRIMFEAS TRUE /**< should LP solutions be checked for primal feasibility to resolve LP at numerical troubles? */ 248 #define SCIP_DEFAULT_LP_CHECKDUALFEAS TRUE /**< should LP solutions be checked for dual feasibility to resolve LP at numerical troubles? */ 249 #define SCIP_DEFAULT_LP_CHECKFARKAS TRUE /**< should infeasibility proofs from the LP be checked? */ 250 #define SCIP_DEFAULT_LP_FASTMIP 1 /**< should FASTMIP setting of LP solver be used? */ 251 #define SCIP_DEFAULT_LP_SCALING 1 /**< LP scaling (0: none, 1: normal, 2: aggressive) */ 252 #define SCIP_DEFAULT_LP_PRESOLVING TRUE /**< should presolving of LP solver be used? */ 253 #define SCIP_DEFAULT_LP_LEXDUALALGO FALSE /**< should the dual lexicographic algorithm be used? */ 254 #define SCIP_DEFAULT_LP_LEXDUALROOTONLY TRUE /**< should the lexicographic dual algorithm be applied only at the root node */ 255 #define SCIP_DEFAULT_LP_LEXDUALMAXROUNDS 2 /**< maximum number of rounds in the dual lexicographic algorithm */ 256 #define SCIP_DEFAULT_LP_LEXDUALBASIC FALSE /**< choose fractional basic variables in lexicographic dual algorithm */ 257 #define SCIP_DEFAULT_LP_LEXDUALSTALLING TRUE /**< turn on the lex dual algorithm only when stalling? */ 258 #define SCIP_DEFAULT_LP_DISABLECUTOFF 2 /**< disable the cutoff bound in the LP solver? (0: enabled, 1: disabled, 2: auto) */ 259 #define SCIP_DEFAULT_LP_ROWREPSWITCH 1.2 /**< simplex algorithm shall use row representation of the basis 260 * if number of rows divided by number of columns exceeds this value */ 261 #define SCIP_DEFAULT_LP_THREADS 0 /**< number of threads used for solving the LP (0: automatic) */ 262 #define SCIP_DEFAULT_LP_RESOLVEITERFAC -1.0 /**< factor of average LP iterations that is used as LP iteration limit 263 * for LP resolve (-1.0: unlimited) */ 264 #define SCIP_DEFAULT_LP_RESOLVEITERMIN 1000 /**< minimum number of iterations that are allowed for LP resolve */ 265 #define SCIP_DEFAULT_LP_SOLUTIONPOLISHING 3 /**< LP solution polishing method (0: disabled, 1: only root, 2: always, 3: auto) */ 266 #define SCIP_DEFAULT_LP_REFACTORINTERVAL 0 /**< LP refactorization interval (0: automatic) */ 267 #define SCIP_DEFAULT_LP_ALWAYSGETDUALS FALSE /**< should the dual solution always be collected */ 268 269 /* NLP */ 270 271 #define SCIP_DEFAULT_NLP_SOLVER "" /**< name of NLP solver to use, or "" if solver should be chosen by priority */ 272 #define SCIP_DEFAULT_NLP_DISABLE FALSE /**< should the NLP be always disabled? */ 273 274 275 /* Memory */ 276 277 #define SCIP_DEFAULT_MEM_SAVEFAC 0.8 /**< fraction of maximal mem usage when switching to memory saving mode */ 278 #define SCIP_DEFAULT_MEM_TREEGROWFAC 2.0 /**< memory growing factor for tree array */ 279 #define SCIP_DEFAULT_MEM_PATHGROWFAC 2.0 /**< memory growing factor for path array */ 280 #define SCIP_DEFAULT_MEM_TREEGROWINIT 65536 /**< initial size of tree array */ 281 #define SCIP_DEFAULT_MEM_PATHGROWINIT 256 /**< initial size of path array */ 282 283 284 /* Miscellaneous */ 285 286 #define SCIP_DEFAULT_MISC_CATCHCTRLC TRUE /**< should the CTRL-C interrupt be caught by SCIP? */ 287 #define SCIP_DEFAULT_MISC_USEVARTABLE TRUE /**< should a hashtable be used to map from variable names to variables? */ 288 #define SCIP_DEFAULT_MISC_USECONSTABLE TRUE /**< should a hashtable be used to map from constraint names to constraints? */ 289 #define SCIP_DEFAULT_MISC_USESMALLTABLES FALSE /**< should smaller hashtables be used? yields better performance for small problems with about 100 variables */ 290 #define SCIP_DEFAULT_MISC_EXACTSOLVE FALSE /**< should the problem be solved exactly (with proven dual bounds)? */ 291 #define SCIP_DEFAULT_MISC_RESETSTAT TRUE /**< should the statistics be reset if the transformed problem is 292 * freed otherwise the statistics get reset after original problem is 293 * freed (in case of Benders' decomposition this parameter should be set 294 * to FALSE and therefore can be used to collect statistics over all 295 * runs) */ 296 #define SCIP_DEFAULT_MISC_IMPROVINGSOLS FALSE /**< should only solutions be checked which improve the primal bound */ 297 #define SCIP_DEFAULT_MISC_PRINTREASON TRUE /**< should the reason be printed if a given start solution is infeasible? */ 298 #define SCIP_DEFAULT_MISC_ESTIMEXTERNMEM TRUE /**< should the usage of external memory be estimated? */ 299 #define SCIP_DEFAULT_MISC_AVOIDMEMOUT TRUE /**< try to avoid running into memory limit by restricting plugins like heuristics? */ 300 #define SCIP_DEFAULT_MISC_TRANSORIGSOLS TRUE /**< should SCIP try to transfer original solutions to the transformed space (after presolving)? */ 301 #define SCIP_DEFAULT_MISC_TRANSSOLSORIG TRUE /**< should SCIP try to transfer transformed solutions to the original space (after solving)? */ 302 #define SCIP_DEFAULT_MISC_CALCINTEGRAL TRUE /**< should SCIP calculate the primal dual integral? */ 303 #define SCIP_DEFAULT_MISC_FINITESOLSTORE FALSE /**< should SCIP try to remove infinite fixings from solutions copied to the solution store? */ 304 #define SCIP_DEFAULT_MISC_OUTPUTORIGSOL TRUE /**< should the best solution be transformed to the orignal space and be output in command line run? */ 305 #define SCIP_DEFAULT_MISC_ALLOWSTRONGDUALREDS TRUE /**< should strong dual reductions be allowed in propagation and presolving? */ 306 #define SCIP_DEFAULT_MISC_ALLOWWEAKDUALREDS TRUE /**< should weak dual reductions be allowed in propagation and presolving? */ 307 #define SCIP_DEFAULT_MISC_REFERENCEVALUE 1e99 /**< objective value for reference purposes */ 308 #define SCIP_DEFAULT_MISC_USESYMMETRY 7 /**< bitset describing used symmetry handling technique (0: off; 1: polyhedral (orbitopes and/or symresacks) 309 * 2: orbital fixing; 3: orbitopes and orbital fixing; 4: Schreier Sims cuts; 5: Schreier Sims cuts and 310 * orbitopes); 6: Schreier Sims cuts and orbital fixing; 7: Schreier Sims cuts, orbitopes, and orbital 311 * fixing, see type_symmetry.h */ 312 #define SCIP_DEFAULT_MISC_SCALEOBJ TRUE /**< should the objective function be scaled? */ 313 #define SCIP_DEFAULT_MISC_SHOWDIVINGSTATS FALSE /**< should detailed statistics for diving heuristics be shown? */ 314 315 #ifdef WITH_DEBUG_SOLUTION 316 #define SCIP_DEFAULT_MISC_DEBUGSOLUTION "-" /**< path to a debug solution */ 317 #endif 318 319 /* Randomization */ 320 #define SCIP_DEFAULT_RANDOM_RANDSEEDSHIFT 0 /**< global shift of all random seeds in the plugins, this will have no impact on the permutation and LP seeds */ 321 #define SCIP_DEFAULT_RANDOM_PERMUTATIONSEED 0 /**< seed value for permuting the problem after reading/transformation (0: no permutation) */ 322 #define SCIP_DEFAULT_RANDOM_LPSEED 0 /**< random seed for LP solver, e.g. for perturbations in the simplex (0: LP default) */ 323 #define SCIP_DEFAULT_RANDOM_PERMUTECONSS TRUE /**< should order of constraints be permuted (depends on permutationseed)? */ 324 #define SCIP_DEFAULT_RANDOM_PERMUTEVARS FALSE /**< should order of variables be permuted (depends on permutationseed)? */ 325 326 327 /* Node Selection */ 328 329 #define SCIP_DEFAULT_NODESEL_CHILDSEL 'h' /**< child selection rule ('d'own, 'u'p, 'p'seudo costs, 'i'nference, 'l'p value, 330 * 'r'oot LP value difference, 'h'brid inference/root LP value difference) */ 331 332 333 /* Presolving */ 334 335 #define SCIP_DEFAULT_PRESOL_ABORTFAC 8e-04 /**< abort presolve, if at most this fraction of the problem was changed 336 * in last presolve round */ 337 #define SCIP_DEFAULT_PRESOL_MAXROUNDS -1 /**< maximal number of presolving rounds (-1: unlimited, 0: off) */ 338 #define SCIP_DEFAULT_PRESOL_MAXRESTARTS -1 /**< maximal number of restarts (-1: unlimited) */ 339 #define SCIP_DEFAULT_PRESOL_CLQTABLEFAC 2.0 /**< limit on number of entries in clique table relative to number of problem nonzeros */ 340 #define SCIP_DEFAULT_PRESOL_RESTARTFAC 0.025 /**< fraction of integer variables that were fixed in the root node 341 * triggering a restart with preprocessing after root node evaluation */ 342 #define SCIP_DEFAULT_PRESOL_IMMRESTARTFAC 0.10 /**< fraction of integer variables that were fixed in the root node triggering an 343 * immediate restart with preprocessing */ 344 #define SCIP_DEFAULT_PRESOL_SUBRESTARTFAC 1.00 /**< fraction of integer variables that were globally fixed during the 345 * solving process triggering a restart with preprocessing */ 346 #define SCIP_DEFAULT_PRESOL_RESTARTMINRED 0.10 /**< minimal fraction of integer variables removed after restart to allow 347 * for an additional restart */ 348 #define SCIP_DEFAULT_PRESOL_DONOTMULTAGGR FALSE /**< should multi-aggregation of variables be forbidden? */ 349 #define SCIP_DEFAULT_PRESOL_DONOTAGGR FALSE /**< should aggregation of variables be forbidden? */ 350 351 352 /* Pricing */ 353 354 #define SCIP_DEFAULT_PRICE_ABORTFAC 2.0 /**< pricing is aborted, if fac * price_maxvars pricing candidates were 355 * found */ 356 #define SCIP_DEFAULT_PRICE_MAXVARS 100 /**< maximal number of variables priced in per pricing round */ 357 #define SCIP_DEFAULT_PRICE_MAXVARSROOT 2000 /**< maximal number of priced variables at the root node */ 358 #define SCIP_DEFAULT_PRICE_DELVARS FALSE /**< should variables created at the current node be deleted when the node is solved 359 * in case they are not present in the LP anymore? */ 360 #define SCIP_DEFAULT_PRICE_DELVARSROOT FALSE /**< should variables created at the root node be deleted when the root is solved 361 * in case they are not present in the LP anymore? */ 362 363 /* Decomposition */ 364 #define SCIP_DEFAULT_DECOMP_BENDERSLABELS FALSE /**< should the variables be labelled for the application of Benders' decomposition */ 365 #define SCIP_DEFAULT_DECOMP_APPLYBENDERS FALSE /**< if a decomposition exists, should Benders' decomposition be applied? */ 366 #define SCIP_DEFAULT_DECOMP_MAXGRAPHEDGE 10000 /**< maximum number of edges in block graph computation (-1: no limit, 0: disable block graph computation) */ 367 #define SCIP_DEFAULT_DECOMP_DISABLEMEASURES FALSE /**< disable expensive measures */ 368 369 /* Benders' decomposition */ 370 #define SCIP_DEFAULT_BENDERS_SOLTOL 1e-6 /**< the tolerance used to determine optimality in Benders' decomposition */ 371 #define SCIP_DEFAULT_BENDERS_CUTLPSOL TRUE /**< should Benders' cuts be generated from the LP solution? */ 372 #define SCIP_DEFAULT_BENDERS_COPYBENDERS TRUE /**< should Benders' decomposition be copied for sub-SCIPs? */ 373 374 /* Reoptimization */ 375 376 #define SCIP_DEFAULT_REOPT_OBJSIMSOL -1.0 /**< re-use stored solutions only if the similarity of the new and the old objective 377 function is greater or equal than this value */ 378 #define SCIP_DEFAULT_REOPT_OBJSIMROOTLP 0.8 /**< similarity of two sequential objective function to disable solving the root LP. */ 379 #define SCIP_DEFAULT_REOPT_OBJSIMDELAY -1.0 /**< start reoptimizing the search if the new objective function has similarity of 380 * at least SCIP_DEFAULT_REOPT_DELAY w.r.t. the previous objective function. */ 381 #define SCIP_DEFAULT_REOPT_VARORDERINTERDICTION 'd' /** use 'd'efault, 'r'andom or 'i'nference score for variable 382 * ordering when performing interdiction branching during 383 * reoptimization of nodes 384 */ 385 #define SCIP_DEFAULT_REOPT_MAXSAVEDNODES INT_MAX/**< maximum number of saved nodes */ 386 #define SCIP_DEFAULT_REOPT_MAXDIFFOFNODES INT_MAX/**< maximum number of bound changes of two ancestor nodes 387 * such that the path get not shrunk */ 388 #define SCIP_DEFAULT_REOPT_FORCEHEURRESTART 3 /**< force a restart if the last n optimal solutions are found by 389 * reoptsols heuristic 390 */ 391 #define SCIP_DEFAULT_REOPT_SAVESOLS INT_MAX/**< save n best solutions found so far. */ 392 #define SCIP_DEFAULT_REOPT_SOLVELP 1 /**< strategy for solving the LP at nodes from reoptimization */ 393 #define SCIP_DEFAULT_REOPT_SOLVELPDIFF 1 /**< difference of path length between two ancestor nodes to solve the LP */ 394 #define SCIP_DEFAULT_REOPT_ENABLE FALSE /**< enable reoptimization */ 395 #define SCIP_DEFAULT_REOPT_SEPAGLBINFSUBTREES TRUE/**< save global constraints to separate infeasible subtrees */ 396 #define SCIP_DEFAULT_REOPT_SEPABESTSOL FALSE /**< separate the optimal solution, e.g., for solving constraint shortest 397 * path problems 398 */ 399 #define SCIP_DEFAULT_REOPT_STOREVARHISTOTY FALSE/**< use the variable history of the previous solve if the objective 400 * function has changed only slightly 401 */ 402 #define SCIP_DEFAULT_REOPT_USEPSCOST FALSE /**< re-use pseudo costs of the objective function changed only slightly */ 403 #define SCIP_DEFAULT_REOPT_COMMONTIMELIMIT FALSE/**< is the given time limit for all reoptimization round? */ 404 #define SCIP_DEFAULT_REOPT_SHRINKINNER TRUE /**< replace branched transit nodes by their child nodes, if the number 405 * of bound changes is not to large 406 */ 407 #define SCIP_DEFAULT_REOPT_STRONGBRANCHINIT TRUE/**< try to fix variables before reoptimizing by probing like strong 408 * branching 409 */ 410 #define SCIP_DEFAULT_REOPT_REDUCETOFRONTIER TRUE/**< delete stored nodes which were not reoptimized */ 411 #define SCIP_DEFAULT_REOPT_SAVECONSPROP FALSE/**< save constraint propagation */ 412 #define SCIP_DEFAULT_REOPT_USESPLITCONS TRUE /**< use constraints to reconstruct the subtree pruned be dual reduction 413 * when reactivating the node 414 */ 415 #define SCIP_DEFAULT_REOPT_USECUTS FALSE /**< reoptimize cuts found at the root node */ 416 #define SCIP_DEFAULT_REOPT_MAXCUTAGE 0 /**< maximal age of a cut to be use for reoptimization */ 417 418 /* Propagating */ 419 420 #define SCIP_DEFAULT_PROP_MAXROUNDS 100 /**< maximal number of propagation rounds per node (-1: unlimited) */ 421 #define SCIP_DEFAULT_PROP_MAXROUNDSROOT 1000 /**< maximal number of propagation rounds in root node (-1: unlimited) */ 422 #define SCIP_DEFAULT_PROP_ABORTONCUTOFF TRUE /**< should propagation be aborted immediately? setting this to FALSE could 423 * help conflict analysis to produce more conflict constraints */ 424 425 426 /* Separation */ 427 428 #define SCIP_DEFAULT_SEPA_MAXBOUNDDIST 1.0 /**< maximal relative distance from current node's dual bound to primal 429 * bound compared to best node's dual bound for applying separation 430 * (0.0: only on current best node, 1.0: on all nodes) */ 431 #define SCIP_DEFAULT_SEPA_MAXLOCALBOUNDDIST 0.0 /**< maximal relative distance from current node's dual bound to primal 432 * bound compared to best node's dual bound for applying local separation 433 * (0.0: only on current best node, 1.0: on all nodes) */ 434 #define SCIP_DEFAULT_SEPA_MAXCOEFRATIO 1e+4 /**< maximal ratio between coefficients in strongcg, cmir, and flowcover cuts */ 435 #define SCIP_DEFAULT_SEPA_MAXCOEFRATIOFACROWPREP 10.0 /**< maximal ratio between coefficients (as factor of 1/feastol) to ensure in rowprep cleanup */ 436 #define SCIP_DEFAULT_SEPA_MINEFFICACY 1e-4 /**< minimal efficacy for a cut to enter the LP */ 437 #define SCIP_DEFAULT_SEPA_MINEFFICACYROOT 1e-4 /**< minimal efficacy for a cut to enter the LP in the root node */ 438 #define SCIP_DEFAULT_SEPA_ORTHOFUNC 'e' /**< function used for calc. scalar prod. in orthogonality test ('e'uclidean, 'd'iscrete) */ 439 #define SCIP_DEFAULT_SEPA_EFFICACYNORM 'e' /**< row norm to use for efficacy calculation ('e'uclidean, 'm'aximum, 440 * 's'um, 'd'iscrete) */ 441 #define SCIP_DEFAULT_SEPA_CUTSELRESTART 'a' /**< cut selection during restart ('a'ge, activity 'q'uotient) */ 442 #define SCIP_DEFAULT_SEPA_CUTSELSUBSCIP 'a' /**< cut selection for sub SCIPs ('a'ge, activity 'q'uotient) */ 443 #define SCIP_DEFAULT_SEPA_FILTERCUTPOOLREL FALSE /**< should cutpool separate only cuts with high relative efficacy? */ 444 #define SCIP_DEFAULT_SEPA_MAXRUNS -1 /**< maximal number of runs for which separation is enabled (-1: unlimited) */ 445 #define SCIP_DEFAULT_SEPA_MAXROUNDS -1 /**< maximal number of separation rounds per node (-1: unlimited) */ 446 #define SCIP_DEFAULT_SEPA_MAXROUNDSROOT -1 /**< maximal number of separation rounds in the root node (-1: unlimited) */ 447 #define SCIP_DEFAULT_SEPA_MAXROUNDSROOTSUBRUN -1 /**< maximal number of separation rounds in the root node of a subsequent run (-1: unlimited) */ 448 #define SCIP_DEFAULT_SEPA_MAXADDROUNDS 1 /**< maximal additional number of separation rounds in subsequent 449 * price-and-cut loops (-1: no additional restriction) */ 450 #define SCIP_DEFAULT_SEPA_MAXSTALLROUNDSROOT 10 /**< maximal number of consecutive separation rounds without objective 451 * or integrality improvement in the root node (-1: no additional restriction) */ 452 #define SCIP_DEFAULT_SEPA_MAXSTALLROUNDS 1 /**< maximal number of consecutive separation rounds without objective 453 * or integrality improvement in local nodes (-1: no additional restriction) */ 454 #define SCIP_DEFAULT_SEPA_MAXCUTSGENFACTOR 2.0 /**< factor w.r.t. maxcuts for maximal number of cuts generated per separation round */ 455 #define SCIP_DEFAULT_SEPA_MAXCUTSROOTGENFACTOR 2.0 /**< factor w.r.t. maxcutsroot for maximal generated cuts at the root node */ 456 #define SCIP_DEFAULT_SEPA_MAXCUTS 100 /**< maximal number of cuts separated per separation round */ 457 #define SCIP_DEFAULT_SEPA_MAXCUTSROOT 2000 /**< maximal separated cuts per separation round at the root node */ 458 #define SCIP_DEFAULT_SEPA_CUTAGELIMIT 80 /**< maximum age a cut can reach before it is deleted from global cut pool 459 * (-1: cuts are never deleted from the global cut pool) */ 460 #define SCIP_DEFAULT_SEPA_POOLFREQ 10 /**< separation frequency for the global cut pool */ 461 #define SCIP_DEFAULT_SEPA_MINACTIVITYQUOT 0.8 /**< minimum cut activity quotient to convert cuts into constraints 462 * during a restart (0.0: all cuts are converted) */ 463 464 /* Parallel */ 465 #define SCIP_DEFAULT_PARALLEL_MODE 1 /**< the mode for the parallel implementation. Either 0: opportunistic or 466 * 1: deterministic */ 467 #define SCIP_DEFAULT_PARALLEL_MINNTHREADS 1 /**< the minimum number of threads used in parallel code */ 468 #define SCIP_DEFAULT_PARALLEL_MAXNTHREADS 8 /**< the maximum number of threads used in parallel code */ 469 470 /* Concurrent solvers */ 471 #define SCIP_DEFAULT_CONCURRENT_CHANGESEEDS TRUE /**< should the concurrent solvers use different random seeds? */ 472 #define SCIP_DEFAULT_CONCURRENT_CHANGECHILDSEL TRUE /**< should the concurrent solvers use different child selection rules? */ 473 #define SCIP_DEFAULT_CONCURRENT_COMMVARBNDS TRUE /**< should the concurrent solvers communicate variable bounds? */ 474 #define SCIP_DEFAULT_CONCURRENT_PRESOLVEBEFORE TRUE /**< should the problem be presolved before it is copied to the concurrent solvers? */ 475 #define SCIP_DEFAULT_CONCURRENT_INITSEED 5131912 /**< the seed used to initialize the random seeds for the concurrent solvers */ 476 #define SCIP_DEFAULT_CONCURRENT_FREQINIT 10.0 /**< initial frequency of synchronization with other threads 477 * (fraction of time required for solving the root LP) */ 478 #define SCIP_DEFAULT_CONCURRENT_FREQMAX 10.0 /**< maximal frequency of synchronization with other threads 479 * (fraction of time required for solving the root LP) */ 480 #define SCIP_DEFAULT_CONCURRENT_FREQFACTOR 1.5 /**< factor by which the frequency of synchronization is changed */ 481 #define SCIP_DEFAULT_CONCURRENT_TARGETPROGRESS 0.001 /**< when adapting the synchronization frequency this value is the targeted 482 * relative difference by which the absolute gap decreases per synchronization */ 483 #define SCIP_DEFAULT_CONCURRENT_MAXNSOLS 3 /**< maximum number of solutions that will be shared in a single synchronization */ 484 #define SCIP_DEFAULT_CONCURRENT_MAXNSYNCDELAY 7 /**< maximum number of synchronizations before reading is enforced regardless of delay */ 485 #define SCIP_DEFAULT_CONCURRENT_MINSYNCDELAY 10.0 /**< minimum delay before synchronization data is read */ 486 #define SCIP_DEFAULT_CONCURRENT_NBESTSOLS 10 /**< how many of the N best solutions should be considered for synchronization */ 487 #define SCIP_DEFAULT_CONCURRENT_PARAMSETPREFIX "" /**< path prefix for parameter setting files of concurrent solvers */ 488 489 490 /* Timing */ 491 492 #define SCIP_DEFAULT_TIME_CLOCKTYPE SCIP_CLOCKTYPE_WALL /**< default clock type for timing */ 493 #define SCIP_DEFAULT_TIME_ENABLED TRUE /**< is timing enabled? */ 494 #define SCIP_DEFAULT_TIME_READING FALSE /**< belongs reading time to solving time? */ 495 #define SCIP_DEFAULT_TIME_RARECLOCKCHECK FALSE /**< should clock checks of solving time be performed less frequently (might exceed time limit slightly) */ 496 #define SCIP_DEFAULT_TIME_STATISTICTIMING TRUE /**< should timing for statistic output be enabled? */ 497 #define SCIP_DEFAULT_TIME_NLPIEVAL FALSE /**< should time for evaluation in NLP solves be measured? */ 498 499 500 /* visualization output */ 501 502 #define SCIP_DEFAULT_VISUAL_VBCFILENAME "-" /**< name of the VBC tool output file, or "-" if no VBC tool output should be created */ 503 #define SCIP_DEFAULT_VISUAL_BAKFILENAME "-" /**< name of the BAK tool output file, or "-" if no BAK tool output should be created */ 504 #define SCIP_DEFAULT_VISUAL_REALTIME TRUE /**< should the real solving time be used instead of a time step counter in visualization? */ 505 #define SCIP_DEFAULT_VISUAL_DISPSOLS FALSE /**< should the node where solutions are found be visualized? */ 506 #define SCIP_DEFAULT_VISUAL_DISPLB FALSE /**< should lower bound information be visualized? */ 507 #define SCIP_DEFAULT_VISUAL_OBJEXTERN TRUE /**< should be output the external value of the objective? */ 508 509 510 /* Reading */ 511 512 #define SCIP_DEFAULT_READ_INITIALCONSS TRUE /**< should model constraints be marked as initial? */ 513 #define SCIP_DEFAULT_READ_DYNAMICCONSS TRUE /**< should model constraints be subject to aging? */ 514 #define SCIP_DEFAULT_READ_DYNAMICCOLS FALSE /**< should columns be added and removed dynamically to the LP? */ 515 #define SCIP_DEFAULT_READ_DYNAMICROWS FALSE /**< should rows be added and removed dynamically to the LP? */ 516 #define SCIP_DEFAULT_WRITE_GENNAMES_OFFSET 0 /**< when writing the problem with generic names, we start with index 517 * 0; using this parameter we can change the starting index to be 518 * different */ 519 520 521 /* Writing */ 522 523 #define SCIP_DEFAULT_WRITE_ALLCONSS FALSE /**< should all constraints be written (including the redundant constraints)? */ 524 #define SCIP_DEFAULT_PRINTZEROS FALSE /**< should variables set to zero be printed? */ 525 526 527 528 /** calculate memory size for dynamically allocated arrays */ 529 static 530 int calcGrowSize( 531 int initsize, /**< initial size of array */ 532 SCIP_Real growfac, /**< growing factor of array */ 533 int num /**< minimum number of entries to store */ 534 ) 535 { 536 int size; 537 538 assert(initsize >= 0); 539 assert(growfac >= 1.0); 540 assert(num >= 0); 541 542 if( growfac == 1.0 ) 543 size = MAX(initsize, num); 544 else 545 { 546 int oldsize; 547 548 /* calculate the size with this loop, such that the resulting numbers are always the same (-> block memory) */ 549 initsize = MAX(initsize, 4); 550 size = initsize; 551 oldsize = size - 1; 552 553 /* second condition checks against overflow */ 554 while( size < num && size > oldsize ) 555 { 556 oldsize = size; 557 size = (int)(growfac * size + initsize); 558 } 559 560 /* if an overflow happened, set the correct value */ 561 if( size <= oldsize ) 562 size = num; 563 } 564 565 assert(size >= initsize); 566 assert(size >= num); 567 568 return size; 569 } 570 571 572 /** information method for a parameter change of feastol */ 573 static 574 SCIP_DECL_PARAMCHGD(paramChgdFeastol) 575 { /*lint --e{715}*/ 576 SCIP_Real newfeastol; 577 578 newfeastol = SCIPparamGetReal(param); 579 580 /* change the feastol through the SCIP call in order to adjust LP's feastol if necessary */ 581 SCIP_CALL( SCIPchgFeastol(scip, newfeastol) ); 582 583 return SCIP_OKAY; 584 } 585 586 /** information method for a parameter change of lpfeastolfactor */ 587 static 588 SCIP_DECL_PARAMCHGD(paramChgdLPFeastolFactor) 589 { /*lint --e{715}*/ 590 SCIP_Real newlpfeastolfactor; 591 592 newlpfeastolfactor = SCIPparamGetReal(param); 593 594 if( SCIPgetStage(scip) == SCIP_STAGE_SOLVING && SCIPgetLPFeastol(scip) > newlpfeastolfactor * SCIPfeastol(scip) ) 595 { 596 /* reset the LP feastol to ensure that it does not exceed newlpfeastolfactor * SCIP's feastol 597 * this also marks the LP unsolved 598 */ 599 SCIPresetLPFeastol(scip); 600 } 601 602 return SCIP_OKAY; 603 } 604 605 /** information method for a parameter change of dualfeastol */ 606 static 607 SCIP_DECL_PARAMCHGD(paramChgdDualfeastol) 608 { /*lint --e{715}*/ 609 SCIP_Real newdualfeastol; 610 611 newdualfeastol = SCIPparamGetReal(param); 612 613 /* change the dualfeastol through the SCIP call in order to mark the LP unsolved */ 614 SCIP_CALL( SCIPchgDualfeastol(scip, newdualfeastol) ); 615 616 return SCIP_OKAY; 617 } 618 619 /** information method for a parameter change of barrierconvtol */ 620 static 621 SCIP_DECL_PARAMCHGD(paramChgdBarrierconvtol) 622 { /*lint --e{715}*/ 623 SCIP_Real newbarrierconvtol; 624 625 newbarrierconvtol = SCIPparamGetReal(param); 626 627 /* change the barrierconvtol through the SCIP call in order to mark the LP unsolved */ 628 SCIP_CALL( SCIPchgBarrierconvtol(scip, newbarrierconvtol) ); 629 630 return SCIP_OKAY; 631 } 632 633 /** information method for a parameter change of infinity value */ 634 static 635 SCIP_DECL_PARAMCHGD(paramChgdInfinity) 636 { /*lint --e{715}*/ 637 SCIP_Real infinity; 638 639 infinity = SCIPparamGetReal(param); 640 641 /* Check that infinity value of LP-solver is at least as large as the one used in SCIP. This is necessary, because we 642 * transfer SCIP infinity values to the ones by the LPI, but not the converse. */ 643 if ( scip->lp != NULL && scip->lp->lpi != NULL && infinity > SCIPlpiInfinity(scip->lp->lpi) ) 644 { 645 SCIPerrorMessage("The infinity value of the LP solver has to be at least as large as the one of SCIP.\n"); 646 return SCIP_PARAMETERWRONGVAL; 647 } 648 649 return SCIP_OKAY; 650 } 651 652 /** parameter change information method to autoselect display columns again */ 653 static 654 SCIP_DECL_PARAMCHGD(SCIPparamChgdDispWidth) 655 { /*lint --e{715}*/ 656 /* automatically select the new active display columns */ 657 SCIP_CALL( SCIPautoselectDisps(scip) ); 658 659 return SCIP_OKAY; 660 } 661 662 /** parameter change information method that some limit was changed */ 663 static 664 SCIP_DECL_PARAMCHGD(SCIPparamChgdLimit) 665 { /*lint --e{715}*/ 666 SCIPmarkLimitChanged(scip); 667 return SCIP_OKAY; 668 } 669 670 /** information method for a parameter change of mem_arraygrowfac */ 671 static 672 SCIP_DECL_PARAMCHGD(paramChgdArraygrowfac) 673 { /*lint --e{715}*/ 674 SCIP_Real newarraygrowfac; 675 676 newarraygrowfac = SCIPparamGetReal(param); 677 678 /* change arraygrowfac */ 679 BMSsetBufferMemoryArraygrowfac(SCIPbuffer(scip), newarraygrowfac); 680 BMSsetBufferMemoryArraygrowfac(SCIPcleanbuffer(scip), newarraygrowfac); 681 682 return SCIP_OKAY; 683 } 684 685 /** information method for a parameter change of mem_arraygrowinit */ 686 static 687 SCIP_DECL_PARAMCHGD(paramChgdArraygrowinit) 688 { /*lint --e{715}*/ 689 int newarraygrowinit; 690 691 newarraygrowinit = SCIPparamGetInt(param); 692 693 /* change arraygrowinit */ 694 BMSsetBufferMemoryArraygrowinit(SCIPbuffer(scip), newarraygrowinit); 695 BMSsetBufferMemoryArraygrowinit(SCIPcleanbuffer(scip), newarraygrowinit); 696 697 return SCIP_OKAY; 698 } 699 700 /** information method for a parameter change of reopt_enable */ 701 static 702 SCIP_DECL_PARAMCHGD(paramChgdEnableReopt) 703 { /*lint --e{715}*/ 704 SCIP_RETCODE retcode; 705 706 assert( scip != NULL ); 707 assert( param != NULL ); 708 709 /* create or deconstruct the reoptimization data structures */ 710 retcode = SCIPenableReoptimization(scip, SCIPparamGetBool(param)); 711 712 /* an appropriate error message is already printed in the above method */ 713 if( retcode == SCIP_INVALIDCALL ) 714 return SCIP_PARAMETERWRONGVAL; 715 716 return SCIP_OKAY; 717 } 718 719 /** information method for a parameter change of usesymmetry */ 720 static 721 SCIP_DECL_PARAMCHGD(paramChgdUsesymmetry) 722 { /*lint --e{715}*/ 723 assert( scip != NULL ); 724 assert( param != NULL ); 725 726 if ( SCIPgetStage(scip) >= SCIP_STAGE_INITPRESOLVE && SCIPgetStage(scip) <= SCIP_STAGE_SOLVED ) 727 { 728 if ( SCIPparamGetInt(param) > 0 ) 729 { 730 SCIPerrorMessage("Cannot turn on symmetry handling during (pre)solving or change method.\n"); 731 return SCIP_PARAMETERWRONGVAL; 732 } 733 } 734 735 return SCIP_OKAY; 736 } 737 738 /** set parameters for reoptimization */ 739 SCIP_RETCODE SCIPsetSetReoptimizationParams( 740 SCIP_SET* set, /**< SCIP data structure */ 741 SCIP_MESSAGEHDLR* messagehdlr /**< message handler */ 742 ) 743 { 744 assert(set != NULL); 745 assert(messagehdlr != NULL); 746 747 if( set->reopt_enable ) 748 { 749 /* disable some parts of conflict analysis */ 750 SCIP_CALL( SCIPsetSetCharParam(set, messagehdlr, "conflict/useboundlp", 'o') ); 751 SCIP_CALL( SCIPsetSetBoolParam(set, messagehdlr, "conflict/usepseudo", FALSE) ); 752 753 /* TODO check wheather multi aggregation can be enabled in reoptimization */ 754 if( SCIPsetIsParamFixed(set, "presolving/donotmultaggr") ) 755 { 756 SCIP_CALL( SCIPsetChgParamFixed(set, "presolving/donotmultaggr", FALSE) ); 757 } 758 SCIP_CALL( SCIPsetSetBoolParam(set, messagehdlr, "presolving/donotmultaggr", TRUE) ); 759 760 if( SCIPsetIsParamFixed(set, "branching/nodereopt/priority") ) 761 { 762 SCIP_CALL( SCIPsetChgParamFixed(set, "branching/nodereopt/priority", FALSE) ); 763 } 764 SCIP_CALL( SCIPsetSetIntParam(set, messagehdlr, "branching/nodereopt/priority", INT_MAX/4) ); 765 } 766 else 767 { 768 /* disable conflict analysis */ 769 if( SCIPsetIsParamFixed(set, "conflict/enable") ) 770 { 771 SCIP_CALL( SCIPsetChgParamFixed(set, "conflict/enable", FALSE) ); 772 } 773 SCIP_CALL( SCIPsetResetParam(set, messagehdlr, "conflict/enable") ); 774 775 /* TODO check wheather multi aggregation can be enabled in reoptimization */ 776 if( SCIPsetIsParamFixed(set, "presolving/donotmultaggr") ) 777 { 778 SCIP_CALL( SCIPsetChgParamFixed(set, "presolving/donotmultaggr", FALSE) ); 779 } 780 SCIP_CALL( SCIPsetResetParam(set, messagehdlr, "presolving/donotmultaggr") ); 781 782 /* set priority to defeault */ 783 if( SCIPsetFindBranchrule(set, "nodereopt") != NULL ) 784 { 785 if( SCIPsetIsParamFixed(set, "branching/nodereopt/priority") ) 786 { 787 SCIP_CALL( SCIPsetChgParamFixed(set, "branching/nodereopt/priority", FALSE) ); 788 } 789 SCIP_CALL( SCIPsetResetParam(set, messagehdlr, "branching/nodereopt/priority") ); 790 } 791 } 792 793 return SCIP_OKAY; 794 } 795 796 /** enable or disable all plugin timers depending on the value of the flag \p enabled */ 797 void SCIPsetEnableOrDisablePluginClocks( 798 SCIP_SET* set, /**< SCIP settings */ 799 SCIP_Bool enabled /**< should plugin clocks be enabled? */ 800 ) 801 { 802 int i; 803 804 assert(set != NULL); 805 806 /* go through all plugin types and enable or disable their respective clocks */ 807 for( i = set->nreaders - 1; i >= 0; --i ) 808 SCIPreaderEnableOrDisableClocks(set->readers[i], enabled); 809 810 for( i = set->npricers - 1; i >= 0; --i ) 811 SCIPpricerEnableOrDisableClocks(set->pricers[i], enabled); 812 813 for( i = set->nconshdlrs - 1; i >= 0; --i ) 814 SCIPconshdlrEnableOrDisableClocks(set->conshdlrs[i], enabled); 815 816 for( i = set->nconflicthdlrs - 1; i >= 0; --i ) 817 SCIPconflicthdlrEnableOrDisableClocks(set->conflicthdlrs[i], enabled); 818 819 for( i = set->npresols - 1; i >= 0; --i ) 820 SCIPpresolEnableOrDisableClocks(set->presols[i], enabled); 821 822 for( i = set->nrelaxs - 1; i >= 0; --i ) 823 SCIPrelaxEnableOrDisableClocks(set->relaxs[i], enabled); 824 825 for( i = set->nsepas - 1; i >= 0; --i ) 826 SCIPsepaEnableOrDisableClocks(set->sepas[i], enabled); 827 828 for( i = set->nprops - 1; i >= 0; --i ) 829 SCIPpropEnableOrDisableClocks(set->props[i], enabled); 830 831 for( i = set->nheurs - 1; i >= 0; --i ) 832 SCIPheurEnableOrDisableClocks(set->heurs[i], enabled); 833 834 for( i = set->neventhdlrs - 1; i >= 0; --i ) 835 SCIPeventhdlrEnableOrDisableClocks(set->eventhdlrs[i], enabled); 836 837 for( i = set->nnodesels - 1; i >= 0; --i ) 838 SCIPnodeselEnableOrDisableClocks(set->nodesels[i], enabled); 839 840 for ( i = set->ncutsels - 1; i >= 0; --i ) 841 SCIPcutselEnableOrDisableClocks(set->cutsels[i], enabled); 842 843 for( i = set->nbranchrules - 1; i >= 0; --i ) 844 SCIPbranchruleEnableOrDisableClocks(set->branchrules[i], enabled); 845 } 846 847 /* method to be invoked when the parameter timing/statistictiming is changed */ 848 static 849 SCIP_DECL_PARAMCHGD(paramChgdStatistictiming) 850 { /*lint --e{715}*/ 851 SCIP_CALL( SCIPenableOrDisableStatisticTiming(scip) ); 852 853 return SCIP_OKAY; 854 } 855 856 /** copies plugins from sourcescip to targetscip; in case that a constraint handler which does not need constraints 857 * cannot be copied, valid will return FALSE. All plugins can declare that, if their copy process failed, the 858 * copied SCIP instance might not represent the same problem semantics as the original. 859 * Note that in this case dual reductions might be invalid. */ 860 SCIP_RETCODE SCIPsetCopyPlugins( 861 SCIP_SET* sourceset, /**< source SCIP_SET data structure */ 862 SCIP_SET* targetset, /**< target SCIP_SET data structure */ 863 SCIP_Bool copyreaders, /**< should the file readers be copied */ 864 SCIP_Bool copypricers, /**< should the variable pricers be copied */ 865 SCIP_Bool copyconshdlrs, /**< should the constraint handlers be copied */ 866 SCIP_Bool copyconflicthdlrs, /**< should the conflict handlers be copied */ 867 SCIP_Bool copypresolvers, /**< should the presolvers be copied */ 868 SCIP_Bool copyrelaxators, /**< should the relaxators be copied */ 869 SCIP_Bool copyseparators, /**< should the separators be copied */ 870 SCIP_Bool copycutselectors, /**< should the cut selectors be copied */ 871 SCIP_Bool copypropagators, /**< should the propagators be copied */ 872 SCIP_Bool copyheuristics, /**< should the heuristics be copied */ 873 SCIP_Bool copyeventhdlrs, /**< should the event handlers be copied */ 874 SCIP_Bool copynodeselectors, /**< should the node selectors be copied */ 875 SCIP_Bool copybranchrules, /**< should the branchrules be copied */ 876 SCIP_Bool copydisplays, /**< should the display columns be copied */ 877 SCIP_Bool copydialogs, /**< should the dialogs be copied */ 878 SCIP_Bool copytables, /**< should the statistics tables be copied */ 879 SCIP_Bool copyexprhdlrs, /**< should the expression handlers be copied */ 880 SCIP_Bool copynlpis, /**< should the NLP interfaces be copied */ 881 SCIP_Bool* allvalid /**< pointer to store whether all plugins were validly copied */ 882 ) 883 { 884 int p; 885 SCIP_Bool valid; 886 887 assert(sourceset != NULL); 888 assert(targetset != NULL); 889 assert(sourceset != targetset); 890 assert(allvalid != NULL); 891 892 *allvalid = TRUE; 893 894 /* copy all dialog plugins */ 895 if( copydialogs && sourceset->dialogs != NULL ) 896 { 897 for( p = sourceset->ndialogs - 1; p >= 0; --p ) 898 { 899 /* @todo: the copying process of dialog handlers is currently not checked for consistency */ 900 SCIP_CALL( SCIPdialogCopyInclude(sourceset->dialogs[p], targetset) ); 901 } 902 } 903 904 /* copy all reader plugins */ 905 if( copyreaders && sourceset->readers != NULL ) 906 { 907 for( p = sourceset->nreaders - 1; p >= 0; --p ) 908 { 909 SCIP_CALL( SCIPreaderCopyInclude(sourceset->readers[p], targetset) ); 910 } 911 } 912 913 /* copy all variable pricer plugins */ 914 if( copypricers && sourceset->pricers != NULL ) 915 { 916 for( p = sourceset->npricers - 1; p >= 0; --p ) 917 { 918 valid = FALSE; 919 SCIP_CALL( SCIPpricerCopyInclude(sourceset->pricers[p], targetset, &valid) ); 920 *allvalid = *allvalid && valid; 921 if( SCIPpricerIsActive(sourceset->pricers[p]) ) 922 { 923 SCIP_CALL( SCIPpricerActivate(targetset->pricers[p], targetset) ); 924 } 925 } 926 } 927 928 /* copy all constraint handler plugins */ 929 if( copyconshdlrs && sourceset->conshdlrs_include != NULL ) 930 { 931 /* copy them in order they were added to the sourcescip 932 * 933 * @note we only have to set the valid pointer to FALSE in case that a constraint handler, which does not need 934 * constraints, does not copy; in the case that a constraint handler does not copy and it needs constraint 935 * we will detect later that the problem is not valid if a constraint of that type exits 936 */ 937 for( p = 0; p < sourceset->nconshdlrs; ++p ) 938 { 939 if( SCIPconshdlrIsClonable(sourceset->conshdlrs_include[p]) ) 940 { 941 valid = FALSE; 942 SCIP_CALL( SCIPconshdlrCopyInclude(sourceset->conshdlrs_include[p], targetset, &valid) ); 943 *allvalid = *allvalid && valid; 944 SCIPsetDebugMsg(sourceset, "Copying conshdlr <%s> was%s valid.\n", SCIPconshdlrGetName(sourceset->conshdlrs_include[p]), valid ? "" : " not"); 945 } 946 else if( !SCIPconshdlrNeedsCons(sourceset->conshdlrs_include[p]) ) 947 { 948 SCIPsetDebugMsg(sourceset, "Copying Conshdlr <%s> without constraints not valid.\n", SCIPconshdlrGetName(sourceset->conshdlrs_include[p])); 949 *allvalid = FALSE; 950 } 951 } 952 } 953 954 /* copy all conflict handler plugins */ 955 if( copyconflicthdlrs && sourceset->conflicthdlrs != NULL ) 956 { 957 for( p = sourceset->nconflicthdlrs - 1; p >= 0; --p ) 958 { 959 SCIP_CALL( SCIPconflicthdlrCopyInclude(sourceset->conflicthdlrs[p], targetset) ); 960 } 961 } 962 963 /* copy all presolver plugins */ 964 if( copypresolvers && sourceset->presols != NULL ) 965 { 966 for( p = sourceset->npresols - 1; p >= 0; --p ) 967 { 968 SCIP_CALL( SCIPpresolCopyInclude(sourceset->presols[p], targetset) ); 969 } 970 } 971 972 /* copy all relaxator plugins */ 973 if( copyrelaxators && sourceset->relaxs != NULL ) 974 { 975 for( p = sourceset->nrelaxs - 1; p >= 0; --p ) 976 { 977 SCIP_CALL( SCIPrelaxCopyInclude(sourceset->relaxs[p], targetset) ); 978 } 979 } 980 981 /* copy all separator plugins */ 982 if( copyseparators && sourceset->sepas != NULL ) 983 { 984 for( p = sourceset->nsepas - 1; p >= 0; --p ) 985 { 986 SCIP_CALL( SCIPsepaCopyInclude(sourceset->sepas[p], targetset) ); 987 } 988 } 989 990 /* copy all cut selector plugins */ 991 if( copycutselectors && sourceset->cutsels != NULL ) 992 { 993 for( p = sourceset->ncutsels - 1; p >= 0; --p ) 994 { 995 SCIP_CALL( SCIPcutselCopyInclude(sourceset->cutsels[p], targetset) ); 996 } 997 } 998 999 /* copy all propagators plugins */ 1000 if( copypropagators && sourceset->props != NULL ) 1001 { 1002 for( p = sourceset->nprops - 1; p >= 0; --p ) 1003 { 1004 SCIP_CALL( SCIPpropCopyInclude(sourceset->props[p], targetset) ); 1005 } 1006 } 1007 1008 /* copy all primal heuristics plugins */ 1009 if( copyheuristics && sourceset->heurs != NULL ) 1010 { 1011 for( p = sourceset->nheurs - 1; p >= 0; --p ) 1012 { 1013 SCIP_CALL( SCIPheurCopyInclude(sourceset->heurs[p], targetset) ); 1014 } 1015 } 1016 1017 /* copy all event handler plugins */ 1018 if( copyeventhdlrs && sourceset->eventhdlrs != NULL ) 1019 { 1020 for( p = sourceset->neventhdlrs - 1; p >= 0; --p ) 1021 { 1022 /* @todo: the copying process of event handlers is currently not checked for consistency */ 1023 SCIP_CALL( SCIPeventhdlrCopyInclude(sourceset->eventhdlrs[p], targetset) ); 1024 } 1025 } 1026 1027 /* copy all node selector plugins */ 1028 if( copynodeselectors && sourceset->nodesels != NULL ) 1029 { 1030 for( p = sourceset->nnodesels - 1; p >= 0; --p ) 1031 { 1032 SCIP_CALL( SCIPnodeselCopyInclude(sourceset->nodesels[p], targetset) ); 1033 } 1034 } 1035 1036 /* copy all branchrule plugins */ 1037 if( copybranchrules && sourceset->branchrules != NULL ) 1038 { 1039 for( p = sourceset->nbranchrules - 1; p >= 0; --p ) 1040 { 1041 SCIP_CALL( SCIPbranchruleCopyInclude(sourceset->branchrules[p], targetset) ); 1042 } 1043 } 1044 1045 /* copy all display plugins */ 1046 if( copydisplays && sourceset->disps != NULL ) 1047 { 1048 for( p = sourceset->ndisps - 1; p >= 0; --p ) 1049 { 1050 SCIP_CALL( SCIPdispCopyInclude(sourceset->disps[p], targetset) ); 1051 } 1052 } 1053 1054 /* copy all table plugins */ 1055 if( copytables && sourceset->tables != NULL ) 1056 { 1057 for( p = sourceset->ntables - 1; p >= 0; --p ) 1058 { 1059 SCIP_CALL( SCIPtableCopyInclude(sourceset->tables[p], targetset) ); 1060 } 1061 } 1062 1063 /* copy all expression handlers */ 1064 if( copyexprhdlrs && sourceset->exprhdlrs != NULL ) 1065 { 1066 for( p = sourceset->nexprhdlrs - 1; p >= 0; --p ) 1067 { 1068 SCIP_CALL( SCIPexprhdlrCopyInclude(sourceset->exprhdlrs[p], targetset) ); 1069 } 1070 } 1071 1072 /* copy all NLP interfaces */ 1073 if( copynlpis && sourceset->nlpis != NULL ) 1074 { 1075 for( p = sourceset->nnlpis - 1; p >= 0; --p ) 1076 { 1077 SCIP_CALL( SCIPnlpiCopyInclude(sourceset->nlpis[p], targetset) ); 1078 } 1079 } 1080 1081 return SCIP_OKAY; 1082 } 1083 1084 1085 /** copies parameters from sourcescip to targetscip */ 1086 SCIP_RETCODE SCIPsetCopyParams( 1087 SCIP_SET* sourceset, /**< source SCIP_SET data structure */ 1088 SCIP_SET* targetset, /**< target SCIP_SET data structure */ 1089 SCIP_MESSAGEHDLR* messagehdlr /**< message handler of target SCIP */ 1090 ) 1091 { 1092 assert(sourceset != NULL); 1093 assert(targetset != NULL); 1094 assert(sourceset != targetset); 1095 assert(targetset->scip != NULL); 1096 1097 SCIP_CALL( SCIPparamsetCopyParams(sourceset->paramset, targetset->paramset, targetset, messagehdlr) ); 1098 1099 return SCIP_OKAY; 1100 } 1101 1102 /** creates global SCIP settings */ 1103 SCIP_RETCODE SCIPsetCreate( 1104 SCIP_SET** set, /**< pointer to SCIP settings */ 1105 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */ 1106 BMS_BLKMEM* blkmem, /**< block memory */ 1107 SCIP* scip /**< SCIP data structure */ 1108 ) 1109 { 1110 assert(set != NULL); 1111 assert(scip != NULL); 1112 1113 SCIP_ALLOC( BMSallocMemory(set) ); 1114 1115 (*set)->stage = SCIP_STAGE_INIT; 1116 (*set)->scip = scip; 1117 (*set)->buffer = SCIPbuffer(scip); 1118 (*set)->cleanbuffer = SCIPcleanbuffer(scip); 1119 1120 SCIP_CALL( SCIPparamsetCreate(&(*set)->paramset, blkmem) ); 1121 1122 (*set)->readers = NULL; 1123 (*set)->nreaders = 0; 1124 (*set)->readerssize = 0; 1125 (*set)->pricers = NULL; 1126 (*set)->npricers = 0; 1127 (*set)->nactivepricers = 0; 1128 (*set)->pricerssize = 0; 1129 (*set)->pricerssorted = FALSE; 1130 (*set)->pricersnamesorted = FALSE; 1131 (*set)->conshdlrs = NULL; 1132 (*set)->conshdlrs_sepa = NULL; 1133 (*set)->conshdlrs_enfo = NULL; 1134 (*set)->conshdlrs_include = NULL; 1135 (*set)->nconshdlrs = 0; 1136 (*set)->conshdlrssize = 0; 1137 (*set)->conflicthdlrs = NULL; 1138 (*set)->nconflicthdlrs = 0; 1139 (*set)->conflicthdlrssize = 0; 1140 (*set)->conflicthdlrssorted = FALSE; 1141 (*set)->conflicthdlrsnamesorted = FALSE; 1142 (*set)->benders = NULL; 1143 (*set)->nbenders = 0; 1144 (*set)->nactivebenders = 0; 1145 (*set)->benderssize = 0; 1146 (*set)->benderssorted = FALSE; 1147 (*set)->bendersnamesorted = FALSE; 1148 1149 (*set)->debugsoldata = NULL; 1150 SCIP_CALL( SCIPdebugSolDataCreate(&(*set)->debugsoldata) ); /*lint !e506 !e774*/ 1151 1152 (*set)->presols = NULL; 1153 (*set)->npresols = 0; 1154 (*set)->presolssize = 0; 1155 (*set)->presolssorted = FALSE; 1156 (*set)->presolsnamesorted = FALSE; 1157 (*set)->relaxs = NULL; 1158 (*set)->nrelaxs = 0; 1159 (*set)->relaxssize = 0; 1160 (*set)->relaxssorted = FALSE; 1161 (*set)->relaxsnamesorted = FALSE; 1162 (*set)->sepas = NULL; 1163 (*set)->nsepas = 0; 1164 (*set)->sepassize = 0; 1165 (*set)->sepassorted = FALSE; 1166 (*set)->sepasnamesorted = FALSE; 1167 (*set)->props = NULL; 1168 (*set)->props_presol = NULL; 1169 (*set)->nprops = 0; 1170 (*set)->propssize = 0; 1171 (*set)->propssorted = FALSE; 1172 (*set)->propspresolsorted = FALSE; 1173 (*set)->propsnamesorted = FALSE; 1174 (*set)->concsolvertypes = NULL; 1175 (*set)->nconcsolvertypes = 0; 1176 (*set)->concsolvertypessize = 0; 1177 (*set)->concsolvers = NULL; 1178 (*set)->nconcsolvers = 0; 1179 (*set)->concsolverssize = 0; 1180 (*set)->concurrent_paramsetprefix = NULL; 1181 (*set)->cutsels = NULL; 1182 (*set)->ncutsels = 0; 1183 (*set)->cutselssize = 0; 1184 (*set)->cutselssorted = FALSE; 1185 (*set)->heurs = NULL; 1186 (*set)->nheurs = 0; 1187 (*set)->heurssize = 0; 1188 (*set)->heurssorted = FALSE; 1189 (*set)->heursnamesorted = FALSE; 1190 (*set)->comprs = NULL; 1191 (*set)->ncomprs = 0; 1192 (*set)->comprssize = 0; 1193 (*set)->comprssorted = FALSE; 1194 (*set)->comprsnamesorted = FALSE; 1195 (*set)->eventhdlrs = NULL; 1196 (*set)->neventhdlrs = 0; 1197 (*set)->eventhdlrssize = 0; 1198 (*set)->nodesels = NULL; 1199 (*set)->nnodesels = 0; 1200 (*set)->nodeselssize = 0; 1201 (*set)->nodesel = NULL; 1202 (*set)->branchrules = NULL; 1203 (*set)->nbranchrules = 0; 1204 (*set)->branchrulessize = 0; 1205 (*set)->branchrulessorted = FALSE; 1206 (*set)->branchrulesnamesorted = FALSE; 1207 (*set)->banditvtables = NULL; 1208 (*set)->banditvtablessize = 0; 1209 (*set)->nbanditvtables = 0; 1210 (*set)->disps = NULL; 1211 (*set)->ndisps = 0; 1212 (*set)->dispssize = 0; 1213 (*set)->tables = NULL; 1214 (*set)->ntables = 0; 1215 (*set)->tablessize = 0; 1216 (*set)->tablessorted = FALSE; 1217 (*set)->dialogs = NULL; 1218 (*set)->ndialogs = 0; 1219 (*set)->dialogssize = 0; 1220 (*set)->exprhdlrs = NULL; 1221 (*set)->exprhdlrvar = NULL; 1222 (*set)->exprhdlrval = NULL; 1223 (*set)->exprhdlrsum = NULL; 1224 (*set)->exprhdlrproduct = NULL; 1225 (*set)->exprhdlrpow = NULL; 1226 (*set)->nexprhdlrs = 0; 1227 (*set)->exprhdlrssize = 0; 1228 (*set)->exprhdlrssorted = FALSE; 1229 (*set)->nlpis = NULL; 1230 (*set)->nnlpis = 0; 1231 (*set)->nlpissize = 0; 1232 (*set)->nlpissorted = FALSE; 1233 (*set)->limitchanged = FALSE; 1234 (*set)->subscipsoff = FALSE; 1235 (*set)->extcodenames = NULL; 1236 (*set)->extcodedescs = NULL; 1237 (*set)->nextcodes = 0; 1238 (*set)->extcodessize = 0; 1239 (*set)->visual_vbcfilename = NULL; 1240 (*set)->visual_bakfilename = NULL; 1241 (*set)->nlp_solver = NULL; 1242 (*set)->nlp_disable = FALSE; 1243 (*set)->num_relaxfeastol = SCIP_INVALID; 1244 (*set)->misc_debugsol = NULL; 1245 1246 /* the default time limit is infinite */ 1247 (*set)->istimelimitfinite = FALSE; 1248 1249 /* branching parameters */ 1250 SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem, 1251 "branching/scorefunc", 1252 "branching score function ('s'um, 'p'roduct, 'q'uotient)", 1253 &(*set)->branch_scorefunc, TRUE, SCIP_DEFAULT_BRANCH_SCOREFUNC, "spq", 1254 NULL, NULL) ); 1255 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 1256 "branching/scorefac", 1257 "branching score factor to weigh downward and upward gain prediction in sum score function", 1258 &(*set)->branch_scorefac, TRUE, SCIP_DEFAULT_BRANCH_SCOREFAC, 0.0, 1.0, 1259 NULL, NULL) ); 1260 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1261 "branching/preferbinary", 1262 "should branching on binary variables be preferred?", 1263 &(*set)->branch_preferbinary, FALSE, SCIP_DEFAULT_BRANCH_PREFERBINARY, 1264 NULL, NULL) ); 1265 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 1266 "branching/clamp", 1267 "minimal relative distance of branching point to bounds when branching on a continuous variable", 1268 &(*set)->branch_clamp, FALSE, SCIP_DEFAULT_BRANCH_CLAMP, 0.0, 0.5, 1269 NULL, NULL) ); 1270 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 1271 "branching/midpull", 1272 "fraction by which to move branching point of a continuous variable towards the middle of the domain; a value of 1.0 leads to branching always in the middle of the domain", 1273 &(*set)->branch_midpull, FALSE, SCIP_DEFAULT_BRANCH_MIDPULL, 0.0, 1.0, 1274 NULL, NULL) ); 1275 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 1276 "branching/midpullreldomtrig", 1277 "multiply midpull by relative domain width if the latter is below this value", 1278 &(*set)->branch_midpullreldomtrig, FALSE, SCIP_DEFAULT_BRANCH_MIDPULLRELDOMTRIG, 0.0, 1.0, 1279 NULL, NULL) ); 1280 SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem, 1281 "branching/lpgainnormalize", 1282 "strategy for normalization of LP gain when updating pseudocosts of continuous variables (divide by movement of 'l'p value, reduction in 'd'omain width, or reduction in domain width of 's'ibling)", 1283 &(*set)->branch_lpgainnorm, FALSE, SCIP_DEFAULT_BRANCH_LPGAINNORMALIZE, "dls", 1284 NULL, NULL) ); 1285 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1286 "branching/delaypscostupdate", 1287 "should updating pseudo costs for continuous variables be delayed to the time after separation?", 1288 &(*set)->branch_delaypscost, FALSE, SCIP_DEFAULT_BRANCH_DELAYPSCOST, 1289 NULL, NULL) ); 1290 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1291 "branching/divingpscost", 1292 "should pseudo costs be updated also in diving and probing mode?", 1293 &(*set)->branch_divingpscost, FALSE, SCIP_DEFAULT_BRANCH_DIVINGPSCOST, 1294 NULL, NULL) ); 1295 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1296 "branching/forceallchildren", 1297 "should all strong branching children be regarded even if one is detected to be infeasible? (only with propagation)", 1298 &(*set)->branch_forceall, TRUE, SCIP_DEFAULT_BRANCH_FORCEALL, 1299 NULL, NULL) ); 1300 SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem, 1301 "branching/firstsbchild", 1302 "child node to be regarded first during strong branching (only with propagation): 'u'p child, 'd'own child, 'h'istory-based, or 'a'utomatic", 1303 &(*set)->branch_firstsbchild, TRUE, SCIP_DEFAULT_BRANCH_FIRSTSBCHILD, "aduh", 1304 NULL, NULL) ); 1305 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1306 "branching/checksol", 1307 "should LP solutions during strong branching with propagation be checked for feasibility?", 1308 &(*set)->branch_checksbsol, TRUE, SCIP_DEFAULT_BRANCH_CHECKSBSOL, 1309 NULL, NULL) ); 1310 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1311 "branching/roundsbsol", 1312 "should LP solutions during strong branching with propagation be rounded? (only when checksbsol=TRUE)", 1313 &(*set)->branch_roundsbsol, TRUE, SCIP_DEFAULT_BRANCH_ROUNDSBSOL, 1314 NULL, NULL) ); 1315 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1316 "branching/sumadjustscore", 1317 "score adjustment near zero by adding epsilon (TRUE) or using maximum (FALSE)", 1318 &(*set)->branch_sumadjustscore, TRUE, SCIP_DEFAULT_BRANCH_SUMADJUSTSCORE, 1319 NULL, NULL) ); 1320 1321 /* tree compression parameters */ 1322 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1323 "compression/enable", 1324 "should automatic tree compression after the presolving be enabled?", 1325 &(*set)->compr_enable, TRUE, SCIP_DEFAULT_COMPR_ENABLE, 1326 NULL, NULL) ); 1327 1328 /* conflict analysis parameters */ 1329 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1330 "conflict/enable", 1331 "should conflict analysis be enabled?", 1332 &(*set)->conf_enable, FALSE, SCIP_DEFAULT_CONF_ENABLE, 1333 NULL, NULL) ); 1334 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1335 "conflict/cleanboundexceedings", 1336 "should conflicts based on an old cutoff bound be removed from the conflict pool after improving the primal bound?", 1337 &(*set)->conf_cleanbnddepend, TRUE, SCIP_DEFAULT_CONF_CLEANBNDDEPEND, 1338 NULL, NULL) ); 1339 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1340 "conflict/uselocalrows", 1341 "use local rows to construct infeasibility proofs", 1342 &(*set)->conf_uselocalrows, TRUE, SCIP_DEFAULT_CONF_USELOCALROWS, 1343 NULL, NULL) ); 1344 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1345 "conflict/useprop", 1346 "should propagation conflict analysis be used?", 1347 &(*set)->conf_useprop, FALSE, SCIP_DEFAULT_CONF_USEPROP, 1348 NULL, NULL) ); 1349 SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem, 1350 "conflict/useinflp", 1351 "should infeasible LP conflict analysis be used? ('o'ff, 'c'onflict graph, 'd'ual ray, 'b'oth conflict graph and dual ray)", 1352 &(*set)->conf_useinflp, FALSE, SCIP_DEFAULT_CONF_USEINFLP, "ocdb", 1353 NULL, NULL) ); 1354 SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem, 1355 "conflict/useboundlp", 1356 "should bound exceeding LP conflict analysis be used? ('o'ff, 'c'onflict graph, 'd'ual ray, 'b'oth conflict graph and dual ray)", 1357 &(*set)->conf_useboundlp, FALSE, SCIP_DEFAULT_CONF_USEBOUNDLP, "ocdb", 1358 NULL, NULL) ); 1359 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1360 "conflict/usesb", 1361 "should infeasible/bound exceeding strong branching conflict analysis be used?", 1362 &(*set)->conf_usesb, FALSE, SCIP_DEFAULT_CONF_USESB, 1363 NULL, NULL) ); 1364 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1365 "conflict/usepseudo", 1366 "should pseudo solution conflict analysis be used?", 1367 &(*set)->conf_usepseudo, FALSE, SCIP_DEFAULT_CONF_USEPSEUDO, 1368 NULL, NULL) ); 1369 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 1370 "conflict/maxvarsfac", 1371 "maximal fraction of variables involved in a conflict constraint", 1372 &(*set)->conf_maxvarsfac, TRUE, SCIP_DEFAULT_CONF_MAXVARSFAC, 0.0, SCIP_REAL_MAX, 1373 NULL, NULL) ); 1374 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 1375 "conflict/minmaxvars", 1376 "minimal absolute maximum of variables involved in a conflict constraint", 1377 &(*set)->conf_minmaxvars, TRUE, SCIP_DEFAULT_CONF_MINMAXVARS, 0, INT_MAX, 1378 NULL, NULL) ); 1379 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 1380 "conflict/maxlploops", 1381 "maximal number of LP resolving loops during conflict analysis (-1: no limit)", 1382 &(*set)->conf_maxlploops, TRUE, SCIP_DEFAULT_CONF_MAXLPLOOPS, -1, INT_MAX, 1383 NULL, NULL) ); 1384 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 1385 "conflict/lpiterations", 1386 "maximal number of LP iterations in each LP resolving loop (-1: no limit)", 1387 &(*set)->conf_lpiterations, TRUE, SCIP_DEFAULT_CONF_LPITERATIONS, -1, INT_MAX, 1388 NULL, NULL) ); 1389 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 1390 "conflict/fuiplevels", 1391 "number of depth levels up to which first UIP's are used in conflict analysis (-1: use All-FirstUIP rule)", 1392 &(*set)->conf_fuiplevels, TRUE, SCIP_DEFAULT_CONF_FUIPLEVELS, -1, INT_MAX, 1393 NULL, NULL) ); 1394 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 1395 "conflict/interconss", 1396 "maximal number of intermediate conflict constraints generated in conflict graph (-1: use every intermediate constraint)", 1397 &(*set)->conf_interconss, TRUE, SCIP_DEFAULT_CONF_INTERCONSS, -1, INT_MAX, 1398 NULL, NULL) ); 1399 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 1400 "conflict/reconvlevels", 1401 "number of depth levels up to which UIP reconvergence constraints are generated (-1: generate reconvergence constraints in all depth levels)", 1402 &(*set)->conf_reconvlevels, TRUE, SCIP_DEFAULT_CONF_RECONVLEVELS, -1, INT_MAX, 1403 NULL, NULL) ); 1404 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 1405 "conflict/maxconss", 1406 "maximal number of conflict constraints accepted at an infeasible node (-1: use all generated conflict constraints)", 1407 &(*set)->conf_maxconss, TRUE, SCIP_DEFAULT_CONF_MAXCONSS, -1, INT_MAX, 1408 NULL, NULL) ); 1409 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 1410 "conflict/maxstoresize", 1411 "maximal size of conflict store (-1: auto, 0: disable storage)", 1412 &(*set)->conf_maxstoresize, TRUE, SCIP_DEFAULT_CONF_MAXSTORESIZE, -1, INT_MAX, 1413 NULL, NULL) ); 1414 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1415 "conflict/preferbinary", 1416 "should binary conflicts be preferred?", 1417 &(*set)->conf_preferbinary, FALSE, SCIP_DEFAULT_CONF_PREFERBINARY, 1418 NULL, NULL) ); 1419 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1420 "conflict/prefinfproof", 1421 "prefer infeasibility proof to boundexceeding proof", 1422 &(*set)->conf_prefinfproof, TRUE, SCIP_DEFAULT_CONF_PREFINFPROOF, 1423 NULL, NULL) ); 1424 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1425 "conflict/allowlocal", 1426 "should conflict constraints be generated that are only valid locally?", 1427 &(*set)->conf_allowlocal, TRUE, SCIP_DEFAULT_CONF_ALLOWLOCAL, 1428 NULL, NULL) ); 1429 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1430 "conflict/settlelocal", 1431 "should conflict constraints be attached only to the local subtree where they can be useful?", 1432 &(*set)->conf_settlelocal, TRUE, SCIP_DEFAULT_CONF_SETTLELOCAL, 1433 NULL, NULL) ); 1434 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1435 "conflict/repropagate", 1436 "should earlier nodes be repropagated in order to replace branching decisions by deductions?", 1437 &(*set)->conf_repropagate, TRUE, SCIP_DEFAULT_CONF_REPROPAGATE, 1438 NULL, NULL) ); 1439 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1440 "conflict/keepreprop", 1441 "should constraints be kept for repropagation even if they are too long?", 1442 &(*set)->conf_keepreprop, TRUE, SCIP_DEFAULT_CONF_KEEPREPROP, 1443 NULL, NULL) ); 1444 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1445 "conflict/separate", 1446 "should the conflict constraints be separated?", 1447 &(*set)->conf_separate, TRUE, SCIP_DEFAULT_CONF_SEPARATE, 1448 NULL, NULL) ); 1449 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1450 "conflict/dynamic", 1451 "should the conflict constraints be subject to aging?", 1452 &(*set)->conf_dynamic, TRUE, SCIP_DEFAULT_CONF_DYNAMIC, 1453 NULL, NULL) ); 1454 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1455 "conflict/removable", 1456 "should the conflict's relaxations be subject to LP aging and cleanup?", 1457 &(*set)->conf_removable, TRUE, SCIP_DEFAULT_CONF_REMOVEABLE, 1458 NULL, NULL) ); 1459 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 1460 "conflict/graph/depthscorefac", 1461 "score factor for depth level in bound relaxation heuristic", 1462 &(*set)->conf_depthscorefac, TRUE, SCIP_DEFAULT_CONF_DEPTHSCOREFAC, SCIP_REAL_MIN, SCIP_REAL_MAX, 1463 NULL, NULL) ); 1464 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 1465 "conflict/proofscorefac", 1466 "score factor for impact on acticity in bound relaxation heuristic", 1467 &(*set)->conf_proofscorefac, TRUE, SCIP_DEFAULT_CONF_PROOFSCOREFAC, SCIP_REAL_MIN, SCIP_REAL_MAX, 1468 NULL, NULL) ); 1469 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 1470 "conflict/uplockscorefac", 1471 "score factor for up locks in bound relaxation heuristic", 1472 &(*set)->conf_uplockscorefac, TRUE, SCIP_DEFAULT_CONF_UPLOCKSCOREFAC, SCIP_REAL_MIN, SCIP_REAL_MAX, 1473 NULL, NULL) ); 1474 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 1475 "conflict/downlockscorefac", 1476 "score factor for down locks in bound relaxation heuristic", 1477 &(*set)->conf_downlockscorefac, TRUE, SCIP_DEFAULT_CONF_DOWNLOCKSCOREFAC, SCIP_REAL_MIN, SCIP_REAL_MAX, 1478 NULL, NULL) ); 1479 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 1480 "conflict/scorefac", 1481 "factor to decrease importance of variables' earlier conflict scores", 1482 &(*set)->conf_scorefac, TRUE, SCIP_DEFAULT_CONF_SCOREFAC, 1e-6, 1.0, 1483 NULL, NULL) ); 1484 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 1485 "conflict/restartnum", 1486 "number of successful conflict analysis calls that trigger a restart (0: disable conflict restarts)", 1487 &(*set)->conf_restartnum, FALSE, SCIP_DEFAULT_CONF_RESTARTNUM, 0, INT_MAX, 1488 NULL, NULL) ); 1489 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 1490 "conflict/restartfac", 1491 "factor to increase restartnum with after each restart", 1492 &(*set)->conf_restartfac, FALSE, SCIP_DEFAULT_CONF_RESTARTFAC, 0.0, SCIP_REAL_MAX, 1493 NULL, NULL) ); 1494 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1495 "conflict/ignorerelaxedbd", 1496 "should relaxed bounds be ignored?", 1497 &(*set)->conf_ignorerelaxedbd, TRUE, SCIP_DEFAULT_CONF_IGNORERELAXEDBD, 1498 NULL, NULL) ); 1499 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 1500 "conflict/maxvarsdetectimpliedbounds", 1501 "maximal number of variables to try to detect global bound implications and shorten the whole conflict set (0: disabled)", 1502 &(*set)->conf_maxvarsdetectimpliedbounds, TRUE, SCIP_DEFAULT_CONF_MAXVARSDETECTIMPLIEDBOUNDS, 0, INT_MAX, 1503 NULL, NULL) ); 1504 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1505 "conflict/fullshortenconflict", 1506 "try to shorten the whole conflict set or terminate early (depending on the 'maxvarsdetectimpliedbounds' parameter)", 1507 &(*set)->conf_fullshortenconflict, TRUE, SCIP_DEFAULT_CONF_FULLSHORTENCONFLICT, 1508 NULL, NULL) ); 1509 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 1510 "conflict/conflictweight", 1511 "the weight the VSIDS score is weight by updating the VSIDS for a variable if it is part of a conflict", 1512 &(*set)->conf_conflictweight, FALSE, SCIP_DEFAULT_CONF_CONFLITWEIGHT, 0.0, 1.0, 1513 NULL, NULL) ); 1514 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 1515 "conflict/conflictgraphweight", 1516 "the weight the VSIDS score is weight by updating the VSIDS for a variable if it is part of a conflict graph", 1517 &(*set)->conf_conflictgraphweight, FALSE, SCIP_DEFAULT_CONF_CONFLITGRAPHWEIGHT, 0.0, 1.0, 1518 NULL, NULL) ); 1519 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 1520 "conflict/minimprove", 1521 "minimal improvement of primal bound to remove conflicts based on a previous incumbent", 1522 &(*set)->conf_minimprove, TRUE, SCIP_DEFAULT_CONF_MINIMPROVE, 0.0, 1.0, NULL, NULL) ); 1523 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 1524 "conflict/weightsize", 1525 "weight of the size of a conflict used in score calculation", 1526 &(*set)->conf_weightsize, TRUE, SCIP_DEFAULT_CONF_WEIGHTSIZE, 0.0, 1.0, NULL, NULL) ); 1527 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 1528 "conflict/weightrepropdepth", 1529 "weight of the repropagation depth of a conflict used in score calculation", 1530 &(*set)->conf_weightrepropdepth, TRUE, SCIP_DEFAULT_CONF_WEIGHTREPROPDEPTH, 0.0, 1.0, NULL, NULL) ); 1531 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 1532 "conflict/weightvaliddepth", 1533 "weight of the valid depth of a conflict used in score calculation", 1534 &(*set)->conf_weightvaliddepth, TRUE, SCIP_DEFAULT_CONF_WEIGHTVALIDDEPTH, 0.0, 1.0, NULL, NULL) ); 1535 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1536 "conflict/sepaaltproofs", 1537 "apply cut generating functions to construct alternative proofs", 1538 &(*set)->conf_sepaaltproofs, FALSE, SCIP_DEFAULT_CONF_SEPAALTPROOFS, 1539 NULL, NULL) ); 1540 1541 /* constraint parameters */ 1542 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 1543 "constraints/agelimit", 1544 "maximum age an unnecessary constraint can reach before it is deleted (0: dynamic, -1: keep all constraints)", 1545 &(*set)->cons_agelimit, TRUE, SCIP_DEFAULT_CONS_AGELIMIT, -1, INT_MAX, 1546 NULL, NULL) ); 1547 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 1548 "constraints/obsoleteage", 1549 "age of a constraint after which it is marked obsolete (0: dynamic, -1 do not mark constraints obsolete)", 1550 &(*set)->cons_obsoleteage, TRUE, SCIP_DEFAULT_CONS_OBSOLETEAGE, -1, INT_MAX, 1551 NULL, NULL) ); 1552 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1553 "constraints/disableenfops", 1554 "should enforcement of pseudo solution be disabled?", 1555 &(*set)->cons_disableenfops, TRUE, SCIP_DEFAULT_CONS_DISABLEENFOPS, 1556 NULL, NULL) ); 1557 1558 /* display parameters */ 1559 assert(sizeof(int) == sizeof(SCIP_VERBLEVEL)); /*lint !e506*/ 1560 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 1561 "display/verblevel", 1562 "verbosity level of output", 1563 (int*)&(*set)->disp_verblevel, FALSE, (int)SCIP_DEFAULT_DISP_VERBLEVEL, 1564 (int)SCIP_VERBLEVEL_NONE, (int)SCIP_VERBLEVEL_FULL, 1565 NULL, NULL) ); 1566 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 1567 "display/width", 1568 "maximal number of characters in a node information line", 1569 &(*set)->disp_width, FALSE, SCIP_DEFAULT_DISP_WIDTH, 0, INT_MAX, 1570 SCIPparamChgdDispWidth, NULL) ); 1571 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 1572 "display/freq", 1573 "frequency for displaying node information lines", 1574 &(*set)->disp_freq, FALSE, SCIP_DEFAULT_DISP_FREQ, -1, INT_MAX, 1575 NULL, NULL) ); 1576 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 1577 "display/headerfreq", 1578 "frequency for displaying header lines (every n'th node information line)", 1579 &(*set)->disp_headerfreq, FALSE, SCIP_DEFAULT_DISP_HEADERFREQ, -1, INT_MAX, 1580 NULL, NULL) ); 1581 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1582 "display/lpinfo", 1583 "should the LP solver display status messages?", 1584 &(*set)->disp_lpinfo, FALSE, SCIP_DEFAULT_DISP_LPINFO, 1585 NULL, NULL) ); 1586 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1587 "display/allviols", 1588 "display all violations for a given start solution / the best solution after the solving process?", 1589 &(*set)->disp_allviols, FALSE, SCIP_DEFAULT_DISP_ALLVIOLS, 1590 NULL, NULL) ); 1591 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1592 "display/relevantstats", 1593 "should the relevant statistics be displayed at the end of solving?", 1594 &(*set)->disp_relevantstats, FALSE, SCIP_DEFAULT_DISP_RELEVANTSTATS, 1595 NULL, NULL) ); 1596 1597 /* heuristic parameters */ 1598 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1599 "heuristics/useuctsubscip", 1600 "should setting of common subscip parameters include the activation of the UCT node selector?", 1601 &(*set)->heur_useuctsubscip, TRUE, SCIP_DEFAULT_HEUR_USEUCTSUBSCIP, NULL, NULL) ); 1602 1603 /* history parameters */ 1604 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1605 "history/valuebased", 1606 "should statistics be collected for variable domain value pairs?", 1607 &(*set)->history_valuebased, FALSE, SCIP_DEFAULT_HISTORY_VALUEBASED, 1608 NULL, NULL) ); 1609 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1610 "history/allowmerge", 1611 "should variable histories be merged from sub-SCIPs whenever possible?", 1612 &(*set)->history_allowmerge, FALSE, SCIP_DEFAULT_HISTORY_ALLOWMERGE, 1613 NULL, NULL) ); 1614 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1615 "history/allowtransfer", 1616 "should variable histories be transferred to initialize SCIP copies?", 1617 &(*set)->history_allowtransfer, FALSE, SCIP_DEFAULT_HISTORY_ALLOWTRANSFER, 1618 NULL, NULL) ); 1619 1620 /* limit parameters */ 1621 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 1622 "limits/time", 1623 "maximal time in seconds to run", 1624 &(*set)->limit_time, FALSE, SCIP_DEFAULT_LIMIT_TIME, 0.0, SCIP_DEFAULT_LIMIT_TIME, 1625 SCIPparamChgdLimit, NULL) ); 1626 SCIP_CALL( SCIPsetAddLongintParam(*set, messagehdlr, blkmem, 1627 "limits/nodes", 1628 "maximal number of nodes to process (-1: no limit)", 1629 &(*set)->limit_nodes, FALSE, SCIP_DEFAULT_LIMIT_NODES, -1LL, SCIP_LONGINT_MAX, 1630 SCIPparamChgdLimit, NULL) ); 1631 SCIP_CALL( SCIPsetAddLongintParam(*set, messagehdlr, blkmem, 1632 "limits/totalnodes", 1633 "maximal number of total nodes (incl. restarts) to process (-1: no limit)", 1634 &(*set)->limit_totalnodes, FALSE, SCIP_DEFAULT_LIMIT_NODES, -1LL, SCIP_LONGINT_MAX, 1635 SCIPparamChgdLimit, NULL) ); 1636 SCIP_CALL( SCIPsetAddLongintParam(*set, messagehdlr, blkmem, 1637 "limits/stallnodes", 1638 "solving stops, if the given number of nodes was processed since the last improvement of the primal solution value (-1: no limit)", 1639 &(*set)->limit_stallnodes, FALSE, SCIP_DEFAULT_LIMIT_STALLNODES, -1LL, SCIP_LONGINT_MAX, 1640 SCIPparamChgdLimit, NULL) ); 1641 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 1642 "limits/memory", 1643 "maximal memory usage in MB; reported memory usage is lower than real memory usage!", 1644 &(*set)->limit_memory, FALSE, (SCIP_Real)SCIP_DEFAULT_LIMIT_MEMORY, 0.0, (SCIP_Real)SCIP_MEM_NOLIMIT, 1645 SCIPparamChgdLimit, NULL) ); 1646 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 1647 "limits/gap", 1648 "solving stops, if the relative gap = |primal - dual|/MIN(|dual|,|primal|) is below the given value, the gap is 'Infinity', if primal and dual bound have opposite signs", 1649 &(*set)->limit_gap, FALSE, SCIP_DEFAULT_LIMIT_GAP, 0.0, SCIP_REAL_MAX, 1650 SCIPparamChgdLimit, NULL) ); 1651 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 1652 "limits/absgap", 1653 "solving stops, if the absolute gap = |primalbound - dualbound| is below the given value", 1654 &(*set)->limit_absgap, FALSE, SCIP_DEFAULT_LIMIT_ABSGAP, 0.0, SCIP_REAL_MAX, 1655 SCIPparamChgdLimit, NULL) ); 1656 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 1657 "limits/objectivestop", 1658 "solving stops, if solution is found that is at least as good as given value", 1659 &(*set)->limit_objstop, FALSE, SCIP_DEFAULT_LIMIT_OBJSTOP, SCIP_REAL_MIN, SCIP_REAL_MAX, 1660 SCIPparamChgdLimit, NULL) ); 1661 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 1662 "limits/solutions", 1663 "solving stops, if the given number of solutions were found; this limit is first checked in presolving (-1: no limit)", 1664 &(*set)->limit_solutions, FALSE, SCIP_DEFAULT_LIMIT_SOLUTIONS, -1, INT_MAX, 1665 SCIPparamChgdLimit, NULL) ); 1666 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 1667 "limits/bestsol", 1668 "solving stops, if the given number of solution improvements were found (-1: no limit)", 1669 &(*set)->limit_bestsol, FALSE, SCIP_DEFAULT_LIMIT_BESTSOL, -1, INT_MAX, 1670 SCIPparamChgdLimit, NULL) ); 1671 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 1672 "limits/maxsol", 1673 "maximal number of solutions to store in the solution storage", 1674 &(*set)->limit_maxsol, FALSE, SCIP_DEFAULT_LIMIT_MAXSOL, 1, INT_MAX, 1675 SCIPparamChgdLimit, NULL) ); 1676 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 1677 "limits/maxorigsol", 1678 "maximal number of solutions candidates to store in the solution storage of the original problem", 1679 &(*set)->limit_maxorigsol, FALSE, SCIP_DEFAULT_LIMIT_MAXORIGSOL, 0, INT_MAX, 1680 SCIPparamChgdLimit, NULL) ); 1681 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 1682 "limits/restarts", 1683 "solving stops, if the given number of restarts was triggered (-1: no limit)", 1684 &(*set)->limit_restarts, FALSE, SCIP_DEFAULT_LIMIT_RESTARTS, -1, INT_MAX, 1685 SCIPparamChgdLimit, NULL) ); 1686 1687 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 1688 "limits/autorestartnodes", 1689 "if solve exceeds this number of nodes for the first time, an automatic restart is triggered (-1: no automatic restart)", 1690 &(*set)->limit_autorestartnodes, FALSE, SCIP_DEFAULT_LIMIT_AUTORESTARTNODES, -1, INT_MAX, 1691 SCIPparamChgdLimit, NULL) ); 1692 1693 /* LP parameters */ 1694 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 1695 "lp/solvefreq", 1696 "frequency for solving LP at the nodes (-1: never; 0: only root LP)", 1697 &(*set)->lp_solvefreq, FALSE, SCIP_DEFAULT_LP_SOLVEFREQ, -1, SCIP_MAXTREEDEPTH, 1698 NULL, NULL) ); 1699 SCIP_CALL( SCIPsetAddLongintParam(*set, messagehdlr, blkmem, 1700 "lp/iterlim", 1701 "iteration limit for each single LP solve (-1: no limit)", 1702 &(*set)->lp_iterlim, TRUE, SCIP_DEFAULT_LP_ITERLIM, -1LL, SCIP_LONGINT_MAX, 1703 NULL, NULL) ); 1704 SCIP_CALL( SCIPsetAddLongintParam(*set, messagehdlr, blkmem, 1705 "lp/rootiterlim", 1706 "iteration limit for initial root LP solve (-1: no limit)", 1707 &(*set)->lp_rootiterlim, TRUE, SCIP_DEFAULT_LP_ROOTITERLIM, -1LL, SCIP_LONGINT_MAX, 1708 NULL, NULL) ); 1709 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 1710 "lp/solvedepth", 1711 "maximal depth for solving LP at the nodes (-1: no depth limit)", 1712 &(*set)->lp_solvedepth, FALSE, SCIP_DEFAULT_LP_SOLVEDEPTH, -1, SCIP_MAXTREEDEPTH, 1713 NULL, NULL) ); 1714 SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem, 1715 "lp/initalgorithm", 1716 "LP algorithm for solving initial LP relaxations (automatic 's'implex, 'p'rimal simplex, 'd'ual simplex, 'b'arrier, barrier with 'c'rossover)", 1717 &(*set)->lp_initalgorithm, FALSE, SCIP_DEFAULT_LP_INITALGORITHM, "spdbc", 1718 NULL, NULL) ); 1719 SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem, 1720 "lp/resolvealgorithm", 1721 "LP algorithm for resolving LP relaxations if a starting basis exists (automatic 's'implex, 'p'rimal simplex, 'd'ual simplex, 'b'arrier, barrier with 'c'rossover)", 1722 &(*set)->lp_resolvealgorithm, FALSE, SCIP_DEFAULT_LP_RESOLVEALGORITHM, "spdbc", 1723 NULL, NULL) ); 1724 SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem, 1725 "lp/pricing", 1726 "LP pricing strategy ('l'pi default, 'a'uto, 'f'ull pricing, 'p'artial, 's'teepest edge pricing, 'q'uickstart steepest edge pricing, 'd'evex pricing)", 1727 &(*set)->lp_pricing, FALSE, SCIP_DEFAULT_LP_PRICING, "lafpsqd", 1728 NULL, NULL) ); 1729 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1730 "lp/clearinitialprobinglp", 1731 "should lp state be cleared at the end of probing mode when lp was initially unsolved, e.g., when called right after presolving?", 1732 &(*set)->lp_clearinitialprobinglp, TRUE, SCIP_DEFAULT_LP_CLEARINITIALPROBINGLP, 1733 NULL, NULL) ); 1734 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1735 "lp/resolverestore", 1736 "should the LP be resolved to restore the state at start of diving (if FALSE we buffer the solution values)?", 1737 &(*set)->lp_resolverestore, TRUE, SCIP_DEFAULT_LP_RESOLVERESTORE, 1738 NULL, NULL) ); 1739 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1740 "lp/freesolvalbuffers", 1741 "should the buffers for storing LP solution values during diving be freed at end of diving?", 1742 &(*set)->lp_freesolvalbuffers, TRUE, SCIP_DEFAULT_LP_FREESOLVALBUFFERS, 1743 NULL, NULL) ); 1744 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 1745 "lp/colagelimit", 1746 "maximum age a dynamic column can reach before it is deleted from the LP (-1: don't delete columns due to aging)", 1747 &(*set)->lp_colagelimit, TRUE, SCIP_DEFAULT_LP_COLAGELIMIT, -1, INT_MAX, 1748 NULL, NULL) ); 1749 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 1750 "lp/rowagelimit", 1751 "maximum age a dynamic row can reach before it is deleted from the LP (-1: don't delete rows due to aging)", 1752 &(*set)->lp_rowagelimit, TRUE, SCIP_DEFAULT_LP_ROWAGELIMIT, -1, INT_MAX, 1753 NULL, NULL) ); 1754 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1755 "lp/cleanupcols", 1756 "should new non-basic columns be removed after LP solving?", 1757 &(*set)->lp_cleanupcols, TRUE, SCIP_DEFAULT_LP_CLEANUPCOLS, 1758 NULL, NULL) ); 1759 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1760 "lp/cleanupcolsroot", 1761 "should new non-basic columns be removed after root LP solving?", 1762 &(*set)->lp_cleanupcolsroot, TRUE, SCIP_DEFAULT_LP_CLEANUPCOLSROOT, 1763 NULL, NULL) ); 1764 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1765 "lp/cleanuprows", 1766 "should new basic rows be removed after LP solving?", 1767 &(*set)->lp_cleanuprows, TRUE, SCIP_DEFAULT_LP_CLEANUPROWS, 1768 NULL, NULL) ); 1769 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1770 "lp/cleanuprowsroot", 1771 "should new basic rows be removed after root LP solving?", 1772 &(*set)->lp_cleanuprowsroot, TRUE, SCIP_DEFAULT_LP_CLEANUPROWSROOT, 1773 NULL, NULL) ); 1774 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1775 "lp/checkstability", 1776 "should LP solver's return status be checked for stability?", 1777 &(*set)->lp_checkstability, TRUE, SCIP_DEFAULT_LP_CHECKSTABILITY, 1778 NULL, NULL) ); 1779 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 1780 "lp/conditionlimit", 1781 "maximum condition number of LP basis counted as stable (-1.0: no limit)", 1782 &(*set)->lp_conditionlimit, TRUE, SCIP_DEFAULT_LP_CONDITIONLIMIT, -1.0, SCIP_REAL_MAX, 1783 NULL, NULL) ); 1784 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 1785 "lp/minmarkowitz", 1786 "minimal Markowitz threshold to control sparsity/stability in LU factorization", 1787 &(*set)->lp_markowitz, TRUE, SCIP_DEFAULT_LP_MARKOWITZ, 1e-4, 0.9999, 1788 NULL, NULL) ); 1789 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1790 "lp/checkprimfeas", 1791 "should LP solutions be checked for primal feasibility, resolving LP when numerical troubles occur?", 1792 &(*set)->lp_checkprimfeas, TRUE, SCIP_DEFAULT_LP_CHECKPRIMFEAS, 1793 NULL, NULL) ); 1794 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1795 "lp/checkdualfeas", 1796 "should LP solutions be checked for dual feasibility, resolving LP when numerical troubles occur?", 1797 &(*set)->lp_checkdualfeas, TRUE, SCIP_DEFAULT_LP_CHECKDUALFEAS, 1798 NULL, NULL) ); 1799 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1800 "lp/checkfarkas", 1801 "should infeasibility proofs from the LP be checked?", 1802 &(*set)->lp_checkfarkas, TRUE, SCIP_DEFAULT_LP_CHECKFARKAS, 1803 NULL, NULL) ); 1804 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 1805 "lp/fastmip", 1806 "which FASTMIP setting of LP solver should be used? 0: off, 1: low", 1807 &(*set)->lp_fastmip, TRUE, SCIP_DEFAULT_LP_FASTMIP, 0, 1, 1808 NULL, NULL) ); 1809 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 1810 "lp/scaling", 1811 "LP scaling (0: none, 1: normal, 2: aggressive)", 1812 &(*set)->lp_scaling, TRUE, SCIP_DEFAULT_LP_SCALING, 0, 2, 1813 NULL, NULL) ); 1814 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1815 "lp/presolving", 1816 "should presolving of LP solver be used?", 1817 &(*set)->lp_presolving, TRUE, SCIP_DEFAULT_LP_PRESOLVING, 1818 NULL, NULL) ); 1819 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1820 "lp/lexdualalgo", 1821 "should the lexicographic dual algorithm be used?", 1822 &(*set)->lp_lexdualalgo, TRUE, SCIP_DEFAULT_LP_LEXDUALALGO, 1823 NULL, NULL) ); 1824 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1825 "lp/lexdualrootonly", 1826 "should the lexicographic dual algorithm be applied only at the root node", 1827 &(*set)->lp_lexdualrootonly, TRUE, SCIP_DEFAULT_LP_LEXDUALROOTONLY, 1828 NULL, NULL) ); 1829 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 1830 "lp/lexdualmaxrounds", 1831 "maximum number of rounds in the lexicographic dual algorithm (-1: unbounded)", 1832 &(*set)->lp_lexdualmaxrounds, TRUE, SCIP_DEFAULT_LP_LEXDUALMAXROUNDS, -1, INT_MAX, 1833 NULL, NULL) ); 1834 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1835 "lp/lexdualbasic", 1836 "choose fractional basic variables in lexicographic dual algorithm?", 1837 &(*set)->lp_lexdualbasic, TRUE, SCIP_DEFAULT_LP_LEXDUALBASIC, 1838 NULL, NULL) ); 1839 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1840 "lp/lexdualstalling", 1841 "turn on the lex dual algorithm only when stalling?", 1842 &(*set)->lp_lexdualstalling, TRUE, SCIP_DEFAULT_LP_LEXDUALSTALLING, 1843 NULL, NULL) ); 1844 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 1845 "lp/disablecutoff", 1846 "disable the cutoff bound in the LP solver? (0: enabled, 1: disabled, 2: auto)", 1847 &(*set)->lp_disablecutoff, TRUE, SCIP_DEFAULT_LP_DISABLECUTOFF, 1848 0, 2, NULL, NULL) ); 1849 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 1850 "lp/rowrepswitch", 1851 "simplex algorithm shall use row representation of the basis if number of rows divided by number of columns exceeds this value (-1.0 to disable row representation)", 1852 &(*set)->lp_rowrepswitch, TRUE, SCIP_DEFAULT_LP_ROWREPSWITCH, -1.0, SCIP_REAL_MAX, 1853 NULL, NULL) ); 1854 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 1855 "lp/threads", 1856 "number of threads used for solving the LP (0: automatic)", 1857 &(*set)->lp_threads, TRUE, SCIP_DEFAULT_LP_THREADS, 0, 64, 1858 NULL, NULL) ); 1859 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 1860 "lp/resolveiterfac", 1861 "factor of average LP iterations that is used as LP iteration limit for LP resolve (-1: unlimited)", 1862 &(*set)->lp_resolveiterfac, TRUE, SCIP_DEFAULT_LP_RESOLVEITERFAC, -1.0, SCIP_REAL_MAX, 1863 NULL, NULL) ); 1864 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 1865 "lp/resolveitermin", 1866 "minimum number of iterations that are allowed for LP resolve", 1867 &(*set)->lp_resolveitermin, TRUE, SCIP_DEFAULT_LP_RESOLVEITERMIN, 1, INT_MAX, 1868 NULL, NULL) ); 1869 1870 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 1871 "lp/solutionpolishing", 1872 "LP solution polishing method (0: disabled, 1: only root, 2: always, 3: auto)", 1873 &(*set)->lp_solutionpolishing, TRUE, SCIP_DEFAULT_LP_SOLUTIONPOLISHING, 0, 3, 1874 NULL, NULL) ); 1875 1876 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 1877 "lp/refactorinterval", 1878 "LP refactorization interval (0: auto)", 1879 &(*set)->lp_refactorinterval, TRUE, SCIP_DEFAULT_LP_REFACTORINTERVAL, 0, INT_MAX, 1880 NULL, NULL) ); 1881 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1882 "lp/alwaysgetduals", 1883 "should the Farkas duals always be collected when an LP is found to be infeasible?", 1884 &(*set)->lp_alwaysgetduals, FALSE, SCIP_DEFAULT_LP_ALWAYSGETDUALS, 1885 NULL, NULL) ); 1886 1887 /* NLP parameters */ 1888 SCIP_CALL( SCIPsetAddStringParam(*set, messagehdlr, blkmem, 1889 "nlp/solver", 1890 "solver to use for solving NLPs; leave empty to select NLPI with highest priority", 1891 &(*set)->nlp_solver, FALSE, SCIP_DEFAULT_NLP_SOLVER, 1892 NULL, NULL) ); 1893 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1894 "nlp/disable", 1895 "should the NLP relaxation be always disabled (also for NLPs/MINLPs)?", 1896 &(*set)->nlp_disable, FALSE, SCIP_DEFAULT_NLP_DISABLE, 1897 NULL, NULL) ); 1898 1899 /* memory parameters */ 1900 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 1901 "memory/savefac", 1902 "fraction of maximal memory usage resulting in switch to memory saving mode", 1903 &(*set)->mem_savefac, FALSE, SCIP_DEFAULT_MEM_SAVEFAC, 0.0, 1.0, 1904 NULL, NULL) ); 1905 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 1906 "memory/arraygrowfac", 1907 "memory growing factor for dynamically allocated arrays", 1908 &(*set)->mem_arraygrowfac, TRUE, SCIP_DEFAULT_MEM_ARRAYGROWFAC, 1.0, 10.0, 1909 paramChgdArraygrowfac, NULL) ); 1910 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 1911 "memory/arraygrowinit", 1912 "initial size of dynamically allocated arrays", 1913 &(*set)->mem_arraygrowinit, TRUE, SCIP_DEFAULT_MEM_ARRAYGROWINIT, 0, INT_MAX, 1914 paramChgdArraygrowinit, NULL) ); 1915 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 1916 "memory/treegrowfac", 1917 "memory growing factor for tree array", 1918 &(*set)->mem_treegrowfac, TRUE, SCIP_DEFAULT_MEM_TREEGROWFAC, 1.0, 10.0, 1919 NULL, NULL) ); 1920 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 1921 "memory/treegrowinit", 1922 "initial size of tree array", 1923 &(*set)->mem_treegrowinit, TRUE, SCIP_DEFAULT_MEM_TREEGROWINIT, 0, INT_MAX, 1924 NULL, NULL) ); 1925 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 1926 "memory/pathgrowfac", 1927 "memory growing factor for path array", 1928 &(*set)->mem_pathgrowfac, TRUE, SCIP_DEFAULT_MEM_PATHGROWFAC, 1.0, 10.0, 1929 NULL, NULL) ); 1930 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 1931 "memory/pathgrowinit", 1932 "initial size of path array", 1933 &(*set)->mem_pathgrowinit, TRUE, SCIP_DEFAULT_MEM_PATHGROWINIT, 0, INT_MAX, 1934 NULL, NULL) ); 1935 1936 /* miscellaneous parameters */ 1937 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1938 "misc/catchctrlc", 1939 "should the CTRL-C interrupt be caught by SCIP?", 1940 &(*set)->misc_catchctrlc, FALSE, SCIP_DEFAULT_MISC_CATCHCTRLC, 1941 NULL, NULL) ); 1942 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1943 "misc/usevartable", 1944 "should a hashtable be used to map from variable names to variables?", 1945 &(*set)->misc_usevartable, FALSE, SCIP_DEFAULT_MISC_USEVARTABLE, 1946 NULL, NULL) ); 1947 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1948 "misc/useconstable", 1949 "should a hashtable be used to map from constraint names to constraints?", 1950 &(*set)->misc_useconstable, FALSE, SCIP_DEFAULT_MISC_USECONSTABLE, 1951 NULL, NULL) ); 1952 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1953 "misc/usesmalltables", 1954 "should smaller hashtables be used? yields better performance for small problems with about 100 variables", 1955 &(*set)->misc_usesmalltables, FALSE, SCIP_DEFAULT_MISC_USESMALLTABLES, 1956 NULL, NULL) ); 1957 #if 0 /**@todo activate exactsolve parameter and finish implementation of solving MIPs exactly */ 1958 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1959 "misc/exactsolve", 1960 "should the problem be solved exactly (with proven dual bounds)?", 1961 &(*set)->misc_exactsolve, FALSE, SCIP_DEFAULT_MISC_EXACTSOLVE, 1962 NULL, NULL) ); 1963 #else 1964 (*set)->misc_exactsolve = SCIP_DEFAULT_MISC_EXACTSOLVE; 1965 #endif 1966 1967 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1968 "misc/resetstat", 1969 "should the statistics be reset if the transformed problem is freed (in case of a Benders' decomposition this parameter should be set to FALSE)", 1970 &(*set)->misc_resetstat, FALSE, SCIP_DEFAULT_MISC_RESETSTAT, 1971 NULL, NULL) ); 1972 1973 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1974 "misc/improvingsols", 1975 "should only solutions be checked which improve the primal bound", 1976 &(*set)->misc_improvingsols, FALSE, SCIP_DEFAULT_MISC_IMPROVINGSOLS, 1977 NULL, NULL) ); 1978 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1979 "misc/printreason", 1980 "should the reason be printed if a given start solution is infeasible", 1981 &(*set)->misc_printreason, FALSE, SCIP_DEFAULT_MISC_PRINTREASON, 1982 NULL, NULL) ); 1983 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1984 "misc/estimexternmem", 1985 "should the usage of external memory be estimated?", 1986 &(*set)->misc_estimexternmem, FALSE, SCIP_DEFAULT_MISC_ESTIMEXTERNMEM, 1987 NULL, NULL) ); 1988 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1989 "misc/avoidmemout", 1990 "try to avoid running into memory limit by restricting plugins like heuristics?", 1991 &(*set)->misc_avoidmemout, FALSE, SCIP_DEFAULT_MISC_AVOIDMEMOUT, 1992 NULL, NULL) ); 1993 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1994 "misc/transorigsols", 1995 "should SCIP try to transfer original solutions to the transformed space (after presolving)?", 1996 &(*set)->misc_transorigsols, FALSE, SCIP_DEFAULT_MISC_TRANSORIGSOLS, 1997 NULL, NULL) ); 1998 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 1999 "misc/transsolsorig", 2000 "should SCIP try to transfer transformed solutions to the original space (after solving)?", 2001 &(*set)->misc_transsolsorig, FALSE, SCIP_DEFAULT_MISC_TRANSSOLSORIG, 2002 NULL, NULL) ); 2003 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2004 "misc/calcintegral", 2005 "should SCIP calculate the primal dual integral value?", 2006 &(*set)->misc_calcintegral, FALSE, SCIP_DEFAULT_MISC_CALCINTEGRAL, 2007 NULL, NULL) ); 2008 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2009 "misc/finitesolutionstore", 2010 "should SCIP try to remove infinite fixings from solutions copied to the solution store?", 2011 &(*set)->misc_finitesolstore, FALSE, SCIP_DEFAULT_MISC_FINITESOLSTORE, 2012 NULL, NULL) ); 2013 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2014 "misc/outputorigsol", 2015 "should the best solution be transformed to the orignal space and be output in command line run?", 2016 &(*set)->misc_outputorigsol, FALSE, SCIP_DEFAULT_MISC_OUTPUTORIGSOL, 2017 NULL, NULL) ); 2018 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2019 "misc/allowstrongdualreds", 2020 "should strong dual reductions be allowed in propagation and presolving?", 2021 &(*set)->misc_allowstrongdualreds, FALSE, SCIP_DEFAULT_MISC_ALLOWSTRONGDUALREDS, 2022 NULL, NULL) ); 2023 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2024 "misc/allowweakdualreds", 2025 "should weak dual reductions be allowed in propagation and presolving?", 2026 &(*set)->misc_allowweakdualreds, FALSE, SCIP_DEFAULT_MISC_ALLOWWEAKDUALREDS, 2027 NULL, NULL) ); 2028 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2029 "misc/scaleobj", 2030 "should the objective function be scaled so that it is always integer?", 2031 &(*set)->misc_scaleobj, FALSE, SCIP_DEFAULT_MISC_SCALEOBJ, 2032 NULL, NULL) ); 2033 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2034 "misc/showdivingstats", 2035 "should detailed statistics for diving heuristics be shown?", 2036 &(*set)->misc_showdivingstats, FALSE, SCIP_DEFAULT_MISC_SHOWDIVINGSTATS, 2037 NULL, NULL) ); 2038 2039 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 2040 "misc/referencevalue", 2041 "objective value for reference purposes", 2042 &(*set)->misc_referencevalue, FALSE, SCIP_DEFAULT_MISC_REFERENCEVALUE, SCIP_REAL_MIN, SCIP_REAL_MAX, 2043 NULL, NULL) ); 2044 2045 #ifdef WITH_DEBUG_SOLUTION 2046 SCIP_CALL( SCIPsetAddStringParam(*set, messagehdlr, blkmem, 2047 "misc/debugsol", 2048 "path to a debug solution", 2049 &(*set)->misc_debugsol, FALSE, SCIP_DEFAULT_MISC_DEBUGSOLUTION, 2050 NULL, NULL) ); 2051 #endif 2052 2053 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 2054 "misc/usesymmetry", 2055 "bitset describing used symmetry handling technique: " \ 2056 "(0: off; " \ 2057 "1: constraint-based (orbitopes and/or symresacks); " \ 2058 "2: orbital fixing; " \ 2059 "3: orbitopes and orbital fixing; " \ 2060 "4: Schreier Sims cuts; " \ 2061 "5: Schreier Sims cuts and orbitopes; " \ 2062 "6: Schreier Sims cuts and orbital fixing; " \ 2063 "7: Schreier Sims cuts, orbitopes, and orbital fixing) " \ 2064 "See type_symmetry.h.", 2065 &(*set)->misc_usesymmetry, FALSE, SCIP_DEFAULT_MISC_USESYMMETRY, 0, 7, 2066 paramChgdUsesymmetry, NULL) ); 2067 2068 /* randomization parameters */ 2069 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 2070 "randomization/randomseedshift", 2071 "global shift of all random seeds in the plugins and the LP random seed", 2072 &(*set)->random_randomseedshift, FALSE, SCIP_DEFAULT_RANDOM_RANDSEEDSHIFT, 0, INT_MAX, 2073 NULL, NULL) ); 2074 2075 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 2076 "randomization/permutationseed", 2077 "seed value for permuting the problem after reading/transformation (0: no permutation)", 2078 &(*set)->random_permutationseed, FALSE, SCIP_DEFAULT_RANDOM_PERMUTATIONSEED, 0, INT_MAX, 2079 NULL, NULL) ); 2080 2081 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2082 "randomization/permuteconss", 2083 "should order of constraints be permuted (depends on permutationseed)?", 2084 &(*set)->random_permuteconss, TRUE, SCIP_DEFAULT_RANDOM_PERMUTECONSS, 2085 NULL, NULL) ); 2086 2087 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2088 "randomization/permutevars", 2089 "should order of variables be permuted (depends on permutationseed)?", 2090 &(*set)->random_permutevars, TRUE, SCIP_DEFAULT_RANDOM_PERMUTEVARS, 2091 NULL, NULL) ); 2092 2093 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 2094 "randomization/lpseed", 2095 "random seed for LP solver, e.g. for perturbations in the simplex (0: LP default)", 2096 &(*set)->random_randomseed, FALSE, SCIP_DEFAULT_RANDOM_LPSEED, 0, INT_MAX, 2097 NULL, NULL) ); 2098 2099 /* node selection */ 2100 SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem, 2101 "nodeselection/childsel", 2102 "child selection rule ('d'own, 'u'p, 'p'seudo costs, 'i'nference, 'l'p value, 'r'oot LP value difference, 'h'ybrid inference/root LP value difference)", 2103 &(*set)->nodesel_childsel, FALSE, SCIP_DEFAULT_NODESEL_CHILDSEL, "dupilrh", 2104 NULL, NULL) ); 2105 2106 /* numerical parameters */ 2107 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 2108 "numerics/infinity", 2109 "values larger than this are considered infinity", 2110 &(*set)->num_infinity, FALSE, SCIP_DEFAULT_INFINITY, 1e+10, SCIP_INVALID/10.0, 2111 paramChgdInfinity, NULL) ); 2112 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 2113 "numerics/epsilon", 2114 "absolute values smaller than this are considered zero", 2115 &(*set)->num_epsilon, FALSE, SCIP_DEFAULT_EPSILON, SCIP_MINEPSILON, SCIP_MAXEPSILON, 2116 NULL, NULL) ); 2117 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 2118 "numerics/sumepsilon", 2119 "absolute values of sums smaller than this are considered zero", 2120 &(*set)->num_sumepsilon, FALSE, SCIP_DEFAULT_SUMEPSILON, SCIP_MINEPSILON*1e+03, SCIP_MAXEPSILON, 2121 NULL, NULL) ); 2122 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 2123 "numerics/feastol", 2124 "feasibility tolerance for constraints", 2125 &(*set)->num_feastol, FALSE, SCIP_DEFAULT_FEASTOL, SCIP_MINEPSILON*1e+03, SCIP_MAXEPSILON, 2126 paramChgdFeastol, NULL) ); 2127 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 2128 "numerics/checkfeastolfac", 2129 "feasibility tolerance factor; for checking the feasibility of the best solution", 2130 &(*set)->num_checkfeastolfac, FALSE, SCIP_DEFAULT_CHECKFEASTOLFAC, 0.0, SCIP_REAL_MAX, 2131 NULL, NULL) ); 2132 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 2133 "numerics/lpfeastolfactor", 2134 "factor w.r.t. primal feasibility tolerance that determines default (and maximal) primal feasibility tolerance of LP solver", 2135 &(*set)->num_lpfeastolfactor, FALSE, SCIP_DEFAULT_LPFEASTOLFACTOR, 1e-6, 1.0, 2136 paramChgdLPFeastolFactor, NULL) ); 2137 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 2138 "numerics/dualfeastol", 2139 "feasibility tolerance for reduced costs in LP solution", 2140 &(*set)->num_dualfeastol, FALSE, SCIP_DEFAULT_DUALFEASTOL, SCIP_MINEPSILON*1e+03, SCIP_MAXEPSILON, 2141 paramChgdDualfeastol, NULL) ); 2142 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 2143 "numerics/barrierconvtol", 2144 "LP convergence tolerance used in barrier algorithm", 2145 &(*set)->num_barrierconvtol, TRUE, SCIP_DEFAULT_BARRIERCONVTOL, SCIP_MINEPSILON*1e+03, SCIP_MAXEPSILON, 2146 paramChgdBarrierconvtol, NULL) ); 2147 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 2148 "numerics/boundstreps", 2149 "minimal relative improve for strengthening bounds", 2150 &(*set)->num_boundstreps, TRUE, SCIP_DEFAULT_BOUNDSTREPS, SCIP_MINEPSILON*1e+03, SCIP_INVALID/10.0, 2151 NULL, NULL) ); 2152 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 2153 "numerics/pseudocosteps", 2154 "minimal variable distance value to use for branching pseudo cost updates", 2155 &(*set)->num_pseudocosteps, TRUE, SCIP_DEFAULT_PSEUDOCOSTEPS, SCIP_MINEPSILON*1e+03, 1.0, 2156 NULL, NULL) ); 2157 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 2158 "numerics/pseudocostdelta", 2159 "minimal objective distance value to use for branching pseudo cost updates", 2160 &(*set)->num_pseudocostdelta, TRUE, SCIP_DEFAULT_PSEUDOCOSTDELTA, 0.0, SCIP_REAL_MAX, 2161 NULL, NULL) ); 2162 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 2163 "numerics/recomputefac", 2164 "minimal decrease factor that causes the recomputation of a value (e.g., pseudo objective) instead of an update", 2165 &(*set)->num_recompfac, TRUE, SCIP_DEFAULT_RECOMPFAC, 0.0, SCIP_REAL_MAX, 2166 NULL, NULL) ); 2167 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 2168 "numerics/hugeval", 2169 "values larger than this are considered huge and should be handled separately (e.g., in activity computation)", 2170 &(*set)->num_hugeval, TRUE, SCIP_DEFAULT_HUGEVAL, 0.0, SCIP_INVALID/10.0, 2171 NULL, NULL) ); 2172 2173 /* presolving parameters */ 2174 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 2175 "presolving/maxrounds", 2176 "maximal number of presolving rounds (-1: unlimited, 0: off)", 2177 &(*set)->presol_maxrounds, FALSE, SCIP_DEFAULT_PRESOL_MAXROUNDS, -1, INT_MAX, 2178 NULL, NULL) ); 2179 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 2180 "presolving/abortfac", 2181 "abort presolve, if at most this fraction of the problem was changed in last presolve round", 2182 &(*set)->presol_abortfac, TRUE, SCIP_DEFAULT_PRESOL_ABORTFAC, 0.0, 1.0, 2183 NULL, NULL) ); 2184 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 2185 "presolving/maxrestarts", 2186 "maximal number of restarts (-1: unlimited)", 2187 &(*set)->presol_maxrestarts, FALSE, SCIP_DEFAULT_PRESOL_MAXRESTARTS, -1, INT_MAX, 2188 NULL, NULL) ); 2189 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 2190 "presolving/restartfac", 2191 "fraction of integer variables that were fixed in the root node triggering a restart with preprocessing after root node evaluation", 2192 &(*set)->presol_restartfac, TRUE, SCIP_DEFAULT_PRESOL_RESTARTFAC, 0.0, 1.0, 2193 NULL, NULL) ); 2194 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 2195 "presolving/clqtablefac", 2196 "limit on number of entries in clique table relative to number of problem nonzeros", 2197 &(*set)->presol_clqtablefac, TRUE, SCIP_DEFAULT_PRESOL_CLQTABLEFAC, 0.0, SCIP_REAL_MAX, 2198 NULL, NULL) ); 2199 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 2200 "presolving/immrestartfac", 2201 "fraction of integer variables that were fixed in the root node triggering an immediate restart with preprocessing", 2202 &(*set)->presol_immrestartfac, TRUE, SCIP_DEFAULT_PRESOL_IMMRESTARTFAC, 0.0, 1.0, 2203 NULL, NULL) ); 2204 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 2205 "presolving/subrestartfac", 2206 "fraction of integer variables that were globally fixed during the solving process triggering a restart with preprocessing", 2207 &(*set)->presol_subrestartfac, TRUE, SCIP_DEFAULT_PRESOL_SUBRESTARTFAC, 0.0, 1.0, 2208 NULL, NULL) ); 2209 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 2210 "presolving/restartminred", 2211 "minimal fraction of integer variables removed after restart to allow for an additional restart", 2212 &(*set)->presol_restartminred, TRUE, SCIP_DEFAULT_PRESOL_RESTARTMINRED, 0.0, 1.0, 2213 NULL, NULL) ); 2214 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2215 "presolving/donotmultaggr", 2216 "should multi-aggregation of variables be forbidden?", 2217 &(*set)->presol_donotmultaggr, TRUE, SCIP_DEFAULT_PRESOL_DONOTMULTAGGR, 2218 NULL, NULL) ); 2219 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2220 "presolving/donotaggr", 2221 "should aggregation of variables be forbidden?", 2222 &(*set)->presol_donotaggr, TRUE, SCIP_DEFAULT_PRESOL_DONOTAGGR, 2223 NULL, NULL) ); 2224 2225 /* pricing parameters */ 2226 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 2227 "pricing/maxvars", 2228 "maximal number of variables priced in per pricing round", 2229 &(*set)->price_maxvars, FALSE, SCIP_DEFAULT_PRICE_MAXVARS, 1, INT_MAX, 2230 NULL, NULL) ); 2231 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 2232 "pricing/maxvarsroot", 2233 "maximal number of priced variables at the root node", 2234 &(*set)->price_maxvarsroot, FALSE, SCIP_DEFAULT_PRICE_MAXVARSROOT, 1, INT_MAX, 2235 NULL, NULL) ); 2236 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 2237 "pricing/abortfac", 2238 "pricing is aborted, if fac * pricing/maxvars pricing candidates were found", 2239 &(*set)->price_abortfac, FALSE, SCIP_DEFAULT_PRICE_ABORTFAC, 1.0, SCIP_REAL_MAX, 2240 NULL, NULL) ); 2241 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2242 "pricing/delvars", 2243 "should variables created at the current node be deleted when the node is solved in case they are not present in the LP anymore?", 2244 &(*set)->price_delvars, FALSE, SCIP_DEFAULT_PRICE_DELVARS, 2245 NULL, NULL) ); 2246 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2247 "pricing/delvarsroot", 2248 "should variables created at the root node be deleted when the root is solved in case they are not present in the LP anymore?", 2249 &(*set)->price_delvarsroot, FALSE, SCIP_DEFAULT_PRICE_DELVARSROOT, 2250 NULL, NULL) ); 2251 2252 /* Decomposition parameters */ 2253 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2254 "decomposition/benderslabels", 2255 "should the variables be labelled for the application of Benders' decomposition?", 2256 &(*set)->decomp_benderslabels, FALSE, SCIP_DEFAULT_DECOMP_BENDERSLABELS, 2257 NULL, NULL) ); 2258 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2259 "decomposition/applybenders", 2260 "if a decomposition exists, should Benders' decomposition be applied?", 2261 &(*set)->decomp_applybenders, FALSE, SCIP_DEFAULT_DECOMP_APPLYBENDERS, 2262 NULL, NULL) ); 2263 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 2264 "decomposition/maxgraphedge", 2265 "maximum number of edges in block graph computation (-1: no limit, 0: disable block graph computation)", 2266 &(*set)->decomp_maxgraphedge, FALSE, SCIP_DEFAULT_DECOMP_MAXGRAPHEDGE, -1, INT_MAX, 2267 NULL, NULL) ); 2268 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2269 "decomposition/disablemeasures", 2270 "disable expensive measures", 2271 &(*set)->decomp_disablemeasures, FALSE, SCIP_DEFAULT_DECOMP_DISABLEMEASURES, 2272 NULL, NULL) ); 2273 2274 /* Benders' decomposition parameters */ 2275 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 2276 "benders/solutiontol", 2277 "the tolerance used for checking optimality in Benders' decomposition. tol where optimality is given by LB + tol > UB.", 2278 &(*set)->benders_soltol, FALSE, SCIP_DEFAULT_BENDERS_SOLTOL, 0.0, SCIP_REAL_MAX, 2279 NULL, NULL) ); 2280 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2281 "benders/cutlpsol", 2282 "should Benders' cuts be generated from the solution to the LP relaxation?", 2283 &(*set)->benders_cutlpsol, FALSE, SCIP_DEFAULT_BENDERS_CUTLPSOL, 2284 NULL, NULL) ); 2285 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2286 "benders/copybenders", 2287 "should Benders' decomposition be copied for use in sub-SCIPs?", 2288 &(*set)->benders_copybenders, FALSE, SCIP_DEFAULT_BENDERS_COPYBENDERS, 2289 NULL, NULL) ); 2290 2291 /* propagation parameters */ 2292 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 2293 "propagating/maxrounds", 2294 "maximal number of propagation rounds per node (-1: unlimited)", 2295 &(*set)->prop_maxrounds, FALSE, SCIP_DEFAULT_PROP_MAXROUNDS, -1, INT_MAX, 2296 NULL, NULL) ); 2297 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 2298 "propagating/maxroundsroot", 2299 "maximal number of propagation rounds in the root node (-1: unlimited)", 2300 &(*set)->prop_maxroundsroot, FALSE, SCIP_DEFAULT_PROP_MAXROUNDSROOT, -1, INT_MAX, 2301 NULL, NULL) ); 2302 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2303 "propagating/abortoncutoff", 2304 "should propagation be aborted immediately? setting this to FALSE could help conflict analysis to produce more conflict constraints", 2305 &(*set)->prop_abortoncutoff, FALSE, SCIP_DEFAULT_PROP_ABORTONCUTOFF, 2306 NULL, NULL) ); 2307 2308 /* reoptimization */ 2309 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2310 "reoptimization/enable", 2311 "should reoptimization used?", 2312 &(*set)->reopt_enable, FALSE, SCIP_DEFAULT_REOPT_ENABLE, 2313 paramChgdEnableReopt, NULL) ); 2314 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 2315 "reoptimization/maxsavednodes", 2316 "maximal number of saved nodes", 2317 &(*set)->reopt_maxsavednodes, TRUE, SCIP_DEFAULT_REOPT_MAXSAVEDNODES, -1, INT_MAX, 2318 NULL, NULL) ); 2319 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 2320 "reoptimization/maxdiffofnodes", 2321 "maximal number of bound changes between two stored nodes on one path", 2322 &(*set)->reopt_maxdiffofnodes, TRUE, SCIP_DEFAULT_REOPT_MAXDIFFOFNODES, 0, INT_MAX, 2323 NULL, NULL) ); 2324 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2325 "reoptimization/globalcons/sepainfsubtrees", 2326 "save global constraints to separate infeasible subtrees.", 2327 &(*set)->reopt_sepaglbinfsubtrees, FALSE, SCIP_DEFAULT_REOPT_SEPAGLBINFSUBTREES, 2328 NULL, NULL) ); 2329 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2330 "reoptimization/sepabestsol", 2331 "separate the optimal solution, i.e., for constrained shortest path", 2332 &(*set)->reopt_sepabestsol, TRUE, SCIP_DEFAULT_REOPT_SEPABESTSOL, 2333 NULL, NULL) ); 2334 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2335 "reoptimization/storevarhistory", 2336 "use variable history of the previous solve if the objctive function has changed only slightly", 2337 &(*set)->reopt_storevarhistory, TRUE, SCIP_DEFAULT_REOPT_STOREVARHISTOTY, 2338 NULL, NULL) ); 2339 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2340 "reoptimization/usepscost", 2341 "re-use pseudo costs if the objective function changed only slightly ", 2342 &(*set)->reopt_usepscost, TRUE, SCIP_DEFAULT_REOPT_USEPSCOST, 2343 NULL, NULL) ); 2344 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 2345 "reoptimization/solvelp", 2346 "at which reopttype should the LP be solved? (1: transit, 3: strong branched, 4: w/ added logicor, 5: only leafs).", 2347 &(*set)->reopt_solvelp, TRUE, SCIP_DEFAULT_REOPT_SOLVELP, 1, 5, 2348 NULL, NULL) ); 2349 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 2350 "reoptimization/solvelpdiff", 2351 "maximal number of bound changes at node to skip solving the LP", 2352 &(*set)->reopt_solvelpdiff, TRUE, SCIP_DEFAULT_REOPT_SOLVELPDIFF, 0, INT_MAX, 2353 NULL, NULL) ); 2354 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 2355 "reoptimization/savesols", 2356 "number of best solutions which should be saved for the following runs. (-1: save all)", 2357 &(*set)->reopt_savesols, TRUE, SCIP_DEFAULT_REOPT_SAVESOLS, 0, INT_MAX, 2358 NULL, NULL) ); 2359 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 2360 "reoptimization/objsimrootLP", 2361 "similarity of two sequential objective function to disable solving the root LP.", 2362 &(*set)->reopt_objsimrootlp, TRUE, SCIP_DEFAULT_REOPT_OBJSIMROOTLP, -1.0, 1.0, 2363 NULL, NULL) ); 2364 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 2365 "reoptimization/objsimsol", 2366 "similarity of two objective functions to re-use stored solutions", 2367 &(*set)->reopt_objsimsol, TRUE, SCIP_DEFAULT_REOPT_OBJSIMSOL, -1.0, 1.0, 2368 NULL, NULL) ); 2369 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 2370 "reoptimization/delay", 2371 "minimum similarity for using reoptimization of the search tree.", 2372 &(*set)->reopt_objsimdelay, TRUE, SCIP_DEFAULT_REOPT_OBJSIMDELAY, -1.0, 1.0, 2373 NULL, NULL) ); 2374 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2375 "reoptimization/commontimelimit", 2376 "time limit over all reoptimization rounds?.", 2377 &(*set)->reopt_commontimelimit, TRUE, SCIP_DEFAULT_REOPT_COMMONTIMELIMIT, 2378 NULL, NULL) ); 2379 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2380 "reoptimization/shrinkinner", 2381 "replace branched inner nodes by their child nodes, if the number of bound changes is not to large", 2382 &(*set)->reopt_shrinkinner, TRUE, SCIP_DEFAULT_REOPT_SHRINKINNER, 2383 NULL, NULL) ); 2384 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2385 "reoptimization/strongbranchinginit", 2386 "try to fix variables at the root node before reoptimizing by probing like strong branching", 2387 &(*set)->reopt_sbinit, TRUE, SCIP_DEFAULT_REOPT_STRONGBRANCHINIT, 2388 NULL, NULL) ); 2389 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2390 "reoptimization/reducetofrontier", 2391 "delete stored nodes which were not reoptimized", 2392 &(*set)->reopt_reducetofrontier, TRUE, SCIP_DEFAULT_REOPT_REDUCETOFRONTIER, 2393 NULL, NULL) ); 2394 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 2395 "reoptimization/forceheurrestart", 2396 "force a restart if the last n optimal solutions were found by heuristic reoptsols", 2397 &(*set)->reopt_forceheurrestart, TRUE, SCIP_DEFAULT_REOPT_FORCEHEURRESTART, 1, INT_MAX, 2398 NULL, NULL) ); 2399 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2400 "reoptimization/saveconsprop", 2401 "save constraint propagations", 2402 &(*set)->reopt_saveconsprop, TRUE, SCIP_DEFAULT_REOPT_SAVECONSPROP, 2403 NULL, NULL) ); 2404 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2405 "reoptimization/usesplitcons", "use constraints to reconstruct the subtree pruned be dual reduction when reactivating the node", 2406 &(*set)->reopt_usesplitcons, TRUE, SCIP_DEFAULT_REOPT_USESPLITCONS, 2407 NULL, NULL) ); 2408 SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem, 2409 "reoptimization/varorderinterdiction", "use 'd'efault, 'r'andom or a variable ordering based on 'i'nference score for interdiction branching used during reoptimization", 2410 &(*set)->reopt_varorderinterdiction, TRUE, SCIP_DEFAULT_REOPT_VARORDERINTERDICTION, "dir", 2411 NULL, NULL) ); 2412 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2413 "reoptimization/usecuts", 2414 "reoptimize cuts found at the root node", 2415 &(*set)->reopt_usecuts, TRUE, SCIP_DEFAULT_REOPT_USECUTS, 2416 NULL, NULL) ); 2417 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 2418 "reoptimization/maxcutage", 2419 "maximal age of a cut to be use for reoptimization", 2420 &(*set)->reopt_maxcutage, TRUE, SCIP_DEFAULT_REOPT_MAXCUTAGE, 0, INT_MAX, 2421 NULL, NULL) ); 2422 2423 /* separation parameters */ 2424 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 2425 "separating/maxbounddist", 2426 "maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separation (0.0: only on current best node, 1.0: on all nodes)", 2427 &(*set)->sepa_maxbounddist, FALSE, SCIP_DEFAULT_SEPA_MAXBOUNDDIST, 0.0, 1.0, 2428 NULL, NULL) ); 2429 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 2430 "separating/maxlocalbounddist", 2431 "maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying local separation (0.0: only on current best node, 1.0: on all nodes)", 2432 &(*set)->sepa_maxlocalbounddist, FALSE, SCIP_DEFAULT_SEPA_MAXLOCALBOUNDDIST, 0.0, 1.0, 2433 NULL, NULL) ); 2434 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 2435 "separating/maxcoefratio", 2436 "maximal ratio between coefficients in strongcg, cmir, and flowcover cuts", 2437 &(*set)->sepa_maxcoefratio, FALSE, SCIP_DEFAULT_SEPA_MAXCOEFRATIO, 1.0, SCIP_INVALID/10.0, 2438 NULL, NULL) ); 2439 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 2440 "separating/maxcoefratiofacrowprep", 2441 "maximal ratio between coefficients (as factor of 1/feastol) to ensure in rowprep cleanup", 2442 &(*set)->sepa_maxcoefratiofacrowprep, FALSE, SCIP_DEFAULT_SEPA_MAXCOEFRATIOFACROWPREP, 0.0, SCIP_REAL_MAX, 2443 NULL, NULL) ); 2444 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 2445 "separating/minefficacy", 2446 "minimal efficacy for a cut to enter the LP", 2447 &(*set)->sepa_minefficacy, FALSE, SCIP_DEFAULT_SEPA_MINEFFICACY, 0.0, SCIP_INVALID/10.0, 2448 NULL, NULL) ); 2449 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 2450 "separating/minefficacyroot", 2451 "minimal efficacy for a cut to enter the LP in the root node", 2452 &(*set)->sepa_minefficacyroot, FALSE, SCIP_DEFAULT_SEPA_MINEFFICACYROOT, 0.0, SCIP_INVALID/10.0, 2453 NULL, NULL) ); 2454 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 2455 "separating/minactivityquot", 2456 "minimum cut activity quotient to convert cuts into constraints during a restart (0.0: all cuts are converted)", 2457 &(*set)->sepa_minactivityquot, FALSE, SCIP_DEFAULT_SEPA_MINACTIVITYQUOT, 0.0, 1.0, 2458 NULL, NULL) ); 2459 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 2460 "separating/maxcutsgenfactor", 2461 "factor w.r.t. maxcuts for maximal number of cuts generated per separation round (-1.0: no limit, >= 0.0: valid finite limit)", 2462 &(*set)->sepa_maxcutsgenfactor, FALSE, SCIP_DEFAULT_SEPA_MAXCUTSGENFACTOR, -1.0, SCIP_REAL_MAX, 2463 NULL, NULL) ); 2464 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 2465 "separating/maxcutsrootgenfactor", 2466 "factor w.r.t. maxcutsroot for maximal number of generated cuts per separation round at the root node " 2467 "(-1.0: no limit, >= 0.0: valid finite limit)", 2468 &(*set)->sepa_maxcutsrootgenfactor, FALSE, SCIP_DEFAULT_SEPA_MAXCUTSROOTGENFACTOR, -1.0, SCIP_REAL_MAX, 2469 NULL, NULL) ); 2470 SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem, 2471 "separating/orthofunc", 2472 "function used for calc. scalar prod. in orthogonality test ('e'uclidean, 'd'iscrete)", 2473 &(*set)->sepa_orthofunc, TRUE, SCIP_DEFAULT_SEPA_ORTHOFUNC, "ed", 2474 NULL, NULL) ); 2475 SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem, 2476 "separating/efficacynorm", 2477 "row norm to use for efficacy calculation ('e'uclidean, 'm'aximum, 's'um, 'd'iscrete)", 2478 &(*set)->sepa_efficacynorm, TRUE, SCIP_DEFAULT_SEPA_EFFICACYNORM, "emsd", 2479 NULL, NULL) ); 2480 SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem, 2481 "separating/cutselrestart", 2482 "cut selection during restart ('a'ge, activity 'q'uotient)", 2483 &(*set)->sepa_cutselrestart, TRUE, SCIP_DEFAULT_SEPA_CUTSELRESTART, "aq", 2484 NULL, NULL) ); 2485 SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem, 2486 "separating/cutselsubscip", 2487 "cut selection for sub SCIPs ('a'ge, activity 'q'uotient)", 2488 &(*set)->sepa_cutselsubscip, TRUE, SCIP_DEFAULT_SEPA_CUTSELSUBSCIP, "aq", 2489 NULL, NULL) ); 2490 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2491 "separating/filtercutpoolrel", 2492 "should cutpool separate only cuts with high relative efficacy?", 2493 &(*set)->sepa_filtercutpoolrel, TRUE, SCIP_DEFAULT_SEPA_FILTERCUTPOOLREL, 2494 NULL, NULL) ); 2495 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 2496 "separating/maxruns", 2497 "maximal number of runs for which separation is enabled (-1: unlimited)", 2498 &(*set)->sepa_maxruns, TRUE, SCIP_DEFAULT_SEPA_MAXRUNS, -1, INT_MAX, 2499 NULL, NULL) ); 2500 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 2501 "separating/maxrounds", 2502 "maximal number of separation rounds per node (-1: unlimited)", 2503 &(*set)->sepa_maxrounds, FALSE, SCIP_DEFAULT_SEPA_MAXROUNDS, -1, INT_MAX, 2504 NULL, NULL) ); 2505 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 2506 "separating/maxroundsroot", 2507 "maximal number of separation rounds in the root node (-1: unlimited)", 2508 &(*set)->sepa_maxroundsroot, FALSE, SCIP_DEFAULT_SEPA_MAXROUNDSROOT, -1, INT_MAX, 2509 NULL, NULL) ); 2510 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 2511 "separating/maxroundsrootsubrun", 2512 "maximal number of separation rounds in the root node of a subsequent run (-1: unlimited)", 2513 &(*set)->sepa_maxroundsrootsubrun, TRUE, SCIP_DEFAULT_SEPA_MAXROUNDSROOTSUBRUN, -1, INT_MAX, 2514 NULL, NULL) ); 2515 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 2516 "separating/maxaddrounds", 2517 "maximal additional number of separation rounds in subsequent price-and-cut loops (-1: no additional restriction)", 2518 &(*set)->sepa_maxaddrounds, TRUE, SCIP_DEFAULT_SEPA_MAXADDROUNDS, -1, INT_MAX, 2519 NULL, NULL) ); 2520 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 2521 "separating/maxstallrounds", 2522 "maximal number of consecutive separation rounds without objective or integrality improvement in local nodes (-1: no additional restriction)", 2523 &(*set)->sepa_maxstallrounds, FALSE, SCIP_DEFAULT_SEPA_MAXSTALLROUNDS, -1, INT_MAX, 2524 NULL, NULL) ); 2525 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 2526 "separating/maxstallroundsroot", 2527 "maximal number of consecutive separation rounds without objective or integrality improvement in the root node (-1: no additional restriction)", 2528 &(*set)->sepa_maxstallroundsroot, FALSE, SCIP_DEFAULT_SEPA_MAXSTALLROUNDSROOT, -1, INT_MAX, 2529 NULL, NULL) ); 2530 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 2531 "separating/maxcuts", 2532 "maximal number of cuts separated per separation round (0: disable local separation)", 2533 &(*set)->sepa_maxcuts, FALSE, SCIP_DEFAULT_SEPA_MAXCUTS, 0, INT_MAX, 2534 NULL, NULL) ); 2535 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 2536 "separating/maxcutsroot", 2537 "maximal number of separated cuts per separation round at the root node (0: disable root node separation)", 2538 &(*set)->sepa_maxcutsroot, FALSE, SCIP_DEFAULT_SEPA_MAXCUTSROOT, 0, INT_MAX, 2539 NULL, NULL) ); 2540 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 2541 "separating/cutagelimit", 2542 "maximum age a cut can reach before it is deleted from the global cut pool, or -1 to keep all cuts", 2543 &(*set)->sepa_cutagelimit, TRUE, SCIP_DEFAULT_SEPA_CUTAGELIMIT, -1, INT_MAX, 2544 NULL, NULL) ); 2545 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 2546 "separating/poolfreq", 2547 "separation frequency for the global cut pool (-1: disable global cut pool, 0: only separate pool at the root)", 2548 &(*set)->sepa_poolfreq, FALSE, SCIP_DEFAULT_SEPA_POOLFREQ, -1, SCIP_MAXTREEDEPTH, 2549 NULL, NULL) ); 2550 2551 /* parallel parameters */ 2552 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 2553 "parallel/mode", 2554 "parallel optimisation mode, 0: opportunistic or 1: deterministic.", 2555 &(*set)->parallel_mode, FALSE, SCIP_DEFAULT_PARALLEL_MODE, 0, 1, 2556 NULL, NULL) ); 2557 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 2558 "parallel/minnthreads", 2559 "the minimum number of threads used during parallel solve", 2560 &(*set)->parallel_minnthreads, FALSE, SCIP_DEFAULT_PARALLEL_MINNTHREADS, 0, 64, 2561 NULL, NULL) ); 2562 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 2563 "parallel/maxnthreads", 2564 "the maximum number of threads used during parallel solve", 2565 &(*set)->parallel_maxnthreads, FALSE, SCIP_DEFAULT_PARALLEL_MAXNTHREADS, 0, 64, 2566 NULL, NULL) ); 2567 2568 /* concurrent solver parameters */ 2569 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2570 "concurrent/changeseeds", 2571 "set different random seeds in each concurrent solver?", 2572 &(*set)->concurrent_changeseeds, FALSE, SCIP_DEFAULT_CONCURRENT_CHANGESEEDS, 2573 NULL, NULL) ); 2574 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2575 "concurrent/changechildsel", 2576 "use different child selection rules in each concurrent solver?", 2577 &(*set)->concurrent_changechildsel, FALSE, SCIP_DEFAULT_CONCURRENT_CHANGECHILDSEL, 2578 NULL, NULL) ); 2579 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2580 "concurrent/commvarbnds", 2581 "should the concurrent solvers communicate global variable bound changes?", 2582 &(*set)->concurrent_commvarbnds, FALSE, SCIP_DEFAULT_CONCURRENT_COMMVARBNDS, 2583 NULL, NULL) ); 2584 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2585 "concurrent/presolvebefore", 2586 "should the problem be presolved before it is copied to the concurrent solvers?", 2587 &(*set)->concurrent_presolvebefore, FALSE, SCIP_DEFAULT_CONCURRENT_PRESOLVEBEFORE, 2588 NULL, NULL) ); 2589 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 2590 "concurrent/initseed", 2591 "maximum number of solutions that will be shared in a one synchronization", 2592 &(*set)->concurrent_initseed, FALSE, SCIP_DEFAULT_CONCURRENT_INITSEED, 0, INT_MAX, 2593 NULL, NULL) ); 2594 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 2595 "concurrent/sync/freqinit", 2596 "initial frequency of synchronization with other threads", 2597 &(*set)->concurrent_freqinit, FALSE, SCIP_DEFAULT_CONCURRENT_FREQINIT, 0.0, SCIP_REAL_MAX, 2598 NULL, NULL) ); 2599 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 2600 "concurrent/sync/freqmax", 2601 "maximal frequency of synchronization with other threads", 2602 &(*set)->concurrent_freqmax, FALSE, SCIP_DEFAULT_CONCURRENT_FREQMAX, 0.0, SCIP_REAL_MAX, 2603 NULL, NULL) ); 2604 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 2605 "concurrent/sync/freqfactor", 2606 "factor by which the frequency of synchronization is changed", 2607 &(*set)->concurrent_freqfactor, FALSE, SCIP_DEFAULT_CONCURRENT_FREQFACTOR, 1.0, SCIP_REAL_MAX, 2608 NULL, NULL) ); 2609 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 2610 "concurrent/sync/targetprogress", 2611 "when adapting the synchronization frequency this value is the targeted relative difference by which the absolute gap decreases per synchronization", 2612 &(*set)->concurrent_targetprogress, FALSE, SCIP_DEFAULT_CONCURRENT_TARGETPROGRESS, 0.0, SCIP_REAL_MAX, 2613 NULL, NULL) ); 2614 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 2615 "concurrent/sync/maxnsols", 2616 "maximum number of solutions that will be shared in a single synchronization", 2617 &(*set)->concurrent_maxnsols, FALSE, SCIP_DEFAULT_CONCURRENT_MAXNSOLS, 0, 1000, 2618 NULL, NULL) ); 2619 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 2620 "concurrent/sync/maxnsyncdelay", 2621 "maximum number of synchronizations before reading is enforced regardless of delay", 2622 &(*set)->concurrent_maxnsyncdelay, TRUE, SCIP_DEFAULT_CONCURRENT_MAXNSYNCDELAY, 0, 100, 2623 NULL, NULL) ); 2624 SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem, 2625 "concurrent/sync/minsyncdelay", 2626 "minimum delay before synchronization data is read", 2627 &(*set)->concurrent_minsyncdelay, FALSE, SCIP_DEFAULT_CONCURRENT_MINSYNCDELAY, 0.0, SCIP_REAL_MAX, 2628 NULL, NULL) ); 2629 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 2630 "concurrent/sync/nbestsols", 2631 "how many of the N best solutions should be considered for synchronization?", 2632 &(*set)->concurrent_nbestsols, FALSE, SCIP_DEFAULT_CONCURRENT_NBESTSOLS, 0, INT_MAX, 2633 NULL, NULL) ); 2634 SCIP_CALL( SCIPsetAddStringParam(*set, messagehdlr, blkmem, 2635 "concurrent/paramsetprefix", 2636 "path prefix for parameter setting files of concurrent solvers", 2637 &(*set)->concurrent_paramsetprefix, FALSE, SCIP_DEFAULT_CONCURRENT_PARAMSETPREFIX, 2638 NULL, NULL) ); 2639 2640 /* timing parameters */ 2641 assert(sizeof(int) == sizeof(SCIP_CLOCKTYPE)); /*lint !e506*/ 2642 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 2643 "timing/clocktype", 2644 "default clock type (1: CPU user seconds, 2: wall clock time)", 2645 (int*)&(*set)->time_clocktype, FALSE, (int)SCIP_DEFAULT_TIME_CLOCKTYPE, 1, 2, 2646 NULL, NULL) ); 2647 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2648 "timing/enabled", 2649 "is timing enabled?", 2650 &(*set)->time_enabled, FALSE, SCIP_DEFAULT_TIME_ENABLED, 2651 NULL, NULL) ); 2652 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2653 "timing/reading", 2654 "belongs reading time to solving time?", 2655 &(*set)->time_reading, FALSE, SCIP_DEFAULT_TIME_READING, 2656 NULL, NULL) ); 2657 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2658 "timing/rareclockcheck", 2659 "should clock checks of solving time be performed less frequently (note: time limit could be exceeded slightly)", 2660 &(*set)->time_rareclockcheck, FALSE, SCIP_DEFAULT_TIME_RARECLOCKCHECK, 2661 NULL, NULL) ); 2662 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2663 "timing/statistictiming", 2664 "should timing for statistic output be performed?", 2665 &(*set)->time_statistictiming, FALSE, SCIP_DEFAULT_TIME_STATISTICTIMING, 2666 paramChgdStatistictiming, NULL) ); 2667 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2668 "timing/nlpieval", 2669 "should time for evaluation in NLP solves be measured?", 2670 &(*set)->time_nlpieval, FALSE, SCIP_DEFAULT_TIME_NLPIEVAL, 2671 NULL, NULL) ); 2672 2673 /* visualization parameters */ 2674 SCIP_CALL( SCIPsetAddStringParam(*set, messagehdlr, blkmem, 2675 "visual/vbcfilename", 2676 "name of the VBC tool output file, or - if no VBC tool output should be created", 2677 &(*set)->visual_vbcfilename, FALSE, SCIP_DEFAULT_VISUAL_VBCFILENAME, 2678 NULL, NULL) ); 2679 SCIP_CALL( SCIPsetAddStringParam(*set, messagehdlr, blkmem, 2680 "visual/bakfilename", 2681 "name of the BAK tool output file, or - if no BAK tool output should be created", 2682 &(*set)->visual_bakfilename, FALSE, SCIP_DEFAULT_VISUAL_BAKFILENAME, 2683 NULL, NULL) ); 2684 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2685 "visual/realtime", 2686 "should the real solving time be used instead of a time step counter in visualization?", 2687 &(*set)->visual_realtime, FALSE, SCIP_DEFAULT_VISUAL_REALTIME, 2688 NULL, NULL) ); 2689 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2690 "visual/dispsols", 2691 "should the node where solutions are found be visualized?", 2692 &(*set)->visual_dispsols, FALSE, SCIP_DEFAULT_VISUAL_DISPSOLS, 2693 NULL, NULL) ); 2694 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2695 "visual/displb", 2696 "should lower bound information be visualized?", 2697 &(*set)->visual_displb, FALSE, SCIP_DEFAULT_VISUAL_DISPLB, 2698 NULL, NULL) ); 2699 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2700 "visual/objextern", 2701 "should be output the external value of the objective?", 2702 &(*set)->visual_objextern, FALSE, SCIP_DEFAULT_VISUAL_OBJEXTERN, 2703 NULL, NULL) ); 2704 2705 /* Reading parameters */ 2706 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2707 "reading/initialconss", 2708 "should model constraints be marked as initial?", 2709 &(*set)->read_initialconss, FALSE, SCIP_DEFAULT_READ_INITIALCONSS, 2710 NULL, NULL) ); 2711 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2712 "reading/dynamicconss", 2713 "should model constraints be subject to aging?", 2714 &(*set)->read_dynamicconss, FALSE, SCIP_DEFAULT_READ_DYNAMICCONSS, 2715 NULL, NULL) ); 2716 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2717 "reading/dynamiccols", 2718 "should columns be added and removed dynamically to the LP?", 2719 &(*set)->read_dynamiccols, FALSE, SCIP_DEFAULT_READ_DYNAMICCOLS, 2720 NULL, NULL) ); 2721 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2722 "reading/dynamicrows", 2723 "should rows be added and removed dynamically to the LP?", 2724 &(*set)->read_dynamicrows, FALSE, SCIP_DEFAULT_READ_DYNAMICROWS, 2725 NULL, NULL) ); 2726 2727 /* Writing parameters */ 2728 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2729 "write/allconss", 2730 "should all constraints be written (including the redundant constraints)?", 2731 &(*set)->write_allconss, FALSE, SCIP_DEFAULT_WRITE_ALLCONSS, 2732 NULL, NULL) ); 2733 SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem, 2734 "write/printzeros", 2735 "should variables set to zero be printed?", 2736 &(*set)->write_printzeros, FALSE, SCIP_DEFAULT_PRINTZEROS, 2737 NULL, NULL) ); 2738 SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem, 2739 "write/genericnamesoffset", 2740 "when writing a generic problem the index for the first variable should start with?", 2741 &(*set)->write_genoffset, FALSE, SCIP_DEFAULT_WRITE_GENNAMES_OFFSET, 0, INT_MAX/2, 2742 NULL, NULL) ); 2743 2744 return SCIP_OKAY; 2745 } 2746 2747 /** frees global SCIP settings */ 2748 SCIP_RETCODE SCIPsetFree( 2749 SCIP_SET** set, /**< pointer to SCIP settings */ 2750 BMS_BLKMEM* blkmem /**< block memory */ 2751 ) 2752 { 2753 int i; 2754 2755 assert(set != NULL); 2756 2757 if( *set == NULL ) 2758 return SCIP_OKAY; 2759 2760 /* free parameter set */ 2761 SCIPparamsetFree(&(*set)->paramset, blkmem); 2762 2763 /* free file readers */ 2764 for( i = 0; i < (*set)->nreaders; ++i ) 2765 { 2766 SCIP_CALL( SCIPreaderFree(&(*set)->readers[i], *set) ); 2767 } 2768 BMSfreeMemoryArrayNull(&(*set)->readers); 2769 2770 /* free variable pricers */ 2771 for( i = 0; i < (*set)->npricers; ++i ) 2772 { 2773 SCIP_CALL( SCIPpricerFree(&(*set)->pricers[i], *set) ); 2774 } 2775 BMSfreeMemoryArrayNull(&(*set)->pricers); 2776 2777 /* free Benders' decomposition */ 2778 for( i = 0; i < (*set)->nbenders; ++i ) 2779 { 2780 SCIP_CALL( SCIPbendersFree(&(*set)->benders[i], *set) ); 2781 } 2782 BMSfreeMemoryArrayNull(&(*set)->benders); 2783 2784 /* free constraint handlers */ 2785 for( i = 0; i < (*set)->nconshdlrs; ++i ) 2786 { 2787 SCIP_CALL( SCIPconshdlrFree(&(*set)->conshdlrs[i], *set) ); 2788 } 2789 BMSfreeMemoryArrayNull(&(*set)->conshdlrs); 2790 BMSfreeMemoryArrayNull(&(*set)->conshdlrs_sepa); 2791 BMSfreeMemoryArrayNull(&(*set)->conshdlrs_enfo); 2792 BMSfreeMemoryArrayNull(&(*set)->conshdlrs_include); 2793 2794 /* free conflict handlers */ 2795 for( i = 0; i < (*set)->nconflicthdlrs; ++i ) 2796 { 2797 SCIP_CALL( SCIPconflicthdlrFree(&(*set)->conflicthdlrs[i], *set) ); 2798 } 2799 BMSfreeMemoryArrayNull(&(*set)->conflicthdlrs); 2800 2801 /* free presolvers */ 2802 for( i = 0; i < (*set)->npresols; ++i ) 2803 { 2804 SCIP_CALL( SCIPpresolFree(&(*set)->presols[i], *set) ); 2805 } 2806 BMSfreeMemoryArrayNull(&(*set)->presols); 2807 2808 /* free relaxators */ 2809 for( i = 0; i < (*set)->nrelaxs; ++i ) 2810 { 2811 SCIP_CALL( SCIPrelaxFree(&(*set)->relaxs[i], *set) ); 2812 } 2813 BMSfreeMemoryArrayNull(&(*set)->relaxs); 2814 2815 /* free separators */ 2816 for( i = 0; i < (*set)->nsepas; ++i ) 2817 { 2818 SCIP_CALL( SCIPsepaFree(&(*set)->sepas[i], *set) ); 2819 } 2820 BMSfreeMemoryArrayNull(&(*set)->sepas); 2821 2822 /* free cut selectors */ 2823 for( i = 0; i < (*set)->ncutsels; ++i) 2824 { 2825 SCIP_CALL( SCIPcutselFree(&(*set)->cutsels[i], *set) ); 2826 } 2827 BMSfreeMemoryArrayNull(&(*set)->cutsels); 2828 2829 /* free propagators */ 2830 for( i = 0; i < (*set)->nprops; ++i ) 2831 { 2832 SCIP_CALL( SCIPpropFree(&(*set)->props[i], *set) ); 2833 } 2834 BMSfreeMemoryArrayNull(&(*set)->props); 2835 BMSfreeMemoryArrayNull(&(*set)->props_presol); 2836 2837 /* free primal heuristics */ 2838 for( i = 0; i < (*set)->nheurs; ++i ) 2839 { 2840 SCIP_CALL( SCIPheurFree(&(*set)->heurs[i], *set, blkmem) ); 2841 } 2842 BMSfreeMemoryArrayNull(&(*set)->heurs); 2843 2844 /* free tree compressions */ 2845 for( i = 0; i < (*set)->ncomprs; ++i ) 2846 { 2847 SCIP_CALL( SCIPcomprFree(&(*set)->comprs[i], *set) ); 2848 } 2849 BMSfreeMemoryArrayNull(&(*set)->comprs); 2850 2851 /* free event handlers */ 2852 for( i = 0; i < (*set)->neventhdlrs; ++i ) 2853 { 2854 SCIP_CALL( SCIPeventhdlrFree(&(*set)->eventhdlrs[i], *set) ); 2855 } 2856 BMSfreeMemoryArrayNull(&(*set)->eventhdlrs); 2857 2858 /* free node selectors */ 2859 for( i = 0; i < (*set)->nnodesels; ++i ) 2860 { 2861 SCIP_CALL( SCIPnodeselFree(&(*set)->nodesels[i], *set) ); 2862 } 2863 BMSfreeMemoryArrayNull(&(*set)->nodesels); 2864 2865 /* free branching methods */ 2866 for( i = 0; i < (*set)->nbranchrules; ++i ) 2867 { 2868 SCIP_CALL( SCIPbranchruleFree(&(*set)->branchrules[i], *set) ); 2869 } 2870 BMSfreeMemoryArrayNull(&(*set)->branchrules); 2871 2872 /* free statistics tables */ 2873 for( i = 0; i < (*set)->ntables; ++i ) 2874 { 2875 SCIP_CALL( SCIPtableFree(&(*set)->tables[i], *set) ); 2876 } 2877 BMSfreeMemoryArrayNull(&(*set)->tables); 2878 2879 /* free display columns */ 2880 for( i = 0; i < (*set)->ndisps; ++i ) 2881 { 2882 SCIP_CALL( SCIPdispFree(&(*set)->disps[i], *set) ); 2883 } 2884 BMSfreeMemoryArrayNull(&(*set)->disps); 2885 2886 /* free dialogs */ 2887 BMSfreeMemoryArrayNull(&(*set)->dialogs); 2888 2889 /* free expression handlers */ 2890 for( i = 0; i < (*set)->nexprhdlrs; ++i ) 2891 { 2892 SCIP_CALL( SCIPexprhdlrFree(&(*set)->exprhdlrs[i], *set, blkmem) ); 2893 } 2894 BMSfreeMemoryArrayNull(&(*set)->exprhdlrs); 2895 (*set)->exprhdlrvar = NULL; 2896 (*set)->exprhdlrval = NULL; 2897 (*set)->exprhdlrsum = NULL; 2898 (*set)->exprhdlrproduct = NULL; 2899 (*set)->exprhdlrpow = NULL; 2900 2901 /* free NLPIs */ 2902 for( i = 0; i < (*set)->nnlpis; ++i ) 2903 { 2904 SCIP_CALL( SCIPnlpiFree(&(*set)->nlpis[i], *set) ); 2905 } 2906 BMSfreeMemoryArrayNull(&(*set)->nlpis); 2907 2908 /* free concsolvers */ 2909 SCIP_CALL( SCIPsetFreeConcsolvers(*set) ); 2910 2911 /* free concsolvers types */ 2912 for( i = 0; i < (*set)->nconcsolvertypes; ++i ) 2913 { 2914 SCIPconcsolverTypeFree(&(*set)->concsolvertypes[i]); 2915 } 2916 BMSfreeMemoryArrayNull(&(*set)->concsolvertypes); 2917 2918 /* free information on external codes */ 2919 for( i = 0; i < (*set)->nextcodes; ++i ) 2920 { 2921 BMSfreeMemoryArrayNull(&(*set)->extcodenames[i]); 2922 BMSfreeMemoryArrayNull(&(*set)->extcodedescs[i]); 2923 } 2924 BMSfreeMemoryArrayNull(&(*set)->extcodenames); 2925 BMSfreeMemoryArrayNull(&(*set)->extcodedescs); 2926 2927 /* free virtual tables of bandit algorithms */ 2928 for( i = 0; i < (*set)->nbanditvtables; ++i ) 2929 { 2930 SCIPbanditvtableFree(&(*set)->banditvtables[i]); 2931 } 2932 BMSfreeMemoryArrayNull(&(*set)->banditvtables); 2933 2934 /* free debugging data structure */ 2935 SCIP_CALL( SCIPdebugFree(*set) ); 2936 2937 BMSfreeMemory(set); 2938 2939 return SCIP_OKAY; 2940 } 2941 2942 /** returns current stage of SCIP */ 2943 SCIP_STAGE SCIPsetGetStage( 2944 SCIP_SET* set /**< global SCIP settings */ 2945 ) 2946 { 2947 assert(set != NULL); 2948 2949 return set->stage; 2950 } 2951 2952 /** creates a SCIP_Bool parameter, sets it to its default value, and adds it to the parameter set */ 2953 SCIP_RETCODE SCIPsetAddBoolParam( 2954 SCIP_SET* set, /**< global SCIP settings */ 2955 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */ 2956 BMS_BLKMEM* blkmem, /**< block memory */ 2957 const char* name, /**< name of the parameter */ 2958 const char* desc, /**< description of the parameter */ 2959 SCIP_Bool* valueptr, /**< pointer to store the current parameter value, or NULL */ 2960 SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */ 2961 SCIP_Bool defaultvalue, /**< default value of the parameter */ 2962 SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */ 2963 SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */ 2964 ) 2965 { 2966 assert(set != NULL); 2967 2968 SCIP_CALL( SCIPparamsetAddBool(set->paramset, messagehdlr, blkmem, name, desc, valueptr, isadvanced, 2969 defaultvalue, paramchgd, paramdata) ); 2970 2971 return SCIP_OKAY; 2972 } 2973 2974 /** creates an int parameter, sets it to its default value, and adds it to the parameter set */ 2975 SCIP_RETCODE SCIPsetAddIntParam( 2976 SCIP_SET* set, /**< global SCIP settings */ 2977 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */ 2978 BMS_BLKMEM* blkmem, /**< block memory */ 2979 const char* name, /**< name of the parameter */ 2980 const char* desc, /**< description of the parameter */ 2981 int* valueptr, /**< pointer to store the current parameter value, or NULL */ 2982 SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */ 2983 int defaultvalue, /**< default value of the parameter */ 2984 int minvalue, /**< minimum value for parameter */ 2985 int maxvalue, /**< maximum value for parameter */ 2986 SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */ 2987 SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */ 2988 ) 2989 { 2990 assert(set != NULL); 2991 2992 SCIP_CALL( SCIPparamsetAddInt(set->paramset, messagehdlr, blkmem, name, desc, valueptr, isadvanced, 2993 defaultvalue, minvalue, maxvalue, paramchgd, paramdata) ); 2994 2995 return SCIP_OKAY; 2996 } 2997 2998 /** creates a SCIP_Longint parameter, sets it to its default value, and adds it to the parameter set */ 2999 SCIP_RETCODE SCIPsetAddLongintParam( 3000 SCIP_SET* set, /**< global SCIP settings */ 3001 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */ 3002 BMS_BLKMEM* blkmem, /**< block memory */ 3003 const char* name, /**< name of the parameter */ 3004 const char* desc, /**< description of the parameter */ 3005 SCIP_Longint* valueptr, /**< pointer to store the current parameter value, or NULL */ 3006 SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */ 3007 SCIP_Longint defaultvalue, /**< default value of the parameter */ 3008 SCIP_Longint minvalue, /**< minimum value for parameter */ 3009 SCIP_Longint maxvalue, /**< maximum value for parameter */ 3010 SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */ 3011 SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */ 3012 ) 3013 { 3014 assert(set != NULL); 3015 3016 SCIP_CALL( SCIPparamsetAddLongint(set->paramset, messagehdlr, blkmem, name, desc, valueptr, isadvanced, 3017 defaultvalue, minvalue, maxvalue, paramchgd, paramdata) ); 3018 3019 return SCIP_OKAY; 3020 } 3021 3022 /** creates a SCIP_Real parameter, sets it to its default value, and adds it to the parameter set */ 3023 SCIP_RETCODE SCIPsetAddRealParam( 3024 SCIP_SET* set, /**< global SCIP settings */ 3025 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */ 3026 BMS_BLKMEM* blkmem, /**< block memory */ 3027 const char* name, /**< name of the parameter */ 3028 const char* desc, /**< description of the parameter */ 3029 SCIP_Real* valueptr, /**< pointer to store the current parameter value, or NULL */ 3030 SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */ 3031 SCIP_Real defaultvalue, /**< default value of the parameter */ 3032 SCIP_Real minvalue, /**< minimum value for parameter */ 3033 SCIP_Real maxvalue, /**< maximum value for parameter */ 3034 SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */ 3035 SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */ 3036 ) 3037 { 3038 assert(set != NULL); 3039 3040 SCIP_CALL( SCIPparamsetAddReal(set->paramset, messagehdlr, blkmem, name, desc, valueptr, isadvanced, 3041 defaultvalue, minvalue, maxvalue, paramchgd, paramdata) ); 3042 3043 return SCIP_OKAY; 3044 } 3045 3046 /** creates a char parameter, sets it to its default value, and adds it to the parameter set */ 3047 SCIP_RETCODE SCIPsetAddCharParam( 3048 SCIP_SET* set, /**< global SCIP settings */ 3049 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */ 3050 BMS_BLKMEM* blkmem, /**< block memory */ 3051 const char* name, /**< name of the parameter */ 3052 const char* desc, /**< description of the parameter */ 3053 char* valueptr, /**< pointer to store the current parameter value, or NULL */ 3054 SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */ 3055 char defaultvalue, /**< default value of the parameter */ 3056 const char* allowedvalues, /**< array with possible parameter values, or NULL if not restricted */ 3057 SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */ 3058 SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */ 3059 ) 3060 { 3061 assert(set != NULL); 3062 3063 SCIP_CALL( SCIPparamsetAddChar(set->paramset, messagehdlr, blkmem, name, desc, valueptr, isadvanced, 3064 defaultvalue, allowedvalues, paramchgd, paramdata) ); 3065 3066 return SCIP_OKAY; 3067 } 3068 3069 /** creates a string parameter, sets it to its default value, and adds it to the parameter set */ 3070 SCIP_RETCODE SCIPsetAddStringParam( 3071 SCIP_SET* set, /**< global SCIP settings */ 3072 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */ 3073 BMS_BLKMEM* blkmem, /**< block memory */ 3074 const char* name, /**< name of the parameter */ 3075 const char* desc, /**< description of the parameter */ 3076 char** valueptr, /**< pointer to store the current parameter value, or NULL */ 3077 SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */ 3078 const char* defaultvalue, /**< default value of the parameter */ 3079 SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */ 3080 SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */ 3081 ) 3082 { 3083 assert(set != NULL); 3084 3085 SCIP_CALL( SCIPparamsetAddString(set->paramset, messagehdlr, blkmem, name, desc, valueptr, isadvanced, 3086 defaultvalue, paramchgd, paramdata) ); 3087 3088 return SCIP_OKAY; 3089 } 3090 3091 /** gets the fixing status value of an existing parameter */ 3092 SCIP_Bool SCIPsetIsParamFixed( 3093 SCIP_SET* set, /**< global SCIP settings */ 3094 const char* name /**< name of the parameter */ 3095 ) 3096 { 3097 assert(set != NULL); 3098 3099 return SCIPparamsetIsFixed(set->paramset, name); 3100 } 3101 3102 /** returns the pointer to the SCIP parameter with the given name */ 3103 SCIP_PARAM* SCIPsetGetParam( 3104 SCIP_SET* set, /**< global SCIP settings */ 3105 const char* name /**< name of the parameter */ 3106 ) 3107 { 3108 assert(set != NULL); 3109 3110 return SCIPparamsetGetParam(set->paramset, name); 3111 } 3112 3113 /** gets the value of an existing SCIP_Bool parameter */ 3114 SCIP_RETCODE SCIPsetGetBoolParam( 3115 SCIP_SET* set, /**< global SCIP settings */ 3116 const char* name, /**< name of the parameter */ 3117 SCIP_Bool* value /**< pointer to store the parameter */ 3118 ) 3119 { 3120 assert(set != NULL); 3121 3122 SCIP_CALL( SCIPparamsetGetBool(set->paramset, name, value) ); 3123 3124 return SCIP_OKAY; 3125 } 3126 3127 /** gets the value of an existing Int parameter */ 3128 SCIP_RETCODE SCIPsetGetIntParam( 3129 SCIP_SET* set, /**< global SCIP settings */ 3130 const char* name, /**< name of the parameter */ 3131 int* value /**< pointer to store the value of the parameter */ 3132 ) 3133 { 3134 assert(set != NULL); 3135 3136 SCIP_CALL( SCIPparamsetGetInt(set->paramset, name, value) ); 3137 3138 return SCIP_OKAY; 3139 } 3140 3141 /** gets the value of an existing SCIP_Longint parameter */ 3142 SCIP_RETCODE SCIPsetGetLongintParam( 3143 SCIP_SET* set, /**< global SCIP settings */ 3144 const char* name, /**< name of the parameter */ 3145 SCIP_Longint* value /**< pointer to store the value of the parameter */ 3146 ) 3147 { 3148 assert(set != NULL); 3149 3150 SCIP_CALL( SCIPparamsetGetLongint(set->paramset, name, value) ); 3151 3152 return SCIP_OKAY; 3153 } 3154 3155 /** gets the value of an existing SCIP_Real parameter */ 3156 SCIP_RETCODE SCIPsetGetRealParam( 3157 SCIP_SET* set, /**< global SCIP settings */ 3158 const char* name, /**< name of the parameter */ 3159 SCIP_Real* value /**< pointer to store the value of the parameter */ 3160 ) 3161 { 3162 assert(set != NULL); 3163 3164 SCIP_CALL( SCIPparamsetGetReal(set->paramset, name, value) ); 3165 3166 return SCIP_OKAY; 3167 } 3168 3169 /** gets the value of an existing Char parameter */ 3170 SCIP_RETCODE SCIPsetGetCharParam( 3171 SCIP_SET* set, /**< global SCIP settings */ 3172 const char* name, /**< name of the parameter */ 3173 char* value /**< pointer to store the value of the parameter */ 3174 ) 3175 { 3176 assert(set != NULL); 3177 3178 SCIP_CALL( SCIPparamsetGetChar(set->paramset, name, value) ); 3179 3180 return SCIP_OKAY; 3181 } 3182 3183 /** gets the value of an existing String parameter */ 3184 SCIP_RETCODE SCIPsetGetStringParam( 3185 SCIP_SET* set, /**< global SCIP settings */ 3186 const char* name, /**< name of the parameter */ 3187 char** value /**< pointer to store the value of the parameter */ 3188 ) 3189 { 3190 assert(set != NULL); 3191 3192 SCIP_CALL( SCIPparamsetGetString(set->paramset, name, value) ); 3193 3194 return SCIP_OKAY; 3195 } 3196 3197 /** changes the fixing status of an existing parameter */ 3198 SCIP_RETCODE SCIPsetChgParamFixed( 3199 SCIP_SET* set, /**< global SCIP settings */ 3200 const char* name, /**< name of the parameter */ 3201 SCIP_Bool fixed /**< new fixing status of the parameter */ 3202 ) 3203 { 3204 assert(set != NULL); 3205 3206 SCIP_CALL( SCIPparamsetFix(set->paramset, name, fixed) ); 3207 3208 return SCIP_OKAY; 3209 } 3210 3211 /** changes the value of an existing SCIP_Bool parameter */ 3212 SCIP_RETCODE SCIPsetChgBoolParam( 3213 SCIP_SET* set, /**< global SCIP settings */ 3214 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */ 3215 SCIP_PARAM* param, /**< parameter */ 3216 SCIP_Bool value /**< new value of the parameter */ 3217 ) 3218 { 3219 SCIP_RETCODE retcode; 3220 3221 assert(set != NULL); 3222 3223 retcode = SCIPparamSetBool(param, set, messagehdlr, value, FALSE, TRUE); 3224 3225 if( retcode != SCIP_PARAMETERWRONGVAL ) 3226 { 3227 SCIP_CALL( retcode ); 3228 } 3229 3230 return retcode; 3231 } 3232 3233 /** changes the value of an existing SCIP_Bool parameter */ 3234 SCIP_RETCODE SCIPsetSetBoolParam( 3235 SCIP_SET* set, /**< global SCIP settings */ 3236 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */ 3237 const char* name, /**< name of the parameter */ 3238 SCIP_Bool value /**< new value of the parameter */ 3239 ) 3240 { 3241 assert(set != NULL); 3242 3243 SCIP_CALL( SCIPparamsetSetBool(set->paramset, set, messagehdlr, name, value) ); 3244 3245 return SCIP_OKAY; 3246 } 3247 3248 /** sets the default value of an existing SCIP_Bool parameter */ 3249 SCIP_RETCODE SCIPsetSetDefaultBoolParam( 3250 SCIP_SET* set, /**< global SCIP settings */ 3251 const char* name, /**< name of the parameter */ 3252 SCIP_Bool defaultvalue /**< new default value of the parameter */ 3253 ) 3254 { 3255 assert(set != NULL); 3256 3257 SCIP_CALL( SCIPparamsetSetDefaultBool(set->paramset, name, defaultvalue) ); 3258 3259 return SCIP_OKAY; 3260 } 3261 3262 3263 /** changes the value of an existing Int parameter */ 3264 SCIP_RETCODE SCIPsetChgIntParam( 3265 SCIP_SET* set, /**< global SCIP settings */ 3266 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */ 3267 SCIP_PARAM* param, /**< parameter */ 3268 int value /**< new value of the parameter */ 3269 ) 3270 { 3271 SCIP_RETCODE retcode; 3272 3273 assert(set != NULL); 3274 assert(param != NULL); 3275 3276 retcode = SCIPparamSetInt(param, set, messagehdlr, value, FALSE, TRUE); 3277 3278 if( retcode != SCIP_PARAMETERWRONGVAL ) 3279 { 3280 SCIP_CALL( retcode ); 3281 } 3282 3283 return retcode; 3284 } 3285 3286 /** changes the value of an existing Int parameter */ 3287 SCIP_RETCODE SCIPsetSetIntParam( 3288 SCIP_SET* set, /**< global SCIP settings */ 3289 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */ 3290 const char* name, /**< name of the parameter */ 3291 int value /**< new value of the parameter */ 3292 ) 3293 { 3294 assert(set != NULL); 3295 3296 SCIP_CALL( SCIPparamsetSetInt(set->paramset, set, messagehdlr, name, value) ); 3297 3298 return SCIP_OKAY; 3299 } 3300 3301 /** changes the default value of an existing Int parameter */ 3302 SCIP_RETCODE SCIPsetSetDefaultIntParam( 3303 SCIP_SET* set, /**< global SCIP settings */ 3304 const char* name, /**< name of the parameter */ 3305 int defaultvalue /**< new default value of the parameter */ 3306 ) 3307 { 3308 assert(set != NULL); 3309 3310 SCIP_CALL( SCIPparamsetSetDefaultInt(set->paramset, name, defaultvalue) ); 3311 3312 return SCIP_OKAY; 3313 } 3314 3315 /** changes the value of an existing SCIP_Longint parameter */ 3316 SCIP_RETCODE SCIPsetChgLongintParam( 3317 SCIP_SET* set, /**< global SCIP settings */ 3318 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */ 3319 SCIP_PARAM* param, /**< parameter */ 3320 SCIP_Longint value /**< new value of the parameter */ 3321 ) 3322 { 3323 SCIP_RETCODE retcode; 3324 3325 assert(set != NULL); 3326 assert(param != NULL); 3327 3328 retcode = SCIPparamSetLongint(param, set, messagehdlr, value, FALSE, TRUE); 3329 3330 if( retcode != SCIP_PARAMETERWRONGVAL ) 3331 { 3332 SCIP_CALL( retcode ); 3333 } 3334 3335 return retcode; 3336 } 3337 3338 /** changes the value of an existing SCIP_Longint parameter */ 3339 SCIP_RETCODE SCIPsetSetLongintParam( 3340 SCIP_SET* set, /**< global SCIP settings */ 3341 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */ 3342 const char* name, /**< name of the parameter */ 3343 SCIP_Longint value /**< new value of the parameter */ 3344 ) 3345 { 3346 assert(set != NULL); 3347 3348 SCIP_CALL( SCIPparamsetSetLongint(set->paramset, set, messagehdlr, name, value) ); 3349 3350 return SCIP_OKAY; 3351 } 3352 3353 /** changes the value of an existing SCIP_Real parameter */ 3354 SCIP_RETCODE SCIPsetChgRealParam( 3355 SCIP_SET* set, /**< global SCIP settings */ 3356 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */ 3357 SCIP_PARAM* param, /**< parameter */ 3358 SCIP_Real value /**< new value of the parameter */ 3359 ) 3360 { 3361 SCIP_RETCODE retcode; 3362 3363 assert(set != NULL); 3364 assert(param != NULL); 3365 3366 retcode = SCIPparamSetReal(param, set, messagehdlr, value, FALSE, TRUE); 3367 3368 if( retcode != SCIP_PARAMETERWRONGVAL ) 3369 { 3370 SCIP_CALL( retcode ); 3371 } 3372 3373 return retcode; 3374 } 3375 3376 /** changes the value of an existing SCIP_Real parameter */ 3377 SCIP_RETCODE SCIPsetSetRealParam( 3378 SCIP_SET* set, /**< global SCIP settings */ 3379 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */ 3380 const char* name, /**< name of the parameter */ 3381 SCIP_Real value /**< new value of the parameter */ 3382 ) 3383 { 3384 assert(set != NULL); 3385 3386 SCIP_CALL( SCIPparamsetSetReal(set->paramset, set, messagehdlr, name, value) ); 3387 3388 return SCIP_OKAY; 3389 } 3390 3391 /** changes the value of an existing Char parameter */ 3392 SCIP_RETCODE SCIPsetChgCharParam( 3393 SCIP_SET* set, /**< global SCIP settings */ 3394 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */ 3395 SCIP_PARAM* param, /**< parameter */ 3396 char value /**< new value of the parameter */ 3397 ) 3398 { 3399 SCIP_RETCODE retcode; 3400 3401 assert(set != NULL); 3402 assert(param != NULL); 3403 3404 retcode = SCIPparamSetChar(param, set, messagehdlr, value, FALSE, TRUE); 3405 3406 if( retcode != SCIP_PARAMETERWRONGVAL ) 3407 { 3408 SCIP_CALL( retcode ); 3409 } 3410 3411 return retcode; 3412 } 3413 3414 /** changes the value of an existing Char parameter */ 3415 SCIP_RETCODE SCIPsetSetCharParam( 3416 SCIP_SET* set, /**< global SCIP settings */ 3417 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */ 3418 const char* name, /**< name of the parameter */ 3419 char value /**< new value of the parameter */ 3420 ) 3421 { 3422 assert(set != NULL); 3423 3424 SCIP_CALL( SCIPparamsetSetChar(set->paramset, set, messagehdlr, name, value) ); 3425 3426 return SCIP_OKAY; 3427 } 3428 3429 /** changes the value of an existing String parameter */ 3430 SCIP_RETCODE SCIPsetChgStringParam( 3431 SCIP_SET* set, /**< global SCIP settings */ 3432 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */ 3433 SCIP_PARAM* param, /**< parameter */ 3434 const char* value /**< new value of the parameter */ 3435 ) 3436 { 3437 SCIP_RETCODE retcode; 3438 3439 assert(set != NULL); 3440 assert(param != NULL); 3441 3442 retcode = SCIPparamSetString(param, set, messagehdlr, value, FALSE, TRUE); 3443 3444 if( retcode != SCIP_PARAMETERWRONGVAL ) 3445 { 3446 SCIP_CALL( retcode ); 3447 } 3448 3449 return retcode; 3450 } 3451 3452 /** changes the value of an existing String parameter */ 3453 SCIP_RETCODE SCIPsetSetStringParam( 3454 SCIP_SET* set, /**< global SCIP settings */ 3455 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */ 3456 const char* name, /**< name of the parameter */ 3457 const char* value /**< new value of the parameter */ 3458 ) 3459 { 3460 assert(set != NULL); 3461 3462 SCIP_CALL( SCIPparamsetSetString(set->paramset, set, messagehdlr, name, value) ); 3463 3464 return SCIP_OKAY; 3465 } 3466 3467 /** changes the value of an existing parameter */ 3468 SCIP_RETCODE SCIPsetSetParam( 3469 SCIP_SET* set, /**< global SCIP settings */ 3470 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */ 3471 const char* name, /**< name of the parameter */ 3472 const char* value /**< new value of the parameter as string */ 3473 ) 3474 { 3475 assert(set != NULL); 3476 3477 SCIP_CALL( SCIPparamsetSet(set->paramset, set, messagehdlr, name, value, FALSE) ); 3478 3479 return SCIP_OKAY; 3480 } 3481 3482 /** reads parameters from a file */ 3483 SCIP_RETCODE SCIPsetReadParams( 3484 SCIP_SET* set, /**< global SCIP settings */ 3485 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */ 3486 const char* filename /**< file name */ 3487 ) 3488 { 3489 assert(set != NULL); 3490 3491 SCIP_CALL( SCIPparamsetRead(set->paramset, set, messagehdlr, filename) ); 3492 3493 return SCIP_OKAY; 3494 } 3495 3496 /** writes all parameters in the parameter set to a file */ 3497 SCIP_RETCODE SCIPsetWriteParams( 3498 SCIP_SET* set, /**< global SCIP settings */ 3499 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */ 3500 const char* filename, /**< file name, or NULL for stdout */ 3501 SCIP_Bool comments, /**< should parameter descriptions be written as comments? */ 3502 SCIP_Bool onlychanged /**< should only the parameters been written, that are changed from default? */ 3503 ) 3504 { 3505 assert(set != NULL); 3506 3507 SCIP_CALL( SCIPparamsetWrite(set->paramset, messagehdlr, filename, comments, onlychanged) ); 3508 3509 return SCIP_OKAY; 3510 } 3511 3512 /** resets a single parameters to its default value */ 3513 SCIP_RETCODE SCIPsetResetParam( 3514 SCIP_SET* set, /**< global SCIP settings */ 3515 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */ 3516 const char* name /**< name of the parameter */ 3517 ) 3518 { 3519 SCIP_CALL( SCIPparamsetSetToDefault(set->paramset, set, messagehdlr, name) ); 3520 3521 return SCIP_OKAY; 3522 } 3523 3524 /** resets all parameters to their default values */ 3525 SCIP_RETCODE SCIPsetResetParams( 3526 SCIP_SET* set, /**< global SCIP settings */ 3527 SCIP_MESSAGEHDLR* messagehdlr /**< message handler */ 3528 ) 3529 { 3530 SCIP_CALL( SCIPparamsetSetToDefaults(set->paramset, set, messagehdlr) ); 3531 3532 return SCIP_OKAY; 3533 } 3534 3535 /** sets parameters to 3536 * 3537 * - \ref SCIP_PARAMEMPHASIS_DEFAULT to use default values (see also SCIPsetResetParams()) 3538 * - \ref SCIP_PARAMEMPHASIS_COUNTER to get feasible and "fast" counting process 3539 * - \ref SCIP_PARAMEMPHASIS_CPSOLVER to get CP like search (e.g. no LP relaxation) 3540 * - \ref SCIP_PARAMEMPHASIS_EASYCIP to solve easy problems fast 3541 * - \ref SCIP_PARAMEMPHASIS_FEASIBILITY to detect feasibility fast 3542 * - \ref SCIP_PARAMEMPHASIS_HARDLP to be capable to handle hard LPs 3543 * - \ref SCIP_PARAMEMPHASIS_OPTIMALITY to prove optimality fast 3544 * - \ref SCIP_PARAMEMPHASIS_PHASEFEAS to find feasible solutions during a 3 phase solution process 3545 * - \ref SCIP_PARAMEMPHASIS_PHASEIMPROVE to find improved solutions during a 3 phase solution process 3546 * - \ref SCIP_PARAMEMPHASIS_PHASEPROOF to proof optimality during a 3 phase solution process 3547 */ 3548 SCIP_RETCODE SCIPsetSetEmphasis( 3549 SCIP_SET* set, /**< global SCIP settings */ 3550 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */ 3551 SCIP_PARAMEMPHASIS paramemphasis, /**< parameter settings */ 3552 SCIP_Bool quiet /**< should the parameter be set quiet (no output) */ 3553 ) 3554 { 3555 SCIP_CALL( SCIPparamsetSetEmphasis(set->paramset, set, messagehdlr, paramemphasis, quiet) ); 3556 3557 return SCIP_OKAY; 3558 } 3559 3560 /** sets parameters to deactivate separators and heuristics that use auxiliary SCIP instances; should be called for 3561 * auxiliary SCIP instances to avoid recursion 3562 */ 3563 SCIP_RETCODE SCIPsetSetSubscipsOff( 3564 SCIP_SET* set, /**< global SCIP settings */ 3565 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */ 3566 SCIP_Bool quiet /**< should the parameter be set quiet (no output) */ 3567 ) 3568 { 3569 SCIP_CALL( SCIPparamsetSetToSubscipsOff(set->paramset, set, messagehdlr, quiet) ); 3570 3571 return SCIP_OKAY; 3572 } 3573 3574 /** sets heuristic parameters values to 3575 * - SCIP_PARAMSETTING_DEFAULT which are the default values of all heuristic parameters 3576 * - SCIP_PARAMSETTING_FAST such that the time spent on heuristics is decreased 3577 * - SCIP_PARAMSETTING_AGGRESSIVE such that the heuristics are called more aggressively 3578 * - SCIP_PARAMSETTING_OFF which turn off all heuristics 3579 */ 3580 SCIP_RETCODE SCIPsetSetHeuristics( 3581 SCIP_SET* set, /**< global SCIP settings */ 3582 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */ 3583 SCIP_PARAMSETTING paramsetting, /**< parameter settings */ 3584 SCIP_Bool quiet /**< should the parameter be set quiet (no output) */ 3585 ) 3586 { 3587 SCIP_CALL( SCIPparamsetSetHeuristics(set->paramset, set, messagehdlr, paramsetting, quiet) ); 3588 3589 return SCIP_OKAY; 3590 } 3591 3592 /** sets presolving parameters to 3593 * - SCIP_PARAMSETTING_DEFAULT which are the default values of all presolving parameters 3594 * - SCIP_PARAMSETTING_FAST such that the time spent on presolving is decreased 3595 * - SCIP_PARAMSETTING_AGGRESSIVE such that the presolving is more aggressive 3596 * - SCIP_PARAMSETTING_OFF which turn off all presolving 3597 */ 3598 SCIP_RETCODE SCIPsetSetPresolving( 3599 SCIP_SET* set, /**< global SCIP settings */ 3600 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */ 3601 SCIP_PARAMSETTING paramsetting, /**< parameter settings */ 3602 SCIP_Bool quiet /**< should the parameter be set quiet (no output) */ 3603 ) 3604 { 3605 SCIP_CALL( SCIPparamsetSetPresolving(set->paramset, set, messagehdlr, paramsetting, quiet) ); 3606 3607 return SCIP_OKAY; 3608 } 3609 3610 /** sets separating parameters to 3611 * - SCIP_PARAMSETTING_DEFAULT which are the default values of all separating parameters 3612 * - SCIP_PARAMSETTING_FAST such that the time spent on separating is decreased 3613 * - SCIP_PARAMSETTING_AGGRESSIVE such that separating is more aggressive 3614 * - SCIP_PARAMSETTING_OFF which turn off all separating 3615 */ 3616 SCIP_RETCODE SCIPsetSetSeparating( 3617 SCIP_SET* set, /**< global SCIP settings */ 3618 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */ 3619 SCIP_PARAMSETTING paramsetting, /**< parameter settings */ 3620 SCIP_Bool quiet /**< should the parameter be set quiet (no output) */ 3621 ) 3622 { 3623 SCIP_CALL( SCIPparamsetSetSeparating(set->paramset, set, messagehdlr, paramsetting, quiet) ); 3624 3625 return SCIP_OKAY; 3626 } 3627 3628 /** returns the array of all available SCIP parameters */ 3629 SCIP_PARAM** SCIPsetGetParams( 3630 SCIP_SET* set /**< global SCIP settings */ 3631 ) 3632 { 3633 assert(set != NULL); 3634 3635 return SCIPparamsetGetParams(set->paramset); 3636 } 3637 3638 /** returns the total number of all available SCIP parameters */ 3639 int SCIPsetGetNParams( 3640 SCIP_SET* set /**< global SCIP settings */ 3641 ) 3642 { 3643 assert(set != NULL); 3644 3645 return SCIPparamsetGetNParams(set->paramset); 3646 } 3647 3648 /** inserts file reader in file reader list */ 3649 SCIP_RETCODE SCIPsetIncludeReader( 3650 SCIP_SET* set, /**< global SCIP settings */ 3651 SCIP_READER* reader /**< file reader */ 3652 ) 3653 { 3654 assert(set != NULL); 3655 assert(reader != NULL); 3656 3657 if( set->nreaders >= set->readerssize ) 3658 { 3659 set->readerssize = SCIPsetCalcMemGrowSize(set, set->nreaders+1); 3660 SCIP_ALLOC( BMSreallocMemoryArray(&set->readers, set->readerssize) ); 3661 } 3662 assert(set->nreaders < set->readerssize); 3663 3664 set->readers[set->nreaders] = reader; 3665 set->nreaders++; 3666 3667 return SCIP_OKAY; 3668 } 3669 3670 /** returns the file reader of the given name, or NULL if not existing */ 3671 SCIP_READER* SCIPsetFindReader( 3672 SCIP_SET* set, /**< global SCIP settings */ 3673 const char* name /**< name of file reader */ 3674 ) 3675 { 3676 int i; 3677 3678 assert(set != NULL); 3679 assert(name != NULL); 3680 3681 for( i = 0; i < set->nreaders; ++i ) 3682 { 3683 if( strcmp(SCIPreaderGetName(set->readers[i]), name) == 0 ) 3684 return set->readers[i]; 3685 } 3686 3687 return NULL; 3688 } 3689 3690 /** inserts variable pricer in variable pricer list */ 3691 SCIP_RETCODE SCIPsetIncludePricer( 3692 SCIP_SET* set, /**< global SCIP settings */ 3693 SCIP_PRICER* pricer /**< variable pricer */ 3694 ) 3695 { 3696 assert(set != NULL); 3697 assert(pricer != NULL); 3698 3699 if( set->npricers >= set->pricerssize ) 3700 { 3701 set->pricerssize = SCIPsetCalcMemGrowSize(set, set->npricers+1); 3702 SCIP_ALLOC( BMSreallocMemoryArray(&set->pricers, set->pricerssize) ); 3703 } 3704 assert(set->npricers < set->pricerssize); 3705 3706 set->pricers[set->npricers] = pricer; 3707 set->npricers++; 3708 set->pricerssorted = FALSE; 3709 3710 return SCIP_OKAY; 3711 } 3712 3713 /** returns the variable pricer of the given name, or NULL if not existing */ 3714 SCIP_PRICER* SCIPsetFindPricer( 3715 SCIP_SET* set, /**< global SCIP settings */ 3716 const char* name /**< name of variable pricer */ 3717 ) 3718 { 3719 int i; 3720 3721 assert(set != NULL); 3722 assert(name != NULL); 3723 3724 for( i = 0; i < set->npricers; ++i ) 3725 { 3726 if( strcmp(SCIPpricerGetName(set->pricers[i]), name) == 0 ) 3727 return set->pricers[i]; 3728 } 3729 3730 return NULL; 3731 } 3732 3733 /** sorts pricers by priorities */ 3734 void SCIPsetSortPricers( 3735 SCIP_SET* set /**< global SCIP settings */ 3736 ) 3737 { 3738 assert(set != NULL); 3739 3740 if( !set->pricerssorted ) 3741 { 3742 SCIPsortPtr((void**)set->pricers, SCIPpricerComp, set->npricers); 3743 set->pricerssorted = TRUE; 3744 set->pricersnamesorted = FALSE; 3745 } 3746 } 3747 3748 /** sorts pricers by name */ 3749 void SCIPsetSortPricersName( 3750 SCIP_SET* set /**< global SCIP settings */ 3751 ) 3752 { 3753 assert(set != NULL); 3754 3755 if( !set->pricersnamesorted ) 3756 { 3757 SCIPsortPtr((void**)set->pricers, SCIPpricerCompName, set->npricers); 3758 set->pricerssorted = FALSE; 3759 set->pricersnamesorted = TRUE; 3760 } 3761 } 3762 3763 /** inserts Benders' decomposition in the Benders' decomposition list */ 3764 SCIP_RETCODE SCIPsetIncludeBenders( 3765 SCIP_SET* set, /**< global SCIP settings */ 3766 SCIP_BENDERS* benders /**< Benders' decomposition structure */ 3767 ) 3768 { 3769 assert(set != NULL); 3770 assert(benders != NULL); 3771 3772 if( set->nbenders >= set->benderssize ) 3773 { 3774 set->benderssize = SCIPsetCalcMemGrowSize(set, set->nbenders+1); 3775 SCIP_ALLOC( BMSreallocMemoryArray(&set->benders, set->benderssize) ); 3776 } 3777 assert(set->nbenders < set->benderssize); 3778 3779 set->benders[set->nbenders] = benders; 3780 set->nbenders++; 3781 set->benderssorted = FALSE; 3782 3783 return SCIP_OKAY; 3784 } 3785 3786 /** returns the Benders' decomposition of the given name, or NULL if not existing */ 3787 SCIP_BENDERS* SCIPsetFindBenders( 3788 SCIP_SET* set, /**< global SCIP settings */ 3789 const char* name /**< name of the Benders' decomposition */ 3790 ) 3791 { 3792 int i; 3793 3794 assert(set != NULL); 3795 assert(name != NULL); 3796 3797 for( i = 0; i < set->nbenders; ++i ) 3798 { 3799 if( strcmp(SCIPbendersGetName(set->benders[i]), name) == 0 ) 3800 return set->benders[i]; 3801 } 3802 3803 return NULL; 3804 } 3805 3806 /** sorts Benders' decomposition by priorities */ 3807 void SCIPsetSortBenders( 3808 SCIP_SET* set /**< global SCIP settings */ 3809 ) 3810 { 3811 assert(set != NULL); 3812 3813 if( !set->benderssorted ) 3814 { 3815 SCIPsortPtr((void**)set->benders, SCIPbendersComp, set->nbenders); 3816 set->benderssorted = TRUE; 3817 set->bendersnamesorted = FALSE; 3818 } 3819 } 3820 3821 /** sorts Benders' decomposition by name */ 3822 void SCIPsetSortBendersName( 3823 SCIP_SET* set /**< global SCIP settings */ 3824 ) 3825 { 3826 assert(set != NULL); 3827 3828 if( !set->bendersnamesorted ) 3829 { 3830 SCIPsortPtr((void**)set->benders, SCIPbendersCompName, set->nbenders); 3831 set->benderssorted = FALSE; 3832 set->bendersnamesorted = TRUE; 3833 } 3834 } 3835 3836 /** inserts constraint handler in constraint handler list */ 3837 SCIP_RETCODE SCIPsetIncludeConshdlr( 3838 SCIP_SET* set, /**< global SCIP settings */ 3839 SCIP_CONSHDLR* conshdlr /**< constraint handler */ 3840 ) 3841 { 3842 int priority; 3843 int i; 3844 3845 assert(set != NULL); 3846 assert(conshdlr != NULL); 3847 assert(!SCIPconshdlrIsInitialized(conshdlr)); 3848 3849 /* allocate memory */ 3850 if( set->nconshdlrs >= set->conshdlrssize ) 3851 { 3852 set->conshdlrssize = SCIPsetCalcMemGrowSize(set, set->nconshdlrs+1); 3853 SCIP_ALLOC( BMSreallocMemoryArray(&set->conshdlrs, set->conshdlrssize) ); 3854 SCIP_ALLOC( BMSreallocMemoryArray(&set->conshdlrs_sepa, set->conshdlrssize) ); 3855 SCIP_ALLOC( BMSreallocMemoryArray(&set->conshdlrs_enfo, set->conshdlrssize) ); 3856 SCIP_ALLOC( BMSreallocMemoryArray(&set->conshdlrs_include, set->conshdlrssize) ); 3857 } 3858 assert(set->nconshdlrs < set->conshdlrssize); 3859 3860 /* sort constraint handler into conshdlrs array sorted by check priority */ 3861 priority = SCIPconshdlrGetCheckPriority(conshdlr); 3862 for( i = set->nconshdlrs; i > 0 && SCIPconshdlrGetCheckPriority(set->conshdlrs[i-1]) < priority; --i ) 3863 { 3864 set->conshdlrs[i] = set->conshdlrs[i-1]; 3865 } 3866 set->conshdlrs[i] = conshdlr; 3867 3868 /* sort constraint handler into conshdlrs_sepa array sorted by sepa priority */ 3869 priority = SCIPconshdlrGetSepaPriority(conshdlr); 3870 for( i = set->nconshdlrs; i > 0 && SCIPconshdlrGetSepaPriority(set->conshdlrs_sepa[i-1]) < priority; --i ) 3871 { 3872 set->conshdlrs_sepa[i] = set->conshdlrs_sepa[i-1]; 3873 } 3874 set->conshdlrs_sepa[i] = conshdlr; 3875 3876 /* sort constraint handler into conshdlrs_enfo array sorted by enfo priority */ 3877 priority = SCIPconshdlrGetEnfoPriority(conshdlr); 3878 for( i = set->nconshdlrs; i > 0 && SCIPconshdlrGetEnfoPriority(set->conshdlrs_enfo[i-1]) < priority; --i ) 3879 { 3880 set->conshdlrs_enfo[i] = set->conshdlrs_enfo[i-1]; 3881 } 3882 set->conshdlrs_enfo[i] = conshdlr; 3883 3884 /* add constraint handler into conshdlrs_include array sorted by inclusion order */ 3885 set->conshdlrs_include[set->nconshdlrs] = conshdlr; 3886 3887 set->nconshdlrs++; 3888 3889 return SCIP_OKAY; 3890 } 3891 3892 /** reinserts a constraint handler with modified sepa priority into the sepa priority sorted array */ 3893 void SCIPsetReinsertConshdlrSepaPrio( 3894 SCIP_SET* set, /**< global SCIP settings */ 3895 SCIP_CONSHDLR* conshdlr, /**< constraint handler to be reinserted */ 3896 int oldpriority /**< the old separation priority of constraint handler */ 3897 ) 3898 { 3899 int newpriority; 3900 int newpos; 3901 int i; 3902 assert(set != NULL); 3903 assert(conshdlr != NULL); 3904 3905 newpriority = SCIPconshdlrGetSepaPriority(conshdlr); 3906 newpos = -1; 3907 3908 /* search for the old position of constraint handler; determine its new position at the same time */ 3909 if( newpriority > oldpriority ) 3910 { 3911 i = 0; 3912 while( i < set->nconshdlrs && 3913 strcmp(SCIPconshdlrGetName(set->conshdlrs_sepa[i]), SCIPconshdlrGetName(conshdlr)) != 0 ) 3914 { 3915 int priorityatpos; 3916 3917 priorityatpos = SCIPconshdlrGetSepaPriority(set->conshdlrs_sepa[i]); 3918 assert(priorityatpos >= oldpriority); 3919 3920 /* current index is the position to insert the constraint handler */ 3921 if( newpriority > priorityatpos && newpos == -1 ) 3922 newpos = i; 3923 3924 ++i; 3925 } 3926 assert(i < set->nconshdlrs); 3927 3928 /* constraint must change its position in array */ 3929 if( newpos != -1 ) 3930 { 3931 /* shift all constraint handlers between old and new position by one, and insert constraint handler */ 3932 for( ; i > newpos; --i ) 3933 { 3934 set->conshdlrs_sepa[i] = set->conshdlrs_sepa[i-1]; 3935 } 3936 set->conshdlrs_sepa[newpos] = conshdlr; 3937 } 3938 } 3939 else if( newpriority < oldpriority ) 3940 { 3941 i = set->nconshdlrs - 1; 3942 while( i >= 0 && strcmp(SCIPconshdlrGetName(set->conshdlrs_sepa[i]), SCIPconshdlrGetName(conshdlr)) != 0 ) 3943 { 3944 int priorityatpos; 3945 3946 priorityatpos = SCIPconshdlrGetSepaPriority(set->conshdlrs_sepa[i]); 3947 assert(priorityatpos <= oldpriority); 3948 3949 /* current index is the position to insert the constraint handler */ 3950 if( newpriority < priorityatpos && newpos == -1 ) 3951 newpos = i; 3952 3953 --i; 3954 } 3955 assert(i >= 0); 3956 3957 /* constraint must change its position in array */ 3958 if( newpos != -1 ) 3959 { 3960 /* shift all constraint handlers between old and new position by one, and insert constraint handler */ 3961 for(; i < newpos; ++i ) 3962 { 3963 set->conshdlrs_sepa[i] = set->conshdlrs_sepa[i + 1]; 3964 } 3965 set->conshdlrs_sepa[newpos] = conshdlr; 3966 } 3967 #ifndef NDEBUG 3968 for( i = 0; i < set->nconshdlrs - 1; ++i ) 3969 assert(SCIPconshdlrGetSepaPriority(set->conshdlrs_sepa[i]) 3970 >= SCIPconshdlrGetSepaPriority(set->conshdlrs_sepa[i + 1])); 3971 #endif 3972 } 3973 } 3974 3975 /** returns the constraint handler of the given name, or NULL if not existing */ 3976 SCIP_CONSHDLR* SCIPsetFindConshdlr( 3977 SCIP_SET* set, /**< global SCIP settings */ 3978 const char* name /**< name of constraint handler */ 3979 ) 3980 { 3981 int i; 3982 3983 assert(set != NULL); 3984 assert(name != NULL); 3985 3986 for( i = 0; i < set->nconshdlrs; ++i ) 3987 { 3988 if( strcmp(SCIPconshdlrGetName(set->conshdlrs[i]), name) == 0 ) 3989 return set->conshdlrs[i]; 3990 } 3991 3992 return NULL; 3993 } 3994 3995 /** inserts conflict handler in conflict handler list */ 3996 SCIP_RETCODE SCIPsetIncludeConflicthdlr( 3997 SCIP_SET* set, /**< global SCIP settings */ 3998 SCIP_CONFLICTHDLR* conflicthdlr /**< conflict handler */ 3999 ) 4000 { 4001 assert(set != NULL); 4002 assert(conflicthdlr != NULL); 4003 assert(!SCIPconflicthdlrIsInitialized(conflicthdlr)); 4004 4005 if( set->nconflicthdlrs >= set->conflicthdlrssize ) 4006 { 4007 set->conflicthdlrssize = SCIPsetCalcMemGrowSize(set, set->nconflicthdlrs+1); 4008 SCIP_ALLOC( BMSreallocMemoryArray(&set->conflicthdlrs, set->conflicthdlrssize) ); 4009 } 4010 assert(set->nconflicthdlrs < set->conflicthdlrssize); 4011 4012 set->conflicthdlrs[set->nconflicthdlrs] = conflicthdlr; 4013 set->nconflicthdlrs++; 4014 set->conflicthdlrssorted = FALSE; 4015 4016 return SCIP_OKAY; 4017 } 4018 4019 /** returns the conflict handler of the given name, or NULL if not existing */ 4020 SCIP_CONFLICTHDLR* SCIPsetFindConflicthdlr( 4021 SCIP_SET* set, /**< global SCIP settings */ 4022 const char* name /**< name of conflict handler */ 4023 ) 4024 { 4025 int i; 4026 4027 assert(set != NULL); 4028 assert(name != NULL); 4029 4030 for( i = 0; i < set->nconflicthdlrs; ++i ) 4031 { 4032 if( strcmp(SCIPconflicthdlrGetName(set->conflicthdlrs[i]), name) == 0 ) 4033 return set->conflicthdlrs[i]; 4034 } 4035 4036 return NULL; 4037 } 4038 4039 /** sorts conflict handlers by priorities */ 4040 void SCIPsetSortConflicthdlrs( 4041 SCIP_SET* set /**< global SCIP settings */ 4042 ) 4043 { 4044 assert(set != NULL); 4045 4046 if( !set->conflicthdlrssorted ) 4047 { 4048 SCIPsortPtr((void**)set->conflicthdlrs, SCIPconflicthdlrComp, set->nconflicthdlrs); 4049 set->conflicthdlrssorted = TRUE; 4050 set->conflicthdlrsnamesorted = FALSE; 4051 } 4052 } 4053 4054 /** sorts conflict handlers by name */ 4055 void SCIPsetSortConflicthdlrsName( 4056 SCIP_SET* set /**< global SCIP settings */ 4057 ) 4058 { 4059 assert(set != NULL); 4060 4061 if( !set->conflicthdlrsnamesorted ) 4062 { 4063 SCIPsortPtr((void**)set->conflicthdlrs, SCIPconflicthdlrCompName, set->nconflicthdlrs); 4064 set->conflicthdlrssorted = FALSE; 4065 set->conflicthdlrsnamesorted = TRUE; 4066 } 4067 } 4068 4069 /** inserts presolver in presolver list */ 4070 SCIP_RETCODE SCIPsetIncludePresol( 4071 SCIP_SET* set, /**< global SCIP settings */ 4072 SCIP_PRESOL* presol /**< presolver */ 4073 ) 4074 { 4075 assert(set != NULL); 4076 assert(presol != NULL); 4077 4078 if( set->npresols >= set->presolssize ) 4079 { 4080 set->presolssize = SCIPsetCalcMemGrowSize(set, set->npresols+1); 4081 SCIP_ALLOC( BMSreallocMemoryArray(&set->presols, set->presolssize) ); 4082 } 4083 assert(set->npresols < set->presolssize); 4084 4085 set->presols[set->npresols] = presol; 4086 set->npresols++; 4087 set->presolssorted = FALSE; 4088 4089 return SCIP_OKAY; 4090 } 4091 4092 /** returns the presolver of the given name, or NULL if not existing */ 4093 SCIP_PRESOL* SCIPsetFindPresol( 4094 SCIP_SET* set, /**< global SCIP settings */ 4095 const char* name /**< name of presolver */ 4096 ) 4097 { 4098 int i; 4099 4100 assert(set != NULL); 4101 assert(name != NULL); 4102 4103 for( i = 0; i < set->npresols; ++i ) 4104 { 4105 if( strcmp(SCIPpresolGetName(set->presols[i]), name) == 0 ) 4106 return set->presols[i]; 4107 } 4108 4109 return NULL; 4110 } 4111 4112 /** sorts presolvers by priorities */ 4113 void SCIPsetSortPresols( 4114 SCIP_SET* set /**< global SCIP settings */ 4115 ) 4116 { 4117 assert(set != NULL); 4118 4119 if( !set->presolssorted ) 4120 { 4121 SCIPsortPtr((void**)set->presols, SCIPpresolComp, set->npresols); 4122 set->presolssorted = TRUE; 4123 set->presolsnamesorted = FALSE; 4124 } 4125 } 4126 4127 /** sorts presolvers by name */ 4128 void SCIPsetSortPresolsName( 4129 SCIP_SET* set /**< global SCIP settings */ 4130 ) 4131 { 4132 assert(set != NULL); 4133 4134 if( !set->presolsnamesorted ) 4135 { 4136 SCIPsortPtr((void**)set->presols, SCIPpresolCompName, set->npresols); 4137 set->presolssorted = FALSE; 4138 set->presolsnamesorted = TRUE; 4139 } 4140 } 4141 4142 /** inserts relaxator in relaxator list */ 4143 SCIP_RETCODE SCIPsetIncludeRelax( 4144 SCIP_SET* set, /**< global SCIP settings */ 4145 SCIP_RELAX* relax /**< relaxator */ 4146 ) 4147 { 4148 assert(set != NULL); 4149 assert(relax != NULL); 4150 assert(!SCIPrelaxIsInitialized(relax)); 4151 4152 if( set->nrelaxs >= set->relaxssize ) 4153 { 4154 set->relaxssize = SCIPsetCalcMemGrowSize(set, set->nrelaxs+1); 4155 SCIP_ALLOC( BMSreallocMemoryArray(&set->relaxs, set->relaxssize) ); 4156 } 4157 assert(set->nrelaxs < set->relaxssize); 4158 4159 set->relaxs[set->nrelaxs] = relax; 4160 set->nrelaxs++; 4161 set->relaxssorted = FALSE; 4162 4163 return SCIP_OKAY; 4164 } 4165 4166 /** returns the relaxator of the given name, or NULL if not existing */ 4167 SCIP_RELAX* SCIPsetFindRelax( 4168 SCIP_SET* set, /**< global SCIP settings */ 4169 const char* name /**< name of relaxator */ 4170 ) 4171 { 4172 int i; 4173 4174 assert(set != NULL); 4175 assert(name != NULL); 4176 4177 for( i = 0; i < set->nrelaxs; ++i ) 4178 { 4179 if( strcmp(SCIPrelaxGetName(set->relaxs[i]), name) == 0 ) 4180 return set->relaxs[i]; 4181 } 4182 4183 return NULL; 4184 } 4185 4186 /** sorts relaxators by priorities */ 4187 void SCIPsetSortRelaxs( 4188 SCIP_SET* set /**< global SCIP settings */ 4189 ) 4190 { 4191 assert(set != NULL); 4192 4193 if( !set->relaxssorted ) 4194 { 4195 SCIPsortPtr((void**)set->relaxs, SCIPrelaxComp, set->nrelaxs); 4196 set->relaxssorted = TRUE; 4197 set->relaxsnamesorted = FALSE; 4198 } 4199 } 4200 4201 /** sorts relaxators by priorities */ 4202 void SCIPsetSortRelaxsName( 4203 SCIP_SET* set /**< global SCIP settings */ 4204 ) 4205 { 4206 assert(set != NULL); 4207 4208 if( !set->relaxsnamesorted ) 4209 { 4210 SCIPsortPtr((void**)set->relaxs, SCIPrelaxCompName, set->nrelaxs); 4211 set->relaxssorted = FALSE; 4212 set->relaxsnamesorted = TRUE; 4213 } 4214 } 4215 4216 /** inserts separator in separator list */ 4217 SCIP_RETCODE SCIPsetIncludeSepa( 4218 SCIP_SET* set, /**< global SCIP settings */ 4219 SCIP_SEPA* sepa /**< separator */ 4220 ) 4221 { 4222 assert(set != NULL); 4223 assert(sepa != NULL); 4224 assert(!SCIPsepaIsInitialized(sepa)); 4225 4226 if( set->nsepas >= set->sepassize ) 4227 { 4228 set->sepassize = SCIPsetCalcMemGrowSize(set, set->nsepas+1); 4229 SCIP_ALLOC( BMSreallocMemoryArray(&set->sepas, set->sepassize) ); 4230 } 4231 assert(set->nsepas < set->sepassize); 4232 4233 set->sepas[set->nsepas] = sepa; 4234 set->nsepas++; 4235 set->sepassorted = FALSE; 4236 4237 return SCIP_OKAY; 4238 } 4239 4240 /** returns the separator of the given name, or NULL if not existing */ 4241 SCIP_SEPA* SCIPsetFindSepa( 4242 SCIP_SET* set, /**< global SCIP settings */ 4243 const char* name /**< name of separator */ 4244 ) 4245 { 4246 int i; 4247 4248 assert(set != NULL); 4249 assert(name != NULL); 4250 4251 for( i = 0; i < set->nsepas; ++i ) 4252 { 4253 if( strcmp(SCIPsepaGetName(set->sepas[i]), name) == 0 ) 4254 return set->sepas[i]; 4255 } 4256 4257 return NULL; 4258 } 4259 4260 /** sorts separators by priorities */ 4261 void SCIPsetSortSepas( 4262 SCIP_SET* set /**< global SCIP settings */ 4263 ) 4264 { 4265 assert(set != NULL); 4266 4267 if( !set->sepassorted ) 4268 { 4269 SCIPsortPtr((void**)set->sepas, SCIPsepaComp, set->nsepas); 4270 set->sepassorted = TRUE; 4271 set->sepasnamesorted = FALSE; 4272 } 4273 } 4274 4275 /** sorts separators by name */ 4276 void SCIPsetSortSepasName( 4277 SCIP_SET* set /**< global SCIP settings */ 4278 ) 4279 { 4280 assert(set != NULL); 4281 4282 if( !set->sepasnamesorted ) 4283 { 4284 SCIPsortPtr((void**)set->sepas, SCIPsepaCompName, set->nsepas); 4285 set->sepassorted = FALSE; 4286 set->sepasnamesorted = TRUE; 4287 } 4288 } 4289 4290 /** inserts cut selector in cut selector list */ 4291 SCIP_RETCODE SCIPsetIncludeCutsel( 4292 SCIP_SET* set, /**< global SCIP settings */ 4293 SCIP_CUTSEL* cutsel /**< cut selector */ 4294 ) 4295 { 4296 assert(set != NULL); 4297 assert(cutsel != NULL); 4298 assert(!SCIPcutselIsInitialized(cutsel)); 4299 4300 if( set->ncutsels >= set->cutselssize ) 4301 { 4302 set->cutselssize = SCIPsetCalcMemGrowSize(set, set->ncutsels + 1); 4303 SCIP_ALLOC( BMSreallocMemoryArray(&set->cutsels, set->cutselssize) ); 4304 } 4305 assert(set->ncutsels < set->cutselssize); 4306 4307 set->cutsels[set->ncutsels] = cutsel; 4308 set->ncutsels++; 4309 set->cutselssorted = FALSE; 4310 4311 return SCIP_OKAY; 4312 } 4313 4314 /** returns the cut selector of the given name, or NULL if not existing */ 4315 SCIP_CUTSEL* SCIPsetFindCutsel( 4316 SCIP_SET* set, /**< global SCIP settings */ 4317 const char* name /**< name of separator */ 4318 ) 4319 { 4320 int i; 4321 4322 assert(set != NULL); 4323 assert(name != NULL); 4324 4325 for( i = 0; i < set->ncutsels; ++i ) 4326 { 4327 if( strcmp(SCIPcutselGetName(set->cutsels[i]), name) == 0 ) 4328 return set->cutsels[i]; 4329 } 4330 4331 return NULL; 4332 } 4333 4334 /** sorts cut selectors by priorities */ 4335 void SCIPsetSortCutsels( 4336 SCIP_SET* set /**< global SCIP settings */ 4337 ) 4338 { 4339 assert(set != NULL); 4340 4341 if( !set->cutselssorted ) 4342 { 4343 SCIPsortPtr((void**)set->cutsels, SCIPcutselComp, set->ncutsels); 4344 set->cutselssorted = TRUE; 4345 } 4346 } 4347 4348 /** inserts propagator in propagator list */ 4349 SCIP_RETCODE SCIPsetIncludeProp( 4350 SCIP_SET* set, /**< global SCIP settings */ 4351 SCIP_PROP* prop /**< propagator */ 4352 ) 4353 { 4354 assert(set != NULL); 4355 assert(prop != NULL); 4356 assert(!SCIPpropIsInitialized(prop)); 4357 4358 if( set->nprops >= set->propssize ) 4359 { 4360 set->propssize = SCIPsetCalcMemGrowSize(set, set->nprops+1); 4361 SCIP_ALLOC( BMSreallocMemoryArray(&set->props, set->propssize) ); 4362 SCIP_ALLOC( BMSreallocMemoryArray(&set->props_presol, set->propssize) ); 4363 } 4364 assert(set->nprops < set->propssize); 4365 4366 set->props[set->nprops] = prop; 4367 set->props_presol[set->nprops] = prop; 4368 set->nprops++; 4369 set->propssorted = FALSE; 4370 set->propspresolsorted = FALSE; 4371 4372 return SCIP_OKAY; 4373 } 4374 4375 /** returns the propagator of the given name, or NULL if not existing */ 4376 SCIP_PROP* SCIPsetFindProp( 4377 SCIP_SET* set, /**< global SCIP settings */ 4378 const char* name /**< name of propagator */ 4379 ) 4380 { 4381 int i; 4382 4383 assert(set != NULL); 4384 assert(name != NULL); 4385 4386 for( i = 0; i < set->nprops; ++i ) 4387 { 4388 if( strcmp(SCIPpropGetName(set->props[i]), name) == 0 ) 4389 return set->props[i]; 4390 } 4391 4392 return NULL; 4393 } 4394 4395 /** sorts propagators by priorities */ 4396 void SCIPsetSortProps( 4397 SCIP_SET* set /**< global SCIP settings */ 4398 ) 4399 { 4400 assert(set != NULL); 4401 4402 if( !set->propssorted ) 4403 { 4404 SCIPsortPtr((void**)set->props, SCIPpropComp, set->nprops); 4405 set->propssorted = TRUE; 4406 set->propsnamesorted = FALSE; 4407 } 4408 } 4409 4410 /** sorts propagators by priorities for presolving */ 4411 void SCIPsetSortPropsPresol( 4412 SCIP_SET* set /**< global SCIP settings */ 4413 ) 4414 { 4415 assert(set != NULL); 4416 4417 if( !set->propspresolsorted ) 4418 { 4419 SCIPsortPtr((void**)set->props_presol, SCIPpropCompPresol, set->nprops); 4420 set->propspresolsorted = TRUE; 4421 set->propsnamesorted = FALSE; 4422 } 4423 } 4424 4425 /** sorts propagators w.r.t. names */ 4426 void SCIPsetSortPropsName( 4427 SCIP_SET* set /**< global SCIP settings */ 4428 ) 4429 { 4430 assert(set != NULL); 4431 4432 if( !set->propsnamesorted ) 4433 { 4434 SCIPsortPtr((void**)set->props, SCIPpropCompName, set->nprops); 4435 set->propssorted = FALSE; 4436 set->propsnamesorted = TRUE; 4437 } 4438 } 4439 4440 /** inserts bandit virtual function table into set */ 4441 SCIP_RETCODE SCIPsetIncludeBanditvtable( 4442 SCIP_SET* set, /**< global SCIP settings */ 4443 SCIP_BANDITVTABLE* banditvtable /**< bandit algorithm virtual function table */ 4444 ) 4445 { 4446 assert(set != NULL); 4447 assert(banditvtable != NULL); 4448 4449 if( set->nbanditvtables >= set->banditvtablessize ) 4450 { 4451 int newsize = SCIPsetCalcMemGrowSize(set, set->nbanditvtables + 1); 4452 SCIP_ALLOC( BMSreallocMemoryArray(&set->banditvtables, newsize) ); 4453 set->banditvtablessize = newsize; 4454 } 4455 4456 assert(set->nbanditvtables < set->banditvtablessize); 4457 set->banditvtables[set->nbanditvtables++] = banditvtable; 4458 4459 return SCIP_OKAY; 4460 } 4461 4462 /** returns the bandit virtual function table of the given name, or NULL if not existing */ 4463 SCIP_BANDITVTABLE* SCIPsetFindBanditvtable( 4464 SCIP_SET* set, /**< global SCIP settings */ 4465 const char* name /**< name of bandit algorithm virtual function table */ 4466 ) 4467 { 4468 int b; 4469 4470 assert(set != NULL); 4471 assert(name != NULL); 4472 4473 /* search for a bandit v table of the given name */ 4474 for( b = 0; b < set->nbanditvtables; ++b ) 4475 { 4476 if( strcmp(name, SCIPbanditvtableGetName(set->banditvtables[b])) == 0 ) 4477 return set->banditvtables[b]; 4478 } 4479 4480 return NULL; 4481 } 4482 4483 /** inserts concurrent solver type into the concurrent solver type list */ 4484 SCIP_RETCODE SCIPsetIncludeConcsolverType( 4485 SCIP_SET* set, /**< global SCIP settings */ 4486 SCIP_CONCSOLVERTYPE* concsolvertype /**< concurrent solver type */ 4487 ) 4488 { 4489 assert(set != NULL); 4490 assert(concsolvertype != NULL); 4491 4492 if( set->nconcsolvertypes >= set->concsolvertypessize ) 4493 { 4494 set->concsolvertypessize = SCIPsetCalcMemGrowSize(set, set->nconcsolvertypes + 1); 4495 SCIP_ALLOC( BMSreallocMemoryArray(&set->concsolvertypes, set->concsolvertypessize) ); 4496 } 4497 assert(set->nconcsolvertypes < set->concsolvertypessize); 4498 4499 set->concsolvertypes[set->nconcsolvertypes] = concsolvertype; 4500 set->nconcsolvertypes++; 4501 4502 return SCIP_OKAY; 4503 } 4504 4505 /** returns the concurrent solver type with the given name, or NULL if not existing */ 4506 SCIP_CONCSOLVERTYPE* SCIPsetFindConcsolverType( 4507 SCIP_SET* set, /**< global SCIP settings */ 4508 const char* name /**< name of concurrent solver type */ 4509 ) 4510 { 4511 int i; 4512 4513 assert(set != NULL); 4514 assert(name != NULL); 4515 4516 for( i = 0; i < set->nconcsolvertypes; ++i ) 4517 { 4518 if( strcmp(SCIPconcsolverTypeGetName(set->concsolvertypes[i]), name) == 0 ) 4519 return set->concsolvertypes[i]; 4520 } 4521 4522 return NULL; 4523 } 4524 4525 /** inserts concurrent solver into the concurrent solver list */ 4526 SCIP_RETCODE SCIPsetIncludeConcsolver( 4527 SCIP_SET* set, /**< global SCIP settings */ 4528 SCIP_CONCSOLVER* concsolver /**< concurrent solver */ 4529 ) 4530 { 4531 assert(set != NULL); 4532 assert(concsolver != NULL); 4533 4534 if( set->nconcsolvers >= set->concsolverssize ) 4535 { 4536 set->concsolverssize = SCIPsetCalcMemGrowSize(set, set->nconcsolvers + 1); 4537 SCIP_ALLOC( BMSreallocMemoryArray(&set->concsolvers, set->concsolverssize) ); 4538 } 4539 assert(set->nconcsolvers < set->concsolverssize); 4540 4541 set->concsolvers[set->nconcsolvers] = concsolver; 4542 assert(set->nconcsolvers == SCIPconcsolverGetIdx(concsolver)); 4543 4544 set->nconcsolvers++; 4545 4546 return SCIP_OKAY; 4547 } 4548 4549 /** frees all concurrent solvers in the concurrent solver list */ 4550 SCIP_RETCODE SCIPsetFreeConcsolvers( 4551 SCIP_SET* set /**< global SCIP settings */ 4552 ) 4553 { 4554 int i; 4555 assert(set != NULL); 4556 4557 /* call user callback for each concurrent solver */ 4558 for( i = 0; i < set->nconcsolvers; ++i ) 4559 { 4560 SCIP_CALL( SCIPconcsolverDestroyInstance(set, &set->concsolvers[i]) ); 4561 } 4562 4563 /* set size and number to zero and free the concurent solver array */ 4564 set->nconcsolvers = 0; 4565 set->concsolverssize = 0; 4566 BMSfreeMemoryArrayNull(&set->concsolvers); 4567 4568 return SCIP_OKAY; 4569 } 4570 4571 /** inserts primal heuristic in primal heuristic list */ 4572 SCIP_RETCODE SCIPsetIncludeHeur( 4573 SCIP_SET* set, /**< global SCIP settings */ 4574 SCIP_HEUR* heur /**< primal heuristic */ 4575 ) 4576 { 4577 assert(set != NULL); 4578 assert(heur != NULL); 4579 assert(!SCIPheurIsInitialized(heur)); 4580 4581 if( set->nheurs >= set->heurssize ) 4582 { 4583 set->heurssize = SCIPsetCalcMemGrowSize(set, set->nheurs+1); 4584 SCIP_ALLOC( BMSreallocMemoryArray(&set->heurs, set->heurssize) ); 4585 } 4586 assert(set->nheurs < set->heurssize); 4587 4588 set->heurs[set->nheurs] = heur; 4589 set->nheurs++; 4590 set->heurssorted = FALSE; 4591 4592 return SCIP_OKAY; 4593 } 4594 4595 /** returns the primal heuristic of the given name, or NULL if not existing */ 4596 SCIP_HEUR* SCIPsetFindHeur( 4597 SCIP_SET* set, /**< global SCIP settings */ 4598 const char* name /**< name of primal heuristic */ 4599 ) 4600 { 4601 int i; 4602 4603 assert(set != NULL); 4604 assert(name != NULL); 4605 4606 for( i = 0; i < set->nheurs; ++i ) 4607 { 4608 if( strcmp(SCIPheurGetName(set->heurs[i]), name) == 0 ) 4609 return set->heurs[i]; 4610 } 4611 4612 return NULL; 4613 } 4614 4615 /** sorts heuristics by their delay positions and priorities */ 4616 void SCIPsetSortHeurs( 4617 SCIP_SET* set /**< global SCIP settings */ 4618 ) 4619 { 4620 assert(set != NULL); 4621 4622 if( !set->heurssorted ) 4623 { 4624 SCIPsortPtr((void**)set->heurs, SCIPheurComp, set->nheurs); 4625 set->heurssorted = TRUE; 4626 set->heursnamesorted = FALSE; 4627 } 4628 } 4629 4630 /** sorts heuristics by names */ 4631 void SCIPsetSortHeursName( 4632 SCIP_SET* set /**< global SCIP settings */ 4633 ) 4634 { 4635 assert(set != NULL); 4636 4637 if( !set->heursnamesorted ) 4638 { 4639 SCIPsortPtr((void**)set->heurs, SCIPheurCompName, set->nheurs); 4640 set->heurssorted = FALSE; 4641 set->heursnamesorted = TRUE; 4642 } 4643 } 4644 4645 /** inserts tree compression in tree compression list */ 4646 SCIP_RETCODE SCIPsetIncludeCompr( 4647 SCIP_SET* set, /**< global SCIP settings */ 4648 SCIP_COMPR* compr /**< tree compression */ 4649 ) 4650 { 4651 assert(set != NULL); 4652 assert(compr != NULL); 4653 assert(!SCIPcomprIsInitialized(compr)); 4654 4655 if( set->ncomprs >= set->comprssize ) 4656 { 4657 set->comprssize = SCIPsetCalcMemGrowSize(set, set->ncomprs+1); 4658 SCIP_ALLOC( BMSreallocMemoryArray(&set->comprs, set->comprssize) ); 4659 } 4660 assert(set->ncomprs < set->comprssize); 4661 4662 set->comprs[set->ncomprs] = compr; 4663 set->ncomprs++; 4664 set->comprssorted = FALSE; 4665 4666 return SCIP_OKAY; 4667 } 4668 4669 /** returns the tree compression of the given name, or NULL if not existing */ 4670 SCIP_COMPR* SCIPsetFindCompr( 4671 SCIP_SET* set, /**< global SCIP settings */ 4672 const char* name /**< name of tree compression */ 4673 ) 4674 { 4675 int i; 4676 4677 assert(set != NULL); 4678 assert(name != NULL); 4679 4680 for( i = 0; i < set->ncomprs; ++i ) 4681 { 4682 if( strcmp(SCIPcomprGetName(set->comprs[i]), name) == 0 ) 4683 return set->comprs[i]; 4684 } 4685 4686 return NULL; 4687 } 4688 4689 /** sorts compressions by priorities */ 4690 void SCIPsetSortComprs( 4691 SCIP_SET* set /**< global SCIP settings */ 4692 ) 4693 { 4694 assert(set != NULL); 4695 4696 if( !set->comprssorted ) 4697 { 4698 SCIPsortPtr((void**)set->comprs, SCIPcomprComp, set->ncomprs); 4699 set->comprssorted = TRUE; 4700 set->comprsnamesorted = FALSE; 4701 } 4702 } 4703 4704 /** sorts heuristics by names */ 4705 void SCIPsetSortComprsName( 4706 SCIP_SET* set /**< global SCIP settings */ 4707 ) 4708 { 4709 assert(set != NULL); 4710 4711 if( !set->comprsnamesorted ) 4712 { 4713 SCIPsortPtr((void**)set->comprs, SCIPcomprCompName, set->ncomprs); 4714 set->comprssorted = FALSE; 4715 set->comprsnamesorted = TRUE; 4716 } 4717 } 4718 4719 /** inserts event handler in event handler list */ 4720 SCIP_RETCODE SCIPsetIncludeEventhdlr( 4721 SCIP_SET* set, /**< global SCIP settings */ 4722 SCIP_EVENTHDLR* eventhdlr /**< event handler */ 4723 ) 4724 { 4725 assert(set != NULL); 4726 assert(eventhdlr != NULL); 4727 assert(!SCIPeventhdlrIsInitialized(eventhdlr)); 4728 4729 if( set->neventhdlrs >= set->eventhdlrssize ) 4730 { 4731 set->eventhdlrssize = SCIPsetCalcMemGrowSize(set, set->neventhdlrs+1); 4732 SCIP_ALLOC( BMSreallocMemoryArray(&set->eventhdlrs, set->eventhdlrssize) ); 4733 } 4734 assert(set->neventhdlrs < set->eventhdlrssize); 4735 4736 set->eventhdlrs[set->neventhdlrs] = eventhdlr; 4737 set->neventhdlrs++; 4738 4739 return SCIP_OKAY; 4740 } 4741 4742 /** returns the event handler of the given name, or NULL if not existing */ 4743 SCIP_EVENTHDLR* SCIPsetFindEventhdlr( 4744 SCIP_SET* set, /**< global SCIP settings */ 4745 const char* name /**< name of event handler */ 4746 ) 4747 { 4748 int i; 4749 4750 assert(set != NULL); 4751 assert(name != NULL); 4752 4753 for( i = 0; i < set->neventhdlrs; ++i ) 4754 { 4755 if( strcmp(SCIPeventhdlrGetName(set->eventhdlrs[i]), name) == 0 ) 4756 return set->eventhdlrs[i]; 4757 } 4758 4759 return NULL; 4760 } 4761 4762 /** inserts node selector in node selector list */ 4763 SCIP_RETCODE SCIPsetIncludeNodesel( 4764 SCIP_SET* set, /**< global SCIP settings */ 4765 SCIP_NODESEL* nodesel /**< node selector */ 4766 ) 4767 { 4768 int i; 4769 int nodeselstdprio; 4770 4771 assert(set != NULL); 4772 assert(nodesel != NULL); 4773 assert(!SCIPnodeselIsInitialized(nodesel)); 4774 4775 if( set->nnodesels >= set->nodeselssize ) 4776 { 4777 set->nodeselssize = SCIPsetCalcMemGrowSize(set, set->nnodesels+1); 4778 SCIP_ALLOC( BMSreallocMemoryArray(&set->nodesels, set->nodeselssize) ); 4779 } 4780 assert(set->nnodesels < set->nodeselssize); 4781 4782 nodeselstdprio = SCIPnodeselGetStdPriority(nodesel); 4783 4784 for( i = set->nnodesels; i > 0 && nodeselstdprio > SCIPnodeselGetStdPriority(set->nodesels[i-1]); --i ) 4785 set->nodesels[i] = set->nodesels[i-1]; 4786 4787 set->nodesels[i] = nodesel; 4788 set->nnodesels++; 4789 4790 return SCIP_OKAY; 4791 } 4792 4793 /** returns the node selector of the given name, or NULL if not existing */ 4794 SCIP_NODESEL* SCIPsetFindNodesel( 4795 SCIP_SET* set, /**< global SCIP settings */ 4796 const char* name /**< name of event handler */ 4797 ) 4798 { 4799 int i; 4800 4801 assert(set != NULL); 4802 assert(name != NULL); 4803 4804 for( i = 0; i < set->nnodesels; ++i ) 4805 { 4806 if( strcmp(SCIPnodeselGetName(set->nodesels[i]), name) == 0 ) 4807 return set->nodesels[i]; 4808 } 4809 4810 return NULL; 4811 } 4812 4813 /** returns node selector with highest priority in the current mode */ 4814 SCIP_NODESEL* SCIPsetGetNodesel( 4815 SCIP_SET* set, /**< global SCIP settings */ 4816 SCIP_STAT* stat /**< dynamic problem statistics */ 4817 ) 4818 { 4819 assert(set != NULL); 4820 assert(stat != NULL); 4821 4822 /* check, if old node selector is still valid */ 4823 if( set->nodesel == NULL && set->nnodesels > 0 ) 4824 { 4825 int i; 4826 4827 set->nodesel = set->nodesels[0]; 4828 4829 /* search highest priority node selector */ 4830 if( stat->memsavemode ) 4831 { 4832 for( i = 1; i < set->nnodesels; ++i ) 4833 { 4834 if( SCIPnodeselGetMemsavePriority(set->nodesels[i]) > SCIPnodeselGetMemsavePriority(set->nodesel) ) 4835 set->nodesel = set->nodesels[i]; 4836 } 4837 } 4838 else 4839 { 4840 for( i = 1; i < set->nnodesels; ++i ) 4841 { 4842 if( SCIPnodeselGetStdPriority(set->nodesels[i]) > SCIPnodeselGetStdPriority(set->nodesel) ) 4843 set->nodesel = set->nodesels[i]; 4844 } 4845 } 4846 } 4847 4848 return set->nodesel; 4849 } 4850 4851 /** inserts branching rule in branching rule list */ 4852 SCIP_RETCODE SCIPsetIncludeBranchrule( 4853 SCIP_SET* set, /**< global SCIP settings */ 4854 SCIP_BRANCHRULE* branchrule /**< branching rule */ 4855 ) 4856 { 4857 assert(set != NULL); 4858 assert(branchrule != NULL); 4859 assert(!SCIPbranchruleIsInitialized(branchrule)); 4860 4861 if( set->nbranchrules >= set->branchrulessize ) 4862 { 4863 set->branchrulessize = SCIPsetCalcMemGrowSize(set, set->nbranchrules+1); 4864 SCIP_ALLOC( BMSreallocMemoryArray(&set->branchrules, set->branchrulessize) ); 4865 } 4866 assert(set->nbranchrules < set->branchrulessize); 4867 4868 set->branchrules[set->nbranchrules] = branchrule; 4869 set->nbranchrules++; 4870 set->branchrulessorted = FALSE; 4871 4872 return SCIP_OKAY; 4873 } 4874 4875 /** returns the branching rule of the given name, or NULL if not existing */ 4876 SCIP_BRANCHRULE* SCIPsetFindBranchrule( 4877 SCIP_SET* set, /**< global SCIP settings */ 4878 const char* name /**< name of event handler */ 4879 ) 4880 { 4881 int i; 4882 4883 assert(set != NULL); 4884 assert(name != NULL); 4885 4886 for( i = 0; i < set->nbranchrules; ++i ) 4887 { 4888 if( strcmp(SCIPbranchruleGetName(set->branchrules[i]), name) == 0 ) 4889 return set->branchrules[i]; 4890 } 4891 4892 return NULL; 4893 } 4894 4895 /** sorts branching rules by priorities */ 4896 void SCIPsetSortBranchrules( 4897 SCIP_SET* set /**< global SCIP settings */ 4898 ) 4899 { 4900 assert(set != NULL); 4901 4902 if( !set->branchrulessorted ) 4903 { 4904 SCIPsortPtr((void**)set->branchrules, SCIPbranchruleComp, set->nbranchrules); 4905 set->branchrulessorted = TRUE; 4906 set->branchrulesnamesorted = FALSE; 4907 } 4908 } 4909 4910 /** sorts branching rules by priorities */ 4911 void SCIPsetSortBranchrulesName( 4912 SCIP_SET* set /**< global SCIP settings */ 4913 ) 4914 { 4915 assert(set != NULL); 4916 4917 if( !set->branchrulesnamesorted ) 4918 { 4919 SCIPsortPtr((void**)set->branchrules, SCIPbranchruleCompName, set->nbranchrules); 4920 set->branchrulessorted = FALSE; 4921 set->branchrulesnamesorted = TRUE; 4922 } 4923 } 4924 4925 /** inserts display column in display column list */ 4926 SCIP_RETCODE SCIPsetIncludeDisp( 4927 SCIP_SET* set, /**< global SCIP settings */ 4928 SCIP_DISP* disp /**< display column */ 4929 ) 4930 { 4931 int i; 4932 int disppos; 4933 4934 assert(set != NULL); 4935 assert(disp != NULL); 4936 assert(!SCIPdispIsInitialized(disp)); 4937 4938 if( set->ndisps >= set->dispssize ) 4939 { 4940 set->dispssize = SCIPsetCalcMemGrowSize(set, set->ndisps+1); 4941 SCIP_ALLOC( BMSreallocMemoryArray(&set->disps, set->dispssize) ); 4942 } 4943 assert(set->ndisps < set->dispssize); 4944 4945 disppos = SCIPdispGetPosition(disp); 4946 4947 for( i = set->ndisps; i > 0 && disppos < SCIPdispGetPosition(set->disps[i-1]); --i ) 4948 { 4949 set->disps[i] = set->disps[i-1]; 4950 } 4951 set->disps[i] = disp; 4952 set->ndisps++; 4953 4954 return SCIP_OKAY; 4955 } 4956 4957 /** returns the display column of the given name, or NULL if not existing */ 4958 SCIP_DISP* SCIPsetFindDisp( 4959 SCIP_SET* set, /**< global SCIP settings */ 4960 const char* name /**< name of display */ 4961 ) 4962 { 4963 int i; 4964 4965 assert(set != NULL); 4966 assert(name != NULL); 4967 4968 for( i = 0; i < set->ndisps; ++i ) 4969 { 4970 if( strcmp(SCIPdispGetName(set->disps[i]), name) == 0 ) 4971 return set->disps[i]; 4972 } 4973 4974 return NULL; 4975 } 4976 4977 /** inserts statistics table in statistics table list */ 4978 SCIP_RETCODE SCIPsetIncludeTable( 4979 SCIP_SET* set, /**< global SCIP settings */ 4980 SCIP_TABLE* table /**< statistics table */ 4981 ) 4982 { 4983 assert(set != NULL); 4984 assert(table != NULL); 4985 assert(!SCIPtableIsInitialized(table)); 4986 4987 if( set->ntables >= set->tablessize ) 4988 { 4989 set->tablessize = SCIPsetCalcMemGrowSize(set, set->ntables+1); 4990 SCIP_ALLOC( BMSreallocMemoryArray(&set->tables, set->tablessize) ); 4991 } 4992 assert(set->ntables < set->tablessize); 4993 4994 /* we insert in arbitrary order and sort once before printing statistics */ 4995 set->tables[set->ntables] = table; 4996 set->ntables++; 4997 set->tablessorted = FALSE; 4998 4999 return SCIP_OKAY; 5000 } 5001 5002 /** returns the statistics table of the given name, or NULL if not existing */ 5003 SCIP_TABLE* SCIPsetFindTable( 5004 SCIP_SET* set, /**< global SCIP settings */ 5005 const char* name /**< name of statistics table */ 5006 ) 5007 { 5008 int i; 5009 5010 assert(set != NULL); 5011 assert(name != NULL); 5012 5013 for( i = 0; i < set->ntables; ++i ) 5014 { 5015 if( strcmp(SCIPtableGetName(set->tables[i]), name) == 0 ) 5016 return set->tables[i]; 5017 } 5018 5019 return NULL; 5020 } 5021 5022 /** inserts dialog in dialog list */ 5023 SCIP_RETCODE SCIPsetIncludeDialog( 5024 SCIP_SET* set, /**< global SCIP settings */ 5025 SCIP_DIALOG* dialog /**< dialog */ 5026 ) 5027 { 5028 assert(set != NULL); 5029 assert(dialog != NULL); 5030 5031 if( set->ndialogs >= set->dialogssize ) 5032 { 5033 set->dialogssize = SCIPsetCalcMemGrowSize(set, set->ndialogs+1); 5034 SCIP_ALLOC( BMSreallocMemoryArray(&set->dialogs, set->dialogssize) ); 5035 } 5036 assert(set->ndialogs < set->dialogssize); 5037 5038 set->dialogs[set->ndialogs] = dialog; 5039 set->ndialogs++; 5040 5041 return SCIP_OKAY; 5042 } 5043 5044 /** returns if the dialog already exists */ 5045 SCIP_Bool SCIPsetExistsDialog( 5046 SCIP_SET* set, /**< global SCIP settings */ 5047 SCIP_DIALOG* dialog /**< dialog */ 5048 ) 5049 { 5050 int i; 5051 5052 assert(set != NULL); 5053 5054 if( dialog == NULL ) 5055 return FALSE; 5056 5057 for( i = 0; i < set->ndialogs; ++i ) 5058 { 5059 if( set->dialogs[i] == dialog ) 5060 return TRUE; 5061 } 5062 5063 return FALSE; 5064 } 5065 5066 /** inserts expression handler in expression handler list */ 5067 SCIP_RETCODE SCIPsetIncludeExprhdlr( 5068 SCIP_SET* set, /**< global SCIP settings */ 5069 SCIP_EXPRHDLR* exprhdlr /**< expression handler */ 5070 ) 5071 { 5072 assert(set != NULL); 5073 assert(exprhdlr != NULL); 5074 5075 if( set->nexprhdlrs >= set->exprhdlrssize ) 5076 { 5077 set->exprhdlrssize = SCIPsetCalcMemGrowSize(set, set->nexprhdlrs+1); 5078 SCIP_ALLOC( BMSreallocMemoryArray(&set->exprhdlrs, set->exprhdlrssize) ); 5079 } 5080 assert(set->nexprhdlrs < set->exprhdlrssize); 5081 5082 set->exprhdlrs[set->nexprhdlrs] = exprhdlr; 5083 set->nexprhdlrs++; 5084 set->exprhdlrssorted = FALSE; 5085 5086 if( set->exprhdlrvar == NULL && strcmp(SCIPexprhdlrGetName(exprhdlr), "var") == 0 ) 5087 set->exprhdlrvar = exprhdlr; 5088 else if( set->exprhdlrval == NULL && strcmp(SCIPexprhdlrGetName(exprhdlr), "val") == 0 ) 5089 set->exprhdlrval = exprhdlr; 5090 else if( set->exprhdlrsum == NULL && strcmp(SCIPexprhdlrGetName(exprhdlr), "sum") == 0 ) 5091 set->exprhdlrsum = exprhdlr; 5092 else if( set->exprhdlrproduct == NULL && strcmp(SCIPexprhdlrGetName(exprhdlr), "prod") == 0 ) 5093 set->exprhdlrproduct = exprhdlr; 5094 else if( set->exprhdlrpow == NULL && strcmp(SCIPexprhdlrGetName(exprhdlr), "pow") == 0 ) 5095 set->exprhdlrpow = exprhdlr; 5096 5097 return SCIP_OKAY; 5098 } 5099 5100 /** returns the expression handler of the given name, or NULL if not existing */ 5101 SCIP_EXPRHDLR* SCIPsetFindExprhdlr( 5102 SCIP_SET* set, /**< global SCIP settings */ 5103 const char* name /**< name of expression handler */ 5104 ) 5105 { 5106 int i; 5107 5108 assert(set != NULL); 5109 assert(name != NULL); 5110 5111 for( i = 0; i < set->nexprhdlrs; ++i ) 5112 if( strcmp(SCIPexprhdlrGetName(set->exprhdlrs[i]), name) == 0 ) 5113 return set->exprhdlrs[i]; 5114 5115 return NULL; 5116 } 5117 5118 /** sorts expression handlers by name */ 5119 void SCIPsetSortExprhdlrs( 5120 SCIP_SET* set /**< global SCIP settings */ 5121 ) 5122 { 5123 assert(set != NULL); 5124 5125 if( !set->exprhdlrssorted ) 5126 { 5127 SCIPsortPtr((void**)set->exprhdlrs, SCIPexprhdlrComp, set->nexprhdlrs); 5128 set->exprhdlrssorted = TRUE; 5129 } 5130 } 5131 5132 /** inserts NLPI in NLPI list */ 5133 SCIP_RETCODE SCIPsetIncludeNlpi( 5134 SCIP_SET* set, /**< global SCIP settings */ 5135 SCIP_NLPI* nlpi /**< NLPI */ 5136 ) 5137 { 5138 assert(set != NULL); 5139 assert(nlpi != NULL); 5140 5141 if( set->nnlpis >= set->nlpissize ) 5142 { 5143 set->nlpissize = SCIPsetCalcMemGrowSize(set, set->nnlpis+1); 5144 SCIP_ALLOC( BMSreallocMemoryArray(&set->nlpis, set->nlpissize) ); 5145 } 5146 assert(set->nnlpis < set->nlpissize); 5147 5148 set->nlpis[set->nnlpis] = nlpi; 5149 set->nnlpis++; 5150 set->nlpissorted = FALSE; 5151 5152 return SCIP_OKAY; 5153 } 5154 5155 /** returns the NLPI of the given name, or NULL if not existing */ 5156 SCIP_NLPI* SCIPsetFindNlpi( 5157 SCIP_SET* set, /**< global SCIP settings */ 5158 const char* name /**< name of NLPI */ 5159 ) 5160 { 5161 int i; 5162 5163 assert(set != NULL); 5164 assert(name != NULL); 5165 5166 for( i = 0; i < set->nnlpis; ++i ) 5167 { 5168 if( strcmp(SCIPnlpiGetName(set->nlpis[i]), name) == 0 ) 5169 return set->nlpis[i]; 5170 } 5171 5172 return NULL; 5173 } 5174 5175 /** sorts NLPIs by priorities */ 5176 void SCIPsetSortNlpis( 5177 SCIP_SET* set /**< global SCIP settings */ 5178 ) 5179 { 5180 assert(set != NULL); 5181 5182 if( !set->nlpissorted ) 5183 { 5184 SCIPsortPtr((void**)set->nlpis, SCIPnlpiComp, set->nnlpis); 5185 set->nlpissorted = TRUE; 5186 } 5187 } 5188 5189 /** set priority of an NLPI */ 5190 void SCIPsetSetPriorityNlpi( 5191 SCIP_SET* set, /**< global SCIP settings */ 5192 SCIP_NLPI* nlpi, /**< NLPI */ 5193 int priority /**< new priority of NLPI */ 5194 ) 5195 { 5196 assert(set != NULL); 5197 assert(nlpi != NULL); 5198 5199 SCIPnlpiSetPriority(nlpi, priority); 5200 set->nlpissorted = FALSE; 5201 } 5202 5203 /** inserts information about an external code in external codes list */ 5204 SCIP_RETCODE SCIPsetIncludeExternalCode( 5205 SCIP_SET* set, /**< global SCIP settings */ 5206 const char* name, /**< name of external code */ 5207 const char* description /**< description of external code, can be NULL */ 5208 ) 5209 { 5210 assert(set != NULL); 5211 assert(name != NULL); 5212 5213 if( set->nextcodes >= set->extcodessize ) 5214 { 5215 set->extcodessize = SCIPsetCalcMemGrowSize(set, set->nextcodes+1); 5216 SCIP_ALLOC( BMSreallocMemoryArray(&set->extcodenames, set->extcodessize) ); 5217 SCIP_ALLOC( BMSreallocMemoryArray(&set->extcodedescs, set->extcodessize) ); 5218 } 5219 assert(set->nextcodes < set->extcodessize); 5220 5221 BMSduplicateMemoryArray(&(set->extcodenames[set->nextcodes]), name, (int) (strlen(name)+1)); /*lint !e866*/ 5222 if( description != NULL ) 5223 { 5224 BMSduplicateMemoryArray(&(set->extcodedescs[set->nextcodes]), description, (int) (strlen(description)+1)); /*lint !e866*/ 5225 } 5226 else 5227 { 5228 set->extcodedescs[set->nextcodes] = NULL; 5229 } 5230 set->nextcodes++; 5231 5232 return SCIP_OKAY; 5233 } 5234 5235 /** calls init methods of all plugins */ 5236 SCIP_RETCODE SCIPsetInitPlugins( 5237 SCIP_SET* set, /**< global SCIP settings */ 5238 BMS_BLKMEM* blkmem, /**< block memory */ 5239 SCIP_STAT* stat /**< dynamic problem statistics */ 5240 ) 5241 { 5242 int i; 5243 5244 assert(set != NULL); 5245 5246 /* active variable pricers */ 5247 SCIPsetSortPricers(set); 5248 for( i = 0; i < set->nactivepricers; ++i ) 5249 { 5250 SCIP_CALL( SCIPpricerInit(set->pricers[i], set) ); 5251 } 5252 5253 /* Benders' decomposition algorithm */ 5254 SCIPsetSortBenders(set); 5255 for( i = 0; i < set->nactivebenders; ++i ) 5256 { 5257 SCIP_CALL( SCIPbendersInit(set->benders[i], set) ); 5258 } 5259 5260 /* constraint handlers */ 5261 for( i = 0; i < set->nconshdlrs; ++i ) 5262 { 5263 SCIP_CALL( SCIPconshdlrInit(set->conshdlrs[i], blkmem, set, stat) ); 5264 } 5265 5266 /* conflict handlers */ 5267 for( i = 0; i < set->nconflicthdlrs; ++i ) 5268 { 5269 SCIP_CALL( SCIPconflicthdlrInit(set->conflicthdlrs[i], set) ); 5270 } 5271 5272 /* presolvers */ 5273 for( i = 0; i < set->npresols; ++i ) 5274 { 5275 SCIP_CALL( SCIPpresolInit(set->presols[i], set) ); 5276 } 5277 5278 /* relaxators */ 5279 for( i = 0; i < set->nrelaxs; ++i ) 5280 { 5281 SCIP_CALL( SCIPrelaxInit(set->relaxs[i], set) ); 5282 } 5283 5284 /* separators */ 5285 for( i = 0; i < set->nsepas; ++i ) 5286 { 5287 SCIP_CALL( SCIPsepaInit(set->sepas[i], set) ); 5288 } 5289 5290 /* cut selectors */ 5291 for( i = 0; i < set->ncutsels; ++i ) 5292 { 5293 SCIP_CALL( SCIPcutselInit(set->cutsels[i], set) ); 5294 } 5295 5296 /* propagators */ 5297 for( i = 0; i < set->nprops; ++i ) 5298 { 5299 SCIP_CALL( SCIPpropInit(set->props[i], set) ); 5300 } 5301 5302 /* primal heuristics */ 5303 for( i = 0; i < set->nheurs; ++i ) 5304 { 5305 SCIP_CALL( SCIPheurInit(set->heurs[i], set) ); 5306 } 5307 5308 /* tree compression */ 5309 for( i = 0; i < set->ncomprs; ++i ) 5310 { 5311 SCIP_CALL( SCIPcomprInit(set->comprs[i], set) ); 5312 } 5313 5314 /* event handlers */ 5315 for( i = 0; i < set->neventhdlrs; ++i ) 5316 { 5317 SCIP_CALL( SCIPeventhdlrInit(set->eventhdlrs[i], set) ); 5318 } 5319 5320 /* node selectors */ 5321 for( i = 0; i < set->nnodesels; ++i ) 5322 { 5323 SCIP_CALL( SCIPnodeselInit(set->nodesels[i], set) ); 5324 } 5325 5326 /* branching rules */ 5327 for( i = 0; i < set->nbranchrules; ++i ) 5328 { 5329 SCIP_CALL( SCIPbranchruleInit(set->branchrules[i], set) ); 5330 } 5331 5332 /* display columns */ 5333 for( i = 0; i < set->ndisps; ++i ) 5334 { 5335 SCIP_CALL( SCIPdispInit(set->disps[i], set) ); 5336 } 5337 SCIP_CALL( SCIPdispAutoActivate(set) ); 5338 5339 /* statistics tables */ 5340 for( i = 0; i < set->ntables; ++i ) 5341 { 5342 SCIP_CALL( SCIPtableInit(set->tables[i], set) ); 5343 } 5344 5345 /* expression handlers */ 5346 for( i = 0; i < set->nexprhdlrs; ++i ) 5347 SCIPexprhdlrInit(set->exprhdlrs[i], set); 5348 5349 /* NLP solver interfaces */ 5350 for( i = 0; i < set->nnlpis; ++i ) 5351 SCIPnlpiInit(set->nlpis[i]); 5352 5353 return SCIP_OKAY; 5354 } 5355 5356 /** calls exit methods of all plugins */ 5357 SCIP_RETCODE SCIPsetExitPlugins( 5358 SCIP_SET* set, /**< global SCIP settings */ 5359 BMS_BLKMEM* blkmem, /**< block memory */ 5360 SCIP_STAT* stat /**< dynamic problem statistics */ 5361 ) 5362 { 5363 int i; 5364 5365 assert(set != NULL); 5366 5367 /* active variable pricers */ 5368 SCIPsetSortPricers(set); 5369 for( i = 0; i < set->nactivepricers; ++i ) 5370 { 5371 SCIP_CALL( SCIPpricerExit(set->pricers[i], set) ); 5372 } 5373 5374 /* Benders' decomposition */ 5375 SCIPsetSortBenders(set); 5376 for( i = 0; i < set->nactivebenders; ++i ) 5377 { 5378 SCIP_CALL( SCIPbendersExit(set->benders[i], set) ); 5379 } 5380 5381 /* constraint handlers */ 5382 for( i = 0; i < set->nconshdlrs; ++i ) 5383 { 5384 SCIP_CALL( SCIPconshdlrExit(set->conshdlrs[i], blkmem, set, stat) ); 5385 } 5386 5387 /* conflict handlers */ 5388 for( i = 0; i < set->nconflicthdlrs; ++i ) 5389 { 5390 SCIP_CALL( SCIPconflicthdlrExit(set->conflicthdlrs[i], set) ); 5391 } 5392 5393 /* presolvers */ 5394 for( i = 0; i < set->npresols; ++i ) 5395 { 5396 SCIP_CALL( SCIPpresolExit(set->presols[i], set) ); 5397 } 5398 5399 /* relaxators */ 5400 for( i = 0; i < set->nrelaxs; ++i ) 5401 { 5402 SCIP_CALL( SCIPrelaxExit(set->relaxs[i], set) ); 5403 } 5404 5405 /* separators */ 5406 for( i = 0; i < set->nsepas; ++i ) 5407 { 5408 SCIP_CALL( SCIPsepaExit(set->sepas[i], set) ); 5409 } 5410 5411 /* cut selectors */ 5412 for( i = 0; i < set->ncutsels; ++i ) 5413 { 5414 SCIP_CALL( SCIPcutselExit(set->cutsels[i], set) ); 5415 } 5416 5417 /* propagators */ 5418 for( i = 0; i < set->nprops; ++i ) 5419 { 5420 SCIP_CALL( SCIPpropExit(set->props[i], set) ); 5421 } 5422 5423 /* primal heuristics */ 5424 for( i = 0; i < set->nheurs; ++i ) 5425 { 5426 SCIP_CALL( SCIPheurExit(set->heurs[i], set) ); 5427 } 5428 5429 /* tree compression */ 5430 for( i = 0; i < set->ncomprs; ++i ) 5431 { 5432 SCIP_CALL( SCIPcomprExit(set->comprs[i], set) ); 5433 } 5434 5435 /* event handlers */ 5436 for( i = 0; i < set->neventhdlrs; ++i ) 5437 { 5438 SCIP_CALL( SCIPeventhdlrExit(set->eventhdlrs[i], set) ); 5439 } 5440 5441 /* node selectors */ 5442 for( i = 0; i < set->nnodesels; ++i ) 5443 { 5444 SCIP_CALL( SCIPnodeselExit(set->nodesels[i], set) ); 5445 } 5446 5447 /* branching rules */ 5448 for( i = 0; i < set->nbranchrules; ++i ) 5449 { 5450 SCIP_CALL( SCIPbranchruleExit(set->branchrules[i], set) ); 5451 } 5452 5453 /* display columns */ 5454 for( i = 0; i < set->ndisps; ++i ) 5455 { 5456 SCIP_CALL( SCIPdispExit(set->disps[i], set) ); 5457 } 5458 5459 /* statistics tables */ 5460 for( i = 0; i < set->ntables; ++i ) 5461 { 5462 SCIP_CALL( SCIPtableExit(set->tables[i], set) ); 5463 } 5464 5465 return SCIP_OKAY; 5466 } 5467 5468 /** calls initpre methods of all plugins */ 5469 SCIP_RETCODE SCIPsetInitprePlugins( 5470 SCIP_SET* set, /**< global SCIP settings */ 5471 BMS_BLKMEM* blkmem, /**< block memory */ 5472 SCIP_STAT* stat /**< dynamic problem statistics */ 5473 ) 5474 { 5475 int i; 5476 5477 assert(set != NULL); 5478 5479 /* inform presolvers that the presolving is about to begin */ 5480 for( i = 0; i < set->npresols; ++i ) 5481 { 5482 SCIP_CALL( SCIPpresolInitpre(set->presols[i], set) ); 5483 } 5484 5485 /* inform propagators that the presolving is about to begin */ 5486 for( i = 0; i < set->nprops; ++i ) 5487 { 5488 SCIP_CALL( SCIPpropInitpre(set->props[i], set) ); 5489 } 5490 5491 /* inform constraint handlers that the presolving is about to begin */ 5492 for( i = 0; i < set->nconshdlrs; ++i ) 5493 { 5494 SCIP_CALL( SCIPconshdlrInitpre(set->conshdlrs[i], blkmem, set, stat) ); 5495 } 5496 5497 /* inform Benders' decomposition that the presolving is about to begin */ 5498 for( i = 0; i < set->nactivebenders; ++i ) 5499 { 5500 SCIP_CALL( SCIPbendersInitpre(set->benders[i], set, stat) ); 5501 } 5502 5503 return SCIP_OKAY; 5504 } 5505 5506 /** calls exitpre methods of all plugins */ 5507 SCIP_RETCODE SCIPsetExitprePlugins( 5508 SCIP_SET* set, /**< global SCIP settings */ 5509 BMS_BLKMEM* blkmem, /**< block memory */ 5510 SCIP_STAT* stat /**< dynamic problem statistics */ 5511 ) 5512 { 5513 int i; 5514 5515 assert(set != NULL); 5516 5517 /* inform presolvers that the presolving is about to end */ 5518 for( i = 0; i < set->npresols; ++i ) 5519 { 5520 SCIP_CALL( SCIPpresolExitpre(set->presols[i], set) ); 5521 } 5522 5523 /* inform propagators that the presolving is about to end */ 5524 for( i = 0; i < set->nprops; ++i ) 5525 { 5526 SCIP_CALL( SCIPpropExitpre(set->props[i], set) ); 5527 } 5528 5529 /* inform constraint handlers that the presolving is about to end */ 5530 for( i = 0; i < set->nconshdlrs; ++i ) 5531 { 5532 SCIP_CALL( SCIPconshdlrExitpre(set->conshdlrs[i], blkmem, set, stat) ); 5533 } 5534 5535 /* inform Benders' decomposition that the presolving is about to end */ 5536 for( i = 0; i < set->nactivebenders; ++i ) 5537 { 5538 SCIP_CALL( SCIPbendersExitpre(set->benders[i], set, stat) ); 5539 } 5540 5541 return SCIP_OKAY; 5542 } 5543 5544 /** calls initsol methods of all plugins */ 5545 SCIP_RETCODE SCIPsetInitsolPlugins( 5546 SCIP_SET* set, /**< global SCIP settings */ 5547 BMS_BLKMEM* blkmem, /**< block memory */ 5548 SCIP_STAT* stat /**< dynamic problem statistics */ 5549 ) 5550 { 5551 int i; 5552 5553 assert(set != NULL); 5554 5555 /* reset SCIP-defined feasibility tolerance for relaxations 5556 * if this is invalid, then only the relaxation specific feasibility tolerance, 5557 * e.g., numerics/lpfeastol is applied 5558 * SCIP plugins or core may set num_relaxfeastol to request a 5559 * tighter feasibility tolerance, though 5560 * see also documentation of SCIPchgRelaxfeastol 5561 */ 5562 set->num_relaxfeastol = SCIP_INVALID; 5563 5564 /* active variable pricers */ 5565 SCIPsetSortPricers(set); 5566 for( i = 0; i < set->nactivepricers; ++i ) 5567 { 5568 SCIP_CALL( SCIPpricerInitsol(set->pricers[i], set) ); 5569 } 5570 5571 /* Benders' decomposition */ 5572 SCIPsetSortBenders(set); 5573 for( i = 0; i < set->nactivebenders; ++i ) 5574 { 5575 SCIP_CALL( SCIPbendersInitsol(set->benders[i], set) ); 5576 } 5577 5578 /* constraint handlers */ 5579 for( i = 0; i < set->nconshdlrs; ++i ) 5580 { 5581 SCIP_CALL( SCIPconshdlrInitsol(set->conshdlrs[i], blkmem, set, stat) ); 5582 } 5583 5584 /* conflict handlers */ 5585 for( i = 0; i < set->nconflicthdlrs; ++i ) 5586 { 5587 SCIP_CALL( SCIPconflicthdlrInitsol(set->conflicthdlrs[i], set) ); 5588 } 5589 5590 /* relaxators */ 5591 for( i = 0; i < set->nrelaxs; ++i ) 5592 { 5593 SCIP_CALL( SCIPrelaxInitsol(set->relaxs[i], set) ); 5594 } 5595 5596 /* separators */ 5597 for( i = 0; i < set->nsepas; ++i ) 5598 { 5599 SCIP_CALL( SCIPsepaInitsol(set->sepas[i], set) ); 5600 } 5601 5602 /* cut selectors */ 5603 for( i =0; i < set->ncutsels; ++i ) 5604 { 5605 SCIP_CALL( SCIPcutselInitsol(set->cutsels[i], set) ); 5606 } 5607 5608 /* propagators */ 5609 for( i = 0; i < set->nprops; ++i ) 5610 { 5611 SCIP_CALL( SCIPpropInitsol(set->props[i], set) ); 5612 } 5613 5614 /* primal heuristics */ 5615 for( i = 0; i < set->nheurs; ++i ) 5616 { 5617 SCIP_CALL( SCIPheurInitsol(set->heurs[i], set) ); 5618 } 5619 5620 /* event handlers */ 5621 for( i = 0; i < set->neventhdlrs; ++i ) 5622 { 5623 SCIP_CALL( SCIPeventhdlrInitsol(set->eventhdlrs[i], set) ); 5624 } 5625 5626 /* node selectors */ 5627 for( i = 0; i < set->nnodesels; ++i ) 5628 { 5629 SCIP_CALL( SCIPnodeselInitsol(set->nodesels[i], set) ); 5630 } 5631 5632 /* branching rules */ 5633 for( i = 0; i < set->nbranchrules; ++i ) 5634 { 5635 SCIP_CALL( SCIPbranchruleInitsol(set->branchrules[i], set) ); 5636 } 5637 5638 /* display columns */ 5639 for( i = 0; i < set->ndisps; ++i ) 5640 { 5641 SCIP_CALL( SCIPdispInitsol(set->disps[i], set) ); 5642 } 5643 5644 /* statistics tables */ 5645 for( i = 0; i < set->ntables; ++i ) 5646 { 5647 SCIP_CALL( SCIPtableInitsol(set->tables[i], set) ); 5648 } 5649 5650 return SCIP_OKAY; 5651 } 5652 5653 /** calls exitsol methods of all plugins */ 5654 SCIP_RETCODE SCIPsetExitsolPlugins( 5655 SCIP_SET* set, /**< global SCIP settings */ 5656 BMS_BLKMEM* blkmem, /**< block memory */ 5657 SCIP_STAT* stat, /**< dynamic problem statistics */ 5658 SCIP_Bool restart /**< was this exit solve call triggered by a restart? */ 5659 ) 5660 { 5661 int i; 5662 5663 assert(set != NULL); 5664 5665 /* active variable pricers */ 5666 SCIPsetSortPricers(set); 5667 for( i = 0; i < set->nactivepricers; ++i ) 5668 { 5669 SCIP_CALL( SCIPpricerExitsol(set->pricers[i], set) ); 5670 } 5671 5672 /* Benders' decomposition */ 5673 SCIPsetSortBenders(set); 5674 for( i = 0; i < set->nactivebenders; ++i ) 5675 { 5676 SCIP_CALL( SCIPbendersExitsol(set->benders[i], set) ); 5677 } 5678 5679 /* constraint handlers */ 5680 for( i = 0; i < set->nconshdlrs; ++i ) 5681 { 5682 SCIP_CALL( SCIPconshdlrExitsol(set->conshdlrs[i], blkmem, set, stat, restart) ); 5683 } 5684 5685 /* conflict handlers */ 5686 for( i = 0; i < set->nconflicthdlrs; ++i ) 5687 { 5688 SCIP_CALL( SCIPconflicthdlrExitsol(set->conflicthdlrs[i], set) ); 5689 } 5690 5691 /* relaxators */ 5692 for( i = 0; i < set->nrelaxs; ++i ) 5693 { 5694 SCIP_CALL( SCIPrelaxExitsol(set->relaxs[i], set) ); 5695 } 5696 5697 /* separators */ 5698 for( i = 0; i < set->nsepas; ++i ) 5699 { 5700 SCIP_CALL( SCIPsepaExitsol(set->sepas[i], set) ); 5701 } 5702 5703 /* cut selectors */ 5704 for( i = 0; i < set->ncutsels; ++i ) 5705 { 5706 SCIP_CALL( SCIPcutselExitsol(set->cutsels[i], set) ); 5707 } 5708 5709 /* propagators */ 5710 for( i = 0; i < set->nprops; ++i ) 5711 { 5712 SCIP_CALL( SCIPpropExitsol(set->props[i], set, restart) ); 5713 } 5714 5715 /* primal heuristics */ 5716 for( i = 0; i < set->nheurs; ++i ) 5717 { 5718 SCIP_CALL( SCIPheurExitsol(set->heurs[i], set) ); 5719 } 5720 5721 /* event handlers */ 5722 for( i = 0; i < set->neventhdlrs; ++i ) 5723 { 5724 SCIP_CALL( SCIPeventhdlrExitsol(set->eventhdlrs[i], set) ); 5725 } 5726 5727 /* node selectors */ 5728 for( i = 0; i < set->nnodesels; ++i ) 5729 { 5730 SCIP_CALL( SCIPnodeselExitsol(set->nodesels[i], set) ); 5731 } 5732 5733 /* branching rules */ 5734 for( i = 0; i < set->nbranchrules; ++i ) 5735 { 5736 SCIP_CALL( SCIPbranchruleExitsol(set->branchrules[i], set) ); 5737 } 5738 5739 /* display columns */ 5740 for( i = 0; i < set->ndisps; ++i ) 5741 { 5742 SCIP_CALL( SCIPdispExitsol(set->disps[i], set) ); 5743 } 5744 5745 /* statistics tables */ 5746 for( i = 0; i < set->ntables; ++i ) 5747 { 5748 SCIP_CALL( SCIPtableExitsol(set->tables[i], set) ); 5749 } 5750 5751 return SCIP_OKAY; 5752 } 5753 5754 /** calculate memory size for dynamically allocated arrays */ 5755 int SCIPsetCalcMemGrowSize( 5756 SCIP_SET* set, /**< global SCIP settings */ 5757 int num /**< minimum number of entries to store */ 5758 ) 5759 { 5760 return calcGrowSize(set->mem_arraygrowinit, set->mem_arraygrowfac, num); 5761 } 5762 5763 /** calculate memory size for tree array */ 5764 int SCIPsetCalcTreeGrowSize( 5765 SCIP_SET* set, /**< global SCIP settings */ 5766 int num /**< minimum number of entries to store */ 5767 ) 5768 { 5769 return calcGrowSize(set->mem_treegrowinit, set->mem_treegrowfac, num); 5770 } 5771 5772 /** calculate memory size for path array */ 5773 int SCIPsetCalcPathGrowSize( 5774 SCIP_SET* set, /**< global SCIP settings */ 5775 int num /**< minimum number of entries to store */ 5776 ) 5777 { 5778 return calcGrowSize(set->mem_pathgrowinit, set->mem_pathgrowfac, num); 5779 } 5780 5781 /** sets verbosity level for message output */ 5782 SCIP_RETCODE SCIPsetSetVerbLevel( 5783 SCIP_SET* set, /**< global SCIP settings */ 5784 SCIP_VERBLEVEL verblevel /**< verbosity level for message output */ 5785 ) 5786 { 5787 assert(set != NULL); 5788 5789 if( verblevel > SCIP_VERBLEVEL_FULL ) 5790 { 5791 SCIPerrorMessage("invalid verbosity level <%d>, maximum is <%d>\n", verblevel, SCIP_VERBLEVEL_FULL); 5792 return SCIP_INVALIDCALL; 5793 } 5794 5795 set->disp_verblevel = verblevel; 5796 5797 return SCIP_OKAY; 5798 } 5799 5800 /** sets feasibility tolerance */ 5801 SCIP_RETCODE SCIPsetSetFeastol( 5802 SCIP_SET* set, /**< global SCIP settings */ 5803 SCIP_LP* lp, /**< LP data, or NULL */ 5804 SCIP_Real feastol /**< new feasibility tolerance */ 5805 ) 5806 { 5807 assert(set != NULL); 5808 5809 set->num_feastol = feastol; 5810 5811 /* the feasibility tolerance of the LP solver should never be larger than 5812 * numerics/lpfeastolfactor times SCIP's feasibility tolerance 5813 * if necessary, reset LP feastol 5814 */ 5815 if( lp != NULL && SCIPlpGetFeastol(lp) > set->num_lpfeastolfactor * SCIPsetFeastol(set) ) 5816 SCIPlpResetFeastol(lp, set); 5817 5818 return SCIP_OKAY; 5819 } 5820 5821 /** sets feasibility tolerance for reduced costs in LP solution */ 5822 SCIP_RETCODE SCIPsetSetDualfeastol( 5823 SCIP_SET* set, /**< global SCIP settings */ 5824 SCIP_Real dualfeastol /**< new reduced costs feasibility tolerance */ 5825 ) 5826 { 5827 assert(set != NULL); 5828 5829 set->num_dualfeastol = dualfeastol; 5830 5831 return SCIP_OKAY; 5832 } 5833 5834 /** sets LP convergence tolerance used in barrier algorithm */ 5835 SCIP_RETCODE SCIPsetSetBarrierconvtol( 5836 SCIP_SET* set, /**< global SCIP settings */ 5837 SCIP_Real barrierconvtol /**< new convergence tolerance used in barrier algorithm */ 5838 ) 5839 { 5840 assert(set != NULL); 5841 5842 set->num_barrierconvtol = barrierconvtol; 5843 5844 return SCIP_OKAY; 5845 } 5846 5847 /** sets primal feasibility tolerance for relaxations (relaxfeastol) 5848 * 5849 * @note Set to SCIP_INVALID to apply relaxation-specific feasibility tolerance only. 5850 * 5851 * @return Previous value of relaxfeastol. 5852 */ 5853 SCIP_Real SCIPsetSetRelaxfeastol( 5854 SCIP_SET* set, /**< global SCIP settings */ 5855 SCIP_Real relaxfeastol /**< new primal feasibility tolerance for relaxations, or SCIP_INVALID */ 5856 ) 5857 { 5858 SCIP_Real oldval; 5859 5860 assert(set != NULL); 5861 assert(relaxfeastol >= 0.0); 5862 5863 oldval = set->num_relaxfeastol; 5864 set->num_relaxfeastol = relaxfeastol; 5865 5866 return oldval; 5867 } 5868 5869 /** marks that some limit parameter was changed */ 5870 void SCIPsetSetLimitChanged( 5871 SCIP_SET* set /**< global SCIP settings */ 5872 ) 5873 { 5874 set->limitchanged = TRUE; 5875 5876 set->istimelimitfinite = (set->limit_time < SCIP_DEFAULT_LIMIT_TIME); 5877 } 5878 5879 /** returns the maximal number of variables priced into the LP per round */ 5880 int SCIPsetGetPriceMaxvars( 5881 SCIP_SET* set, /**< global SCIP settings */ 5882 SCIP_Bool root /**< are we at the root node? */ 5883 ) 5884 { 5885 assert(set != NULL); 5886 5887 if( root ) 5888 return set->price_maxvarsroot; 5889 else 5890 return set->price_maxvars; 5891 } 5892 5893 /** returns factor for the maximal number of cuts that can be generated per round */ 5894 SCIP_Real SCIPsetGetSepaMaxcutsGenFactor( 5895 SCIP_SET* set, /**< global SCIP settings */ 5896 SCIP_Bool root /**< are we at the root node? */ 5897 ) 5898 { 5899 assert(set != NULL); 5900 5901 if( root ) 5902 return set->sepa_maxcutsrootgenfactor; 5903 else 5904 return set->sepa_maxcutsgenfactor; 5905 } 5906 5907 /** returns the maximal number of cuts separated per round */ 5908 int SCIPsetGetSepaMaxcuts( 5909 SCIP_SET* set, /**< global SCIP settings */ 5910 SCIP_Bool root /**< are we at the root node? */ 5911 ) 5912 { 5913 assert(set != NULL); 5914 5915 if( root ) 5916 return set->sepa_maxcutsroot; 5917 else 5918 return set->sepa_maxcuts; 5919 } 5920 5921 /** returns the maximal ratio between coefficients to ensure in rowprep cleanup */ 5922 SCIP_Real SCIPsetGetSepaMaxCoefRatioRowprep( 5923 SCIP_SET* set /**< global SCIP settings */ 5924 ) 5925 { 5926 SCIP_Real maxcoefrange; 5927 5928 maxcoefrange = set->sepa_maxcoefratiofacrowprep / set->num_feastol; 5929 if( maxcoefrange < 1.0 ) 5930 maxcoefrange = 1.0; 5931 5932 return maxcoefrange; 5933 } 5934 5935 /** returns user defined objective value (in original space) for reference purposes */ 5936 SCIP_Real SCIPsetGetReferencevalue( 5937 SCIP_SET* set /**< global SCIP settings */ 5938 ) 5939 { 5940 assert(NULL != set); 5941 5942 return set->misc_referencevalue; 5943 } 5944 5945 5946 /** returns debug solution data */ 5947 SCIP_DEBUGSOLDATA* SCIPsetGetDebugSolData( 5948 SCIP_SET* set /**< global SCIP settings */ 5949 ) 5950 { 5951 assert(set != NULL); 5952 5953 return set->debugsoldata; 5954 } 5955 5956 5957 /* 5958 * simple functions implemented as defines 5959 */ 5960 5961 /* In debug mode, the following methods are implemented as function calls to ensure 5962 * type validity. 5963 * In optimized mode, the methods are implemented as defines to improve performance. 5964 * However, we want to have them in the library anyways, so we have to undef the defines. 5965 */ 5966 5967 #undef SCIPsetInfinity 5968 #undef SCIPsetEpsilon 5969 #undef SCIPsetSumepsilon 5970 #undef SCIPsetFeastol 5971 #undef SCIPsetDualfeastol 5972 #undef SCIPsetBarrierconvtol 5973 #undef SCIPsetPseudocosteps 5974 #undef SCIPsetPseudocostdelta 5975 #undef SCIPsetCutoffbounddelta 5976 #undef SCIPsetLPFeastolFactor 5977 #undef SCIPsetRelaxfeastol 5978 #undef SCIPsetRecompfac 5979 #undef SCIPsetIsEQ 5980 #undef SCIPsetIsLT 5981 #undef SCIPsetIsLE 5982 #undef SCIPsetIsGT 5983 #undef SCIPsetIsGE 5984 #undef SCIPsetIsInfinity 5985 #undef SCIPsetIsZero 5986 #undef SCIPsetIsPositive 5987 #undef SCIPsetIsNegative 5988 #undef SCIPsetIsIntegral 5989 #undef SCIPsetIsScalingIntegral 5990 #undef SCIPsetIsFracIntegral 5991 #undef SCIPsetFloor 5992 #undef SCIPsetCeil 5993 #undef SCIPsetRound 5994 #undef SCIPsetFrac 5995 #undef SCIPsetIsSumEQ 5996 #undef SCIPsetIsSumLT 5997 #undef SCIPsetIsSumLE 5998 #undef SCIPsetIsSumGT 5999 #undef SCIPsetIsSumGE 6000 #undef SCIPsetIsSumZero 6001 #undef SCIPsetIsSumPositive 6002 #undef SCIPsetIsSumNegative 6003 #undef SCIPsetSumFloor 6004 #undef SCIPsetSumCeil 6005 #undef SCIPsetSumRound 6006 #undef SCIPsetSumFrac 6007 #undef SCIPsetIsFeasEQ 6008 #undef SCIPsetIsFeasLT 6009 #undef SCIPsetIsFeasLE 6010 #undef SCIPsetIsFeasGT 6011 #undef SCIPsetIsFeasGE 6012 #undef SCIPsetIsFeasZero 6013 #undef SCIPsetIsFeasPositive 6014 #undef SCIPsetIsFeasNegative 6015 #undef SCIPsetIsFeasIntegral 6016 #undef SCIPsetIsFeasFracIntegral 6017 #undef SCIPsetFeasFloor 6018 #undef SCIPsetFeasCeil 6019 #undef SCIPsetFeasRound 6020 #undef SCIPsetFeasFrac 6021 #undef SCIPsetIsDualfeasEQ 6022 #undef SCIPsetIsDualfeasLT 6023 #undef SCIPsetIsDualfeasLE 6024 #undef SCIPsetIsDualfeasGT 6025 #undef SCIPsetIsDualfeasGE 6026 #undef SCIPsetIsDualfeasZero 6027 #undef SCIPsetIsDualfeasPositive 6028 #undef SCIPsetIsDualfeasNegative 6029 #undef SCIPsetIsDualfeasIntegral 6030 #undef SCIPsetIsDualfeasFracIntegral 6031 #undef SCIPsetDualfeasFloor 6032 #undef SCIPsetDualfeasCeil 6033 #undef SCIPsetDualfeasRound 6034 #undef SCIPsetDualfeasFrac 6035 #undef SCIPsetIsLbBetter 6036 #undef SCIPsetIsUbBetter 6037 #undef SCIPsetIsEfficacious 6038 #undef SCIPsetIsRelEQ 6039 #undef SCIPsetIsRelLT 6040 #undef SCIPsetIsRelLE 6041 #undef SCIPsetIsRelGT 6042 #undef SCIPsetIsRelGE 6043 #undef SCIPsetIsSumRelEQ 6044 #undef SCIPsetIsSumRelLT 6045 #undef SCIPsetIsSumRelLE 6046 #undef SCIPsetIsSumRelGT 6047 #undef SCIPsetIsSumRelGE 6048 #undef SCIPsetIsUpdateUnreliable 6049 #undef SCIPsetInitializeRandomSeed 6050 #undef SCIPsetIsHugeValue 6051 #undef SCIPsetGetHugeValue 6052 #undef SCIPsetGetSubscipsOff 6053 6054 /** returns value treated as infinity */ 6055 SCIP_Real SCIPsetInfinity( 6056 SCIP_SET* set /**< global SCIP settings */ 6057 ) 6058 { 6059 assert(set != NULL); 6060 6061 return set->num_infinity; 6062 } 6063 6064 /** returns the minimum value that is regarded as huge and should be handled separately (e.g., in activity 6065 * computation) 6066 */ 6067 SCIP_Real SCIPsetGetHugeValue( 6068 SCIP_SET* set /**< global SCIP settings */ 6069 ) 6070 { 6071 assert(set != NULL); 6072 6073 return set->num_hugeval; 6074 } 6075 6076 /** returns value treated as zero */ 6077 SCIP_Real SCIPsetEpsilon( 6078 SCIP_SET* set /**< global SCIP settings */ 6079 ) 6080 { 6081 assert(set != NULL); 6082 6083 return set->num_epsilon; 6084 } 6085 6086 /** returns value treated as zero for sums of floating point values */ 6087 SCIP_Real SCIPsetSumepsilon( 6088 SCIP_SET* set /**< global SCIP settings */ 6089 ) 6090 { 6091 assert(set != NULL); 6092 6093 return set->num_sumepsilon; 6094 } 6095 6096 /** returns feasibility tolerance for constraints */ 6097 SCIP_Real SCIPsetFeastol( 6098 SCIP_SET* set /**< global SCIP settings */ 6099 ) 6100 { 6101 assert(set != NULL); 6102 6103 return set->num_feastol; 6104 } 6105 6106 /** returns feasibility tolerance for reduced costs */ 6107 SCIP_Real SCIPsetDualfeastol( 6108 SCIP_SET* set /**< global SCIP settings */ 6109 ) 6110 { 6111 assert(set != NULL); 6112 6113 return set->num_dualfeastol; 6114 } 6115 6116 /** returns factor w.r.t. primal feasibility tolerance that determines default (and maximal) feasibility tolerance */ 6117 SCIP_Real SCIPsetLPFeastolFactor( 6118 SCIP_SET* set /**< global SCIP settings */ 6119 ) 6120 { 6121 return set->num_lpfeastolfactor; 6122 } 6123 6124 /** returns convergence tolerance used in barrier algorithm */ 6125 SCIP_Real SCIPsetBarrierconvtol( 6126 SCIP_SET* set /**< global SCIP settings */ 6127 ) 6128 { 6129 assert(set != NULL); 6130 6131 return set->num_barrierconvtol; 6132 } 6133 6134 /** returns minimal variable distance value to use for pseudo cost updates */ 6135 SCIP_Real SCIPsetPseudocosteps( 6136 SCIP_SET* set /**< global SCIP settings */ 6137 ) 6138 { 6139 assert(set != NULL); 6140 6141 return set->num_pseudocosteps; 6142 } 6143 6144 /** returns minimal minimal objective distance value to use for pseudo cost updates */ 6145 SCIP_Real SCIPsetPseudocostdelta( 6146 SCIP_SET* set /**< global SCIP settings */ 6147 ) 6148 { 6149 assert(set != NULL); 6150 6151 return set->num_pseudocostdelta; 6152 } 6153 6154 /** return the delta to use for computing the cutoff bound for integral objectives */ 6155 SCIP_Real SCIPsetCutoffbounddelta( 6156 SCIP_SET* set /**< global SCIP settings */ 6157 ) 6158 { 6159 SCIP_Real feastol; 6160 6161 assert(set != NULL); 6162 6163 feastol = SCIPsetFeastol(set); 6164 6165 return MIN(100.0 * feastol, 0.0001); 6166 } 6167 6168 /** return the primal feasibility tolerance for relaxations */ 6169 SCIP_Real SCIPsetRelaxfeastol( 6170 SCIP_SET* set /**< global SCIP settings */ 6171 ) 6172 { 6173 assert(set != NULL); 6174 6175 return set->num_relaxfeastol; 6176 } 6177 6178 /** returns minimal decrease factor that causes the recomputation of a value 6179 * (e.g., pseudo objective) instead of an update */ 6180 SCIP_Real SCIPsetRecompfac( 6181 SCIP_SET* set /**< global SCIP settings */ 6182 ) 6183 { 6184 assert(set != NULL); 6185 6186 return set->num_recompfac; 6187 } 6188 6189 /** checks, if value is (positive) infinite */ 6190 SCIP_Bool SCIPsetIsInfinity( 6191 SCIP_SET* set, /**< global SCIP settings */ 6192 SCIP_Real val /**< value to be compared against infinity */ 6193 ) 6194 { 6195 assert(set != NULL); 6196 6197 return (val >= set->num_infinity); 6198 } 6199 6200 /** checks, if value is huge and should be handled separately (e.g., in activity computation) */ 6201 SCIP_Bool SCIPsetIsHugeValue( 6202 SCIP_SET* set, /**< global SCIP settings */ 6203 SCIP_Real val /**< value to be checked whether it is huge */ 6204 ) 6205 { 6206 assert(set != NULL); 6207 6208 return (val >= set->num_hugeval); 6209 } 6210 6211 /** checks, if values are in range of epsilon */ 6212 SCIP_Bool SCIPsetIsEQ( 6213 SCIP_SET* set, /**< global SCIP settings */ 6214 SCIP_Real val1, /**< first value to be compared */ 6215 SCIP_Real val2 /**< second value to be compared */ 6216 ) 6217 { 6218 assert(set != NULL); 6219 6220 /* avoid to compare two different infinities; the reason for that is 6221 * that such a comparison can lead to unexpected results */ 6222 assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2)) 6223 && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2))) 6224 || val1 == val2 ); /*lint !e777*/ 6225 6226 return EPSEQ(val1, val2, set->num_epsilon); 6227 } 6228 6229 /** checks, if val1 is (more than epsilon) lower than val2 */ 6230 SCIP_Bool SCIPsetIsLT( 6231 SCIP_SET* set, /**< global SCIP settings */ 6232 SCIP_Real val1, /**< first value to be compared */ 6233 SCIP_Real val2 /**< second value to be compared */ 6234 ) 6235 { 6236 assert(set != NULL); 6237 6238 /* avoid to compare two different infinities; the reason for that is 6239 * that such a comparison can lead to unexpected results */ 6240 assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2)) 6241 && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2))) 6242 || val1 == val2 ); /*lint !e777*/ 6243 6244 return EPSLT(val1, val2, set->num_epsilon); 6245 } 6246 6247 /** checks, if val1 is not (more than epsilon) greater than val2 */ 6248 SCIP_Bool SCIPsetIsLE( 6249 SCIP_SET* set, /**< global SCIP settings */ 6250 SCIP_Real val1, /**< first value to be compared */ 6251 SCIP_Real val2 /**< second value to be compared */ 6252 ) 6253 { 6254 assert(set != NULL); 6255 6256 /* avoid to compare two different infinities; the reason for that is 6257 * that such a comparison can lead to unexpected results */ 6258 assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2)) 6259 && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2))) 6260 || val1 == val2 ); /*lint !e777*/ 6261 6262 return EPSLE(val1, val2, set->num_epsilon); 6263 } 6264 6265 /** checks, if val1 is (more than epsilon) greater than val2 */ 6266 SCIP_Bool SCIPsetIsGT( 6267 SCIP_SET* set, /**< global SCIP settings */ 6268 SCIP_Real val1, /**< first value to be compared */ 6269 SCIP_Real val2 /**< second value to be compared */ 6270 ) 6271 { 6272 assert(set != NULL); 6273 6274 /* avoid to compare two different infinities; the reason for that is 6275 * that such a comparison can lead to unexpected results */ 6276 assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2)) 6277 && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2))) 6278 || val1 == val2 ); /*lint !e777*/ 6279 6280 return EPSGT(val1, val2, set->num_epsilon); 6281 } 6282 6283 /** checks, if val1 is not (more than epsilon) lower than val2 */ 6284 SCIP_Bool SCIPsetIsGE( 6285 SCIP_SET* set, /**< global SCIP settings */ 6286 SCIP_Real val1, /**< first value to be compared */ 6287 SCIP_Real val2 /**< second value to be compared */ 6288 ) 6289 { 6290 assert(set != NULL); 6291 6292 /* avoid to compare two different infinities; the reason for that is 6293 * that such a comparison can lead to unexpected results */ 6294 assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2)) 6295 && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2))) 6296 || val1 == val2 ); /*lint !e777*/ 6297 6298 return EPSGE(val1, val2, set->num_epsilon); 6299 } 6300 6301 /** checks, if value is in range epsilon of 0.0 */ 6302 SCIP_Bool SCIPsetIsZero( 6303 SCIP_SET* set, /**< global SCIP settings */ 6304 SCIP_Real val /**< value to process */ 6305 ) 6306 { 6307 assert(set != NULL); 6308 6309 return EPSZ(val, set->num_epsilon); 6310 } 6311 6312 /** checks, if value is greater than epsilon */ 6313 SCIP_Bool SCIPsetIsPositive( 6314 SCIP_SET* set, /**< global SCIP settings */ 6315 SCIP_Real val /**< value to process */ 6316 ) 6317 { 6318 assert(set != NULL); 6319 6320 return EPSP(val, set->num_epsilon); 6321 } 6322 6323 /** checks, if value is lower than -epsilon */ 6324 SCIP_Bool SCIPsetIsNegative( 6325 SCIP_SET* set, /**< global SCIP settings */ 6326 SCIP_Real val /**< value to process */ 6327 ) 6328 { 6329 assert(set != NULL); 6330 6331 return EPSN(val, set->num_epsilon); 6332 } 6333 6334 /** checks, if value is integral within epsilon */ 6335 SCIP_Bool SCIPsetIsIntegral( 6336 SCIP_SET* set, /**< global SCIP settings */ 6337 SCIP_Real val /**< value to process */ 6338 ) 6339 { 6340 assert(set != NULL); 6341 6342 return EPSISINT(val, set->num_epsilon); 6343 } 6344 6345 /** checks whether the product val * scalar is integral in epsilon scaled by scalar */ 6346 SCIP_Bool SCIPsetIsScalingIntegral( 6347 SCIP_SET* set, /**< global SCIP settings */ 6348 SCIP_Real val, /**< unscaled value to check for scaled integrality */ 6349 SCIP_Real scalar /**< value to scale val with for checking for integrality */ 6350 ) 6351 { 6352 SCIP_Real scaledeps; 6353 6354 assert(set != NULL); 6355 6356 scaledeps = REALABS(scalar); 6357 scaledeps = MAX(scaledeps, 1.0); 6358 scaledeps *= set->num_epsilon; 6359 6360 return EPSISINT(scalar*val, scaledeps); 6361 } 6362 6363 /** checks, if given fractional part is smaller than epsilon */ 6364 SCIP_Bool SCIPsetIsFracIntegral( 6365 SCIP_SET* set, /**< global SCIP settings */ 6366 SCIP_Real val /**< value to process */ 6367 ) 6368 { 6369 assert(set != NULL); 6370 assert(SCIPsetIsGE(set, val, -set->num_epsilon)); 6371 assert(SCIPsetIsLE(set, val, 1.0+set->num_epsilon)); 6372 6373 return (val <= set->num_epsilon); 6374 } 6375 6376 /** rounds value + feasibility tolerance down to the next integer in epsilon tolerance */ 6377 SCIP_Real SCIPsetFloor( 6378 SCIP_SET* set, /**< global SCIP settings */ 6379 SCIP_Real val /**< value to process */ 6380 ) 6381 { 6382 assert(set != NULL); 6383 6384 return EPSFLOOR(val, set->num_epsilon); 6385 } 6386 6387 /** rounds value - feasibility tolerance up to the next integer in epsilon tolerance */ 6388 SCIP_Real SCIPsetCeil( 6389 SCIP_SET* set, /**< global SCIP settings */ 6390 SCIP_Real val /**< value to process */ 6391 ) 6392 { 6393 assert(set != NULL); 6394 6395 return EPSCEIL(val, set->num_epsilon); 6396 } 6397 6398 /** rounds value to the nearest integer in epsilon tolerance */ 6399 SCIP_Real SCIPsetRound( 6400 SCIP_SET* set, /**< global SCIP settings */ 6401 SCIP_Real val /**< value to process */ 6402 ) 6403 { 6404 assert(set != NULL); 6405 6406 return EPSROUND(val, set->num_epsilon); 6407 } 6408 6409 /** returns fractional part of value, i.e. x - floor(x) in epsilon tolerance */ 6410 SCIP_Real SCIPsetFrac( 6411 SCIP_SET* set, /**< global SCIP settings */ 6412 SCIP_Real val /**< value to return fractional part for */ 6413 ) 6414 { 6415 assert(set != NULL); 6416 6417 return EPSFRAC(val, set->num_epsilon); 6418 } 6419 6420 /** checks, if values are in range of sumepsilon */ 6421 SCIP_Bool SCIPsetIsSumEQ( 6422 SCIP_SET* set, /**< global SCIP settings */ 6423 SCIP_Real val1, /**< first value to be compared */ 6424 SCIP_Real val2 /**< second value to be compared */ 6425 ) 6426 { 6427 assert(set != NULL); 6428 6429 /* avoid to compare two different infinities; the reason for that is 6430 * that such a comparison can lead to unexpected results */ 6431 assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2)) 6432 && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2))) 6433 || val1 == val2 ); /*lint !e777*/ 6434 6435 return EPSEQ(val1, val2, set->num_sumepsilon); 6436 } 6437 6438 /** checks, if val1 is (more than sumepsilon) lower than val2 */ 6439 SCIP_Bool SCIPsetIsSumLT( 6440 SCIP_SET* set, /**< global SCIP settings */ 6441 SCIP_Real val1, /**< first value to be compared */ 6442 SCIP_Real val2 /**< second value to be compared */ 6443 ) 6444 { 6445 assert(set != NULL); 6446 6447 /* avoid to compare two different infinities; the reason for that is 6448 * that such a comparison can lead to unexpected results */ 6449 assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2)) 6450 && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2))) 6451 || val1 == val2 ); /*lint !e777*/ 6452 6453 return EPSLT(val1, val2, set->num_sumepsilon); 6454 } 6455 6456 /** checks, if val1 is not (more than sumepsilon) greater than val2 */ 6457 SCIP_Bool SCIPsetIsSumLE( 6458 SCIP_SET* set, /**< global SCIP settings */ 6459 SCIP_Real val1, /**< first value to be compared */ 6460 SCIP_Real val2 /**< second value to be compared */ 6461 ) 6462 { 6463 assert(set != NULL); 6464 6465 /* avoid to compare two different infinities; the reason for that is 6466 * that such a comparison can lead to unexpected results */ 6467 assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2)) 6468 && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2))) 6469 || val1 == val2 ); /*lint !e777*/ 6470 6471 return EPSLE(val1, val2, set->num_sumepsilon); 6472 } 6473 6474 /** checks, if val1 is (more than sumepsilon) greater than val2 */ 6475 SCIP_Bool SCIPsetIsSumGT( 6476 SCIP_SET* set, /**< global SCIP settings */ 6477 SCIP_Real val1, /**< first value to be compared */ 6478 SCIP_Real val2 /**< second value to be compared */ 6479 ) 6480 { 6481 assert(set != NULL); 6482 6483 /* avoid to compare two different infinities; the reason for that is 6484 * that such a comparison can lead to unexpected results */ 6485 assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2)) 6486 && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2))) 6487 || val1 == val2 ); /*lint !e777*/ 6488 6489 return EPSGT(val1, val2, set->num_sumepsilon); 6490 } 6491 6492 /** checks, if val1 is not (more than sumepsilon) lower than val2 */ 6493 SCIP_Bool SCIPsetIsSumGE( 6494 SCIP_SET* set, /**< global SCIP settings */ 6495 SCIP_Real val1, /**< first value to be compared */ 6496 SCIP_Real val2 /**< second value to be compared */ 6497 ) 6498 { 6499 assert(set != NULL); 6500 6501 /* avoid to compare two different infinities; the reason for that is 6502 * that such a comparison can lead to unexpected results */ 6503 assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2)) 6504 && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2))) 6505 || val1 == val2 ); /*lint !e777*/ 6506 6507 return EPSGE(val1, val2, set->num_sumepsilon); 6508 } 6509 6510 /** checks, if value is in range sumepsilon of 0.0 */ 6511 SCIP_Bool SCIPsetIsSumZero( 6512 SCIP_SET* set, /**< global SCIP settings */ 6513 SCIP_Real val /**< value to process */ 6514 ) 6515 { 6516 assert(set != NULL); 6517 6518 return EPSZ(val, set->num_sumepsilon); 6519 } 6520 6521 /** checks, if value is greater than sumepsilon */ 6522 SCIP_Bool SCIPsetIsSumPositive( 6523 SCIP_SET* set, /**< global SCIP settings */ 6524 SCIP_Real val /**< value to process */ 6525 ) 6526 { 6527 assert(set != NULL); 6528 6529 return EPSP(val, set->num_sumepsilon); 6530 } 6531 6532 /** checks, if value is lower than -sumepsilon */ 6533 SCIP_Bool SCIPsetIsSumNegative( 6534 SCIP_SET* set, /**< global SCIP settings */ 6535 SCIP_Real val /**< value to process */ 6536 ) 6537 { 6538 assert(set != NULL); 6539 6540 return EPSN(val, set->num_sumepsilon); 6541 } 6542 6543 /** rounds value + sumepsilon tolerance down to the next integer */ 6544 SCIP_Real SCIPsetSumFloor( 6545 SCIP_SET* set, /**< global SCIP settings */ 6546 SCIP_Real val /**< value to process */ 6547 ) 6548 { 6549 assert(set != NULL); 6550 6551 return EPSFLOOR(val, set->num_sumepsilon); 6552 } 6553 6554 /** rounds value - sumepsilon tolerance up to the next integer */ 6555 SCIP_Real SCIPsetSumCeil( 6556 SCIP_SET* set, /**< global SCIP settings */ 6557 SCIP_Real val /**< value to process */ 6558 ) 6559 { 6560 assert(set != NULL); 6561 6562 return EPSCEIL(val, set->num_sumepsilon); 6563 } 6564 6565 /** rounds value to the nearest integer in sumepsilon tolerance */ 6566 SCIP_Real SCIPsetSumRound( 6567 SCIP_SET* set, /**< global SCIP settings */ 6568 SCIP_Real val /**< value to process */ 6569 ) 6570 { 6571 assert(set != NULL); 6572 6573 return EPSROUND(val, set->num_sumepsilon); 6574 } 6575 6576 /** returns fractional part of value, i.e. x - floor(x) in sumepsilon tolerance */ 6577 SCIP_Real SCIPsetSumFrac( 6578 SCIP_SET* set, /**< global SCIP settings */ 6579 SCIP_Real val /**< value to process */ 6580 ) 6581 { 6582 assert(set != NULL); 6583 6584 return EPSFRAC(val, set->num_sumepsilon); 6585 } 6586 6587 /** checks, if relative difference of values is in range of feastol */ 6588 SCIP_Bool SCIPsetIsFeasEQ( 6589 SCIP_SET* set, /**< global SCIP settings */ 6590 SCIP_Real val1, /**< first value to be compared */ 6591 SCIP_Real val2 /**< second value to be compared */ 6592 ) 6593 { 6594 SCIP_Real diff; 6595 6596 assert(set != NULL); 6597 6598 /* avoid to compare two different infinities; the reason for that is 6599 * that such a comparison can lead to unexpected results */ 6600 assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2)) 6601 && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2))) 6602 || val1 == val2 ); /*lint !e777*/ 6603 6604 diff = SCIPrelDiff(val1, val2); 6605 6606 return EPSZ(diff, set->num_feastol); 6607 } 6608 6609 /** checks, if relative difference of val1 and val2 is lower than feastol */ 6610 SCIP_Bool SCIPsetIsFeasLT( 6611 SCIP_SET* set, /**< global SCIP settings */ 6612 SCIP_Real val1, /**< first value to be compared */ 6613 SCIP_Real val2 /**< second value to be compared */ 6614 ) 6615 { 6616 SCIP_Real diff; 6617 6618 assert(set != NULL); 6619 6620 /* avoid to compare two different infinities; the reason for that is 6621 * that such a comparison can lead to unexpected results */ 6622 assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2)) 6623 && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2))) 6624 || val1 == val2 ); /*lint !e777*/ 6625 6626 diff = SCIPrelDiff(val1, val2); 6627 6628 return EPSN(diff, set->num_feastol); 6629 } 6630 6631 /** checks, if relative difference of val1 and val2 is not greater than feastol */ 6632 SCIP_Bool SCIPsetIsFeasLE( 6633 SCIP_SET* set, /**< global SCIP settings */ 6634 SCIP_Real val1, /**< first value to be compared */ 6635 SCIP_Real val2 /**< second value to be compared */ 6636 ) 6637 { 6638 SCIP_Real diff; 6639 6640 assert(set != NULL); 6641 6642 /* avoid to compare two different infinities; the reason for that is 6643 * that such a comparison can lead to unexpected results */ 6644 assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2)) 6645 && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2))) 6646 || val1 == val2 ); /*lint !e777*/ 6647 6648 diff = SCIPrelDiff(val1, val2); 6649 6650 return !EPSP(diff, set->num_feastol); 6651 } 6652 6653 /** checks, if relative difference of val1 and val2 is greater than feastol */ 6654 SCIP_Bool SCIPsetIsFeasGT( 6655 SCIP_SET* set, /**< global SCIP settings */ 6656 SCIP_Real val1, /**< first value to be compared */ 6657 SCIP_Real val2 /**< second value to be compared */ 6658 ) 6659 { 6660 SCIP_Real diff; 6661 6662 assert(set != NULL); 6663 6664 /* avoid to compare two different infinities; the reason for that is 6665 * that such a comparison can lead to unexpected results */ 6666 assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2)) 6667 && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2))) 6668 || val1 == val2 ); /*lint !e777*/ 6669 6670 diff = SCIPrelDiff(val1, val2); 6671 6672 return EPSP(diff, set->num_feastol); 6673 } 6674 6675 /** checks, if relative difference of val1 and val2 is not lower than -feastol */ 6676 SCIP_Bool SCIPsetIsFeasGE( 6677 SCIP_SET* set, /**< global SCIP settings */ 6678 SCIP_Real val1, /**< first value to be compared */ 6679 SCIP_Real val2 /**< second value to be compared */ 6680 ) 6681 { 6682 SCIP_Real diff; 6683 6684 assert(set != NULL); 6685 6686 /* avoid to compare two different infinities; the reason for that is 6687 * that such a comparison can lead to unexpected results */ 6688 assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2)) 6689 && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2))) 6690 || val1 == val2 ); /*lint !e777*/ 6691 6692 diff = SCIPrelDiff(val1, val2); 6693 6694 return !EPSN(diff, set->num_feastol); 6695 } 6696 6697 /** checks, if value is in range feasibility tolerance of 0.0 */ 6698 SCIP_Bool SCIPsetIsFeasZero( 6699 SCIP_SET* set, /**< global SCIP settings */ 6700 SCIP_Real val /**< value to process */ 6701 ) 6702 { 6703 assert(set != NULL); 6704 6705 return EPSZ(val, set->num_feastol); 6706 } 6707 6708 /** checks, if value is greater than feasibility tolerance */ 6709 SCIP_Bool SCIPsetIsFeasPositive( 6710 SCIP_SET* set, /**< global SCIP settings */ 6711 SCIP_Real val /**< value to process */ 6712 ) 6713 { 6714 assert(set != NULL); 6715 6716 return EPSP(val, set->num_feastol); 6717 } 6718 6719 /** checks, if value is lower than -feasibility tolerance */ 6720 SCIP_Bool SCIPsetIsFeasNegative( 6721 SCIP_SET* set, /**< global SCIP settings */ 6722 SCIP_Real val /**< value to process */ 6723 ) 6724 { 6725 assert(set != NULL); 6726 6727 return EPSN(val, set->num_feastol); 6728 } 6729 6730 /** checks, if value is integral within the feasibility bounds */ 6731 SCIP_Bool SCIPsetIsFeasIntegral( 6732 SCIP_SET* set, /**< global SCIP settings */ 6733 SCIP_Real val /**< value to process */ 6734 ) 6735 { 6736 assert(set != NULL); 6737 6738 return EPSISINT(val, set->num_feastol); 6739 } 6740 6741 /** checks, if given fractional part is smaller than feastol */ 6742 SCIP_Bool SCIPsetIsFeasFracIntegral( 6743 SCIP_SET* set, /**< global SCIP settings */ 6744 SCIP_Real val /**< value to process */ 6745 ) 6746 { 6747 assert(set != NULL); 6748 assert(SCIPsetIsGE(set, val, -2*set->num_feastol)); 6749 assert(SCIPsetIsLE(set, val, 1.0+set->num_feastol)); 6750 6751 return (val <= set->num_feastol); 6752 } 6753 6754 /** rounds value + feasibility tolerance down to the next integer in feasibility tolerance */ 6755 SCIP_Real SCIPsetFeasFloor( 6756 SCIP_SET* set, /**< global SCIP settings */ 6757 SCIP_Real val /**< value to process */ 6758 ) 6759 { 6760 assert(set != NULL); 6761 6762 return EPSFLOOR(val, set->num_feastol); 6763 } 6764 6765 /** rounds value - feasibility tolerance up to the next integer in feasibility tolerance */ 6766 SCIP_Real SCIPsetFeasCeil( 6767 SCIP_SET* set, /**< global SCIP settings */ 6768 SCIP_Real val /**< value to process */ 6769 ) 6770 { 6771 assert(set != NULL); 6772 6773 return EPSCEIL(val, set->num_feastol); 6774 } 6775 6776 /** rounds value to the nearest integer in feasibility tolerance */ 6777 SCIP_Real SCIPsetFeasRound( 6778 SCIP_SET* set, /**< global SCIP settings */ 6779 SCIP_Real val /**< value to process */ 6780 ) 6781 { 6782 assert(set != NULL); 6783 6784 return EPSROUND(val, set->num_feastol); 6785 } 6786 6787 /** returns fractional part of value, i.e. x - floor(x) in feasibility tolerance */ 6788 SCIP_Real SCIPsetFeasFrac( 6789 SCIP_SET* set, /**< global SCIP settings */ 6790 SCIP_Real val /**< value to process */ 6791 ) 6792 { 6793 assert(set != NULL); 6794 6795 return EPSFRAC(val, set->num_feastol); 6796 } 6797 6798 /** checks, if relative difference of values is in range of dual feasibility tolerance */ 6799 SCIP_Bool SCIPsetIsDualfeasEQ( 6800 SCIP_SET* set, /**< global SCIP settings */ 6801 SCIP_Real val1, /**< first value to be compared */ 6802 SCIP_Real val2 /**< second value to be compared */ 6803 ) 6804 { 6805 SCIP_Real diff; 6806 6807 assert(set != NULL); 6808 6809 /* avoid to compare two different infinities; the reason for that is 6810 * that such a comparison can lead to unexpected results */ 6811 assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2)) 6812 && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2))) 6813 || val1 == val2 ); /*lint !e777*/ 6814 6815 diff = SCIPrelDiff(val1, val2); 6816 6817 return EPSZ(diff, set->num_dualfeastol); 6818 } 6819 6820 /** checks, if relative difference of val1 and val2 is lower than dual feasibility tolerance */ 6821 SCIP_Bool SCIPsetIsDualfeasLT( 6822 SCIP_SET* set, /**< global SCIP settings */ 6823 SCIP_Real val1, /**< first value to be compared */ 6824 SCIP_Real val2 /**< second value to be compared */ 6825 ) 6826 { 6827 SCIP_Real diff; 6828 6829 assert(set != NULL); 6830 6831 /* avoid to compare two different infinities; the reason for that is 6832 * that such a comparison can lead to unexpected results */ 6833 assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2)) 6834 && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2))) 6835 || val1 == val2 ); /*lint !e777*/ 6836 6837 diff = SCIPrelDiff(val1, val2); 6838 6839 return EPSN(diff, set->num_dualfeastol); 6840 } 6841 6842 /** checks, if relative difference of val1 and val2 is not greater than dual feasibility tolerance */ 6843 SCIP_Bool SCIPsetIsDualfeasLE( 6844 SCIP_SET* set, /**< global SCIP settings */ 6845 SCIP_Real val1, /**< first value to be compared */ 6846 SCIP_Real val2 /**< second value to be compared */ 6847 ) 6848 { 6849 SCIP_Real diff; 6850 6851 assert(set != NULL); 6852 6853 /* avoid to compare two different infinities; the reason for that is 6854 * that such a comparison can lead to unexpected results */ 6855 assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2)) 6856 && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2))) 6857 || val1 == val2 ); /*lint !e777*/ 6858 6859 diff = SCIPrelDiff(val1, val2); 6860 6861 return !EPSP(diff, set->num_dualfeastol); 6862 } 6863 6864 /** checks, if relative difference of val1 and val2 is greater than dual feasibility tolerance */ 6865 SCIP_Bool SCIPsetIsDualfeasGT( 6866 SCIP_SET* set, /**< global SCIP settings */ 6867 SCIP_Real val1, /**< first value to be compared */ 6868 SCIP_Real val2 /**< second value to be compared */ 6869 ) 6870 { 6871 SCIP_Real diff; 6872 6873 assert(set != NULL); 6874 6875 /* avoid to compare two different infinities; the reason for that is 6876 * that such a comparison can lead to unexpected results */ 6877 assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2)) 6878 && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2))) 6879 || val1 == val2 ); /*lint !e777*/ 6880 6881 diff = SCIPrelDiff(val1, val2); 6882 6883 return EPSP(diff, set->num_dualfeastol); 6884 } 6885 6886 /** checks, if relative difference of val1 and val2 is not lower than -dual feasibility tolerance */ 6887 SCIP_Bool SCIPsetIsDualfeasGE( 6888 SCIP_SET* set, /**< global SCIP settings */ 6889 SCIP_Real val1, /**< first value to be compared */ 6890 SCIP_Real val2 /**< second value to be compared */ 6891 ) 6892 { 6893 SCIP_Real diff; 6894 6895 assert(set != NULL); 6896 6897 /* avoid to compare two different infinities; the reason for that is 6898 * that such a comparison can lead to unexpected results */ 6899 assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2)) 6900 && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2))) 6901 || val1 == val2 ); /*lint !e777*/ 6902 6903 diff = SCIPrelDiff(val1, val2); 6904 6905 return !EPSN(diff, set->num_dualfeastol); 6906 } 6907 6908 /** checks, if value is in range feasibility tolerance of 0.0 */ 6909 SCIP_Bool SCIPsetIsDualfeasZero( 6910 SCIP_SET* set, /**< global SCIP settings */ 6911 SCIP_Real val /**< value to process */ 6912 ) 6913 { 6914 assert(set != NULL); 6915 6916 return EPSZ(val, set->num_dualfeastol); 6917 } 6918 6919 /** checks, if value is greater than dual feasibility tolerance */ 6920 SCIP_Bool SCIPsetIsDualfeasPositive( 6921 SCIP_SET* set, /**< global SCIP settings */ 6922 SCIP_Real val /**< value to process */ 6923 ) 6924 { 6925 assert(set != NULL); 6926 6927 return EPSP(val, set->num_dualfeastol); 6928 } 6929 6930 /** checks, if value is lower than -dual feasibility tolerance */ 6931 SCIP_Bool SCIPsetIsDualfeasNegative( 6932 SCIP_SET* set, /**< global SCIP settings */ 6933 SCIP_Real val /**< value to process */ 6934 ) 6935 { 6936 assert(set != NULL); 6937 6938 return EPSN(val, set->num_dualfeastol); 6939 } 6940 6941 /** checks, if value is integral within the dual feasibility bounds */ 6942 SCIP_Bool SCIPsetIsDualfeasIntegral( 6943 SCIP_SET* set, /**< global SCIP settings */ 6944 SCIP_Real val /**< value to process */ 6945 ) 6946 { 6947 assert(set != NULL); 6948 6949 return EPSISINT(val, set->num_dualfeastol); 6950 } 6951 6952 /** checks, if given fractional part is smaller than dual feasibility tolerance */ 6953 SCIP_Bool SCIPsetIsDualfeasFracIntegral( 6954 SCIP_SET* set, /**< global SCIP settings */ 6955 SCIP_Real val /**< value to process */ 6956 ) 6957 { 6958 assert(set != NULL); 6959 assert(SCIPsetIsGE(set, val, -set->num_dualfeastol)); 6960 assert(SCIPsetIsLE(set, val, 1.0+set->num_dualfeastol)); 6961 6962 return (val <= set->num_dualfeastol); 6963 } 6964 6965 /** rounds value + dual feasibility tolerance down to the next integer */ 6966 SCIP_Real SCIPsetDualfeasFloor( 6967 SCIP_SET* set, /**< global SCIP settings */ 6968 SCIP_Real val /**< value to process */ 6969 ) 6970 { 6971 assert(set != NULL); 6972 6973 return EPSFLOOR(val, set->num_dualfeastol); 6974 } 6975 6976 /** rounds value - dual feasibility tolerance up to the next integer */ 6977 SCIP_Real SCIPsetDualfeasCeil( 6978 SCIP_SET* set, /**< global SCIP settings */ 6979 SCIP_Real val /**< value to process */ 6980 ) 6981 { 6982 assert(set != NULL); 6983 6984 return EPSCEIL(val, set->num_dualfeastol); 6985 } 6986 6987 /** rounds value to the nearest integer in dual feasibility tolerance */ 6988 SCIP_Real SCIPsetDualfeasRound( 6989 SCIP_SET* set, /**< global SCIP settings */ 6990 SCIP_Real val /**< value to process */ 6991 ) 6992 { 6993 assert(set != NULL); 6994 6995 return EPSROUND(val, set->num_dualfeastol); 6996 } 6997 6998 /** returns fractional part of value, i.e. x - floor(x) in dual feasibility tolerance */ 6999 SCIP_Real SCIPsetDualfeasFrac( 7000 SCIP_SET* set, /**< global SCIP settings */ 7001 SCIP_Real val /**< value to process */ 7002 ) 7003 { 7004 assert(set != NULL); 7005 7006 return EPSFRAC(val, set->num_dualfeastol); 7007 } 7008 7009 /** checks, if the given new lower bound is at least min(oldub - oldlb, |oldlb|) times the bound 7010 * strengthening epsilon better than the old one or the change in the lower bound would fix the 7011 * sign of the variable 7012 */ 7013 SCIP_Bool SCIPsetIsLbBetter( 7014 SCIP_SET* set, /**< global SCIP settings */ 7015 SCIP_Real newlb, /**< new lower bound */ 7016 SCIP_Real oldlb, /**< old lower bound */ 7017 SCIP_Real oldub /**< old upper bound */ 7018 ) 7019 { 7020 assert(set != NULL); 7021 assert(SCIPsetIsLE(set, oldlb, oldub)); 7022 7023 /* if lower bound is moved to 0 or higher, always accept bound change */ 7024 if( oldlb < 0.0 && newlb >= 0.0 ) 7025 return TRUE; 7026 7027 return EPSGT(newlb, oldlb, set->num_boundstreps * MAX(MIN(oldub - oldlb, REALABS(oldlb)), 1e-3)); /*lint !e666*/ 7028 } 7029 7030 /** checks, if the given new upper bound is at least min(oldub - oldlb, |oldub|) times the bound 7031 * strengthening epsilon better than the old one or the change in the upper bound would fix the 7032 * sign of the variable 7033 */ 7034 SCIP_Bool SCIPsetIsUbBetter( 7035 SCIP_SET* set, /**< global SCIP settings */ 7036 SCIP_Real newub, /**< new upper bound */ 7037 SCIP_Real oldlb, /**< old lower bound */ 7038 SCIP_Real oldub /**< old upper bound */ 7039 ) 7040 { 7041 assert(set != NULL); 7042 assert(SCIPsetIsLE(set, oldlb, oldub)); 7043 7044 /* if upper bound is moved to 0 or lower, always accept bound change */ 7045 if( oldub > 0.0 && newub <= 0.0 ) 7046 return TRUE; 7047 7048 return EPSLT(newub, oldub, set->num_boundstreps * MAX(MIN(oldub - oldlb, REALABS(oldub)), 1e-3)); /*lint !e666*/ 7049 } 7050 7051 /** checks, if the given cut's efficacy is larger than the minimal cut efficacy */ 7052 SCIP_Bool SCIPsetIsEfficacious( 7053 SCIP_SET* set, /**< global SCIP settings */ 7054 SCIP_Bool root, /**< should the root's minimal cut efficacy be used? */ 7055 SCIP_Real efficacy /**< efficacy of the cut */ 7056 ) 7057 { 7058 assert(set != NULL); 7059 7060 if( root ) 7061 return EPSP(efficacy, set->sepa_minefficacyroot); 7062 else 7063 return EPSP(efficacy, set->sepa_minefficacy); 7064 } 7065 7066 /** checks, if relative difference of values is in range of epsilon */ 7067 SCIP_Bool SCIPsetIsRelEQ( 7068 SCIP_SET* set, /**< global SCIP settings */ 7069 SCIP_Real val1, /**< first value to be compared */ 7070 SCIP_Real val2 /**< second value to be compared */ 7071 ) 7072 { 7073 SCIP_Real diff; 7074 7075 assert(set != NULL); 7076 7077 /* avoid to compare two different infinities; the reason for that is 7078 * that such a comparison can lead to unexpected results */ 7079 assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2)) 7080 && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2))) 7081 || val1 == val2 ); /*lint !e777*/ 7082 7083 diff = SCIPrelDiff(val1, val2); 7084 7085 return EPSZ(diff, set->num_epsilon); 7086 } 7087 7088 /** checks, if relative difference of val1 and val2 is lower than epsilon */ 7089 SCIP_Bool SCIPsetIsRelLT( 7090 SCIP_SET* set, /**< global SCIP settings */ 7091 SCIP_Real val1, /**< first value to be compared */ 7092 SCIP_Real val2 /**< second value to be compared */ 7093 ) 7094 { 7095 SCIP_Real diff; 7096 7097 assert(set != NULL); 7098 7099 /* avoid to compare two different infinities; the reason for that is 7100 * that such a comparison can lead to unexpected results */ 7101 assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2)) 7102 && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2))) 7103 || val1 == val2 ); /*lint !e777*/ 7104 7105 diff = SCIPrelDiff(val1, val2); 7106 7107 return EPSN(diff, set->num_epsilon); 7108 } 7109 7110 /** checks, if relative difference of val1 and val2 is not greater than epsilon */ 7111 SCIP_Bool SCIPsetIsRelLE( 7112 SCIP_SET* set, /**< global SCIP settings */ 7113 SCIP_Real val1, /**< first value to be compared */ 7114 SCIP_Real val2 /**< second value to be compared */ 7115 ) 7116 { 7117 SCIP_Real diff; 7118 7119 assert(set != NULL); 7120 7121 /* avoid to compare two different infinities; the reason for that is 7122 * that such a comparison can lead to unexpected results */ 7123 assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2)) 7124 && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2))) 7125 || val1 == val2 ); /*lint !e777*/ 7126 7127 diff = SCIPrelDiff(val1, val2); 7128 7129 return !EPSP(diff, set->num_epsilon); 7130 } 7131 7132 /** checks, if relative difference of val1 and val2 is greater than epsilon */ 7133 SCIP_Bool SCIPsetIsRelGT( 7134 SCIP_SET* set, /**< global SCIP settings */ 7135 SCIP_Real val1, /**< first value to be compared */ 7136 SCIP_Real val2 /**< second value to be compared */ 7137 ) 7138 { 7139 SCIP_Real diff; 7140 7141 assert(set != NULL); 7142 7143 /* avoid to compare two different infinities; the reason for that is 7144 * that such a comparison can lead to unexpected results */ 7145 assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2)) 7146 && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2))) 7147 || val1 == val2 ); /*lint !e777*/ 7148 7149 diff = SCIPrelDiff(val1, val2); 7150 7151 return EPSP(diff, set->num_epsilon); 7152 } 7153 7154 /** checks, if relative difference of val1 and val2 is not lower than -epsilon */ 7155 SCIP_Bool SCIPsetIsRelGE( 7156 SCIP_SET* set, /**< global SCIP settings */ 7157 SCIP_Real val1, /**< first value to be compared */ 7158 SCIP_Real val2 /**< second value to be compared */ 7159 ) 7160 { 7161 SCIP_Real diff; 7162 7163 assert(set != NULL); 7164 7165 /* avoid to compare two different infinities; the reason for that is 7166 * that such a comparison can lead to unexpected results */ 7167 assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2)) 7168 && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2))) 7169 || val1 == val2 ); /*lint !e777*/ 7170 7171 diff = SCIPrelDiff(val1, val2); 7172 7173 return !EPSN(diff, set->num_epsilon); 7174 } 7175 7176 /** checks, if relative difference of values is in range of sumepsilon */ 7177 SCIP_Bool SCIPsetIsSumRelEQ( 7178 SCIP_SET* set, /**< global SCIP settings */ 7179 SCIP_Real val1, /**< first value to be compared */ 7180 SCIP_Real val2 /**< second value to be compared */ 7181 ) 7182 { 7183 SCIP_Real diff; 7184 7185 assert(set != NULL); 7186 7187 /* avoid to compare two different infinities; the reason for that is 7188 * that such a comparison can lead to unexpected results */ 7189 assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2)) 7190 && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2))) 7191 || val1 == val2 ); /*lint !e777*/ 7192 7193 diff = SCIPrelDiff(val1, val2); 7194 7195 return EPSZ(diff, set->num_sumepsilon); 7196 } 7197 7198 /** checks, if relative difference of val1 and val2 is lower than sumepsilon */ 7199 SCIP_Bool SCIPsetIsSumRelLT( 7200 SCIP_SET* set, /**< global SCIP settings */ 7201 SCIP_Real val1, /**< first value to be compared */ 7202 SCIP_Real val2 /**< second value to be compared */ 7203 ) 7204 { 7205 SCIP_Real diff; 7206 7207 assert(set != NULL); 7208 7209 /* avoid to compare two different infinities; the reason for that is 7210 * that such a comparison can lead to unexpected results */ 7211 assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2)) 7212 && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2))) 7213 || val1 == val2 ); /*lint !e777*/ 7214 7215 diff = SCIPrelDiff(val1, val2); 7216 7217 return EPSN(diff, set->num_sumepsilon); 7218 } 7219 7220 /** checks, if relative difference of val1 and val2 is not greater than sumepsilon */ 7221 SCIP_Bool SCIPsetIsSumRelLE( 7222 SCIP_SET* set, /**< global SCIP settings */ 7223 SCIP_Real val1, /**< first value to be compared */ 7224 SCIP_Real val2 /**< second value to be compared */ 7225 ) 7226 { 7227 SCIP_Real diff; 7228 7229 assert(set != NULL); 7230 7231 /* avoid to compare two different infinities; the reason for that is 7232 * that such a comparison can lead to unexpected results */ 7233 assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2)) 7234 && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2))) 7235 || val1 == val2 ); /*lint !e777*/ 7236 7237 diff = SCIPrelDiff(val1, val2); 7238 7239 return !EPSP(diff, set->num_sumepsilon); 7240 } 7241 7242 /** checks, if relative difference of val1 and val2 is greater than sumepsilon */ 7243 SCIP_Bool SCIPsetIsSumRelGT( 7244 SCIP_SET* set, /**< global SCIP settings */ 7245 SCIP_Real val1, /**< first value to be compared */ 7246 SCIP_Real val2 /**< second value to be compared */ 7247 ) 7248 { 7249 SCIP_Real diff; 7250 7251 assert(set != NULL); 7252 7253 /* avoid to compare two different infinities; the reason for that is 7254 * that such a comparison can lead to unexpected results */ 7255 assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2)) 7256 && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2))) 7257 || val1 == val2 ); /*lint !e777*/ 7258 7259 diff = SCIPrelDiff(val1, val2); 7260 7261 return EPSP(diff, set->num_sumepsilon); 7262 } 7263 7264 /** checks, if relative difference of val1 and val2 is not lower than -sumepsilon */ 7265 SCIP_Bool SCIPsetIsSumRelGE( 7266 SCIP_SET* set, /**< global SCIP settings */ 7267 SCIP_Real val1, /**< first value to be compared */ 7268 SCIP_Real val2 /**< second value to be compared */ 7269 ) 7270 { 7271 SCIP_Real diff; 7272 7273 assert(set != NULL); 7274 7275 /* avoid to compare two different infinities; the reason for that is 7276 * that such a comparison can lead to unexpected results */ 7277 assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2)) 7278 && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2))) 7279 || val1 == val2 ); /*lint !e777*/ 7280 7281 diff = SCIPrelDiff(val1, val2); 7282 7283 return !EPSN(diff, set->num_sumepsilon); 7284 } 7285 7286 /** returns the flag indicating whether sub-SCIPs that could cause recursion have been deactivated */ 7287 SCIP_Bool SCIPsetGetSubscipsOff( 7288 SCIP_SET* set /**< global SCIP settings */ 7289 ) 7290 { 7291 assert(set != NULL); 7292 7293 return set->subscipsoff; 7294 } 7295 7296 /** Checks, if an iteratively updated value is reliable or should be recomputed from scratch. 7297 * This is useful, if the value, e.g., the activity of a linear constraint or the pseudo objective value, gets a high 7298 * absolute value during the optimization process which is later reduced significantly. In this case, the last digits 7299 * were canceled out when increasing the value and are random after decreasing it. 7300 * We dot not consider the cancellations which can occur during increasing the absolute value because they just cannot 7301 * be expressed using fixed precision floating point arithmetic, anymore. 7302 * The idea to get more reliable values is to always store the last reliable value, where increasing the absolute of 7303 * the value is viewed as preserving reliability. Then, after each update, the new absolute value can be compared 7304 * against the last reliable one with this method, checking whether it was decreased by a factor of at least 7305 * "lp/recompfac" and should be recomputed. 7306 */ 7307 SCIP_Bool SCIPsetIsUpdateUnreliable( 7308 SCIP_SET* set, /**< global SCIP settings */ 7309 SCIP_Real newvalue, /**< new value after update */ 7310 SCIP_Real oldvalue /**< old value, i.e., last reliable value */ 7311 ) 7312 { 7313 SCIP_Real quotient; 7314 7315 assert(set != NULL); 7316 7317 quotient = ABS(oldvalue) / MAX(ABS(newvalue), set->num_epsilon); 7318 7319 return quotient >= set->num_recompfac; 7320 } 7321 7322 /** prints a debug message */ 7323 void SCIPsetPrintDebugMessage( 7324 SCIP_SET* set, /**< global SCIP settings */ 7325 const char* sourcefile, /**< name of the source file that called the function */ 7326 int sourceline, /**< line in the source file where the function was called */ 7327 const char* formatstr, /**< format string like in printf() function */ 7328 ... /**< format arguments line in printf() function */ 7329 ) 7330 { 7331 const char* filename; 7332 int subscipdepth = 0; 7333 SCIP* scip; 7334 va_list ap; 7335 7336 assert( sourcefile != NULL ); 7337 assert( set != NULL ); 7338 7339 scip = set->scip; 7340 assert( scip != NULL ); 7341 7342 /* strip directory from filename */ 7343 #if defined(_WIN32) || defined(_WIN64) 7344 filename = strrchr(sourcefile, '\\'); 7345 #else 7346 filename = strrchr(sourcefile, '/'); 7347 #endif 7348 if ( filename == NULL ) 7349 filename = sourcefile; 7350 else 7351 ++filename; 7352 7353 if ( scip->stat != NULL ) 7354 subscipdepth = scip->stat->subscipdepth; 7355 7356 if ( subscipdepth > 0 ) 7357 SCIPmessageFPrintInfo(scip->messagehdlr, NULL, "%d: [%s:%d] debug: ", subscipdepth, filename, sourceline); 7358 else 7359 SCIPmessageFPrintInfo(scip->messagehdlr, NULL, "[%s:%d] debug: ", filename, sourceline); 7360 7361 va_start(ap, formatstr); /*lint !e838*/ 7362 SCIPmessageVFPrintInfo(scip->messagehdlr, NULL, formatstr, ap); 7363 va_end(ap); 7364 } 7365 7366 /** prints a debug message without precode */ 7367 void SCIPsetDebugMessagePrint( 7368 SCIP_SET* set, /**< global SCIP settings */ 7369 const char* formatstr, /**< format string like in printf() function */ 7370 ... /**< format arguments line in printf() function */ 7371 ) 7372 { 7373 va_list ap; 7374 7375 assert( set != NULL ); 7376 assert( set->scip != NULL ); 7377 7378 va_start(ap, formatstr); /*lint !e838*/ 7379 SCIPmessageVFPrintInfo(set->scip->messagehdlr, NULL, formatstr, ap); 7380 va_end(ap); 7381 } 7382 7383 /** modifies an initial seed value with the global shift of random seeds */ 7384 unsigned int SCIPsetInitializeRandomSeed( 7385 SCIP_SET* set, /**< global SCIP settings */ 7386 unsigned int initialseedvalue /**< initial seed value to be modified */ 7387 ) 7388 { 7389 assert(set != NULL); 7390 7391 return (unsigned int)(initialseedvalue + (unsigned) set->random_randomseedshift); 7392 } 7393