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