Scippy

SCIP

Solving Constraint Integer Programs

var.h
Go to the documentation of this file.
1/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2/* */
3/* This file is part of the program and library */
4/* SCIP --- Solving Constraint Integer Programs */
5/* */
6/* Copyright (c) 2002-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"
41#include "scip/type_cons.h"
42#include "scip/type_event.h"
43#include "scip/type_history.h"
44#include "scip/type_implics.h"
45#include "scip/type_lp.h"
46#include "scip/type_lpexact.h"
47#include "scip/type_message.h"
48#include "scip/type_misc.h"
49#include "scip/type_primal.h"
50#include "scip/type_prob.h"
51#include "scip/type_prop.h"
52#include "scip/type_relax.h"
53#include "scip/type_reopt.h"
54#include "scip/type_result.h"
55#include "scip/type_retcode.h"
56#include "scip/type_scip.h"
57#include "scip/type_set.h"
58#include "scip/type_sol.h"
59#include "scip/type_stat.h"
60#include "scip/type_tree.h"
61#include "scip/type_var.h"
62#include "scip/intervalarith.h"
63
64#ifndef NDEBUG
65#include "scip/struct_var.h"
66#else
67#include "scip/event.h"
68#include "scip/pub_history.h"
69#endif
70
71#ifdef __cplusplus
72extern "C" {
73#endif
74
75/*
76 * domain change methods
77 */
78
79/** applies single bound change */
81 SCIP_BOUNDCHG* boundchg, /**< bound change to apply */
82 BMS_BLKMEM* blkmem, /**< block memory */
83 SCIP_SET* set, /**< global SCIP settings */
84 SCIP_STAT* stat, /**< problem statistics */
85 SCIP_LP* lp, /**< current LP data */
86 SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */
87 SCIP_EVENTQUEUE* eventqueue, /**< event queue */
88 int depth, /**< depth in the tree, where the bound change takes place */
89 int pos, /**< position of the bound change in its bound change array */
90 SCIP_Bool* cutoff /**< pointer to store whether an infeasible bound change was detected */
91 );
92
93/** undoes single bound change */
95 SCIP_BOUNDCHG* boundchg, /**< bound change to remove */
96 BMS_BLKMEM* blkmem, /**< block memory */
97 SCIP_SET* set, /**< global SCIP settings */
98 SCIP_STAT* stat, /**< problem statistics */
99 SCIP_LP* lp, /**< current LP data */
100 SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */
101 SCIP_EVENTQUEUE* eventqueue /**< event queue */
102 );
103
104/** applies domain change to the global problem */
106 SCIP_DOMCHG* domchg, /**< domain change to apply */
107 BMS_BLKMEM* blkmem, /**< block memory */
108 SCIP_SET* set, /**< global SCIP settings */
109 SCIP_STAT* stat, /**< problem statistics */
110 SCIP_LP* lp, /**< current LP data */
111 SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */
112 SCIP_EVENTQUEUE* eventqueue, /**< event queue */
113 SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
114 SCIP_Bool* cutoff /**< pointer to store whether an infeasible domain change was detected */
115 );
116
117/** frees domain change data */
119 SCIP_DOMCHG** domchg, /**< pointer to domain change */
120 BMS_BLKMEM* blkmem, /**< block memory */
121 SCIP_SET* set, /**< global SCIP settings */
122 SCIP_EVENTQUEUE* eventqueue, /**< event queue */
123 SCIP_LP* lp /**< current LP data */
124 );
125
126/** converts a dynamic domain change data into a static one, using less memory than for a dynamic one */
128 SCIP_DOMCHG** domchg, /**< pointer to domain change data */
129 BMS_BLKMEM* blkmem, /**< block memory */
130 SCIP_SET* set, /**< global SCIP settings */
131 SCIP_EVENTQUEUE* eventqueue, /**< event queue */
132 SCIP_LP* lp /**< current LP data */
133 );
134
135/** applies domain change */
137 SCIP_DOMCHG* domchg, /**< domain change to apply */
138 BMS_BLKMEM* blkmem, /**< block memory */
139 SCIP_SET* set, /**< global SCIP settings */
140 SCIP_STAT* stat, /**< problem statistics */
141 SCIP_LP* lp, /**< current LP data */
142 SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */
143 SCIP_EVENTQUEUE* eventqueue, /**< event queue */
144 int depth, /**< depth in the tree, where the domain change takes place */
145 SCIP_Bool* cutoff /**< pointer to store whether an infeasible domain change was detected */
146 );
147
148/** undoes domain change */
150 SCIP_DOMCHG* domchg, /**< domain change to remove */
151 BMS_BLKMEM* blkmem, /**< block memory */
152 SCIP_SET* set, /**< global SCIP settings */
153 SCIP_STAT* stat, /**< problem statistics */
154 SCIP_LP* lp, /**< current LP data */
155 SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */
156 SCIP_EVENTQUEUE* eventqueue /**< event queue */
157 );
158
159/** adds certificate line number to domain changes */
161 SCIP_DOMCHG* domchg, /**< pointer to domain change data structure */
162 SCIP_CERTIFICATE* certificate /**< certificate information */
163 );
164
165/** adds bound change to domain changes */
167 SCIP_DOMCHG** domchg, /**< pointer to domain change data structure */
168 BMS_BLKMEM* blkmem, /**< block memory */
169 SCIP_SET* set, /**< global SCIP settings */
170 SCIP_VAR* var, /**< variable to change the bounds for */
171 SCIP_Real newbound, /**< new value for bound */
172 SCIP_RATIONAL* newboundexact, /**< new value for exact bound, or NULL if not needed */
173 SCIP_BOUNDTYPE boundtype, /**< type of bound for var: lower or upper bound */
174 SCIP_BOUNDCHGTYPE boundchgtype, /**< type of bound change: branching decision or inference */
175 SCIP_Real lpsolval, /**< solval of variable in last LP on path to node, or SCIP_INVALID if unknown */
176 SCIP_VAR* infervar, /**< variable that was changed (parent of var, or var itself) */
177 SCIP_CONS* infercons, /**< constraint that deduced the bound change, or NULL */
178 SCIP_PROP* inferprop, /**< propagator that deduced the bound change, or NULL */
179 int inferinfo, /**< user information for inference to help resolving the conflict */
180 SCIP_BOUNDTYPE inferboundtype /**< type of bound for inference var: lower or upper bound */
181 );
182
183/** adds hole change to domain changes */
185 SCIP_DOMCHG** domchg, /**< pointer to domain change data structure */
186 BMS_BLKMEM* blkmem, /**< block memory */
187 SCIP_SET* set, /**< global SCIP settings */
188 SCIP_HOLELIST** ptr, /**< changed list pointer */
189 SCIP_HOLELIST* newlist, /**< new value of list pointer */
190 SCIP_HOLELIST* oldlist /**< old value of list pointer */
191 );
192
193/** creates an artificial bound change information object with depth = INT_MAX and pos = -1 */
195 SCIP_BDCHGINFO** bdchginfo, /**< pointer to store bound change information */
196 BMS_BLKMEM* blkmem, /**< block memory */
197 SCIP_VAR* var, /**< active variable that changed the bounds */
198 SCIP_BOUNDTYPE boundtype, /**< type of bound for var: lower or upper bound */
199 SCIP_Real oldbound, /**< old value for bound */
200 SCIP_Real newbound /**< new value for bound */
201 );
202
203/** frees a bound change information object */
205 SCIP_BDCHGINFO** bdchginfo, /**< pointer to store bound change information */
206 BMS_BLKMEM* blkmem /**< block memory */
207 );
208
209/** returns the relaxed bound change type */
211 SCIP_BDCHGINFO* bdchginfo /**< bound change to add to the conflict set */
212 );
213
214/*
215 * methods for variables
216 */
217
218/** creates and captures an original problem variable; an integer variable with bounds
219 * zero and one is automatically converted into a binary variable
220 */
222 SCIP_VAR** var, /**< pointer to variable data */
223 BMS_BLKMEM* blkmem, /**< block memory */
224 SCIP_SET* set, /**< global SCIP settings */
225 SCIP_STAT* stat, /**< problem statistics */
226 const char* name, /**< name of variable */
227 SCIP_Real lb, /**< lower bound of variable */
228 SCIP_Real ub, /**< upper bound of variable */
229 SCIP_Real obj, /**< objective function value */
230 SCIP_VARTYPE vartype, /**< type of variable */
231 SCIP_IMPLINTTYPE impltype, /**< implied integral type of the variable */
232 SCIP_Bool initial, /**< should var's column be present in the initial root LP? */
233 SCIP_Bool removable, /**< is var's column removable from the LP (due to aging or cleanup)? */
234 SCIP_DECL_VARDELORIG ((*vardelorig)), /**< frees user data of original variable, or NULL */
235 SCIP_DECL_VARTRANS ((*vartrans)), /**< creates transformed user data by transforming original user data, or NULL */
236 SCIP_DECL_VARDELTRANS ((*vardeltrans)), /**< frees user data of transformed variable, or NULL */
237 SCIP_DECL_VARCOPY ((*varcopy)), /**< copies variable data if wanted to subscip, or NULL */
238 SCIP_VARDATA* vardata /**< user data for this specific variable */
239 );
240
241/** creates and captures a loose variable belonging to the transformed problem; an integer variable with bounds
242 * zero and one is automatically converted into a binary variable
243 */
245 SCIP_VAR** var, /**< pointer to variable data */
246 BMS_BLKMEM* blkmem, /**< block memory */
247 SCIP_SET* set, /**< global SCIP settings */
248 SCIP_STAT* stat, /**< problem statistics */
249 const char* name, /**< name of variable */
250 SCIP_Real lb, /**< lower bound of variable */
251 SCIP_Real ub, /**< upper bound of variable */
252 SCIP_Real obj, /**< objective function value */
253 SCIP_VARTYPE vartype, /**< type of variable */
254 SCIP_IMPLINTTYPE impltype, /**< implied integral type of the variable */
255 SCIP_Bool initial, /**< should var's column be present in the initial root LP? */
256 SCIP_Bool removable, /**< is var's column removable from the LP (due to aging or cleanup)? */
257 SCIP_DECL_VARDELORIG ((*vardelorig)), /**< frees user data of original variable, or NULL */
258 SCIP_DECL_VARTRANS ((*vartrans)), /**< creates transformed user data by transforming original user data, or NULL */
259 SCIP_DECL_VARDELTRANS ((*vardeltrans)), /**< frees user data of transformed variable, or NULL */
260 SCIP_DECL_VARCOPY ((*varcopy)), /**< copies variable data if wanted to subscip, or NULL */
261 SCIP_VARDATA* vardata /**< user data for this specific variable */
262 );
263
264/** creates and sets the exact variable bounds and objective value (using floating-point data if value pointer is NULL)
265 *
266 * @note an inactive integer variable with bounds zero and one is automatically converted into a binary variable
267 *
268 * @note if exact data is provided, the corresponding floating-point data is overwritten
269 */
271 SCIP_VAR* var, /**< pointer to variable data */
272 BMS_BLKMEM* blkmem, /**< block memory */
273 SCIP_RATIONAL* lb, /**< lower bound of variable */
274 SCIP_RATIONAL* ub, /**< upper bound of variable */
275 SCIP_RATIONAL* obj /**< objective function value */
276 );
277
278/** copies exact variable data from one variable to another
279 *
280 * @note This method cannot be integrated into SCIPvarCopy() because it is needed, e.g., when transforming vars.
281 */
283 BMS_BLKMEM* blkmem, /**< block memory */
284 SCIP_VAR* targetvar, /**< variable that gets the exact data */
285 SCIP_VAR* sourcevar, /**< variable the data gets copied from */
286 SCIP_Bool negateobj /**< should the objective be negated */
287 );
288
289/** copies and captures a variable from source to target SCIP; an integer variable with bounds zero and one is
290 * automatically converted into a binary variable; in case the variable data cannot be copied the variable is not
291 * copied at all
292 */
294 SCIP_VAR** var, /**< pointer to store the target variable */
295 BMS_BLKMEM* blkmem, /**< block memory */
296 SCIP_SET* set, /**< global SCIP settings */
297 SCIP_STAT* stat, /**< problem statistics */
298 SCIP* sourcescip, /**< source SCIP data structure */
299 SCIP_VAR* sourcevar, /**< source variable */
300 SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
301 * target variables */
302 SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
303 * target constraints */
304 SCIP_Bool global /**< should global or local bounds be used? */
305 );
306
307/** parses variable information (in cip format) out of a string; if the parsing process was successful an original
308 * variable is created and captured; if variable is of integral type, fractional bounds are automatically rounded; an
309 * integer variable with bounds zero and one is automatically converted into a binary variable
310 */
312 SCIP_VAR** var, /**< pointer to variable data */
313 BMS_BLKMEM* blkmem, /**< block memory */
314 SCIP_SET* set, /**< global SCIP settings */
315 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
316 SCIP_STAT* stat, /**< problem statistics */
317 const char* str, /**< string to parse */
318 SCIP_Bool initial, /**< should var's column be present in the initial root LP? */
319 SCIP_Bool removable, /**< is var's column removable from the LP (due to aging or cleanup)? */
320 SCIP_DECL_VARCOPY ((*varcopy)), /**< copies variable data if wanted to subscip, or NULL */
321 SCIP_DECL_VARDELORIG ((*vardelorig)), /**< frees user data of original variable */
322 SCIP_DECL_VARTRANS ((*vartrans)), /**< creates transformed user data by transforming original user data */
323 SCIP_DECL_VARDELTRANS ((*vardeltrans)), /**< frees user data of transformed variable */
324 SCIP_VARDATA* vardata, /**< user data for this specific variable */
325 char** endptr, /**< pointer to store the final string position if successfully */
326 SCIP_Bool* success /**< pointer store if the paring process was successful */
327 );
328
329/** parses variable information (in cip format) out of a string; if the parsing process was successful a loose variable
330 * belonging to the transformed problem is created and captured; if variable is of integral type, fractional bounds are
331 * automatically rounded; an integer variable with bounds zero and one is automatically converted into a binary
332 * variable
333 */
335 SCIP_VAR** var, /**< pointer to variable data */
336 BMS_BLKMEM* blkmem, /**< block memory */
337 SCIP_SET* set, /**< global SCIP settings */
338 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
339 SCIP_STAT* stat, /**< problem statistics */
340 const char* str, /**< string to parse */
341 SCIP_Bool initial, /**< should var's column be present in the initial root LP? */
342 SCIP_Bool removable, /**< is var's column removable from the LP (due to aging or cleanup)? */
343 SCIP_DECL_VARCOPY ((*varcopy)), /**< copies variable data if wanted to subscip, or NULL */
344 SCIP_DECL_VARDELORIG ((*vardelorig)), /**< frees user data of original variable */
345 SCIP_DECL_VARTRANS ((*vartrans)), /**< creates transformed user data by transforming original user data */
346 SCIP_DECL_VARDELTRANS ((*vardeltrans)), /**< frees user data of transformed variable */
347 SCIP_VARDATA* vardata, /**< user data for this specific variable */
348 char** endptr, /**< pointer to store the final string position if successfully */
349 SCIP_Bool* success /**< pointer store if the paring process was successful */
350 );
351
352/** increases usage counter of variable */
353void SCIPvarCapture(
354 SCIP_VAR* var /**< variable */
355 );
356
357/** decreases usage counter of variable, and frees memory if necessary */
359 SCIP_VAR** var, /**< pointer to variable */
360 BMS_BLKMEM* blkmem, /**< block memory */
361 SCIP_SET* set, /**< global SCIP settings */
362 SCIP_EVENTQUEUE* eventqueue, /**< event queue */
363 SCIP_LP* lp /**< current LP data (may be NULL, if it's not a column variable) */
364 );
365
366/** change variable name */
367/** change variable name */
369 SCIP_VAR* var, /**< problem variable */
370 BMS_BLKMEM* blkmem, /**< block memory */
371 const char* name /**< name of variable */
372 );
373
374/** initializes variable data structure for solving */
376 SCIP_VAR* var /**< problem variable */
377 );
378
379/** gets and captures transformed variable of a given variable; if the variable is not yet transformed,
380 * a new transformed variable for this variable is created
381 */
383 SCIP_VAR* origvar, /**< original problem variable */
384 BMS_BLKMEM* blkmem, /**< block memory of transformed problem */
385 SCIP_SET* set, /**< global SCIP settings */
386 SCIP_STAT* stat, /**< problem statistics */
387 SCIP_OBJSENSE objsense, /**< objective sense of original problem; transformed is always MINIMIZE */
388 SCIP_VAR** transvar /**< pointer to store the transformed variable */
389 );
390
391/** gets corresponding transformed variable of an original or negated original variable */
393 SCIP_VAR* origvar, /**< original problem variable */
394 BMS_BLKMEM* blkmem, /**< block memory of transformed problem */
395 SCIP_SET* set, /**< global SCIP settings */
396 SCIP_STAT* stat, /**< problem statistics */
397 SCIP_VAR** transvar /**< pointer to store the transformed variable, or NULL if not existing yet */
398 );
399
400/** converts transformed variable into column variable and creates LP column */
402 SCIP_VAR* var, /**< problem variable */
403 BMS_BLKMEM* blkmem, /**< block memory */
404 SCIP_SET* set, /**< global SCIP settings */
405 SCIP_STAT* stat, /**< problem statistics */
406 SCIP_PROB* prob, /**< problem data */
407 SCIP_LP* lp /**< current LP data */
408 );
409
410/** converts transformed variable into column variable and creates LP column */
412 SCIP_VAR* var, /**< problem variable */
413 BMS_BLKMEM* blkmem, /**< block memory */
414 SCIP_SET* set, /**< global SCIP settings */
415 SCIP_STAT* stat, /**< problem statistics */
416 SCIP_LPEXACT* lp /**< current LP data */
417 );
418
419/** converts column transformed variable back into loose variable, frees LP column */
421 SCIP_VAR* var, /**< problem variable */
422 BMS_BLKMEM* blkmem, /**< block memory */
423 SCIP_SET* set, /**< global SCIP settings */
424 SCIP_EVENTQUEUE* eventqueue, /**< event queue */
425 SCIP_PROB* prob, /**< problem data */
426 SCIP_LP* lp /**< current LP data */
427 );
428
429/** converts variable into fixed variable */
431 SCIP_VAR* var, /**< problem variable */
432 BMS_BLKMEM* blkmem, /**< block memory */
433 SCIP_SET* set, /**< global SCIP settings */
434 SCIP_STAT* stat, /**< problem statistics */
435 SCIP_PROB* transprob, /**< tranformed problem data */
436 SCIP_PROB* origprob, /**< original problem data */
437 SCIP_PRIMAL* primal, /**< primal data */
438 SCIP_TREE* tree, /**< branch and bound tree */
439 SCIP_REOPT* reopt, /**< reoptimization data structure */
440 SCIP_LP* lp, /**< current LP data */
441 SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */
442 SCIP_EVENTQUEUE* eventqueue, /**< event queue */
443 SCIP_EVENTFILTER* eventfilter, /**< global event filter */
444 SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
445 SCIP_Real fixedval, /**< value to fix variable at */
446 SCIP_Bool* infeasible, /**< pointer to store whether the fixing is infeasible */
447 SCIP_Bool* fixed /**< pointer to store whether the fixing was performed (variable was unfixed) */
448 );
449
450/** converts variable into fixed variable */
452 SCIP_VAR* var, /**< problem variable */
453 BMS_BLKMEM* blkmem, /**< block memory */
454 SCIP_SET* set, /**< global SCIP settings */
455 SCIP_STAT* stat, /**< problem statistics */
456 SCIP_PROB* transprob, /**< tranformed problem data */
457 SCIP_PROB* origprob, /**< original problem data */
458 SCIP_PRIMAL* primal, /**< primal data */
459 SCIP_TREE* tree, /**< branch and bound tree */
460 SCIP_REOPT* reopt, /**< reoptimization data structure */
461 SCIP_LP* lp, /**< current LP data */
462 SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */
463 SCIP_EVENTQUEUE* eventqueue, /**< event queue */
464 SCIP_EVENTFILTER* eventfilter, /**< global event filter */
465 SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
466 SCIP_RATIONAL* fixedval, /**< value to fix variable at */
467 SCIP_Bool* infeasible, /**< pointer to store whether the fixing is infeasible */
468 SCIP_Bool* fixed /**< pointer to store whether the fixing was performed (variable was unfixed) */
469 );
470
471/** transforms given variables, scalars and constant to the corresponding active variables, scalars and constant
472 *
473 * If the number of needed active variables is greater than the available slots in the variable array, nothing happens
474 * except that an upper bound on the required size is stored in the variable requiredsize; otherwise, the active
475 * variable representation is stored in the arrays.
476 *
477 * The reason for this approach is that we cannot reallocate memory, since we do not know how the memory has been
478 * allocated (e.g., by a C++ 'new' or SCIP functions). Note that requiredsize is an upper bound due to possible
479 * cancelations.
480 */
482 SCIP_SET* set, /**< global SCIP settings */
483 SCIP_VAR** vars, /**< variable array to get active variables */
484 SCIP_Real* scalars, /**< scalars a_1, ..., a_n in linear sum a_1*x_1 + ... + a_n*x_n + c */
485 int* nvars, /**< pointer to number of variables and values in vars and vals array */
486 int varssize, /**< available slots in vars and scalars array */
487 SCIP_Real* constant, /**< pointer to constant c in linear sum a_1*x_1 + ... + a_n*x_n + c */
488 int* requiredsize /**< pointer to store an uppper bound on the required size for the active variables */
489 );
490
491/** transforms given variables, scalars and constant to the corresponding active variables, scalars and constant
492 *
493 * If the number of needed active variables is greater than the available slots in the variable array, nothing happens except
494 * that the required size is stored in the corresponding variable; hence, if afterwards the required size is greater than the
495 * available slots (varssize), nothing happens; otherwise, the active variable representation is stored in the arrays.
496 *
497 * The reason for this approach is that we cannot reallocate memory, since we do not know how the
498 * memory has been allocated (e.g., by a C++ 'new' or SCIP functions).
499 */
501 SCIP_SET* set, /**< global SCIP settings */
502 SCIP_VAR** vars, /**< variable array to get active variables */
503 SCIP_RATIONAL** scalars, /**< scalars a_1, ..., a_n in linear sum a_1*x_1 + ... + a_n*x_n + c */
504 int* nvars, /**< pointer to number of variables and values in vars and vals array */
505 int varssize, /**< available slots in vars and scalars array */
506 SCIP_RATIONAL* constant, /**< pointer to constant c in linear sum a_1*x_1 + ... + a_n*x_n + c */
507 int* requiredsize, /**< pointer to store the required array size for the active variables */
508 SCIP_Bool mergemultiples /**< should multiple occurrences of a var be replaced by a single coeff? */
509 );
510
511/** transforms given variable, scalar and constant to the corresponding active, fixed, or
512 * multi-aggregated variable, scalar and constant; if the variable resolves to a fixed variable,
513 * "scalar" will be 0.0 and the value of the sum will be stored in "constant"; a multi-aggregation
514 * with only one active variable (this can happen due to fixings after the multi-aggregation),
515 * is treated like an aggregation; if the multi-aggregation constant is infinite, "scalar" will be 0.0
516 */
518 SCIP_VAR** var, /**< pointer to problem variable x in sum a*x + c */
519 SCIP_SET* set, /**< global SCIP settings */
520 SCIP_Real* scalar, /**< pointer to scalar a in sum a*x + c */
521 SCIP_Real* constant /**< pointer to constant c in sum a*x + c */
522 );
523
524/** transforms given variable, scalar and constant to the corresponding active, fixed, or
525 * multi-aggregated variable, scalar and constant; if the variable resolves to a fixed variable,
526 * "scalar" will be 0.0 and the value of the sum will be stored in "constant"; a multi-aggregation
527 * with only one active variable (this can happen due to fixings after the multi-aggregation),
528 * is treated like an aggregation; if the multi-aggregation constant is infinite, "scalar" will be 0.0
529 */
531 SCIP_VAR** var, /**< pointer to problem variable x in sum a*x + c */
532 SCIP_RATIONAL* scalar, /**< pointer to scalar a in sum a*x + c */
533 SCIP_RATIONAL* constant /**< pointer to constant c in sum a*x + c */
534 );
535
536/** flattens aggregation graph of multi-aggregated variable in order to avoid exponential recursion later-on */
538 SCIP_VAR* var, /**< problem variable */
539 BMS_BLKMEM* blkmem, /**< block memory */
540 SCIP_SET* set, /**< global SCIP settings */
541 SCIP_EVENTQUEUE* eventqueue /**< event queue */
542 );
543
544/** return for given variables all their active counterparts; all active variables will be pairwise different */
546 SCIP_SET* set, /**< global SCIP settings */
547 SCIP_VAR** vars, /**< variable array with given variables and as output all active
548 * variables, if enough slots exist
549 */
550 int* nvars, /**< number of given variables, and as output number of active variables,
551 * if enough slots exist
552 */
553 int varssize, /**< available slots in vars array */
554 int* requiredsize /**< pointer to store the required array size for the active variables */
555 );
556
557/** performs second step of SCIPaggregateVars():
558 * the variable to be aggregated is chosen among active problem variables x' and y', preferring a less strict variable
559 * type as aggregation variable (i.e. continuous variables are preferred over implicit integers, implicit integers
560 * or integers over binaries). If none of the variables is continuous, it is tried to find an integer
561 * aggregation (i.e. integral coefficients a'' and b'', such that a''*x' + b''*y' == c''). This can lead to
562 * the detection of infeasibility (e.g. if c'' is fractional), or to a rejection of the aggregation (denoted by
563 * aggregated == FALSE), if the resulting integer coefficients are too large and thus numerically instable.
564 */
566 SCIP_SET* set, /**< global SCIP settings */
567 BMS_BLKMEM* blkmem, /**< block memory */
568 SCIP_STAT* stat, /**< problem statistics */
569 SCIP_PROB* transprob, /**< tranformed problem data */
570 SCIP_PROB* origprob, /**< original problem data */
571 SCIP_PRIMAL* primal, /**< primal data */
572 SCIP_TREE* tree, /**< branch and bound tree */
573 SCIP_REOPT* reopt, /**< reoptimization data structure */
574 SCIP_LP* lp, /**< current LP data */
575 SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
576 SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */
577 SCIP_EVENTQUEUE* eventqueue, /**< event queue */
578 SCIP_EVENTFILTER* eventfilter, /**< global event filter */
579 SCIP_VAR* varx, /**< variable x in equality a*x + b*y == c */
580 SCIP_VAR* vary, /**< variable y in equality a*x + b*y == c */
581 SCIP_Real scalarx, /**< multiplier a in equality a*x + b*y == c */
582 SCIP_Real scalary, /**< multiplier b in equality a*x + b*y == c */
583 SCIP_Real rhs, /**< right hand side c in equality a*x + b*y == c */
584 SCIP_Bool* infeasible, /**< pointer to store whether the aggregation is infeasible */
585 SCIP_Bool* aggregated /**< pointer to store whether the aggregation was successful */
586 );
587
588/** performs second step of SCIPaggregateVarsExact():
589 * the variable to be aggregated is chosen among active problem variables x' and y', preferring a less strict variable
590 * type as aggregation variable (i.e. continuous variables are preferred over implicit integers, implicit integers
591 * or integers over binaries). If none of the variables is continuous, it is tried to find an integer
592 * aggregation (i.e. integral coefficients a'' and b'', such that a''*x' + b''*y' == c''). This can lead to
593 * the detection of infeasibility (e.g. if c'' is fractional), or to a rejection of the aggregation (denoted by
594 * aggregated == FALSE), if the resulting integer coefficients are too large and thus numerically instable.
595 *
596 * @todo check for fixings, infeasibility, bound changes, or domain holes:
597 * a) if there is no easy aggregation and we have one binary variable and another integer/implicit/binary variable
598 * b) for implicit integer variables with fractional aggregation scalar (we cannot (for technical reasons) and do
599 * not want to aggregate implicit integer variables, since we loose the corresponding divisibility property)
600 */
602 SCIP_SET* set, /**< global SCIP settings */
603 BMS_BLKMEM* blkmem, /**< block memory */
604 SCIP_STAT* stat, /**< problem statistics */
605 SCIP_PROB* transprob, /**< tranformed problem data */
606 SCIP_PROB* origprob, /**< original problem data */
607 SCIP_PRIMAL* primal, /**< primal data */
608 SCIP_TREE* tree, /**< branch and bound tree */
609 SCIP_REOPT* reopt, /**< reoptimization data structure */
610 SCIP_LP* lp, /**< current LP data */
611 SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
612 SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */
613 SCIP_EVENTQUEUE* eventqueue, /**< event queue */
614 SCIP_EVENTFILTER* eventfilter, /**< global event filter */
615 SCIP_VAR* varx, /**< variable x in equality a*x + b*y == c */
616 SCIP_VAR* vary, /**< variable y in equality a*x + b*y == c */
617 SCIP_RATIONAL* scalarx, /**< multiplier a in equality a*x + b*y == c */
618 SCIP_RATIONAL* scalary, /**< multiplier b in equality a*x + b*y == c */
619 SCIP_RATIONAL* rhs, /**< right hand side c in equality a*x + b*y == c */
620 SCIP_Bool* infeasible, /**< pointer to store whether the aggregation is infeasible */
621 SCIP_Bool* aggregated /**< pointer to store whether the aggregation was successful */
622 );
623
624/** converts loose variable into aggregated variable */
626 SCIP_VAR* var, /**< loose problem variable */
627 BMS_BLKMEM* blkmem, /**< block memory */
628 SCIP_SET* set, /**< global SCIP settings */
629 SCIP_STAT* stat, /**< problem statistics */
630 SCIP_PROB* transprob, /**< tranformed problem data */
631 SCIP_PROB* origprob, /**< original problem data */
632 SCIP_PRIMAL* primal, /**< primal data */
633 SCIP_TREE* tree, /**< branch and bound tree */
634 SCIP_REOPT* reopt, /**< reoptimization data structure */
635 SCIP_LP* lp, /**< current LP data */
636 SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
637 SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */
638 SCIP_EVENTQUEUE* eventqueue, /**< event queue */
639 SCIP_EVENTFILTER* eventfilter, /**< global event filter */
640 SCIP_VAR* aggvar, /**< loose variable y in aggregation x = a*y + c */
641 SCIP_Real scalar, /**< multiplier a in aggregation x = a*y + c */
642 SCIP_Real constant, /**< constant shift c in aggregation x = a*y + c */
643 SCIP_Bool* infeasible, /**< pointer to store whether the aggregation is infeasible */
644 SCIP_Bool* aggregated /**< pointer to store whether the aggregation was successful */
645 );
646
647/** converts loose variable into aggregated variable */
649 SCIP_VAR* var, /**< loose problem variable */
650 BMS_BLKMEM* blkmem, /**< block memory */
651 SCIP_SET* set, /**< global SCIP settings */
652 SCIP_STAT* stat, /**< problem statistics */
653 SCIP_PROB* transprob, /**< tranformed problem data */
654 SCIP_PROB* origprob, /**< original problem data */
655 SCIP_PRIMAL* primal, /**< primal data */
656 SCIP_TREE* tree, /**< branch and bound tree */
657 SCIP_REOPT* reopt, /**< reoptimization data structure */
658 SCIP_LP* lp, /**< current LP data */
659 SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
660 SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */
661 SCIP_EVENTQUEUE* eventqueue, /**< event queue */
662 SCIP_EVENTFILTER* eventfilter, /**< global event filter */
663 SCIP_VAR* aggvar, /**< loose variable y in aggregation x = a*y + c */
664 SCIP_RATIONAL* scalar, /**< multiplier a in aggregation x = a*y + c */
665 SCIP_RATIONAL* constant, /**< constant shift c in aggregation x = a*y + c */
666 SCIP_Bool* infeasible, /**< pointer to store whether the aggregation is infeasible */
667 SCIP_Bool* aggregated /**< pointer to store whether the aggregation was successful */
668 );
669
670/** converts variable into multi-aggregated variable */
672 SCIP_VAR* var, /**< problem variable */
673 BMS_BLKMEM* blkmem, /**< block memory */
674 SCIP_SET* set, /**< global SCIP settings */
675 SCIP_STAT* stat, /**< problem statistics */
676 SCIP_PROB* transprob, /**< tranformed problem data */
677 SCIP_PROB* origprob, /**< original problem data */
678 SCIP_PRIMAL* primal, /**< primal data */
679 SCIP_TREE* tree, /**< branch and bound tree */
680 SCIP_REOPT* reopt, /**< reoptimization data structure */
681 SCIP_LP* lp, /**< current LP data */
682 SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
683 SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */
684 SCIP_EVENTQUEUE* eventqueue, /**< event queue */
685 SCIP_EVENTFILTER* eventfilter, /**< global event filter */
686 int naggvars, /**< number n of variables in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
687 SCIP_VAR** aggvars, /**< variables y_i in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
688 SCIP_Real* scalars, /**< multipliers a_i in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
689 SCIP_Real constant, /**< constant shift c in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
690 SCIP_Bool* infeasible, /**< pointer to store whether the aggregation is infeasible */
691 SCIP_Bool* aggregated /**< pointer to store whether the aggregation was successful */
692 );
693
694/** converts variable into multi-aggregated variable */
696 SCIP_VAR* var, /**< problem variable */
697 BMS_BLKMEM* blkmem, /**< block memory */
698 SCIP_SET* set, /**< global SCIP settings */
699 SCIP_STAT* stat, /**< problem statistics */
700 SCIP_PROB* transprob, /**< tranformed problem data */
701 SCIP_PROB* origprob, /**< original problem data */
702 SCIP_PRIMAL* primal, /**< primal data */
703 SCIP_TREE* tree, /**< branch and bound tree */
704 SCIP_REOPT* reopt, /**< reoptimization data structure */
705 SCIP_LPEXACT* lpexact, /**< current LP data */
706 SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
707 SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */
708 SCIP_EVENTQUEUE* eventqueue, /**< event queue */
709 SCIP_EVENTFILTER* eventfilter, /**< global event filter */
710 int naggvars, /**< number n of variables in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
711 SCIP_VAR** aggvars, /**< variables y_i in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
712 SCIP_RATIONAL** scalars, /**< multipliers a_i in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
713 SCIP_RATIONAL* constant, /**< constant shift c in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
714 SCIP_Bool* infeasible, /**< pointer to store whether the aggregation is infeasible */
715 SCIP_Bool* aggregated /**< pointer to store whether the aggregation was successful */
716 );
717
718/** returns whether variable is not allowed to be aggregated */
720 SCIP_VAR* var /**< problem variable */
721 );
722
723/** returns whether variable is not allowed to be multi-aggregated */
725 SCIP_VAR* var /**< problem variable */
726 );
727
728/** checks whether a loose variable can be used in a new aggregation with given coefficient */
730 SCIP_SET* set, /**< global SCIP settings */
731 SCIP_VAR* var, /**< problem variable */
732 SCIP_Real scalar /**< aggregation scalar */
733 );
734
735/** returns whether the variable was flagged for deletion from global structures (cliques etc.) */
737 SCIP_VAR* var /**< problem variable */
738 );
739
740/** gets negated variable x' = offset - x of problem variable x; the negated variable is created if not yet existing;
741 * the negation offset of binary variables is always 1, the offset of other variables is fixed to lb + ub when the
742 * negated variable is created
743 */
745 SCIP_VAR* var, /**< problem variable to negate */
746 BMS_BLKMEM* blkmem, /**< block memory of transformed problem */
747 SCIP_SET* set, /**< global SCIP settings */
748 SCIP_STAT* stat, /**< problem statistics */
749 SCIP_VAR** negvar /**< pointer to store the negated variable */
750 );
751
752/** informs variable that its position in problem's vars array changed */
754 SCIP_VAR* var, /**< problem variable */
755 int probindex /**< new problem index of variable */
756 );
757
758/** gives the variable a new name
759 *
760 * @note the old pointer is overwritten, which might result in a memory leakage
761 */
763 SCIP_VAR* var, /**< problem variable */
764 const char* name /**< new name of variable */
765 );
766
767/** informs variable that it will be removed from the problem; adjusts probindex and removes variable from the
768 * implication graph;
769 * If 'final' is TRUE, the thorough implication graph removal is not performed. Instead, only the
770 * variable bounds and implication data structures of the variable are freed. Since in the final removal
771 * of all variables from the transformed problem, this deletes the implication graph completely and is faster
772 * than removing the variables one by one, each time updating all lists of the other variables.
773 * If 'keepimplics' is TRUE, the implications, variable bounds and cliques are kept. This should be used when the
774 * variable type is upgraded, i.e. when it gains (implied) integrality, so that existing implications are not lost.
775 */
777 SCIP_VAR* var, /**< problem variable */
778 BMS_BLKMEM* blkmem, /**< block memory buffer */
779 SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
780 SCIP_SET* set, /**< global SCIP settings */
781 SCIP_Bool final, /**< is this the final removal of all problem variables? */
782 SCIP_Bool keepimplics /**< should the implications be kept? */
783 );
784
785/** marks the variable to be deleted from the problem */
787 SCIP_VAR* var /**< problem variable */
788 );
789
790/** marks the variable to not to be maggregated */
792 SCIP_VAR* var /**< problem variable */
793 );
794
795/** marks the variable to not to be multi-aggregated */
797 SCIP_VAR* var /**< problem variable */
798 );
799
800/** modifies lock numbers for rounding */
802 SCIP_VAR* var, /**< problem variable */
803 BMS_BLKMEM* blkmem, /**< block memory */
804 SCIP_SET* set, /**< global SCIP settings */
805 SCIP_EVENTQUEUE* eventqueue, /**< event queue */
806 SCIP_LOCKTYPE locktype, /**< type of the variable locks */
807 int addnlocksdown, /**< increase in number of rounding down locks */
808 int addnlocksup /**< increase in number of rounding up locks */
809 );
810
811/** changes type of variable; cannot be called, if var belongs to a problem */
813 SCIP_VAR* var, /**< variable to change */
814 BMS_BLKMEM* blkmem, /**< block memory */
815 SCIP_SET* set, /**< global SCIP settings */
816 SCIP_PRIMAL* primal, /**< primal data */
817 SCIP_LP* lp, /**< current LP data */
818 SCIP_EVENTQUEUE* eventqueue, /**< event queue */
819 SCIP_VARTYPE vartype /**< new type of variable */
820 );
821
822/** changes implied integral type of variable; cannot be called, if var belongs to a problem */
824 SCIP_VAR* var, /**< variable to change */
825 BMS_BLKMEM* blkmem, /**< block memory */
826 SCIP_SET* set, /**< global SCIP settings */
827 SCIP_PRIMAL* primal, /**< primal data */
828 SCIP_LP* lp, /**< current LP data */
829 SCIP_EVENTQUEUE* eventqueue, /**< event queue */
830 SCIP_IMPLINTTYPE impltype /**< new implied integral type of variable */
831);
832
833/** changes objective value of variable */
835 SCIP_VAR* var, /**< variable to change */
836 BMS_BLKMEM* blkmem, /**< block memory */
837 SCIP_SET* set, /**< global SCIP settings */
838 SCIP_PROB* prob, /**< problem data */
839 SCIP_PRIMAL* primal, /**< primal data */
840 SCIP_LP* lp, /**< current LP data */
841 SCIP_EVENTQUEUE* eventqueue, /**< event queue */
842 SCIP_Real newobj /**< new objective value for variable */
843 );
844
845/** changes objective value of variable */
847 SCIP_VAR* var, /**< variable to change */
848 BMS_BLKMEM* blkmem, /**< block memory */
849 SCIP_SET* set, /**< global SCIP settings */
850 SCIP_PROB* prob, /**< problem data */
851 SCIP_PRIMAL* primal, /**< primal data */
852 SCIP_LPEXACT* lp, /**< current LP data */
853 SCIP_EVENTQUEUE* eventqueue, /**< event queue */
854 SCIP_RATIONAL* newobj /**< new objective value for variable */
855 );
856
857/** changes rational objective value of variable */
859 SCIP_VAR* var, /**< variable to change */
860 BMS_BLKMEM* blkmem, /**< block memory */
861 SCIP_SET* set, /**< global SCIP settings */
862 SCIP_STAT* stat, /**< problem statistics */
863 SCIP_LPEXACT* lpexact, /**< current LP data */
864 SCIP_BRANCHCAND* branchcand, /**< branching candidate storage, may be NULL for original variables */
865 SCIP_EVENTQUEUE* eventqueue, /**< event queue, may be NULL for original variables */
866 SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
867 SCIP_RATIONAL* newbound /**< new upper bound value for variable */
868 );
869
870/** changes rational objective value of variable */
872 SCIP_VAR* var, /**< variable to change */
873 BMS_BLKMEM* blkmem, /**< block memory */
874 SCIP_SET* set, /**< global SCIP settings */
875 SCIP_STAT* stat, /**< problem statistics */
876 SCIP_LPEXACT* lpexact, /**< current LP data */
877 SCIP_BRANCHCAND* branchcand, /**< branching candidate storage, may be NULL for original variables */
878 SCIP_EVENTQUEUE* eventqueue, /**< event queue, may be NULL for original variables */
879 SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
880 SCIP_RATIONAL* newbound /**< new upper bound value for variable */
881 );
882
883/** adds value to objective value of variable */
885 SCIP_VAR* var, /**< variable to change */
886 BMS_BLKMEM* blkmem, /**< block memory */
887 SCIP_SET* set, /**< global SCIP settings */
888 SCIP_STAT* stat, /**< problem statistics */
889 SCIP_PROB* transprob, /**< tranformed problem data */
890 SCIP_PROB* origprob, /**< original problem data */
891 SCIP_PRIMAL* primal, /**< primal data */
892 SCIP_TREE* tree, /**< branch and bound tree */
893 SCIP_REOPT* reopt, /**< reoptimization data structure */
894 SCIP_LP* lp, /**< current LP data */
895 SCIP_EVENTQUEUE* eventqueue, /**< event queue */
896 SCIP_EVENTFILTER* eventfilter, /**< global event filter */
897 SCIP_Real addobj /**< additional objective value for variable */
898 );
899
900/** adds exact value to objective value of variable */
902 SCIP_VAR* var, /**< variable to change */
903 BMS_BLKMEM* blkmem, /**< block memory */
904 SCIP_SET* set, /**< global SCIP settings */
905 SCIP_STAT* stat, /**< problem statistics */
906 SCIP_PROB* transprob, /**< transformed problem data */
907 SCIP_PROB* origprob, /**< original problem data */
908 SCIP_PRIMAL* primal, /**< primal data */
909 SCIP_TREE* tree, /**< branch and bound tree */
910 SCIP_REOPT* reopt, /**< reoptimization data structure */
911 SCIP_LP* lp, /**< current LP data */
912 SCIP_EVENTQUEUE* eventqueue, /**< event queue */
913 SCIP_EVENTFILTER* eventfilter, /**< global event filter */
914 SCIP_RATIONAL* addobj /**< additional objective value for variable */
915 );
916
917/** changes objective value of variable in current dive */
919 SCIP_VAR* var, /**< problem variable to change */
920 SCIP_SET* set, /**< global SCIP settings */
921 SCIP_LP* lp, /**< current LP data */
922 SCIP_Real newobj /**< new objective value for variable */
923 );
924
925/** adjust lower bound to integral value, if variable is integral */
926void SCIPvarAdjustLb(
927 SCIP_VAR* var, /**< problem variable */
928 SCIP_SET* set, /**< global SCIP settings */
929 SCIP_Real* lb /**< pointer to lower bound to adjust */
930 );
931
932/** adjust lower bound to integral value, if variable is integral */
934 SCIP_VAR* var, /**< problem variable */
935 SCIP_SET* set, /**< global SCIP settings */
936 SCIP_RATIONAL* lb /**< pointer to lower bound to adjust */
937 );
938
939/** adjust lower bound to integral value, if variable is integral */
941 SCIP_VAR* var, /**< problem variable */
942 SCIP_SET* set, /**< global SCIP settings */
943 SCIP_Real* lb /**< pointer to lower bound to adjust */
944 );
945
946/** adjust upper bound to integral value, if variable is integral */
947void SCIPvarAdjustUb(
948 SCIP_VAR* var, /**< problem variable */
949 SCIP_SET* set, /**< global SCIP settings */
950 SCIP_Real* ub /**< pointer to upper bound to adjust */
951 );
952
953/** adjust lower bound to integral value, if variable is integral */
955 SCIP_VAR* var, /**< problem variable */
956 SCIP_SET* set, /**< global SCIP settings */
957 SCIP_RATIONAL* ub /**< pointer to lower bound to adjust */
958 );
959
960/** adjust lower bound to integral value, if variable is integral */
962 SCIP_VAR* var, /**< problem variable */
963 SCIP_SET* set, /**< global SCIP settings */
964 SCIP_Real* ub /**< pointer to upper bound to adjust */
965 );
966
967/** adjust lower or upper bound to integral value, if variable is integral */
968void SCIPvarAdjustBd(
969 SCIP_VAR* var, /**< problem variable */
970 SCIP_SET* set, /**< global SCIP settings */
971 SCIP_BOUNDTYPE boundtype, /**< type of bound to adjust */
972 SCIP_Real* bd /**< pointer to bound to adjust */
973 );
974
975/** changes lower bound of original variable in original problem */
977 SCIP_VAR* var, /**< problem variable to change */
978 SCIP_SET* set, /**< global SCIP settings */
979 SCIP_Real newbound /**< new bound for variable */
980 );
981
982/** changes exact lower bound of original variable in original problem */
984 SCIP_VAR* var, /**< problem variable to change */
985 SCIP_SET* set, /**< global SCIP settings */
986 SCIP_RATIONAL* newbound /**< new bound for variable */
987 );
988
989/** changes upper bound of original variable in original problem */
991 SCIP_VAR* var, /**< problem variable to change */
992 SCIP_SET* set, /**< global SCIP settings */
993 SCIP_Real newbound /**< new bound for variable */
994 );
995
996/** changes exact upper bound of original variable in original problem */
998 SCIP_VAR* var, /**< problem variable to change */
999 SCIP_SET* set, /**< global SCIP settings */
1000 SCIP_RATIONAL* newbound /**< new bound for variable */
1001 );
1002
1003/** changes global lower bound of variable; if possible, adjusts bound to integral value;
1004 * updates local lower bound if the global bound is tighter
1005 */
1007 SCIP_VAR* var, /**< problem variable to change */
1008 BMS_BLKMEM* blkmem, /**< block memory */
1009 SCIP_SET* set, /**< global SCIP settings */
1010 SCIP_STAT* stat, /**< problem statistics */
1011 SCIP_LP* lp, /**< current LP data, may be NULL for original variables */
1012 SCIP_BRANCHCAND* branchcand, /**< branching candidate storage, may be NULL for original variables */
1013 SCIP_EVENTQUEUE* eventqueue, /**< event queue, may be NULL for original variables */
1014 SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
1015 SCIP_Real newbound /**< new bound for variable */
1016 );
1017
1018/** changes global upper bound of variable; if possible, adjusts bound to integral value;
1019 * updates local upper bound if the global bound is tighter
1020 */
1022 SCIP_VAR* var, /**< problem variable to change */
1023 BMS_BLKMEM* blkmem, /**< block memory */
1024 SCIP_SET* set, /**< global SCIP settings */
1025 SCIP_STAT* stat, /**< problem statistics */
1026 SCIP_LP* lp, /**< current LP data, may be NULL for original variables */
1027 SCIP_BRANCHCAND* branchcand, /**< branching candidate storage, may be NULL for original variables */
1028 SCIP_EVENTQUEUE* eventqueue, /**< event queue, may be NULL for original variables */
1029 SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
1030 SCIP_Real newbound /**< new bound for variable */
1031 );
1032
1033/** changes global bound of variable; if possible, adjusts bound to integral value;
1034 * updates local bound if the global bound is tighter
1035 */
1037 SCIP_VAR* var, /**< problem variable to change */
1038 BMS_BLKMEM* blkmem, /**< block memory */
1039 SCIP_SET* set, /**< global SCIP settings */
1040 SCIP_STAT* stat, /**< problem statistics */
1041 SCIP_LP* lp, /**< current LP data, may be NULL for original variables */
1042 SCIP_BRANCHCAND* branchcand, /**< branching candidate storage, may be NULL for original variables */
1043 SCIP_EVENTQUEUE* eventqueue, /**< event queue, may be NULL for original variables */
1044 SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
1045 SCIP_Real newbound, /**< new bound for variable */
1046 SCIP_BOUNDTYPE boundtype /**< type of bound: lower or upper bound */
1047 );
1048
1049/** changes exact global bound of variable; if possible, adjusts bound to integral value;
1050 * updates local bound if the global bound is tighter
1051 */
1053 SCIP_VAR* var, /**< problem variable to change */
1054 BMS_BLKMEM* blkmem, /**< block memory */
1055 SCIP_SET* set, /**< global SCIP settings */
1056 SCIP_STAT* stat, /**< problem statistics */
1057 SCIP_LPEXACT* lpexact, /**< current LP data, may be NULL for original variables */
1058 SCIP_BRANCHCAND* branchcand, /**< branching candidate storage, may be NULL for original variables */
1059 SCIP_EVENTQUEUE* eventqueue, /**< event queue, may be NULL for original variables */
1060 SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
1061 SCIP_RATIONAL* newbound, /**< new bound for variable */
1062 SCIP_BOUNDTYPE boundtype /**< type of bound: lower or upper bound */
1063 );
1064
1065/** changes current local lower bound of variable; if possible, adjusts bound to integral value; stores inference
1066 * information in variable
1067 */
1069 SCIP_VAR* var, /**< problem variable to change */
1070 BMS_BLKMEM* blkmem, /**< block memory */
1071 SCIP_SET* set, /**< global SCIP settings */
1072 SCIP_STAT* stat, /**< problem statistics */
1073 SCIP_LP* lp, /**< current LP data, may be NULL for original variables */
1074 SCIP_BRANCHCAND* branchcand, /**< branching candidate storage, may be NULL for original variables */
1075 SCIP_EVENTQUEUE* eventqueue, /**< event queue, may be NULL for original variables */
1076 SCIP_Real newbound /**< new bound for variable */
1077 );
1078
1079/** changes current exact local lower bound of variable; if possible, adjusts bound to integral value; stores inference
1080 * information in variable
1081 */
1083 SCIP_VAR* var, /**< problem variable to change */
1084 BMS_BLKMEM* blkmem, /**< block memory */
1085 SCIP_SET* set, /**< global SCIP settings */
1086 SCIP_STAT* stat, /**< problem statistics */
1087 SCIP_LPEXACT* lpexact, /**< current exact LP data, may be NULL for original variables */
1088 SCIP_BRANCHCAND* branchcand, /**< branching candidate storage, may be NULL for original variables */
1089 SCIP_EVENTQUEUE* eventqueue, /**< event queue, may be NULL for original variables */
1090 SCIP_RATIONAL* newbound /**< new bound for variable */
1091 );
1092
1093/** changes current local upper bound of variable; if possible, adjusts bound to integral value; stores inference
1094 * information in variable
1095 */
1097 SCIP_VAR* var, /**< problem variable to change */
1098 BMS_BLKMEM* blkmem, /**< block memory */
1099 SCIP_SET* set, /**< global SCIP settings */
1100 SCIP_STAT* stat, /**< problem statistics */
1101 SCIP_LP* lp, /**< current LP data, may be NULL for original variables */
1102 SCIP_BRANCHCAND* branchcand, /**< branching candidate storage, may be NULL for original variables */
1103 SCIP_EVENTQUEUE* eventqueue, /**< event queue, may be NULL for original variables */
1104 SCIP_Real newbound /**< new bound for variable */
1105 );
1106
1107/** changes current exact upper lower bound of variable; if possible, adjusts bound to integral value; stores inference
1108 * information in variable
1109 */
1111 SCIP_VAR* var, /**< problem variable to change */
1112 BMS_BLKMEM* blkmem, /**< block memory */
1113 SCIP_SET* set, /**< global SCIP settings */
1114 SCIP_STAT* stat, /**< problem statistics */
1115 SCIP_LPEXACT* lpexact, /**< current exact LP data, may be NULL for original variables */
1116 SCIP_BRANCHCAND* branchcand, /**< branching candidate storage, may be NULL for original variables */
1117 SCIP_EVENTQUEUE* eventqueue, /**< event queue, may be NULL for original variables */
1118 SCIP_RATIONAL* newbound /**< new bound for variable */
1119 );
1120
1121/** changes current local bound of variable; if possible, adjusts bound to integral value; stores inference
1122 * information in variable
1123 */
1125 SCIP_VAR* var, /**< problem variable to change */
1126 BMS_BLKMEM* blkmem, /**< block memory */
1127 SCIP_SET* set, /**< global SCIP settings */
1128 SCIP_STAT* stat, /**< problem statistics */
1129 SCIP_LP* lp, /**< current LP data, may be NULL for original variables */
1130 SCIP_BRANCHCAND* branchcand, /**< branching candidate storage, may be NULL for original variables */
1131 SCIP_EVENTQUEUE* eventqueue, /**< event queue, may be NULL for original variables */
1132 SCIP_Real newbound, /**< new bound for variable */
1133 SCIP_BOUNDTYPE boundtype /**< type of bound: lower or upper bound */
1134 );
1135
1136/** changes lazy lower bound of the variable, this is only possible if the variable is not in the LP yet */
1138 SCIP_VAR* var, /**< problem variable */
1139 SCIP_SET* set, /**< global SCIP settings */
1140 SCIP_Real lazylb /**< the lazy lower bound to be set */
1141 );
1142
1143/** changes lazy upper bound of the variable, this is only possible if the variable is not in the LP yet */
1145 SCIP_VAR* var, /**< problem variable */
1146 SCIP_SET* set, /**< global SCIP settings */
1147 SCIP_Real lazyub /**< the lazy upper bound to be set */
1148 );
1149
1150/** changes lower bound of variable in current dive; if possible, adjusts bound to integral value */
1152 SCIP_VAR* var, /**< problem variable to change */
1153 SCIP_SET* set, /**< global SCIP settings */
1154 SCIP_LP* lp, /**< current LP data */
1155 SCIP_Real newbound /**< new bound for variable */
1156 );
1157
1158/** changes lower bound of variable in current exact dive */
1160 SCIP_VAR* var, /**< problem variable to change */
1161 SCIP_SET* set, /**< global SCIP settings */
1162 SCIP_LPEXACT* lpexact, /**< current exact LP data */
1163 SCIP_RATIONAL* newbound /**< new bound for variable */
1164 );
1165
1166/** changes upper bound of variable in current dive; if possible, adjusts bound to integral value */
1168 SCIP_VAR* var, /**< problem variable to change */
1169 SCIP_SET* set, /**< global SCIP settings */
1170 SCIP_LP* lp, /**< current LP data */
1171 SCIP_Real newbound /**< new bound for variable */
1172 );
1173
1174/** changes upper bound of variable in current exact dive */
1176 SCIP_VAR* var, /**< problem variable to change */
1177 SCIP_SET* set, /**< global SCIP settings */
1178 SCIP_LPEXACT* lpexact, /**< current exact LP data */
1179 SCIP_RATIONAL* newbound /**< new bound for variable */
1180 );
1181
1182/** for a multi-aggregated variable, gives the local lower bound computed by adding the local bounds from all aggregation variables
1183 * 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
1184 * calling this function for a non-multi-aggregated variable is not allowed
1185 */
1187 SCIP_VAR* var, /**< problem variable */
1188 SCIP_SET* set /**< global SCIP settings */
1189 );
1190
1191/** for a multi-aggregated variable, gives the exact local lower bound computed by adding the local bounds from all aggregation variables
1192 * 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
1193 * calling this function for a non-multi-aggregated variable is not allowed
1194 */
1196 SCIP_VAR* var, /**< problem variable */
1197 SCIP_SET* set, /**< global SCIP settings */
1198 SCIP_RATIONAL* result /**< the resulting bound */
1199 );
1200
1201/** for a multi-aggregated variable, gives the local upper bound computed by adding the local bounds from all aggregation variables
1202 * 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
1203 * calling this function for a non-multi-aggregated variable is not allowed
1204 */
1206 SCIP_VAR* var, /**< problem variable */
1207 SCIP_SET* set /**< global SCIP settings */
1208 );
1209
1210/** for a multi-aggregated variable, gives the exact local upper bound computed by adding the local bounds from all aggregation variables
1211 * this lower bound may be tighter than the one given by SCIPvarGetUbLocal, since the latter is not updated if bounds of aggregation variables are changing
1212 * calling this function for a non-multi-aggregated variable is not allowed
1213 */
1215 SCIP_VAR* var, /**< problem variable */
1216 SCIP_SET* set, /**< global SCIP settings */
1217 SCIP_RATIONAL* result /**< the resulting bound */
1218 );
1219
1220/** for a multi-aggregated variable, gives the global lower bound computed by adding the global bounds from all aggregation variables
1221 * 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
1222 * calling this function for a non-multi-aggregated variable is not allowed
1223 */
1225 SCIP_VAR* var, /**< problem variable */
1226 SCIP_SET* set /**< global SCIP settings */
1227 );
1228
1229/** for a multi-aggregated variable, gives the global upper bound computed by adding the global bounds from all aggregation variables
1230 * 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
1231 * calling this function for a non-multi-aggregated variable is not allowed
1232 */
1234 SCIP_VAR* var, /**< problem variable */
1235 SCIP_SET* set /**< global SCIP settings */
1236 );
1237
1238/** adds a hole to the original domain of the variable*/
1240 SCIP_VAR* var, /**< problem variable */
1241 BMS_BLKMEM* blkmem, /**< block memory */
1242 SCIP_SET* set, /**< global SCIP settings */
1243 SCIP_Real left, /**< left bound of open interval in new hole */
1244 SCIP_Real right /**< right bound of open interval in new hole */
1245 );
1246
1247/** adds a hole to the variable's global domain */
1249 SCIP_VAR* var, /**< problem variable */
1250 BMS_BLKMEM* blkmem, /**< block memory */
1251 SCIP_SET* set, /**< global SCIP settings */
1252 SCIP_STAT* stat, /**< problem statistics */
1253 SCIP_EVENTQUEUE* eventqueue, /**< event queue, may be NULL for original variables */
1254 SCIP_Real left, /**< left bound of open interval in new hole */
1255 SCIP_Real right, /**< right bound of open interval in new hole */
1256 SCIP_Bool* added /**< pointer to store whether the hole was added, or NULL */
1257 );
1258
1259/** adds a hole to the variable's current local domain */
1261 SCIP_VAR* var, /**< problem variable */
1262 BMS_BLKMEM* blkmem, /**< block memory */
1263 SCIP_SET* set, /**< global SCIP settings */
1264 SCIP_STAT* stat, /**< problem statistics */
1265 SCIP_EVENTQUEUE* eventqueue, /**< event queue, may be NULL for original variables */
1266 SCIP_Real left, /**< left bound of open interval in new hole */
1267 SCIP_Real right, /**< right bound of open interval in new hole */
1268 SCIP_Bool* added /**< pointer to store whether the hole was added, or NULL */
1269 );
1270
1271/** resets the global and local bounds of original variable to their original values */
1273 SCIP_VAR* var, /**< problem variable */
1274 BMS_BLKMEM* blkmem, /**< block memory */
1275 SCIP_SET* set, /**< global SCIP settings */
1276 SCIP_STAT* stat /**< problem statistics */
1277 );
1278
1279/** returns at which depth in the tree a bound change was applied to the variable that conflicts with the
1280 * given bound; returns -1 if the bound does not conflict with the current local bounds of the variable
1281 */
1283 SCIP_VAR* var, /**< problem variable */
1284 SCIP_SET* set, /**< global SCIP settings */
1285 SCIP_BOUNDTYPE boundtype, /**< bound type of the conflicting bound */
1286 SCIP_Real bound /**< conflicting bound */
1287 );
1288
1289/** informs variable x about a globally valid variable lower bound x >= b*z + d with integer variable z;
1290 * if z is binary, the corresponding valid implication for z is also added;
1291 * improves the global bounds of the variable and the vlb variable if possible
1292 */
1294 SCIP_VAR* var, /**< problem variable */
1295 BMS_BLKMEM* blkmem, /**< block memory */
1296 SCIP_SET* set, /**< global SCIP settings */
1297 SCIP_STAT* stat, /**< problem statistics */
1298 SCIP_PROB* transprob, /**< transformed problem */
1299 SCIP_PROB* origprob, /**< original problem */
1300 SCIP_TREE* tree, /**< branch and bound tree if in solving stage */
1301 SCIP_REOPT* reopt, /**< reoptimization data structure */
1302 SCIP_LP* lp, /**< current LP data */
1303 SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
1304 SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */
1305 SCIP_EVENTQUEUE* eventqueue, /**< event queue */
1306 SCIP_EVENTFILTER* eventfilter, /**< global event filter */
1307 SCIP_VAR* vlbvar, /**< variable z in x >= b*z + d */
1308 SCIP_Real vlbcoef, /**< coefficient b in x >= b*z + d */
1309 SCIP_Real vlbconstant, /**< constant d in x >= b*z + d */
1310 SCIP_Bool transitive, /**< should transitive closure of implication also be added? */
1311 SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
1312 int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
1313 );
1314
1315/** informs variable x about a globally valid variable upper bound x <= b*z + d with integer variable z;
1316 * if z is binary, the corresponding valid implication for z is also added;
1317 * updates the global bounds of the variable and the vub variable correspondingly
1318 */
1320 SCIP_VAR* var, /**< problem variable */
1321 BMS_BLKMEM* blkmem, /**< block memory */
1322 SCIP_SET* set, /**< global SCIP settings */
1323 SCIP_STAT* stat, /**< problem statistics */
1324 SCIP_PROB* transprob, /**< transformed problem */
1325 SCIP_PROB* origprob, /**< original problem */
1326 SCIP_TREE* tree, /**< branch and bound tree if in solving stage */
1327 SCIP_REOPT* reopt, /**< reoptimization data structure */
1328 SCIP_LP* lp, /**< current LP data */
1329 SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
1330 SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */
1331 SCIP_EVENTQUEUE* eventqueue, /**< event queue */
1332 SCIP_EVENTFILTER* eventfilter, /**< global event filter */
1333 SCIP_VAR* vubvar, /**< variable z in x <= b*z + d */
1334 SCIP_Real vubcoef, /**< coefficient b in x <= b*z + d */
1335 SCIP_Real vubconstant, /**< constant d in x <= b*z + d */
1336 SCIP_Bool transitive, /**< should transitive closure of implication also be added? */
1337 SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
1338 int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
1339 );
1340
1341/** informs binary variable x about a globally valid implication: x == 0 or x == 1 ==> y <= b or y >= b;
1342 * also adds the corresponding implication or variable bound to the implied variable;
1343 * if the implication is conflicting, the variable is fixed to the opposite value;
1344 * if the variable is already fixed to the given value, the implication is performed immediately;
1345 * if the implication is redundant with respect to the variables' global bounds, it is ignored
1346 */
1348 SCIP_VAR* var, /**< problem variable */
1349 BMS_BLKMEM* blkmem, /**< block memory */
1350 SCIP_SET* set, /**< global SCIP settings */
1351 SCIP_STAT* stat, /**< problem statistics */
1352 SCIP_PROB* transprob, /**< transformed problem */
1353 SCIP_PROB* origprob, /**< original problem */
1354 SCIP_TREE* tree, /**< branch and bound tree if in solving stage */
1355 SCIP_REOPT* reopt, /**< reoptimization data structure */
1356 SCIP_LP* lp, /**< current LP data */
1357 SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
1358 SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */
1359 SCIP_EVENTQUEUE* eventqueue, /**< event queue */
1360 SCIP_EVENTFILTER* eventfilter, /**< global event filter */
1361 SCIP_Bool varfixing, /**< FALSE if y should be added in implications for x == 0, TRUE for x == 1 */
1362 SCIP_VAR* implvar, /**< variable y in implication y <= b or y >= b */
1363 SCIP_BOUNDTYPE impltype, /**< type of implication y <= b (SCIP_BOUNDTYPE_UPPER) or y >= b (SCIP_BOUNDTYPE_LOWER) */
1364 SCIP_Real implbound, /**< bound b in implication y <= b or y >= b */
1365 SCIP_Bool transitive, /**< should transitive closure of implication also be added? */
1366 SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
1367 int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
1368 );
1369
1370/** fixes the bounds of a binary variable to the given value, counting bound changes and detecting infeasibility */
1372 SCIP_VAR* var, /**< problem variable */
1373 BMS_BLKMEM* blkmem, /**< block memory */
1374 SCIP_SET* set, /**< global SCIP settings */
1375 SCIP_STAT* stat, /**< problem statistics */
1376 SCIP_PROB* transprob, /**< transformed problem */
1377 SCIP_PROB* origprob, /**< original problem */
1378 SCIP_TREE* tree, /**< branch and bound tree if in solving stage */
1379 SCIP_REOPT* reopt, /**< reoptimization data structure */
1380 SCIP_LP* lp, /**< current LP data */
1381 SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */
1382 SCIP_EVENTQUEUE* eventqueue, /**< event queue */
1383 SCIP_EVENTFILTER* eventfilter, /**< global event filter */
1384 SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
1385 SCIP_Bool value, /**< value to fix variable to */
1386 SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
1387 int* nbdchgs /**< pointer to count the number of performed bound changes, or NULL */
1388 );
1389
1390/** adds the variable to the given clique and updates the list of cliques the binary variable is member of;
1391 * if the variable now appears twice in the clique with the same value, it is fixed to the opposite value;
1392 * if the variable now appears twice in the clique with opposite values, all other variables are fixed to
1393 * the opposite of the value they take in the clique
1394 */
1396 SCIP_VAR* var, /**< problem variable */
1397 BMS_BLKMEM* blkmem, /**< block memory */
1398 SCIP_SET* set, /**< global SCIP settings */
1399 SCIP_STAT* stat, /**< problem statistics */
1400 SCIP_PROB* transprob, /**< transformed problem */
1401 SCIP_PROB* origprob, /**< original problem */
1402 SCIP_TREE* tree, /**< branch and bound tree if in solving stage */
1403 SCIP_REOPT* reopt, /**< reoptimization data structure */
1404 SCIP_LP* lp, /**< current LP data */
1405 SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */
1406 SCIP_EVENTQUEUE* eventqueue, /**< event queue */
1407 SCIP_EVENTFILTER* eventfilter, /**< global event filter */
1408 SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
1409 SCIP_Bool value, /**< value of the variable in the clique */
1410 SCIP_CLIQUE* clique, /**< clique the variable should be added to */
1411 SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
1412 int* nbdchgs /**< pointer to count the number of performed bound changes, or NULL */
1413 );
1414
1415/** adds a filled clique to the cliquelists of all corresponding variables */
1417 SCIP_VAR** vars, /**< problem variables */
1418 SCIP_Bool* values, /**< values of the variables in the clique */
1419 int nvars, /**< number of problem variables */
1420 BMS_BLKMEM* blkmem, /**< block memory */
1421 SCIP_SET* set, /**< global SCIP settings */
1422 SCIP_CLIQUE* clique /**< clique that contains all given variables and values */
1423 );
1424
1425/** deletes the variable from the given clique and updates the list of cliques the binary variable is member of */
1427 SCIP_VAR* var, /**< problem variable */
1428 BMS_BLKMEM* blkmem, /**< block memory */
1429 SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
1430 SCIP_Bool value, /**< value of the variable in the clique */
1431 SCIP_CLIQUE* clique /**< clique the variable should be removed from */
1432 );
1433
1434/** adds a clique to the list of cliques of the given binary variable, but does not change the clique
1435 * itself
1436 */
1438 SCIP_VAR* var, /**< problem variable */
1439 BMS_BLKMEM* blkmem, /**< block memory */
1440 SCIP_SET* set, /**< global SCIP settings */
1441 SCIP_Bool value, /**< value of the variable in the clique */
1442 SCIP_CLIQUE* clique /**< clique that should be removed from the variable's clique list */
1443 );
1444
1445/** deletes a clique from the list of cliques the binary variable is member of, but does not change the clique
1446 * itself
1447 */
1449 SCIP_VAR* var, /**< problem variable */
1450 BMS_BLKMEM* blkmem, /**< block memory */
1451 SCIP_Bool value, /**< value of the variable in the clique */
1452 SCIP_CLIQUE* clique /**< clique that should be removed from the variable's clique list */
1453 );
1454
1455/** sets the branch factor of the variable; this value can be used in the branching methods to scale the score
1456 * values of the variables; higher factor leads to a higher probability that this variable is chosen for branching
1457 */
1459 SCIP_VAR* var, /**< problem variable */
1460 SCIP_SET* set, /**< global SCIP settings */
1461 SCIP_Real branchfactor /**< factor to weigh variable's branching score with */
1462 );
1463
1464/** sets the branch priority of the variable; variables with higher branch priority are always preferred to variables
1465 * with lower priority in selection of branching variable
1466 */
1468 SCIP_VAR* var, /**< problem variable */
1469 int branchpriority /**< branching priority of the variable */
1470 );
1471
1472/** sets the branch direction of the variable; variables with higher branch direction are always preferred to variables
1473 * with lower direction in selection of branching variable
1474 */
1476 SCIP_VAR* var, /**< problem variable */
1477 SCIP_BRANCHDIR branchdirection /**< preferred branch direction of the variable (downwards, upwards, auto) */
1478 );
1479
1480/** gets objective value of variable in current SCIP_LP; the value can be different from the bound stored in the variable's own
1481 * data due to diving, that operate only on the LP without updating the variables
1482 */
1484 SCIP_VAR* var /**< problem variable */
1485 );
1486
1487/** gets lower bound of variable in current SCIP_LP; the bound can be different from the bound stored in the variable's own
1488 * data due to diving or conflict analysis, that operate only on the LP without updating the variables
1489 */
1491 SCIP_VAR* var, /**< problem variable */
1492 SCIP_SET* set /**< global SCIP settings */
1493 );
1494
1495/** gets upper bound of variable in current SCIP_LP; the bound can be different from the bound stored in the variable's own
1496 * data due to diving or conflict analysis, that operate only on the LP without updating the variables
1497 */
1499 SCIP_VAR* var, /**< problem variable */
1500 SCIP_SET* set /**< global SCIP settings */
1501 );
1502
1503/** returns solution value and index of variable lower bound that is closest to the variable's value in the given primal solution
1504 * or current LP solution if no primal solution is given; returns an index of -1 if no variable lower bound is available
1505 */
1507 SCIP_VAR* var, /**< active problem variable */
1508 SCIP_SOL* sol, /**< primal solution, or NULL for LP solution */
1509 SCIP_SET* set, /**< global SCIP settings */
1510 SCIP_STAT* stat, /**< problem statistics */
1511 SCIP_Real* closestvlb, /**< pointer to store the value of the closest variable lower bound */
1512 int* closestvlbidx /**< pointer to store the index of the closest variable lower bound */
1513 );
1514
1515/** returns solution value and index of variable upper bound that is closest to the variable's value in the given primal solution;
1516 * or current LP solution if no primal solution is given; returns an index of -1 if no variable upper bound is available
1517 */
1519 SCIP_VAR* var, /**< active problem variable */
1520 SCIP_SOL* sol, /**< primal solution, or NULL for LP solution */
1521 SCIP_SET* set, /**< global SCIP settings */
1522 SCIP_STAT* stat, /**< problem statistics */
1523 SCIP_Real* closestvub, /**< pointer to store the value of the closest variable upper bound */
1524 int* closestvubidx /**< pointer to store the index of the closest variable upper bound */
1525 );
1526
1527/** remembers the current solution as root solution in the problem variables */
1529 SCIP_VAR* var, /**< problem variable */
1530 SCIP_Bool roothaslp /**< is the root solution from LP? */
1531 );
1532
1533/** updates the current solution as best root solution in the problem variables if it is better */
1535 SCIP_VAR* var, /**< problem variable */
1536 SCIP_SET* set, /**< global SCIP settings */
1537 SCIP_Real rootsol, /**< root solution value */
1538 SCIP_Real rootredcost, /**< root reduced cost */
1539 SCIP_Real rootlpobjval /**< objective value of the root LP */
1540 );
1541
1542/** returns the solution value of the problem variables in the relaxation solution */
1544 SCIP_VAR* var, /**< problem variable */
1545 SCIP_SET* set /**< global SCIP settings */
1546 );
1547
1548/** returns the solution value of the transformed problem variable in the relaxation solution */
1550 SCIP_VAR* var /**< problem variable */
1551 );
1552
1553/** returns for the given binary variable the reduced cost which are given by the variable itself and its implication if
1554 * the binary variable is fixed to the given value
1555 */
1557 SCIP_VAR* var, /**< problem variable */
1558 SCIP_SET* set, /**< global SCIP settings */
1559 SCIP_Bool varfixing, /**< FALSE if for x == 0, TRUE for x == 1 */
1560 SCIP_STAT* stat, /**< problem statistics */
1561 SCIP_PROB* prob, /**< transformed problem, or NULL */
1562 SCIP_LP* lp /**< current LP data */
1563 );
1564
1565
1566/** stores the solution value as relaxation solution in the problem variable */
1568 SCIP_VAR* var, /**< problem variable */
1569 SCIP_SET* set, /**< global SCIP settings */
1570 SCIP_RELAXATION* relaxation, /**< global relaxation data */
1571 SCIP_Real solval, /**< solution value in the current relaxation solution */
1572 SCIP_Bool updateobj /**< should the objective value be updated? */
1573 );
1574
1575/** stores the solution value as NLP solution in the problem variable */
1577 SCIP_VAR* var, /**< problem variable */
1578 SCIP_SET* set, /**< global SCIP settings */
1579 SCIP_Real solval /**< solution value in the current NLP solution */
1580 );
1581
1582/** resolves variable to columns and adds them with the coefficient to the row */
1584 SCIP_VAR* var, /**< problem variable */
1585 BMS_BLKMEM* blkmem, /**< block memory */
1586 SCIP_SET* set, /**< global SCIP settings */
1587 SCIP_STAT* stat, /**< problem statistics */
1588 SCIP_EVENTQUEUE* eventqueue, /**< event queue */
1589 SCIP_PROB* prob, /**< problem data */
1590 SCIP_LP* lp, /**< current LP data */
1591 SCIP_ROW* row, /**< LP row */
1592 SCIP_Real val /**< value of coefficient */
1593 );
1594
1595/** resolves variable to columns and adds them with the coefficient to the */
1597 SCIP_VAR* var, /**< problem variable */
1598 BMS_BLKMEM* blkmem, /**< block memory */
1599 SCIP_SET* set, /**< global SCIP settings */
1600 SCIP_STAT* stat, /**< problem statistics */
1601 SCIP_EVENTQUEUE* eventqueue, /**< event queue */
1602 SCIP_PROB* prob, /**< problem data */
1603 SCIP_LPEXACT* lpexact, /**< current LP data */
1604 SCIP_ROWEXACT* rowexact, /**< LP row */
1605 SCIP_RATIONAL* val /**< value of coefficient */
1606 );
1607
1608/** merge two variable histories together; a typical use case is that \p othervar is an image of the target variable
1609 * in a SCIP copy. Method should be applied with care, especially because no internal checks are performed whether
1610 * the history merge is reasonable
1611 *
1612 * @note Do not use this method if the two variables originate from two SCIP's with different objective functions, since
1613 * this corrupts the variable pseudo costs
1614 * @note Apply with care; no internal checks are performed if the two variables should be merged
1615 */
1617 SCIP_VAR* targetvar, /**< the variable that should contain both histories afterwards */
1618 SCIP_VAR* othervar, /**< the variable whose history is to be merged with that of the target variable */
1619 SCIP_STAT* stat /**< problem statistics */
1620 );
1621
1622/** sets the history of a variable; this method is typacally used within reoptimization to keep and update the variable
1623 * history over several iteraions
1624 */
1626 SCIP_VAR* var, /**< variable */
1627 SCIP_HISTORY* history, /**< the history which is to set */
1628 SCIP_STAT* stat /**< problem statistics */
1629 );
1630
1631/** updates the pseudo costs of the given variable and the global pseudo costs after a change of
1632 * "solvaldelta" in the variable's solution value and resulting change of "objdelta" in the LP's objective value
1633 */
1635 SCIP_VAR* var, /**< problem variable */
1636 SCIP_SET* set, /**< global SCIP settings */
1637 SCIP_STAT* stat, /**< problem statistics */
1638 SCIP_Real solvaldelta, /**< difference of variable's new LP value - old LP value */
1639 SCIP_Real objdelta, /**< difference of new LP's objective value - old LP's objective value */
1640 SCIP_Real weight /**< weight in (0,1] of this update in pseudo cost sum */
1641 );
1642
1643/** updates the ancestral pseudo costs of the given variable and the global ancestral pseudo costs after a change of
1644 * "solvaldelta" in the variable's solution value and resulting change of "objdelta" in the LP's objective value
1645 */
1647 SCIP_VAR* var, /**< problem variable */
1648 SCIP_SET* set, /**< global SCIP settings */
1649 SCIP_STAT* stat, /**< problem statistics */
1650 SCIP_Real solvaldelta, /**< difference of variable's new LP value - old LP value */
1651 SCIP_Real objdelta, /**< difference of new LP's objective value - old LP's objective value */
1652 SCIP_Real weight /**< weight in (0,1] of this update in pseudo cost sum */
1653 );
1654
1655/** gets the variable's pseudo cost value for the given step size "solvaldelta" in the variable's LP solution value */
1657 SCIP_VAR* var, /**< problem variable */
1658 SCIP_STAT* stat, /**< problem statistics */
1659 SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
1660 );
1661
1662/** gets the variable's ancestral pseudo cost value for the given step size "solvaldelta" in the variable's LP solution value */
1664 SCIP_VAR* var, /**< problem variable */
1665 SCIP_STAT* stat, /**< problem statistics */
1666 SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
1667 );
1668
1669/** gets the variable's pseudo cost value for the given step size "solvaldelta" in the variable's LP solution value,
1670 * only using the pseudo cost information of the current run
1671 */
1673 SCIP_VAR* var, /**< problem variable */
1674 SCIP_STAT* stat, /**< problem statistics */
1675 SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
1676 );
1677
1678/** gets the variable's (possible fractional) number of pseudo cost updates for the given direction */
1680 SCIP_VAR* var, /**< problem variable */
1681 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
1682 );
1683
1684/** gets the variable's (possible fractional) number of pseudo cost updates for the given direction,
1685 * only using the pseudo cost information of the current run
1686 */
1688 SCIP_VAR* var, /**< problem variable */
1689 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
1690 );
1691
1692/** gets the variable's (possible fractional) number of ancestor pseudo cost updates for the given direction,
1693 * only using the pseudo cost information of the current run
1694 */
1696 SCIP_VAR* var, /**< problem variable */
1697 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
1698 );
1699
1700/** compares both possible directions for rounding the given solution value and returns the minimum pseudo-costs of the variable */
1702 SCIP_VAR* var, /**< problem variable */
1703 SCIP_STAT* stat, /**< problem statistics */
1704 SCIP_SET* set, /**< global SCIP settings */
1705 SCIP_Real solval /**< solution value, e.g., LP solution value */
1706 );
1707
1708/** gets the an estimate of the variable's pseudo cost variance in direction \p dir */
1710 SCIP_VAR* var, /**< problem variable */
1711 SCIP_BRANCHDIR dir, /**< branching direction (downwards, or upwards) */
1712 SCIP_Bool onlycurrentrun /**< return pseudo cost variance only for current branch and bound run */
1713 );
1714
1715/** calculates a confidence bound for this variable under the assumption of normally distributed pseudo costs
1716 *
1717 * The confidence bound \f$ \theta \geq 0\f$ denotes the interval borders \f$ [X - \theta, \ X + \theta]\f$, which contains
1718 * the true pseudo costs of the variable, i.e., the expected value of the normal distribution, with a probability
1719 * of 95 %.
1720 *
1721 * @return value of confidence bound for this variable
1722 */
1724 SCIP_VAR* var, /**< variable in question */
1725 SCIP_SET* set, /**< global SCIP settings */
1726 SCIP_BRANCHDIR dir, /**< the branching direction for the confidence bound */
1727 SCIP_Bool onlycurrentrun, /**< should only the current run be taken into account */
1728 SCIP_CONFIDENCELEVEL clevel /**< confidence level for the interval */
1729 );
1730
1731/** check if the current pseudo cost relative error in a direction violates the given threshold. The Relative
1732 * Error is calculated at a specific confidence level
1733 */
1735 SCIP_VAR* var, /**< variable in question */
1736 SCIP_SET* set, /**< global SCIP settings */
1737 SCIP_STAT* stat, /**< problem statistics */
1738 SCIP_Real threshold, /**< threshold for relative errors to be considered reliable (enough) */
1739 SCIP_CONFIDENCELEVEL clevel /**< a given confidence level */
1740 );
1741
1742/** check if variable pseudo-costs have a significant difference in location. The significance depends on
1743 * the choice of \p clevel and on the kind of tested hypothesis. The one-sided hypothesis, which
1744 * should be rejected, is that fracy * mu_y >= fracx * mu_x, where mu_y and mu_x denote the
1745 * unknown location means of the underlying pseudo-cost distributions of x and y.
1746 *
1747 * This method is applied best if variable x has a better pseudo-cost score than y. The method hypothesizes that y were actually
1748 * better than x (despite the current information), meaning that y can be expected to yield branching
1749 * decisions as least as good as x in the long run. If the method returns TRUE, the current history information is
1750 * sufficient to safely rely on the alternative hypothesis that x yields indeed a better branching score (on average)
1751 * than y.
1752 *
1753 * @note The order of x and y matters for the one-sided hypothesis
1754 *
1755 * @note set \p onesided to FALSE if you are not sure which variable is better. The hypothesis tested then reads
1756 * fracy * mu_y == fracx * mu_x vs the alternative hypothesis fracy * mu_y != fracx * mu_x.
1757 *
1758 * @return TRUE if the hypothesis can be safely rejected at the given confidence level
1759 */
1761 SCIP_SET* set, /**< global SCIP settings */
1762 SCIP_STAT* stat, /**< problem statistics */
1763 SCIP_VAR* varx, /**< variable x */
1764 SCIP_Real fracx, /**< the fractionality of variable x */
1765 SCIP_VAR* vary, /**< variable y */
1766 SCIP_Real fracy, /**< the fractionality of variable y */
1767 SCIP_BRANCHDIR dir, /**< branching direction */
1768 SCIP_CONFIDENCELEVEL clevel, /**< confidence level for rejecting hypothesis */
1769 SCIP_Bool onesided /**< should a one-sided hypothesis y >= x be tested? */
1770 );
1771
1772/** tests at a given confidence level whether the variable pseudo-costs only have a small probability to
1773 * exceed a \p threshold. This is useful to determine if past observations provide enough evidence
1774 * to skip an expensive strong-branching step if there is already a candidate that has been proven to yield an improvement
1775 * of at least \p threshold.
1776 *
1777 * @note use \p clevel to adjust the level of confidence. For SCIP_CONFIDENCELEVEL_MIN, the method returns TRUE if
1778 * the estimated probability to exceed \p threshold is less than 25 %.
1779 *
1780 * @see SCIP_Confidencelevel for a list of available levels. The used probability limits refer to the one-sided levels
1781 * of confidence.
1782 *
1783 * @return TRUE if the variable pseudo-cost probabilistic model is likely to be smaller than \p threshold
1784 * at the given confidence level \p clevel.
1785 */
1787 SCIP_SET* set, /**< global SCIP settings */
1788 SCIP_STAT* stat, /**< problem statistics */
1789 SCIP_VAR* var, /**< variable x */
1790 SCIP_Real frac, /**< the fractionality of variable x */
1791 SCIP_Real threshold, /**< the threshold to test against */
1792 SCIP_BRANCHDIR dir, /**< branching direction */
1793 SCIP_CONFIDENCELEVEL clevel /**< confidence level for rejecting hypothesis */
1794 );
1795
1796/** increases the VSIDS of the variable by the given weight */
1798 SCIP_VAR* var, /**< problem variable */
1799 BMS_BLKMEM* blkmem, /**< block memory, or NULL if the domain value is SCIP_UNKNOWN */
1800 SCIP_SET* set, /**< global SCIP settings, or NULL if the domain value is SCIP_UNKNOWN */
1801 SCIP_STAT* stat, /**< problem statistics */
1802 SCIP_BRANCHDIR dir, /**< branching direction */
1803 SCIP_Real value, /**< domain value, or SCIP_UNKNOWN */
1804 SCIP_Real weight /**< weight of this update in conflict score */
1805 );
1806
1807/** scales the VSIDS of the variable by the given scalar */
1809 SCIP_VAR* var, /**< problem variable */
1810 SCIP_Real scalar /**< scalar to multiply the conflict scores with */
1811 );
1812
1813/** increases the number of active conflicts by one and the overall length of the variable by the given length */
1815 SCIP_VAR* var, /**< problem variable */
1816 BMS_BLKMEM* blkmem, /**< block memory, or NULL if the domain value is SCIP_UNKNOWN */
1817 SCIP_SET* set, /**< global SCIP settings, or NULL if the domain value is SCIP_UNKNOWN */
1818 SCIP_STAT* stat, /**< problem statistics */
1819 SCIP_BRANCHDIR dir, /**< branching direction */
1820 SCIP_Real value, /**< domain value, or SCIP_UNKNOWN */
1821 SCIP_Real length /**< length of the conflict */
1822 );
1823
1824/** gets the number of active conflicts containing this variable in given direction */
1826 SCIP_VAR* var, /**< problem variable */
1827 SCIP_STAT* stat, /**< problem statistics */
1828 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
1829 );
1830
1831/** gets the number of active conflicts containing this variable in given direction
1832 * in the current run
1833 */
1835 SCIP_VAR* var, /**< problem variable */
1836 SCIP_STAT* stat, /**< problem statistics */
1837 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
1838 );
1839
1840/** gets the average conflict length in given direction due to branching on the variable */
1842 SCIP_VAR* var, /**< problem variable */
1843 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
1844 );
1845
1846/** gets the average conflict length in given direction due to branching on the variable
1847 * in the current run
1848 */
1850 SCIP_VAR* var, /**< problem variable */
1851 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
1852 );
1853
1854/** increases the number of branchings counter of the variable */
1856 SCIP_VAR* var, /**< problem variable */
1857 BMS_BLKMEM* blkmem, /**< block memory, or NULL if the domain value is SCIP_UNKNOWN */
1858 SCIP_SET* set, /**< global SCIP settings, or NULL if the domain value is SCIP_UNKNOWN */
1859 SCIP_STAT* stat, /**< problem statistics */
1860 SCIP_BRANCHDIR dir, /**< branching direction (downwards, or upwards) */
1861 SCIP_Real value, /**< domain value, or SCIP_UNKNOWN */
1862 int depth /**< depth at which the bound change took place */
1863 );
1864
1865/** increases the inference score of the variable by the given weight */
1867 SCIP_VAR* var, /**< problem variable */
1868 BMS_BLKMEM* blkmem, /**< block memory, or NULL if the domain value is SCIP_UNKNOWN */
1869 SCIP_SET* set, /**< global SCIP settings, or NULL if the domain value is SCIP_UNKNOWN */
1870 SCIP_STAT* stat, /**< problem statistics */
1871 SCIP_BRANCHDIR dir, /**< branching direction (downwards, or upwards) */
1872 SCIP_Real value, /**< domain value, or SCIP_UNKNOWN */
1873 SCIP_Real weight /**< weight of this update in inference score */
1874 );
1875
1876/** increases the cutoff score of the variable by the given weight */
1878 SCIP_VAR* var, /**< problem variable */
1879 BMS_BLKMEM* blkmem, /**< block memory, or NULL if the domain value is SCIP_UNKNOWN */
1880 SCIP_SET* set, /**< global SCIP settings, or NULL if the domain value is SCIP_UNKNOWN */
1881 SCIP_STAT* stat, /**< problem statistics */
1882 SCIP_BRANCHDIR dir, /**< branching direction (downwards, or upwards) */
1883 SCIP_Real value, /**< domain value, or SCIP_UNKNOWN */
1884 SCIP_Real weight /**< weight of this update in cutoff score */
1885 );
1886
1887/** returns the variable's VSIDS score */
1889 SCIP_VAR* var, /**< problem variable */
1890 SCIP_STAT* stat, /**< problem statistics */
1891 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
1892 );
1893
1894/** returns the variable's VSIDS score only using conflicts of the current run */
1896 SCIP_VAR* var, /**< problem variable */
1897 SCIP_STAT* stat, /**< problem statistics */
1898 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
1899 );
1900
1901/** returns the average number of inferences found after branching on the variable in given direction */
1903 SCIP_VAR* var, /**< problem variable */
1904 SCIP_STAT* stat, /**< problem statistics */
1905 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
1906 );
1907
1908/** returns the average number of inferences found after branching on the variable in given direction
1909 * in the current run
1910 */
1912 SCIP_VAR* var, /**< problem variable */
1913 SCIP_STAT* stat, /**< problem statistics */
1914 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
1915 );
1916
1917/** returns the average number of cutoffs found after branching on the variable in given direction */
1919 SCIP_VAR* var, /**< problem variable */
1920 SCIP_STAT* stat, /**< problem statistics */
1921 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
1922 );
1923
1924/** returns the average number of cutoffs found after branching on the variable in given direction in the current run */
1926 SCIP_VAR* var, /**< problem variable */
1927 SCIP_STAT* stat, /**< problem statistics */
1928 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
1929 );
1930
1931/** returns the variable's average GMI efficacy score value generated from simplex tableau rows of this variable */
1933 SCIP_VAR* var, /**< problem variable */
1934 SCIP_STAT* stat /**< problem statistics */
1935 );
1936
1937/** increase the variable's GMI efficacy scores generated from simplex tableau rows of this variable */
1939 SCIP_VAR* var, /**< problem variable */
1940 SCIP_STAT* stat, /**< problem statistics */
1941 SCIP_Real gmieff /**< efficacy of last GMI cut produced when variable was frac and basic */
1942 );
1943
1944/** returns the variable's last GMI efficacy score value generated from a simplex tableau row of this variable */
1946 SCIP_VAR* var, /**< problem variable */
1947 SCIP_STAT* stat /**< problem statistics */
1948 );
1949
1950/** sets the variable's last GMI efficacy score value generated from a simplex tableau row of this variable */
1952 SCIP_VAR* var, /**< problem variable */
1953 SCIP_STAT* stat, /**< problem statistics */
1954 SCIP_Real gmieff /**< efficacy of last GMI cut produced when variable was frac and basic */
1955 );
1956
1957/** outputs variable information into file stream */
1959 SCIP_VAR* var, /**< problem variable */
1960 SCIP_SET* set, /**< global SCIP settings */
1961 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
1962 FILE* file /**< output file (or NULL for standard output) */
1963 );
1964
1965/** includes event handler with given data in variable's event filter */
1967 SCIP_VAR* var, /**< problem variable */
1968 BMS_BLKMEM* blkmem, /**< block memory */
1969 SCIP_SET* set, /**< global SCIP settings */
1970 SCIP_EVENTTYPE eventtype, /**< event type to catch */
1971 SCIP_EVENTHDLR* eventhdlr, /**< event handler to call for the event processing */
1972 SCIP_EVENTDATA* eventdata, /**< event data to pass to the event handler for the event processing */
1973 int* filterpos /**< pointer to store position of event filter entry, or NULL */
1974 );
1975
1976/** deletes event handler with given data from variable's event filter */
1978 SCIP_VAR* var, /**< problem variable */
1979 BMS_BLKMEM* blkmem, /**< block memory */
1980 SCIP_SET* set, /**< global SCIP settings */
1981 SCIP_EVENTTYPE eventtype, /**< event type mask of dropped event */
1982 SCIP_EVENTHDLR* eventhdlr, /**< event handler to call for the event processing */
1983 SCIP_EVENTDATA* eventdata, /**< event data to pass to the event handler for the event processing */
1984 int filterpos /**< position of event filter entry returned by SCIPvarCatchEvent(), or -1 */
1985 );
1986
1987/** returns the variable's VSIDS score */
1989 SCIP_VAR* var, /**< problem variable */
1990 SCIP_STAT* stat, /**< problem statistics */
1991 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
1992 );
1993
1994/** returns the position of the bound change index */
1996 SCIP_BDCHGIDX* bdchgidx /**< bound change index */
1997 );
1998
1999/** returns the depth of the bound change index */
2001 SCIP_BDCHGIDX* bdchgidx /**< bound change index */
2002 );
2003
2004/** removes (redundant) cliques, implications and variable bounds of variable from all other variables' implications and variable
2005 * bounds arrays, and optionally removes them also from the variable itself
2006 */
2008 SCIP_VAR* var, /**< problem variable */
2009 BMS_BLKMEM* blkmem, /**< block memory */
2010 SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
2011 SCIP_SET* set, /**< global SCIP settings */
2012 SCIP_Bool irrelevantvar, /**< has the variable become irrelevant? */
2013 SCIP_Bool onlyredundant, /**< should only the redundant implications and variable bounds be removed? */
2014 SCIP_Bool removefromvar /**< should the implications and variable bounds be removed from the var itself? */
2015 );
2016
2017/** Get the tightest local lower bound (from the exact and the real bound) */
2019 SCIP_VAR* var, /**< problem variable */
2020 SCIP_RATIONAL* output /**< output rational */
2021 );
2022/** Get the tightest local uppper bound (from the exact and the real bound) */
2024 SCIP_VAR* var, /**< problem variable */
2025 SCIP_RATIONAL* output /**< output rational */
2026 );
2027
2028/** sets index of variable in certificate */
2030 SCIP_VAR* var, /**< variable to set index for */
2031 SCIP_Longint certidx /**< the index */
2032 );
2033
2034/** sets index of variable in certificate */
2036 SCIP_VAR* var, /**< variable to set index for */
2037 SCIP_Longint certidx /**< the index */
2038 );
2039
2040#ifdef NDEBUG
2041
2042/* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
2043 * speed up the algorithms.
2044 */
2045
2046#define SCIPvarCatchEvent(var, blkmem, set, eventtype, eventhdlr, eventdata, filterpos) \
2047 SCIPeventfilterAdd(var->eventfilter, blkmem, set, eventtype, eventhdlr, eventdata, filterpos)
2048#define SCIPvarDropEvent(var, blkmem, set, eventtype, eventhdlr, eventdata, filterpos) \
2049 SCIPeventfilterDel(var->eventfilter, blkmem, set, eventtype, eventhdlr, eventdata, filterpos)
2050#define SCIPvarGetVSIDS(var, stat, dir) ((var)->varstatus == SCIP_VARSTATUS_LOOSE || (var)->varstatus == SCIP_VARSTATUS_COLUMN ? \
2051 SCIPhistoryGetVSIDS(var->history, dir)/stat->vsidsweight : SCIPvarGetVSIDS_rec(var, stat, dir))
2052#define SCIPbdchgidxGetPos(bdchgidx) ((bdchgidx)->pos)
2053#define SCIPbdchgidxGetDepth(bdchgidx) ((bdchgidx)->depth)
2054#endif
2055
2056/*
2057 * Hash functions
2058 */
2059
2060/** gets the key (i.e. the name) of the given variable */
2061SCIP_DECL_HASHGETKEY(SCIPhashGetKeyVar);
2062
2063#ifdef __cplusplus
2064}
2065#endif
2066
2067#endif
static long bound
common defines and data types used in all packages of SCIP
#define SCIP_Longint
Definition: def.h:141
#define SCIP_Bool
Definition: def.h:91
#define SCIP_Real
Definition: def.h:156
internal methods for managing events
interval arithmetics for provable bounds
static const SCIP_Real scalars[]
Definition: lp.c:5959
memory allocation routines
struct BMS_BlkMem BMS_BLKMEM
Definition: memory.h:437
public methods for branching and inference history structure
datastructures for problem variables
Definition: heur_padm.c:135
type definitions for branching rules
type definitions for certificate output
type definitions for constraints and constraint handlers
type definitions for managing events
struct SCIP_EventData SCIP_EVENTDATA
Definition: type_event.h:179
uint64_t SCIP_EVENTTYPE
Definition: type_event.h:156
type definitions for branching and inference history
enum SCIP_BranchDir SCIP_BRANCHDIR
Definition: type_history.h:48
type definitions for implications, variable bounds, and cliques
type definitions for LP management
enum SCIP_BoundType SCIP_BOUNDTYPE
Definition: type_lp.h:60
type definitions for exact LP management
type definitions for message output methods
type definitions for miscellaneous datastructures
enum SCIP_Confidencelevel SCIP_CONFIDENCELEVEL
Definition: type_misc.h:53
type definitions for collecting primal CIP solutions and primal informations
type definitions for storing and manipulating the main problem
enum SCIP_Objsense SCIP_OBJSENSE
Definition: type_prob.h:50
type definitions for propagators
type definitions for relaxators
type definitions for collecting reoptimization information
result codes for SCIP callback methods
type definitions for return codes for SCIP methods
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:63
type definitions for SCIP's main datastructure
type definitions for global SCIP settings
type definitions for storing primal CIP solutions
type definitions for problem statistics
type definitions for branch and bound tree
type definitions for problem variables
struct SCIP_VarData SCIP_VARDATA
Definition: type_var.h:167
enum SCIP_BoundchgType SCIP_BOUNDCHGTYPE
Definition: type_var.h:135
enum SCIP_ImplintType SCIP_IMPLINTTYPE
Definition: type_var.h:117
#define SCIP_DECL_VARDELORIG(x)
Definition: type_var.h:180
#define SCIP_DECL_VARTRANS(x)
Definition: type_var.h:200
#define SCIP_DECL_VARCOPY(x)
Definition: type_var.h:243
#define SCIP_DECL_VARDELTRANS(x)
Definition: type_var.h:213
enum SCIP_LockType SCIP_LOCKTYPE
Definition: type_var.h:144
enum SCIP_Vartype SCIP_VARTYPE
Definition: type_var.h:73
SCIP_Real SCIPvarGetObjLP(SCIP_VAR *var)
Definition: var.c:18522
SCIP_Real SCIPvarGetPseudocost(SCIP_VAR *var, SCIP_STAT *stat, SCIP_Real solvaldelta)
Definition: var.c:20437
SCIP_RETCODE SCIPvarsGetActiveVars(SCIP_SET *set, SCIP_VAR **vars, int *nvars, int varssize, int *requiredsize)
Definition: var.c:17338
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_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, int naggvars, SCIP_VAR **aggvars, SCIP_Real *scalars, SCIP_Real constant, SCIP_Bool *infeasible, SCIP_Bool *aggregated)
Definition: var.c:8055
SCIP_RETCODE SCIPvarTryAggregateVarsExact(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_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_VAR *varx, SCIP_VAR *vary, SCIP_RATIONAL *scalarx, SCIP_RATIONAL *scalary, SCIP_RATIONAL *rhs, SCIP_Bool *infeasible, SCIP_Bool *aggregated)
Definition: var.c:7863
SCIP_DECL_HASHGETKEY(SCIPhashGetKeyVar)
Definition: var.c:23009
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:21499
SCIP_RETCODE SCIPdomchgAddBoundchg(SCIP_DOMCHG **domchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_VAR *var, SCIP_Real newbound, SCIP_RATIONAL *newboundexact, 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:1734
SCIP_RETCODE SCIPvarChgLbLazy(SCIP_VAR *var, SCIP_SET *set, SCIP_Real lazylb)
Definition: var.c:11771
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_EVENTFILTER *eventfilter, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool value, SCIP_Bool *infeasible, int *nbdchgs)
Definition: var.c:16512
SCIP_Real SCIPvarGetPseudocostCount(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: var.c:20580
SCIP_RETCODE SCIPvarResetBounds(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
Definition: var.c:14534
void SCIPbdchginfoFree(SCIP_BDCHGINFO **bdchginfo, BMS_BLKMEM *blkmem)
Definition: var.c:22615
SCIP_RETCODE SCIPvarGetTransformed(SCIP_VAR *origvar, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR **transvar)
Definition: var.c:4581
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:9419
void SCIPvarGetUbLocalExactMinimal(SCIP_VAR *var, SCIP_RATIONAL *output)
Definition: var.c:24289
SCIP_Real SCIPvarGetPseudocostVariance(SCIP_VAR *var, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun)
Definition: var.c:20744
SCIP_Real SCIPvarGetImplRedcost(SCIP_VAR *var, SCIP_SET *set, SCIP_Bool varfixing, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_LP *lp)
Definition: var.c:19233
SCIP_RETCODE SCIPvarSetLastGMIScore(SCIP_VAR *var, SCIP_STAT *stat, SCIP_Real gmieff)
Definition: var.c:22535
void SCIPvarInitSolve(SCIP_VAR *var)
Definition: var.c:3846
SCIP_RETCODE SCIPvarChgUbGlobalExact(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LPEXACT *lpexact, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_RATIONAL *newbound)
Definition: var.c:11618
SCIP_Real SCIPvarGetAncPseudocostCountCurrentRun(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: var.c:20670
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:21583
SCIP_RETCODE SCIPvarChgLbGlobalExact(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LPEXACT *lpexact, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_RATIONAL *newbound)
Definition: var.c:11321
SCIP_RETCODE SCIPvarChgBdGlobalExact(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LPEXACT *lpexact, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_RATIONAL *newbound, SCIP_BOUNDTYPE boundtype)
Definition: var.c:11848
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_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_VAR *varx, SCIP_VAR *vary, SCIP_Real scalarx, SCIP_Real scalary, SCIP_Real rhs, SCIP_Bool *infeasible, SCIP_Bool *aggregated)
Definition: var.c:7688
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:21103
SCIP_RETCODE SCIPvarChgUbLocalExact(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LPEXACT *lpexact, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_RATIONAL *newbound)
Definition: var.c:13112
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:1640
SCIP_Real SCIPvarGetAvgCutoffs(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
Definition: var.c:22317
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:845
SCIP_RETCODE SCIPvarGetProbvarSumExact(SCIP_VAR **var, SCIP_RATIONAL *scalar, SCIP_RATIONAL *constant)
Definition: var.c:18205
SCIP_RETCODE SCIPdomchgMakeStatic(SCIP_DOMCHG **domchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
Definition: var.c:1451
SCIP_RETCODE SCIPvarGetMultaggrUbLocalExact(SCIP_VAR *var, SCIP_SET *set, SCIP_RATIONAL *result)
Definition: var.c:13786
SCIP_RETCODE SCIPvarUpdatePseudocost(SCIP_VAR *var, SCIP_SET *set, SCIP_STAT *stat, SCIP_Real solvaldelta, SCIP_Real objdelta, SCIP_Real weight)
Definition: var.c:20274
void SCIPvarSetLbCertificateIndexLocal(SCIP_VAR *var, SCIP_Longint certidx)
Definition: var.c:25149
SCIP_RETCODE SCIPvarTransform(SCIP_VAR *origvar, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_OBJSENSE objsense, SCIP_VAR **transvar)
Definition: var.c:4494
SCIP_RETCODE SCIPvarAddHoleOriginal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_Real left, SCIP_Real right)
Definition: var.c:13997
SCIP_RETCODE SCIPvarAddCliqueToList(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_Bool value, SCIP_CLIQUE *clique)
Definition: var.c:16725
int SCIPbdchgidxGetDepth(SCIP_BDCHGIDX *bdchgidx)
Definition: var.c:24859
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:14178
SCIP_Real SCIPvarGetAvgInferencesCurrentRun(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
Definition: var.c:22176
SCIP_RETCODE SCIPvarRelease(SCIP_VAR **var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
Definition: var.c:3787
void SCIPvarGetClosestVub(SCIP_VAR *var, SCIP_SOL *sol, SCIP_SET *set, SCIP_STAT *stat, SCIP_Real *closestvub, int *closestvubidx)
Definition: var.c:19963
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:21239
SCIP_RETCODE SCIPvarRemove(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_CLIQUETABLE *cliquetable, SCIP_SET *set, SCIP_Bool final, SCIP_Bool keepimplics)
Definition: var.c:9122
void SCIPvarAdjustLb(SCIP_VAR *var, SCIP_SET *set, SCIP_Real *lb)
Definition: var.c:9910
void SCIPvarAdjustLbExact(SCIP_VAR *var, SCIP_SET *set, SCIP_RATIONAL *lb)
Definition: var.c:9927
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:24824
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:11178
SCIP_RETCODE SCIPvarSetNLPSol(SCIP_VAR *var, SCIP_SET *set, SCIP_Real solval)
Definition: var.c:19771
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:2751
SCIP_Real SCIPvarCalcPscostConfidenceBound(SCIP_VAR *var, SCIP_SET *set, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun, SCIP_CONFIDENCELEVEL clevel)
Definition: var.c:20798
SCIP_Bool SCIPvarIsPscostRelerrorReliable(SCIP_VAR *var, SCIP_SET *set, SCIP_STAT *stat, SCIP_Real threshold, SCIP_CONFIDENCELEVEL clevel)
Definition: var.c:20836
SCIP_RETCODE SCIPvarChgLbOriginal(SCIP_VAR *var, SCIP_SET *set, SCIP_Real newbound)
Definition: var.c:10028
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:20035
SCIP_Real SCIPvarGetLbLP(SCIP_VAR *var, SCIP_SET *set)
Definition: var.c:18568
void SCIPvarAdjustBd(SCIP_VAR *var, SCIP_SET *set, SCIP_BOUNDTYPE boundtype, SCIP_Real *bd)
Definition: var.c:10012
SCIP_RETCODE SCIPvarChgObjDive(SCIP_VAR *var, SCIP_SET *set, SCIP_LP *lp, SCIP_Real newobj)
Definition: var.c:9847
SCIP_RETCODE SCIPdomchgFree(SCIP_DOMCHG **domchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
Definition: var.c:1348
SCIP_RETCODE SCIPvarColumnExact(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LPEXACT *lp)
Definition: var.c:4646
SCIP_Real SCIPvarGetRelaxSolTransVar(SCIP_VAR *var)
Definition: var.c:19760
SCIP_RETCODE SCIPvarPrint(SCIP_VAR *var, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, FILE *file)
Definition: var.c:3953
SCIP_Real SCIPvarGetAvgGMIScore(SCIP_VAR *var, SCIP_STAT *stat)
Definition: var.c:22411
SCIP_Real SCIPvarGetVSIDS(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
Definition: var.c:24782
SCIP_RETCODE SCIPvarAddObjExact(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_RATIONAL *addobj)
Definition: var.c:9704
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:21667
SCIP_Real SCIPvarGetMultaggrLbLocal(SCIP_VAR *var, SCIP_SET *set)
Definition: var.c:13574
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:20913
void SCIPvarCapture(SCIP_VAR *var)
Definition: var.c:3762
SCIP_RETCODE SCIPvarChgBranchDirection(SCIP_VAR *var, SCIP_BRANCHDIR branchdirection)
Definition: var.c:17150
SCIP_Real SCIPvarGetPseudocostCurrentRun(SCIP_VAR *var, SCIP_STAT *stat, SCIP_Real solvaldelta)
Definition: var.c:20533
SCIP_RETCODE SCIPdomchgAddHolechg(SCIP_DOMCHG **domchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_HOLELIST **ptr, SCIP_HOLELIST *newlist, SCIP_HOLELIST *oldlist)
Definition: var.c:1839
void SCIPvarStoreRootSol(SCIP_VAR *var, SCIP_Bool roothaslp)
Definition: var.c:19034
void SCIPvarGetLbLocalExactMaximal(SCIP_VAR *var, SCIP_RATIONAL *output)
Definition: var.c:24255
SCIP_Bool SCIPvarDoNotAggr(SCIP_VAR *var)
Definition: var.c:8843
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:9242
SCIP_RETCODE SCIPvarFlattenAggregationGraph(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue)
Definition: var.c:5989
void SCIPvarAdjustUbExact(SCIP_VAR *var, SCIP_SET *set, SCIP_RATIONAL *ub)
Definition: var.c:9978
SCIP_Longint SCIPvarGetNActiveConflicts(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
Definition: var.c:21320
SCIP_RETCODE SCIPvarChgLbExactDive(SCIP_VAR *var, SCIP_SET *set, SCIP_LPEXACT *lpexact, SCIP_RATIONAL *newbound)
Definition: var.c:13365
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_IMPLINTTYPE impltype, 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:2487
void SCIPvarUpdateBestRootSol(SCIP_VAR *var, SCIP_SET *set, SCIP_Real rootsol, SCIP_Real rootredcost, SCIP_Real rootlpobjval)
Definition: var.c:19045
SCIP_RETCODE SCIPvarFixExact(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_CLIQUETABLE *cliquetable, SCIP_RATIONAL *fixedval, SCIP_Bool *infeasible, SCIP_Bool *fixed)
Definition: var.c:4987
SCIP_Real SCIPvarGetVSIDS_rec(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
Definition: var.c:21929
SCIP_RETCODE SCIPvarChgImplType(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_PRIMAL *primal, SCIP_LP *lp, SCIP_EVENTQUEUE *eventqueue, SCIP_IMPLINTTYPE impltype)
Definition: var.c:9301
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:13249
SCIP_RETCODE SCIPvarScaleVSIDS(SCIP_VAR *var, SCIP_Real scalar)
Definition: var.c:21189
SCIP_Real SCIPvarGetAvgConflictlength(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: var.c:21412
SCIP_Real SCIPvarGetPseudocostCountCurrentRun(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: var.c:20625
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:11475
SCIP_RETCODE SCIPvarMultiaggregateExact(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_LPEXACT *lpexact, SCIP_CLIQUETABLE *cliquetable, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, int naggvars, SCIP_VAR **aggvars, SCIP_RATIONAL **scalars, SCIP_RATIONAL *constant, SCIP_Bool *infeasible, SCIP_Bool *aggregated)
Definition: var.c:8415
SCIP_RETCODE SCIPvarChgUbOriginalExact(SCIP_VAR *var, SCIP_SET *set, SCIP_RATIONAL *newbound)
Definition: var.c:10220
SCIP_RETCODE SCIPvarAggregate(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_CLIQUETABLE *cliquetable, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_VAR *aggvar, SCIP_Real scalar, SCIP_Real constant, SCIP_Bool *infeasible, SCIP_Bool *aggregated)
Definition: var.c:6599
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_IMPLINTTYPE impltype, 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:2531
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:3357
SCIP_Real SCIPvarGetUbLP(SCIP_VAR *var, SCIP_SET *set)
Definition: var.c:18638
SCIP_RETCODE SCIPvarColumn(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_LP *lp)
Definition: var.c:4612
SCIP_Real SCIPvarGetAncPseudocost(SCIP_VAR *var, SCIP_STAT *stat, SCIP_Real solvaldelta)
Definition: var.c:20484
SCIP_RETCODE SCIPvarChgUbOriginal(SCIP_VAR *var, SCIP_SET *set, SCIP_Real newbound)
Definition: var.c:10161
SCIP_RETCODE SCIPvarChgUbDive(SCIP_VAR *var, SCIP_SET *set, SCIP_LP *lp, SCIP_Real newbound)
Definition: var.c:13422
SCIP_Real SCIPvarGetAvgInferences(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
Definition: var.c:22119
SCIP_RETCODE SCIPvarAddObj(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_Real addobj)
Definition: var.c:9589
int SCIPvarGetConflictingBdchgDepth(SCIP_VAR *var, SCIP_SET *set, SCIP_BOUNDTYPE boundtype, SCIP_Real bound)
Definition: var.c:22816
SCIP_RETCODE SCIPvarChgUbExactDive(SCIP_VAR *var, SCIP_SET *set, SCIP_LPEXACT *lpexact, SCIP_RATIONAL *newbound)
Definition: var.c:13512
SCIP_Real SCIPvarGetMultaggrUbGlobal(SCIP_VAR *var, SCIP_SET *set)
Definition: var.c:13936
void SCIPvarGetClosestVlb(SCIP_VAR *var, SCIP_SOL *sol, SCIP_SET *set, SCIP_STAT *stat, SCIP_Real *closestvlb, int *closestvlbidx)
Definition: var.c:19888
SCIP_RETCODE SCIPvarChgUbLazy(SCIP_VAR *var, SCIP_SET *set, SCIP_Real lazyub)
Definition: var.c:11794
SCIP_RETCODE SCIPvarChgLbOriginalExact(SCIP_VAR *var, SCIP_SET *set, SCIP_RATIONAL *newbound)
Definition: var.c:10087
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:20979
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:1675
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:1059
void SCIPvarMarkDeleted(SCIP_VAR *var)
Definition: var.c:9159
void SCIPvarMergeHistories(SCIP_VAR *targetvar, SCIP_VAR *othervar, SCIP_STAT *stat)
Definition: var.c:6116
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_EVENTFILTER *eventfilter, SCIP_VAR *vlbvar, SCIP_Real vlbcoef, SCIP_Real vlbconstant, SCIP_Bool transitive, SCIP_Bool *infeasible, int *nbdchgs)
Definition: var.c:15316
void SCIPdomchgAddCurrentCertificateIndex(SCIP_DOMCHG *domchg, SCIP_CERTIFICATE *certificate)
Definition: var.c:1714
SCIP_RETCODE SCIPvarUpdateAncPseudocost(SCIP_VAR *var, SCIP_SET *set, SCIP_STAT *stat, SCIP_Real solvaldelta, SCIP_Real objdelta, SCIP_Real weight)
Definition: var.c:20374
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:24797
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:14425
SCIP_Bool SCIPvarIsMarkedDeleteGlobalStructures(SCIP_VAR *var)
Definition: var.c:23580
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:1591
SCIP_RETCODE SCIPvarDelClique(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool value, SCIP_CLIQUE *clique)
Definition: var.c:16764
SCIP_Real SCIPvarGetRelaxSol(SCIP_VAR *var, SCIP_SET *set)
Definition: var.c:19688
SCIP_RETCODE SCIPvarDelCliqueFromList(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_Bool value, SCIP_CLIQUE *clique)
Definition: var.c:16747
int SCIPbdchgidxGetPos(SCIP_BDCHGIDX *bdchgidx)
Definition: var.c:24849
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:11819
SCIP_RETCODE SCIPvarsAddClique(SCIP_VAR **vars, SCIP_Bool *values, int nvars, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_CLIQUE *clique)
Definition: var.c:16687
SCIP_RETCODE SCIPvarMarkDoNotAggr(SCIP_VAR *var)
Definition: var.c:9170
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:12715
SCIP_RETCODE SCIPvarLoose(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_PROB *prob, SCIP_LP *lp)
Definition: var.c:4680
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_EVENTFILTER *eventfilter, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool value, SCIP_CLIQUE *clique, SCIP_Bool *infeasible, int *nbdchgs)
Definition: var.c:16601
SCIP_RETCODE SCIPvarChgBranchPriority(SCIP_VAR *var, int branchpriority)
Definition: var.c:17019
SCIP_RETCODE SCIPvarChgLbLocalExact(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LPEXACT *lpexact, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_RATIONAL *newbound)
Definition: var.c:12845
SCIP_RETCODE SCIPvarMarkDoNotMultaggr(SCIP_VAR *var)
Definition: var.c:9206
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:4200
SCIP_RETCODE SCIPvarNegate(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR **negvar)
Definition: var.c:8979
SCIP_Real SCIPvarGetMultaggrUbLocal(SCIP_VAR *var, SCIP_SET *set)
Definition: var.c:13722
SCIP_RETCODE SCIPbdchginfoCreate(SCIP_BDCHGINFO **bdchginfo, BMS_BLKMEM *blkmem, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_Real oldbound, SCIP_Real newbound)
Definition: var.c:22585
SCIP_Real SCIPvarGetMinPseudocostScore(SCIP_VAR *var, SCIP_STAT *stat, SCIP_SET *set, SCIP_Real solval)
Definition: var.c:20713
SCIP_RETCODE SCIPvarGetProbvarSum(SCIP_VAR **var, SCIP_SET *set, SCIP_Real *scalar, SCIP_Real *constant)
Definition: var.c:18075
SCIP_Bool SCIPvarIsAggrCoefAcceptable(SCIP_SET *set, SCIP_VAR *var, SCIP_Real scalar)
Definition: var.c:8909
SCIP_RETCODE SCIPvarAddExactData(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_RATIONAL *lb, SCIP_RATIONAL *ub, SCIP_RATIONAL *obj)
Definition: var.c:2578
SCIP_RETCODE SCIPvarIncGMIeffSum(SCIP_VAR *var, SCIP_STAT *stat, SCIP_Real gmieff)
Definition: var.c:22451
SCIP_Real SCIPvarGetLastGMIScore(SCIP_VAR *var, SCIP_STAT *stat)
Definition: var.c:22495
void SCIPvarAdjustUb(SCIP_VAR *var, SCIP_SET *set, SCIP_Real *ub)
Definition: var.c:9961
SCIP_Real SCIPbdchginfoGetRelaxedBound(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:25048
SCIP_RETCODE SCIPvarGetActiveRepresentatives(SCIP_SET *set, SCIP_VAR **vars, SCIP_Real *scalars, int *nvars, int varssize, SCIP_Real *constant, int *requiredsize)
Definition: var.c:5180
SCIP_RETCODE SCIPvarChgLbDive(SCIP_VAR *var, SCIP_SET *set, SCIP_LP *lp, SCIP_Real newbound)
Definition: var.c:13275
SCIP_RETCODE SCIPvarFix(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_CLIQUETABLE *cliquetable, SCIP_Real fixedval, SCIP_Bool *infeasible, SCIP_Bool *fixed)
Definition: var.c:4820
SCIP_Real SCIPvarGetAvgConflictlengthCurrentRun(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: var.c:21456
SCIP_RETCODE SCIPvarCopyExactData(BMS_BLKMEM *blkmem, SCIP_VAR *targetvar, SCIP_VAR *sourcevar, SCIP_Bool negateobj)
Definition: var.c:2686
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:12983
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:3234
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_EVENTFILTER *eventfilter, SCIP_VAR *vubvar, SCIP_Real vubcoef, SCIP_Real vubconstant, SCIP_Bool transitive, SCIP_Bool *infeasible, int *nbdchgs)
Definition: var.c:15783
SCIP_Real SCIPvarGetVSIDSCurrentRun(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
Definition: var.c:21980
void SCIPvarSetNamePointer(SCIP_VAR *var, const char *name)
Definition: var.c:9102
SCIP_RETCODE SCIPvarAggregateExact(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_CLIQUETABLE *cliquetable, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_VAR *aggvar, SCIP_RATIONAL *scalar, SCIP_RATIONAL *constant, SCIP_Bool *infeasible, SCIP_Bool *aggregated)
Definition: var.c:6909
SCIP_RETCODE SCIPvarChgName(SCIP_VAR *var, BMS_BLKMEM *blkmem, const char *name)
Definition: var.c:3828
void SCIPvarSetHistory(SCIP_VAR *var, SCIP_HISTORY *history, SCIP_STAT *stat)
Definition: var.c:6132
void SCIPvarSetUbCertificateIndexLocal(SCIP_VAR *var, SCIP_Longint certidx)
Definition: var.c:25136
void SCIPvarAdjustUbExactFloat(SCIP_VAR *var, SCIP_SET *set, SCIP_Real *ub)
Definition: var.c:9995
void SCIPvarSetProbindex(SCIP_VAR *var, int probindex)
Definition: var.c:9087
SCIP_Real SCIPvarGetMultaggrLbGlobal(SCIP_VAR *var, SCIP_SET *set)
Definition: var.c:13870
SCIP_RETCODE SCIPvarSetRelaxSol(SCIP_VAR *var, SCIP_SET *set, SCIP_RELAXATION *relaxation, SCIP_Real solval, SCIP_Bool updateobj)
Definition: var.c:19627
void SCIPvarAdjustLbExactFloat(SCIP_VAR *var, SCIP_SET *set, SCIP_Real *lb)
Definition: var.c:9944
SCIP_RETCODE SCIPvarChgBranchFactor(SCIP_VAR *var, SCIP_SET *set, SCIP_Real branchfactor)
Definition: var.c:16892
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_EVENTFILTER *eventfilter, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_BOUNDTYPE impltype, SCIP_Real implbound, SCIP_Bool transitive, SCIP_Bool *infeasible, int *nbdchgs)
Definition: var.c:16241
SCIP_Longint SCIPvarGetNActiveConflictsCurrentRun(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
Definition: var.c:21367
SCIP_RETCODE SCIPvarChgObjExact(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_PROB *prob, SCIP_PRIMAL *primal, SCIP_LPEXACT *lp, SCIP_EVENTQUEUE *eventqueue, SCIP_RATIONAL *newobj)
Definition: var.c:9494
SCIP_Real SCIPvarGetAvgCutoffsCurrentRun(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
Definition: var.c:22364
SCIP_Bool SCIPvarDoNotMultaggr(SCIP_VAR *var)
Definition: var.c:8876
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:2006
SCIP_RETCODE SCIPvarGetMultaggrLbLocalExact(SCIP_VAR *var, SCIP_SET *set, SCIP_RATIONAL *result)
Definition: var.c:13638
SCIP_RETCODE SCIPvarGetActiveRepresentativesExact(SCIP_SET *set, SCIP_VAR **vars, SCIP_RATIONAL **scalars, int *nvars, int varssize, SCIP_RATIONAL *constant, int *requiredsize, SCIP_Bool mergemultiples)
Definition: var.c:5511
SCIP_RETCODE SCIPvarAddToRowExact(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_PROB *prob, SCIP_LPEXACT *lpexact, SCIP_ROWEXACT *rowexact, SCIP_RATIONAL *val)
Definition: var.c:20135