Scippy

SCIP

Solving Constraint Integer Programs

branch.h
Go to the documentation of this file.
1/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2/* */
3/* This file is part of the program and library */
4/* SCIP --- Solving Constraint Integer Programs */
5/* */
6/* Copyright (c) 2002-2024 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
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
55extern "C" {
56#endif
57
58/*
59 * branching candidate storage methods
60 */
61
62/** creates a branching candidate storage */
64 SCIP_BRANCHCAND** branchcand /**< pointer to store branching candidate storage */
65 );
66
67/** frees branching candidate storage */
69 SCIP_BRANCHCAND** branchcand /**< pointer to store branching candidate storage */
70 );
71
72/** invalidates branching candidates storage */
74 SCIP_BRANCHCAND* branchcand /**< pointer to store branching candidate storage */
75 );
76
77/** gets branching candidates for LP solution branching (fractional variables) */
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 */
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 */
108 SCIP_BRANCHCAND* branchcand /**< branching candidate storage */
109 );
110
111/** gets number of LP branching candidates with maximal branch priority */
113 SCIP_BRANCHCAND* branchcand /**< branching candidate storage */
114 );
115
116/** gets maximal branching priority of external branching candidates */
118 SCIP_BRANCHCAND* branchcand /**< branching candidate storage */
119 );
120
121/** gets number of external branching candidates */
123 SCIP_BRANCHCAND* branchcand /**< branching candidate storage */
124 );
125
126/** gets number of external branching candidates with maximal branch priority */
128 SCIP_BRANCHCAND* branchcand /**< branching candidate storage */
129 );
130
131/** gets number of binary external branching candidates with maximal branch priority */
133 SCIP_BRANCHCAND* branchcand /**< branching candidate storage */
134 );
135
136/** gets number of integer external branching candidates with maximal branch priority */
138 SCIP_BRANCHCAND* branchcand /**< branching candidate storage */
139 );
140
141/** gets number of implicit integer external branching candidates with maximal branch priority */
143 SCIP_BRANCHCAND* branchcand /**< branching candidate storage */
144 );
145
146/** gets number of continuous external branching candidates with maximal branch priority */
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 */
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 */
164 SCIP_BRANCHCAND* branchcand /**< branching candidate storage */
165 );
166
167/** checks whether the given variable is contained in the candidate storage for external branching */
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) */
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) */
185 SCIP_BRANCHCAND* branchcand /**< branching candidate storage */
186 );
187
188/** gets number of branching candidates with maximal branch priority for pseudo solution branching */
190 SCIP_BRANCHCAND* branchcand /**< branching candidate storage */
191 );
192
193/** gets number of binary branching candidates with maximal branch priority for pseudo solution branching */
195 SCIP_BRANCHCAND* branchcand /**< branching candidate storage */
196 );
197
198/** gets number of integer branching candidates with maximal branch priority for pseudo solution branching */
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 */
205 SCIP_BRANCHCAND* branchcand /**< branching candidate storage */
206 );
207
208/** removes variable from branching candidate list */
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 */
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 */
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 */
238 SCIP_BRANCHRULE* branchrule, /**< branchrule */
239 SCIP_SET* set /**< SCIP_SET of SCIP to copy to */
240 );
241
242/** creates a branching rule */
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 */
269 SCIP_BRANCHRULE** branchrule, /**< pointer to branching rule data structure */
270 SCIP_SET* set /**< global SCIP settings */
271 );
272
273/** initializes branching rule */
275 SCIP_BRANCHRULE* branchrule, /**< branching rule */
276 SCIP_SET* set /**< global SCIP settings */
277 );
278
279/** deinitializes branching rule */
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 */
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 */
293 SCIP_BRANCHRULE* branchrule, /**< branching rule */
294 SCIP_SET* set /**< global SCIP settings */
295 );
296
297/** executes branching rule for fractional LP solution */
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 */
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 */
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 */
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) */
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 */
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 */
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 */
359 SCIP_BRANCHRULE* branchrule, /**< branching rule */
360 SCIP_DECL_BRANCHFREE ((*branchfree)) /**< destructor of branching rule */
361 );
362
363/** sets initialization method of branching rule */
365 SCIP_BRANCHRULE* branchrule, /**< branching rule */
366 SCIP_DECL_BRANCHINIT ((*branchinit)) /**< initialize branching rule */
367 );
368
369/** sets deinitialization method of branching rule */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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
SCIP_RETCODE SCIPbranchcandGetLPCands(SCIP_BRANCHCAND *branchcand, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_VAR ***lpcands, SCIP_Real **lpcandssol, SCIP_Real **lpcandsfrac, int *nlpcands, int *npriolpcands, int *nfracimplvars)
Definition: branch.c:405
int SCIPbranchcandGetNPrioPseudoCands(SCIP_BRANCHCAND *branchcand)
Definition: branch.c:862
int SCIPbranchcandGetNExternCands(SCIP_BRANCHCAND *branchcand)
Definition: branch.c:507
SCIP_Real SCIPbranchGetBranchingPoint(SCIP_SET *set, SCIP_TREE *tree, SCIP_VAR *var, SCIP_Real suggestion)
Definition: branch.c:2288
SCIP_RETCODE SCIPbranchcandCreate(SCIP_BRANCHCAND **branchcand)
Definition: branch.c:143
void SCIPbranchruleSetExit(SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHEXIT((*branchexit)))
Definition: branch.c:1903
void SCIPbranchruleSetInitsol(SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHINITSOL((*branchinitsol)))
Definition: branch.c:1914
void SCIPbranchruleSetMaxdepth(SCIP_BRANCHRULE *branchrule, int maxdepth)
Definition: branch.c:2025
void SCIPbranchruleSetFree(SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHFREE((*branchfree)))
Definition: branch.c:1881
SCIP_RETCODE SCIPbranchExecPseudo(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_Real cutoffbound, SCIP_Bool allowaddcons, SCIP_RESULT *result)
Definition: branch.c:2769
void SCIPbranchruleSetInit(SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHINIT((*branchinit)))
Definition: branch.c:1892
SCIP_RETCODE SCIPbranchruleExecLPSol(SCIP_BRANCHRULE *branchrule, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_SEPASTORE *sepastore, SCIP_Real cutoffbound, SCIP_Bool allowaddcons, SCIP_RESULT *result)
Definition: branch.c:1534
SCIP_Real SCIPbranchGetScoreMultiple(SCIP_SET *set, SCIP_VAR *var, int nchildren, SCIP_Real *gains)
Definition: branch.c:2250
int SCIPbranchcandGetNPrioExternCands(SCIP_BRANCHCAND *branchcand)
Definition: branch.c:517
SCIP_RETCODE SCIPbranchruleExit(SCIP_BRANCHRULE *branchrule, SCIP_SET *set)
Definition: branch.c:1456
void SCIPbranchcandClearExternCands(SCIP_BRANCHCAND *branchcand)
Definition: branch.c:697
int SCIPbranchcandGetExternMaxPrio(SCIP_BRANCHCAND *branchcand)
Definition: branch.c:497
SCIP_RETCODE SCIPbranchruleFree(SCIP_BRANCHRULE **branchrule, SCIP_SET *set)
Definition: branch.c:1385
SCIP_RETCODE SCIPbranchruleInitsol(SCIP_BRANCHRULE *branchrule, SCIP_SET *set)
Definition: branch.c:1486
SCIP_RETCODE SCIPbranchcandUpdateVarBranchPriority(SCIP_BRANCHCAND *branchcand, SCIP_SET *set, SCIP_VAR *var, int branchpriority)
Definition: branch.c:1176
int SCIPbranchcandGetNPrioExternBins(SCIP_BRANCHCAND *branchcand)
Definition: branch.c:527
SCIP_RETCODE SCIPbranchruleExecPseudoSol(SCIP_BRANCHRULE *branchrule, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_Real cutoffbound, SCIP_Bool allowaddcons, SCIP_RESULT *result)
Definition: branch.c:1748
void SCIPbranchruleSetExecPs(SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHEXECPS((*branchexecps)))
Definition: branch.c:1960
int SCIPbranchcandGetNPseudoCands(SCIP_BRANCHCAND *branchcand)
Definition: branch.c:852
int SCIPbranchcandGetNPrioPseudoBins(SCIP_BRANCHCAND *branchcand)
Definition: branch.c:872
SCIP_RETCODE SCIPbranchcandGetExternCands(SCIP_BRANCHCAND *branchcand, SCIP_VAR ***externcands, SCIP_Real **externcandssol, SCIP_Real **externcandsscore, int *nexterncands, int *nprioexterncands, int *nprioexternbins, int *nprioexternints, int *nprioexternimpls)
Definition: branch.c:440
void SCIPbranchruleSetCopy(SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHCOPY((*branchcopy)))
Definition: branch.c:1870
SCIP_RETCODE SCIPbranchruleExitsol(SCIP_BRANCHRULE *branchrule, SCIP_SET *set)
Definition: branch.c:1510
int SCIPbranchcandGetNPrioExternImpls(SCIP_BRANCHCAND *branchcand)
Definition: branch.c:547
SCIP_RETCODE SCIPbranchruleExecExternSol(SCIP_BRANCHRULE *branchrule, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_SEPASTORE *sepastore, SCIP_Real cutoffbound, SCIP_Bool allowaddcons, SCIP_RESULT *result)
Definition: branch.c:1641
int SCIPbranchcandGetNPrioLPCands(SCIP_BRANCHCAND *branchcand)
Definition: branch.c:487
SCIP_RETCODE SCIPbranchcandGetPseudoCands(SCIP_BRANCHCAND *branchcand, SCIP_SET *set, SCIP_PROB *prob, SCIP_VAR ***pseudocands, int *npseudocands, int *npriopseudocands)
Definition: branch.c:788
SCIP_RETCODE SCIPbranchExecExtern(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_SEPASTORE *sepastore, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_Real cutoffbound, SCIP_Bool allowaddcons, SCIP_RESULT *result)
Definition: branch.c:2638
void SCIPbranchcandInvalidate(SCIP_BRANCHCAND *branchcand)
Definition: branch.c:202
void SCIPbranchruleSetExecExt(SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHEXECEXT((*branchexecext)))
Definition: branch.c:1949
int SCIPbranchcandGetNPrioExternInts(SCIP_BRANCHCAND *branchcand)
Definition: branch.c:537
int SCIPbranchcandGetNPrioPseudoImpls(SCIP_BRANCHCAND *branchcand)
Definition: branch.c:892
SCIP_RETCODE SCIPbranchcandRemoveVar(SCIP_BRANCHCAND *branchcand, SCIP_VAR *var)
Definition: branch.c:1119
SCIP_RETCODE SCIPbranchcandAddExternCand(SCIP_BRANCHCAND *branchcand, SCIP_SET *set, SCIP_VAR *var, SCIP_Real score, SCIP_Real solval)
Definition: branch.c:569
void SCIPbranchruleEnableOrDisableClocks(SCIP_BRANCHRULE *branchrule, SCIP_Bool enable)
Definition: branch.c:2059
SCIP_RETCODE SCIPbranchcandFree(SCIP_BRANCHCAND **branchcand)
Definition: branch.c:183
int SCIPbranchcandGetNPrioPseudoInts(SCIP_BRANCHCAND *branchcand)
Definition: branch.c:882
SCIP_RETCODE SCIPbranchcandUpdateVar(SCIP_BRANCHCAND *branchcand, SCIP_SET *set, SCIP_VAR *var)
Definition: branch.c:1136
void SCIPbranchruleSetMaxbounddist(SCIP_BRANCHRULE *branchrule, SCIP_Real maxbounddist)
Definition: branch.c:2047
SCIP_RETCODE SCIPbranchExecLP(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_SEPASTORE *sepastore, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_Real cutoffbound, SCIP_Bool allowaddcons, SCIP_RESULT *result)
Definition: branch.c:2536
int SCIPbranchcandGetLPMaxPrio(SCIP_BRANCHCAND *branchcand)
Definition: branch.c:477
void SCIPbranchruleSetPriority(SCIP_BRANCHRULE *branchrule, SCIP_SET *set, int priority)
Definition: branch.c:2001
void SCIPbranchruleSetExitsol(SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHEXITSOL((*branchexitsol)))
Definition: branch.c:1925
SCIP_RETCODE SCIPbranchruleCreate(SCIP_BRANCHRULE **branchrule, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, int priority, int maxdepth, SCIP_Real maxbounddist, SCIP_DECL_BRANCHCOPY((*branchcopy)), SCIP_DECL_BRANCHFREE((*branchfree)), SCIP_DECL_BRANCHINIT((*branchinit)), SCIP_DECL_BRANCHEXIT((*branchexit)), SCIP_DECL_BRANCHINITSOL((*branchinitsol)), SCIP_DECL_BRANCHEXITSOL((*branchexitsol)), SCIP_DECL_BRANCHEXECLP((*branchexeclp)), SCIP_DECL_BRANCHEXECEXT((*branchexecext)), SCIP_DECL_BRANCHEXECPS((*branchexecps)), SCIP_BRANCHRULEDATA *branchruledata)
Definition: branch.c:1349
void SCIPbranchruleSetExecLp(SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHEXECLP((*branchexeclp)))
Definition: branch.c:1938
int SCIPbranchcandGetNPrioExternConts(SCIP_BRANCHCAND *branchcand)
Definition: branch.c:557
SCIP_Real SCIPbranchGetScore(SCIP_SET *set, SCIP_VAR *var, SCIP_Real downgain, SCIP_Real upgain)
Definition: branch.c:2190
SCIP_RETCODE SCIPbranchruleCopyInclude(SCIP_BRANCHRULE *branchrule, SCIP_SET *set)
Definition: branch.c:1247
SCIP_Bool SCIPbranchcandContainsExternCand(SCIP_BRANCHCAND *branchcand, SCIP_VAR *var)
Definition: branch.c:712
SCIP_RETCODE SCIPbranchruleInit(SCIP_BRANCHRULE *branchrule, SCIP_SET *set)
Definition: branch.c:1412
common defines and data types used in all packages of SCIP
#define SCIP_Bool
Definition: def.h:91
#define SCIP_Real
Definition: def.h:173
memory allocation routines
struct BMS_BlkMem BMS_BLKMEM
Definition: memory.h:437
Definition: heur_padm.c:135
type definitions for branching rules
#define SCIP_DECL_BRANCHEXECPS(x)
Definition: type_branch.h:176
#define SCIP_DECL_BRANCHEXECLP(x)
Definition: type_branch.h:134
#define SCIP_DECL_BRANCHEXECEXT(x)
Definition: type_branch.h:155
#define SCIP_DECL_BRANCHINITSOL(x)
Definition: type_branch.h:102
#define SCIP_DECL_BRANCHINIT(x)
Definition: type_branch.h:83
#define SCIP_DECL_BRANCHCOPY(x)
Definition: type_branch.h:67
#define SCIP_DECL_BRANCHEXIT(x)
Definition: type_branch.h:91
#define SCIP_DECL_BRANCHFREE(x)
Definition: type_branch.h:75
struct SCIP_BranchruleData SCIP_BRANCHRULEDATA
Definition: type_branch.h:57
#define SCIP_DECL_BRANCHEXITSOL(x)
Definition: type_branch.h:113
type definitions for managing events
type definitions for LP management
type definitions for message output methods
type definitions for storing and manipulating the main problem
type definitions for collecting reoptimization information
result codes for SCIP callback methods
enum SCIP_Result SCIP_RESULT
Definition: type_result.h:61
type definitions for return codes for SCIP methods
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:63
type definitions for SCIP's main datastructure
type definitions for storing separated cuts
type definitions for global SCIP settings
type definitions for problem statistics
type definitions for branch and bound tree
type definitions for problem variables