SCIP Doxygen Documentation
Loading...
Searching...
No Matches
var.h
Go to the documentation of this file.
1/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2/* */
3/* This file is part of the program and library */
4/* SCIP --- Solving Constraint Integer Programs */
5/* */
6/* Copyright (c) 2002-2026 Zuse Institute Berlin (ZIB) */
7/* */
8/* Licensed under the Apache License, Version 2.0 (the "License"); */
9/* you may not use this file except in compliance with the License. */
10/* You may obtain a copy of the License at */
11/* */
12/* http://www.apache.org/licenses/LICENSE-2.0 */
13/* */
14/* Unless required by applicable law or agreed to in writing, software */
15/* distributed under the License is distributed on an "AS IS" BASIS, */
16/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */
17/* See the License for the specific language governing permissions and */
18/* limitations under the License. */
19/* */
20/* You should have received a copy of the Apache-2.0 license */
21/* along with SCIP; see the file LICENSE. If not visit scipopt.org. */
22/* */
23/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
24
25/**@file var.h
26 * @ingroup INTERNALAPI
27 * @brief internal methods for problem variables
28 * @author Tobias Achterberg
29 */
30
31/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
32
33#ifndef __SCIP_VAR_H__
34#define __SCIP_VAR_H__
35
36
37#include "blockmemshell/memory.h"
38#include "scip/def.h"
39#include "scip/type_branch.h"
40#include "scip/type_certificate.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 */
80SCIP_RETCODE SCIPboundchgApply(
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 */
94SCIP_RETCODE SCIPboundchgUndo(
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 */
105SCIP_RETCODE SCIPdomchgApplyGlobal(
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 */
118SCIP_RETCODE SCIPdomchgFree(
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 */
127SCIP_RETCODE SCIPdomchgMakeStatic(
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 */
136SCIP_RETCODE SCIPdomchgApply(
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 */
149SCIP_RETCODE SCIPdomchgUndo(
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 */
160void SCIPdomchgAddCurrentCertificateIndex(
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 */
166SCIP_RETCODE SCIPdomchgAddBoundchg(
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 */
184SCIP_RETCODE SCIPdomchgAddHolechg(
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 */
194SCIP_RETCODE SCIPbdchginfoCreate(
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 */
204void SCIPbdchginfoFree(
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 */
210SCIP_Real SCIPbdchginfoGetRelaxedBound(
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 */
221SCIP_RETCODE SCIPvarCreateOriginal(
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 */
244SCIP_RETCODE SCIPvarCreateTransformed(
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 */
270SCIP_RETCODE SCIPvarAddExactData(
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 */
282SCIP_RETCODE SCIPvarCopyExactData(
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 */
293SCIP_RETCODE SCIPvarCopy(
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 */
311SCIP_RETCODE SCIPvarParseOriginal(
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 */
334SCIP_RETCODE SCIPvarParseTransformed(
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 */
358SCIP_RETCODE SCIPvarRelease(
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 */
368SCIP_RETCODE SCIPvarChgName(
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 */
375void SCIPvarInitSolve(
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 */
382SCIP_RETCODE SCIPvarTransform(
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 */
392SCIP_RETCODE SCIPvarGetTransformed(
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 */
401SCIP_RETCODE SCIPvarColumn(
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 */
411SCIP_RETCODE SCIPvarColumnExact(
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 */
420SCIP_RETCODE SCIPvarLoose(
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 */
430SCIP_RETCODE SCIPvarFix(
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 */
451SCIP_RETCODE SCIPvarFixExact(
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 */
481SCIP_RETCODE SCIPvarGetActiveRepresentatives(
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 */
500SCIP_RETCODE SCIPvarGetActiveRepresentativesExact(
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 */
517SCIP_RETCODE SCIPvarGetProbvarSum(
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 */
530SCIP_RETCODE SCIPvarGetProbvarSumExact(
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 */
537SCIP_RETCODE SCIPvarFlattenAggregationGraph(
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 */
545SCIP_RETCODE SCIPvarsGetActiveVars(
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 */
565SCIP_RETCODE SCIPvarTryAggregateVars(
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 */
601SCIP_RETCODE SCIPvarTryAggregateVarsExact(
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 */
625SCIP_RETCODE SCIPvarAggregate(
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 */
648SCIP_RETCODE SCIPvarAggregateExact(
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 */
671SCIP_RETCODE SCIPvarMultiaggregate(
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 */
695SCIP_RETCODE SCIPvarMultiaggregateExact(
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 */
719SCIP_Bool SCIPvarDoNotAggr(
720 SCIP_VAR* var /**< problem variable */
721 );
722
723/** returns whether variable is not allowed to be multi-aggregated */
724SCIP_Bool SCIPvarDoNotMultaggr(
725 SCIP_VAR* var /**< problem variable */
726 );
727
728/** checks whether a loose variable can be used in a new aggregation with given coefficient */
729SCIP_Bool SCIPvarIsAggrCoefAcceptable(
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.) */
736SCIP_Bool SCIPvarIsMarkedDeleteGlobalStructures(
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 */
744SCIP_RETCODE SCIPvarNegate(
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 */
753void SCIPvarSetProbindex(
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 */
762void SCIPvarSetNamePointer(
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 */
776SCIP_RETCODE SCIPvarRemove(
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 */
786void SCIPvarMarkDeleted(
787 SCIP_VAR* var /**< problem variable */
788 );
789
790/** marks the variable to not to be maggregated */
791SCIP_RETCODE SCIPvarMarkDoNotAggr(
792 SCIP_VAR* var /**< problem variable */
793 );
794
795/** marks the variable to not to be multi-aggregated */
796SCIP_RETCODE SCIPvarMarkDoNotMultaggr(
797 SCIP_VAR* var /**< problem variable */
798 );
799
800/** modifies lock numbers for rounding */
801SCIP_RETCODE SCIPvarAddLocks(
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 */
812SCIP_RETCODE SCIPvarChgType(
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 */
823SCIP_RETCODE SCIPvarChgImplType(
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 */
834SCIP_RETCODE SCIPvarChgObj(
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 */
846SCIP_RETCODE SCIPvarChgObjExact(
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 */
858SCIP_RETCODE SCIPvarChgUbGlobalExact(
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 */
871SCIP_RETCODE SCIPvarChgLbGlobalExact(
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 */
884SCIP_RETCODE SCIPvarAddObj(
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 */
901SCIP_RETCODE SCIPvarAddObjExact(
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 */
918SCIP_RETCODE SCIPvarChgObjDive(
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 */
933void SCIPvarAdjustLbExact(
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 */
940void SCIPvarAdjustLbExactFloat(
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 */
954void SCIPvarAdjustUbExact(
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 */
961void SCIPvarAdjustUbExactFloat(
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 */
976SCIP_RETCODE SCIPvarChgLbOriginal(
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 */
983SCIP_RETCODE SCIPvarChgLbOriginalExact(
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 */
990SCIP_RETCODE SCIPvarChgUbOriginal(
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 */
997SCIP_RETCODE SCIPvarChgUbOriginalExact(
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 */
1006SCIP_RETCODE SCIPvarChgLbGlobal(
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 */
1021SCIP_RETCODE SCIPvarChgUbGlobal(
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 */
1036SCIP_RETCODE SCIPvarChgBdGlobal(
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 */
1052SCIP_RETCODE SCIPvarChgBdGlobalExact(
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 */
1068SCIP_RETCODE SCIPvarChgLbLocal(
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 */
1082SCIP_RETCODE SCIPvarChgLbLocalExact(
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 */
1096SCIP_RETCODE SCIPvarChgUbLocal(
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 */
1110SCIP_RETCODE SCIPvarChgUbLocalExact(
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 */
1124SCIP_RETCODE SCIPvarChgBdLocal(
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 */
1137SCIP_RETCODE SCIPvarChgLbLazy(
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 */
1144SCIP_RETCODE SCIPvarChgUbLazy(
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 */
1151SCIP_RETCODE SCIPvarChgLbDive(
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 */
1159SCIP_RETCODE SCIPvarChgLbExactDive(
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 */
1167SCIP_RETCODE SCIPvarChgUbDive(
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 */
1175SCIP_RETCODE SCIPvarChgUbExactDive(
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 */
1186SCIP_Real SCIPvarGetMultaggrLbLocal(
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 */
1195SCIP_RETCODE SCIPvarGetMultaggrLbLocalExact(
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 */
1205SCIP_Real SCIPvarGetMultaggrUbLocal(
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 */
1214SCIP_RETCODE SCIPvarGetMultaggrUbLocalExact(
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 */
1224SCIP_Real SCIPvarGetMultaggrLbGlobal(
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 */
1233SCIP_Real SCIPvarGetMultaggrUbGlobal(
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*/
1239SCIP_RETCODE SCIPvarAddHoleOriginal(
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 */
1248SCIP_RETCODE SCIPvarAddHoleGlobal(
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 */
1260SCIP_RETCODE SCIPvarAddHoleLocal(
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 */
1272SCIP_RETCODE SCIPvarResetBounds(
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 */
1282int SCIPvarGetConflictingBdchgDepth(
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 */
1293SCIP_RETCODE SCIPvarAddVlb(
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 */
1319SCIP_RETCODE SCIPvarAddVub(
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 */
1347SCIP_RETCODE SCIPvarAddImplic(
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 */
1371SCIP_RETCODE SCIPvarFixBinary(
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 */
1395SCIP_RETCODE SCIPvarAddClique(
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 */
1416SCIP_RETCODE SCIPvarsAddClique(
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 */
1426SCIP_RETCODE SCIPvarDelClique(
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 */
1437SCIP_RETCODE SCIPvarAddCliqueToList(
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 */
1448SCIP_RETCODE SCIPvarDelCliqueFromList(
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 */
1458SCIP_RETCODE SCIPvarChgBranchFactor(
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 */
1467SCIP_RETCODE SCIPvarChgBranchPriority(
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 */
1475SCIP_RETCODE SCIPvarChgBranchDirection(
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 */
1483SCIP_Real SCIPvarGetObjLP(
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 */
1490SCIP_Real SCIPvarGetLbLP(
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 */
1498SCIP_Real SCIPvarGetUbLP(
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 */
1506void SCIPvarGetClosestVlb(
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 */
1518void SCIPvarGetClosestVub(
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 */
1528void SCIPvarStoreRootSol(
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 */
1534void SCIPvarUpdateBestRootSol(
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 */
1543SCIP_Real SCIPvarGetRelaxSol(
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 */
1549SCIP_Real SCIPvarGetRelaxSolTransVar(
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 */
1556SCIP_Real SCIPvarGetImplRedcost(
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 */
1567SCIP_RETCODE SCIPvarSetRelaxSol(
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 */
1576SCIP_RETCODE SCIPvarSetNLPSol(
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 */
1583SCIP_RETCODE SCIPvarAddToRow(
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 */
1596SCIP_RETCODE SCIPvarAddToRowExact(
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 */
1616void SCIPvarMergeHistories(
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 */
1625void SCIPvarSetHistory(
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 */
1634SCIP_RETCODE SCIPvarUpdatePseudocost(
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 */
1646SCIP_RETCODE SCIPvarUpdateAncPseudocost(
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 */
1656SCIP_Real SCIPvarGetPseudocost(
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 */
1663SCIP_Real SCIPvarGetAncPseudocost(
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 */
1672SCIP_Real SCIPvarGetPseudocostCurrentRun(
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 */
1679SCIP_Real SCIPvarGetPseudocostCount(
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 */
1687SCIP_Real SCIPvarGetPseudocostCountCurrentRun(
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 */
1695SCIP_Real SCIPvarGetAncPseudocostCountCurrentRun(
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 */
1701SCIP_Real SCIPvarGetMinPseudocostScore(
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 */
1709SCIP_Real SCIPvarGetPseudocostVariance(
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 */
1723SCIP_Real SCIPvarCalcPscostConfidenceBound(
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 */
1734SCIP_Bool SCIPvarIsPscostRelerrorReliable(
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 */
1760SCIP_Bool SCIPvarSignificantPscostDifference(
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 */
1786SCIP_Bool SCIPvarPscostThresholdProbabilityTest(
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 */
1797SCIP_RETCODE SCIPvarIncVSIDS(
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 */
1808SCIP_RETCODE SCIPvarScaleVSIDS(
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 */
1814SCIP_RETCODE SCIPvarIncNActiveConflicts(
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 */
1825SCIP_Longint SCIPvarGetNActiveConflicts(
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 */
1834SCIP_Longint SCIPvarGetNActiveConflictsCurrentRun(
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 */
1841SCIP_Real SCIPvarGetAvgConflictlength(
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 */
1849SCIP_Real SCIPvarGetAvgConflictlengthCurrentRun(
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 */
1855SCIP_RETCODE SCIPvarIncNBranchings(
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 */
1866SCIP_RETCODE SCIPvarIncInferenceSum(
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 */
1877SCIP_RETCODE SCIPvarIncCutoffSum(
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 */
1888SCIP_Real SCIPvarGetVSIDS_rec(
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 */
1895SCIP_Real SCIPvarGetVSIDSCurrentRun(
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 */
1902SCIP_Real SCIPvarGetAvgInferences(
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 */
1911SCIP_Real SCIPvarGetAvgInferencesCurrentRun(
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 */
1918SCIP_Real SCIPvarGetAvgCutoffs(
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 */
1925SCIP_Real SCIPvarGetAvgCutoffsCurrentRun(
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 */
1932SCIP_Real SCIPvarGetAvgGMIScore(
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 */
1938SCIP_RETCODE SCIPvarIncGMIeffSum(
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 */
1945SCIP_Real SCIPvarGetLastGMIScore(
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 */
1951SCIP_RETCODE SCIPvarSetLastGMIScore(
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 */
1958SCIP_RETCODE SCIPvarPrint(
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 */
1966SCIP_RETCODE SCIPvarCatchEvent(
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 */
1977SCIP_RETCODE SCIPvarDropEvent(
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 */
1988SCIP_Real SCIPvarGetVSIDS(
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 */
1995int SCIPbdchgidxGetPos(
1996 SCIP_BDCHGIDX* bdchgidx /**< bound change index */
1997 );
1998
1999/** returns the depth of the bound change index */
2000int SCIPbdchgidxGetDepth(
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 */
2007SCIP_RETCODE SCIPvarRemoveCliquesImplicsVbs(
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) */
2018void SCIPvarGetLbLocalExactMaximal(
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) */
2023void SCIPvarGetUbLocalExactMinimal(
2024 SCIP_VAR* var, /**< problem variable */
2025 SCIP_RATIONAL* output /**< output rational */
2026 );
2027
2028/** sets index of variable in certificate */
2029void SCIPvarSetUbCertificateIndexLocal(
2030 SCIP_VAR* var, /**< variable to set index for */
2031 SCIP_Longint certidx /**< the index */
2032 );
2033
2034/** sets index of variable in certificate */
2035void SCIPvarSetLbCertificateIndexLocal(
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
bound
static long bound
Definition GomoryHuTree.cpp:47
def.h
common defines and data types used in all packages of SCIP
SCIP_Longint
#define SCIP_Longint
Definition def.h:148
SCIP_Bool
#define SCIP_Bool
Definition def.h:98
SCIP_Real
#define SCIP_Real
Definition def.h:163
event.h
internal methods for managing events
result
* result
Definition heur_actconsdiving.c:293
depth
int depth
Definition heur_intdiving.c:214
cutoff
SCIP_Bool cutoff
Definition heur_intdiving.c:206
sol
static SCIP_SOL * sol
Definition heur_intshifting.c:694
obj
SCIP_Real obj
Definition heur_intshifting.c:706
nvars
int nvars
Definition heur_intshifting.c:709
var
SCIP_VAR * var
Definition heur_objpscostdiving.c:265
frac
SCIP_Real frac
Definition heur_objpscostdiving.c:270
newobj
SCIP_Real newobj
Definition heur_objpscostdiving.c:274
vars
static SCIP_VAR ** vars
Definition heur_rootsoldiving.c:186
rootsol
SCIP_Real * rootsol
Definition heur_rootsoldiving.c:187
intervalarith.h
interval arithmetics for provable bounds
scalars
static const SCIP_Real scalars[]
Definition lp.c:5959
memory.h
memory allocation routines
BMS_BLKMEM
struct BMS_BlkMem BMS_BLKMEM
Definition memory.h:437
pub_history.h
public methods for branching and inference history structure
struct_var.h
datastructures for problem variables
type_branch.h
type definitions for branching rules
SCIP_BRANCHCAND
struct SCIP_BranchCand SCIP_BRANCHCAND
Definition type_branch.h:55
type_certificate.h
type definitions for certificate output
SCIP_CERTIFICATE
struct SCIP_Certificate SCIP_CERTIFICATE
Definition type_certificate.h:43
type_cons.h
type definitions for constraints and constraint handlers
SCIP_CONS
struct SCIP_Cons SCIP_CONS
Definition type_cons.h:63
type_event.h
type definitions for managing events
SCIP_EVENTHDLR
struct SCIP_Eventhdlr SCIP_EVENTHDLR
Definition type_event.h:159
SCIP_EVENTDATA
struct SCIP_EventData SCIP_EVENTDATA
Definition type_event.h:179
SCIP_EVENTFILTER
struct SCIP_EventFilter SCIP_EVENTFILTER
Definition type_event.h:180
SCIP_EVENTQUEUE
struct SCIP_EventQueue SCIP_EVENTQUEUE
Definition type_event.h:181
SCIP_EVENTTYPE
uint64_t SCIP_EVENTTYPE
Definition type_event.h:156
type_history.h
type definitions for branching and inference history
SCIP_HISTORY
struct SCIP_History SCIP_HISTORY
Definition type_history.h:50
SCIP_BRANCHDIR
enum SCIP_BranchDir SCIP_BRANCHDIR
Definition type_history.h:48
type_implics.h
type definitions for implications, variable bounds, and cliques
SCIP_CLIQUE
struct SCIP_Clique SCIP_CLIQUE
Definition type_implics.h:41
SCIP_CLIQUETABLE
struct SCIP_CliqueTable SCIP_CLIQUETABLE
Definition type_implics.h:43
type_lp.h
type definitions for LP management
SCIP_ROW
struct SCIP_Row SCIP_ROW
Definition type_lp.h:105
SCIP_LP
struct SCIP_Lp SCIP_LP
Definition type_lp.h:111
SCIP_BOUNDTYPE
enum SCIP_BoundType SCIP_BOUNDTYPE
Definition type_lp.h:60
type_lpexact.h
type definitions for exact LP management
SCIP_LPEXACT
struct SCIP_LpExact SCIP_LPEXACT
Definition type_lpexact.h:64
SCIP_ROWEXACT
struct SCIP_RowExact SCIP_ROWEXACT
Definition type_lpexact.h:55
type_message.h
type definitions for message output methods
SCIP_MESSAGEHDLR
struct SCIP_Messagehdlr SCIP_MESSAGEHDLR
Definition type_message.h:66
type_misc.h
type definitions for miscellaneous datastructures
SCIP_HASHMAP
struct SCIP_HashMap SCIP_HASHMAP
Definition type_misc.h:106
SCIP_DECL_HASHGETKEY
#define SCIP_DECL_HASHGETKEY(x)
Definition type_misc.h:192
SCIP_CONFIDENCELEVEL
enum SCIP_Confidencelevel SCIP_CONFIDENCELEVEL
Definition type_misc.h:53
type_primal.h
type definitions for collecting primal CIP solutions and primal informations
SCIP_PRIMAL
struct SCIP_Primal SCIP_PRIMAL
Definition type_primal.h:39
type_prob.h
type definitions for storing and manipulating the main problem
SCIP_PROB
struct SCIP_Prob SCIP_PROB
Definition type_prob.h:52
SCIP_OBJSENSE
enum SCIP_Objsense SCIP_OBJSENSE
Definition type_prob.h:50
type_prop.h
type definitions for propagators
SCIP_PROP
struct SCIP_Prop SCIP_PROP
Definition type_prop.h:51
SCIP_RATIONAL
struct SCIP_Rational SCIP_RATIONAL
Definition type_rational.h:40
type_relax.h
type definitions for relaxators
SCIP_RELAXATION
struct SCIP_Relaxation SCIP_RELAXATION
Definition type_relax.h:51
type_reopt.h
type definitions for collecting reoptimization information
SCIP_REOPT
struct SCIP_Reopt SCIP_REOPT
Definition type_reopt.h:39
type_result.h
result codes for SCIP callback methods
type_retcode.h
type definitions for return codes for SCIP methods
SCIP_RETCODE
enum SCIP_Retcode SCIP_RETCODE
Definition type_retcode.h:63
type_scip.h
type definitions for SCIP's main datastructure
SCIP
struct Scip SCIP
Definition type_scip.h:39
type_set.h
type definitions for global SCIP settings
SCIP_SET
struct SCIP_Set SCIP_SET
Definition type_set.h:71
type_sol.h
type definitions for storing primal CIP solutions
SCIP_SOL
struct SCIP_Sol SCIP_SOL
Definition type_sol.h:57
type_stat.h
type definitions for problem statistics
SCIP_STAT
struct SCIP_Stat SCIP_STAT
Definition type_stat.h:66
type_tree.h
type definitions for branch and bound tree
SCIP_TREE
struct SCIP_Tree SCIP_TREE
Definition type_tree.h:65
type_var.h
type definitions for problem variables
SCIP_VARDATA
struct SCIP_VarData SCIP_VARDATA
Definition type_var.h:167
SCIP_VAR
struct SCIP_Var SCIP_VAR
Definition type_var.h:166
SCIP_BOUNDCHGTYPE
enum SCIP_BoundchgType SCIP_BOUNDCHGTYPE
Definition type_var.h:135
SCIP_IMPLINTTYPE
enum SCIP_ImplintType SCIP_IMPLINTTYPE
Definition type_var.h:117
SCIP_DECL_VARDELORIG
#define SCIP_DECL_VARDELORIG(x)
Definition type_var.h:180
SCIP_DOMCHG
union SCIP_DomChg SCIP_DOMCHG
Definition type_var.h:149
SCIP_BOUNDCHG
struct SCIP_BoundChg SCIP_BOUNDCHG
Definition type_var.h:150
SCIP_BDCHGIDX
struct SCIP_BdChgIdx SCIP_BDCHGIDX
Definition type_var.h:151
SCIP_DECL_VARTRANS
#define SCIP_DECL_VARTRANS(x)
Definition type_var.h:200
SCIP_HOLELIST
struct SCIP_Holelist SCIP_HOLELIST
Definition type_var.h:157
SCIP_BDCHGINFO
struct SCIP_BdChgInfo SCIP_BDCHGINFO
Definition type_var.h:152
SCIP_DECL_VARCOPY
#define SCIP_DECL_VARCOPY(x)
Definition type_var.h:243
SCIP_DECL_VARDELTRANS
#define SCIP_DECL_VARDELTRANS(x)
Definition type_var.h:213
SCIP_LOCKTYPE
enum SCIP_LockType SCIP_LOCKTYPE
Definition type_var.h:144
SCIP_VARTYPE
enum SCIP_Vartype SCIP_VARTYPE
Definition type_var.h:73
SCIPvarGetObjLP
SCIP_Real SCIPvarGetObjLP(SCIP_VAR *var)
Definition var.c:18522
SCIPvarGetPseudocost
SCIP_Real SCIPvarGetPseudocost(SCIP_VAR *var, SCIP_STAT *stat, SCIP_Real solvaldelta)
Definition var.c:20437
SCIPvarsGetActiveVars
SCIP_RETCODE SCIPvarsGetActiveVars(SCIP_SET *set, SCIP_VAR **vars, int *nvars, int varssize, int *requiredsize)
Definition var.c:17338
SCIPvarMultiaggregate
SCIP_RETCODE SCIPvarMultiaggregate(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_CLIQUETABLE *cliquetable, SCIP_BRANCHCAND *branchcand, SCIP_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
SCIPvarTryAggregateVarsExact
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
SCIPvarIncNBranchings
SCIP_RETCODE SCIPvarIncNBranchings(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_BRANCHDIR dir, SCIP_Real value, int depth)
Definition var.c:21499
SCIPdomchgAddBoundchg
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
SCIPvarChgLbLazy
SCIP_RETCODE SCIPvarChgLbLazy(SCIP_VAR *var, SCIP_SET *set, SCIP_Real lazylb)
Definition var.c:11771
SCIPvarFixBinary
SCIP_RETCODE SCIPvarFixBinary(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool value, SCIP_Bool *infeasible, int *nbdchgs)
Definition var.c:16512
SCIPvarGetPseudocostCount
SCIP_Real SCIPvarGetPseudocostCount(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition var.c:20580
SCIPvarResetBounds
SCIP_RETCODE SCIPvarResetBounds(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
Definition var.c:14534
SCIPbdchginfoFree
void SCIPbdchginfoFree(SCIP_BDCHGINFO **bdchginfo, BMS_BLKMEM *blkmem)
Definition var.c:22615
SCIPvarGetTransformed
SCIP_RETCODE SCIPvarGetTransformed(SCIP_VAR *origvar, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR **transvar)
Definition var.c:4581
SCIPvarChgObj
SCIP_RETCODE SCIPvarChgObj(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_PROB *prob, SCIP_PRIMAL *primal, SCIP_LP *lp, SCIP_EVENTQUEUE *eventqueue, SCIP_Real newobj)
Definition var.c:9419
SCIPvarGetUbLocalExactMinimal
void SCIPvarGetUbLocalExactMinimal(SCIP_VAR *var, SCIP_RATIONAL *output)
Definition var.c:24289
SCIPvarGetPseudocostVariance
SCIP_Real SCIPvarGetPseudocostVariance(SCIP_VAR *var, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun)
Definition var.c:20744
SCIPvarGetImplRedcost
SCIP_Real SCIPvarGetImplRedcost(SCIP_VAR *var, SCIP_SET *set, SCIP_Bool varfixing, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_LP *lp)
Definition var.c:19233
SCIPvarSetLastGMIScore
SCIP_RETCODE SCIPvarSetLastGMIScore(SCIP_VAR *var, SCIP_STAT *stat, SCIP_Real gmieff)
Definition var.c:22535
SCIPvarInitSolve
void SCIPvarInitSolve(SCIP_VAR *var)
Definition var.c:3846
SCIPvarChgUbGlobalExact
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
SCIPvarGetAncPseudocostCountCurrentRun
SCIP_Real SCIPvarGetAncPseudocostCountCurrentRun(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition var.c:20670
SCIPvarIncInferenceSum
SCIP_RETCODE SCIPvarIncInferenceSum(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_BRANCHDIR dir, SCIP_Real value, SCIP_Real weight)
Definition var.c:21583
SCIPvarChgLbGlobalExact
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
SCIPvarChgBdGlobalExact
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
SCIPvarTryAggregateVars
SCIP_RETCODE SCIPvarTryAggregateVars(SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_CLIQUETABLE *cliquetable, SCIP_BRANCHCAND *branchcand, SCIP_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
SCIPvarIncVSIDS
SCIP_RETCODE SCIPvarIncVSIDS(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_BRANCHDIR dir, SCIP_Real value, SCIP_Real weight)
Definition var.c:21103
SCIPvarChgUbLocalExact
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
SCIPdomchgUndo
SCIP_RETCODE SCIPdomchgUndo(SCIP_DOMCHG *domchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue)
Definition var.c:1640
SCIPvarGetAvgCutoffs
SCIP_Real SCIPvarGetAvgCutoffs(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
Definition var.c:22317
SCIPboundchgApply
SCIP_RETCODE SCIPboundchgApply(SCIP_BOUNDCHG *boundchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, int depth, int pos, SCIP_Bool *cutoff)
Definition var.c:845
SCIPvarGetProbvarSumExact
SCIP_RETCODE SCIPvarGetProbvarSumExact(SCIP_VAR **var, SCIP_RATIONAL *scalar, SCIP_RATIONAL *constant)
Definition var.c:18205
SCIPdomchgMakeStatic
SCIP_RETCODE SCIPdomchgMakeStatic(SCIP_DOMCHG **domchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
Definition var.c:1451
SCIPvarGetMultaggrUbLocalExact
SCIP_RETCODE SCIPvarGetMultaggrUbLocalExact(SCIP_VAR *var, SCIP_SET *set, SCIP_RATIONAL *result)
Definition var.c:13786
SCIPvarUpdatePseudocost
SCIP_RETCODE SCIPvarUpdatePseudocost(SCIP_VAR *var, SCIP_SET *set, SCIP_STAT *stat, SCIP_Real solvaldelta, SCIP_Real objdelta, SCIP_Real weight)
Definition var.c:20274
SCIPvarSetLbCertificateIndexLocal
void SCIPvarSetLbCertificateIndexLocal(SCIP_VAR *var, SCIP_Longint certidx)
Definition var.c:25149
SCIPvarTransform
SCIP_RETCODE SCIPvarTransform(SCIP_VAR *origvar, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_OBJSENSE objsense, SCIP_VAR **transvar)
Definition var.c:4494
SCIPvarAddHoleOriginal
SCIP_RETCODE SCIPvarAddHoleOriginal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_Real left, SCIP_Real right)
Definition var.c:13997
SCIPvarAddCliqueToList
SCIP_RETCODE SCIPvarAddCliqueToList(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_Bool value, SCIP_CLIQUE *clique)
Definition var.c:16725
SCIPbdchgidxGetDepth
int SCIPbdchgidxGetDepth(SCIP_BDCHGIDX *bdchgidx)
Definition var.c:24859
SCIPvarAddHoleGlobal
SCIP_RETCODE SCIPvarAddHoleGlobal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_Real left, SCIP_Real right, SCIP_Bool *added)
Definition var.c:14178
SCIPvarGetAvgInferencesCurrentRun
SCIP_Real SCIPvarGetAvgInferencesCurrentRun(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
Definition var.c:22176
SCIPvarRelease
SCIP_RETCODE SCIPvarRelease(SCIP_VAR **var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
Definition var.c:3787
SCIPvarGetClosestVub
void SCIPvarGetClosestVub(SCIP_VAR *var, SCIP_SOL *sol, SCIP_SET *set, SCIP_STAT *stat, SCIP_Real *closestvub, int *closestvubidx)
Definition var.c:19963
SCIPvarIncNActiveConflicts
SCIP_RETCODE SCIPvarIncNActiveConflicts(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_BRANCHDIR dir, SCIP_Real value, SCIP_Real length)
Definition var.c:21239
SCIPvarRemove
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
SCIPvarAdjustLb
void SCIPvarAdjustLb(SCIP_VAR *var, SCIP_SET *set, SCIP_Real *lb)
Definition var.c:9910
SCIPvarAdjustLbExact
void SCIPvarAdjustLbExact(SCIP_VAR *var, SCIP_SET *set, SCIP_RATIONAL *lb)
Definition var.c:9927
SCIPvarDropEvent
SCIP_RETCODE SCIPvarDropEvent(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
Definition var.c:24824
SCIPvarChgLbGlobal
SCIP_RETCODE SCIPvarChgLbGlobal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Real newbound)
Definition var.c:11178
SCIPvarSetNLPSol
SCIP_RETCODE SCIPvarSetNLPSol(SCIP_VAR *var, SCIP_SET *set, SCIP_Real solval)
Definition var.c:19771
SCIPvarCopy
SCIP_RETCODE SCIPvarCopy(SCIP_VAR **var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP *sourcescip, SCIP_VAR *sourcevar, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global)
Definition var.c:2751
SCIPvarCalcPscostConfidenceBound
SCIP_Real SCIPvarCalcPscostConfidenceBound(SCIP_VAR *var, SCIP_SET *set, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun, SCIP_CONFIDENCELEVEL clevel)
Definition var.c:20798
SCIPvarIsPscostRelerrorReliable
SCIP_Bool SCIPvarIsPscostRelerrorReliable(SCIP_VAR *var, SCIP_SET *set, SCIP_STAT *stat, SCIP_Real threshold, SCIP_CONFIDENCELEVEL clevel)
Definition var.c:20836
SCIPvarChgLbOriginal
SCIP_RETCODE SCIPvarChgLbOriginal(SCIP_VAR *var, SCIP_SET *set, SCIP_Real newbound)
Definition var.c:10028
SCIPvarAddToRow
SCIP_RETCODE SCIPvarAddToRow(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_PROB *prob, SCIP_LP *lp, SCIP_ROW *row, SCIP_Real val)
Definition var.c:20035
SCIPvarGetLbLP
SCIP_Real SCIPvarGetLbLP(SCIP_VAR *var, SCIP_SET *set)
Definition var.c:18568
SCIPvarAdjustBd
void SCIPvarAdjustBd(SCIP_VAR *var, SCIP_SET *set, SCIP_BOUNDTYPE boundtype, SCIP_Real *bd)
Definition var.c:10012
SCIPvarChgObjDive
SCIP_RETCODE SCIPvarChgObjDive(SCIP_VAR *var, SCIP_SET *set, SCIP_LP *lp, SCIP_Real newobj)
Definition var.c:9847
SCIPdomchgFree
SCIP_RETCODE SCIPdomchgFree(SCIP_DOMCHG **domchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
Definition var.c:1348
SCIPvarColumnExact
SCIP_RETCODE SCIPvarColumnExact(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LPEXACT *lp)
Definition var.c:4646
SCIPvarGetRelaxSolTransVar
SCIP_Real SCIPvarGetRelaxSolTransVar(SCIP_VAR *var)
Definition var.c:19760
SCIPvarPrint
SCIP_RETCODE SCIPvarPrint(SCIP_VAR *var, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, FILE *file)
Definition var.c:3953
SCIPvarGetAvgGMIScore
SCIP_Real SCIPvarGetAvgGMIScore(SCIP_VAR *var, SCIP_STAT *stat)
Definition var.c:22411
SCIPvarGetVSIDS
SCIP_Real SCIPvarGetVSIDS(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
Definition var.c:24782
SCIPvarAddObjExact
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
SCIPvarIncCutoffSum
SCIP_RETCODE SCIPvarIncCutoffSum(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_BRANCHDIR dir, SCIP_Real value, SCIP_Real weight)
Definition var.c:21667
SCIPvarGetMultaggrLbLocal
SCIP_Real SCIPvarGetMultaggrLbLocal(SCIP_VAR *var, SCIP_SET *set)
Definition var.c:13574
SCIPvarSignificantPscostDifference
SCIP_Bool SCIPvarSignificantPscostDifference(SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR *varx, SCIP_Real fracx, SCIP_VAR *vary, SCIP_Real fracy, SCIP_BRANCHDIR dir, SCIP_CONFIDENCELEVEL clevel, SCIP_Bool onesided)
Definition var.c:20913
SCIPvarCapture
void SCIPvarCapture(SCIP_VAR *var)
Definition var.c:3762
SCIPvarChgBranchDirection
SCIP_RETCODE SCIPvarChgBranchDirection(SCIP_VAR *var, SCIP_BRANCHDIR branchdirection)
Definition var.c:17150
SCIPvarGetPseudocostCurrentRun
SCIP_Real SCIPvarGetPseudocostCurrentRun(SCIP_VAR *var, SCIP_STAT *stat, SCIP_Real solvaldelta)
Definition var.c:20533
SCIPdomchgAddHolechg
SCIP_RETCODE SCIPdomchgAddHolechg(SCIP_DOMCHG **domchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_HOLELIST **ptr, SCIP_HOLELIST *newlist, SCIP_HOLELIST *oldlist)
Definition var.c:1839
SCIPvarStoreRootSol
void SCIPvarStoreRootSol(SCIP_VAR *var, SCIP_Bool roothaslp)
Definition var.c:19034
SCIPvarGetLbLocalExactMaximal
void SCIPvarGetLbLocalExactMaximal(SCIP_VAR *var, SCIP_RATIONAL *output)
Definition var.c:24255
SCIPvarDoNotAggr
SCIP_Bool SCIPvarDoNotAggr(SCIP_VAR *var)
Definition var.c:8843
SCIPvarChgType
SCIP_RETCODE SCIPvarChgType(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_PRIMAL *primal, SCIP_LP *lp, SCIP_EVENTQUEUE *eventqueue, SCIP_VARTYPE vartype)
Definition var.c:9242
SCIPvarFlattenAggregationGraph
SCIP_RETCODE SCIPvarFlattenAggregationGraph(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue)
Definition var.c:5989
SCIPvarAdjustUbExact
void SCIPvarAdjustUbExact(SCIP_VAR *var, SCIP_SET *set, SCIP_RATIONAL *ub)
Definition var.c:9978
SCIPvarGetNActiveConflicts
SCIP_Longint SCIPvarGetNActiveConflicts(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
Definition var.c:21320
SCIPvarChgLbExactDive
SCIP_RETCODE SCIPvarChgLbExactDive(SCIP_VAR *var, SCIP_SET *set, SCIP_LPEXACT *lpexact, SCIP_RATIONAL *newbound)
Definition var.c:13365
SCIPvarCreateOriginal
SCIP_RETCODE SCIPvarCreateOriginal(SCIP_VAR **var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype, SCIP_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
SCIPvarUpdateBestRootSol
void SCIPvarUpdateBestRootSol(SCIP_VAR *var, SCIP_SET *set, SCIP_Real rootsol, SCIP_Real rootredcost, SCIP_Real rootlpobjval)
Definition var.c:19045
SCIPvarFixExact
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
SCIPvarGetVSIDS_rec
SCIP_Real SCIPvarGetVSIDS_rec(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
Definition var.c:21929
SCIPvarChgImplType
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
SCIPvarChgBdLocal
SCIP_RETCODE SCIPvarChgBdLocal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_Real newbound, SCIP_BOUNDTYPE boundtype)
Definition var.c:13249
SCIPvarScaleVSIDS
SCIP_RETCODE SCIPvarScaleVSIDS(SCIP_VAR *var, SCIP_Real scalar)
Definition var.c:21189
SCIPvarGetAvgConflictlength
SCIP_Real SCIPvarGetAvgConflictlength(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition var.c:21412
SCIPvarGetPseudocostCountCurrentRun
SCIP_Real SCIPvarGetPseudocostCountCurrentRun(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition var.c:20625
SCIPvarChgUbGlobal
SCIP_RETCODE SCIPvarChgUbGlobal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Real newbound)
Definition var.c:11475
SCIPvarMultiaggregateExact
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
SCIPvarChgUbOriginalExact
SCIP_RETCODE SCIPvarChgUbOriginalExact(SCIP_VAR *var, SCIP_SET *set, SCIP_RATIONAL *newbound)
Definition var.c:10220
SCIPvarAggregate
SCIP_RETCODE SCIPvarAggregate(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_CLIQUETABLE *cliquetable, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_VAR *aggvar, SCIP_Real scalar, SCIP_Real constant, SCIP_Bool *infeasible, SCIP_Bool *aggregated)
Definition var.c:6599
SCIPvarCreateTransformed
SCIP_RETCODE SCIPvarCreateTransformed(SCIP_VAR **var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype, SCIP_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
SCIPvarParseTransformed
SCIP_RETCODE SCIPvarParseTransformed(SCIP_VAR **var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, const char *str, SCIP_Bool initial, SCIP_Bool removable, SCIP_DECL_VARCOPY((*varcopy)), SCIP_DECL_VARDELORIG((*vardelorig)), SCIP_DECL_VARTRANS((*vartrans)), SCIP_DECL_VARDELTRANS((*vardeltrans)), SCIP_VARDATA *vardata, char **endptr, SCIP_Bool *success)
Definition var.c:3357
SCIPvarGetUbLP
SCIP_Real SCIPvarGetUbLP(SCIP_VAR *var, SCIP_SET *set)
Definition var.c:18638
SCIPvarColumn
SCIP_RETCODE SCIPvarColumn(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_LP *lp)
Definition var.c:4612
SCIPvarGetAncPseudocost
SCIP_Real SCIPvarGetAncPseudocost(SCIP_VAR *var, SCIP_STAT *stat, SCIP_Real solvaldelta)
Definition var.c:20484
SCIPvarChgUbOriginal
SCIP_RETCODE SCIPvarChgUbOriginal(SCIP_VAR *var, SCIP_SET *set, SCIP_Real newbound)
Definition var.c:10161
SCIPvarChgUbDive
SCIP_RETCODE SCIPvarChgUbDive(SCIP_VAR *var, SCIP_SET *set, SCIP_LP *lp, SCIP_Real newbound)
Definition var.c:13422
SCIPvarGetAvgInferences
SCIP_Real SCIPvarGetAvgInferences(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
Definition var.c:22119
SCIPvarAddObj
SCIP_RETCODE SCIPvarAddObj(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_Real addobj)
Definition var.c:9589
SCIPvarGetConflictingBdchgDepth
int SCIPvarGetConflictingBdchgDepth(SCIP_VAR *var, SCIP_SET *set, SCIP_BOUNDTYPE boundtype, SCIP_Real bound)
Definition var.c:22816
SCIPvarChgUbExactDive
SCIP_RETCODE SCIPvarChgUbExactDive(SCIP_VAR *var, SCIP_SET *set, SCIP_LPEXACT *lpexact, SCIP_RATIONAL *newbound)
Definition var.c:13512
SCIPvarGetMultaggrUbGlobal
SCIP_Real SCIPvarGetMultaggrUbGlobal(SCIP_VAR *var, SCIP_SET *set)
Definition var.c:13936
SCIPvarGetClosestVlb
void SCIPvarGetClosestVlb(SCIP_VAR *var, SCIP_SOL *sol, SCIP_SET *set, SCIP_STAT *stat, SCIP_Real *closestvlb, int *closestvlbidx)
Definition var.c:19888
SCIPvarChgUbLazy
SCIP_RETCODE SCIPvarChgUbLazy(SCIP_VAR *var, SCIP_SET *set, SCIP_Real lazyub)
Definition var.c:11794
SCIPvarChgLbOriginalExact
SCIP_RETCODE SCIPvarChgLbOriginalExact(SCIP_VAR *var, SCIP_SET *set, SCIP_RATIONAL *newbound)
Definition var.c:10087
SCIPvarPscostThresholdProbabilityTest
SCIP_Bool SCIPvarPscostThresholdProbabilityTest(SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR *var, SCIP_Real frac, SCIP_Real threshold, SCIP_BRANCHDIR dir, SCIP_CONFIDENCELEVEL clevel)
Definition var.c:20979
SCIPdomchgApplyGlobal
SCIP_RETCODE SCIPdomchgApplyGlobal(SCIP_DOMCHG *domchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool *cutoff)
Definition var.c:1675
SCIPboundchgUndo
SCIP_RETCODE SCIPboundchgUndo(SCIP_BOUNDCHG *boundchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue)
Definition var.c:1059
SCIPvarMarkDeleted
void SCIPvarMarkDeleted(SCIP_VAR *var)
Definition var.c:9159
SCIPvarMergeHistories
void SCIPvarMergeHistories(SCIP_VAR *targetvar, SCIP_VAR *othervar, SCIP_STAT *stat)
Definition var.c:6116
SCIPvarAddVlb
SCIP_RETCODE SCIPvarAddVlb(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_CLIQUETABLE *cliquetable, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_VAR *vlbvar, SCIP_Real vlbcoef, SCIP_Real vlbconstant, SCIP_Bool transitive, SCIP_Bool *infeasible, int *nbdchgs)
Definition var.c:15316
SCIPdomchgAddCurrentCertificateIndex
void SCIPdomchgAddCurrentCertificateIndex(SCIP_DOMCHG *domchg, SCIP_CERTIFICATE *certificate)
Definition var.c:1714
SCIPvarUpdateAncPseudocost
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
SCIPvarCatchEvent
SCIP_RETCODE SCIPvarCatchEvent(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
Definition var.c:24797
SCIPvarAddHoleLocal
SCIP_RETCODE SCIPvarAddHoleLocal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_Real left, SCIP_Real right, SCIP_Bool *added)
Definition var.c:14425
SCIPvarIsMarkedDeleteGlobalStructures
SCIP_Bool SCIPvarIsMarkedDeleteGlobalStructures(SCIP_VAR *var)
Definition var.c:23580
SCIPdomchgApply
SCIP_RETCODE SCIPdomchgApply(SCIP_DOMCHG *domchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, int depth, SCIP_Bool *cutoff)
Definition var.c:1591
SCIPvarDelClique
SCIP_RETCODE SCIPvarDelClique(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool value, SCIP_CLIQUE *clique)
Definition var.c:16764
SCIPvarGetRelaxSol
SCIP_Real SCIPvarGetRelaxSol(SCIP_VAR *var, SCIP_SET *set)
Definition var.c:19688
SCIPvarDelCliqueFromList
SCIP_RETCODE SCIPvarDelCliqueFromList(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_Bool value, SCIP_CLIQUE *clique)
Definition var.c:16747
SCIPbdchgidxGetPos
int SCIPbdchgidxGetPos(SCIP_BDCHGIDX *bdchgidx)
Definition var.c:24849
SCIPvarChgBdGlobal
SCIP_RETCODE SCIPvarChgBdGlobal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Real newbound, SCIP_BOUNDTYPE boundtype)
Definition var.c:11819
SCIPvarsAddClique
SCIP_RETCODE SCIPvarsAddClique(SCIP_VAR **vars, SCIP_Bool *values, int nvars, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_CLIQUE *clique)
Definition var.c:16687
SCIPvarMarkDoNotAggr
SCIP_RETCODE SCIPvarMarkDoNotAggr(SCIP_VAR *var)
Definition var.c:9170
SCIPvarChgLbLocal
SCIP_RETCODE SCIPvarChgLbLocal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_Real newbound)
Definition var.c:12715
SCIPvarLoose
SCIP_RETCODE SCIPvarLoose(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_PROB *prob, SCIP_LP *lp)
Definition var.c:4680
SCIPvarAddClique
SCIP_RETCODE SCIPvarAddClique(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool value, SCIP_CLIQUE *clique, SCIP_Bool *infeasible, int *nbdchgs)
Definition var.c:16601
SCIPvarChgBranchPriority
SCIP_RETCODE SCIPvarChgBranchPriority(SCIP_VAR *var, int branchpriority)
Definition var.c:17019
SCIPvarChgLbLocalExact
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
SCIPvarMarkDoNotMultaggr
SCIP_RETCODE SCIPvarMarkDoNotMultaggr(SCIP_VAR *var)
Definition var.c:9206
SCIPvarAddLocks
SCIP_RETCODE SCIPvarAddLocks(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LOCKTYPE locktype, int addnlocksdown, int addnlocksup)
Definition var.c:4200
SCIPvarNegate
SCIP_RETCODE SCIPvarNegate(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR **negvar)
Definition var.c:8979
SCIPvarGetMultaggrUbLocal
SCIP_Real SCIPvarGetMultaggrUbLocal(SCIP_VAR *var, SCIP_SET *set)
Definition var.c:13722
SCIPbdchginfoCreate
SCIP_RETCODE SCIPbdchginfoCreate(SCIP_BDCHGINFO **bdchginfo, BMS_BLKMEM *blkmem, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_Real oldbound, SCIP_Real newbound)
Definition var.c:22585
SCIPvarGetMinPseudocostScore
SCIP_Real SCIPvarGetMinPseudocostScore(SCIP_VAR *var, SCIP_STAT *stat, SCIP_SET *set, SCIP_Real solval)
Definition var.c:20713
SCIPvarGetProbvarSum
SCIP_RETCODE SCIPvarGetProbvarSum(SCIP_VAR **var, SCIP_SET *set, SCIP_Real *scalar, SCIP_Real *constant)
Definition var.c:18075
SCIPvarIsAggrCoefAcceptable
SCIP_Bool SCIPvarIsAggrCoefAcceptable(SCIP_SET *set, SCIP_VAR *var, SCIP_Real scalar)
Definition var.c:8909
SCIPvarAddExactData
SCIP_RETCODE SCIPvarAddExactData(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_RATIONAL *lb, SCIP_RATIONAL *ub, SCIP_RATIONAL *obj)
Definition var.c:2578
SCIPvarIncGMIeffSum
SCIP_RETCODE SCIPvarIncGMIeffSum(SCIP_VAR *var, SCIP_STAT *stat, SCIP_Real gmieff)
Definition var.c:22451
SCIPvarGetLastGMIScore
SCIP_Real SCIPvarGetLastGMIScore(SCIP_VAR *var, SCIP_STAT *stat)
Definition var.c:22495
SCIPvarAdjustUb
void SCIPvarAdjustUb(SCIP_VAR *var, SCIP_SET *set, SCIP_Real *ub)
Definition var.c:9961
SCIPbdchginfoGetRelaxedBound
SCIP_Real SCIPbdchginfoGetRelaxedBound(SCIP_BDCHGINFO *bdchginfo)
Definition var.c:25048
SCIPvarGetActiveRepresentatives
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
SCIPvarChgLbDive
SCIP_RETCODE SCIPvarChgLbDive(SCIP_VAR *var, SCIP_SET *set, SCIP_LP *lp, SCIP_Real newbound)
Definition var.c:13275
SCIPvarFix
SCIP_RETCODE SCIPvarFix(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_CLIQUETABLE *cliquetable, SCIP_Real fixedval, SCIP_Bool *infeasible, SCIP_Bool *fixed)
Definition var.c:4820
SCIPvarGetAvgConflictlengthCurrentRun
SCIP_Real SCIPvarGetAvgConflictlengthCurrentRun(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition var.c:21456
SCIPvarCopyExactData
SCIP_RETCODE SCIPvarCopyExactData(BMS_BLKMEM *blkmem, SCIP_VAR *targetvar, SCIP_VAR *sourcevar, SCIP_Bool negateobj)
Definition var.c:2686
SCIPvarChgUbLocal
SCIP_RETCODE SCIPvarChgUbLocal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_Real newbound)
Definition var.c:12983
SCIPvarParseOriginal
SCIP_RETCODE SCIPvarParseOriginal(SCIP_VAR **var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, const char *str, SCIP_Bool initial, SCIP_Bool removable, SCIP_DECL_VARCOPY((*varcopy)), SCIP_DECL_VARDELORIG((*vardelorig)), SCIP_DECL_VARTRANS((*vartrans)), SCIP_DECL_VARDELTRANS((*vardeltrans)), SCIP_VARDATA *vardata, char **endptr, SCIP_Bool *success)
Definition var.c:3234
SCIPvarAddVub
SCIP_RETCODE SCIPvarAddVub(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_CLIQUETABLE *cliquetable, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_VAR *vubvar, SCIP_Real vubcoef, SCIP_Real vubconstant, SCIP_Bool transitive, SCIP_Bool *infeasible, int *nbdchgs)
Definition var.c:15783
SCIPvarGetVSIDSCurrentRun
SCIP_Real SCIPvarGetVSIDSCurrentRun(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
Definition var.c:21980
SCIPvarSetNamePointer
void SCIPvarSetNamePointer(SCIP_VAR *var, const char *name)
Definition var.c:9102
SCIPvarAggregateExact
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
SCIPvarChgName
SCIP_RETCODE SCIPvarChgName(SCIP_VAR *var, BMS_BLKMEM *blkmem, const char *name)
Definition var.c:3828
SCIPvarSetHistory
void SCIPvarSetHistory(SCIP_VAR *var, SCIP_HISTORY *history, SCIP_STAT *stat)
Definition var.c:6132
SCIPvarSetUbCertificateIndexLocal
void SCIPvarSetUbCertificateIndexLocal(SCIP_VAR *var, SCIP_Longint certidx)
Definition var.c:25136
SCIPvarAdjustUbExactFloat
void SCIPvarAdjustUbExactFloat(SCIP_VAR *var, SCIP_SET *set, SCIP_Real *ub)
Definition var.c:9995
SCIPvarSetProbindex
void SCIPvarSetProbindex(SCIP_VAR *var, int probindex)
Definition var.c:9087
SCIPvarGetMultaggrLbGlobal
SCIP_Real SCIPvarGetMultaggrLbGlobal(SCIP_VAR *var, SCIP_SET *set)
Definition var.c:13870
SCIPvarSetRelaxSol
SCIP_RETCODE SCIPvarSetRelaxSol(SCIP_VAR *var, SCIP_SET *set, SCIP_RELAXATION *relaxation, SCIP_Real solval, SCIP_Bool updateobj)
Definition var.c:19627
SCIPvarAdjustLbExactFloat
void SCIPvarAdjustLbExactFloat(SCIP_VAR *var, SCIP_SET *set, SCIP_Real *lb)
Definition var.c:9944
SCIPvarChgBranchFactor
SCIP_RETCODE SCIPvarChgBranchFactor(SCIP_VAR *var, SCIP_SET *set, SCIP_Real branchfactor)
Definition var.c:16892
SCIPvarAddImplic
SCIP_RETCODE SCIPvarAddImplic(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_CLIQUETABLE *cliquetable, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_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
SCIPvarGetNActiveConflictsCurrentRun
SCIP_Longint SCIPvarGetNActiveConflictsCurrentRun(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
Definition var.c:21367
SCIPvarChgObjExact
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
SCIPvarGetAvgCutoffsCurrentRun
SCIP_Real SCIPvarGetAvgCutoffsCurrentRun(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
Definition var.c:22364
SCIPvarDoNotMultaggr
SCIP_Bool SCIPvarDoNotMultaggr(SCIP_VAR *var)
Definition var.c:8876
SCIPvarRemoveCliquesImplicsVbs
SCIP_RETCODE SCIPvarRemoveCliquesImplicsVbs(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_CLIQUETABLE *cliquetable, SCIP_SET *set, SCIP_Bool irrelevantvar, SCIP_Bool onlyredundant, SCIP_Bool removefromvar)
Definition var.c:2006
SCIPvarGetMultaggrLbLocalExact
SCIP_RETCODE SCIPvarGetMultaggrLbLocalExact(SCIP_VAR *var, SCIP_SET *set, SCIP_RATIONAL *result)
Definition var.c:13638
SCIPvarGetActiveRepresentativesExact
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
SCIPvarAddToRowExact
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