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