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