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 2002-2022 Zuse Institute Berlin */
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 */
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
enum SCIP_Result SCIP_RESULT
Definition: type_result.h:61
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:2747
void SCIPbranchruleSetFree(SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHFREE((*branchfree)))
Definition: branch.c:1881
int SCIPbranchcandGetNPrioExternImpls(SCIP_BRANCHCAND *branchcand)
Definition: branch.c:547
int SCIPbranchcandGetNPrioExternBins(SCIP_BRANCHCAND *branchcand)
Definition: branch.c:527
int SCIPbranchcandGetNPseudoCands(SCIP_BRANCHCAND *branchcand)
Definition: branch.c:852
#define SCIP_DECL_BRANCHEXECPS(x)
Definition: type_branch.h:176
int SCIPbranchcandGetExternMaxPrio(SCIP_BRANCHCAND *branchcand)
Definition: branch.c:497
struct SCIP_BranchruleData SCIP_BRANCHRULEDATA
Definition: type_branch.h:57
SCIP_RETCODE SCIPbranchruleExitsol(SCIP_BRANCHRULE *branchrule, SCIP_SET *set)
Definition: branch.c:1510
#define SCIP_DECL_BRANCHFREE(x)
Definition: type_branch.h:75
int SCIPbranchcandGetNExternCands(SCIP_BRANCHCAND *branchcand)
Definition: branch.c:507
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:63
type definitions for global SCIP settings
void SCIPbranchruleSetCopy(SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHCOPY((*branchcopy)))
Definition: branch.c:1870
int SCIPbranchcandGetNPrioExternCands(SCIP_BRANCHCAND *branchcand)
Definition: branch.c:517
#define SCIP_DECL_BRANCHEXECEXT(x)
Definition: type_branch.h:155
type definitions for return codes for SCIP methods
SCIP_RETCODE SCIPbranchcandCreate(SCIP_BRANCHCAND **branchcand)
Definition: branch.c:143
#define SCIP_DECL_BRANCHEXITSOL(x)
Definition: type_branch.h:113
int SCIPbranchcandGetNPrioPseudoImpls(SCIP_BRANCHCAND *branchcand)
Definition: branch.c:892
type definitions for collecting reoptimization information
SCIP_RETCODE SCIPbranchcandGetPseudoCands(SCIP_BRANCHCAND *branchcand, SCIP_SET *set, SCIP_PROB *prob, SCIP_VAR ***pseudocands, int *npseudocands, int *npriopseudocands)
Definition: branch.c:788
void SCIPbranchruleSetInit(SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHINIT((*branchinit)))
Definition: branch.c:1892
void SCIPbranchcandClearExternCands(SCIP_BRANCHCAND *branchcand)
Definition: branch.c:697
type definitions for branching rules
type definitions for problem statistics
type definitions for LP management
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
int SCIPbranchcandGetNPrioLPCands(SCIP_BRANCHCAND *branchcand)
Definition: branch.c:487
SCIP_Bool SCIPbranchcandContainsExternCand(SCIP_BRANCHCAND *branchcand, SCIP_VAR *var)
Definition: branch.c:712
#define SCIP_DECL_BRANCHINIT(x)
Definition: type_branch.h:83
int SCIPbranchcandGetNPrioExternInts(SCIP_BRANCHCAND *branchcand)
Definition: branch.c:537
SCIP_RETCODE SCIPbranchruleInitsol(SCIP_BRANCHRULE *branchrule, SCIP_SET *set)
Definition: branch.c:1486
SCIP_RETCODE SCIPbranchcandAddExternCand(SCIP_BRANCHCAND *branchcand, SCIP_SET *set, SCIP_VAR *var, SCIP_Real score, SCIP_Real solval)
Definition: branch.c:569
#define SCIP_DECL_BRANCHCOPY(x)
Definition: type_branch.h:67
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
type definitions for SCIP&#39;s main datastructure
#define SCIP_DECL_BRANCHINITSOL(x)
Definition: type_branch.h:102
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
#define SCIP_DECL_BRANCHEXECLP(x)
Definition: type_branch.h:134
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:2514
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
int SCIPbranchcandGetNPrioPseudoCands(SCIP_BRANCHCAND *branchcand)
Definition: branch.c:862
void SCIPbranchruleSetExecLp(SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHEXECLP((*branchexeclp)))
Definition: branch.c:1938
SCIP_Real SCIPbranchGetBranchingPoint(SCIP_SET *set, SCIP_TREE *tree, SCIP_VAR *var, SCIP_Real suggestion)
Definition: branch.c:2288
type definitions for problem variables
type definitions for storing separated cuts
void SCIPbranchruleSetInitsol(SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHINITSOL((*branchinitsol)))
Definition: branch.c:1914
type definitions for managing events
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
void SCIPbranchruleSetExecExt(SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHEXECEXT((*branchexecext)))
Definition: branch.c:1949
#define SCIP_Bool
Definition: def.h:93
SCIP_RETCODE SCIPbranchruleExit(SCIP_BRANCHRULE *branchrule, SCIP_SET *set)
Definition: branch.c:1456
SCIP_RETCODE SCIPbranchruleInit(SCIP_BRANCHRULE *branchrule, SCIP_SET *set)
Definition: branch.c:1412
int SCIPbranchcandGetLPMaxPrio(SCIP_BRANCHCAND *branchcand)
Definition: branch.c:477
SCIP_RETCODE SCIPbranchcandFree(SCIP_BRANCHCAND **branchcand)
Definition: branch.c:183
SCIP_RETCODE SCIPbranchruleFree(SCIP_BRANCHRULE **branchrule, SCIP_SET *set)
Definition: branch.c:1385
void SCIPbranchruleSetExecPs(SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHEXECPS((*branchexecps)))
Definition: branch.c:1960
type definitions for branch and bound tree
void SCIPbranchruleSetMaxdepth(SCIP_BRANCHRULE *branchrule, int maxdepth)
Definition: branch.c:2025
void SCIPbranchruleSetPriority(SCIP_BRANCHRULE *branchrule, SCIP_SET *set, int priority)
Definition: branch.c:2001
type definitions for storing and manipulating the main problem
SCIP_RETCODE SCIPbranchcandUpdateVar(SCIP_BRANCHCAND *branchcand, SCIP_SET *set, SCIP_VAR *var)
Definition: branch.c:1136
int SCIPbranchcandGetNPrioExternConts(SCIP_BRANCHCAND *branchcand)
Definition: branch.c:557
void SCIPbranchruleSetExit(SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHEXIT((*branchexit)))
Definition: branch.c:1903
int SCIPbranchcandGetNPrioPseudoInts(SCIP_BRANCHCAND *branchcand)
Definition: branch.c:882
SCIP_Real SCIPbranchGetScoreMultiple(SCIP_SET *set, SCIP_VAR *var, int nchildren, SCIP_Real *gains)
Definition: branch.c:2250
void SCIPbranchruleEnableOrDisableClocks(SCIP_BRANCHRULE *branchrule, SCIP_Bool enable)
Definition: branch.c:2059
#define SCIP_Real
Definition: def.h:186
result codes for SCIP callback methods
void SCIPbranchcandInvalidate(SCIP_BRANCHCAND *branchcand)
Definition: branch.c:202
void SCIPbranchruleSetMaxbounddist(SCIP_BRANCHRULE *branchrule, SCIP_Real maxbounddist)
Definition: branch.c:2047
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:2616
SCIP_RETCODE SCIPbranchruleCopyInclude(SCIP_BRANCHRULE *branchrule, SCIP_SET *set)
Definition: branch.c:1247
type definitions for message output methods
common defines and data types used in all packages of SCIP
struct BMS_BlkMem BMS_BLKMEM
Definition: memory.h:439
int SCIPbranchcandGetNPrioPseudoBins(SCIP_BRANCHCAND *branchcand)
Definition: branch.c:872
SCIP_RETCODE SCIPbranchcandRemoveVar(SCIP_BRANCHCAND *branchcand, SCIP_VAR *var)
Definition: branch.c:1119
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
SCIP_RETCODE SCIPbranchcandUpdateVarBranchPriority(SCIP_BRANCHCAND *branchcand, SCIP_SET *set, SCIP_VAR *var, int branchpriority)
Definition: branch.c:1176
#define SCIP_DECL_BRANCHEXIT(x)
Definition: type_branch.h:91
void SCIPbranchruleSetExitsol(SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHEXITSOL((*branchexitsol)))
Definition: branch.c:1925
SCIP_Real SCIPbranchGetScore(SCIP_SET *set, SCIP_VAR *var, SCIP_Real downgain, SCIP_Real upgain)
Definition: branch.c:2190
memory allocation routines