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