Scippy

SCIP

Solving Constraint Integer Programs

var.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-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 var.h
26  * @ingroup INTERNALAPI
27  * @brief internal methods for problem variables
28  * @author Tobias Achterberg
29  */
30 
31 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
32 
33 #ifndef __SCIP_VAR_H__
34 #define __SCIP_VAR_H__
35 
36 
37 #include "blockmemshell/memory.h"
38 #include "scip/def.h"
39 #include "scip/type_branch.h"
40 #include "scip/type_cons.h"
41 #include "scip/type_event.h"
42 #include "scip/type_history.h"
43 #include "scip/type_implics.h"
44 #include "scip/type_lp.h"
45 #include "scip/type_message.h"
46 #include "scip/type_misc.h"
47 #include "scip/type_primal.h"
48 #include "scip/type_prob.h"
49 #include "scip/type_prop.h"
50 #include "scip/type_relax.h"
51 #include "scip/type_reopt.h"
52 #include "scip/type_result.h"
53 #include "scip/type_retcode.h"
54 #include "scip/type_scip.h"
55 #include "scip/type_set.h"
56 #include "scip/type_sol.h"
57 #include "scip/type_stat.h"
58 #include "scip/type_tree.h"
59 #include "scip/type_var.h"
60 
61 #ifndef NDEBUG
62 #include "scip/struct_var.h"
63 #else
64 #include "scip/event.h"
65 #include "scip/pub_history.h"
66 #endif
67 
68 #ifdef __cplusplus
69 extern "C" {
70 #endif
71 
72 /*
73  * domain change methods
74  */
75 
76 /** applies single bound change */
78  SCIP_BOUNDCHG* boundchg, /**< bound change to apply */
79  BMS_BLKMEM* blkmem, /**< block memory */
80  SCIP_SET* set, /**< global SCIP settings */
81  SCIP_STAT* stat, /**< problem statistics */
82  SCIP_LP* lp, /**< current LP data */
83  SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */
84  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
85  int depth, /**< depth in the tree, where the bound change takes place */
86  int pos, /**< position of the bound change in its bound change array */
87  SCIP_Bool* cutoff /**< pointer to store whether an infeasible bound change was detected */
88  );
89 
90 /** undoes single bound change */
92  SCIP_BOUNDCHG* boundchg, /**< bound change to remove */
93  BMS_BLKMEM* blkmem, /**< block memory */
94  SCIP_SET* set, /**< global SCIP settings */
95  SCIP_STAT* stat, /**< problem statistics */
96  SCIP_LP* lp, /**< current LP data */
97  SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */
98  SCIP_EVENTQUEUE* eventqueue /**< event queue */
99  );
100 
101 /** applies domain change to the global problem */
103  SCIP_DOMCHG* domchg, /**< domain change to apply */
104  BMS_BLKMEM* blkmem, /**< block memory */
105  SCIP_SET* set, /**< global SCIP settings */
106  SCIP_STAT* stat, /**< problem statistics */
107  SCIP_LP* lp, /**< current LP data */
108  SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */
109  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
110  SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
111  SCIP_Bool* cutoff /**< pointer to store whether an infeasible domain change was detected */
112  );
113 
114 /** frees domain change data */
116  SCIP_DOMCHG** domchg, /**< pointer to domain change */
117  BMS_BLKMEM* blkmem, /**< block memory */
118  SCIP_SET* set, /**< global SCIP settings */
119  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
120  SCIP_LP* lp /**< current LP data */
121  );
122 
123 /** converts a dynamic domain change data into a static one, using less memory than for a dynamic one */
125  SCIP_DOMCHG** domchg, /**< pointer to domain change data */
126  BMS_BLKMEM* blkmem, /**< block memory */
127  SCIP_SET* set, /**< global SCIP settings */
128  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
129  SCIP_LP* lp /**< current LP data */
130  );
131 
132 /** applies domain change */
134  SCIP_DOMCHG* domchg, /**< domain change to apply */
135  BMS_BLKMEM* blkmem, /**< block memory */
136  SCIP_SET* set, /**< global SCIP settings */
137  SCIP_STAT* stat, /**< problem statistics */
138  SCIP_LP* lp, /**< current LP data */
139  SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */
140  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
141  int depth, /**< depth in the tree, where the domain change takes place */
142  SCIP_Bool* cutoff /**< pointer to store whether an infeasible domain change was detected */
143  );
144 
145 /** undoes domain change */
147  SCIP_DOMCHG* domchg, /**< domain change to remove */
148  BMS_BLKMEM* blkmem, /**< block memory */
149  SCIP_SET* set, /**< global SCIP settings */
150  SCIP_STAT* stat, /**< problem statistics */
151  SCIP_LP* lp, /**< current LP data */
152  SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */
153  SCIP_EVENTQUEUE* eventqueue /**< event queue */
154  );
155 
156 /** adds bound change to domain changes */
158  SCIP_DOMCHG** domchg, /**< pointer to domain change data structure */
159  BMS_BLKMEM* blkmem, /**< block memory */
160  SCIP_SET* set, /**< global SCIP settings */
161  SCIP_VAR* var, /**< variable to change the bounds for */
162  SCIP_Real newbound, /**< new value for bound */
163  SCIP_BOUNDTYPE boundtype, /**< type of bound for var: lower or upper bound */
164  SCIP_BOUNDCHGTYPE boundchgtype, /**< type of bound change: branching decision or inference */
165  SCIP_Real lpsolval, /**< solval of variable in last LP on path to node, or SCIP_INVALID if unknown */
166  SCIP_VAR* infervar, /**< variable that was changed (parent of var, or var itself) */
167  SCIP_CONS* infercons, /**< constraint that deduced the bound change, or NULL */
168  SCIP_PROP* inferprop, /**< propagator that deduced the bound change, or NULL */
169  int inferinfo, /**< user information for inference to help resolving the conflict */
170  SCIP_BOUNDTYPE inferboundtype /**< type of bound for inference var: lower or upper bound */
171  );
172 
173 /** adds hole change to domain changes */
175  SCIP_DOMCHG** domchg, /**< pointer to domain change data structure */
176  BMS_BLKMEM* blkmem, /**< block memory */
177  SCIP_SET* set, /**< global SCIP settings */
178  SCIP_HOLELIST** ptr, /**< changed list pointer */
179  SCIP_HOLELIST* newlist, /**< new value of list pointer */
180  SCIP_HOLELIST* oldlist /**< old value of list pointer */
181  );
182 
183 /** creates an artificial bound change information object with depth = INT_MAX and pos = -1 */
185  SCIP_BDCHGINFO** bdchginfo, /**< pointer to store bound change information */
186  BMS_BLKMEM* blkmem, /**< block memory */
187  SCIP_VAR* var, /**< active variable that changed the bounds */
188  SCIP_BOUNDTYPE boundtype, /**< type of bound for var: lower or upper bound */
189  SCIP_Real oldbound, /**< old value for bound */
190  SCIP_Real newbound /**< new value for bound */
191  );
192 
193 /** frees a bound change information object */
194 void SCIPbdchginfoFree(
195  SCIP_BDCHGINFO** bdchginfo, /**< pointer to store bound change information */
196  BMS_BLKMEM* blkmem /**< block memory */
197  );
198 
199 /** returns the relaxed bound change type */
201  SCIP_BDCHGINFO* bdchginfo /**< bound change to add to the conflict set */
202  );
203 
204 /*
205  * methods for variables
206  */
207 
208 /** creates and captures an original problem variable; an integer variable with bounds
209  * zero and one is automatically converted into a binary variable
210  */
212  SCIP_VAR** var, /**< pointer to variable data */
213  BMS_BLKMEM* blkmem, /**< block memory */
214  SCIP_SET* set, /**< global SCIP settings */
215  SCIP_STAT* stat, /**< problem statistics */
216  const char* name, /**< name of variable */
217  SCIP_Real lb, /**< lower bound of variable */
218  SCIP_Real ub, /**< upper bound of variable */
219  SCIP_Real obj, /**< objective function value */
220  SCIP_VARTYPE vartype, /**< type of variable */
221  SCIP_Bool initial, /**< should var's column be present in the initial root LP? */
222  SCIP_Bool removable, /**< is var's column removable from the LP (due to aging or cleanup)? */
223  SCIP_DECL_VARDELORIG ((*vardelorig)), /**< frees user data of original variable, or NULL */
224  SCIP_DECL_VARTRANS ((*vartrans)), /**< creates transformed user data by transforming original user data, or NULL */
225  SCIP_DECL_VARDELTRANS ((*vardeltrans)), /**< frees user data of transformed variable, or NULL */
226  SCIP_DECL_VARCOPY ((*varcopy)), /**< copies variable data if wanted to subscip, or NULL */
227  SCIP_VARDATA* vardata /**< user data for this specific variable */
228  );
229 
230 /** creates and captures a loose variable belonging to the transformed problem; an integer variable with bounds
231  * zero and one is automatically converted into a binary variable
232  */
234  SCIP_VAR** var, /**< pointer to variable data */
235  BMS_BLKMEM* blkmem, /**< block memory */
236  SCIP_SET* set, /**< global SCIP settings */
237  SCIP_STAT* stat, /**< problem statistics */
238  const char* name, /**< name of variable */
239  SCIP_Real lb, /**< lower bound of variable */
240  SCIP_Real ub, /**< upper bound of variable */
241  SCIP_Real obj, /**< objective function value */
242  SCIP_VARTYPE vartype, /**< type of variable */
243  SCIP_Bool initial, /**< should var's column be present in the initial root LP? */
244  SCIP_Bool removable, /**< is var's column removable from the LP (due to aging or cleanup)? */
245  SCIP_DECL_VARDELORIG ((*vardelorig)), /**< frees user data of original variable, or NULL */
246  SCIP_DECL_VARTRANS ((*vartrans)), /**< creates transformed user data by transforming original user data, or NULL */
247  SCIP_DECL_VARDELTRANS ((*vardeltrans)), /**< frees user data of transformed variable, or NULL */
248  SCIP_DECL_VARCOPY ((*varcopy)), /**< copies variable data if wanted to subscip, or NULL */
249  SCIP_VARDATA* vardata /**< user data for this specific variable */
250  );
251 
252 /** copies and captures a variable from source to target SCIP; an integer variable with bounds zero and one is
253  * automatically converted into a binary variable; in case the variable data cannot be copied the variable is not
254  * copied at all
255  */
257  SCIP_VAR** var, /**< pointer to store the target variable */
258  BMS_BLKMEM* blkmem, /**< block memory */
259  SCIP_SET* set, /**< global SCIP settings */
260  SCIP_STAT* stat, /**< problem statistics */
261  SCIP* sourcescip, /**< source SCIP data structure */
262  SCIP_VAR* sourcevar, /**< source variable */
263  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
264  * target variables */
265  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
266  * target constraints */
267  SCIP_Bool global /**< should global or local bounds be used? */
268  );
269 
270 /** parses variable information (in cip format) out of a string; if the parsing process was successful an original
271  * variable is created and captured; if variable is of integral type, fractional bounds are automatically rounded; an
272  * integer variable with bounds zero and one is automatically converted into a binary variable
273  */
275  SCIP_VAR** var, /**< pointer to variable data */
276  BMS_BLKMEM* blkmem, /**< block memory */
277  SCIP_SET* set, /**< global SCIP settings */
278  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
279  SCIP_STAT* stat, /**< problem statistics */
280  const char* str, /**< string to parse */
281  SCIP_Bool initial, /**< should var's column be present in the initial root LP? */
282  SCIP_Bool removable, /**< is var's column removable from the LP (due to aging or cleanup)? */
283  SCIP_DECL_VARCOPY ((*varcopy)), /**< copies variable data if wanted to subscip, or NULL */
284  SCIP_DECL_VARDELORIG ((*vardelorig)), /**< frees user data of original variable */
285  SCIP_DECL_VARTRANS ((*vartrans)), /**< creates transformed user data by transforming original user data */
286  SCIP_DECL_VARDELTRANS ((*vardeltrans)), /**< frees user data of transformed variable */
287  SCIP_VARDATA* vardata, /**< user data for this specific variable */
288  char** endptr, /**< pointer to store the final string position if successfully */
289  SCIP_Bool* success /**< pointer store if the paring process was successful */
290  );
291 
292 /** parses variable information (in cip format) out of a string; if the parsing process was successful a loose variable
293  * belonging to the transformed problem is created and captured; if variable is of integral type, fractional bounds are
294  * automatically rounded; an integer variable with bounds zero and one is automatically converted into a binary
295  * variable
296  */
298  SCIP_VAR** var, /**< pointer to variable data */
299  BMS_BLKMEM* blkmem, /**< block memory */
300  SCIP_SET* set, /**< global SCIP settings */
301  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
302  SCIP_STAT* stat, /**< problem statistics */
303  const char* str, /**< string to parse */
304  SCIP_Bool initial, /**< should var's column be present in the initial root LP? */
305  SCIP_Bool removable, /**< is var's column removable from the LP (due to aging or cleanup)? */
306  SCIP_DECL_VARCOPY ((*varcopy)), /**< copies variable data if wanted to subscip, or NULL */
307  SCIP_DECL_VARDELORIG ((*vardelorig)), /**< frees user data of original variable */
308  SCIP_DECL_VARTRANS ((*vartrans)), /**< creates transformed user data by transforming original user data */
309  SCIP_DECL_VARDELTRANS ((*vardeltrans)), /**< frees user data of transformed variable */
310  SCIP_VARDATA* vardata, /**< user data for this specific variable */
311  char** endptr, /**< pointer to store the final string position if successfully */
312  SCIP_Bool* success /**< pointer store if the paring process was successful */
313  );
314 
315 /** increases usage counter of variable */
316 void SCIPvarCapture(
317  SCIP_VAR* var /**< variable */
318  );
319 
320 /** decreases usage counter of variable, and frees memory if necessary */
322  SCIP_VAR** var, /**< pointer to variable */
323  BMS_BLKMEM* blkmem, /**< block memory */
324  SCIP_SET* set, /**< global SCIP settings */
325  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
326  SCIP_LP* lp /**< current LP data (may be NULL, if it's not a column variable) */
327  );
328 
329 /** change variable name */
330 /** change variable name */
332  SCIP_VAR* var, /**< problem variable */
333  BMS_BLKMEM* blkmem, /**< block memory */
334  const char* name /**< name of variable */
335  );
336 
337 /** initializes variable data structure for solving */
338 void SCIPvarInitSolve(
339  SCIP_VAR* var /**< problem variable */
340  );
341 
342 /** gets and captures transformed variable of a given variable; if the variable is not yet transformed,
343  * a new transformed variable for this variable is created
344  */
346  SCIP_VAR* origvar, /**< original problem variable */
347  BMS_BLKMEM* blkmem, /**< block memory of transformed problem */
348  SCIP_SET* set, /**< global SCIP settings */
349  SCIP_STAT* stat, /**< problem statistics */
350  SCIP_OBJSENSE objsense, /**< objective sense of original problem; transformed is always MINIMIZE */
351  SCIP_VAR** transvar /**< pointer to store the transformed variable */
352  );
353 
354 /** gets corresponding transformed variable of an original or negated original variable */
356  SCIP_VAR* origvar, /**< original problem variable */
357  BMS_BLKMEM* blkmem, /**< block memory of transformed problem */
358  SCIP_SET* set, /**< global SCIP settings */
359  SCIP_STAT* stat, /**< problem statistics */
360  SCIP_VAR** transvar /**< pointer to store the transformed variable, or NULL if not existing yet */
361  );
362 
363 /** converts transformed variable into column variable and creates LP column */
365  SCIP_VAR* var, /**< problem variable */
366  BMS_BLKMEM* blkmem, /**< block memory */
367  SCIP_SET* set, /**< global SCIP settings */
368  SCIP_STAT* stat, /**< problem statistics */
369  SCIP_PROB* prob, /**< problem data */
370  SCIP_LP* lp /**< current LP data */
371  );
372 
373 /** converts column transformed variable back into loose variable, frees LP column */
375  SCIP_VAR* var, /**< problem variable */
376  BMS_BLKMEM* blkmem, /**< block memory */
377  SCIP_SET* set, /**< global SCIP settings */
378  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
379  SCIP_PROB* prob, /**< problem data */
380  SCIP_LP* lp /**< current LP data */
381  );
382 
383 /** converts variable into fixed variable */
385  SCIP_VAR* var, /**< problem variable */
386  BMS_BLKMEM* blkmem, /**< block memory */
387  SCIP_SET* set, /**< global SCIP settings */
388  SCIP_STAT* stat, /**< problem statistics */
389  SCIP_PROB* transprob, /**< tranformed problem data */
390  SCIP_PROB* origprob, /**< original problem data */
391  SCIP_PRIMAL* primal, /**< primal data */
392  SCIP_TREE* tree, /**< branch and bound tree */
393  SCIP_REOPT* reopt, /**< reoptimization data structure */
394  SCIP_LP* lp, /**< current LP data */
395  SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */
396  SCIP_EVENTFILTER* eventfilter, /**< event filter for global (not variable dependent) events */
397  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
398  SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
399  SCIP_Real fixedval, /**< value to fix variable at */
400  SCIP_Bool* infeasible, /**< pointer to store whether the fixing is infeasible */
401  SCIP_Bool* fixed /**< pointer to store whether the fixing was performed (variable was unfixed) */
402  );
403 
404 /** transforms given variables, scalars and constant to the corresponding active variables, scalars and constant
405  *
406  * If the number of needed active variables is greater than the available slots in the variable array, nothing happens except
407  * that the required size is stored in the corresponding variable; hence, if afterwards the required size is greater than the
408  * available slots (varssize), nothing happens; otherwise, the active variable representation is stored in the arrays.
409  *
410  * The reason for this approach is that we cannot reallocate memory, since we do not know how the
411  * memory has been allocated (e.g., by a C++ 'new' or SCIP functions).
412  */
414  SCIP_SET* set, /**< global SCIP settings */
415  SCIP_VAR** vars, /**< variable array to get active variables */
416  SCIP_Real* scalars, /**< scalars a_1, ..., a_n in linear sum a_1*x_1 + ... + a_n*x_n + c */
417  int* nvars, /**< pointer to number of variables and values in vars and vals array */
418  int varssize, /**< available slots in vars and scalars array */
419  SCIP_Real* constant, /**< pointer to constant c in linear sum a_1*x_1 + ... + a_n*x_n + c */
420  int* requiredsize, /**< pointer to store the required array size for the active variables */
421  SCIP_Bool mergemultiples /**< should multiple occurrences of a var be replaced by a single coeff? */
422  );
423 
424 /** transforms given variable, scalar and constant to the corresponding active, fixed, or
425  * multi-aggregated variable, scalar and constant; if the variable resolves to a fixed variable,
426  * "scalar" will be 0.0 and the value of the sum will be stored in "constant"; a multi-aggregation
427  * with only one active variable (this can happen due to fixings after the multi-aggregation),
428  * is treated like an aggregation; if the multi-aggregation constant is infinite, "scalar" will be 0.0
429  */
431  SCIP_VAR** var, /**< pointer to problem variable x in sum a*x + c */
432  SCIP_SET* set, /**< global SCIP settings */
433  SCIP_Real* scalar, /**< pointer to scalar a in sum a*x + c */
434  SCIP_Real* constant /**< pointer to constant c in sum a*x + c */
435  );
436 
437 
438 /** flattens aggregation graph of multi-aggregated variable in order to avoid exponential recursion later-on */
440  SCIP_VAR* var, /**< problem variable */
441  BMS_BLKMEM* blkmem, /**< block memory */
442  SCIP_SET* set, /**< global SCIP settings */
443  SCIP_EVENTQUEUE* eventqueue /**< event queue */
444  );
445 
446 /** return for given variables all their active counterparts; all active variables will be pairwise different */
448  SCIP_SET* set, /**< global SCIP settings */
449  SCIP_VAR** vars, /**< variable array with given variables and as output all active
450  * variables, if enough slots exist
451  */
452  int* nvars, /**< number of given variables, and as output number of active variables,
453  * if enough slots exist
454  */
455  int varssize, /**< available slots in vars array */
456  int* requiredsize /**< pointer to store the required array size for the active variables */
457  );
458 
459 /** performs second step of SCIPaggregateVars():
460  * the variable to be aggregated is chosen among active problem variables x' and y', preferring a less strict variable
461  * type as aggregation variable (i.e. continuous variables are preferred over implicit integers, implicit integers
462  * or integers over binaries). If none of the variables is continuous, it is tried to find an integer
463  * aggregation (i.e. integral coefficients a'' and b'', such that a''*x' + b''*y' == c''). This can lead to
464  * the detection of infeasibility (e.g. if c'' is fractional), or to a rejection of the aggregation (denoted by
465  * aggregated == FALSE), if the resulting integer coefficients are too large and thus numerically instable.
466  */
468  SCIP_SET* set, /**< global SCIP settings */
469  BMS_BLKMEM* blkmem, /**< block memory */
470  SCIP_STAT* stat, /**< problem statistics */
471  SCIP_PROB* transprob, /**< tranformed problem data */
472  SCIP_PROB* origprob, /**< original problem data */
473  SCIP_PRIMAL* primal, /**< primal data */
474  SCIP_TREE* tree, /**< branch and bound tree */
475  SCIP_REOPT* reopt, /**< reoptimization data structure */
476  SCIP_LP* lp, /**< current LP data */
477  SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
478  SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */
479  SCIP_EVENTFILTER* eventfilter, /**< event filter for global (not variable dependent) events */
480  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
481  SCIP_VAR* varx, /**< variable x in equality a*x + b*y == c */
482  SCIP_VAR* vary, /**< variable y in equality a*x + b*y == c */
483  SCIP_Real scalarx, /**< multiplier a in equality a*x + b*y == c */
484  SCIP_Real scalary, /**< multiplier b in equality a*x + b*y == c */
485  SCIP_Real rhs, /**< right hand side c in equality a*x + b*y == c */
486  SCIP_Bool* infeasible, /**< pointer to store whether the aggregation is infeasible */
487  SCIP_Bool* aggregated /**< pointer to store whether the aggregation was successful */
488  );
489 
490 /** converts loose variable into aggregated variable */
492  SCIP_VAR* var, /**< loose problem variable */
493  BMS_BLKMEM* blkmem, /**< block memory */
494  SCIP_SET* set, /**< global SCIP settings */
495  SCIP_STAT* stat, /**< problem statistics */
496  SCIP_PROB* transprob, /**< tranformed problem data */
497  SCIP_PROB* origprob, /**< original problem data */
498  SCIP_PRIMAL* primal, /**< primal data */
499  SCIP_TREE* tree, /**< branch and bound tree */
500  SCIP_REOPT* reopt, /**< reoptimization data structure */
501  SCIP_LP* lp, /**< current LP data */
502  SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
503  SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */
504  SCIP_EVENTFILTER* eventfilter, /**< event filter for global (not variable dependent) events */
505  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
506  SCIP_VAR* aggvar, /**< loose variable y in aggregation x = a*y + c */
507  SCIP_Real scalar, /**< multiplier a in aggregation x = a*y + c */
508  SCIP_Real constant, /**< constant shift c in aggregation x = a*y + c */
509  SCIP_Bool* infeasible, /**< pointer to store whether the aggregation is infeasible */
510  SCIP_Bool* aggregated /**< pointer to store whether the aggregation was successful */
511  );
512 
513 /** converts variable into multi-aggregated variable */
515  SCIP_VAR* var, /**< problem variable */
516  BMS_BLKMEM* blkmem, /**< block memory */
517  SCIP_SET* set, /**< global SCIP settings */
518  SCIP_STAT* stat, /**< problem statistics */
519  SCIP_PROB* transprob, /**< tranformed problem data */
520  SCIP_PROB* origprob, /**< original problem data */
521  SCIP_PRIMAL* primal, /**< primal data */
522  SCIP_TREE* tree, /**< branch and bound tree */
523  SCIP_REOPT* reopt, /**< reoptimization data structure */
524  SCIP_LP* lp, /**< current LP data */
525  SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
526  SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */
527  SCIP_EVENTFILTER* eventfilter, /**< event filter for global (not variable dependent) events */
528  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
529  int naggvars, /**< number n of variables in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
530  SCIP_VAR** aggvars, /**< variables y_i in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
531  SCIP_Real* scalars, /**< multipliers a_i in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
532  SCIP_Real constant, /**< constant shift c in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
533  SCIP_Bool* infeasible, /**< pointer to store whether the aggregation is infeasible */
534  SCIP_Bool* aggregated /**< pointer to store whether the aggregation was successful */
535  );
536 
537 /** returns whether variable is not allowed to be aggregated */
539  SCIP_VAR* var /**< problem variable */
540  );
541 
542 /** returns whether variable is not allowed to be multi-aggregated */
544  SCIP_VAR* var /**< problem variable */
545  );
546 
547 /** returns whether the variable was flagged for deletion from global structures (cliques etc.) */
549  SCIP_VAR* var /**< problem variable */
550  );
551 
552 /** gets negated variable x' = offset - x of problem variable x; the negated variable is created if not yet existing;
553  * the negation offset of binary variables is always 1, the offset of other variables is fixed to lb + ub when the
554  * negated variable is created
555  */
557  SCIP_VAR* var, /**< problem variable to negate */
558  BMS_BLKMEM* blkmem, /**< block memory of transformed problem */
559  SCIP_SET* set, /**< global SCIP settings */
560  SCIP_STAT* stat, /**< problem statistics */
561  SCIP_VAR** negvar /**< pointer to store the negated variable */
562  );
563 
564 /** informs variable that its position in problem's vars array changed */
566  SCIP_VAR* var, /**< problem variable */
567  int probindex /**< new problem index of variable */
568  );
569 
570 /** gives the variable a new name
571  *
572  * @note the old pointer is overwritten, which might result in a memory leakage
573  */
575  SCIP_VAR* var, /**< problem variable */
576  const char* name /**< new name of variable */
577  );
578 
579 /** informs variable that it will be removed from the problem; adjusts probindex and removes variable from the
580  * implication graph;
581  * If 'final' is TRUE, the thorough implication graph removal is not performed. Instead, only the
582  * variable bounds and implication data structures of the variable are freed. Since in the final removal
583  * of all variables from the transformed problem, this deletes the implication graph completely and is faster
584  * than removing the variables one by one, each time updating all lists of the other variables.
585  */
587  SCIP_VAR* var, /**< problem variable */
588  BMS_BLKMEM* blkmem, /**< block memory buffer */
589  SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
590  SCIP_SET* set, /**< global SCIP settings */
591  SCIP_Bool final /**< is this the final removal of all problem variables? */
592  );
593 
594 /** marks the variable to be deleted from the problem */
595 void SCIPvarMarkDeleted(
596  SCIP_VAR* var /**< problem variable */
597  );
598 
599 /** marks the variable to not to be maggregated */
601  SCIP_VAR* var /**< problem variable */
602  );
603 
604 /** marks the variable to not to be multi-aggregated */
606  SCIP_VAR* var /**< problem variable */
607  );
608 
609 /** modifies lock numbers for rounding */
611  SCIP_VAR* var, /**< problem variable */
612  BMS_BLKMEM* blkmem, /**< block memory */
613  SCIP_SET* set, /**< global SCIP settings */
614  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
615  SCIP_LOCKTYPE locktype, /**< type of the variable locks */
616  int addnlocksdown, /**< increase in number of rounding down locks */
617  int addnlocksup /**< increase in number of rounding up locks */
618  );
619 
620 /** changes type of variable; cannot be called, if var belongs to a problem */
622  SCIP_VAR* var, /**< problem variable to change */
623  BMS_BLKMEM* blkmem, /**< block memory */
624  SCIP_SET* set, /**< global SCIP settings */
625  SCIP_PRIMAL* primal, /**< primal data */
626  SCIP_LP* lp, /**< current LP data */
627  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
628  SCIP_VARTYPE vartype /**< new type of variable */
629  );
630 
631 /** changes objective value of variable */
633  SCIP_VAR* var, /**< variable to change */
634  BMS_BLKMEM* blkmem, /**< block memory */
635  SCIP_SET* set, /**< global SCIP settings */
636  SCIP_PROB* prob, /**< problem data */
637  SCIP_PRIMAL* primal, /**< primal data */
638  SCIP_LP* lp, /**< current LP data */
639  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
640  SCIP_Real newobj /**< new objective value for variable */
641  );
642 
643 /** adds value to objective value of variable */
645  SCIP_VAR* var, /**< variable to change */
646  BMS_BLKMEM* blkmem, /**< block memory */
647  SCIP_SET* set, /**< global SCIP settings */
648  SCIP_STAT* stat, /**< problem statistics */
649  SCIP_PROB* transprob, /**< tranformed problem data */
650  SCIP_PROB* origprob, /**< original problem data */
651  SCIP_PRIMAL* primal, /**< primal data */
652  SCIP_TREE* tree, /**< branch and bound tree */
653  SCIP_REOPT* reopt, /**< reoptimization data structure */
654  SCIP_LP* lp, /**< current LP data */
655  SCIP_EVENTFILTER* eventfilter, /**< event filter for global (not variable dependent) events */
656  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
657  SCIP_Real addobj /**< additional objective value for variable */
658  );
659 
660 /** changes objective value of variable in current dive */
662  SCIP_VAR* var, /**< problem variable to change */
663  SCIP_SET* set, /**< global SCIP settings */
664  SCIP_LP* lp, /**< current LP data */
665  SCIP_Real newobj /**< new objective value for variable */
666  );
667 
668 /** adjust lower bound to integral value, if variable is integral */
669 void SCIPvarAdjustLb(
670  SCIP_VAR* var, /**< problem variable */
671  SCIP_SET* set, /**< global SCIP settings */
672  SCIP_Real* lb /**< pointer to lower bound to adjust */
673  );
674 
675 /** adjust upper bound to integral value, if variable is integral */
676 void SCIPvarAdjustUb(
677  SCIP_VAR* var, /**< problem variable */
678  SCIP_SET* set, /**< global SCIP settings */
679  SCIP_Real* ub /**< pointer to upper bound to adjust */
680  );
681 
682 /** adjust lower or upper bound to integral value, if variable is integral */
683 void SCIPvarAdjustBd(
684  SCIP_VAR* var, /**< problem variable */
685  SCIP_SET* set, /**< global SCIP settings */
686  SCIP_BOUNDTYPE boundtype, /**< type of bound to adjust */
687  SCIP_Real* bd /**< pointer to bound to adjust */
688  );
689 
690 /** changes lower bound of original variable in original problem */
692  SCIP_VAR* var, /**< problem variable to change */
693  SCIP_SET* set, /**< global SCIP settings */
694  SCIP_Real newbound /**< new bound for variable */
695  );
696 
697 /** changes upper bound of original variable in original problem */
699  SCIP_VAR* var, /**< problem variable to change */
700  SCIP_SET* set, /**< global SCIP settings */
701  SCIP_Real newbound /**< new bound for variable */
702  );
703 
704 /** changes global lower bound of variable; if possible, adjusts bound to integral value;
705  * updates local lower bound if the global bound is tighter
706  */
708  SCIP_VAR* var, /**< problem variable to change */
709  BMS_BLKMEM* blkmem, /**< block memory */
710  SCIP_SET* set, /**< global SCIP settings */
711  SCIP_STAT* stat, /**< problem statistics */
712  SCIP_LP* lp, /**< current LP data, may be NULL for original variables */
713  SCIP_BRANCHCAND* branchcand, /**< branching candidate storage, may be NULL for original variables */
714  SCIP_EVENTQUEUE* eventqueue, /**< event queue, may be NULL for original variables */
715  SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
716  SCIP_Real newbound /**< new bound for variable */
717  );
718 
719 /** changes global upper bound of variable; if possible, adjusts bound to integral value;
720  * updates local upper bound if the global bound is tighter
721  */
723  SCIP_VAR* var, /**< problem variable to change */
724  BMS_BLKMEM* blkmem, /**< block memory */
725  SCIP_SET* set, /**< global SCIP settings */
726  SCIP_STAT* stat, /**< problem statistics */
727  SCIP_LP* lp, /**< current LP data, may be NULL for original variables */
728  SCIP_BRANCHCAND* branchcand, /**< branching candidate storage, may be NULL for original variables */
729  SCIP_EVENTQUEUE* eventqueue, /**< event queue, may be NULL for original variables */
730  SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
731  SCIP_Real newbound /**< new bound for variable */
732  );
733 
734 /** changes global bound of variable; if possible, adjusts bound to integral value;
735  * updates local bound if the global bound is tighter
736  */
738  SCIP_VAR* var, /**< problem variable to change */
739  BMS_BLKMEM* blkmem, /**< block memory */
740  SCIP_SET* set, /**< global SCIP settings */
741  SCIP_STAT* stat, /**< problem statistics */
742  SCIP_LP* lp, /**< current LP data, may be NULL for original variables */
743  SCIP_BRANCHCAND* branchcand, /**< branching candidate storage, may be NULL for original variables */
744  SCIP_EVENTQUEUE* eventqueue, /**< event queue, may be NULL for original variables */
745  SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
746  SCIP_Real newbound, /**< new bound for variable */
747  SCIP_BOUNDTYPE boundtype /**< type of bound: lower or upper bound */
748  );
749 
750 /** changes current local lower bound of variable; if possible, adjusts bound to integral value; stores inference
751  * information in variable
752  */
754  SCIP_VAR* var, /**< problem variable to change */
755  BMS_BLKMEM* blkmem, /**< block memory */
756  SCIP_SET* set, /**< global SCIP settings */
757  SCIP_STAT* stat, /**< problem statistics */
758  SCIP_LP* lp, /**< current LP data, may be NULL for original variables */
759  SCIP_BRANCHCAND* branchcand, /**< branching candidate storage, may be NULL for original variables */
760  SCIP_EVENTQUEUE* eventqueue, /**< event queue, may be NULL for original variables */
761  SCIP_Real newbound /**< new bound for variable */
762  );
763 
764 /** changes current local upper bound of variable; if possible, adjusts bound to integral value; stores inference
765  * information in variable
766  */
768  SCIP_VAR* var, /**< problem variable to change */
769  BMS_BLKMEM* blkmem, /**< block memory */
770  SCIP_SET* set, /**< global SCIP settings */
771  SCIP_STAT* stat, /**< problem statistics */
772  SCIP_LP* lp, /**< current LP data, may be NULL for original variables */
773  SCIP_BRANCHCAND* branchcand, /**< branching candidate storage, may be NULL for original variables */
774  SCIP_EVENTQUEUE* eventqueue, /**< event queue, may be NULL for original variables */
775  SCIP_Real newbound /**< new bound for variable */
776  );
777 
778 /** changes current local bound of variable; if possible, adjusts bound to integral value; stores inference
779  * information in variable
780  */
782  SCIP_VAR* var, /**< problem variable to change */
783  BMS_BLKMEM* blkmem, /**< block memory */
784  SCIP_SET* set, /**< global SCIP settings */
785  SCIP_STAT* stat, /**< problem statistics */
786  SCIP_LP* lp, /**< current LP data, may be NULL for original variables */
787  SCIP_BRANCHCAND* branchcand, /**< branching candidate storage, may be NULL for original variables */
788  SCIP_EVENTQUEUE* eventqueue, /**< event queue, may be NULL for original variables */
789  SCIP_Real newbound, /**< new bound for variable */
790  SCIP_BOUNDTYPE boundtype /**< type of bound: lower or upper bound */
791  );
792 
793 /** changes lazy lower bound of the variable, this is only possible if the variable is not in the LP yet */
795  SCIP_VAR* var, /**< problem variable */
796  SCIP_SET* set, /**< global SCIP settings */
797  SCIP_Real lazylb /**< the lazy lower bound to be set */
798  );
799 
800 /** changes lazy upper bound of the variable, this is only possible if the variable is not in the LP yet */
802  SCIP_VAR* var, /**< problem variable */
803  SCIP_SET* set, /**< global SCIP settings */
804  SCIP_Real lazylb /**< the lazy lower bound to be set */
805  );
806 
807 /** changes lower bound of variable in current dive; if possible, adjusts bound to integral value */
809  SCIP_VAR* var, /**< problem variable to change */
810  SCIP_SET* set, /**< global SCIP settings */
811  SCIP_LP* lp, /**< current LP data */
812  SCIP_Real newbound /**< new bound for variable */
813  );
814 
815 /** changes upper bound of variable in current dive; if possible, adjusts bound to integral value */
817  SCIP_VAR* var, /**< problem variable to change */
818  SCIP_SET* set, /**< global SCIP settings */
819  SCIP_LP* lp, /**< current LP data */
820  SCIP_Real newbound /**< new bound for variable */
821  );
822 
823 /** for a multi-aggregated variable, gives the local lower bound computed by adding the local bounds from all aggregation variables
824  * this lower bound may be tighter than the one given by SCIPvarGetLbLocal, since the latter is not updated if bounds of aggregation variables are changing
825  * calling this function for a non-multi-aggregated variable is not allowed
826  */
828  SCIP_VAR* var, /**< problem variable */
829  SCIP_SET* set /**< global SCIP settings */
830  );
831 
832 /** for a multi-aggregated variable, gives the local upper bound computed by adding the local bounds from all aggregation variables
833  * this upper bound may be tighter than the one given by SCIPvarGetUbLocal, since the latter is not updated if bounds of aggregation variables are changing
834  * calling this function for a non-multi-aggregated variable is not allowed
835  */
837  SCIP_VAR* var, /**< problem variable */
838  SCIP_SET* set /**< global SCIP settings */
839  );
840 
841 /** for a multi-aggregated variable, gives the global lower bound computed by adding the global bounds from all aggregation variables
842  * this global bound may be tighter than the one given by SCIPvarGetLbGlobal, since the latter is not updated if bounds of aggregation variables are changing
843  * calling this function for a non-multi-aggregated variable is not allowed
844  */
846  SCIP_VAR* var, /**< problem variable */
847  SCIP_SET* set /**< global SCIP settings */
848  );
849 
850 /** for a multi-aggregated variable, gives the global upper bound computed by adding the global bounds from all aggregation variables
851  * this upper bound may be tighter than the one given by SCIPvarGetUbGlobal, since the latter is not updated if bounds of aggregation variables are changing
852  * calling this function for a non-multi-aggregated variable is not allowed
853  */
855  SCIP_VAR* var, /**< problem variable */
856  SCIP_SET* set /**< global SCIP settings */
857  );
858 
859 /** adds a hole to the original domain of the variable*/
861  SCIP_VAR* var, /**< problem variable */
862  BMS_BLKMEM* blkmem, /**< block memory */
863  SCIP_SET* set, /**< global SCIP settings */
864  SCIP_Real left, /**< left bound of open interval in new hole */
865  SCIP_Real right /**< right bound of open interval in new hole */
866  );
867 
868 /** adds a hole to the variable's global domain */
870  SCIP_VAR* var, /**< problem variable */
871  BMS_BLKMEM* blkmem, /**< block memory */
872  SCIP_SET* set, /**< global SCIP settings */
873  SCIP_STAT* stat, /**< problem statistics */
874  SCIP_EVENTQUEUE* eventqueue, /**< event queue, may be NULL for original variables */
875  SCIP_Real left, /**< left bound of open interval in new hole */
876  SCIP_Real right, /**< right bound of open interval in new hole */
877  SCIP_Bool* added /**< pointer to store whether the hole was added, or NULL */
878  );
879 
880 /** adds a hole to the variable's current local domain */
882  SCIP_VAR* var, /**< problem variable */
883  BMS_BLKMEM* blkmem, /**< block memory */
884  SCIP_SET* set, /**< global SCIP settings */
885  SCIP_STAT* stat, /**< problem statistics */
886  SCIP_EVENTQUEUE* eventqueue, /**< event queue, may be NULL for original variables */
887  SCIP_Real left, /**< left bound of open interval in new hole */
888  SCIP_Real right, /**< right bound of open interval in new hole */
889  SCIP_Bool* added /**< pointer to store whether the hole was added, or NULL */
890  );
891 
892 /** resets the global and local bounds of original variable to their original values */
894  SCIP_VAR* var, /**< problem variable */
895  BMS_BLKMEM* blkmem, /**< block memory */
896  SCIP_SET* set, /**< global SCIP settings */
897  SCIP_STAT* stat /**< problem statistics */
898  );
899 
900 /** returns at which depth in the tree a bound change was applied to the variable that conflicts with the
901  * given bound; returns -1 if the bound does not conflict with the current local bounds of the variable
902  */
904  SCIP_VAR* var, /**< problem variable */
905  SCIP_SET* set, /**< global SCIP settings */
906  SCIP_BOUNDTYPE boundtype, /**< bound type of the conflicting bound */
907  SCIP_Real bound /**< conflicting bound */
908  );
909 
910 /** informs variable x about a globally valid variable lower bound x >= b*z + d with integer variable z;
911  * if z is binary, the corresponding valid implication for z is also added;
912  * improves the global bounds of the variable and the vlb variable if possible
913  */
915  SCIP_VAR* var, /**< problem variable */
916  BMS_BLKMEM* blkmem, /**< block memory */
917  SCIP_SET* set, /**< global SCIP settings */
918  SCIP_STAT* stat, /**< problem statistics */
919  SCIP_PROB* transprob, /**< transformed problem */
920  SCIP_PROB* origprob, /**< original problem */
921  SCIP_TREE* tree, /**< branch and bound tree if in solving stage */
922  SCIP_REOPT* reopt, /**< reoptimization data structure */
923  SCIP_LP* lp, /**< current LP data */
924  SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
925  SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */
926  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
927  SCIP_VAR* vlbvar, /**< variable z in x >= b*z + d */
928  SCIP_Real vlbcoef, /**< coefficient b in x >= b*z + d */
929  SCIP_Real vlbconstant, /**< constant d in x >= b*z + d */
930  SCIP_Bool transitive, /**< should transitive closure of implication also be added? */
931  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
932  int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
933  );
934 
935 /** informs variable x about a globally valid variable upper bound x <= b*z + d with integer variable z;
936  * if z is binary, the corresponding valid implication for z is also added;
937  * updates the global bounds of the variable and the vub variable correspondingly
938  */
940  SCIP_VAR* var, /**< problem variable */
941  BMS_BLKMEM* blkmem, /**< block memory */
942  SCIP_SET* set, /**< global SCIP settings */
943  SCIP_STAT* stat, /**< problem statistics */
944  SCIP_PROB* transprob, /**< transformed problem */
945  SCIP_PROB* origprob, /**< original problem */
946  SCIP_TREE* tree, /**< branch and bound tree if in solving stage */
947  SCIP_REOPT* reopt, /**< reoptimization data structure */
948  SCIP_LP* lp, /**< current LP data */
949  SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
950  SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */
951  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
952  SCIP_VAR* vubvar, /**< variable z in x <= b*z + d */
953  SCIP_Real vubcoef, /**< coefficient b in x <= b*z + d */
954  SCIP_Real vubconstant, /**< constant d in x <= b*z + d */
955  SCIP_Bool transitive, /**< should transitive closure of implication also be added? */
956  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
957  int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
958  );
959 
960 /** informs binary variable x about a globally valid implication: x == 0 or x == 1 ==> y <= b or y >= b;
961  * also adds the corresponding implication or variable bound to the implied variable;
962  * if the implication is conflicting, the variable is fixed to the opposite value;
963  * if the variable is already fixed to the given value, the implication is performed immediately;
964  * if the implication is redundant with respect to the variables' global bounds, it is ignored
965  */
967  SCIP_VAR* var, /**< problem variable */
968  BMS_BLKMEM* blkmem, /**< block memory */
969  SCIP_SET* set, /**< global SCIP settings */
970  SCIP_STAT* stat, /**< problem statistics */
971  SCIP_PROB* transprob, /**< transformed problem */
972  SCIP_PROB* origprob, /**< original problem */
973  SCIP_TREE* tree, /**< branch and bound tree if in solving stage */
974  SCIP_REOPT* reopt, /**< reoptimization data structure */
975  SCIP_LP* lp, /**< current LP data */
976  SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
977  SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */
978  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
979  SCIP_Bool varfixing, /**< FALSE if y should be added in implications for x == 0, TRUE for x == 1 */
980  SCIP_VAR* implvar, /**< variable y in implication y <= b or y >= b */
981  SCIP_BOUNDTYPE impltype, /**< type of implication y <= b (SCIP_BOUNDTYPE_UPPER) or y >= b (SCIP_BOUNDTYPE_LOWER) */
982  SCIP_Real implbound, /**< bound b in implication y <= b or y >= b */
983  SCIP_Bool transitive, /**< should transitive closure of implication also be added? */
984  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
985  int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
986  );
987 
988 /** fixes the bounds of a binary variable to the given value, counting bound changes and detecting infeasibility */
990  SCIP_VAR* var, /**< problem variable */
991  BMS_BLKMEM* blkmem, /**< block memory */
992  SCIP_SET* set, /**< global SCIP settings */
993  SCIP_STAT* stat, /**< problem statistics */
994  SCIP_PROB* transprob, /**< transformed problem */
995  SCIP_PROB* origprob, /**< original problem */
996  SCIP_TREE* tree, /**< branch and bound tree if in solving stage */
997  SCIP_REOPT* reopt, /**< reoptimization data structure */
998  SCIP_LP* lp, /**< current LP data */
999  SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */
1000  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
1001  SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
1002  SCIP_Bool value, /**< value to fix variable to */
1003  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
1004  int* nbdchgs /**< pointer to count the number of performed bound changes, or NULL */
1005  );
1006 
1007 /** adds the variable to the given clique and updates the list of cliques the binary variable is member of;
1008  * if the variable now appears twice in the clique with the same value, it is fixed to the opposite value;
1009  * if the variable now appears twice in the clique with opposite values, all other variables are fixed to
1010  * the opposite of the value they take in the clique
1011  */
1013  SCIP_VAR* var, /**< problem variable */
1014  BMS_BLKMEM* blkmem, /**< block memory */
1015  SCIP_SET* set, /**< global SCIP settings */
1016  SCIP_STAT* stat, /**< problem statistics */
1017  SCIP_PROB* transprob, /**< transformed problem */
1018  SCIP_PROB* origprob, /**< original problem */
1019  SCIP_TREE* tree, /**< branch and bound tree if in solving stage */
1020  SCIP_REOPT* reopt, /**< reoptimization data structure */
1021  SCIP_LP* lp, /**< current LP data */
1022  SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */
1023  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
1024  SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
1025  SCIP_Bool value, /**< value of the variable in the clique */
1026  SCIP_CLIQUE* clique, /**< clique the variable should be added to */
1027  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
1028  int* nbdchgs /**< pointer to count the number of performed bound changes, or NULL */
1029  );
1030 
1031 /** adds a filled clique to the cliquelists of all corresponding variables */
1033  SCIP_VAR** vars, /**< problem variables */
1034  SCIP_Bool* values, /**< values of the variables in the clique */
1035  int nvars, /**< number of problem variables */
1036  BMS_BLKMEM* blkmem, /**< block memory */
1037  SCIP_SET* set, /**< global SCIP settings */
1038  SCIP_CLIQUE* clique /**< clique that contains all given variables and values */
1039  );
1040 
1041 /** deletes the variable from the given clique and updates the list of cliques the binary variable is member of */
1043  SCIP_VAR* var, /**< problem variable */
1044  BMS_BLKMEM* blkmem, /**< block memory */
1045  SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
1046  SCIP_Bool value, /**< value of the variable in the clique */
1047  SCIP_CLIQUE* clique /**< clique the variable should be removed from */
1048  );
1049 
1050 /** adds a clique to the list of cliques of the given binary variable, but does not change the clique
1051  * itself
1052  */
1054  SCIP_VAR* var, /**< problem variable */
1055  BMS_BLKMEM* blkmem, /**< block memory */
1056  SCIP_SET* set, /**< global SCIP settings */
1057  SCIP_Bool value, /**< value of the variable in the clique */
1058  SCIP_CLIQUE* clique /**< clique that should be removed from the variable's clique list */
1059  );
1060 
1061 /** deletes a clique from the list of cliques the binary variable is member of, but does not change the clique
1062  * itself
1063  */
1065  SCIP_VAR* var, /**< problem variable */
1066  BMS_BLKMEM* blkmem, /**< block memory */
1067  SCIP_Bool value, /**< value of the variable in the clique */
1068  SCIP_CLIQUE* clique /**< clique that should be removed from the variable's clique list */
1069  );
1070 
1071 /** sets the branch factor of the variable; this value can be used in the branching methods to scale the score
1072  * values of the variables; higher factor leads to a higher probability that this variable is chosen for branching
1073  */
1075  SCIP_VAR* var, /**< problem variable */
1076  SCIP_SET* set, /**< global SCIP settings */
1077  SCIP_Real branchfactor /**< factor to weigh variable's branching score with */
1078  );
1079 
1080 /** sets the branch priority of the variable; variables with higher branch priority are always preferred to variables
1081  * with lower priority in selection of branching variable
1082  */
1084  SCIP_VAR* var, /**< problem variable */
1085  int branchpriority /**< branching priority of the variable */
1086  );
1087 
1088 /** sets the branch direction of the variable; variables with higher branch direction are always preferred to variables
1089  * with lower direction in selection of branching variable
1090  */
1092  SCIP_VAR* var, /**< problem variable */
1093  SCIP_BRANCHDIR branchdirection /**< preferred branch direction of the variable (downwards, upwards, auto) */
1094  );
1095 
1096 /** gets objective value of variable in current SCIP_LP; the value can be different from the bound stored in the variable's own
1097  * data due to diving, that operate only on the LP without updating the variables
1098  */
1100  SCIP_VAR* var /**< problem variable */
1101  );
1102 
1103 /** gets lower bound of variable in current SCIP_LP; the bound can be different from the bound stored in the variable's own
1104  * data due to diving or conflict analysis, that operate only on the LP without updating the variables
1105  */
1107  SCIP_VAR* var, /**< problem variable */
1108  SCIP_SET* set /**< global SCIP settings */
1109  );
1110 
1111 /** gets upper bound of variable in current SCIP_LP; the bound can be different from the bound stored in the variable's own
1112  * data due to diving or conflict analysis, that operate only on the LP without updating the variables
1113  */
1115  SCIP_VAR* var, /**< problem variable */
1116  SCIP_SET* set /**< global SCIP settings */
1117  );
1118 
1119 /** returns solution value and index of variable lower bound that is closest to the variable's value in the given primal solution
1120  * or current LP solution if no primal solution is given; returns an index of -1 if no variable lower bound is available
1121  */
1123  SCIP_VAR* var, /**< active problem variable */
1124  SCIP_SOL* sol, /**< primal solution, or NULL for LP solution */
1125  SCIP_SET* set, /**< global SCIP settings */
1126  SCIP_STAT* stat, /**< problem statistics */
1127  SCIP_Real* closestvlb, /**< pointer to store the value of the closest variable lower bound */
1128  int* closestvlbidx /**< pointer to store the index of the closest variable lower bound */
1129  );
1130 
1131 /** returns solution value and index of variable upper bound that is closest to the variable's value in the given primal solution;
1132  * or current LP solution if no primal solution is given; returns an index of -1 if no variable upper bound is available
1133  */
1135  SCIP_VAR* var, /**< active problem variable */
1136  SCIP_SOL* sol, /**< primal solution, or NULL for LP solution */
1137  SCIP_SET* set, /**< global SCIP settings */
1138  SCIP_STAT* stat, /**< problem statistics */
1139  SCIP_Real* closestvub, /**< pointer to store the value of the closest variable upper bound */
1140  int* closestvubidx /**< pointer to store the index of the closest variable upper bound */
1141  );
1142 
1143 /** remembers the current solution as root solution in the problem variables */
1144 void SCIPvarStoreRootSol(
1145  SCIP_VAR* var, /**< problem variable */
1146  SCIP_Bool roothaslp /**< is the root solution from LP? */
1147  );
1148 
1149 /** updates the current solution as best root solution in the problem variables if it is better */
1151  SCIP_VAR* var, /**< problem variable */
1152  SCIP_SET* set, /**< global SCIP settings */
1153  SCIP_Real rootsol, /**< root solution value */
1154  SCIP_Real rootredcost, /**< root reduced cost */
1155  SCIP_Real rootlpobjval /**< objective value of the root LP */
1156  );
1157 
1158 /** returns the solution value of the problem variables in the relaxation solution */
1160  SCIP_VAR* var, /**< problem variable */
1161  SCIP_SET* set /**< global SCIP settings */
1162  );
1163 
1164 /** returns the solution value of the transformed problem variable in the relaxation solution */
1166  SCIP_VAR* var /**< problem variable */
1167  );
1168 
1169 /** returns for the given binary variable the reduced cost which are given by the variable itself and its implication if
1170  * the binary variable is fixed to the given value
1171  */
1173  SCIP_VAR* var, /**< problem variable */
1174  SCIP_SET* set, /**< global SCIP settings */
1175  SCIP_Bool varfixing, /**< FALSE if for x == 0, TRUE for x == 1 */
1176  SCIP_STAT* stat, /**< problem statistics */
1177  SCIP_PROB* prob, /**< transformed problem, or NULL */
1178  SCIP_LP* lp /**< current LP data */
1179  );
1180 
1181 
1182 /** stores the solution value as relaxation solution in the problem variable */
1184  SCIP_VAR* var, /**< problem variable */
1185  SCIP_SET* set, /**< global SCIP settings */
1186  SCIP_RELAXATION* relaxation, /**< global relaxation data */
1187  SCIP_Real solval, /**< solution value in the current relaxation solution */
1188  SCIP_Bool updateobj /**< should the objective value be updated? */
1189  );
1190 
1191 /** stores the solution value as NLP solution in the problem variable */
1193  SCIP_VAR* var, /**< problem variable */
1194  SCIP_SET* set, /**< global SCIP settings */
1195  SCIP_Real solval /**< solution value in the current NLP solution */
1196  );
1197 
1198 /** resolves variable to columns and adds them with the coefficient to the row */
1200  SCIP_VAR* var, /**< problem variable */
1201  BMS_BLKMEM* blkmem, /**< block memory */
1202  SCIP_SET* set, /**< global SCIP settings */
1203  SCIP_STAT* stat, /**< problem statistics */
1204  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
1205  SCIP_PROB* prob, /**< problem data */
1206  SCIP_LP* lp, /**< current LP data */
1207  SCIP_ROW* row, /**< LP row */
1208  SCIP_Real val /**< value of coefficient */
1209  );
1210 
1211 
1212 /** merge two variable histories together; a typical use case is that \p othervar is an image of the target variable
1213  * in a SCIP copy. Method should be applied with care, especially because no internal checks are performed whether
1214  * the history merge is reasonable
1215  *
1216  * @note Do not use this method if the two variables originate from two SCIP's with different objective functions, since
1217  * this corrupts the variable pseudo costs
1218  * @note Apply with care; no internal checks are performed if the two variables should be merged
1219  */
1221  SCIP_VAR* targetvar, /**< the variable that should contain both histories afterwards */
1222  SCIP_VAR* othervar, /**< the variable whose history is to be merged with that of the target variable */
1223  SCIP_STAT* stat /**< problem statistics */
1224  );
1225 
1226 /** sets the history of a variable; this method is typacally used within reoptimization to keep and update the variable
1227  * history over several iteraions
1228  */
1229 void SCIPvarSetHistory(
1230  SCIP_VAR* var, /**< variable */
1231  SCIP_HISTORY* history, /**< the history which is to set */
1232  SCIP_STAT* stat /**< problem statistics */
1233  );
1234 
1235 /** updates the pseudo costs of the given variable and the global pseudo costs after a change of
1236  * "solvaldelta" in the variable's solution value and resulting change of "objdelta" in the in the LP's objective value
1237  */
1239  SCIP_VAR* var, /**< problem variable */
1240  SCIP_SET* set, /**< global SCIP settings */
1241  SCIP_STAT* stat, /**< problem statistics */
1242  SCIP_Real solvaldelta, /**< difference of variable's new LP value - old LP value */
1243  SCIP_Real objdelta, /**< difference of new LP's objective value - old LP's objective value */
1244  SCIP_Real weight /**< weight in (0,1] of this update in pseudo cost sum */
1245  );
1246 
1247 /** gets the variable's pseudo cost value for the given step size "solvaldelta" in the variable's LP solution value */
1249  SCIP_VAR* var, /**< problem variable */
1250  SCIP_STAT* stat, /**< problem statistics */
1251  SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
1252  );
1253 
1254 /** gets the variable's pseudo cost value for the given step size "solvaldelta" in the variable's LP solution value,
1255  * only using the pseudo cost information of the current run
1256  */
1258  SCIP_VAR* var, /**< problem variable */
1259  SCIP_STAT* stat, /**< problem statistics */
1260  SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
1261  );
1262 
1263 /** gets the variable's (possible fractional) number of pseudo cost updates for the given direction */
1265  SCIP_VAR* var, /**< problem variable */
1266  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
1267  );
1268 
1269 /** gets the variable's (possible fractional) number of pseudo cost updates for the given direction,
1270  * only using the pseudo cost information of the current run
1271  */
1273  SCIP_VAR* var, /**< problem variable */
1274  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
1275  );
1276 
1277 
1278 /** compares both possible directions for rounding the given solution value and returns the minimum pseudo-costs of the variable */
1280  SCIP_VAR* var, /**< problem variable */
1281  SCIP_STAT* stat, /**< problem statistics */
1282  SCIP_SET* set, /**< global SCIP settings */
1283  SCIP_Real solval /**< solution value, e.g., LP solution value */
1284  );
1285 
1286 /** gets the an estimate of the variable's pseudo cost variance in direction \p dir */
1288  SCIP_VAR* var, /**< problem variable */
1289  SCIP_BRANCHDIR dir, /**< branching direction (downwards, or upwards) */
1290  SCIP_Bool onlycurrentrun /**< return pseudo cost variance only for current branch and bound run */
1291  );
1292 
1293 /** calculates a confidence bound for this variable under the assumption of normally distributed pseudo costs
1294  *
1295  * The confidence bound \f$ \theta \geq 0\f$ denotes the interval borders \f$ [X - \theta, \ X + \theta]\f$, which contains
1296  * the true pseudo costs of the variable, i.e., the expected value of the normal distribution, with a probability
1297  * of 95 %.
1298  *
1299  * @return value of confidence bound for this variable
1300  */
1302  SCIP_VAR* var, /**< variable in question */
1303  SCIP_SET* set, /**< global SCIP settings */
1304  SCIP_BRANCHDIR dir, /**< the branching direction for the confidence bound */
1305  SCIP_Bool onlycurrentrun, /**< should only the current run be taken into account */
1306  SCIP_CONFIDENCELEVEL clevel /**< confidence level for the interval */
1307  );
1308 
1309 /** check if the current pseudo cost relative error in a direction violates the given threshold. The Relative
1310  * Error is calculated at a specific confidence level
1311  */
1313  SCIP_VAR* var, /**< variable in question */
1314  SCIP_SET* set, /**< global SCIP settings */
1315  SCIP_STAT* stat, /**< problem statistics */
1316  SCIP_Real threshold, /**< threshold for relative errors to be considered reliable (enough) */
1317  SCIP_CONFIDENCELEVEL clevel /**< a given confidence level */
1318  );
1319 
1320 /** check if variable pseudo-costs have a significant difference in location. The significance depends on
1321  * the choice of \p clevel and on the kind of tested hypothesis. The one-sided hypothesis, which
1322  * should be rejected, is that fracy * mu_y >= fracx * mu_x, where mu_y and mu_x denote the
1323  * unknown location means of the underlying pseudo-cost distributions of x and y.
1324  *
1325  * This method is applied best if variable x has a better pseudo-cost score than y. The method hypothesizes that y were actually
1326  * better than x (despite the current information), meaning that y can be expected to yield branching
1327  * decisions as least as good as x in the long run. If the method returns TRUE, the current history information is
1328  * sufficient to safely rely on the alternative hypothesis that x yields indeed a better branching score (on average)
1329  * than y.
1330  *
1331  * @note The order of x and y matters for the one-sided hypothesis
1332  *
1333  * @note set \p onesided to FALSE if you are not sure which variable is better. The hypothesis tested then reads
1334  * fracy * mu_y == fracx * mu_x vs the alternative hypothesis fracy * mu_y != fracx * mu_x.
1335  *
1336  * @return TRUE if the hypothesis can be safely rejected at the given confidence level
1337  */
1339  SCIP_SET* set, /**< global SCIP settings */
1340  SCIP_STAT* stat, /**< problem statistics */
1341  SCIP_VAR* varx, /**< variable x */
1342  SCIP_Real fracx, /**< the fractionality of variable x */
1343  SCIP_VAR* vary, /**< variable y */
1344  SCIP_Real fracy, /**< the fractionality of variable y */
1345  SCIP_BRANCHDIR dir, /**< branching direction */
1346  SCIP_CONFIDENCELEVEL clevel, /**< confidence level for rejecting hypothesis */
1347  SCIP_Bool onesided /**< should a one-sided hypothesis y >= x be tested? */
1348  );
1349 
1350 /** tests at a given confidence level whether the variable pseudo-costs only have a small probability to
1351  * exceed a \p threshold. This is useful to determine if past observations provide enough evidence
1352  * to skip an expensive strong-branching step if there is already a candidate that has been proven to yield an improvement
1353  * of at least \p threshold.
1354  *
1355  * @note use \p clevel to adjust the level of confidence. For SCIP_CONFIDENCELEVEL_MIN, the method returns TRUE if
1356  * the estimated probability to exceed \p threshold is less than 25 %.
1357  *
1358  * @see SCIP_Confidencelevel for a list of available levels. The used probability limits refer to the one-sided levels
1359  * of confidence.
1360  *
1361  * @return TRUE if the variable pseudo-cost probabilistic model is likely to be smaller than \p threshold
1362  * at the given confidence level \p clevel.
1363  */
1365  SCIP_SET* set, /**< global SCIP settings */
1366  SCIP_STAT* stat, /**< problem statistics */
1367  SCIP_VAR* var, /**< variable x */
1368  SCIP_Real frac, /**< the fractionality of variable x */
1369  SCIP_Real threshold, /**< the threshold to test against */
1370  SCIP_BRANCHDIR dir, /**< branching direction */
1371  SCIP_CONFIDENCELEVEL clevel /**< confidence level for rejecting hypothesis */
1372  );
1373 
1374 /** increases the VSIDS of the variable by the given weight */
1376  SCIP_VAR* var, /**< problem variable */
1377  BMS_BLKMEM* blkmem, /**< block memory, or NULL if the domain value is SCIP_UNKNOWN */
1378  SCIP_SET* set, /**< global SCIP settings, or NULL if the domain value is SCIP_UNKNOWN */
1379  SCIP_STAT* stat, /**< problem statistics */
1380  SCIP_BRANCHDIR dir, /**< branching direction */
1381  SCIP_Real value, /**< domain value, or SCIP_UNKNOWN */
1382  SCIP_Real weight /**< weight of this update in conflict score */
1383  );
1384 
1385 /** scales the VSIDS of the variable by the given scalar */
1387  SCIP_VAR* var, /**< problem variable */
1388  SCIP_Real scalar /**< scalar to multiply the conflict scores with */
1389  );
1390 
1391 /** increases the number of active conflicts by one and the overall length of the variable by the given length */
1393  SCIP_VAR* var, /**< problem variable */
1394  BMS_BLKMEM* blkmem, /**< block memory, or NULL if the domain value is SCIP_UNKNOWN */
1395  SCIP_SET* set, /**< global SCIP settings, or NULL if the domain value is SCIP_UNKNOWN */
1396  SCIP_STAT* stat, /**< problem statistics */
1397  SCIP_BRANCHDIR dir, /**< branching direction */
1398  SCIP_Real value, /**< domain value, or SCIP_UNKNOWN */
1399  SCIP_Real length /**< length of the conflict */
1400  );
1401 
1402 /** gets the number of active conflicts containing this variable in given direction */
1404  SCIP_VAR* var, /**< problem variable */
1405  SCIP_STAT* stat, /**< problem statistics */
1406  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
1407  );
1408 
1409 /** gets the number of active conflicts containing this variable in given direction
1410  * in the current run
1411  */
1413  SCIP_VAR* var, /**< problem variable */
1414  SCIP_STAT* stat, /**< problem statistics */
1415  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
1416  );
1417 
1418 /** gets the average conflict length in given direction due to branching on the variable */
1420  SCIP_VAR* var, /**< problem variable */
1421  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
1422  );
1423 
1424 /** gets the average conflict length in given direction due to branching on the variable
1425  * in the current run
1426  */
1428  SCIP_VAR* var, /**< problem variable */
1429  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
1430  );
1431 
1432 /** increases the number of branchings counter of the variable */
1434  SCIP_VAR* var, /**< problem variable */
1435  BMS_BLKMEM* blkmem, /**< block memory, or NULL if the domain value is SCIP_UNKNOWN */
1436  SCIP_SET* set, /**< global SCIP settings, or NULL if the domain value is SCIP_UNKNOWN */
1437  SCIP_STAT* stat, /**< problem statistics */
1438  SCIP_BRANCHDIR dir, /**< branching direction (downwards, or upwards) */
1439  SCIP_Real value, /**< domain value, or SCIP_UNKNOWN */
1440  int depth /**< depth at which the bound change took place */
1441  );
1442 
1443 /** increases the inference score of the variable by the given weight */
1445  SCIP_VAR* var, /**< problem variable */
1446  BMS_BLKMEM* blkmem, /**< block memory, or NULL if the domain value is SCIP_UNKNOWN */
1447  SCIP_SET* set, /**< global SCIP settings, or NULL if the domain value is SCIP_UNKNOWN */
1448  SCIP_STAT* stat, /**< problem statistics */
1449  SCIP_BRANCHDIR dir, /**< branching direction (downwards, or upwards) */
1450  SCIP_Real value, /**< domain value, or SCIP_UNKNOWN */
1451  SCIP_Real weight /**< weight of this update in inference score */
1452  );
1453 
1454 /** increases the cutoff score of the variable by the given weight */
1456  SCIP_VAR* var, /**< problem variable */
1457  BMS_BLKMEM* blkmem, /**< block memory, or NULL if the domain value is SCIP_UNKNOWN */
1458  SCIP_SET* set, /**< global SCIP settings, or NULL if the domain value is SCIP_UNKNOWN */
1459  SCIP_STAT* stat, /**< problem statistics */
1460  SCIP_BRANCHDIR dir, /**< branching direction (downwards, or upwards) */
1461  SCIP_Real value, /**< domain value, or SCIP_UNKNOWN */
1462  SCIP_Real weight /**< weight of this update in cutoff score */
1463  );
1464 
1465 /** returns the variable's VSIDS score */
1467  SCIP_VAR* var, /**< problem variable */
1468  SCIP_STAT* stat, /**< problem statistics */
1469  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
1470  );
1471 
1472 /** returns the variable's VSIDS score only using conflicts of the current run */
1474  SCIP_VAR* var, /**< problem variable */
1475  SCIP_STAT* stat, /**< problem statistics */
1476  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
1477  );
1478 
1479 /** returns the average number of inferences found after branching on the variable in given direction */
1481  SCIP_VAR* var, /**< problem variable */
1482  SCIP_STAT* stat, /**< problem statistics */
1483  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
1484  );
1485 
1486 /** returns the average number of inferences found after branching on the variable in given direction
1487  * in the current run
1488  */
1490  SCIP_VAR* var, /**< problem variable */
1491  SCIP_STAT* stat, /**< problem statistics */
1492  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
1493  );
1494 
1495 /** returns the average number of cutoffs found after branching on the variable in given direction */
1497  SCIP_VAR* var, /**< problem variable */
1498  SCIP_STAT* stat, /**< problem statistics */
1499  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
1500  );
1501 
1502 /** returns the average number of cutoffs found after branching on the variable in given direction in the current run */
1504  SCIP_VAR* var, /**< problem variable */
1505  SCIP_STAT* stat, /**< problem statistics */
1506  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
1507  );
1508 
1509 /** outputs variable information into file stream */
1511  SCIP_VAR* var, /**< problem variable */
1512  SCIP_SET* set, /**< global SCIP settings */
1513  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
1514  FILE* file /**< output file (or NULL for standard output) */
1515  );
1516 
1517 /** includes event handler with given data in variable's event filter */
1519  SCIP_VAR* var, /**< problem variable */
1520  BMS_BLKMEM* blkmem, /**< block memory */
1521  SCIP_SET* set, /**< global SCIP settings */
1522  SCIP_EVENTTYPE eventtype, /**< event type to catch */
1523  SCIP_EVENTHDLR* eventhdlr, /**< event handler to call for the event processing */
1524  SCIP_EVENTDATA* eventdata, /**< event data to pass to the event handler for the event processing */
1525  int* filterpos /**< pointer to store position of event filter entry, or NULL */
1526  );
1527 
1528 /** deletes event handler with given data from variable's event filter */
1530  SCIP_VAR* var, /**< problem variable */
1531  BMS_BLKMEM* blkmem, /**< block memory */
1532  SCIP_SET* set, /**< global SCIP settings */
1533  SCIP_EVENTTYPE eventtype, /**< event type mask of dropped event */
1534  SCIP_EVENTHDLR* eventhdlr, /**< event handler to call for the event processing */
1535  SCIP_EVENTDATA* eventdata, /**< event data to pass to the event handler for the event processing */
1536  int filterpos /**< position of event filter entry returned by SCIPvarCatchEvent(), or -1 */
1537  );
1538 
1539 /** returns the variable's VSIDS score */
1541  SCIP_VAR* var, /**< problem variable */
1542  SCIP_STAT* stat, /**< problem statistics */
1543  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
1544  );
1545 
1546 /** returns the position of the bound change index */
1547 int SCIPbdchgidxGetPos(
1548  SCIP_BDCHGIDX* bdchgidx /**< bound change index */
1549  );
1550 
1551 /** removes (redundant) cliques, implications and variable bounds of variable from all other variables' implications and variable
1552  * bounds arrays, and optionally removes them also from the variable itself
1553  */
1555  SCIP_VAR* var, /**< problem variable */
1556  BMS_BLKMEM* blkmem, /**< block memory */
1557  SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
1558  SCIP_SET* set, /**< global SCIP settings */
1559  SCIP_Bool irrelevantvar, /**< has the variable become irrelevant? */
1560  SCIP_Bool onlyredundant, /**< should only the redundant implications and variable bounds be removed? */
1561  SCIP_Bool removefromvar /**< should the implications and variable bounds be removed from the var itself? */
1562  );
1563 
1564 #ifdef NDEBUG
1565 
1566 /* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
1567  * speed up the algorithms.
1568  */
1569 
1570 #define SCIPvarCatchEvent(var, blkmem, set, eventtype, eventhdlr, eventdata, filterpos) \
1571  SCIPeventfilterAdd(var->eventfilter, blkmem, set, eventtype, eventhdlr, eventdata, filterpos)
1572 #define SCIPvarDropEvent(var, blkmem, set, eventtype, eventhdlr, eventdata, filterpos) \
1573  SCIPeventfilterDel(var->eventfilter, blkmem, set, eventtype, eventhdlr, eventdata, filterpos)
1574 #define SCIPvarGetVSIDS(var, stat, dir) ((var)->varstatus == SCIP_VARSTATUS_LOOSE || (var)->varstatus == SCIP_VARSTATUS_COLUMN ? \
1575  SCIPhistoryGetVSIDS(var->history, dir)/stat->vsidsweight : SCIPvarGetVSIDS_rec(var, stat, dir))
1576 #define SCIPbdchgidxGetPos(bdchgidx) ((bdchgidx)->pos)
1577 
1578 #endif
1579 
1580 /*
1581  * Hash functions
1582  */
1583 
1584 /** gets the key (i.e. the name) of the given variable */
1585 SCIP_DECL_HASHGETKEY(SCIPhashGetKeyVar);
1586 
1587 #ifdef __cplusplus
1588 }
1589 #endif
1590 
1591 #endif
SCIP_Real SCIPvarGetRelaxSolTransVar(SCIP_VAR *var)
Definition: var.c:14007
SCIP_RETCODE SCIPvarColumn(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_LP *lp)
Definition: var.c:3583
enum SCIP_BoundType SCIP_BOUNDTYPE
Definition: type_lp.h:59
SCIP_RETCODE SCIPvarChgBdLocal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_Real newbound, SCIP_BOUNDTYPE boundtype)
Definition: var.c:8232
SCIP_RETCODE SCIPvarChgBdGlobal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Real newbound, SCIP_BOUNDTYPE boundtype)
Definition: var.c:7527
internal methods for managing events
int SCIPbdchgidxGetPos(SCIP_BDCHGIDX *bdchgidx)
Definition: var.c:18455
SCIP_RETCODE SCIPvarAddVlb(SCIP_VAR *var, 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_CLIQUETABLE *cliquetable, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_VAR *vlbvar, SCIP_Real vlbcoef, SCIP_Real vlbconstant, SCIP_Bool transitive, SCIP_Bool *infeasible, int *nbdchgs)
Definition: var.c:10010
SCIP_Real SCIPvarGetPseudocostCurrentRun(SCIP_VAR *var, SCIP_STAT *stat, SCIP_Real solvaldelta)
Definition: var.c:14538
public methods for branching and inference history structure
SCIP_RETCODE SCIPdomchgApply(SCIP_DOMCHG *domchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, int depth, SCIP_Bool *cutoff)
Definition: var.c:1300
SCIP_RETCODE SCIPvarChgLbLocal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_Real newbound)
Definition: var.c:7979
void SCIPvarCapture(SCIP_VAR *var)
Definition: var.c:2851
type definitions for miscellaneous datastructures
type definitions for implications, variable bounds, and cliques
SCIP_RETCODE SCIPvarsGetActiveVars(SCIP_SET *set, SCIP_VAR **vars, int *nvars, int varssize, int *requiredsize)
Definition: var.c:12018
SCIP_RETCODE SCIPvarPrint(SCIP_VAR *var, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, FILE *file)
Definition: var.c:3010
SCIP_Real SCIPvarGetAvgCutoffs(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
Definition: var.c:16277
#define SCIP_DECL_VARTRANS(x)
Definition: type_var.h:147
void SCIPvarSetHistory(SCIP_VAR *var, SCIP_HISTORY *history, SCIP_STAT *stat)
Definition: var.c:4529
SCIP_RETCODE SCIPvarCreateOriginal(SCIP_VAR **var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype, SCIP_Bool initial, SCIP_Bool removable, SCIP_DECL_VARDELORIG((*vardelorig)), SCIP_DECL_VARTRANS((*vartrans)), SCIP_DECL_VARDELTRANS((*vardeltrans)), SCIP_DECL_VARCOPY((*varcopy)), SCIP_VARDATA *vardata)
Definition: var.c:2078
SCIP_RETCODE SCIPdomchgMakeStatic(SCIP_DOMCHG **domchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
Definition: var.c:1162
void SCIPvarInitSolve(SCIP_VAR *var)
Definition: var.c:2935
SCIP_RETCODE SCIPvarTryAggregateVars(SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_CLIQUETABLE *cliquetable, SCIP_BRANCHCAND *branchcand, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_VAR *varx, SCIP_VAR *vary, SCIP_Real scalarx, SCIP_Real scalary, SCIP_Real rhs, SCIP_Bool *infeasible, SCIP_Bool *aggregated)
Definition: var.c:5287
SCIP_RETCODE SCIPvarChgBranchDirection(SCIP_VAR *var, SCIP_BRANCHDIR branchdirection)
Definition: var.c:11830
SCIP_Real SCIPvarGetVSIDSCurrentRun(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
Definition: var.c:15940
SCIP_DECL_HASHGETKEY(SCIPhashGetKeyVar)
Definition: var.c:17022
SCIP_RETCODE SCIPvarChgObj(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_PROB *prob, SCIP_PRIMAL *primal, SCIP_LP *lp, SCIP_EVENTQUEUE *eventqueue, SCIP_Real newobj)
Definition: var.c:6273
void SCIPbdchginfoFree(SCIP_BDCHGINFO **bdchginfo, BMS_BLKMEM *blkmem)
Definition: var.c:16408
static long bound
SCIP_RETCODE SCIPvarRelease(SCIP_VAR **var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
Definition: var.c:2876
SCIP_Longint SCIPvarGetNActiveConflictsCurrentRun(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
Definition: var.c:15327
SCIP_Real SCIPvarGetRelaxSol(SCIP_VAR *var, SCIP_SET *set)
Definition: var.c:13935
SCIP_RETCODE SCIPvarAddObj(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_Real addobj)
Definition: var.c:6348
SCIP_RETCODE SCIPvarIncVSIDS(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_BRANCHDIR dir, SCIP_Real value, SCIP_Real weight)
Definition: var.c:15063
SCIP_RETCODE SCIPvarResetBounds(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
Definition: var.c:9240
SCIP_RETCODE SCIPvarAddHoleLocal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_Real left, SCIP_Real right, SCIP_Bool *added)
Definition: var.c:9131
SCIP_RETCODE SCIPboundchgApply(SCIP_BOUNDCHG *boundchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, int depth, int pos, SCIP_Bool *cutoff)
Definition: var.c:629
SCIP_Bool SCIPvarIsMarkedDeleteGlobalStructures(SCIP_VAR *var)
Definition: var.c:17531
struct SCIP_VarData SCIP_VARDATA
Definition: type_var.h:116
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:63
SCIP_RETCODE SCIPvarCopy(SCIP_VAR **var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP *sourcescip, SCIP_VAR *sourcevar, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global)
Definition: var.c:2163
type definitions for global SCIP settings
#define SCIP_DECL_VARCOPY(x)
Definition: type_var.h:190
SCIP_Real SCIPvarGetMultaggrUbGlobal(SCIP_VAR *var, SCIP_SET *set)
Definition: var.c:8641
SCIP_RETCODE SCIPvarAggregate(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_CLIQUETABLE *cliquetable, SCIP_BRANCHCAND *branchcand, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_VAR *aggvar, SCIP_Real scalar, SCIP_Real constant, SCIP_Bool *infeasible, SCIP_Bool *aggregated)
Definition: var.c:4735
SCIP_Bool SCIPvarPscostThresholdProbabilityTest(SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR *var, SCIP_Real frac, SCIP_Real threshold, SCIP_BRANCHDIR dir, SCIP_CONFIDENCELEVEL clevel)
Definition: var.c:14939
SCIP_Real SCIPvarGetImplRedcost(SCIP_VAR *var, SCIP_SET *set, SCIP_Bool varfixing, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_LP *lp)
Definition: var.c:13480
SCIP_Bool SCIPvarSignificantPscostDifference(SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR *varx, SCIP_Real fracx, SCIP_VAR *vary, SCIP_Real fracy, SCIP_BRANCHDIR dir, SCIP_CONFIDENCELEVEL clevel, SCIP_Bool onesided)
Definition: var.c:14873
type definitions for return codes for SCIP methods
SCIP_Real SCIPvarGetMultaggrLbGlobal(SCIP_VAR *var, SCIP_SET *set)
Definition: var.c:8575
SCIP_RETCODE SCIPvarCreateTransformed(SCIP_VAR **var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype, SCIP_Bool initial, SCIP_Bool removable, SCIP_DECL_VARDELORIG((*vardelorig)), SCIP_DECL_VARTRANS((*vartrans)), SCIP_DECL_VARDELTRANS((*vardeltrans)), SCIP_DECL_VARCOPY((*varcopy)), SCIP_VARDATA *vardata)
Definition: var.c:2121
SCIP_RETCODE SCIPvarChgUbOriginal(SCIP_VAR *var, SCIP_SET *set, SCIP_Real newbound)
Definition: var.c:6635
SCIP_RETCODE SCIPvarGetTransformed(SCIP_VAR *origvar, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR **transvar)
Definition: var.c:3552
type definitions for collecting reoptimization information
SCIP_RETCODE SCIPvarDelCliqueFromList(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_Bool value, SCIP_CLIQUE *clique)
Definition: var.c:11427
void SCIPvarAdjustUb(SCIP_VAR *var, SCIP_SET *set, SCIP_Real *ub)
Definition: var.c:6543
type definitions for branching rules
type definitions for problem statistics
SCIP_RETCODE SCIPvarAddVub(SCIP_VAR *var, 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_CLIQUETABLE *cliquetable, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_VAR *vubvar, SCIP_Real vubcoef, SCIP_Real vubconstant, SCIP_Bool transitive, SCIP_Bool *infeasible, int *nbdchgs)
Definition: var.c:10474
SCIP_RETCODE SCIPvarSetNLPSol(SCIP_VAR *var, SCIP_SET *set, SCIP_Real solval)
Definition: var.c:14018
SCIP_RETCODE SCIPvarRemove(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_CLIQUETABLE *cliquetable, SCIP_SET *set, SCIP_Bool final)
Definition: var.c:6067
#define SCIP_DECL_VARDELTRANS(x)
Definition: type_var.h:160
type definitions for LP management
SCIP_RETCODE SCIPvarIncInferenceSum(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_BRANCHDIR dir, SCIP_Real value, SCIP_Real weight)
Definition: var.c:15543
enum SCIP_BranchDir SCIP_BRANCHDIR
Definition: type_history.h:48
SCIP_Real SCIPbdchginfoGetRelaxedBound(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:18644
void SCIPvarMarkDeleted(SCIP_VAR *var)
Definition: var.c:6103
SCIP_RETCODE SCIPdomchgAddBoundchg(SCIP_DOMCHG **domchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_VAR *var, SCIP_Real newbound, SCIP_BOUNDTYPE boundtype, SCIP_BOUNDCHGTYPE boundchgtype, SCIP_Real lpsolval, SCIP_VAR *infervar, SCIP_CONS *infercons, SCIP_PROP *inferprop, int inferinfo, SCIP_BOUNDTYPE inferboundtype)
Definition: var.c:1423
SCIP_Bool SCIPvarDoNotMultaggr(SCIP_VAR *var)
Definition: var.c:5889
SCIP_RETCODE SCIPvarFlattenAggregationGraph(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue)
Definition: var.c:4418
SCIP_Real SCIPvarGetAvgInferences(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
Definition: var.c:16079
SCIP_Real SCIPvarCalcPscostConfidenceBound(SCIP_VAR *var, SCIP_SET *set, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun, SCIP_CONFIDENCELEVEL clevel)
Definition: var.c:14758
enum SCIP_Confidencelevel SCIP_CONFIDENCELEVEL
Definition: type_misc.h:53
SCIP_Bool SCIPvarIsPscostRelerrorReliable(SCIP_VAR *var, SCIP_SET *set, SCIP_STAT *stat, SCIP_Real threshold, SCIP_CONFIDENCELEVEL clevel)
Definition: var.c:14796
SCIP_RETCODE SCIPvarIncNActiveConflicts(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_BRANCHDIR dir, SCIP_Real value, SCIP_Real length)
Definition: var.c:15199
SCIP_Real SCIPvarGetPseudocostVariance(SCIP_VAR *var, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun)
Definition: var.c:14704
void SCIPvarGetClosestVlb(SCIP_VAR *var, SCIP_SOL *sol, SCIP_SET *set, SCIP_STAT *stat, SCIP_Real *closestvlb, int *closestvlbidx)
Definition: var.c:14135
SCIP_RETCODE SCIPvarFix(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Real fixedval, SCIP_Bool *infeasible, SCIP_Bool *fixed)
Definition: var.c:3753
SCIP_RETCODE SCIPvarChgUbLazy(SCIP_VAR *var, SCIP_SET *set, SCIP_Real lazylb)
Definition: var.c:7501
SCIP_Real SCIPvarGetPseudocostCountCurrentRun(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: var.c:14630
enum SCIP_LockType SCIP_LOCKTYPE
Definition: type_var.h:96
SCIP_RETCODE SCIPvarAddCliqueToList(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_Bool value, SCIP_CLIQUE *clique)
Definition: var.c:11405
SCIP_RETCODE SCIPvarParseOriginal(SCIP_VAR **var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, const char *str, SCIP_Bool initial, SCIP_Bool removable, SCIP_DECL_VARCOPY((*varcopy)), SCIP_DECL_VARDELORIG((*vardelorig)), SCIP_DECL_VARTRANS((*vartrans)), SCIP_DECL_VARDELTRANS((*vardeltrans)), SCIP_VARDATA *vardata, char **endptr, SCIP_Bool *success)
Definition: var.c:2500
type definitions for SCIP&#39;s main datastructure
SCIP_RETCODE SCIPvarGetProbvarSum(SCIP_VAR **var, SCIP_SET *set, SCIP_Real *scalar, SCIP_Real *constant)
Definition: var.c:12659
SCIP_RETCODE SCIPvarCatchEvent(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
Definition: var.c:18403
SCIP_RETCODE SCIPvarChgType(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_PRIMAL *primal, SCIP_LP *lp, SCIP_EVENTQUEUE *eventqueue, SCIP_VARTYPE vartype)
Definition: var.c:6186
void SCIPvarSetNamePointer(SCIP_VAR *var, const char *name)
Definition: var.c:6049
SCIP_RETCODE SCIPvarUpdatePseudocost(SCIP_VAR *var, SCIP_SET *set, SCIP_STAT *stat, SCIP_Real solvaldelta, SCIP_Real objdelta, SCIP_Real weight)
Definition: var.c:14391
struct SCIP_EventData SCIP_EVENTDATA
Definition: type_event.h:173
SCIP_Real SCIPvarGetLbLP(SCIP_VAR *var, SCIP_SET *set)
Definition: var.c:12944
SCIP_RETCODE SCIPvarMultiaggregate(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_CLIQUETABLE *cliquetable, SCIP_BRANCHCAND *branchcand, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, int naggvars, SCIP_VAR **aggvars, SCIP_Real *scalars, SCIP_Real constant, SCIP_Bool *infeasible, SCIP_Bool *aggregated)
Definition: var.c:5453
SCIP_RETCODE SCIPvarDropEvent(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
Definition: var.c:18430
SCIP_RETCODE SCIPbdchginfoCreate(SCIP_BDCHGINFO **bdchginfo, BMS_BLKMEM *blkmem, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_Real oldbound, SCIP_Real newbound)
Definition: var.c:16378
SCIP_Real SCIPvarGetVSIDS_rec(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
Definition: var.c:15889
SCIP_RETCODE SCIPvarChgLbDive(SCIP_VAR *var, SCIP_SET *set, SCIP_LP *lp, SCIP_Real newbound)
Definition: var.c:8258
SCIP_RETCODE SCIPvarChgBranchPriority(SCIP_VAR *var, int branchpriority)
Definition: var.c:11699
SCIP_Real SCIPvarGetAvgConflictlength(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: var.c:15372
type definitions for problem variables
type definitions for relaxators
SCIP_Real SCIPvarGetAvgInferencesCurrentRun(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
Definition: var.c:16136
SCIP_Bool SCIPvarDoNotAggr(SCIP_VAR *var)
Definition: var.c:5856
SCIP_Real SCIPvarGetObjLP(SCIP_VAR *var)
Definition: var.c:12898
type definitions for managing events
SCIP_RETCODE SCIPvarChgLbGlobal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Real newbound)
Definition: var.c:7194
SCIP_Real SCIPvarGetMultaggrUbLocal(SCIP_VAR *var, SCIP_SET *set)
Definition: var.c:8509
SCIP_Real SCIPvarGetPseudocost(SCIP_VAR *var, SCIP_STAT *stat, SCIP_Real solvaldelta)
Definition: var.c:14489
SCIP_RETCODE SCIPdomchgAddHolechg(SCIP_DOMCHG **domchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_HOLELIST **ptr, SCIP_HOLELIST *newlist, SCIP_HOLELIST *oldlist)
Definition: var.c:1520
void SCIPvarAdjustLb(SCIP_VAR *var, SCIP_SET *set, SCIP_Real *lb)
Definition: var.c:6526
SCIP_RETCODE SCIPvarAddLocks(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LOCKTYPE locktype, int addnlocksdown, int addnlocksup)
Definition: var.c:3171
#define SCIP_Bool
Definition: def.h:93
SCIP_Real SCIPvarGetAvgConflictlengthCurrentRun(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: var.c:15416
SCIP_RETCODE SCIPdomchgUndo(SCIP_DOMCHG *domchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue)
Definition: var.c:1349
enum SCIP_Objsense SCIP_OBJSENSE
Definition: type_prob.h:50
SCIP_RETCODE SCIPvarMarkDoNotAggr(SCIP_VAR *var)
Definition: var.c:6114
void SCIPvarGetClosestVub(SCIP_VAR *var, SCIP_SOL *sol, SCIP_SET *set, SCIP_STAT *stat, SCIP_Real *closestvub, int *closestvubidx)
Definition: var.c:14210
SCIP_RETCODE SCIPvarChgObjDive(SCIP_VAR *var, SCIP_SET *set, SCIP_LP *lp, SCIP_Real newobj)
Definition: var.c:6463
SCIP_Longint SCIPvarGetNActiveConflicts(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
Definition: var.c:15280
SCIP_RETCODE SCIPvarsAddClique(SCIP_VAR **vars, SCIP_Bool *values, int nvars, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_CLIQUE *clique)
Definition: var.c:11367
SCIP_Real SCIPvarGetAvgCutoffsCurrentRun(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
Definition: var.c:16324
type definitions for branch and bound tree
SCIP_RETCODE SCIPvarNegate(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR **negvar)
Definition: var.c:5925
SCIP_RETCODE SCIPvarChgName(SCIP_VAR *var, BMS_BLKMEM *blkmem, const char *name)
Definition: var.c:2917
type definitions for storing primal CIP solutions
type definitions for storing and manipulating the main problem
SCIP_Real SCIPvarGetMultaggrLbLocal(SCIP_VAR *var, SCIP_SET *set)
Definition: var.c:8443
SCIP_RETCODE SCIPvarRemoveCliquesImplicsVbs(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_CLIQUETABLE *cliquetable, SCIP_SET *set, SCIP_Bool irrelevantvar, SCIP_Bool onlyredundant, SCIP_Bool removefromvar)
Definition: var.c:1610
SCIP_RETCODE SCIPvarAddHoleOriginal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_Real left, SCIP_Real right)
Definition: var.c:8702
SCIP_RETCODE SCIPvarParseTransformed(SCIP_VAR **var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, const char *str, SCIP_Bool initial, SCIP_Bool removable, SCIP_DECL_VARCOPY((*varcopy)), SCIP_DECL_VARDELORIG((*vardelorig)), SCIP_DECL_VARTRANS((*vartrans)), SCIP_DECL_VARDELTRANS((*vardeltrans)), SCIP_VARDATA *vardata, char **endptr, SCIP_Bool *success)
Definition: var.c:2564
void SCIPvarMergeHistories(SCIP_VAR *targetvar, SCIP_VAR *othervar, SCIP_STAT *stat)
Definition: var.c:4513
SCIP_RETCODE SCIPvarAddClique(SCIP_VAR *var, 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_CLIQUETABLE *cliquetable, SCIP_Bool value, SCIP_CLIQUE *clique, SCIP_Bool *infeasible, int *nbdchgs)
Definition: var.c:11282
#define SCIP_DECL_VARDELORIG(x)
Definition: type_var.h:127
type definitions for propagators
void SCIPvarStoreRootSol(SCIP_VAR *var, SCIP_Bool roothaslp)
Definition: var.c:13281
SCIP_RETCODE SCIPvarIncNBranchings(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_BRANCHDIR dir, SCIP_Real value, int depth)
Definition: var.c:15459
SCIP_RETCODE SCIPvarMarkDoNotMultaggr(SCIP_VAR *var)
Definition: var.c:6150
SCIP_Real SCIPvarGetPseudocostCount(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: var.c:14585
static const SCIP_Real scalars[]
Definition: lp.c:5747
SCIP_RETCODE SCIPvarChgUbLocal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_Real newbound)
Definition: var.c:8106
SCIP_MESSAGEHDLR * messagehdlr
Definition: struct_visual.h:53
SCIP_Real SCIPvarGetUbLP(SCIP_VAR *var, SCIP_SET *set)
Definition: var.c:13014
datastructures for problem variables
#define SCIP_Real
Definition: def.h:186
result codes for SCIP callback methods
SCIP_RETCODE SCIPvarChgLbLazy(SCIP_VAR *var, SCIP_SET *set, SCIP_Real lazylb)
Definition: var.c:7478
type definitions for branching and inference history
SCIP_RETCODE SCIPdomchgFree(SCIP_DOMCHG **domchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
Definition: var.c:1061
SCIP_RETCODE SCIPvarChgLbOriginal(SCIP_VAR *var, SCIP_SET *set, SCIP_Real newbound)
Definition: var.c:6576
SCIP_RETCODE SCIPvarTransform(SCIP_VAR *origvar, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_OBJSENSE objsense, SCIP_VAR **transvar)
Definition: var.c:3465
SCIP_RETCODE SCIPvarAddHoleGlobal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_Real left, SCIP_Real right, SCIP_Bool *added)
Definition: var.c:8883
#define SCIP_Longint
Definition: def.h:171
SCIP_RETCODE SCIPvarLoose(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_PROB *prob, SCIP_LP *lp)
Definition: var.c:3617
SCIP_RETCODE SCIPvarScaleVSIDS(SCIP_VAR *var, SCIP_Real scalar)
Definition: var.c:15149
SCIP_RETCODE SCIPvarAddImplic(SCIP_VAR *var, 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_CLIQUETABLE *cliquetable, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_BOUNDTYPE impltype, SCIP_Real implbound, SCIP_Bool transitive, SCIP_Bool *infeasible, int *nbdchgs)
Definition: var.c:10921
void SCIPvarUpdateBestRootSol(SCIP_VAR *var, SCIP_SET *set, SCIP_Real rootsol, SCIP_Real rootredcost, SCIP_Real rootlpobjval)
Definition: var.c:13292
void SCIPvarSetProbindex(SCIP_VAR *var, int probindex)
Definition: var.c:6034
int SCIPvarGetConflictingBdchgDepth(SCIP_VAR *var, SCIP_SET *set, SCIP_BOUNDTYPE boundtype, SCIP_Real bound)
Definition: var.c:16890
type definitions for message output methods
enum SCIP_Vartype SCIP_VARTYPE
Definition: type_var.h:69
SCIP_RETCODE SCIPvarIncCutoffSum(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_BRANCHDIR dir, SCIP_Real value, SCIP_Real weight)
Definition: var.c:15627
SCIP_Real SCIPvarGetMinPseudocostScore(SCIP_VAR *var, SCIP_STAT *stat, SCIP_SET *set, SCIP_Real solval)
Definition: var.c:14673
SCIP_RETCODE SCIPvarDelClique(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool value, SCIP_CLIQUE *clique)
Definition: var.c:11444
type definitions for collecting primal CIP solutions and primal informations
SCIP_RETCODE SCIPvarSetRelaxSol(SCIP_VAR *var, SCIP_SET *set, SCIP_RELAXATION *relaxation, SCIP_Real solval, SCIP_Bool updateobj)
Definition: var.c:13874
SCIP_RETCODE SCIPvarAddToRow(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_PROB *prob, SCIP_LP *lp, SCIP_ROW *row, SCIP_Real val)
Definition: var.c:14282
common defines and data types used in all packages of SCIP
SCIP_RETCODE SCIPvarGetActiveRepresentatives(SCIP_SET *set, SCIP_VAR **vars, SCIP_Real *scalars, int *nvars, int varssize, SCIP_Real *constant, int *requiredsize, SCIP_Bool mergemultiples)
Definition: var.c:3923
struct BMS_BlkMem BMS_BLKMEM
Definition: memory.h:439
SCIP_RETCODE SCIPboundchgUndo(SCIP_BOUNDCHG *boundchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue)
Definition: var.c:826
enum SCIP_BoundchgType SCIP_BOUNDCHGTYPE
Definition: type_var.h:87
void SCIPvarAdjustBd(SCIP_VAR *var, SCIP_SET *set, SCIP_BOUNDTYPE boundtype, SCIP_Real *bd)
Definition: var.c:6560
SCIP_RETCODE SCIPdomchgApplyGlobal(SCIP_DOMCHG *domchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool *cutoff)
Definition: var.c:1384
SCIP_RETCODE SCIPvarChgUbGlobal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Real newbound)
Definition: var.c:7337
SCIP_Real SCIPvarGetVSIDS(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
Definition: var.c:18388
type definitions for constraints and constraint handlers
SCIP_RETCODE SCIPvarFixBinary(SCIP_VAR *var, 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_CLIQUETABLE *cliquetable, SCIP_Bool value, SCIP_Bool *infeasible, int *nbdchgs)
Definition: var.c:11191
SCIP_RETCODE SCIPvarChgBranchFactor(SCIP_VAR *var, SCIP_SET *set, SCIP_Real branchfactor)
Definition: var.c:11572
uint64_t SCIP_EVENTTYPE
Definition: type_event.h:151
SCIP_RETCODE SCIPvarChgUbDive(SCIP_VAR *var, SCIP_SET *set, SCIP_LP *lp, SCIP_Real newbound)
Definition: var.c:8348
memory allocation routines