1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 2 /* */ 3 /* This file is part of the program and library */ 4 /* SCIP --- Solving Constraint Integer Programs */ 5 /* */ 6 /* Copyright (C) 2002-2021 Konrad-Zuse-Zentrum */ 7 /* fuer Informationstechnik Berlin */ 8 /* */ 9 /* SCIP is distributed under the terms of the ZIB Academic License. */ 10 /* */ 11 /* You should have received a copy of the ZIB Academic License */ 12 /* along with SCIP; see the file COPYING. If not visit scipopt.org. */ 13 /* */ 14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 15 16 /**@file branch.h 17 * @ingroup INTERNALAPI 18 * @brief internal methods for branching rules and branching candidate storage 19 * @author Tobias Achterberg 20 */ 21 22 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/ 23 24 #ifndef __SCIP_BRANCH_H__ 25 #define __SCIP_BRANCH_H__ 26 27 28 #include "blockmemshell/memory.h" 29 #include "scip/def.h" 30 #include "scip/type_branch.h" 31 #include "scip/type_event.h" 32 #include "scip/type_lp.h" 33 #include "scip/type_message.h" 34 #include "scip/type_prob.h" 35 #include "scip/type_reopt.h" 36 #include "scip/type_result.h" 37 #include "scip/type_retcode.h" 38 #include "scip/type_scip.h" 39 #include "scip/type_sepastore.h" 40 #include "scip/type_set.h" 41 #include "scip/type_stat.h" 42 #include "scip/type_tree.h" 43 #include "scip/type_var.h" 44 45 #ifdef __cplusplus 46 extern "C" { 47 #endif 48 49 /* 50 * branching candidate storage methods 51 */ 52 53 /** creates a branching candidate storage */ 54 SCIP_RETCODE SCIPbranchcandCreate( 55 SCIP_BRANCHCAND** branchcand /**< pointer to store branching candidate storage */ 56 ); 57 58 /** frees branching candidate storage */ 59 SCIP_RETCODE SCIPbranchcandFree( 60 SCIP_BRANCHCAND** branchcand /**< pointer to store branching candidate storage */ 61 ); 62 63 /** invalidates branching candidates storage */ 64 void SCIPbranchcandInvalidate( 65 SCIP_BRANCHCAND* branchcand /**< pointer to store branching candidate storage */ 66 ); 67 68 /** gets branching candidates for LP solution branching (fractional variables) */ 69 SCIP_RETCODE SCIPbranchcandGetLPCands( 70 SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */ 71 SCIP_SET* set, /**< global SCIP settings */ 72 SCIP_STAT* stat, /**< problem statistics */ 73 SCIP_LP* lp, /**< current LP data */ 74 SCIP_VAR*** lpcands, /**< pointer to store the array of LP branching candidates, or NULL */ 75 SCIP_Real** lpcandssol, /**< pointer to store the array of LP candidate solution values, or NULL */ 76 SCIP_Real** lpcandsfrac, /**< pointer to store the array of LP candidate fractionalities, or NULL */ 77 int* nlpcands, /**< pointer to store the number of LP branching candidates, or NULL */ 78 int* npriolpcands, /**< pointer to store the number of candidates with maximal priority, or NULL */ 79 int* nfracimplvars /**< pointer to store the number of implicit fractional variables, or NULL */ 80 ); 81 82 83 /** gets external branching candidates */ 84 SCIP_RETCODE SCIPbranchcandGetExternCands( 85 SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */ 86 SCIP_VAR*** externcands, /**< pointer to store the array of external branching candidates, or NULL */ 87 SCIP_Real** externcandssol, /**< pointer to store the array of external candidate solution values, or NULL */ 88 SCIP_Real** externcandsscore, /**< pointer to store the array of external candidate scores, or NULL */ 89 int* nexterncands, /**< pointer to store the number of external branching candidates, or NULL */ 90 int* nprioexterncands, /**< pointer to store the number of candidates with maximal priority, or NULL */ 91 int* nprioexternbins, /**< pointer to store the number of binary candidates with maximal priority, or NULL */ 92 int* nprioexternints, /**< pointer to store the number of integer candidates with maximal priority, or NULL */ 93 int* nprioexternimpls /**< pointer to store the number of implicit integer candidates with maximal priority, 94 * or NULL */ 95 ); 96 97 /** gets maximal branching priority of LP branching candidates */ 98 int SCIPbranchcandGetLPMaxPrio( 99 SCIP_BRANCHCAND* branchcand /**< branching candidate storage */ 100 ); 101 102 /** gets number of LP branching candidates with maximal branch priority */ 103 int SCIPbranchcandGetNPrioLPCands( 104 SCIP_BRANCHCAND* branchcand /**< branching candidate storage */ 105 ); 106 107 /** gets maximal branching priority of external branching candidates */ 108 int SCIPbranchcandGetExternMaxPrio( 109 SCIP_BRANCHCAND* branchcand /**< branching candidate storage */ 110 ); 111 112 /** gets number of external branching candidates */ 113 int SCIPbranchcandGetNExternCands( 114 SCIP_BRANCHCAND* branchcand /**< branching candidate storage */ 115 ); 116 117 /** gets number of external branching candidates with maximal branch priority */ 118 int SCIPbranchcandGetNPrioExternCands( 119 SCIP_BRANCHCAND* branchcand /**< branching candidate storage */ 120 ); 121 122 /** gets number of binary external branching candidates with maximal branch priority */ 123 int SCIPbranchcandGetNPrioExternBins( 124 SCIP_BRANCHCAND* branchcand /**< branching candidate storage */ 125 ); 126 127 /** gets number of integer external branching candidates with maximal branch priority */ 128 int SCIPbranchcandGetNPrioExternInts( 129 SCIP_BRANCHCAND* branchcand /**< branching candidate storage */ 130 ); 131 132 /** gets number of implicit integer external branching candidates with maximal branch priority */ 133 int SCIPbranchcandGetNPrioExternImpls( 134 SCIP_BRANCHCAND* branchcand /**< branching candidate storage */ 135 ); 136 137 /** gets number of continuous external branching candidates with maximal branch priority */ 138 int SCIPbranchcandGetNPrioExternConts( 139 SCIP_BRANCHCAND* branchcand /**< branching candidate storage */ 140 ); 141 142 /** insert variable, its score and its solution value into the external branching candidate storage 143 * the absolute difference of the current lower and upper bounds of the variable must be at least epsilon 144 */ 145 SCIP_RETCODE SCIPbranchcandAddExternCand( 146 SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */ 147 SCIP_SET* set, /**< global SCIP settings */ 148 SCIP_VAR* var, /**< variable to insert */ 149 SCIP_Real score, /**< score of external candidate, e.g. infeasibility */ 150 SCIP_Real solval /**< value of the variable in the current solution */ 151 ); 152 153 /** removes all external candidates from the storage for external branching */ 154 void SCIPbranchcandClearExternCands( 155 SCIP_BRANCHCAND* branchcand /**< branching candidate storage */ 156 ); 157 158 /** checks whether the given variable is contained in the candidate storage for external branching */ 159 SCIP_Bool SCIPbranchcandContainsExternCand( 160 SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */ 161 SCIP_VAR* var /**< variable to look for */ 162 ); 163 164 /** gets branching candidates for pseudo solution branching (non-fixed variables) */ 165 SCIP_RETCODE SCIPbranchcandGetPseudoCands( 166 SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */ 167 SCIP_SET* set, /**< global SCIP settings */ 168 SCIP_PROB* prob, /**< problem data */ 169 SCIP_VAR*** pseudocands, /**< pointer to store the array of pseudo branching candidates, or NULL */ 170 int* npseudocands, /**< pointer to store the number of pseudo branching candidates, or NULL */ 171 int* npriopseudocands /**< pointer to store the number of candidates with maximal priority, or NULL */ 172 ); 173 174 /** gets number of branching candidates for pseudo solution branching (non-fixed variables) */ 175 int SCIPbranchcandGetNPseudoCands( 176 SCIP_BRANCHCAND* branchcand /**< branching candidate storage */ 177 ); 178 179 /** gets number of branching candidates with maximal branch priority for pseudo solution branching */ 180 int SCIPbranchcandGetNPrioPseudoCands( 181 SCIP_BRANCHCAND* branchcand /**< branching candidate storage */ 182 ); 183 184 /** gets number of binary branching candidates with maximal branch priority for pseudo solution branching */ 185 int SCIPbranchcandGetNPrioPseudoBins( 186 SCIP_BRANCHCAND* branchcand /**< branching candidate storage */ 187 ); 188 189 /** gets number of integer branching candidates with maximal branch priority for pseudo solution branching */ 190 int SCIPbranchcandGetNPrioPseudoInts( 191 SCIP_BRANCHCAND* branchcand /**< branching candidate storage */ 192 ); 193 194 /** gets number of implicit integer branching candidates with maximal branch priority for pseudo solution branching */ 195 int SCIPbranchcandGetNPrioPseudoImpls( 196 SCIP_BRANCHCAND* branchcand /**< branching candidate storage */ 197 ); 198 199 /** removes variable from branching candidate list */ 200 SCIP_RETCODE SCIPbranchcandRemoveVar( 201 SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */ 202 SCIP_VAR* var /**< variable that changed its bounds */ 203 ); 204 205 /** updates branching candidate list for a given variable */ 206 SCIP_RETCODE SCIPbranchcandUpdateVar( 207 SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */ 208 SCIP_SET* set, /**< global SCIP settings */ 209 SCIP_VAR* var /**< variable that changed its bounds */ 210 ); 211 212 /** updates branching priority of the given variable and update the pseudo candidate array if needed */ 213 SCIP_RETCODE SCIPbranchcandUpdateVarBranchPriority( 214 SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */ 215 SCIP_SET* set, /**< global SCIP settings */ 216 SCIP_VAR* var, /**< variable that changed its bounds */ 217 int branchpriority /**< branch priority of the variable */ 218 ); 219 220 221 222 223 /* 224 * branching rules 225 */ 226 227 /** copies the given branchrule to a new scip */ 228 SCIP_RETCODE SCIPbranchruleCopyInclude( 229 SCIP_BRANCHRULE* branchrule, /**< branchrule */ 230 SCIP_SET* set /**< SCIP_SET of SCIP to copy to */ 231 ); 232 233 /** creates a branching rule */ 234 SCIP_RETCODE SCIPbranchruleCreate( 235 SCIP_BRANCHRULE** branchrule, /**< pointer to store branching rule */ 236 SCIP_SET* set, /**< global SCIP settings */ 237 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */ 238 BMS_BLKMEM* blkmem, /**< block memory for parameter settings */ 239 const char* name, /**< name of branching rule */ 240 const char* desc, /**< description of branching rule */ 241 int priority, /**< priority of the branching rule */ 242 int maxdepth, /**< maximal depth level, up to which this branching rule should be used (or -1) */ 243 SCIP_Real maxbounddist, /**< maximal relative distance from current node's dual bound to primal bound 244 * compared to best node's dual bound for applying branching rule 245 * (0.0: only on current best node, 1.0: on all nodes) */ 246 SCIP_DECL_BRANCHCOPY ((*branchcopy)), /**< copy method of branching rule */ 247 SCIP_DECL_BRANCHFREE ((*branchfree)), /**< destructor of branching rule */ 248 SCIP_DECL_BRANCHINIT ((*branchinit)), /**< initialize branching rule */ 249 SCIP_DECL_BRANCHEXIT ((*branchexit)), /**< deinitialize branching rule */ 250 SCIP_DECL_BRANCHINITSOL((*branchinitsol)),/**< solving process initialization method of branching rule */ 251 SCIP_DECL_BRANCHEXITSOL((*branchexitsol)),/**< solving process deinitialization method of branching rule */ 252 SCIP_DECL_BRANCHEXECLP((*branchexeclp)), /**< branching execution method for fractional LP solutions */ 253 SCIP_DECL_BRANCHEXECEXT((*branchexecext)),/**< branching execution method for external solutions */ 254 SCIP_DECL_BRANCHEXECPS((*branchexecps)), /**< branching execution method for not completely fixed pseudo solutions */ 255 SCIP_BRANCHRULEDATA* branchruledata /**< branching rule data */ 256 ); 257 258 /** frees memory of branching rule */ 259 SCIP_RETCODE SCIPbranchruleFree( 260 SCIP_BRANCHRULE** branchrule, /**< pointer to branching rule data structure */ 261 SCIP_SET* set /**< global SCIP settings */ 262 ); 263 264 /** initializes branching rule */ 265 SCIP_RETCODE SCIPbranchruleInit( 266 SCIP_BRANCHRULE* branchrule, /**< branching rule */ 267 SCIP_SET* set /**< global SCIP settings */ 268 ); 269 270 /** deinitializes branching rule */ 271 SCIP_RETCODE SCIPbranchruleExit( 272 SCIP_BRANCHRULE* branchrule, /**< branching rule */ 273 SCIP_SET* set /**< global SCIP settings */ 274 ); 275 276 /** informs branching rule that the branch and bound process is being started */ 277 SCIP_RETCODE SCIPbranchruleInitsol( 278 SCIP_BRANCHRULE* branchrule, /**< branching rule */ 279 SCIP_SET* set /**< global SCIP settings */ 280 ); 281 282 /** informs branching rule that the branch and bound process data is being freed */ 283 SCIP_RETCODE SCIPbranchruleExitsol( 284 SCIP_BRANCHRULE* branchrule, /**< branching rule */ 285 SCIP_SET* set /**< global SCIP settings */ 286 ); 287 288 /** executes branching rule for fractional LP solution */ 289 SCIP_RETCODE SCIPbranchruleExecLPSol( 290 SCIP_BRANCHRULE* branchrule, /**< branching rule */ 291 SCIP_SET* set, /**< global SCIP settings */ 292 SCIP_STAT* stat, /**< problem statistics */ 293 SCIP_TREE* tree, /**< branch and bound tree */ 294 SCIP_SEPASTORE* sepastore, /**< separation storage */ 295 SCIP_Real cutoffbound, /**< global upper cutoff bound */ 296 SCIP_Bool allowaddcons, /**< should adding constraints be allowed to avoid a branching? */ 297 SCIP_RESULT* result /**< pointer to store the result of the callback method */ 298 ); 299 300 /** executes branching rule for external branching candidates */ 301 SCIP_RETCODE SCIPbranchruleExecExternSol( 302 SCIP_BRANCHRULE* branchrule, /**< branching rule */ 303 SCIP_SET* set, /**< global SCIP settings */ 304 SCIP_STAT* stat, /**< problem statistics */ 305 SCIP_TREE* tree, /**< branch and bound tree */ 306 SCIP_SEPASTORE* sepastore, /**< separation storage */ 307 SCIP_Real cutoffbound, /**< global upper cutoff bound */ 308 SCIP_Bool allowaddcons, /**< should adding constraints be allowed to avoid a branching? */ 309 SCIP_RESULT* result /**< pointer to store the result of the callback method */ 310 ); 311 312 /** executes branching rule for not completely fixed pseudo solution */ 313 SCIP_RETCODE SCIPbranchruleExecPseudoSol( 314 SCIP_BRANCHRULE* branchrule, /**< branching rule */ 315 SCIP_SET* set, /**< global SCIP settings */ 316 SCIP_STAT* stat, /**< problem statistics */ 317 SCIP_TREE* tree, /**< branch and bound tree */ 318 SCIP_Real cutoffbound, /**< global upper cutoff bound */ 319 SCIP_Bool allowaddcons, /**< should adding constraints be allowed to avoid a branching? */ 320 SCIP_RESULT* result /**< pointer to store the result of the callback method */ 321 ); 322 323 /** sets priority of branching rule */ 324 void SCIPbranchruleSetPriority( 325 SCIP_BRANCHRULE* branchrule, /**< branching rule */ 326 SCIP_SET* set, /**< global SCIP settings */ 327 int priority /**< new priority of the branching rule */ 328 ); 329 330 /** sets maximal depth level, up to which this branching rule should be used (-1 for no limit) */ 331 void SCIPbranchruleSetMaxdepth( 332 SCIP_BRANCHRULE* branchrule, /**< branching rule */ 333 int maxdepth /**< new maxdepth of the branching rule */ 334 ); 335 336 /** sets maximal relative distance from current node's dual bound to primal bound for applying branching rule */ 337 void SCIPbranchruleSetMaxbounddist( 338 SCIP_BRANCHRULE* branchrule, /**< branching rule */ 339 SCIP_Real maxbounddist /**< new maxbounddist of the branching rule */ 340 ); 341 342 /** sets copy method of branching rule */ 343 void SCIPbranchruleSetCopy( 344 SCIP_BRANCHRULE* branchrule, /**< branching rule */ 345 SCIP_DECL_BRANCHCOPY ((*branchcopy)) /**< copy method of branching rule or NULL if you don't want to copy your plugin into sub-SCIPs */ 346 ); 347 348 /** sets destructor method of branching rule */ 349 void SCIPbranchruleSetFree( 350 SCIP_BRANCHRULE* branchrule, /**< branching rule */ 351 SCIP_DECL_BRANCHFREE ((*branchfree)) /**< destructor of branching rule */ 352 ); 353 354 /** sets initialization method of branching rule */ 355 void SCIPbranchruleSetInit( 356 SCIP_BRANCHRULE* branchrule, /**< branching rule */ 357 SCIP_DECL_BRANCHINIT ((*branchinit)) /**< initialize branching rule */ 358 ); 359 360 /** sets deinitialization method of branching rule */ 361 void SCIPbranchruleSetExit( 362 SCIP_BRANCHRULE* branchrule, /**< branching rule */ 363 SCIP_DECL_BRANCHEXIT ((*branchexit)) /**< deinitialize branching rule */ 364 ); 365 366 /** sets solving process initialization method of branching rule */ 367 void SCIPbranchruleSetInitsol( 368 SCIP_BRANCHRULE* branchrule, /**< branching rule */ 369 SCIP_DECL_BRANCHINITSOL((*branchinitsol)) /**< solving process initialization method of branching rule */ 370 ); 371 372 /** sets solving process deinitialization method of branching rule */ 373 void SCIPbranchruleSetExitsol( 374 SCIP_BRANCHRULE* branchrule, /**< branching rule */ 375 SCIP_DECL_BRANCHEXITSOL((*branchexitsol)) /**< solving process deinitialization method of branching rule */ 376 ); 377 378 /** sets branching execution method for fractional LP solutions */ 379 void SCIPbranchruleSetExecLp( 380 SCIP_BRANCHRULE* branchrule, /**< branching rule */ 381 SCIP_DECL_BRANCHEXECLP((*branchexeclp)) /**< branching execution method for fractional LP solutions */ 382 ); 383 384 /** sets branching execution method for external candidates */ 385 void SCIPbranchruleSetExecExt( 386 SCIP_BRANCHRULE* branchrule, /**< branching rule */ 387 SCIP_DECL_BRANCHEXECEXT((*branchexecext)) /**< branching execution method for external candidates */ 388 ); 389 390 /** sets branching execution method for not completely fixed pseudo solutions */ 391 void SCIPbranchruleSetExecPs( 392 SCIP_BRANCHRULE* branchrule, /**< branching rule */ 393 SCIP_DECL_BRANCHEXECPS((*branchexecps)) /**< branching execution method for not completely fixed pseudo solutions */ 394 ); 395 396 /** enables or disables all clocks of \p branchrule, depending on the value of the flag */ 397 void SCIPbranchruleEnableOrDisableClocks( 398 SCIP_BRANCHRULE* branchrule, /**< the branching rule for which all clocks should be enabled or disabled */ 399 SCIP_Bool enable /**< should the clocks of the branching rule be enabled? */ 400 ); 401 402 /* 403 * branching methods 404 */ 405 406 /** calculates the branching score out of the gain predictions for a binary branching */ 407 SCIP_Real SCIPbranchGetScore( 408 SCIP_SET* set, /**< global SCIP settings */ 409 SCIP_VAR* var, /**< variable, of which the branching factor should be applied, or NULL */ 410 SCIP_Real downgain, /**< prediction of objective gain for rounding downwards */ 411 SCIP_Real upgain /**< prediction of objective gain for rounding upwards */ 412 ); 413 414 /** calculates the branching score out of the gain predictions for a branching with arbitrary many children */ 415 SCIP_Real SCIPbranchGetScoreMultiple( 416 SCIP_SET* set, /**< global SCIP settings */ 417 SCIP_VAR* var, /**< variable, of which the branching factor should be applied, or NULL */ 418 int nchildren, /**< number of children that the branching will create */ 419 SCIP_Real* gains /**< prediction of objective gain for each child */ 420 ); 421 422 /** computes a branching point for a (not necessarily discrete) variable 423 * a suggested branching point is first projected onto the box 424 * if no point is suggested, then the value in the current LP or pseudo solution is used 425 * if this value is at infinity, then 0.0 projected onto the bounds and then moved inside the interval is used 426 * for a discrete variable, it is ensured that the returned value is fractional 427 * for a continuous variable, the parameter branching/clamp defines how far a branching point need to be from the bounds of a variable 428 * the latter is only applied if no point has been suggested, or the suggested point is not inside the variable's interval 429 */ 430 SCIP_Real SCIPbranchGetBranchingPoint( 431 SCIP_SET* set, /**< global SCIP settings */ 432 SCIP_TREE* tree, /**< branch and bound tree */ 433 SCIP_VAR* var, /**< variable, of which the branching point should be computed */ 434 SCIP_Real suggestion /**< suggestion for branching point, or SCIP_INVALID if no suggestion */ 435 ); 436 437 /** calls branching rules to branch on an LP solution; if no fractional variables exist, the result is SCIP_DIDNOTRUN; 438 * if the branch priority of an unfixed variable is larger than the maximal branch priority of the fractional 439 * variables, pseudo solution branching is applied on the unfixed variables with maximal branch priority 440 */ 441 SCIP_RETCODE SCIPbranchExecLP( 442 BMS_BLKMEM* blkmem, /**< block memory for parameter settings */ 443 SCIP_SET* set, /**< global SCIP settings */ 444 SCIP_STAT* stat, /**< problem statistics */ 445 SCIP_PROB* transprob, /**< transformed problem after presolve */ 446 SCIP_PROB* origprob, /**< original problem */ 447 SCIP_TREE* tree, /**< branch and bound tree */ 448 SCIP_REOPT* reopt, /**< reoptimization data structure */ 449 SCIP_LP* lp, /**< current LP data */ 450 SCIP_SEPASTORE* sepastore, /**< separation storage */ 451 SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */ 452 SCIP_EVENTQUEUE* eventqueue, /**< event queue */ 453 SCIP_Real cutoffbound, /**< global upper cutoff bound */ 454 SCIP_Bool allowaddcons, /**< should adding constraints be allowed to avoid a branching? */ 455 SCIP_RESULT* result /**< pointer to store the result of the branching */ 456 ); 457 458 /** calls branching rules to branch on an external solution; if no external branching candidates exist, the result is SCIP_DIDNOTRUN */ 459 SCIP_RETCODE SCIPbranchExecExtern( 460 BMS_BLKMEM* blkmem, /**< block memory for parameter settings */ 461 SCIP_SET* set, /**< global SCIP settings */ 462 SCIP_STAT* stat, /**< problem statistics */ 463 SCIP_PROB* transprob, /**< transformed problem after presolve */ 464 SCIP_PROB* origprob, /**< original problem */ 465 SCIP_TREE* tree, /**< branch and bound tree */ 466 SCIP_REOPT* reopt, /**< reoptimization data structure */ 467 SCIP_LP* lp, /**< current LP data */ 468 SCIP_SEPASTORE* sepastore, /**< separation storage */ 469 SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */ 470 SCIP_EVENTQUEUE* eventqueue, /**< event queue */ 471 SCIP_Real cutoffbound, /**< global upper cutoff bound */ 472 SCIP_Bool allowaddcons, /**< should adding constraints be allowed to avoid a branching? */ 473 SCIP_RESULT* result /**< pointer to store the result of the branching */ 474 ); 475 476 /** calls branching rules to branch on a pseudo solution; if no unfixed variables exist, the result is SCIP_DIDNOTRUN */ 477 SCIP_RETCODE SCIPbranchExecPseudo( 478 BMS_BLKMEM* blkmem, /**< block memory for parameter settings */ 479 SCIP_SET* set, /**< global SCIP settings */ 480 SCIP_STAT* stat, /**< problem statistics */ 481 SCIP_PROB* transprob, /**< transformed problem after presolve */ 482 SCIP_PROB* origprob, /**< original problem */ 483 SCIP_TREE* tree, /**< branch and bound tree */ 484 SCIP_REOPT* reopt, /**< reoptimization data structure */ 485 SCIP_LP* lp, /**< current LP data */ 486 SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */ 487 SCIP_EVENTQUEUE* eventqueue, /**< event queue */ 488 SCIP_Real cutoffbound, /**< global upper cutoff bound */ 489 SCIP_Bool allowaddcons, /**< should adding constraints be allowed to avoid a branching? */ 490 SCIP_RESULT* result /**< pointer to store the result of the branching */ 491 ); 492 493 #ifdef __cplusplus 494 } 495 #endif 496 497 #endif 498