Scippy

SCIP

Solving Constraint Integer Programs

scip_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-2018 Konrad-Zuse-Zentrum */
7 /* fuer Informationstechnik Berlin */
8 /* */
9 /* SCIP is distributed under the terms of the ZIB Academic License. */
10 /* */
11 /* You should have received a copy of the ZIB Academic License */
12 /* along with SCIP; see the file COPYING. If not visit scip.zib.de. */
13 /* */
14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15 
16 /**@file scip_var.h
17  * @ingroup PUBLICCOREAPI
18  * @brief public methods for SCIP variables
19  * @author Tobias Achterberg
20  * @author Timo Berthold
21  * @author Thorsten Koch
22  * @author Alexander Martin
23  * @author Marc Pfetsch
24  * @author Kati Wolter
25  * @author Gregor Hendel
26  * @author Robert Lion Gottwald
27  */
28 
29 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
30 
31 #ifndef __SCIP_SCIP_VAR_H__
32 #define __SCIP_SCIP_VAR_H__
33 
34 
35 #include "scip/def.h"
36 #include "scip/type_cons.h"
37 #include "scip/type_history.h"
38 #include "scip/type_implics.h"
39 #include "scip/type_lp.h"
40 #include "scip/type_misc.h"
41 #include "scip/type_prop.h"
42 #include "scip/type_result.h"
43 #include "scip/type_retcode.h"
44 #include "scip/type_scip.h"
45 #include "scip/type_sol.h"
46 #include "scip/type_tree.h"
47 #include "scip/type_var.h"
48 
49 /* In debug mode, we include the SCIP's structure in scip.c, such that no one can access
50  * this structure except the interface methods in scip.c.
51  * In optimized mode, the structure is included in scip.h, because some of the methods
52  * are implemented as defines for performance reasons (e.g. the numerical comparisons).
53  * Additionally, the internal "set.h" is included, such that the defines in set.h are
54  * available in optimized mode.
55  */
56 #ifdef NDEBUG
57 #include "scip/struct_scip.h"
58 #include "scip/struct_stat.h"
59 #include "scip/set.h"
60 #include "scip/tree.h"
61 #include "scip/misc.h"
62 #include "scip/var.h"
63 #include "scip/cons.h"
64 #include "scip/solve.h"
65 #include "scip/debug.h"
66 #endif
67 
68 #ifdef __cplusplus
69 extern "C" {
70 #endif
71 
72 /**@addtogroup PublicVariableMethods
73  *
74  *@{
75  */
76 
77 /** creates and captures problem variable; if variable is of integral type, fractional bounds are automatically rounded;
78  * an integer variable with bounds zero and one is automatically converted into a binary variable;
79  *
80  * @warning When doing column generation and the original problem is a maximization problem, notice that SCIP will
81  * transform the problem into a minimization problem by multiplying the objective function by -1. Thus, the
82  * original objective function value of variables created during the solving process has to be multiplied by
83  * -1, too.
84  *
85  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
86  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
87  *
88  * @pre This method can be called if @p scip is in one of the following stages:
89  * - \ref SCIP_STAGE_PROBLEM
90  * - \ref SCIP_STAGE_TRANSFORMING
91  * - \ref SCIP_STAGE_INITPRESOLVE
92  * - \ref SCIP_STAGE_PRESOLVING
93  * - \ref SCIP_STAGE_EXITPRESOLVE
94  * - \ref SCIP_STAGE_PRESOLVED
95  * - \ref SCIP_STAGE_SOLVING
96  *
97  * @note the variable gets captured, hence at one point you have to release it using the method SCIPreleaseVar()
98  */
99 extern
100 SCIP_RETCODE SCIPcreateVar(
101  SCIP* scip, /**< SCIP data structure */
102  SCIP_VAR** var, /**< pointer to variable object */
103  const char* name, /**< name of variable, or NULL for automatic name creation */
104  SCIP_Real lb, /**< lower bound of variable */
105  SCIP_Real ub, /**< upper bound of variable */
106  SCIP_Real obj, /**< objective function value */
107  SCIP_VARTYPE vartype, /**< type of variable */
108  SCIP_Bool initial, /**< should var's column be present in the initial root LP? */
109  SCIP_Bool removable, /**< is var's column removable from the LP (due to aging or cleanup)? */
110  SCIP_DECL_VARDELORIG ((*vardelorig)), /**< frees user data of original variable, or NULL */
111  SCIP_DECL_VARTRANS ((*vartrans)), /**< creates transformed user data by transforming original user data, or NULL */
112  SCIP_DECL_VARDELTRANS ((*vardeltrans)), /**< frees user data of transformed variable, or NULL */
113  SCIP_DECL_VARCOPY ((*varcopy)), /**< copies variable data if wanted to subscip, or NULL */
114  SCIP_VARDATA* vardata /**< user data for this specific variable, or NULL */
115  );
116 
117 /** creates and captures problem variable with optional callbacks and variable data set to NULL, which can be set
118  * afterwards using SCIPvarSetDelorigData(), SCIPvarSetTransData(),
119  * SCIPvarSetDeltransData(), SCIPvarSetCopy(), and SCIPvarSetData(); sets variable flags initial=TRUE
120  * and removable = FALSE, which can be adjusted by using SCIPvarSetInitial() and SCIPvarSetRemovable(), resp.;
121  * if variable is of integral type, fractional bounds are automatically rounded;
122  * an integer variable with bounds zero and one is automatically converted into a binary variable;
123  *
124  * @warning When doing column generation and the original problem is a maximization problem, notice that SCIP will
125  * transform the problem into a minimization problem by multiplying the objective function by -1. Thus, the
126  * original objective function value of variables created during the solving process has to be multiplied by
127  * -1, too.
128  *
129  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
130  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
131  *
132  * @pre This method can be called if @p scip is in one of the following stages:
133  * - \ref SCIP_STAGE_PROBLEM
134  * - \ref SCIP_STAGE_TRANSFORMING
135  * - \ref SCIP_STAGE_INITPRESOLVE
136  * - \ref SCIP_STAGE_PRESOLVING
137  * - \ref SCIP_STAGE_EXITPRESOLVE
138  * - \ref SCIP_STAGE_PRESOLVED
139  * - \ref SCIP_STAGE_SOLVING
140  *
141  * @note the variable gets captured, hence at one point you have to release it using the method SCIPreleaseVar()
142  */
143 extern
144 SCIP_RETCODE SCIPcreateVarBasic(
145  SCIP* scip, /**< SCIP data structure */
146  SCIP_VAR** var, /**< pointer to variable object */
147  const char* name, /**< name of variable, or NULL for automatic name creation */
148  SCIP_Real lb, /**< lower bound of variable */
149  SCIP_Real ub, /**< upper bound of variable */
150  SCIP_Real obj, /**< objective function value */
151  SCIP_VARTYPE vartype /**< type of variable */
152  );
153 
154 /** outputs the variable name to the file stream
155  *
156  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
157  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
158  *
159  * @pre This method can be called if @p scip is in one of the following stages:
160  * - \ref SCIP_STAGE_PROBLEM
161  * - \ref SCIP_STAGE_TRANSFORMING
162  * - \ref SCIP_STAGE_TRANSFORMED
163  * - \ref SCIP_STAGE_INITPRESOLVE
164  * - \ref SCIP_STAGE_PRESOLVING
165  * - \ref SCIP_STAGE_EXITPRESOLVE
166  * - \ref SCIP_STAGE_PRESOLVED
167  * - \ref SCIP_STAGE_INITSOLVE
168  * - \ref SCIP_STAGE_SOLVING
169  * - \ref SCIP_STAGE_SOLVED
170  * - \ref SCIP_STAGE_EXITSOLVE
171  * - \ref SCIP_STAGE_FREETRANS
172  */
173 extern
174 SCIP_RETCODE SCIPwriteVarName(
175  SCIP* scip, /**< SCIP data structure */
176  FILE* file, /**< output file, or NULL for stdout */
177  SCIP_VAR* var, /**< variable to output */
178  SCIP_Bool type /**< should the variable type be also posted */
179  );
180 
181 /** print the given list of variables to output stream separated by the given delimiter character;
182  *
183  * i. e. the variables x1, x2, ..., xn with given delimiter ',' are written as: <x1>, <x2>, ..., <xn>;
184  *
185  * the method SCIPparseVarsList() can parse such a string
186  *
187  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
188  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
189  *
190  * @pre This method can be called if @p scip is in one of the following stages:
191  * - \ref SCIP_STAGE_PROBLEM
192  * - \ref SCIP_STAGE_TRANSFORMING
193  * - \ref SCIP_STAGE_TRANSFORMED
194  * - \ref SCIP_STAGE_INITPRESOLVE
195  * - \ref SCIP_STAGE_PRESOLVING
196  * - \ref SCIP_STAGE_EXITPRESOLVE
197  * - \ref SCIP_STAGE_PRESOLVED
198  * - \ref SCIP_STAGE_INITSOLVE
199  * - \ref SCIP_STAGE_SOLVING
200  * - \ref SCIP_STAGE_SOLVED
201  * - \ref SCIP_STAGE_EXITSOLVE
202  * - \ref SCIP_STAGE_FREETRANS
203  *
204  * @note The printing process is done via the message handler system.
205  */
206 extern
207 SCIP_RETCODE SCIPwriteVarsList(
208  SCIP* scip, /**< SCIP data structure */
209  FILE* file, /**< output file, or NULL for stdout */
210  SCIP_VAR** vars, /**< variable array to output */
211  int nvars, /**< number of variables */
212  SCIP_Bool type, /**< should the variable type be also posted */
213  char delimiter /**< character which is used for delimitation */
214  );
215 
216 /** print the given variables and coefficients as linear sum in the following form
217  * c1 <x1> + c2 <x2> ... + cn <xn>
218  *
219  * This string can be parsed by the method SCIPparseVarsLinearsum().
220  *
221  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
222  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
223  *
224  * @pre This method can be called if @p scip is in one of the following stages:
225  * - \ref SCIP_STAGE_PROBLEM
226  * - \ref SCIP_STAGE_TRANSFORMING
227  * - \ref SCIP_STAGE_TRANSFORMED
228  * - \ref SCIP_STAGE_INITPRESOLVE
229  * - \ref SCIP_STAGE_PRESOLVING
230  * - \ref SCIP_STAGE_EXITPRESOLVE
231  * - \ref SCIP_STAGE_PRESOLVED
232  * - \ref SCIP_STAGE_INITSOLVE
233  * - \ref SCIP_STAGE_SOLVING
234  * - \ref SCIP_STAGE_SOLVED
235  * - \ref SCIP_STAGE_EXITSOLVE
236  * - \ref SCIP_STAGE_FREETRANS
237  *
238  * @note The printing process is done via the message handler system.
239  */
240 extern
241 SCIP_RETCODE SCIPwriteVarsLinearsum(
242  SCIP* scip, /**< SCIP data structure */
243  FILE* file, /**< output file, or NULL for stdout */
244  SCIP_VAR** vars, /**< variable array to output */
245  SCIP_Real* vals, /**< array of coefficients or NULL if all coefficients are 1.0 */
246  int nvars, /**< number of variables */
247  SCIP_Bool type /**< should the variable type be also posted */
248  );
249 
250 /** print the given monomials as polynomial in the following form
251  * c1 <x11>^e11 <x12>^e12 ... <x1n>^e1n + c2 <x21>^e21 <x22>^e22 ... + ... + cn <xn1>^en1 ...
252  *
253  * This string can be parsed by the method SCIPparseVarsPolynomial().
254  *
255  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
256  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
257  *
258  * @pre This method can be called if @p scip is in one of the following stages:
259  * - \ref SCIP_STAGE_PROBLEM
260  * - \ref SCIP_STAGE_TRANSFORMING
261  * - \ref SCIP_STAGE_TRANSFORMED
262  * - \ref SCIP_STAGE_INITPRESOLVE
263  * - \ref SCIP_STAGE_PRESOLVING
264  * - \ref SCIP_STAGE_EXITPRESOLVE
265  * - \ref SCIP_STAGE_PRESOLVED
266  * - \ref SCIP_STAGE_INITSOLVE
267  * - \ref SCIP_STAGE_SOLVING
268  * - \ref SCIP_STAGE_SOLVED
269  * - \ref SCIP_STAGE_EXITSOLVE
270  * - \ref SCIP_STAGE_FREETRANS
271  *
272  * @note The printing process is done via the message handler system.
273  */
274 extern
275 SCIP_RETCODE SCIPwriteVarsPolynomial(
276  SCIP* scip, /**< SCIP data structure */
277  FILE* file, /**< output file, or NULL for stdout */
278  SCIP_VAR*** monomialvars, /**< arrays with variables for each monomial */
279  SCIP_Real** monomialexps, /**< arrays with variable exponents, or NULL if always 1.0 */
280  SCIP_Real* monomialcoefs, /**< array with monomial coefficients */
281  int* monomialnvars, /**< array with number of variables for each monomial */
282  int nmonomials, /**< number of monomials */
283  SCIP_Bool type /**< should the variable type be also posted */
284  );
285 
286 /** parses variable information (in cip format) out of a string; if the parsing process was successful a variable is
287  * created and captured; if variable is of integral type, fractional bounds are automatically rounded; an integer
288  * variable with bounds zero and one is automatically converted into a binary variable
289  *
290  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
291  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
292  *
293  * @pre This method can be called if @p scip is in one of the following stages:
294  * - \ref SCIP_STAGE_PROBLEM
295  * - \ref SCIP_STAGE_TRANSFORMING
296  * - \ref SCIP_STAGE_INITPRESOLVE
297  * - \ref SCIP_STAGE_PRESOLVING
298  * - \ref SCIP_STAGE_EXITPRESOLVE
299  * - \ref SCIP_STAGE_PRESOLVED
300  * - \ref SCIP_STAGE_SOLVING
301  */
302 extern
303 SCIP_RETCODE SCIPparseVar(
304  SCIP* scip, /**< SCIP data structure */
305  SCIP_VAR** var, /**< pointer to store the problem variable */
306  const char* str, /**< string to parse */
307  SCIP_Bool initial, /**< should var's column be present in the initial root LP? */
308  SCIP_Bool removable, /**< is var's column removable from the LP (due to aging or cleanup)? */
309  SCIP_DECL_VARCOPY ((*varcopy)), /**< copies variable data if wanted to subscip, or NULL */
310  SCIP_DECL_VARDELORIG ((*vardelorig)), /**< frees user data of original variable */
311  SCIP_DECL_VARTRANS ((*vartrans)), /**< creates transformed user data by transforming original user data */
312  SCIP_DECL_VARDELTRANS ((*vardeltrans)), /**< frees user data of transformed variable */
313  SCIP_VARDATA* vardata, /**< user data for this specific variable */
314  char** endptr, /**< pointer to store the final string position if successful */
315  SCIP_Bool* success /**< pointer store if the paring process was successful */
316  );
317 
318 /** parses the given string for a variable name and stores the variable in the corresponding pointer if such a variable
319  * exits and returns the position where the parsing stopped
320  *
321  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
322  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
323  *
324  * @pre This method can be called if @p scip is in one of the following stages:
325  * - \ref SCIP_STAGE_PROBLEM
326  * - \ref SCIP_STAGE_TRANSFORMING
327  * - \ref SCIP_STAGE_INITPRESOLVE
328  * - \ref SCIP_STAGE_PRESOLVING
329  * - \ref SCIP_STAGE_EXITPRESOLVE
330  * - \ref SCIP_STAGE_PRESOLVED
331  * - \ref SCIP_STAGE_SOLVING
332  */
333 extern
334 SCIP_RETCODE SCIPparseVarName(
335  SCIP* scip, /**< SCIP data structure */
336  const char* str, /**< string to parse */
337  SCIP_VAR** var, /**< pointer to store the problem variable, or NULL if it does not exit */
338  char** endptr /**< pointer to store the final string position if successful */
339  );
340 
341 /** parse the given string as variable list (here ',' is the delimiter)) (<x1>, <x2>, ..., <xn>) (see
342  * SCIPwriteVarsList() ); if it was successful, the pointer success is set to TRUE
343  *
344  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
345  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
346  *
347  * @pre This method can be called if @p scip is in one of the following stages:
348  * - \ref SCIP_STAGE_PROBLEM
349  * - \ref SCIP_STAGE_TRANSFORMING
350  * - \ref SCIP_STAGE_INITPRESOLVE
351  * - \ref SCIP_STAGE_PRESOLVING
352  * - \ref SCIP_STAGE_EXITPRESOLVE
353  * - \ref SCIP_STAGE_PRESOLVED
354  * - \ref SCIP_STAGE_SOLVING
355  *
356  * @note The pointer success in only set to FALSE in the case that a variable with a parsed variable name does not exist.
357  *
358  * @note If the number of (parsed) variables is greater than the available slots in the variable array, nothing happens
359  * except that the required size is stored in the corresponding integer; the reason for this approach is that we
360  * cannot reallocate memory, since we do not know how the memory has been allocated (e.g., by a C++ 'new' or SCIP
361  * memory functions).
362  */
363 extern
364 SCIP_RETCODE SCIPparseVarsList(
365  SCIP* scip, /**< SCIP data structure */
366  const char* str, /**< string to parse */
367  SCIP_VAR** vars, /**< array to store the parsed variable */
368  int* nvars, /**< pointer to store number of parsed variables */
369  int varssize, /**< size of the variable array */
370  int* requiredsize, /**< pointer to store the required array size for the active variables */
371  char** endptr, /**< pointer to store the final string position if successful */
372  char delimiter, /**< character which is used for delimitation */
373  SCIP_Bool* success /**< pointer to store the whether the parsing was successful or not */
374  );
375 
376 /** parse the given string as linear sum of variables and coefficients (c1 <x1> + c2 <x2> + ... + cn <xn>)
377  * (see SCIPwriteVarsLinearsum() ); if it was successful, the pointer success is set to TRUE
378  *
379  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
380  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
381  *
382  * @pre This method can be called if @p scip is in one of the following stages:
383  * - \ref SCIP_STAGE_PROBLEM
384  * - \ref SCIP_STAGE_TRANSFORMING
385  * - \ref SCIP_STAGE_INITPRESOLVE
386  * - \ref SCIP_STAGE_PRESOLVING
387  * - \ref SCIP_STAGE_EXITPRESOLVE
388  * - \ref SCIP_STAGE_PRESOLVED
389  * - \ref SCIP_STAGE_SOLVING
390  *
391  * @note The pointer success in only set to FALSE in the case that a variable with a parsed variable name does not exist.
392  *
393  * @note If the number of (parsed) variables is greater than the available slots in the variable array, nothing happens
394  * except that the required size is stored in the corresponding integer; the reason for this approach is that we
395  * cannot reallocate memory, since we do not know how the memory has been allocated (e.g., by a C++ 'new' or SCIP
396  * memory functions).
397  */
398 extern
399 SCIP_RETCODE SCIPparseVarsLinearsum(
400  SCIP* scip, /**< SCIP data structure */
401  const char* str, /**< string to parse */
402  SCIP_VAR** vars, /**< array to store the parsed variables */
403  SCIP_Real* vals, /**< array to store the parsed coefficients */
404  int* nvars, /**< pointer to store number of parsed variables */
405  int varssize, /**< size of the variable array */
406  int* requiredsize, /**< pointer to store the required array size for the active variables */
407  char** endptr, /**< pointer to store the final string position if successful */
408  SCIP_Bool* success /**< pointer to store the whether the parsing was successful or not */
409  );
410 
411 /** parse the given string as polynomial of variables and coefficients
412  * (c1 <x11>^e11 <x12>^e12 ... <x1n>^e1n + c2 <x21>^e21 <x22>^e22 ... + ... + cn <xn1>^en1 ...)
413  * (see SCIPwriteVarsPolynomial()); if it was successful, the pointer success is set to TRUE
414  *
415  * The user has to call SCIPfreeParseVarsPolynomialData(scip, monomialvars, monomialexps,
416  * monomialcoefs, monomialnvars, *nmonomials) short after SCIPparseVarsPolynomial to free all the
417  * allocated memory again. Do not keep the arrays created by SCIPparseVarsPolynomial around, since
418  * they use buffer memory that is intended for short term use only.
419  *
420  * Parsing is stopped at the end of string (indicated by the \\0-character) or when no more monomials
421  * are recognized.
422  *
423  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
424  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
425  *
426  * @pre This method can be called if @p scip is in one of the following stages:
427  * - \ref SCIP_STAGE_PROBLEM
428  * - \ref SCIP_STAGE_TRANSFORMING
429  * - \ref SCIP_STAGE_INITPRESOLVE
430  * - \ref SCIP_STAGE_PRESOLVING
431  * - \ref SCIP_STAGE_EXITPRESOLVE
432  * - \ref SCIP_STAGE_PRESOLVED
433  * - \ref SCIP_STAGE_SOLVING
434  */
435 extern
436 SCIP_RETCODE SCIPparseVarsPolynomial(
437  SCIP* scip, /**< SCIP data structure */
438  const char* str, /**< string to parse */
439  SCIP_VAR**** monomialvars, /**< pointer to store arrays with variables for each monomial */
440  SCIP_Real*** monomialexps, /**< pointer to store arrays with variable exponents */
441  SCIP_Real** monomialcoefs, /**< pointer to store array with monomial coefficients */
442  int** monomialnvars, /**< pointer to store array with number of variables for each monomial */
443  int* nmonomials, /**< pointer to store number of parsed monomials */
444  char** endptr, /**< pointer to store the final string position if successful */
445  SCIP_Bool* success /**< pointer to store the whether the parsing was successful or not */
446  );
447 
448 /** frees memory allocated when parsing a polynomial from a string
449  *
450  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
451  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
452  *
453  * @pre This method can be called if @p scip is in one of the following stages:
454  * - \ref SCIP_STAGE_PROBLEM
455  * - \ref SCIP_STAGE_TRANSFORMING
456  * - \ref SCIP_STAGE_INITPRESOLVE
457  * - \ref SCIP_STAGE_PRESOLVING
458  * - \ref SCIP_STAGE_EXITPRESOLVE
459  * - \ref SCIP_STAGE_PRESOLVED
460  * - \ref SCIP_STAGE_SOLVING
461  */
462 extern
463 void SCIPfreeParseVarsPolynomialData(
464  SCIP* scip, /**< SCIP data structure */
465  SCIP_VAR**** monomialvars, /**< pointer to store arrays with variables for each monomial */
466  SCIP_Real*** monomialexps, /**< pointer to store arrays with variable exponents */
467  SCIP_Real** monomialcoefs, /**< pointer to store array with monomial coefficients */
468  int** monomialnvars, /**< pointer to store array with number of variables for each monomial */
469  int nmonomials /**< pointer to store number of parsed monomials */
470  );
471 
472 /** increases usage counter of variable
473  *
474  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
475  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
476  *
477  * @pre This method can be called if @p scip is in one of the following stages:
478  * - \ref SCIP_STAGE_PROBLEM
479  * - \ref SCIP_STAGE_TRANSFORMING
480  * - \ref SCIP_STAGE_TRANSFORMED
481  * - \ref SCIP_STAGE_INITPRESOLVE
482  * - \ref SCIP_STAGE_PRESOLVING
483  * - \ref SCIP_STAGE_EXITPRESOLVE
484  * - \ref SCIP_STAGE_PRESOLVED
485  * - \ref SCIP_STAGE_INITSOLVE
486  * - \ref SCIP_STAGE_SOLVING
487  * - \ref SCIP_STAGE_SOLVED
488  * - \ref SCIP_STAGE_EXITSOLVE
489  */
490 extern
491 SCIP_RETCODE SCIPcaptureVar(
492  SCIP* scip, /**< SCIP data structure */
493  SCIP_VAR* var /**< variable to capture */
494  );
495 
496 /** decreases usage counter of variable, if the usage pointer reaches zero the variable gets freed
497  *
498  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
499  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
500  *
501  * @pre This method can be called if @p scip is in one of the following stages:
502  * - \ref SCIP_STAGE_PROBLEM
503  * - \ref SCIP_STAGE_TRANSFORMING
504  * - \ref SCIP_STAGE_TRANSFORMED
505  * - \ref SCIP_STAGE_INITPRESOLVE
506  * - \ref SCIP_STAGE_PRESOLVING
507  * - \ref SCIP_STAGE_EXITPRESOLVE
508  * - \ref SCIP_STAGE_PRESOLVED
509  * - \ref SCIP_STAGE_INITSOLVE
510  * - \ref SCIP_STAGE_SOLVING
511  * - \ref SCIP_STAGE_SOLVED
512  * - \ref SCIP_STAGE_EXITSOLVE
513  * - \ref SCIP_STAGE_FREETRANS
514  *
515  * @note the pointer of the variable will be NULLed
516  */
517 extern
518 SCIP_RETCODE SCIPreleaseVar(
519  SCIP* scip, /**< SCIP data structure */
520  SCIP_VAR** var /**< pointer to variable */
521  );
522 
523 /** changes the name of a variable
524  *
525  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
526  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
527  *
528  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_PROBLEM
529  *
530  * @note to get the current name of a variable, use SCIPvarGetName() from pub_var.h
531  */
532 extern
533 SCIP_RETCODE SCIPchgVarName(
534  SCIP* scip, /**< SCIP data structure */
535  SCIP_VAR* var, /**< variable */
536  const char* name /**< new name of constraint */
537  );
538 
539 /** gets and captures transformed variable of a given variable; if the variable is not yet transformed,
540  * a new transformed variable for this variable is created
541  *
542  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
543  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
544  *
545  * @pre This method can be called if @p scip is in one of the following stages:
546  * - \ref SCIP_STAGE_TRANSFORMING
547  * - \ref SCIP_STAGE_TRANSFORMED
548  * - \ref SCIP_STAGE_INITPRESOLVE
549  * - \ref SCIP_STAGE_PRESOLVING
550  * - \ref SCIP_STAGE_EXITPRESOLVE
551  * - \ref SCIP_STAGE_PRESOLVED
552  * - \ref SCIP_STAGE_INITSOLVE
553  * - \ref SCIP_STAGE_SOLVING
554  */
555 extern
556 SCIP_RETCODE SCIPtransformVar(
557  SCIP* scip, /**< SCIP data structure */
558  SCIP_VAR* var, /**< variable to get/create transformed variable for */
559  SCIP_VAR** transvar /**< pointer to store the transformed variable */
560  );
561 
562 /** gets and captures transformed variables for an array of variables;
563  * if a variable of the array is not yet transformed, a new transformed variable for this variable is created;
564  * it is possible to call this method with vars == transvars
565  *
566  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
567  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
568  *
569  * @pre This method can be called if @p scip is in one of the following stages:
570  * - \ref SCIP_STAGE_TRANSFORMING
571  * - \ref SCIP_STAGE_TRANSFORMED
572  * - \ref SCIP_STAGE_INITPRESOLVE
573  * - \ref SCIP_STAGE_PRESOLVING
574  * - \ref SCIP_STAGE_EXITPRESOLVE
575  * - \ref SCIP_STAGE_PRESOLVED
576  * - \ref SCIP_STAGE_INITSOLVE
577  * - \ref SCIP_STAGE_SOLVING
578  */
579 extern
580 SCIP_RETCODE SCIPtransformVars(
581  SCIP* scip, /**< SCIP data structure */
582  int nvars, /**< number of variables to get/create transformed variables for */
583  SCIP_VAR** vars, /**< array with variables to get/create transformed variables for */
584  SCIP_VAR** transvars /**< array to store the transformed variables */
585  );
586 
587 /** gets corresponding transformed variable of a given variable;
588  * returns NULL as transvar, if transformed variable is not yet existing
589  *
590  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
591  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
592  *
593  * @pre This method can be called if @p scip is in one of the following stages:
594  * - \ref SCIP_STAGE_TRANSFORMING
595  * - \ref SCIP_STAGE_TRANSFORMED
596  * - \ref SCIP_STAGE_INITPRESOLVE
597  * - \ref SCIP_STAGE_PRESOLVING
598  * - \ref SCIP_STAGE_EXITPRESOLVE
599  * - \ref SCIP_STAGE_PRESOLVED
600  * - \ref SCIP_STAGE_INITSOLVE
601  * - \ref SCIP_STAGE_SOLVING
602  * - \ref SCIP_STAGE_SOLVED
603  * - \ref SCIP_STAGE_EXITSOLVE
604  * - \ref SCIP_STAGE_FREETRANS
605  */
606 extern
607 SCIP_RETCODE SCIPgetTransformedVar(
608  SCIP* scip, /**< SCIP data structure */
609  SCIP_VAR* var, /**< variable to get transformed variable for */
610  SCIP_VAR** transvar /**< pointer to store the transformed variable */
611  );
612 
613 /** gets corresponding transformed variables for an array of variables;
614  * stores NULL in a transvars slot, if the transformed variable is not yet existing;
615  * it is possible to call this method with vars == transvars, but remember that variables that are not
616  * yet transformed will be replaced with NULL
617  *
618  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
619  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
620  *
621  * @pre This method can be called if @p scip is in one of the following stages:
622  * - \ref SCIP_STAGE_TRANSFORMING
623  * - \ref SCIP_STAGE_TRANSFORMED
624  * - \ref SCIP_STAGE_INITPRESOLVE
625  * - \ref SCIP_STAGE_PRESOLVING
626  * - \ref SCIP_STAGE_EXITPRESOLVE
627  * - \ref SCIP_STAGE_PRESOLVED
628  * - \ref SCIP_STAGE_INITSOLVE
629  * - \ref SCIP_STAGE_SOLVING
630  * - \ref SCIP_STAGE_SOLVED
631  * - \ref SCIP_STAGE_EXITSOLVE
632  * - \ref SCIP_STAGE_FREETRANS
633  */
634 extern
635 SCIP_RETCODE SCIPgetTransformedVars(
636  SCIP* scip, /**< SCIP data structure */
637  int nvars, /**< number of variables to get transformed variables for */
638  SCIP_VAR** vars, /**< array with variables to get transformed variables for */
639  SCIP_VAR** transvars /**< array to store the transformed variables */
640  );
641 
642 /** gets negated variable x' = lb + ub - x of variable x; negated variable is created, if not yet existing
643  *
644  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
645  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
646  *
647  * @pre This method can be called if @p scip is in one of the following stages:
648  * - \ref SCIP_STAGE_PROBLEM
649  * - \ref SCIP_STAGE_TRANSFORMING
650  * - \ref SCIP_STAGE_TRANSFORMED
651  * - \ref SCIP_STAGE_INITPRESOLVE
652  * - \ref SCIP_STAGE_PRESOLVING
653  * - \ref SCIP_STAGE_EXITPRESOLVE
654  * - \ref SCIP_STAGE_PRESOLVED
655  * - \ref SCIP_STAGE_INITSOLVE
656  * - \ref SCIP_STAGE_SOLVING
657  * - \ref SCIP_STAGE_SOLVED
658  * - \ref SCIP_STAGE_EXITSOLVE
659  * - \ref SCIP_STAGE_FREETRANS
660  */
661 extern
662 SCIP_RETCODE SCIPgetNegatedVar(
663  SCIP* scip, /**< SCIP data structure */
664  SCIP_VAR* var, /**< variable to get negated variable for */
665  SCIP_VAR** negvar /**< pointer to store the negated variable */
666  );
667 
668 /** gets negated variables x' = lb + ub - x of variables x; negated variables are created, if not yet existing;
669  * in difference to \ref SCIPcreateVar, the negated variable must not be released (unless captured explicitly)
670  *
671  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
672  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
673  *
674  * @pre This method can be called if @p scip is in one of the following stages:
675  * - \ref SCIP_STAGE_PROBLEM
676  * - \ref SCIP_STAGE_TRANSFORMING
677  * - \ref SCIP_STAGE_TRANSFORMED
678  * - \ref SCIP_STAGE_INITPRESOLVE
679  * - \ref SCIP_STAGE_PRESOLVING
680  * - \ref SCIP_STAGE_EXITPRESOLVE
681  * - \ref SCIP_STAGE_PRESOLVED
682  * - \ref SCIP_STAGE_INITSOLVE
683  * - \ref SCIP_STAGE_SOLVING
684  * - \ref SCIP_STAGE_SOLVED
685  * - \ref SCIP_STAGE_EXITSOLVE
686  * - \ref SCIP_STAGE_FREETRANS
687  */
688 extern
689 SCIP_RETCODE SCIPgetNegatedVars(
690  SCIP* scip, /**< SCIP data structure */
691  int nvars, /**< number of variables to get negated variables for */
692  SCIP_VAR** vars, /**< array of variables to get negated variables for */
693  SCIP_VAR** negvars /**< array to store the negated variables */
694  );
695 
696 /** gets a binary variable that is equal to the given binary variable, and that is either active, fixed, or
697  * multi-aggregated, or the negated variable of an active, fixed, or multi-aggregated variable
698  *
699  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
700  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
701  *
702  * @pre This method can be called if @p scip is in one of the following stages:
703  * - \ref SCIP_STAGE_PROBLEM
704  * - \ref SCIP_STAGE_TRANSFORMED
705  * - \ref SCIP_STAGE_INITPRESOLVE
706  * - \ref SCIP_STAGE_PRESOLVING
707  * - \ref SCIP_STAGE_EXITPRESOLVE
708  * - \ref SCIP_STAGE_PRESOLVED
709  * - \ref SCIP_STAGE_INITSOLVE
710  * - \ref SCIP_STAGE_SOLVING
711  * - \ref SCIP_STAGE_SOLVED
712  * - \ref SCIP_STAGE_EXITSOLVE
713  */
714 extern
715 SCIP_RETCODE SCIPgetBinvarRepresentative(
716  SCIP* scip, /**< SCIP data structure */
717  SCIP_VAR* var, /**< binary variable to get binary representative for */
718  SCIP_VAR** repvar, /**< pointer to store the binary representative */
719  SCIP_Bool* negated /**< pointer to store whether the negation of an active variable was returned */
720  );
721 
722 /** gets binary variables that are equal to the given binary variables, and which are either active, fixed, or
723  * multi-aggregated, or the negated variables of active, fixed, or multi-aggregated variables
724  *
725  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
726  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
727  *
728  * @pre This method can be called if @p scip is in one of the following stages:
729  * - \ref SCIP_STAGE_PROBLEM
730  * - \ref SCIP_STAGE_TRANSFORMED
731  * - \ref SCIP_STAGE_INITPRESOLVE
732  * - \ref SCIP_STAGE_PRESOLVING
733  * - \ref SCIP_STAGE_EXITPRESOLVE
734  * - \ref SCIP_STAGE_PRESOLVED
735  * - \ref SCIP_STAGE_INITSOLVE
736  * - \ref SCIP_STAGE_SOLVING
737  * - \ref SCIP_STAGE_SOLVED
738  * - \ref SCIP_STAGE_EXITSOLVE
739  */
740 extern
741 SCIP_RETCODE SCIPgetBinvarRepresentatives(
742  SCIP* scip, /**< SCIP data structure */
743  int nvars, /**< number of binary variables to get representatives for */
744  SCIP_VAR** vars, /**< binary variables to get binary representatives for */
745  SCIP_VAR** repvars, /**< array to store the binary representatives */
746  SCIP_Bool* negated /**< array to store whether the negation of an active variable was returned */
747  );
748 
749 /** flattens aggregation graph of multi-aggregated variable in order to avoid exponential recursion later on
750  *
751  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
752  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
753  *
754  * @pre This method can be called if @p scip is in one of the following stages:
755  * - \ref SCIP_STAGE_INITPRESOLVE
756  * - \ref SCIP_STAGE_PRESOLVING
757  * - \ref SCIP_STAGE_EXITPRESOLVE
758  * - \ref SCIP_STAGE_PRESOLVED
759  * - \ref SCIP_STAGE_INITSOLVE
760  * - \ref SCIP_STAGE_SOLVING
761  * - \ref SCIP_STAGE_SOLVED
762  */
763 extern
764 SCIP_RETCODE SCIPflattenVarAggregationGraph(
765  SCIP* scip, /**< SCIP data structure */
766  SCIP_VAR* var /**< problem variable */
767  );
768 
769 /** Transforms a given linear sum of variables, that is a_1*x_1 + ... + a_n*x_n + c into a corresponding linear sum of
770  * active variables, that is b_1*y_1 + ... + b_m*y_m + d.
771  *
772  * If the number of needed active variables is greater than the available slots in the variable array, nothing happens
773  * except that the required size is stored in the corresponding variable (requiredsize). Otherwise, the active variable
774  * representation is stored in the variable array, scalar array and constant.
775  *
776  * The reason for this approach is that we cannot reallocate memory, since we do not know how the memory has been
777  * allocated (e.g., by a C++ 'new' or SCIP functions).
778  *
779  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
780  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
781  *
782  * @pre This method can be called if @p scip is in one of the following stages:
783  * - \ref SCIP_STAGE_TRANSFORMED
784  * - \ref SCIP_STAGE_INITPRESOLVE
785  * - \ref SCIP_STAGE_PRESOLVING
786  * - \ref SCIP_STAGE_EXITPRESOLVE
787  * - \ref SCIP_STAGE_PRESOLVED
788  * - \ref SCIP_STAGE_INITSOLVE
789  * - \ref SCIP_STAGE_SOLVING
790  * - \ref SCIP_STAGE_SOLVED
791  * - \ref SCIP_STAGE_EXITSOLVE
792  * - \ref SCIP_STAGE_FREETRANS
793  *
794  * @note The resulting linear sum is stored into the given variable array, scalar array, and constant. That means the
795  * given entries are overwritten.
796  *
797  * @note That method can be used to convert a single variables into variable space of active variables. Therefore call
798  * the method with the linear sum 1.0*x + 0.0.
799  */
800 extern
801 SCIP_RETCODE SCIPgetProbvarLinearSum(
802  SCIP* scip, /**< SCIP data structure */
803  SCIP_VAR** vars, /**< variable array x_1, ..., x_n in the linear sum which will be
804  * overwritten by the variable array y_1, ..., y_m in the linear sum
805  * w.r.t. active variables */
806  SCIP_Real* scalars, /**< scalars a_1, ..., a_n in linear sum which will be overwritten to the
807  * scalars b_1, ..., b_m in the linear sum of the active variables */
808  int* nvars, /**< pointer to number of variables in the linear sum which will be
809  * overwritten by the number of variables in the linear sum corresponding
810  * to the active variables */
811  int varssize, /**< available slots in vars and scalars array which is needed to check if
812  * the array are large enough for the linear sum w.r.t. active
813  * variables */
814  SCIP_Real* constant, /**< pointer to constant c in linear sum a_1*x_1 + ... + a_n*x_n + c which
815  * will chnage to constant d in the linear sum b_1*y_1 + ... + b_m*y_m +
816  * d w.r.t. the active variables */
817  int* requiredsize, /**< pointer to store the required array size for the linear sum w.r.t. the
818  * active variables */
819  SCIP_Bool mergemultiples /**< should multiple occurrences of a var be replaced by a single coeff? */
820  );
821 
822 /** transforms given variable, scalar and constant to the corresponding active, fixed, or
823  * multi-aggregated variable, scalar and constant; if the variable resolves to a fixed variable,
824  * "scalar" will be 0.0 and the value of the sum will be stored in "constant"; a multi-aggregation
825  * with only one active variable (this can happen due to fixings after the multi-aggregation),
826  * is treated like an aggregation; if the multi-aggregation constant is infinite, "scalar" will be 0.0
827  *
828  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
829  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
830  *
831  * @pre This method can be called if @p scip is in one of the following stages:
832  * - \ref SCIP_STAGE_TRANSFORMED
833  * - \ref SCIP_STAGE_INITPRESOLVE
834  * - \ref SCIP_STAGE_PRESOLVING
835  * - \ref SCIP_STAGE_EXITPRESOLVE
836  * - \ref SCIP_STAGE_PRESOLVED
837  * - \ref SCIP_STAGE_INITSOLVE
838  * - \ref SCIP_STAGE_SOLVING
839  * - \ref SCIP_STAGE_SOLVED
840  * - \ref SCIP_STAGE_EXITSOLVE
841  * - \ref SCIP_STAGE_FREETRANS
842  */
843 extern
844 SCIP_RETCODE SCIPgetProbvarSum(
845  SCIP* scip, /**< SCIP data structure */
846  SCIP_VAR** var, /**< pointer to problem variable x in sum a*x + c */
847  SCIP_Real* scalar, /**< pointer to scalar a in sum a*x + c */
848  SCIP_Real* constant /**< pointer to constant c in sum a*x + c */
849  );
850 
851 /** return for given variables all their active counterparts; all active variables will be pairwise different
852  * @note It does not hold that the first output variable is the active variable for the first input variable.
853  *
854  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
855  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
856  *
857  * @pre This method can be called if @p scip is in one of the following stages:
858  * - \ref SCIP_STAGE_TRANSFORMED
859  * - \ref SCIP_STAGE_INITPRESOLVE
860  * - \ref SCIP_STAGE_PRESOLVING
861  * - \ref SCIP_STAGE_EXITPRESOLVE
862  * - \ref SCIP_STAGE_PRESOLVED
863  * - \ref SCIP_STAGE_INITSOLVE
864  * - \ref SCIP_STAGE_SOLVING
865  * - \ref SCIP_STAGE_SOLVED
866  * - \ref SCIP_STAGE_EXITSOLVE
867  * - \ref SCIP_STAGE_FREETRANS
868  */
869 extern
870 SCIP_RETCODE SCIPgetActiveVars(
871  SCIP* scip, /**< SCIP data structure */
872  SCIP_VAR** vars, /**< variable array with given variables and as output all active
873  * variables, if enough slots exist */
874  int* nvars, /**< number of given variables, and as output number of active variables,
875  * if enough slots exist */
876  int varssize, /**< available slots in vars array */
877  int* requiredsize /**< pointer to store the required array size for the active variables */
878  );
879 
880 /** returns the reduced costs of the variable in the current node's LP relaxation;
881  * the current node has to have a feasible LP.
882  *
883  * returns SCIP_INVALID if the variable is active but not in the current LP;
884  * returns 0 if the variable has been aggregated out or fixed in presolving.
885  *
886  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
887  *
888  * @note The return value of this method should be used carefully if the dual feasibility check was explictely disabled.
889  */
890 extern
891 SCIP_Real SCIPgetVarRedcost(
892  SCIP* scip, /**< SCIP data structure */
893  SCIP_VAR* var /**< variable to get reduced costs, should be a column in current node LP */
894  );
895 
896 /** returns the implied reduced costs of the variable in the current node's LP relaxation;
897  * the current node has to have a feasible LP.
898  *
899  * returns SCIP_INVALID if the variable is active but not in the current LP;
900  * returns 0 if the variable has been aggregated out or fixed in presolving.
901  *
902  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
903  *
904  * @note The return value of this method should be used carefully if the dual feasibility check was explictely disabled.
905  */
906 extern
907 SCIP_Real SCIPgetVarImplRedcost(
908  SCIP* scip, /**< SCIP data structure */
909  SCIP_VAR* var, /**< variable to get reduced costs, should be a column in current node LP */
910  SCIP_Bool varfixing /**< FALSE if for x == 0, TRUE for x == 1 */
911  );
912 
913 /** returns the Farkas coefficient of the variable in the current node's LP relaxation;
914  * the current node has to have an infeasible LP.
915  *
916  * returns SCIP_INVALID if the variable is active but not in the current LP;
917  * returns 0 if the variable has been aggregated out or fixed in presolving.
918  *
919  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
920  */
921 extern
922 SCIP_Real SCIPgetVarFarkasCoef(
923  SCIP* scip, /**< SCIP data structure */
924  SCIP_VAR* var /**< variable to get reduced costs, should be a column in current node LP */
925  );
926 
927 /** returns lower bound of variable directly before or after the bound change given by the bound change index
928  * was applied
929  */
930 extern
931 SCIP_Real SCIPgetVarLbAtIndex(
932  SCIP* scip, /**< SCIP data structure */
933  SCIP_VAR* var, /**< problem variable */
934  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
935  SCIP_Bool after /**< should the bound change with given index be included? */
936  );
937 
938 /** returns upper bound of variable directly before or after the bound change given by the bound change index
939  * was applied
940  */
941 extern
942 SCIP_Real SCIPgetVarUbAtIndex(
943  SCIP* scip, /**< SCIP data structure */
944  SCIP_VAR* var, /**< problem variable */
945  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
946  SCIP_Bool after /**< should the bound change with given index be included? */
947  );
948 
949 /** returns lower or upper bound of variable directly before or after the bound change given by the bound change index
950  * was applied
951  */
952 extern
953 SCIP_Real SCIPgetVarBdAtIndex(
954  SCIP* scip, /**< SCIP data structure */
955  SCIP_VAR* var, /**< problem variable */
956  SCIP_BOUNDTYPE boundtype, /**< type of bound: lower or upper bound */
957  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
958  SCIP_Bool after /**< should the bound change with given index be included? */
959  );
960 
961 /** returns whether the binary variable was fixed at the time given by the bound change index */
962 extern
963 SCIP_Bool SCIPgetVarWasFixedAtIndex(
964  SCIP* scip, /**< SCIP data structure */
965  SCIP_VAR* var, /**< problem variable */
966  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
967  SCIP_Bool after /**< should the bound change with given index be included? */
968  );
969 
970 /** gets solution value for variable in current node
971  *
972  * @return solution value for variable in current node
973  *
974  * @pre This method can be called if @p scip is in one of the following stages:
975  * - \ref SCIP_STAGE_PRESOLVED
976  * - \ref SCIP_STAGE_SOLVING
977  */
978 extern
979 SCIP_Real SCIPgetVarSol(
980  SCIP* scip, /**< SCIP data structure */
981  SCIP_VAR* var /**< variable to get solution value for */
982  );
983 
984 /** gets solution values of multiple variables in current node
985  *
986  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
987  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
988  *
989  * @pre This method can be called if @p scip is in one of the following stages:
990  * - \ref SCIP_STAGE_PRESOLVED
991  * - \ref SCIP_STAGE_SOLVING
992  */
993 extern
994 SCIP_RETCODE SCIPgetVarSols(
995  SCIP* scip, /**< SCIP data structure */
996  int nvars, /**< number of variables to get solution value for */
997  SCIP_VAR** vars, /**< array with variables to get value for */
998  SCIP_Real* vals /**< array to store solution values of variables */
999  );
1000 
1001 /** sets the solution value of all variables in the global relaxation solution to zero
1002  *
1003  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1004  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1005  *
1006  * @pre This method can be called if @p scip is in one of the following stages:
1007  * - \ref SCIP_STAGE_PRESOLVED
1008  * - \ref SCIP_STAGE_SOLVING
1009  */
1010 extern
1011 SCIP_RETCODE SCIPclearRelaxSolVals(
1012  SCIP* scip /**< SCIP data structure */
1013  );
1014 
1015 /** sets the value of the given variable in the global relaxation solution;
1016  * this solution can be filled by the relaxation handlers and can be used by heuristics and for separation;
1017  * You can use SCIPclearRelaxSolVals() to set all values to zero, initially;
1018  * after setting all solution values, you have to call SCIPmarkRelaxSolValid()
1019  * to inform SCIP that the stored solution is valid
1020  *
1021  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1022  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1023  *
1024  * @pre This method can be called if @p scip is in one of the following stages:
1025  * - \ref SCIP_STAGE_PRESOLVED
1026  * - \ref SCIP_STAGE_SOLVING
1027  *
1028  * @note This method incrementally updates the objective value of the relaxation solution. If the whole solution
1029  * should be updated, using SCIPsetRelaxSolVals() instead or calling SCIPclearRelaxSolVals() before setting
1030  * the first value to reset the solution and the objective value to 0 may help the numerics.
1031  */
1032 extern
1033 SCIP_RETCODE SCIPsetRelaxSolVal(
1034  SCIP* scip, /**< SCIP data structure */
1035  SCIP_VAR* var, /**< variable to set value for */
1036  SCIP_Real val /**< solution value of variable */
1037  );
1038 
1039 /** sets the values of the given variables in the global relaxation solution and informs SCIP about the validity
1040  * and whether the solution can be enforced via linear cuts;
1041  * this solution can be filled by the relaxation handlers and can be used by heuristics and for separation;
1042  * the solution is automatically cleared, s.t. all other variables get value 0.0
1043  *
1044  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1045  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1046  *
1047  * @pre This method can be called if @p scip is in one of the following stages:
1048  * - \ref SCIP_STAGE_PRESOLVED
1049  * - \ref SCIP_STAGE_SOLVING
1050  */
1051 extern
1052 SCIP_RETCODE SCIPsetRelaxSolVals(
1053  SCIP* scip, /**< SCIP data structure */
1054  int nvars, /**< number of variables to set relaxation solution value for */
1055  SCIP_VAR** vars, /**< array with variables to set value for */
1056  SCIP_Real* vals, /**< array with solution values of variables */
1057  SCIP_Bool includeslp /**< does the relaxator contain all cuts in the LP? */
1058  );
1059 
1060 /** sets the values of the variables in the global relaxation solution to the values in the given primal solution
1061  * and informs SCIP about the validity and whether the solution can be enforced via linear cuts;
1062  * the relaxation solution can be filled by the relaxation handlers and might be used by heuristics and for separation
1063  *
1064  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1065  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1066  *
1067  * @pre This method can be called if @p scip is in one of the following stages:
1068  * - \ref SCIP_STAGE_PRESOLVED
1069  * - \ref SCIP_STAGE_SOLVING
1070  */
1071 extern
1072 SCIP_RETCODE SCIPsetRelaxSolValsSol(
1073  SCIP* scip, /**< SCIP data structure */
1074  SCIP_SOL* sol, /**< primal relaxation solution */
1075  SCIP_Bool includeslp /**< does the relaxator contain all cuts in the LP? */
1076  );
1077 
1078 /** returns whether the relaxation solution is valid
1079  *
1080  * @return TRUE, if the relaxation solution is valid; FALSE, otherwise
1081  *
1082  * @pre This method can be called if @p scip is in one of the following stages:
1083  * - \ref SCIP_STAGE_PRESOLVED
1084  * - \ref SCIP_STAGE_SOLVING
1085  */
1086 extern
1087 SCIP_Bool SCIPisRelaxSolValid(
1088  SCIP* scip /**< SCIP data structure */
1089  );
1090 
1091 /** informs SCIP that the relaxation solution is valid and whether the relaxation can be enforced through linear cuts
1092  *
1093  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1094  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1095  *
1096  * @pre This method can be called if @p scip is in one of the following stages:
1097  * - \ref SCIP_STAGE_PRESOLVED
1098  * - \ref SCIP_STAGE_SOLVING
1099  */
1100 extern
1101 SCIP_RETCODE SCIPmarkRelaxSolValid(
1102  SCIP* scip, /**< SCIP data structure */
1103  SCIP_Bool includeslp /**< does the relaxator contain all cuts in the LP? */
1104  );
1105 
1106 /** informs SCIP, that the relaxation solution is invalid
1107  *
1108  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1109  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1110  *
1111  * @pre This method can be called if @p scip is in one of the following stages:
1112  * - \ref SCIP_STAGE_PRESOLVED
1113  * - \ref SCIP_STAGE_SOLVING
1114  */
1115 extern
1116 SCIP_RETCODE SCIPmarkRelaxSolInvalid(
1117  SCIP* scip /**< SCIP data structure */
1118  );
1119 
1120 /** gets the relaxation solution value of the given variable
1121  *
1122  * @return the relaxation solution value of the given variable
1123  *
1124  * @pre This method can be called if @p scip is in one of the following stages:
1125  * - \ref SCIP_STAGE_PRESOLVED
1126  * - \ref SCIP_STAGE_SOLVING
1127  */
1128 extern
1129 SCIP_Real SCIPgetRelaxSolVal(
1130  SCIP* scip, /**< SCIP data structure */
1131  SCIP_VAR* var /**< variable to get value for */
1132  );
1133 
1134 /** gets the relaxation solution objective value
1135  *
1136  * @return the objective value of the relaxation solution
1137  *
1138  * @pre This method can be called if @p scip is in one of the following stages:
1139  * - \ref SCIP_STAGE_PRESOLVED
1140  * - \ref SCIP_STAGE_SOLVING
1141  */
1142 extern
1143 SCIP_Real SCIPgetRelaxSolObj(
1144  SCIP* scip /**< SCIP data structure */
1145  );
1146 
1147 /** determine which branching direction should be evaluated first by strong branching
1148  *
1149  * @return TRUE iff strong branching should first evaluate the down child
1150  *
1151  */
1152 extern
1153 SCIP_Bool SCIPisStrongbranchDownFirst(
1154  SCIP* scip, /**< SCIP data structure */
1155  SCIP_VAR* var /**< variable to determine the branching direction on */
1156  );
1157 
1158 /** start strong branching - call before any strong branching
1159  *
1160  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1161  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1162  *
1163  * @pre This method can be called if @p scip is in one of the following stages:
1164  * - \ref SCIP_STAGE_PRESOLVED
1165  * - \ref SCIP_STAGE_SOLVING
1166  *
1167  * @note if propagation is enabled, strong branching is not done directly on the LP, but probing nodes are created
1168  * which allow to perform propagation but also creates some overhead
1169  */
1170 extern
1171 SCIP_RETCODE SCIPstartStrongbranch(
1172  SCIP* scip, /**< SCIP data structure */
1173  SCIP_Bool enablepropagation /**< should propagation be done before solving the strong branching LP? */
1174  );
1175 
1176 /** end strong branching - call after any strong branching
1177  *
1178  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1179  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1180  *
1181  * @pre This method can be called if @p scip is in one of the following stages:
1182  * - \ref SCIP_STAGE_PRESOLVED
1183  * - \ref SCIP_STAGE_SOLVING
1184  */
1185 extern
1186 SCIP_RETCODE SCIPendStrongbranch(
1187  SCIP* scip /**< SCIP data structure */
1188  );
1189 
1190 /** gets strong branching information on column variable with fractional value
1191  *
1192  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1193  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1194  *
1195  * @pre This method can be called if @p scip is in one of the following stages:
1196  * - \ref SCIP_STAGE_PRESOLVED
1197  * - \ref SCIP_STAGE_SOLVING
1198  */
1199 extern
1200 SCIP_RETCODE SCIPgetVarStrongbranchFrac(
1201  SCIP* scip, /**< SCIP data structure */
1202  SCIP_VAR* var, /**< variable to get strong branching values for */
1203  int itlim, /**< iteration limit for strong branchings */
1204  SCIP_Real* down, /**< stores dual bound after branching column down */
1205  SCIP_Real* up, /**< stores dual bound after branching column up */
1206  SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL;
1207  * otherwise, it can only be used as an estimate value */
1208  SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound, or NULL;
1209  * otherwise, it can only be used as an estimate value */
1210  SCIP_Bool* downinf, /**< pointer to store whether the downwards branch is infeasible, or NULL */
1211  SCIP_Bool* upinf, /**< pointer to store whether the upwards branch is infeasible, or NULL */
1212  SCIP_Bool* downconflict, /**< pointer to store whether a conflict constraint was created for an
1213  * infeasible downwards branch, or NULL */
1214  SCIP_Bool* upconflict, /**< pointer to store whether a conflict constraint was created for an
1215  * infeasible upwards branch, or NULL */
1216  SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred or the
1217  * solving process should be stopped (e.g., due to a time limit) */
1218  );
1219 
1220 /** gets strong branching information with previous domain propagation on column variable
1221  *
1222  * Before calling this method, the strong branching mode must have been activated by calling SCIPstartStrongbranch();
1223  * after strong branching was done for all candidate variables, the strong branching mode must be ended by
1224  * SCIPendStrongbranch(). Since this method applies domain propagation before strongbranching, propagation has to be be
1225  * enabled in the SCIPstartStrongbranch() call.
1226  *
1227  * Before solving the strong branching LP, domain propagation can be performed. The number of propagation rounds
1228  * can be specified by the parameter @p maxproprounds.
1229  *
1230  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1231  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1232  *
1233  * @pre This method can be called if @p scip is in one of the following stages:
1234  * - \ref SCIP_STAGE_PRESOLVED
1235  * - \ref SCIP_STAGE_SOLVING
1236  *
1237  * @warning When using this method, LP banching candidates and solution values must be copied beforehand, because
1238  * they are updated w.r.t. the strong branching LP solution.
1239  */
1240 extern
1241 SCIP_RETCODE SCIPgetVarStrongbranchWithPropagation(
1242  SCIP* scip, /**< SCIP data structure */
1243  SCIP_VAR* var, /**< variable to get strong branching values for */
1244  SCIP_Real solval, /**< value of the variable in the current LP solution */
1245  SCIP_Real lpobjval, /**< LP objective value of the current LP solution */
1246  int itlim, /**< iteration limit for strong branchings */
1247  int maxproprounds, /**< maximum number of propagation rounds (-1: no limit, -2: parameter
1248  * settings) */
1249  SCIP_Real* down, /**< stores dual bound after branching column down */
1250  SCIP_Real* up, /**< stores dual bound after branching column up */
1251  SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL;
1252  * otherwise, it can only be used as an estimate value */
1253  SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound, or NULL;
1254  * otherwise, it can only be used as an estimate value */
1255  SCIP_Longint* ndomredsdown, /**< pointer to store the number of domain reductions down, or NULL */
1256  SCIP_Longint* ndomredsup, /**< pointer to store the number of domain reductions up, or NULL */
1257  SCIP_Bool* downinf, /**< pointer to store whether the downwards branch is infeasible, or NULL */
1258  SCIP_Bool* upinf, /**< pointer to store whether the upwards branch is infeasible, or NULL */
1259  SCIP_Bool* downconflict, /**< pointer to store whether a conflict constraint was created for an
1260  * infeasible downwards branch, or NULL */
1261  SCIP_Bool* upconflict, /**< pointer to store whether a conflict constraint was created for an
1262  * infeasible upwards branch, or NULL */
1263  SCIP_Bool* lperror, /**< pointer to store whether an unresolved LP error occurred or the
1264  * solving process should be stopped (e.g., due to a time limit) */
1265  SCIP_Real* newlbs, /**< array to store valid lower bounds for all active variables, or NULL */
1266  SCIP_Real* newubs /**< array to store valid upper bounds for all active variables, or NULL */
1267  );
1268 
1269 /** gets strong branching information on column variable x with integral LP solution value (val); that is, the down branch
1270  * is (val -1.0) and the up brach ins (val +1.0)
1271  *
1272  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1273  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1274  *
1275  * @pre This method can be called if @p scip is in one of the following stages:
1276  * - \ref SCIP_STAGE_PRESOLVED
1277  * - \ref SCIP_STAGE_SOLVING
1278  *
1279  * @note If the integral LP solution value is the lower or upper bound of the variable, the corresponding branch will be
1280  * marked as infeasible. That is, the valid pointer and the infeasible pointer are set to TRUE.
1281  */
1282 extern
1283 SCIP_RETCODE SCIPgetVarStrongbranchInt(
1284  SCIP* scip, /**< SCIP data structure */
1285  SCIP_VAR* var, /**< variable to get strong branching values for */
1286  int itlim, /**< iteration limit for strong branchings */
1287  SCIP_Real* down, /**< stores dual bound after branching column down */
1288  SCIP_Real* up, /**< stores dual bound after branching column up */
1289  SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL;
1290  * otherwise, it can only be used as an estimate value */
1291  SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound, or NULL;
1292  * otherwise, it can only be used as an estimate value */
1293  SCIP_Bool* downinf, /**< pointer to store whether the downwards branch is infeasible, or NULL */
1294  SCIP_Bool* upinf, /**< pointer to store whether the upwards branch is infeasible, or NULL */
1295  SCIP_Bool* downconflict, /**< pointer to store whether a conflict constraint was created for an
1296  * infeasible downwards branch, or NULL */
1297  SCIP_Bool* upconflict, /**< pointer to store whether a conflict constraint was created for an
1298  * infeasible upwards branch, or NULL */
1299  SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred or the
1300  * solving process should be stopped (e.g., due to a time limit) */
1301  );
1302 
1303 /** gets strong branching information on column variables with fractional values
1304  *
1305  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1306  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1307  *
1308  * @pre This method can be called if @p scip is in one of the following stages:
1309  * - \ref SCIP_STAGE_PRESOLVED
1310  * - \ref SCIP_STAGE_SOLVING
1311  */
1312 extern
1313 SCIP_RETCODE SCIPgetVarsStrongbranchesFrac(
1314  SCIP* scip, /**< SCIP data structure */
1315  SCIP_VAR** vars, /**< variables to get strong branching values for */
1316  int nvars, /**< number of variables */
1317  int itlim, /**< iteration limit for strong branchings */
1318  SCIP_Real* down, /**< stores dual bounds after branching variables down */
1319  SCIP_Real* up, /**< stores dual bounds after branching variables up */
1320  SCIP_Bool* downvalid, /**< stores whether the returned down values are valid dual bounds, or NULL;
1321  * otherwise, they can only be used as an estimate value */
1322  SCIP_Bool* upvalid, /**< stores whether the returned up values are valid dual bounds, or NULL;
1323  * otherwise, they can only be used as an estimate value */
1324  SCIP_Bool* downinf, /**< array to store whether the downward branches are infeasible, or NULL */
1325  SCIP_Bool* upinf, /**< array to store whether the upward branches are infeasible, or NULL */
1326  SCIP_Bool* downconflict, /**< array to store whether conflict constraints were created for
1327  * infeasible downward branches, or NULL */
1328  SCIP_Bool* upconflict, /**< array to store whether conflict constraints were created for
1329  * infeasible upward branches, or NULL */
1330  SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred or the
1331  * solving process should be stopped (e.g., due to a time limit) */
1332  );
1333 
1334 /** gets strong branching information on column variables with integral values
1335  *
1336  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1337  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1338  *
1339  * @pre This method can be called if @p scip is in one of the following stages:
1340  * - \ref SCIP_STAGE_PRESOLVED
1341  * - \ref SCIP_STAGE_SOLVING
1342  */
1343 extern
1344 SCIP_RETCODE SCIPgetVarsStrongbranchesInt(
1345  SCIP* scip, /**< SCIP data structure */
1346  SCIP_VAR** vars, /**< variables to get strong branching values for */
1347  int nvars, /**< number of variables */
1348  int itlim, /**< iteration limit for strong branchings */
1349  SCIP_Real* down, /**< stores dual bounds after branching variables down */
1350  SCIP_Real* up, /**< stores dual bounds after branching variables up */
1351  SCIP_Bool* downvalid, /**< stores whether the returned down values are valid dual bounds, or NULL;
1352  * otherwise, they can only be used as an estimate value */
1353  SCIP_Bool* upvalid, /**< stores whether the returned up values are valid dual bounds, or NULL;
1354  * otherwise, they can only be used as an estimate value */
1355  SCIP_Bool* downinf, /**< array to store whether the downward branches are infeasible, or NULL */
1356  SCIP_Bool* upinf, /**< array to store whether the upward branches are infeasible, or NULL */
1357  SCIP_Bool* downconflict, /**< array to store whether conflict constraints were created for
1358  * infeasible downward branches, or NULL */
1359  SCIP_Bool* upconflict, /**< array to store whether conflict constraints were created for
1360  * infeasible upward branches, or NULL */
1361  SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred or the
1362  * solving process should be stopped (e.g., due to a time limit) */
1363  );
1364 
1365 /** get LP solution status of last strong branching call (currently only works for strong branching with propagation) */
1366 extern
1367 SCIP_LPSOLSTAT SCIPgetLastStrongbranchLPSolStat(
1368  SCIP* scip, /**< SCIP data structure */
1369  SCIP_BRANCHDIR branchdir /**< branching direction for which LP solution status is requested */
1370  );
1371 
1372 /** gets strong branching information on COLUMN variable of the last SCIPgetVarStrongbranch() call;
1373  * returns values of SCIP_INVALID, if strong branching was not yet called on the given variable;
1374  * keep in mind, that the returned old values may have nothing to do with the current LP solution
1375  *
1376  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1377  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1378  *
1379  * @pre This method can be called if @p scip is in one of the following stages:
1380  * - \ref SCIP_STAGE_SOLVING
1381  * - \ref SCIP_STAGE_SOLVED
1382  */
1383 extern
1384 SCIP_RETCODE SCIPgetVarStrongbranchLast(
1385  SCIP* scip, /**< SCIP data structure */
1386  SCIP_VAR* var, /**< variable to get last strong branching values for */
1387  SCIP_Real* down, /**< stores dual bound after branching column down, or NULL */
1388  SCIP_Real* up, /**< stores dual bound after branching column up, or NULL */
1389  SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL;
1390  * otherwise, it can only be used as an estimate value */
1391  SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound, or NULL;
1392  * otherwise, it can only be used as an estimate value */
1393  SCIP_Real* solval, /**< stores LP solution value of variable at last strong branching call, or NULL */
1394  SCIP_Real* lpobjval /**< stores LP objective value at last strong branching call, or NULL */
1395  );
1396 
1397 /** sets strong branching information for a column variable
1398  *
1399  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1400  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1401  *
1402  * @pre This method can be called if @p scip is in one of the following stages:
1403  * - \ref SCIP_STAGE_SOLVING
1404  */
1405 extern
1406 SCIP_RETCODE SCIPsetVarStrongbranchData(
1407  SCIP* scip, /**< SCIP data structure */
1408  SCIP_VAR* var, /**< variable to set last strong branching values for */
1409  SCIP_Real lpobjval, /**< objective value of the current LP */
1410  SCIP_Real primsol, /**< primal solution value of the column in the current LP */
1411  SCIP_Real down, /**< dual bound after branching column down */
1412  SCIP_Real up, /**< dual bound after branching column up */
1413  SCIP_Bool downvalid, /**< is the returned down value a valid dual bound? */
1414  SCIP_Bool upvalid, /**< is the returned up value a valid dual bound? */
1415  SCIP_Longint iter, /**< total number of strong branching iterations */
1416  int itlim /**< iteration limit applied to the strong branching call */
1417  );
1418 
1419 /** rounds the current solution and tries it afterwards; if feasible, adds it to storage
1420  *
1421  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1422  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1423  *
1424  * @pre This method can be called if @p scip is in one of the following stages:
1425  * - \ref SCIP_STAGE_SOLVING
1426  */
1427 extern
1428 SCIP_RETCODE SCIPtryStrongbranchLPSol(
1429  SCIP* scip, /**< SCIP data structure */
1430  SCIP_Bool* foundsol, /**< stores whether solution was feasible and good enough to keep */
1431  SCIP_Bool* cutoff /**< stores whether solution was cutoff due to exceeding the cutoffbound */
1432  );
1433 
1434 /** gets node number of the last node in current branch and bound run, where strong branching was used on the
1435  * given variable, or -1 if strong branching was never applied to the variable in current run
1436  *
1437  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1438  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1439  *
1440  * @pre This method can be called if @p scip is in one of the following stages:
1441  * - \ref SCIP_STAGE_TRANSFORMING
1442  * - \ref SCIP_STAGE_TRANSFORMED
1443  * - \ref SCIP_STAGE_INITPRESOLVE
1444  * - \ref SCIP_STAGE_PRESOLVING
1445  * - \ref SCIP_STAGE_EXITPRESOLVE
1446  * - \ref SCIP_STAGE_PRESOLVED
1447  * - \ref SCIP_STAGE_INITSOLVE
1448  * - \ref SCIP_STAGE_SOLVING
1449  * - \ref SCIP_STAGE_SOLVED
1450  * - \ref SCIP_STAGE_EXITSOLVE
1451  */
1452 extern
1453 SCIP_Longint SCIPgetVarStrongbranchNode(
1454  SCIP* scip, /**< SCIP data structure */
1455  SCIP_VAR* var /**< variable to get last strong branching node for */
1456  );
1457 
1458 /** if strong branching was already applied on the variable at the current node, returns the number of LPs solved after
1459  * the LP where the strong branching on this variable was applied;
1460  * if strong branching was not yet applied on the variable at the current node, returns INT_MAX
1461  *
1462  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1463  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1464  *
1465  * @pre This method can be called if @p scip is in one of the following stages:
1466  * - \ref SCIP_STAGE_TRANSFORMING
1467  * - \ref SCIP_STAGE_TRANSFORMED
1468  * - \ref SCIP_STAGE_INITPRESOLVE
1469  * - \ref SCIP_STAGE_PRESOLVING
1470  * - \ref SCIP_STAGE_EXITPRESOLVE
1471  * - \ref SCIP_STAGE_PRESOLVED
1472  * - \ref SCIP_STAGE_INITSOLVE
1473  * - \ref SCIP_STAGE_SOLVING
1474  * - \ref SCIP_STAGE_SOLVED
1475  * - \ref SCIP_STAGE_EXITSOLVE
1476  */
1477 extern
1478 SCIP_Longint SCIPgetVarStrongbranchLPAge(
1479  SCIP* scip, /**< SCIP data structure */
1480  SCIP_VAR* var /**< variable to get strong branching LP age for */
1481  );
1482 
1483 /** gets number of times, strong branching was applied in current run on the given variable
1484  *
1485  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1486  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1487  *
1488  * @pre This method can be called if @p scip is in one of the following stages:
1489  * - \ref SCIP_STAGE_TRANSFORMING
1490  * - \ref SCIP_STAGE_TRANSFORMED
1491  * - \ref SCIP_STAGE_INITPRESOLVE
1492  * - \ref SCIP_STAGE_PRESOLVING
1493  * - \ref SCIP_STAGE_EXITPRESOLVE
1494  * - \ref SCIP_STAGE_PRESOLVED
1495  * - \ref SCIP_STAGE_INITSOLVE
1496  * - \ref SCIP_STAGE_SOLVING
1497  * - \ref SCIP_STAGE_SOLVED
1498  * - \ref SCIP_STAGE_EXITSOLVE
1499  */
1500 extern
1501 int SCIPgetVarNStrongbranchs(
1502  SCIP* scip, /**< SCIP data structure */
1503  SCIP_VAR* var /**< variable to get last strong branching node for */
1504  );
1505 
1506 /** adds given values to lock numbers of type @p locktype of variable for rounding
1507  *
1508  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1509  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1510  *
1511  * @pre This method can be called if @p scip is in one of the following stages:
1512  * - \ref SCIP_STAGE_PROBLEM
1513  * - \ref SCIP_STAGE_TRANSFORMING
1514  * - \ref SCIP_STAGE_TRANSFORMED
1515  * - \ref SCIP_STAGE_INITPRESOLVE
1516  * - \ref SCIP_STAGE_PRESOLVING
1517  * - \ref SCIP_STAGE_EXITPRESOLVE
1518  * - \ref SCIP_STAGE_PRESOLVED
1519  * - \ref SCIP_STAGE_INITSOLVE
1520  * - \ref SCIP_STAGE_SOLVING
1521  * - \ref SCIP_STAGE_EXITSOLVE
1522  * - \ref SCIP_STAGE_FREETRANS
1523  */
1524 extern
1525 SCIP_RETCODE SCIPaddVarLocksType(
1526  SCIP* scip, /**< SCIP data structure */
1527  SCIP_VAR* var, /**< problem variable */
1528  SCIP_LOCKTYPE locktype, /**< type of the variable locks */
1529  int nlocksdown, /**< modification in number of rounding down locks */
1530  int nlocksup /**< modification in number of rounding up locks */
1531  );
1532 
1533 
1534 /** adds given values to lock numbers of variable for rounding
1535  *
1536  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1537  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1538  *
1539  * @pre This method can be called if @p scip is in one of the following stages:
1540  * - \ref SCIP_STAGE_PROBLEM
1541  * - \ref SCIP_STAGE_TRANSFORMING
1542  * - \ref SCIP_STAGE_TRANSFORMED
1543  * - \ref SCIP_STAGE_INITPRESOLVE
1544  * - \ref SCIP_STAGE_PRESOLVING
1545  * - \ref SCIP_STAGE_EXITPRESOLVE
1546  * - \ref SCIP_STAGE_PRESOLVED
1547  * - \ref SCIP_STAGE_INITSOLVE
1548  * - \ref SCIP_STAGE_SOLVING
1549  * - \ref SCIP_STAGE_EXITSOLVE
1550  * - \ref SCIP_STAGE_FREETRANS
1551  *
1552  * @note This method will always add variable locks of type model
1553  */
1554 extern
1555 SCIP_RETCODE SCIPaddVarLocks(
1556  SCIP* scip, /**< SCIP data structure */
1557  SCIP_VAR* var, /**< problem variable */
1558  int nlocksdown, /**< modification in number of rounding down locks */
1559  int nlocksup /**< modification in number of rounding up locks */
1560  );
1561 
1562 
1563 /** add locks of type @p locktype of variable with respect to the lock status of the constraint and its negation;
1564  * this method should be called whenever the lock status of a variable in a constraint changes, for example if
1565  * the coefficient of the variable changed its sign or if the left or right hand sides of the constraint were
1566  * added or removed
1567  *
1568  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1569  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1570  *
1571  * @pre This method can be called if @p scip is in one of the following stages:
1572  * - \ref SCIP_STAGE_PROBLEM
1573  * - \ref SCIP_STAGE_TRANSFORMING
1574  * - \ref SCIP_STAGE_INITPRESOLVE
1575  * - \ref SCIP_STAGE_PRESOLVING
1576  * - \ref SCIP_STAGE_EXITPRESOLVE
1577  * - \ref SCIP_STAGE_INITSOLVE
1578  * - \ref SCIP_STAGE_SOLVING
1579  * - \ref SCIP_STAGE_EXITSOLVE
1580  * - \ref SCIP_STAGE_FREETRANS
1581  */
1582 extern
1583 SCIP_RETCODE SCIPlockVarCons(
1584  SCIP* scip, /**< SCIP data structure */
1585  SCIP_VAR* var, /**< problem variable */
1586  SCIP_CONS* cons, /**< constraint */
1587  SCIP_Bool lockdown, /**< should the rounding be locked in downwards direction? */
1588  SCIP_Bool lockup /**< should the rounding be locked in upwards direction? */
1589  );
1590 
1591 /** remove locks of type @p locktype of variable with respect to the lock status of the constraint and its negation;
1592  * this method should be called whenever the lock status of a variable in a constraint changes, for example if
1593  * the coefficient of the variable changed its sign or if the left or right hand sides of the constraint were
1594  * added or removed
1595  *
1596  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1597  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1598  *
1599  * @pre This method can be called if @p scip is in one of the following stages:
1600  * - \ref SCIP_STAGE_PROBLEM
1601  * - \ref SCIP_STAGE_TRANSFORMING
1602  * - \ref SCIP_STAGE_INITPRESOLVE
1603  * - \ref SCIP_STAGE_PRESOLVING
1604  * - \ref SCIP_STAGE_EXITPRESOLVE
1605  * - \ref SCIP_STAGE_INITSOLVE
1606  * - \ref SCIP_STAGE_SOLVING
1607  * - \ref SCIP_STAGE_EXITSOLVE
1608  * - \ref SCIP_STAGE_FREETRANS
1609  */
1610 extern
1611 SCIP_RETCODE SCIPunlockVarCons(
1612  SCIP* scip, /**< SCIP data structure */
1613  SCIP_VAR* var, /**< problem variable */
1614  SCIP_CONS* cons, /**< constraint */
1615  SCIP_Bool lockdown, /**< should the rounding be unlocked in downwards direction? */
1616  SCIP_Bool lockup /**< should the rounding be unlocked in upwards direction? */
1617  );
1618 
1619 /** changes variable's objective value
1620  *
1621  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1622  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1623  *
1624  * @pre This method can be called if @p scip is in one of the following stages:
1625  * - \ref SCIP_STAGE_PROBLEM
1626  * - \ref SCIP_STAGE_TRANSFORMING
1627  * - \ref SCIP_STAGE_PRESOLVING
1628  */
1629 extern
1630 SCIP_RETCODE SCIPchgVarObj(
1631  SCIP* scip, /**< SCIP data structure */
1632  SCIP_VAR* var, /**< variable to change the objective value for */
1633  SCIP_Real newobj /**< new objective value */
1634  );
1635 
1636 /** adds value to variable's objective value
1637  *
1638  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1639  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1640  *
1641  * @pre This method can be called if @p scip is in one of the following stages:
1642  * - \ref SCIP_STAGE_PROBLEM
1643  * - \ref SCIP_STAGE_TRANSFORMING
1644  * - \ref SCIP_STAGE_PRESOLVING
1645  * - \ref SCIP_STAGE_EXITPRESOLVE
1646  * - \ref SCIP_STAGE_PRESOLVED
1647  */
1648 extern
1649 SCIP_RETCODE SCIPaddVarObj(
1650  SCIP* scip, /**< SCIP data structure */
1651  SCIP_VAR* var, /**< variable to change the objective value for */
1652  SCIP_Real addobj /**< additional objective value */
1653  );
1654 
1655 /** returns the adjusted (i.e. rounded, if the given variable is of integral type) lower bound value;
1656  * does not change the bounds of the variable
1657  *
1658  * @return adjusted lower bound for the given variable; the bound of the variable is not changed
1659  *
1660  * @pre This method can be called if @p scip is in one of the following stages:
1661  * - \ref SCIP_STAGE_PROBLEM
1662  * - \ref SCIP_STAGE_TRANSFORMING
1663  * - \ref SCIP_STAGE_TRANSFORMED
1664  * - \ref SCIP_STAGE_INITPRESOLVE
1665  * - \ref SCIP_STAGE_PRESOLVING
1666  * - \ref SCIP_STAGE_EXITPRESOLVE
1667  * - \ref SCIP_STAGE_PRESOLVED
1668  * - \ref SCIP_STAGE_INITSOLVE
1669  * - \ref SCIP_STAGE_SOLVING
1670  * - \ref SCIP_STAGE_SOLVED
1671  * - \ref SCIP_STAGE_EXITSOLVE
1672  * - \ref SCIP_STAGE_FREETRANS
1673  */
1674 extern
1675 SCIP_Real SCIPadjustedVarLb(
1676  SCIP* scip, /**< SCIP data structure */
1677  SCIP_VAR* var, /**< variable to adjust the bound for */
1678  SCIP_Real lb /**< lower bound value to adjust */
1679  );
1680 
1681 /** returns the adjusted (i.e. rounded, if the given variable is of integral type) upper bound value;
1682  * does not change the bounds of the variable
1683  *
1684  * @return adjusted upper bound for the given variable; the bound of the variable is not changed
1685  *
1686  * @pre This method can be called if @p scip is in one of the following stages:
1687  * - \ref SCIP_STAGE_PROBLEM
1688  * - \ref SCIP_STAGE_TRANSFORMING
1689  * - \ref SCIP_STAGE_TRANSFORMED
1690  * - \ref SCIP_STAGE_INITPRESOLVE
1691  * - \ref SCIP_STAGE_PRESOLVING
1692  * - \ref SCIP_STAGE_EXITPRESOLVE
1693  * - \ref SCIP_STAGE_PRESOLVED
1694  * - \ref SCIP_STAGE_INITSOLVE
1695  * - \ref SCIP_STAGE_SOLVING
1696  * - \ref SCIP_STAGE_SOLVED
1697  * - \ref SCIP_STAGE_EXITSOLVE
1698  * - \ref SCIP_STAGE_FREETRANS
1699  */
1700 extern
1701 SCIP_Real SCIPadjustedVarUb(
1702  SCIP* scip, /**< SCIP data structure */
1703  SCIP_VAR* var, /**< variable to adjust the bound for */
1704  SCIP_Real ub /**< upper bound value to adjust */
1705  );
1706 
1707 /** depending on SCIP's stage, changes lower bound of variable in the problem, in preprocessing, or in current node;
1708  * if possible, adjusts bound to integral value; doesn't store any inference information in the bound change, such
1709  * that in conflict analysis, this change is treated like a branching decision
1710  *
1711  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
1712  * SCIPgetVars()) gets resorted.
1713  *
1714  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1715  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1716  *
1717  * @pre This method can be called if @p scip is in one of the following stages:
1718  * - \ref SCIP_STAGE_PROBLEM
1719  * - \ref SCIP_STAGE_TRANSFORMING
1720  * - \ref SCIP_STAGE_PRESOLVING
1721  * - \ref SCIP_STAGE_SOLVING
1722  *
1723  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
1724  */
1725 extern
1726 SCIP_RETCODE SCIPchgVarLb(
1727  SCIP* scip, /**< SCIP data structure */
1728  SCIP_VAR* var, /**< variable to change the bound for */
1729  SCIP_Real newbound /**< new value for bound */
1730  );
1731 
1732 /** depending on SCIP's stage, changes upper bound of variable in the problem, in preprocessing, or in current node;
1733  * if possible, adjusts bound to integral value; doesn't store any inference information in the bound change, such
1734  * that in conflict analysis, this change is treated like a branching decision
1735  *
1736  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
1737  * SCIPgetVars()) gets resorted.
1738  *
1739  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1740  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1741  *
1742  * @pre This method can be called if @p scip is in one of the following stages:
1743  * - \ref SCIP_STAGE_PROBLEM
1744  * - \ref SCIP_STAGE_TRANSFORMING
1745  * - \ref SCIP_STAGE_PRESOLVING
1746  * - \ref SCIP_STAGE_SOLVING
1747  *
1748  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
1749  */
1750 extern
1751 SCIP_RETCODE SCIPchgVarUb(
1752  SCIP* scip, /**< SCIP data structure */
1753  SCIP_VAR* var, /**< variable to change the bound for */
1754  SCIP_Real newbound /**< new value for bound */
1755  );
1756 
1757 /** changes lower bound of variable in the given node; if possible, adjust bound to integral value; doesn't store any
1758  * inference information in the bound change, such that in conflict analysis, this change is treated like a branching
1759  * decision
1760  *
1761  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1762  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1763  *
1764  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
1765  */
1766 extern
1767 SCIP_RETCODE SCIPchgVarLbNode(
1768  SCIP* scip, /**< SCIP data structure */
1769  SCIP_NODE* node, /**< node to change bound at, or NULL for current node */
1770  SCIP_VAR* var, /**< variable to change the bound for */
1771  SCIP_Real newbound /**< new value for bound */
1772  );
1773 
1774 /** changes upper bound of variable in the given node; if possible, adjust bound to integral value; doesn't store any
1775  * inference information in the bound change, such that in conflict analysis, this change is treated like a branching
1776  * decision
1777  *
1778  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1779  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1780  *
1781  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
1782  */
1783 extern
1784 SCIP_RETCODE SCIPchgVarUbNode(
1785  SCIP* scip, /**< SCIP data structure */
1786  SCIP_NODE* node, /**< node to change bound at, or NULL for current node */
1787  SCIP_VAR* var, /**< variable to change the bound for */
1788  SCIP_Real newbound /**< new value for bound */
1789  );
1790 
1791 /** changes global lower bound of variable; if possible, adjust bound to integral value; also tightens the local bound,
1792  * if the global bound is better than the local bound
1793  *
1794  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
1795  * SCIPgetVars()) gets resorted.
1796  *
1797  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1798  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1799  *
1800  * @pre This method can be called if @p scip is in one of the following stages:
1801  * - \ref SCIP_STAGE_PROBLEM
1802  * - \ref SCIP_STAGE_TRANSFORMING
1803  * - \ref SCIP_STAGE_PRESOLVING
1804  * - \ref SCIP_STAGE_SOLVING
1805  *
1806  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
1807  */
1808 extern
1809 SCIP_RETCODE SCIPchgVarLbGlobal(
1810  SCIP* scip, /**< SCIP data structure */
1811  SCIP_VAR* var, /**< variable to change the bound for */
1812  SCIP_Real newbound /**< new value for bound */
1813  );
1814 
1815 /** changes global upper bound of variable; if possible, adjust bound to integral value; also tightens the local bound,
1816  * if the global bound is better than the local bound
1817  *
1818  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
1819  * SCIPgetVars()) gets resorted.
1820  *
1821  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1822  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1823  *
1824  * @pre This method can be called if @p scip is in one of the following stages:
1825  * - \ref SCIP_STAGE_PROBLEM
1826  * - \ref SCIP_STAGE_TRANSFORMING
1827  * - \ref SCIP_STAGE_PRESOLVING
1828  * - \ref SCIP_STAGE_SOLVING
1829  *
1830  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
1831  */
1832 extern
1833 SCIP_RETCODE SCIPchgVarUbGlobal(
1834  SCIP* scip, /**< SCIP data structure */
1835  SCIP_VAR* var, /**< variable to change the bound for */
1836  SCIP_Real newbound /**< new value for bound */
1837  );
1838 
1839 /** changes lazy lower bound of the variable, this is only possible if the variable is not in the LP yet
1840  *
1841  * lazy bounds are bounds, that are enforced by constraints and the objective function; hence, these bounds do not need
1842  * to be put into the LP explicitly.
1843  *
1844  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1845  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1846  *
1847  * @pre This method can be called if @p scip is in one of the following stages:
1848  * - \ref SCIP_STAGE_PROBLEM
1849  * - \ref SCIP_STAGE_TRANSFORMING
1850  * - \ref SCIP_STAGE_TRANSFORMED
1851  * - \ref SCIP_STAGE_PRESOLVING
1852  * - \ref SCIP_STAGE_SOLVING
1853  *
1854  * @note lazy bounds are useful for branch-and-price since the corresponding variable bounds are not part of the LP
1855  */
1856 extern
1857 SCIP_RETCODE SCIPchgVarLbLazy(
1858  SCIP* scip, /**< SCIP data structure */
1859  SCIP_VAR* var, /**< problem variable */
1860  SCIP_Real lazylb /**< the lazy lower bound to be set */
1861  );
1862 
1863 /** changes lazy upper bound of the variable, this is only possible if the variable is not in the LP yet
1864  *
1865  * lazy bounds are bounds, that are enforced by constraints and the objective function; hence, these bounds do not need
1866  * to be put into the LP explicitly.
1867  *
1868  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1869  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1870  *
1871  * @pre This method can be called if @p scip is in one of the following stages:
1872  * - \ref SCIP_STAGE_PROBLEM
1873  * - \ref SCIP_STAGE_TRANSFORMING
1874  * - \ref SCIP_STAGE_TRANSFORMED
1875  * - \ref SCIP_STAGE_PRESOLVING
1876  * - \ref SCIP_STAGE_SOLVING
1877  *
1878  * @note lazy bounds are useful for branch-and-price since the corresponding variable bounds are not part of the LP
1879  */
1880 extern
1881 SCIP_RETCODE SCIPchgVarUbLazy(
1882  SCIP* scip, /**< SCIP data structure */
1883  SCIP_VAR* var, /**< problem variable */
1884  SCIP_Real lazyub /**< the lazy lower bound to be set */
1885  );
1886 
1887 /** changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter
1888  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
1889  * doesn't store any inference information in the bound change, such that in conflict analysis, this change
1890  * is treated like a branching decision
1891  *
1892  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
1893  * SCIPgetVars()) gets resorted.
1894  *
1895  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1896  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1897  *
1898  * @pre This method can be called if @p scip is in one of the following stages:
1899  * - \ref SCIP_STAGE_PROBLEM
1900  * - \ref SCIP_STAGE_PRESOLVING
1901  * - \ref SCIP_STAGE_SOLVING
1902  *
1903  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
1904  */
1905 extern
1906 SCIP_RETCODE SCIPtightenVarLb(
1907  SCIP* scip, /**< SCIP data structure */
1908  SCIP_VAR* var, /**< variable to change the bound for */
1909  SCIP_Real newbound, /**< new value for bound */
1910  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
1911  SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */
1912  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
1913  );
1914 
1915 /** changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter
1916  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
1917  * doesn't store any inference information in the bound change, such that in conflict analysis, this change
1918  * is treated like a branching decision
1919  *
1920  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
1921  * SCIPgetVars()) gets resorted.
1922  *
1923  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1924  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1925  *
1926  * @pre This method can be called if @p scip is in one of the following stages:
1927  * - \ref SCIP_STAGE_PROBLEM
1928  * - \ref SCIP_STAGE_PRESOLVING
1929  * - \ref SCIP_STAGE_SOLVING
1930  *
1931  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
1932  */
1933 extern
1934 SCIP_RETCODE SCIPtightenVarUb(
1935  SCIP* scip, /**< SCIP data structure */
1936  SCIP_VAR* var, /**< variable to change the bound for */
1937  SCIP_Real newbound, /**< new value for bound */
1938  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
1939  SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */
1940  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
1941  );
1942 
1943 /** fixes variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening
1944  * epsilon) than the current bound; if possible, adjusts bound to integral value; the given inference constraint is
1945  * stored, such that the conflict analysis is able to find out the reason for the deduction of the bound change
1946  *
1947  * @note In presolving stage when not in probing mode the variable will be fixed directly, otherwise this method
1948  * changes first the lowerbound by calling SCIPinferVarLbCons and second the upperbound by calling
1949  * SCIPinferVarUbCons
1950  *
1951  * @note If SCIP is in presolving stage, it can happen that the internal variable array (which get be accessed via
1952  * SCIPgetVars()) gets resorted.
1953  *
1954  * @note During presolving, an integer variable which bound changes to {0,1} is upgraded to a binary variable.
1955  */
1956 extern
1957 SCIP_RETCODE SCIPinferVarFixCons(
1958  SCIP* scip, /**< SCIP data structure */
1959  SCIP_VAR* var, /**< variable to change the bound for */
1960  SCIP_Real fixedval, /**< new value for fixation */
1961  SCIP_CONS* infercons, /**< constraint that deduced the bound change */
1962  int inferinfo, /**< user information for inference to help resolving the conflict */
1963  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
1964  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
1965  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
1966  );
1967 
1968 /** changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter
1969  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
1970  * the given inference constraint is stored, such that the conflict analysis is able to find out the reason
1971  * for the deduction of the bound change
1972  *
1973  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
1974  * SCIPgetVars()) gets resorted.
1975  *
1976  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1977  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1978  *
1979  * @pre This method can be called if @p scip is in one of the following stages:
1980  * - \ref SCIP_STAGE_PROBLEM
1981  * - \ref SCIP_STAGE_PRESOLVING
1982  * - \ref SCIP_STAGE_SOLVING
1983  *
1984  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
1985  */
1986 extern
1987 SCIP_RETCODE SCIPinferVarLbCons(
1988  SCIP* scip, /**< SCIP data structure */
1989  SCIP_VAR* var, /**< variable to change the bound for */
1990  SCIP_Real newbound, /**< new value for bound */
1991  SCIP_CONS* infercons, /**< constraint that deduced the bound change, or NULL */
1992  int inferinfo, /**< user information for inference to help resolving the conflict */
1993  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
1994  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
1995  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
1996  );
1997 
1998 /** changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter
1999  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
2000  * the given inference constraint is stored, such that the conflict analysis is able to find out the reason
2001  * for the deduction of the bound change
2002  *
2003  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
2004  * SCIPgetVars()) gets resorted.
2005  *
2006  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2007  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2008  *
2009  * @pre This method can be called if @p scip is in one of the following stages:
2010  * - \ref SCIP_STAGE_PROBLEM
2011  * - \ref SCIP_STAGE_PRESOLVING
2012  * - \ref SCIP_STAGE_SOLVING
2013  *
2014  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
2015  */
2016 extern
2017 SCIP_RETCODE SCIPinferVarUbCons(
2018  SCIP* scip, /**< SCIP data structure */
2019  SCIP_VAR* var, /**< variable to change the bound for */
2020  SCIP_Real newbound, /**< new value for bound */
2021  SCIP_CONS* infercons, /**< constraint that deduced the bound change */
2022  int inferinfo, /**< user information for inference to help resolving the conflict */
2023  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
2024  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
2025  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
2026  );
2027 
2028 /** depending on SCIP's stage, fixes binary variable in the problem, in preprocessing, or in current node;
2029  * the given inference constraint is stored, such that the conflict analysis is able to find out the reason for the
2030  * deduction of the fixing
2031  *
2032  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2033  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2034  *
2035  * @pre This method can be called if @p scip is in one of the following stages:
2036  * - \ref SCIP_STAGE_PROBLEM
2037  * - \ref SCIP_STAGE_PRESOLVING
2038  * - \ref SCIP_STAGE_SOLVING
2039  */
2040 extern
2041 SCIP_RETCODE SCIPinferBinvarCons(
2042  SCIP* scip, /**< SCIP data structure */
2043  SCIP_VAR* var, /**< binary variable to fix */
2044  SCIP_Bool fixedval, /**< value to fix binary variable to */
2045  SCIP_CONS* infercons, /**< constraint that deduced the fixing */
2046  int inferinfo, /**< user information for inference to help resolving the conflict */
2047  SCIP_Bool* infeasible, /**< pointer to store whether the fixing is infeasible */
2048  SCIP_Bool* tightened /**< pointer to store whether the fixing tightened the local bounds, or NULL */
2049  );
2050 
2051 /** fixes variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening
2052  * epsilon) than the current bound; if possible, adjusts bound to integral value; the given inference constraint is
2053  * stored, such that the conflict analysis is able to find out the reason for the deduction of the bound change
2054  *
2055  * @note In presolving stage when not in probing mode the variable will be fixed directly, otherwise this method
2056  * changes first the lowerbound by calling SCIPinferVarLbProp and second the upperbound by calling
2057  * SCIPinferVarUbProp
2058  *
2059  * @note If SCIP is in presolving stage, it can happen that the internal variable array (which get be accessed via
2060  * SCIPgetVars()) gets resorted.
2061  *
2062  * @note During presolving, an integer variable which bound changes to {0,1} is upgraded to a binary variable.
2063  */
2064 extern
2065 SCIP_RETCODE SCIPinferVarFixProp(
2066  SCIP* scip, /**< SCIP data structure */
2067  SCIP_VAR* var, /**< variable to change the bound for */
2068  SCIP_Real fixedval, /**< new value for fixation */
2069  SCIP_PROP* inferprop, /**< propagator that deduced the bound change */
2070  int inferinfo, /**< user information for inference to help resolving the conflict */
2071  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
2072  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
2073  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
2074  );
2075 
2076 /** changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter
2077  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
2078  * the given inference propagator is stored, such that the conflict analysis is able to find out the reason
2079  * for the deduction of the bound change
2080  *
2081  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
2082  * SCIPgetVars()) gets resorted.
2083  *
2084  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2085  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2086  *
2087  * @pre This method can be called if @p scip is in one of the following stages:
2088  * - \ref SCIP_STAGE_PROBLEM
2089  * - \ref SCIP_STAGE_PRESOLVING
2090  * - \ref SCIP_STAGE_SOLVING
2091  *
2092  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
2093  */
2094 extern
2095 SCIP_RETCODE SCIPinferVarLbProp(
2096  SCIP* scip, /**< SCIP data structure */
2097  SCIP_VAR* var, /**< variable to change the bound for */
2098  SCIP_Real newbound, /**< new value for bound */
2099  SCIP_PROP* inferprop, /**< propagator that deduced the bound change, or NULL */
2100  int inferinfo, /**< user information for inference to help resolving the conflict */
2101  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
2102  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
2103  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
2104  );
2105 
2106 /** changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter
2107  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
2108  * the given inference propagator is stored, such that the conflict analysis is able to find out the reason
2109  * for the deduction of the bound change
2110  *
2111  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
2112  * SCIPgetVars()) gets resorted.
2113  *
2114  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2115  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2116  *
2117  * @pre This method can be called if @p scip is in one of the following stages:
2118  * - \ref SCIP_STAGE_PROBLEM
2119  * - \ref SCIP_STAGE_PRESOLVING
2120  * - \ref SCIP_STAGE_SOLVING
2121  *
2122  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
2123  */
2124 extern
2125 SCIP_RETCODE SCIPinferVarUbProp(
2126  SCIP* scip, /**< SCIP data structure */
2127  SCIP_VAR* var, /**< variable to change the bound for */
2128  SCIP_Real newbound, /**< new value for bound */
2129  SCIP_PROP* inferprop, /**< propagator that deduced the bound change */
2130  int inferinfo, /**< user information for inference to help resolving the conflict */
2131  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
2132  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
2133  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
2134  );
2135 
2136 /** depending on SCIP's stage, fixes binary variable in the problem, in preprocessing, or in current node;
2137  * the given inference propagator is stored, such that the conflict analysis is able to find out the reason for the
2138  * deduction of the fixing
2139  *
2140  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2141  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2142  *
2143  * @pre This method can be called if @p scip is in one of the following stages:
2144  * - \ref SCIP_STAGE_PROBLEM
2145  * - \ref SCIP_STAGE_PRESOLVING
2146  * - \ref SCIP_STAGE_PRESOLVED
2147  * - \ref SCIP_STAGE_SOLVING
2148  */
2149 extern
2150 SCIP_RETCODE SCIPinferBinvarProp(
2151  SCIP* scip, /**< SCIP data structure */
2152  SCIP_VAR* var, /**< binary variable to fix */
2153  SCIP_Bool fixedval, /**< value to fix binary variable to */
2154  SCIP_PROP* inferprop, /**< propagator that deduced the fixing */
2155  int inferinfo, /**< user information for inference to help resolving the conflict */
2156  SCIP_Bool* infeasible, /**< pointer to store whether the fixing is infeasible */
2157  SCIP_Bool* tightened /**< pointer to store whether the fixing tightened the local bounds, or NULL */
2158  );
2159 
2160 /** changes global lower bound of variable in preprocessing or in the current node, if the new bound is tighter
2161  * (w.r.t. bound strengthening epsilon) than the current global bound; if possible, adjusts bound to integral value;
2162  * also tightens the local bound, if the global bound is better than the local bound
2163  *
2164  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
2165  * SCIPgetVars()) gets resorted.
2166  *
2167  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2168  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2169  *
2170  * @pre This method can be called if @p scip is in one of the following stages:
2171  * - \ref SCIP_STAGE_PROBLEM
2172  * - \ref SCIP_STAGE_TRANSFORMING
2173  * - \ref SCIP_STAGE_PRESOLVING
2174  * - \ref SCIP_STAGE_SOLVING
2175  *
2176  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
2177  */
2178 extern
2179 SCIP_RETCODE SCIPtightenVarLbGlobal(
2180  SCIP* scip, /**< SCIP data structure */
2181  SCIP_VAR* var, /**< variable to change the bound for */
2182  SCIP_Real newbound, /**< new value for bound */
2183  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
2184  SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */
2185  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
2186  );
2187 
2188 /** changes global upper bound of variable in preprocessing or in the current node, if the new bound is tighter
2189  * (w.r.t. bound strengthening epsilon) than the current global bound; if possible, adjusts bound to integral value;
2190  * also tightens the local bound, if the global bound is better than the local bound
2191  *
2192  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
2193  * SCIPgetVars()) gets resorted.
2194  *
2195  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2196  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2197  *
2198  * @pre This method can be called if @p scip is in one of the following stages:
2199  * - \ref SCIP_STAGE_PROBLEM
2200  * - \ref SCIP_STAGE_TRANSFORMING
2201  * - \ref SCIP_STAGE_PRESOLVING
2202  * - \ref SCIP_STAGE_SOLVING
2203  *
2204  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
2205  */
2206 extern
2207 SCIP_RETCODE SCIPtightenVarUbGlobal(
2208  SCIP* scip, /**< SCIP data structure */
2209  SCIP_VAR* var, /**< variable to change the bound for */
2210  SCIP_Real newbound, /**< new value for bound */
2211  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
2212  SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */
2213  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
2214  );
2215 
2216 /** for a multi-aggregated variable, returns the global lower bound computed by adding the global bounds from all aggregation variables
2217  *
2218  * 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
2219  * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetLbGlobal.
2220  *
2221  * @return the global lower bound computed by adding the global bounds from all aggregation variables
2222  */
2223 extern
2224 SCIP_Real SCIPcomputeVarLbGlobal(
2225  SCIP* scip, /**< SCIP data structure */
2226  SCIP_VAR* var /**< variable to compute the bound for */
2227  );
2228 
2229 /** for a multi-aggregated variable, returns the global upper bound computed by adding the global bounds from all aggregation variables
2230  *
2231  * This global bound may be tighter than the one given by SCIPvarGetUbGlobal, since the latter is not updated if bounds of aggregation variables are changing
2232  * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetUbGlobal.
2233  *
2234  * @return the global upper bound computed by adding the global bounds from all aggregation variables
2235  */
2236 extern
2237 SCIP_Real SCIPcomputeVarUbGlobal(
2238  SCIP* scip, /**< SCIP data structure */
2239  SCIP_VAR* var /**< variable to compute the bound for */
2240  );
2241 
2242 /** for a multi-aggregated variable, returns the local lower bound computed by adding the local bounds from all aggregation variables
2243  *
2244  * This local bound may be tighter than the one given by SCIPvarGetLbLocal, since the latter is not updated if bounds of aggregation variables are changing
2245  * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetLbLocal.
2246  *
2247  * @return the local lower bound computed by adding the global bounds from all aggregation variables
2248  */
2249 extern
2250 SCIP_Real SCIPcomputeVarLbLocal(
2251  SCIP* scip, /**< SCIP data structure */
2252  SCIP_VAR* var /**< variable to compute the bound for */
2253  );
2254 
2255 /** for a multi-aggregated variable, returns the local upper bound computed by adding the local bounds from all aggregation variables
2256  *
2257  * This local bound may be tighter than the one given by SCIPvarGetUbLocal, since the latter is not updated if bounds of aggregation variables are changing
2258  * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetUbLocal.
2259  *
2260  * @return the local upper bound computed by adding the global bounds from all aggregation variables
2261  */
2262 extern
2263 SCIP_Real SCIPcomputeVarUbLocal(
2264  SCIP* scip, /**< SCIP data structure */
2265  SCIP_VAR* var /**< variable to compute the bound for */
2266  );
2267 
2268 /** for a multi-aggregated variable, gives the global lower bound computed by adding the global bounds from all
2269  * aggregation variables, this global bound may be tighter than the one given by SCIPvarGetLbGlobal, since the latter is
2270  * not updated if bounds of aggregation variables are changing
2271  *
2272  * calling this function for a non-multi-aggregated variable is not allowed
2273  */
2274 extern
2275 SCIP_Real SCIPgetVarMultaggrLbGlobal(
2276  SCIP* scip, /**< SCIP data structure */
2277  SCIP_VAR* var /**< variable to compute the bound for */
2278  );
2279 
2280 /** for a multi-aggregated variable, gives the global upper bound computed by adding the global bounds from all
2281  * aggregation variables, this upper bound may be tighter than the one given by SCIPvarGetUbGlobal, since the latter is
2282  * not updated if bounds of aggregation variables are changing
2283  *
2284  * calling this function for a non-multi-aggregated variable is not allowed
2285  */
2286 extern
2287 SCIP_Real SCIPgetVarMultaggrUbGlobal(
2288  SCIP* scip, /**< SCIP data structure */
2289  SCIP_VAR* var /**< variable to compute the bound for */
2290  );
2291 
2292 /** for a multi-aggregated variable, gives the local lower bound computed by adding the local bounds from all
2293  * aggregation variables, this lower bound may be tighter than the one given by SCIPvarGetLbLocal, since the latter is
2294  * not updated if bounds of aggregation variables are changing
2295  *
2296  * calling this function for a non-multi-aggregated variable is not allowed
2297  */
2298 extern
2299 SCIP_Real SCIPgetVarMultaggrLbLocal(
2300  SCIP* scip, /**< SCIP data structure */
2301  SCIP_VAR* var /**< variable to compute the bound for */
2302  );
2303 
2304 /** for a multi-aggregated variable, gives the local upper bound computed by adding the local bounds from all
2305  * aggregation variables, this upper bound may be tighter than the one given by SCIPvarGetUbLocal, since the latter is
2306  * not updated if bounds of aggregation variables are changing
2307  *
2308  * calling this function for a non-multi-aggregated variable is not allowed
2309  */
2310 extern
2311 SCIP_Real SCIPgetVarMultaggrUbLocal(
2312  SCIP* scip, /**< SCIP data structure */
2313  SCIP_VAR* var /**< variable to compute the bound for */
2314  );
2315 
2316 #ifdef NDEBUG
2317 
2318 /* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
2319  * speed up the algorithms.
2320  */
2321 
2322 #define SCIPcomputeVarLbGlobal(scip, var) (SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR ? SCIPgetVarMultaggrLbGlobal(scip, var) : SCIPvarGetLbGlobal(var))
2323 #define SCIPcomputeVarUbGlobal(scip, var) (SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR ? SCIPgetVarMultaggrUbGlobal(scip, var) : SCIPvarGetUbGlobal(var))
2324 #define SCIPcomputeVarLbLocal(scip, var) (SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR ? SCIPgetVarMultaggrLbLocal(scip, var) : SCIPvarGetLbLocal(var))
2325 #define SCIPcomputeVarUbLocal(scip, var) (SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR ? SCIPgetVarMultaggrUbLocal(scip, var) : SCIPvarGetUbLocal(var))
2326 
2327 #endif
2328 
2329 /** returns solution value and index of variable lower bound that is closest to the variable's value in the given primal
2330  * solution or current LP solution if no primal solution is given; returns an index of -1 if no variable lower bound is
2331  * available
2332  *
2333  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2334  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2335  *
2336  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
2337  */
2338 extern
2339 SCIP_RETCODE SCIPgetVarClosestVlb(
2340  SCIP* scip, /**< SCIP data structure */
2341  SCIP_VAR* var, /**< active problem variable */
2342  SCIP_SOL* sol, /**< primal solution, or NULL for LP solution */
2343  SCIP_Real* closestvlb, /**< pointer to store the value of the closest variable lower bound */
2344  int* closestvlbidx /**< pointer to store the index of the closest variable lower bound */
2345  );
2346 
2347 /** returns solution value and index of variable upper bound that is closest to the variable's value in the given primal solution;
2348  * or current LP solution if no primal solution is given; returns an index of -1 if no variable upper bound is available
2349  *
2350  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2351  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2352  *
2353  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
2354  */
2355 extern
2356 SCIP_RETCODE SCIPgetVarClosestVub(
2357  SCIP* scip, /**< SCIP data structure */
2358  SCIP_VAR* var, /**< active problem variable */
2359  SCIP_SOL* sol, /**< primal solution, or NULL for LP solution */
2360  SCIP_Real* closestvub, /**< pointer to store the value of the closest variable lower bound */
2361  int* closestvubidx /**< pointer to store the index of the closest variable lower bound */
2362  );
2363 
2364 /** informs variable x about a globally valid variable lower bound x >= b*z + d with integer variable z;
2365  * if z is binary, the corresponding valid implication for z is also added;
2366  * if z is non-continuous and 1/b not too small, the corresponding valid upper/lower bound
2367  * z <= (x-d)/b or z >= (x-d)/b (depending on the sign of of b) is added, too;
2368  * improves the global bounds of the variable and the vlb variable if possible
2369  *
2370  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2371  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2372  *
2373  * @pre This method can be called if @p scip is in one of the following stages:
2374  * - \ref SCIP_STAGE_PRESOLVING
2375  * - \ref SCIP_STAGE_PRESOLVED
2376  * - \ref SCIP_STAGE_SOLVING
2377  */
2378 extern
2379 SCIP_RETCODE SCIPaddVarVlb(
2380  SCIP* scip, /**< SCIP data structure */
2381  SCIP_VAR* var, /**< problem variable */
2382  SCIP_VAR* vlbvar, /**< variable z in x >= b*z + d */
2383  SCIP_Real vlbcoef, /**< coefficient b in x >= b*z + d */
2384  SCIP_Real vlbconstant, /**< constant d in x >= b*z + d */
2385  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
2386  int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
2387  );
2388 
2389 
2390 /** informs variable x about a globally valid variable upper bound x <= b*z + d with integer variable z;
2391  * if z is binary, the corresponding valid implication for z is also added;
2392  * if z is non-continuous and 1/b not too small, the corresponding valid lower/upper bound
2393  * z >= (x-d)/b or z <= (x-d)/b (depending on the sign of of b) is added, too;
2394  * improves the global bounds of the variable and the vlb variable if possible
2395  *
2396  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2397  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2398  *
2399  * @pre This method can be called if @p scip is in one of the following stages:
2400  * - \ref SCIP_STAGE_PRESOLVING
2401  * - \ref SCIP_STAGE_PRESOLVED
2402  * - \ref SCIP_STAGE_SOLVING
2403  */
2404 extern
2405 SCIP_RETCODE SCIPaddVarVub(
2406  SCIP* scip, /**< SCIP data structure */
2407  SCIP_VAR* var, /**< problem variable */
2408  SCIP_VAR* vubvar, /**< variable z in x <= b*z + d */
2409  SCIP_Real vubcoef, /**< coefficient b in x <= b*z + d */
2410  SCIP_Real vubconstant, /**< constant d in x <= b*z + d */
2411  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
2412  int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
2413  );
2414 
2415 /** informs binary variable x about a globally valid implication: x == 0 or x == 1 ==> y <= b or y >= b;
2416  * also adds the corresponding implication or variable bound to the implied variable;
2417  * if the implication is conflicting, the variable is fixed to the opposite value;
2418  * if the variable is already fixed to the given value, the implication is performed immediately;
2419  * if the implication is redundant with respect to the variables' global bounds, it is ignored
2420  *
2421  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2422  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2423  *
2424  * @pre This method can be called if @p scip is in one of the following stages:
2425  * - \ref SCIP_STAGE_TRANSFORMED
2426  * - \ref SCIP_STAGE_PRESOLVING
2427  * - \ref SCIP_STAGE_PRESOLVED
2428  * - \ref SCIP_STAGE_SOLVING
2429  */
2430 extern
2431 SCIP_RETCODE SCIPaddVarImplication(
2432  SCIP* scip, /**< SCIP data structure */
2433  SCIP_VAR* var, /**< problem variable */
2434  SCIP_Bool varfixing, /**< FALSE if y should be added in implications for x == 0, TRUE for x == 1 */
2435  SCIP_VAR* implvar, /**< variable y in implication y <= b or y >= b */
2436  SCIP_BOUNDTYPE impltype, /**< type of implication y <= b (SCIP_BOUNDTYPE_UPPER)
2437  * or y >= b (SCIP_BOUNDTYPE_LOWER) */
2438  SCIP_Real implbound, /**< bound b in implication y <= b or y >= b */
2439  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
2440  int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
2441  );
2442 
2443 /** adds a clique information to SCIP, stating that at most one of the given binary variables can be set to 1;
2444  * if a variable appears twice in the same clique, the corresponding implications are performed
2445  *
2446  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2447  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2448  *
2449  * @pre This method can be called if @p scip is in one of the following stages:
2450  * - \ref SCIP_STAGE_TRANSFORMED
2451  * - \ref SCIP_STAGE_PRESOLVING
2452  * - \ref SCIP_STAGE_PRESOLVED
2453  * - \ref SCIP_STAGE_SOLVING
2454  */
2455 extern
2456 SCIP_RETCODE SCIPaddClique(
2457  SCIP* scip, /**< SCIP data structure */
2458  SCIP_VAR** vars, /**< binary variables in the clique from which at most one can be set to 1 */
2459  SCIP_Bool* values, /**< values of the variables in the clique; NULL to use TRUE for all vars */
2460  int nvars, /**< number of variables in the clique */
2461  SCIP_Bool isequation, /**< is the clique an equation or an inequality? */
2462  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
2463  int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
2464  );
2465 
2466 /** calculates a partition of the given set of binary variables into cliques; takes into account independent clique components
2467  *
2468  * The algorithm performs the following steps:
2469  * - recomputes connected components of the clique table, if necessary
2470  * - computes a clique partition for every connected component greedily.
2471  * - relabels the resulting clique partition such that it satisfies the description below
2472  *
2473  * afterwards the output array contains one value for each variable, such that two variables got the same value iff they
2474  * were assigned to the same clique;
2475  * the first variable is always assigned to clique 0, and a variable can only be assigned to clique i if at least one of
2476  * the preceding variables was assigned to clique i-1;
2477  * for each clique at most 1 variables can be set to TRUE in a feasible solution;
2478  *
2479  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2480  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2481  *
2482  * @pre This method can be called if @p scip is in one of the following stages:
2483  * - \ref SCIP_STAGE_INITPRESOLVE
2484  * - \ref SCIP_STAGE_PRESOLVING
2485  * - \ref SCIP_STAGE_EXITPRESOLVE
2486  * - \ref SCIP_STAGE_PRESOLVED
2487  * - \ref SCIP_STAGE_SOLVING
2488  */
2489 extern
2490 SCIP_RETCODE SCIPcalcCliquePartition(
2491  SCIP*const scip, /**< SCIP data structure */
2492  SCIP_VAR**const vars, /**< binary variables in the clique from which at most one can be set to 1 */
2493  int const nvars, /**< number of variables in the clique */
2494  int*const cliquepartition, /**< array of length nvars to store the clique partition */
2495  int*const ncliques /**< pointer to store the number of cliques actually contained in the partition */
2496  );
2497 
2498 /** calculates a partition of the given set of binary variables into negated cliques;
2499  * afterwards the output array contains one value for each variable, such that two variables got the same value iff they
2500  * were assigned to the same negated clique;
2501  * the first variable is always assigned to clique 0 and a variable can only be assigned to clique i if at least one of
2502  * the preceding variables was assigned to clique i-1;
2503  * for each clique with n_c variables at least n_c-1 variables can be set to TRUE in a feasible solution;
2504  *
2505  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2506  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2507  *
2508  * @pre This method can be called if @p scip is in one of the following stages:
2509  * - \ref SCIP_STAGE_INITPRESOLVE
2510  * - \ref SCIP_STAGE_PRESOLVING
2511  * - \ref SCIP_STAGE_EXITPRESOLVE
2512  * - \ref SCIP_STAGE_PRESOLVED
2513  * - \ref SCIP_STAGE_SOLVING
2514  */
2515 extern
2516 SCIP_RETCODE SCIPcalcNegatedCliquePartition(
2517  SCIP*const scip, /**< SCIP data structure */
2518  SCIP_VAR**const vars, /**< binary variables in the clique from which at most one can be set to 1 */
2519  int const nvars, /**< number of variables in the clique */
2520  int*const cliquepartition, /**< array of length nvars to store the clique partition */
2521  int*const ncliques /**< pointer to store the number of cliques actually contained in the partition */
2522  );
2523 
2524 /** force SCIP to clean up all cliques; cliques do not get automatically cleaned up after presolving. Use
2525  * this method to prevent inactive variables in cliques when retrieved via SCIPgetCliques()
2526  *
2527  * @return SCIP_OKAY if everything worked, otherwise a suitable error code is passed
2528  *
2529  * @pre This method can be called if @p scip is in one of the following stages:
2530  * - \ref SCIP_STAGE_TRANSFORMED
2531  * - \ref SCIP_STAGE_INITPRESOLVE
2532  * - \ref SCIP_STAGE_PRESOLVING
2533  * - \ref SCIP_STAGE_EXITPRESOLVE
2534  * - \ref SCIP_STAGE_PRESOLVED
2535  * - \ref SCIP_STAGE_INITSOLVE
2536  * - \ref SCIP_STAGE_SOLVING
2537  * - \ref SCIP_STAGE_SOLVED
2538  * - \ref SCIP_STAGE_EXITSOLVE
2539  */
2540 extern
2541 SCIP_RETCODE SCIPcleanupCliques(
2542  SCIP* scip, /**< SCIP data structure */
2543  SCIP_Bool* infeasible /**< pointer to store if cleanup detected infeasibility */
2544  );
2545 
2546 /** gets the number of cliques in the clique table
2547  *
2548  * @return number of cliques in the clique table
2549  *
2550  * @pre This method can be called if @p scip is in one of the following stages:
2551  * - \ref SCIP_STAGE_TRANSFORMED
2552  * - \ref SCIP_STAGE_INITPRESOLVE
2553  * - \ref SCIP_STAGE_PRESOLVING
2554  * - \ref SCIP_STAGE_EXITPRESOLVE
2555  * - \ref SCIP_STAGE_PRESOLVED
2556  * - \ref SCIP_STAGE_INITSOLVE
2557  * - \ref SCIP_STAGE_SOLVING
2558  * - \ref SCIP_STAGE_SOLVED
2559  * - \ref SCIP_STAGE_EXITSOLVE
2560  */
2561 extern
2562 int SCIPgetNCliques(
2563  SCIP* scip /**< SCIP data structure */
2564  );
2565 
2566 /** gets the number of cliques created so far by the cliquetable
2567  *
2568  * @return number of cliques created so far by the cliquetable
2569  *
2570  * @pre This method can be called if @p scip is in one of the following stages:
2571  * - \ref SCIP_STAGE_TRANSFORMED
2572  * - \ref SCIP_STAGE_INITPRESOLVE
2573  * - \ref SCIP_STAGE_PRESOLVING
2574  * - \ref SCIP_STAGE_EXITPRESOLVE
2575  * - \ref SCIP_STAGE_PRESOLVED
2576  * - \ref SCIP_STAGE_INITSOLVE
2577  * - \ref SCIP_STAGE_SOLVING
2578  * - \ref SCIP_STAGE_SOLVED
2579  * - \ref SCIP_STAGE_EXITSOLVE
2580  */
2581 extern
2582 int SCIPgetNCliquesCreated(
2583  SCIP* scip /**< SCIP data structure */
2584  );
2585 
2586 /** gets the array of cliques in the clique table
2587  *
2588  * @return array of cliques in the clique table
2589  *
2590  * @pre This method can be called if @p scip is in one of the following stages:
2591  * - \ref SCIP_STAGE_TRANSFORMED
2592  * - \ref SCIP_STAGE_INITPRESOLVE
2593  * - \ref SCIP_STAGE_PRESOLVING
2594  * - \ref SCIP_STAGE_EXITPRESOLVE
2595  * - \ref SCIP_STAGE_PRESOLVED
2596  * - \ref SCIP_STAGE_INITSOLVE
2597  * - \ref SCIP_STAGE_SOLVING
2598  * - \ref SCIP_STAGE_SOLVED
2599  * - \ref SCIP_STAGE_EXITSOLVE
2600  */
2601 extern
2602 SCIP_CLIQUE** SCIPgetCliques(
2603  SCIP* scip /**< SCIP data structure */
2604  );
2605 
2606 /** returns whether there is a clique that contains both given variable/value pairs;
2607  * the variables must be active binary variables;
2608  * if regardimplics is FALSE, only the cliques in the clique table are looked at;
2609  * if regardimplics is TRUE, both the cliques and the implications of the implication graph are regarded
2610  *
2611  * @return TRUE, if there is a clique that contains both variable/clique pairs; FALSE, otherwise
2612  *
2613  * @pre This method can be called if @p scip is in one of the following stages:
2614  * - \ref SCIP_STAGE_TRANSFORMED
2615  * - \ref SCIP_STAGE_INITPRESOLVE
2616  * - \ref SCIP_STAGE_PRESOLVING
2617  * - \ref SCIP_STAGE_EXITPRESOLVE
2618  * - \ref SCIP_STAGE_PRESOLVED
2619  * - \ref SCIP_STAGE_INITSOLVE
2620  * - \ref SCIP_STAGE_SOLVING
2621  * - \ref SCIP_STAGE_SOLVED
2622  * - \ref SCIP_STAGE_EXITSOLVE
2623  *
2624  * @note a variable with it's negated variable are NOT! in a clique
2625  * @note a variable with itself are in a clique
2626  */
2627 extern
2628 SCIP_Bool SCIPhaveVarsCommonClique(
2629  SCIP* scip, /**< SCIP data structure */
2630  SCIP_VAR* var1, /**< first variable */
2631  SCIP_Bool value1, /**< value of first variable */
2632  SCIP_VAR* var2, /**< second variable */
2633  SCIP_Bool value2, /**< value of second variable */
2634  SCIP_Bool regardimplics /**< should the implication graph also be searched for a clique? */
2635  );
2636 
2637 /** writes the clique graph to a gml file
2638  *
2639  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2640  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2641  *
2642  * @pre This method can be called if @p scip is in one of the following stages:
2643  * - \ref SCIP_STAGE_TRANSFORMED
2644  * - \ref SCIP_STAGE_INITPRESOLVE
2645  * - \ref SCIP_STAGE_PRESOLVING
2646  * - \ref SCIP_STAGE_EXITPRESOLVE
2647  * - \ref SCIP_STAGE_PRESOLVED
2648  * - \ref SCIP_STAGE_INITSOLVE
2649  * - \ref SCIP_STAGE_SOLVING
2650  * - \ref SCIP_STAGE_SOLVED
2651  * - \ref SCIP_STAGE_EXITSOLVE
2652  *
2653  * @note there can be duplicated arcs in the output file
2654  *
2655  * If @p writenodeweights is true, only nodes corresponding to variables that have a fractional value and only edges
2656  * between such nodes are written.
2657  */
2658 extern
2659 SCIP_RETCODE SCIPwriteCliqueGraph(
2660  SCIP* scip, /**< SCIP data structure */
2661  const char* fname, /**< name of file */
2662  SCIP_Bool writenodeweights /**< should we write weights of nodes? */
2663  );
2664 
2665 /** Removes (irrelevant) variable from all its global structures, i.e. cliques, implications and variable bounds.
2666  * This is an advanced method which should be used with care.
2667  *
2668  * @return SCIP_OKAY if everything worked, otherwise a suitable error code is passed
2669  *
2670  * @pre This method can be called if @p scip is in one of the following stages:
2671  * - \ref SCIP_STAGE_TRANSFORMED
2672  * - \ref SCIP_STAGE_INITPRESOLVE
2673  * - \ref SCIP_STAGE_PRESOLVING
2674  * - \ref SCIP_STAGE_EXITPRESOLVE
2675  * - \ref SCIP_STAGE_PRESOLVED
2676  * - \ref SCIP_STAGE_INITSOLVE
2677  * - \ref SCIP_STAGE_SOLVING
2678  * - \ref SCIP_STAGE_SOLVED
2679  * - \ref SCIP_STAGE_EXITSOLVE
2680  */
2681 extern
2682 SCIP_RETCODE SCIPremoveVarFromGlobalStructures(
2683  SCIP* scip, /**< SCIP data structure */
2684  SCIP_VAR* var /**< variable to remove from global structures */
2685  );
2686 
2687 /** sets the branch factor of the variable; this value can be used in the branching methods to scale the score
2688  * values of the variables; higher factor leads to a higher probability that this variable is chosen for branching
2689  *
2690  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2691  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2692  *
2693  * @pre This method can be called if @p scip is in one of the following stages:
2694  * - \ref SCIP_STAGE_PROBLEM
2695  * - \ref SCIP_STAGE_TRANSFORMING
2696  * - \ref SCIP_STAGE_TRANSFORMED
2697  * - \ref SCIP_STAGE_INITPRESOLVE
2698  * - \ref SCIP_STAGE_PRESOLVING
2699  * - \ref SCIP_STAGE_EXITPRESOLVE
2700  * - \ref SCIP_STAGE_PRESOLVED
2701  * - \ref SCIP_STAGE_SOLVING
2702  */
2703 extern
2704 SCIP_RETCODE SCIPchgVarBranchFactor(
2705  SCIP* scip, /**< SCIP data structure */
2706  SCIP_VAR* var, /**< problem variable */
2707  SCIP_Real branchfactor /**< factor to weigh variable's branching score with */
2708  );
2709 
2710 /** scales the branch factor of the variable with the given value
2711  *
2712  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2713  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2714  *
2715  * @pre This method can be called if @p scip is in one of the following stages:
2716  * - \ref SCIP_STAGE_PROBLEM
2717  * - \ref SCIP_STAGE_TRANSFORMING
2718  * - \ref SCIP_STAGE_TRANSFORMED
2719  * - \ref SCIP_STAGE_INITPRESOLVE
2720  * - \ref SCIP_STAGE_PRESOLVING
2721  * - \ref SCIP_STAGE_EXITPRESOLVE
2722  * - \ref SCIP_STAGE_PRESOLVED
2723  * - \ref SCIP_STAGE_SOLVING
2724  */
2725 extern
2726 SCIP_RETCODE SCIPscaleVarBranchFactor(
2727  SCIP* scip, /**< SCIP data structure */
2728  SCIP_VAR* var, /**< problem variable */
2729  SCIP_Real scale /**< factor to scale variable's branching factor with */
2730  );
2731 
2732 /** adds the given value to the branch factor of the variable
2733  *
2734  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2735  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2736  *
2737  * @pre This method can be called if @p scip is in one of the following stages:
2738  * - \ref SCIP_STAGE_PROBLEM
2739  * - \ref SCIP_STAGE_TRANSFORMING
2740  * - \ref SCIP_STAGE_TRANSFORMED
2741  * - \ref SCIP_STAGE_INITPRESOLVE
2742  * - \ref SCIP_STAGE_PRESOLVING
2743  * - \ref SCIP_STAGE_EXITPRESOLVE
2744  * - \ref SCIP_STAGE_PRESOLVED
2745  * - \ref SCIP_STAGE_SOLVING
2746  */
2747 extern
2748 SCIP_RETCODE SCIPaddVarBranchFactor(
2749  SCIP* scip, /**< SCIP data structure */
2750  SCIP_VAR* var, /**< problem variable */
2751  SCIP_Real addfactor /**< value to add to the branch factor of the variable */
2752  );
2753 
2754 /** sets the branch priority of the variable; variables with higher branch priority are always preferred to variables
2755  * with lower priority in selection of branching variable
2756  *
2757  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2758  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2759  *
2760  * @pre This method can be called if @p scip is in one of the following stages:
2761  * - \ref SCIP_STAGE_PROBLEM
2762  * - \ref SCIP_STAGE_TRANSFORMING
2763  * - \ref SCIP_STAGE_TRANSFORMED
2764  * - \ref SCIP_STAGE_INITPRESOLVE
2765  * - \ref SCIP_STAGE_PRESOLVING
2766  * - \ref SCIP_STAGE_EXITPRESOLVE
2767  * - \ref SCIP_STAGE_PRESOLVED
2768  * - \ref SCIP_STAGE_SOLVING
2769  *
2770  * @note the default branching priority is 0
2771  */
2772 extern
2773 SCIP_RETCODE SCIPchgVarBranchPriority(
2774  SCIP* scip, /**< SCIP data structure */
2775  SCIP_VAR* var, /**< problem variable */
2776  int branchpriority /**< branch priority of the variable */
2777  );
2778 
2779 /** changes the branch priority of the variable to the given value, if it is larger than the current priority
2780  *
2781  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2782  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2783  *
2784  * @pre This method can be called if @p scip is in one of the following stages:
2785  * - \ref SCIP_STAGE_PROBLEM
2786  * - \ref SCIP_STAGE_TRANSFORMING
2787  * - \ref SCIP_STAGE_TRANSFORMED
2788  * - \ref SCIP_STAGE_INITPRESOLVE
2789  * - \ref SCIP_STAGE_PRESOLVING
2790  * - \ref SCIP_STAGE_EXITPRESOLVE
2791  * - \ref SCIP_STAGE_PRESOLVED
2792  * - \ref SCIP_STAGE_SOLVING
2793  */
2794 extern
2795 SCIP_RETCODE SCIPupdateVarBranchPriority(
2796  SCIP* scip, /**< SCIP data structure */
2797  SCIP_VAR* var, /**< problem variable */
2798  int branchpriority /**< new branch priority of the variable, if it is larger than current priority */
2799  );
2800 
2801 /** adds the given value to the branch priority of the variable
2802  *
2803  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2804  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2805  *
2806  * @pre This method can be called if @p scip is in one of the following stages:
2807  * - \ref SCIP_STAGE_PROBLEM
2808  * - \ref SCIP_STAGE_TRANSFORMING
2809  * - \ref SCIP_STAGE_TRANSFORMED
2810  * - \ref SCIP_STAGE_INITPRESOLVE
2811  * - \ref SCIP_STAGE_PRESOLVING
2812  * - \ref SCIP_STAGE_EXITPRESOLVE
2813  * - \ref SCIP_STAGE_PRESOLVED
2814  * - \ref SCIP_STAGE_SOLVING
2815  */
2816 extern
2817 SCIP_RETCODE SCIPaddVarBranchPriority(
2818  SCIP* scip, /**< SCIP data structure */
2819  SCIP_VAR* var, /**< problem variable */
2820  int addpriority /**< value to add to the branch priority of the variable */
2821  );
2822 
2823 /** sets the branch direction of the variable (-1: prefer downwards branch, 0: automatic selection, +1: prefer upwards
2824  * branch)
2825  *
2826  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2827  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2828  *
2829  * @pre This method can be called if @p scip is in one of the following stages:
2830  * - \ref SCIP_STAGE_PROBLEM
2831  * - \ref SCIP_STAGE_TRANSFORMING
2832  * - \ref SCIP_STAGE_TRANSFORMED
2833  * - \ref SCIP_STAGE_INITPRESOLVE
2834  * - \ref SCIP_STAGE_PRESOLVING
2835  * - \ref SCIP_STAGE_EXITPRESOLVE
2836  * - \ref SCIP_STAGE_PRESOLVED
2837  * - \ref SCIP_STAGE_SOLVING
2838  */
2839 extern
2840 SCIP_RETCODE SCIPchgVarBranchDirection(
2841  SCIP* scip, /**< SCIP data structure */
2842  SCIP_VAR* var, /**< problem variable */
2843  SCIP_BRANCHDIR branchdirection /**< preferred branch direction of the variable (downwards, upwards, auto) */
2844  );
2845 
2846 /** changes type of variable in the problem;
2847  *
2848  * @warning This type change might change the variable array returned from SCIPgetVars() and SCIPgetVarsData();
2849  *
2850  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2851  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2852  *
2853  * @pre This method can be called if @p scip is in one of the following stages:
2854  * - \ref SCIP_STAGE_PROBLEM
2855  * - \ref SCIP_STAGE_TRANSFORMING
2856  * - \ref SCIP_STAGE_PRESOLVING
2857  *
2858  * @note If SCIP is already beyond the SCIP_STAGE_PROBLEM and a original variable is passed, the variable type of the
2859  * corresponding transformed variable is changed; the type of the original variable does not change
2860  *
2861  * @note If the type changes from a continuous variable to a non-continuous variable the bounds of the variable get
2862  * adjusted w.r.t. to integrality information
2863  */
2864 extern
2865 SCIP_RETCODE SCIPchgVarType(
2866  SCIP* scip, /**< SCIP data structure */
2867  SCIP_VAR* var, /**< variable to change the bound for */
2868  SCIP_VARTYPE vartype, /**< new type of variable */
2869  SCIP_Bool* infeasible /**< pointer to store whether an infeasibility was detected (, due to
2870  * integrality condition of the new variable type) */
2871  );
2872 
2873 /** in problem creation and solving stage, both bounds of the variable are set to the given value;
2874  * in presolving stage, the variable is converted into a fixed variable, and bounds are changed respectively;
2875  * conversion into a fixed variable changes the vars array returned from SCIPgetVars() and SCIPgetVarsData(),
2876  * and also renders arrays returned from the SCIPvarGetImpl...() methods invalid
2877  *
2878  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2879  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2880  *
2881  * @pre This method can be called if @p scip is in one of the following stages:
2882  * - \ref SCIP_STAGE_PROBLEM
2883  * - \ref SCIP_STAGE_PRESOLVING
2884  * - \ref SCIP_STAGE_SOLVING
2885  */
2886 extern
2887 SCIP_RETCODE SCIPfixVar(
2888  SCIP* scip, /**< SCIP data structure */
2889  SCIP_VAR* var, /**< variable to fix */
2890  SCIP_Real fixedval, /**< value to fix variable to */
2891  SCIP_Bool* infeasible, /**< pointer to store whether the fixing is infeasible */
2892  SCIP_Bool* fixed /**< pointer to store whether the fixing was performed (variable was unfixed) */
2893  );
2894 
2895 /** From a given equality a*x + b*y == c, aggregates one of the variables and removes it from the set of
2896  * active problem variables. This changes the vars array returned from SCIPgetVars() and SCIPgetVarsData(),
2897  * and also renders the arrays returned from the SCIPvarGetImpl...() methods for the two variables invalid.
2898  * In the first step, the equality is transformed into an equality with active problem variables
2899  * a'*x' + b'*y' == c'. If x' == y', this leads to the detection of redundancy if a' == -b' and c' == 0,
2900  * of infeasibility, if a' == -b' and c' != 0, or to a variable fixing x' == c'/(a'+b') (and possible
2901  * infeasibility) otherwise.
2902  * In the second step, the variable to be aggregated is chosen among x' and y', prefering a less strict variable
2903  * type as aggregation variable (i.e. continuous variables are preferred over implicit integers, implicit integers
2904  * over integers, and integers over binaries). If none of the variables is continuous, it is tried to find an integer
2905  * aggregation (i.e. integral coefficients a'' and b'', such that a''*x' + b''*y' == c''). This can lead to
2906  * the detection of infeasibility (e.g. if c'' is fractional), or to a rejection of the aggregation (denoted by
2907  * aggregated == FALSE), if the resulting integer coefficients are too large and thus numerically instable.
2908  *
2909  * The output flags have the following meaning:
2910  * - infeasible: the problem is infeasible
2911  * - redundant: the equality can be deleted from the constraint set
2912  * - aggregated: the aggregation was successfully performed (the variables were not aggregated before)
2913  *
2914  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2915  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2916  *
2917  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_PRESOLVING
2918  */
2919 extern
2920 SCIP_RETCODE SCIPaggregateVars(
2921  SCIP* scip, /**< SCIP data structure */
2922  SCIP_VAR* varx, /**< variable x in equality a*x + b*y == c */
2923  SCIP_VAR* vary, /**< variable y in equality a*x + b*y == c */
2924  SCIP_Real scalarx, /**< multiplier a in equality a*x + b*y == c */
2925  SCIP_Real scalary, /**< multiplier b in equality a*x + b*y == c */
2926  SCIP_Real rhs, /**< right hand side c in equality a*x + b*y == c */
2927  SCIP_Bool* infeasible, /**< pointer to store whether the aggregation is infeasible */
2928  SCIP_Bool* redundant, /**< pointer to store whether the equality is (now) redundant */
2929  SCIP_Bool* aggregated /**< pointer to store whether the aggregation was successful */
2930  );
2931 
2932 /** converts variable into multi-aggregated variable; this changes the variable array returned from
2933  * SCIPgetVars() and SCIPgetVarsData();
2934  *
2935  * @warning The integrality condition is not checked anymore on the multi-aggregated variable. You must not
2936  * multi-aggregate an integer variable without being sure, that integrality on the aggregation variables
2937  * implies integrality on the aggregated variable.
2938  *
2939  * The output flags have the following meaning:
2940  * - infeasible: the problem is infeasible
2941  * - aggregated: the aggregation was successfully performed (the variables were not aggregated before)
2942  *
2943  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2944  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2945  *
2946  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_PRESOLVING
2947  */
2948 extern
2949 SCIP_RETCODE SCIPmultiaggregateVar(
2950  SCIP* scip, /**< SCIP data structure */
2951  SCIP_VAR* var, /**< variable x to aggregate */
2952  int naggvars, /**< number n of variables in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
2953  SCIP_VAR** aggvars, /**< variables y_i in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
2954  SCIP_Real* scalars, /**< multipliers a_i in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
2955  SCIP_Real constant, /**< constant shift c in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
2956  SCIP_Bool* infeasible, /**< pointer to store whether the aggregation is infeasible */
2957  SCIP_Bool* aggregated /**< pointer to store whether the aggregation was successful */
2958  );
2959 
2960 /** returns whether aggregation of variables is not allowed */
2961 extern
2962 SCIP_Bool SCIPdoNotAggr(
2963  SCIP* scip /**< SCIP data structure */
2964  );
2965 
2966 /** returns whether multi-aggregation is disabled */
2967 extern
2968 SCIP_Bool SCIPdoNotMultaggr(
2969  SCIP* scip /**< SCIP data structure */
2970  );
2971 
2972 /** returns whether variable is not allowed to be multi-aggregated */
2973 extern
2974 SCIP_Bool SCIPdoNotMultaggrVar(
2975  SCIP* scip, /**< SCIP data structure */
2976  SCIP_VAR* var /**< variable x to aggregate */
2977  );
2978 
2979 /** returns whether dual reductions are allowed during propagation and presolving
2980  *
2981  * @note A reduction is called dual, if it may discard feasible solutions, but leaves at least one optimal solution
2982  * intact. Often such reductions are based on analyzing the objective function, reduced costs, and/or dual LPs.
2983  */
2984 extern
2985 SCIP_Bool SCIPallowDualReds(
2986  SCIP* scip /**< SCIP data structure */
2987  );
2988 
2989 /** returns whether propagation w.r.t. current objective is allowed */
2990 extern
2991 SCIP_Bool SCIPallowObjProp(
2992  SCIP* scip /**< SCIP data structure */
2993  );
2994 
2995 /** marks the variable that it must not be multi-aggregated
2996  *
2997  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2998  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2999  *
3000  * @pre This method can be called if @p scip is in one of the following stages:
3001  * - \ref SCIP_STAGE_INIT
3002  * - \ref SCIP_STAGE_PROBLEM
3003  * - \ref SCIP_STAGE_TRANSFORMING
3004  * - \ref SCIP_STAGE_TRANSFORMED
3005  * - \ref SCIP_STAGE_INITPRESOLVE
3006  * - \ref SCIP_STAGE_PRESOLVING
3007  * - \ref SCIP_STAGE_EXITPRESOLVE
3008  *
3009  * @note There exists no "unmark" method since it has to be ensured that if a plugin requires that a variable is not
3010  * multi-aggregated that this is will be the case.
3011  */
3012 extern
3013 SCIP_RETCODE SCIPmarkDoNotMultaggrVar(
3014  SCIP* scip, /**< SCIP data structure */
3015  SCIP_VAR* var /**< variable to delete */
3016  );
3017 
3018 /** enables the collection of statistics for a variable
3019  *
3020  * @pre This method can be called if @p scip is in one of the following stages:
3021  * - \ref SCIP_STAGE_PROBLEM
3022  * - \ref SCIP_STAGE_INITPRESOLVE
3023  * - \ref SCIP_STAGE_PRESOLVING
3024  * - \ref SCIP_STAGE_EXITPRESOLVE
3025  * - \ref SCIP_STAGE_SOLVING
3026  * - \ref SCIP_STAGE_SOLVED
3027  */
3028 extern
3029 void SCIPenableVarHistory(
3030  SCIP* scip /**< SCIP data structure */
3031  );
3032 
3033 /** disables the collection of any statistic for a variable
3034  *
3035  * @pre This method can be called if @p scip is in one of the following stages:
3036  * - \ref SCIP_STAGE_PROBLEM
3037  * - \ref SCIP_STAGE_INITPRESOLVE
3038  * - \ref SCIP_STAGE_PRESOLVING
3039  * - \ref SCIP_STAGE_EXITPRESOLVE
3040  * - \ref SCIP_STAGE_SOLVING
3041  * - \ref SCIP_STAGE_SOLVED
3042  */
3043 extern
3044 void SCIPdisableVarHistory(
3045  SCIP* scip /**< SCIP data structure */
3046  );
3047 
3048 /** updates the pseudo costs of the given variable and the global pseudo costs after a change of "solvaldelta" in the
3049  * variable's solution value and resulting change of "objdelta" in the in the LP's objective value;
3050  * the update is ignored, if the objective value difference is infinite
3051  *
3052  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3053  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3054  *
3055  * @pre This method can be called if @p scip is in one of the following stages:
3056  * - \ref SCIP_STAGE_SOLVING
3057  * - \ref SCIP_STAGE_SOLVED
3058  */
3059 extern
3060 SCIP_RETCODE SCIPupdateVarPseudocost(
3061  SCIP* scip, /**< SCIP data structure */
3062  SCIP_VAR* var, /**< problem variable */
3063  SCIP_Real solvaldelta, /**< difference of variable's new LP value - old LP value */
3064  SCIP_Real objdelta, /**< difference of new LP's objective value - old LP's objective value */
3065  SCIP_Real weight /**< weight in (0,1] of this update in pseudo cost sum */
3066  );
3067 
3068 /** gets the variable's pseudo cost value for the given change of the variable's LP value
3069  *
3070  * @return the variable's pseudo cost value for the given change of the variable's LP value
3071  *
3072  * @pre This method can be called if @p scip is in one of the following stages:
3073  * - \ref SCIP_STAGE_INITPRESOLVE
3074  * - \ref SCIP_STAGE_PRESOLVING
3075  * - \ref SCIP_STAGE_EXITPRESOLVE
3076  * - \ref SCIP_STAGE_PRESOLVED
3077  * - \ref SCIP_STAGE_INITSOLVE
3078  * - \ref SCIP_STAGE_SOLVING
3079  * - \ref SCIP_STAGE_SOLVED
3080  */
3081 extern
3082 SCIP_Real SCIPgetVarPseudocostVal(
3083  SCIP* scip, /**< SCIP data structure */
3084  SCIP_VAR* var, /**< problem variable */
3085  SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
3086  );
3087 
3088 /** gets the variable's pseudo cost value for the given change of the variable's LP value,
3089  * only using the pseudo cost information of the current run
3090  *
3091  * @return the variable's pseudo cost value for the given change of the variable's LP value,
3092  * only using the pseudo cost information of the current run
3093  *
3094  * @pre This method can be called if @p scip is in one of the following stages:
3095  * - \ref SCIP_STAGE_INITPRESOLVE
3096  * - \ref SCIP_STAGE_PRESOLVING
3097  * - \ref SCIP_STAGE_EXITPRESOLVE
3098  * - \ref SCIP_STAGE_PRESOLVED
3099  * - \ref SCIP_STAGE_INITSOLVE
3100  * - \ref SCIP_STAGE_SOLVING
3101  * - \ref SCIP_STAGE_SOLVED
3102  */
3103 extern
3104 SCIP_Real SCIPgetVarPseudocostValCurrentRun(
3105  SCIP* scip, /**< SCIP data structure */
3106  SCIP_VAR* var, /**< problem variable */
3107  SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
3108  );
3109 
3110 /** gets the variable's pseudo cost value for the given direction
3111  *
3112  * @return the variable's pseudo cost value for the given direction
3113  *
3114  * @pre This method can be called if @p scip is in one of the following stages:
3115  * - \ref SCIP_STAGE_INITPRESOLVE
3116  * - \ref SCIP_STAGE_PRESOLVING
3117  * - \ref SCIP_STAGE_EXITPRESOLVE
3118  * - \ref SCIP_STAGE_PRESOLVED
3119  * - \ref SCIP_STAGE_INITSOLVE
3120  * - \ref SCIP_STAGE_SOLVING
3121  * - \ref SCIP_STAGE_SOLVED
3122  */
3123 extern
3124 SCIP_Real SCIPgetVarPseudocost(
3125  SCIP* scip, /**< SCIP data structure */
3126  SCIP_VAR* var, /**< problem variable */
3127  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
3128  );
3129 
3130 /** gets the variable's pseudo cost value for the given direction,
3131  * only using the pseudo cost information of the current run
3132  *
3133  * @return the variable's pseudo cost value for the given direction,
3134  * only using the pseudo cost information of the current run
3135  *
3136  * @pre This method can be called if @p scip is in one of the following stages:
3137  * - \ref SCIP_STAGE_INITPRESOLVE
3138  * - \ref SCIP_STAGE_PRESOLVING
3139  * - \ref SCIP_STAGE_EXITPRESOLVE
3140  * - \ref SCIP_STAGE_PRESOLVED
3141  * - \ref SCIP_STAGE_INITSOLVE
3142  * - \ref SCIP_STAGE_SOLVING
3143  * - \ref SCIP_STAGE_SOLVED
3144  */
3145 extern
3146 SCIP_Real SCIPgetVarPseudocostCurrentRun(
3147  SCIP* scip, /**< SCIP data structure */
3148  SCIP_VAR* var, /**< problem variable */
3149  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
3150  );
3151 
3152 /** gets the variable's (possible fractional) number of pseudo cost updates for the given direction
3153  *
3154  * @return the variable's (possible fractional) number of pseudo cost updates for the given direction
3155  *
3156  * @pre This method can be called if @p scip is in one of the following stages:
3157  * - \ref SCIP_STAGE_INITPRESOLVE
3158  * - \ref SCIP_STAGE_PRESOLVING
3159  * - \ref SCIP_STAGE_EXITPRESOLVE
3160  * - \ref SCIP_STAGE_PRESOLVED
3161  * - \ref SCIP_STAGE_INITSOLVE
3162  * - \ref SCIP_STAGE_SOLVING
3163  * - \ref SCIP_STAGE_SOLVED
3164  */
3165 extern
3166 SCIP_Real SCIPgetVarPseudocostCount(
3167  SCIP* scip, /**< SCIP data structure */
3168  SCIP_VAR* var, /**< problem variable */
3169  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
3170  );
3171 
3172 /** gets the variable's (possible fractional) number of pseudo cost updates for the given direction,
3173  * only using the pseudo cost information of the current run
3174  *
3175  * @return the variable's (possible fractional) number of pseudo cost updates for the given direction,
3176  * only using the pseudo cost information of the current run
3177  *
3178  * @pre This method can be called if @p scip is in one of the following stages:
3179  * - \ref SCIP_STAGE_INITPRESOLVE
3180  * - \ref SCIP_STAGE_PRESOLVING
3181  * - \ref SCIP_STAGE_EXITPRESOLVE
3182  * - \ref SCIP_STAGE_PRESOLVED
3183  * - \ref SCIP_STAGE_INITSOLVE
3184  * - \ref SCIP_STAGE_SOLVING
3185  * - \ref SCIP_STAGE_SOLVED
3186  */
3187 extern
3188 SCIP_Real SCIPgetVarPseudocostCountCurrentRun(
3189  SCIP* scip, /**< SCIP data structure */
3190  SCIP_VAR* var, /**< problem variable */
3191  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
3192  );
3193 
3194 /** get pseudo cost variance of the variable, either for entire solve or only for current branch and bound run
3195  *
3196  * @return returns the (corrected) variance of pseudo code information collected so far.
3197  *
3198  * @pre This method can be called if @p scip is in one of the following stages:
3199  * - \ref SCIP_STAGE_INITPRESOLVE
3200  * - \ref SCIP_STAGE_PRESOLVING
3201  * - \ref SCIP_STAGE_EXITPRESOLVE
3202  * - \ref SCIP_STAGE_PRESOLVED
3203  * - \ref SCIP_STAGE_INITSOLVE
3204  * - \ref SCIP_STAGE_SOLVING
3205  * - \ref SCIP_STAGE_SOLVED
3206  */
3207 extern
3208 SCIP_Real SCIPgetVarPseudocostVariance(
3209  SCIP* scip, /**< SCIP data structure */
3210  SCIP_VAR* var, /**< problem variable */
3211  SCIP_BRANCHDIR dir, /**< branching direction (downwards, or upwards) */
3212  SCIP_Bool onlycurrentrun /**< only for pseudo costs of current branch and bound run */
3213  );
3214 
3215 /** calculates a confidence bound for this variable under the assumption of normally distributed pseudo costs
3216  *
3217  * The confidence bound \f$ \theta \geq 0\f$ denotes the interval borders \f$ [X - \theta, \ X + \theta]\f$, which contains
3218  * the true pseudo costs of the variable, i.e., the expected value of the normal distribution, with a probability
3219  * of 2 * clevel - 1.
3220  *
3221  * @return value of confidence bound for this variable
3222  */
3223 extern
3224 SCIP_Real SCIPcalculatePscostConfidenceBound(
3225  SCIP* scip, /**< SCIP data structure */
3226  SCIP_VAR* var, /**< variable in question */
3227  SCIP_BRANCHDIR dir, /**< the branching direction for the confidence bound */
3228  SCIP_Bool onlycurrentrun, /**< should only the current run be taken into account */
3229  SCIP_CONFIDENCELEVEL clevel /**< confidence level for the interval */
3230  );
3231 
3232 /** check if variable pseudo-costs have a significant difference in location. The significance depends on
3233  * the choice of \p clevel and on the kind of tested hypothesis. The one-sided hypothesis, which
3234  * should be rejected, is that fracy * mu_y >= fracx * mu_x, where mu_y and mu_x denote the
3235  * unknown location means of the underlying pseudo-cost distributions of x and y.
3236  *
3237  * This method is applied best if variable x has a better pseudo-cost score than y. The method hypothesizes that y were actually
3238  * better than x (despite the current information), meaning that y can be expected to yield branching
3239  * decisions as least as good as x in the long run. If the method returns TRUE, the current history information is
3240  * sufficient to safely rely on the alternative hypothesis that x yields indeed a better branching score (on average)
3241  * than y.
3242  *
3243  * @note The order of x and y matters for the one-sided hypothesis
3244  *
3245  * @note set \p onesided to FALSE if you are not sure which variable is better. The hypothesis tested then reads
3246  * fracy * mu_y == fracx * mu_x vs the alternative hypothesis fracy * mu_y != fracx * mu_x.
3247  *
3248  * @return TRUE if the hypothesis can be safely rejected at the given confidence level
3249  */
3250 extern
3251 SCIP_Bool SCIPsignificantVarPscostDifference(
3252  SCIP* scip, /**< SCIP data structure */
3253  SCIP_VAR* varx, /**< variable x */
3254  SCIP_Real fracx, /**< the fractionality of variable x */
3255  SCIP_VAR* vary, /**< variable y */
3256  SCIP_Real fracy, /**< the fractionality of variable y */
3257  SCIP_BRANCHDIR dir, /**< branching direction */
3258  SCIP_CONFIDENCELEVEL clevel, /**< confidence level for rejecting hypothesis */
3259  SCIP_Bool onesided /**< should a one-sided hypothesis y >= x be tested? */
3260  );
3261 
3262 /** tests at a given confidence level whether the variable pseudo-costs only have a small probability to
3263  * exceed a \p threshold. This is useful to determine if past observations provide enough evidence
3264  * to skip an expensive strong-branching step if there is already a candidate that has been proven to yield an improvement
3265  * of at least \p threshold.
3266  *
3267  * @note use \p clevel to adjust the level of confidence. For SCIP_CONFIDENCELEVEL_MIN, the method returns TRUE if
3268  * the estimated probability to exceed \p threshold is less than 25 %.
3269  *
3270  * @see SCIP_Confidencelevel for a list of available levels. The used probability limits refer to the one-sided levels
3271  * of confidence.
3272  *
3273  * @return TRUE if the variable pseudo-cost probabilistic model is likely to be smaller than \p threshold
3274  * at the given confidence level \p clevel.
3275  */
3276 extern
3277 SCIP_Bool SCIPpscostThresholdProbabilityTest(
3278  SCIP* scip, /**< SCIP data structure */
3279  SCIP_VAR* var, /**< variable x */
3280  SCIP_Real frac, /**< the fractionality of variable x */
3281  SCIP_Real threshold, /**< the threshold to test against */
3282  SCIP_BRANCHDIR dir, /**< branching direction */
3283  SCIP_CONFIDENCELEVEL clevel /**< confidence level for rejecting hypothesis */
3284  );
3285 
3286 /** check if the current pseudo cost relative error in a direction violates the given threshold. The Relative
3287  * Error is calculated at a specific confidence level
3288  *
3289  * @return TRUE if relative error in variable pseudo costs is smaller than \p threshold
3290  */
3291 extern
3292 SCIP_Bool SCIPisVarPscostRelerrorReliable(
3293  SCIP* scip, /**< SCIP data structure */
3294  SCIP_VAR* var, /**< variable in question */
3295  SCIP_Real threshold, /**< threshold for relative errors to be considered reliable (enough) */
3296  SCIP_CONFIDENCELEVEL clevel /**< a given confidence level */
3297  );
3298 
3299 /** gets the variable's pseudo cost score value for the given LP solution value
3300  *
3301  * @return the variable's pseudo cost score value for the given LP solution value
3302  *
3303  * @pre This method can be called if @p scip is in one of the following stages:
3304  * - \ref SCIP_STAGE_INITPRESOLVE
3305  * - \ref SCIP_STAGE_PRESOLVING
3306  * - \ref SCIP_STAGE_EXITPRESOLVE
3307  * - \ref SCIP_STAGE_PRESOLVED
3308  * - \ref SCIP_STAGE_INITSOLVE
3309  * - \ref SCIP_STAGE_SOLVING
3310  * - \ref SCIP_STAGE_SOLVED
3311  */
3312 extern
3313 SCIP_Real SCIPgetVarPseudocostScore(
3314  SCIP* scip, /**< SCIP data structure */
3315  SCIP_VAR* var, /**< problem variable */
3316  SCIP_Real solval /**< variable's LP solution value */
3317  );
3318 
3319 /** gets the variable's pseudo cost score value for the given LP solution value,
3320  * only using the pseudo cost information of the current run
3321  *
3322  * @return the variable's pseudo cost score value for the given LP solution value,
3323  * only using the pseudo cost information of the current run
3324  *
3325  * @pre This method can be called if @p scip is in one of the following stages:
3326  * - \ref SCIP_STAGE_INITPRESOLVE
3327  * - \ref SCIP_STAGE_PRESOLVING
3328  * - \ref SCIP_STAGE_EXITPRESOLVE
3329  * - \ref SCIP_STAGE_PRESOLVED
3330  * - \ref SCIP_STAGE_INITSOLVE
3331  * - \ref SCIP_STAGE_SOLVING
3332  * - \ref SCIP_STAGE_SOLVED
3333  */
3334 extern
3335 SCIP_Real SCIPgetVarPseudocostScoreCurrentRun(
3336  SCIP* scip, /**< SCIP data structure */
3337  SCIP_VAR* var, /**< problem variable */
3338  SCIP_Real solval /**< variable's LP solution value */
3339  );
3340 
3341 /** returns the variable's VSIDS value
3342  *
3343  * @return the variable's VSIDS value
3344  *
3345  * @pre This method can be called if @p scip is in one of the following stages:
3346  * - \ref SCIP_STAGE_INITPRESOLVE
3347  * - \ref SCIP_STAGE_PRESOLVING
3348  * - \ref SCIP_STAGE_EXITPRESOLVE
3349  * - \ref SCIP_STAGE_PRESOLVED
3350  * - \ref SCIP_STAGE_INITSOLVE
3351  * - \ref SCIP_STAGE_SOLVING
3352  * - \ref SCIP_STAGE_SOLVED
3353  */
3354 extern
3355 SCIP_Real SCIPgetVarVSIDS(
3356  SCIP* scip, /**< SCIP data structure */
3357  SCIP_VAR* var, /**< problem variable */
3358  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
3359  );
3360 
3361 /** returns the variable's VSIDS value only using conflicts of the current run
3362  *
3363  * @return the variable's VSIDS value only using conflicts of the current run
3364  *
3365  * @pre This method can be called if @p scip is in one of the following stages:
3366  * - \ref SCIP_STAGE_INITPRESOLVE
3367  * - \ref SCIP_STAGE_PRESOLVING
3368  * - \ref SCIP_STAGE_EXITPRESOLVE
3369  * - \ref SCIP_STAGE_PRESOLVED
3370  * - \ref SCIP_STAGE_INITSOLVE
3371  * - \ref SCIP_STAGE_SOLVING
3372  * - \ref SCIP_STAGE_SOLVED
3373  */
3374 extern
3375 SCIP_Real SCIPgetVarVSIDSCurrentRun(
3376  SCIP* scip, /**< SCIP data structure */
3377  SCIP_VAR* var, /**< problem variable */
3378  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
3379  );
3380 
3381 /** returns the variable's conflict score value
3382  *
3383  * @return the variable's conflict score value
3384  *
3385  * @pre This method can be called if @p scip is in one of the following stages:
3386  * - \ref SCIP_STAGE_INITPRESOLVE
3387  * - \ref SCIP_STAGE_PRESOLVING
3388  * - \ref SCIP_STAGE_EXITPRESOLVE
3389  * - \ref SCIP_STAGE_PRESOLVED
3390  * - \ref SCIP_STAGE_INITSOLVE
3391  * - \ref SCIP_STAGE_SOLVING
3392  * - \ref SCIP_STAGE_SOLVED
3393  */
3394 extern
3395 SCIP_Real SCIPgetVarConflictScore(
3396  SCIP* scip, /**< SCIP data structure */
3397  SCIP_VAR* var /**< problem variable */
3398  );
3399 
3400 /** returns the variable's conflict score value only using conflicts of the current run
3401  *
3402  * @return the variable's conflict score value only using conflicts of the current run
3403  *
3404  * @pre This method can be called if @p scip is in one of the following stages:
3405  * - \ref SCIP_STAGE_INITPRESOLVE
3406  * - \ref SCIP_STAGE_PRESOLVING
3407  * - \ref SCIP_STAGE_EXITPRESOLVE
3408  * - \ref SCIP_STAGE_PRESOLVED
3409  * - \ref SCIP_STAGE_INITSOLVE
3410  * - \ref SCIP_STAGE_SOLVING
3411  * - \ref SCIP_STAGE_SOLVED
3412  */
3413 extern
3414 SCIP_Real SCIPgetVarConflictScoreCurrentRun(
3415  SCIP* scip, /**< SCIP data structure */
3416  SCIP_VAR* var /**< problem variable */
3417  );
3418 
3419 /** returns the variable's conflict length score
3420  *
3421  * @return the variable's conflict length score
3422  *
3423  * @pre This method can be called if @p scip is in one of the following stages:
3424  * - \ref SCIP_STAGE_INITPRESOLVE
3425  * - \ref SCIP_STAGE_PRESOLVING
3426  * - \ref SCIP_STAGE_EXITPRESOLVE
3427  * - \ref SCIP_STAGE_PRESOLVED
3428  * - \ref SCIP_STAGE_INITSOLVE
3429  * - \ref SCIP_STAGE_SOLVING
3430  * - \ref SCIP_STAGE_SOLVED
3431  */
3432 extern
3433 SCIP_Real SCIPgetVarConflictlengthScore(
3434  SCIP* scip, /**< SCIP data structure */
3435  SCIP_VAR* var /**< problem variable */
3436  );
3437 
3438 /** returns the variable's conflict length score only using conflicts of the current run
3439  *
3440  * @return the variable's conflict length score only using conflicts of the current run
3441  *
3442  * @pre This method can be called if @p scip is in one of the following stages:
3443  * - \ref SCIP_STAGE_INITPRESOLVE
3444  * - \ref SCIP_STAGE_PRESOLVING
3445  * - \ref SCIP_STAGE_EXITPRESOLVE
3446  * - \ref SCIP_STAGE_PRESOLVED
3447  * - \ref SCIP_STAGE_INITSOLVE
3448  * - \ref SCIP_STAGE_SOLVING
3449  * - \ref SCIP_STAGE_SOLVED
3450  */
3451 extern
3452 SCIP_Real SCIPgetVarConflictlengthScoreCurrentRun(
3453  SCIP* scip, /**< SCIP data structure */
3454  SCIP_VAR* var /**< problem variable */
3455  );
3456 
3457 /** returns the variable's average conflict length
3458  *
3459  * @return the variable's average conflict length
3460  *
3461  * @pre This method can be called if @p scip is in one of the following stages:
3462  * - \ref SCIP_STAGE_INITPRESOLVE
3463  * - \ref SCIP_STAGE_PRESOLVING
3464  * - \ref SCIP_STAGE_EXITPRESOLVE
3465  * - \ref SCIP_STAGE_PRESOLVED
3466  * - \ref SCIP_STAGE_INITSOLVE
3467  * - \ref SCIP_STAGE_SOLVING
3468  * - \ref SCIP_STAGE_SOLVED
3469  */
3470 extern
3471 SCIP_Real SCIPgetVarAvgConflictlength(
3472  SCIP* scip, /**< SCIP data structure */
3473  SCIP_VAR* var, /**< problem variable */
3474  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
3475  );
3476 
3477 /** returns the variable's average conflict length only using conflicts of the current run
3478  *
3479  * @return the variable's average conflict length only using conflicts of the current run
3480  *
3481  * @pre This method can be called if @p scip is in one of the following stages:
3482  * - \ref SCIP_STAGE_INITPRESOLVE
3483  * - \ref SCIP_STAGE_PRESOLVING
3484  * - \ref SCIP_STAGE_EXITPRESOLVE
3485  * - \ref SCIP_STAGE_PRESOLVED
3486  * - \ref SCIP_STAGE_INITSOLVE
3487  * - \ref SCIP_STAGE_SOLVING
3488  * - \ref SCIP_STAGE_SOLVED
3489  */
3490 extern
3491 SCIP_Real SCIPgetVarAvgConflictlengthCurrentRun(
3492  SCIP* scip, /**< SCIP data structure */
3493  SCIP_VAR* var, /**< problem variable */
3494  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
3495  );
3496 
3497 /** returns the average number of inferences found after branching on the variable in given direction;
3498  * if branching on the variable in the given direction was yet evaluated, the average number of inferences
3499  * over all variables for branching in the given direction is returned
3500  *
3501  * @return the average number of inferences found after branching on the variable in given direction
3502  *
3503  * @pre This method can be called if @p scip is in one of the following stages:
3504  * - \ref SCIP_STAGE_INITPRESOLVE
3505  * - \ref SCIP_STAGE_PRESOLVING
3506  * - \ref SCIP_STAGE_EXITPRESOLVE
3507  * - \ref SCIP_STAGE_PRESOLVED
3508  * - \ref SCIP_STAGE_INITSOLVE
3509  * - \ref SCIP_STAGE_SOLVING
3510  * - \ref SCIP_STAGE_SOLVED
3511  */
3512 extern
3513 SCIP_Real SCIPgetVarAvgInferences(
3514  SCIP* scip, /**< SCIP data structure */
3515  SCIP_VAR* var, /**< problem variable */
3516  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
3517  );
3518 
3519 /** returns the average number of inferences found after branching on the variable in given direction in the current run;
3520  * if branching on the variable in the given direction was yet evaluated, the average number of inferences
3521  * over all variables for branching in the given direction is returned
3522  *
3523  * @return the average number of inferences found after branching on the variable in given direction in the current run
3524  *
3525  * @pre This method can be called if @p scip is in one of the following stages:
3526  * - \ref SCIP_STAGE_INITPRESOLVE
3527  * - \ref SCIP_STAGE_PRESOLVING
3528  * - \ref SCIP_STAGE_EXITPRESOLVE
3529  * - \ref SCIP_STAGE_PRESOLVED
3530  * - \ref SCIP_STAGE_INITSOLVE
3531  * - \ref SCIP_STAGE_SOLVING
3532  * - \ref SCIP_STAGE_SOLVED
3533  */
3534 extern
3535 SCIP_Real SCIPgetVarAvgInferencesCurrentRun(
3536  SCIP* scip, /**< SCIP data structure */
3537  SCIP_VAR* var, /**< problem variable */
3538  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
3539  );
3540 
3541 /** returns the variable's average inference score value
3542  *
3543  * @return the variable's average inference score value
3544  *
3545  * @pre This method can be called if @p scip is in one of the following stages:
3546  * - \ref SCIP_STAGE_INITPRESOLVE
3547  * - \ref SCIP_STAGE_PRESOLVING
3548  * - \ref SCIP_STAGE_EXITPRESOLVE
3549  * - \ref SCIP_STAGE_PRESOLVED
3550  * - \ref SCIP_STAGE_INITSOLVE
3551  * - \ref SCIP_STAGE_SOLVING
3552  * - \ref SCIP_STAGE_SOLVED
3553  */
3554 extern
3555 SCIP_Real SCIPgetVarAvgInferenceScore(
3556  SCIP* scip, /**< SCIP data structure */
3557  SCIP_VAR* var /**< problem variable */
3558  );
3559 
3560 /** returns the variable's average inference score value only using inferences of the current run
3561  *
3562  * @return the variable's average inference score value only using inferences of the current run
3563  *
3564  * @pre This method can be called if @p scip is in one of the following stages:
3565  * - \ref SCIP_STAGE_INITPRESOLVE
3566  * - \ref SCIP_STAGE_PRESOLVING
3567  * - \ref SCIP_STAGE_EXITPRESOLVE
3568  * - \ref SCIP_STAGE_PRESOLVED
3569  * - \ref SCIP_STAGE_INITSOLVE
3570  * - \ref SCIP_STAGE_SOLVING
3571  * - \ref SCIP_STAGE_SOLVED
3572  */
3573 extern
3574 SCIP_Real SCIPgetVarAvgInferenceScoreCurrentRun(
3575  SCIP* scip, /**< SCIP data structure */
3576  SCIP_VAR* var /**< problem variable */
3577  );
3578 
3579 /** initializes the upwards and downwards pseudocosts, conflict scores, conflict lengths, inference scores, cutoff scores
3580  * of a variable to the given values
3581  *
3582  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3583  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3584  *
3585  * @pre This method can be called if @p scip is in one of the following stages:
3586  * - \ref SCIP_STAGE_TRANSFORMED
3587  * - \ref SCIP_STAGE_INITPRESOLVE
3588  * - \ref SCIP_STAGE_PRESOLVING
3589  * - \ref SCIP_STAGE_EXITPRESOLVE
3590  * - \ref SCIP_STAGE_PRESOLVED
3591  * - \ref SCIP_STAGE_INITSOLVE
3592  * - \ref SCIP_STAGE_SOLVING
3593  */
3594 extern
3595 SCIP_RETCODE SCIPinitVarBranchStats(
3596  SCIP* scip, /**< SCIP data structure */
3597  SCIP_VAR* var, /**< variable which should be initialized */
3598  SCIP_Real downpscost, /**< value to which pseudocosts for downwards branching should be initialized */
3599  SCIP_Real uppscost, /**< value to which pseudocosts for upwards branching should be initialized */
3600  SCIP_Real downvsids, /**< value to which VSIDS score for downwards branching should be initialized */
3601  SCIP_Real upvsids, /**< value to which VSIDS score for upwards branching should be initialized */
3602  SCIP_Real downconflen, /**< value to which conflict length score for downwards branching should be initialized */
3603  SCIP_Real upconflen, /**< value to which conflict length score for upwards branching should be initialized */
3604  SCIP_Real downinfer, /**< value to which inference counter for downwards branching should be initialized */
3605  SCIP_Real upinfer, /**< value to which inference counter for upwards branching should be initialized */
3606  SCIP_Real downcutoff, /**< value to which cutoff counter for downwards branching should be initialized */
3607  SCIP_Real upcutoff /**< value to which cutoff counter for upwards branching should be initialized */
3608  );
3609 
3610 /** initializes the upwards and downwards conflict scores, conflict lengths, inference scores, cutoff scores of a
3611  * variable w.r.t. a value by the given values (SCIP_VALUEHISTORY)
3612  *
3613  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3614  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3615  *
3616  * @pre This method can be called if @p scip is in one of the following stages:
3617  * - \ref SCIP_STAGE_TRANSFORMED
3618  * - \ref SCIP_STAGE_INITPRESOLVE
3619  * - \ref SCIP_STAGE_PRESOLVING
3620  * - \ref SCIP_STAGE_EXITPRESOLVE
3621  * - \ref SCIP_STAGE_PRESOLVED
3622  * - \ref SCIP_STAGE_INITSOLVE
3623  * - \ref SCIP_STAGE_SOLVING
3624  */
3625 extern
3626 SCIP_RETCODE SCIPinitVarValueBranchStats(
3627  SCIP* scip, /**< SCIP data structure */
3628  SCIP_VAR* var, /**< variable which should be initialized */
3629  SCIP_Real value, /**< domain value, or SCIP_UNKNOWN */
3630  SCIP_Real downvsids, /**< value to which VSIDS score for downwards branching should be initialized */
3631  SCIP_Real upvsids, /**< value to which VSIDS score for upwards branching should be initialized */
3632  SCIP_Real downconflen, /**< value to which conflict length score for downwards branching should be initialized */
3633  SCIP_Real upconflen, /**< value to which conflict length score for upwards branching should be initialized */
3634  SCIP_Real downinfer, /**< value to which inference counter for downwards branching should be initialized */
3635  SCIP_Real upinfer, /**< value to which inference counter for upwards branching should be initialized */
3636  SCIP_Real downcutoff, /**< value to which cutoff counter for downwards branching should be initialized */
3637  SCIP_Real upcutoff /**< value to which cutoff counter for upwards branching should be initialized */
3638  );
3639 
3640 /** returns the average number of cutoffs found after branching on the variable in given direction;
3641  * if branching on the variable in the given direction was yet evaluated, the average number of cutoffs
3642  * over all variables for branching in the given direction is returned
3643  *
3644  * @return the average number of cutoffs found after branching on the variable in given direction
3645  *
3646  * @pre This method can be called if @p scip is in one of the following stages:
3647  * - \ref SCIP_STAGE_INITPRESOLVE
3648  * - \ref SCIP_STAGE_PRESOLVING
3649  * - \ref SCIP_STAGE_EXITPRESOLVE
3650  * - \ref SCIP_STAGE_PRESOLVED
3651  * - \ref SCIP_STAGE_INITSOLVE
3652  * - \ref SCIP_STAGE_SOLVING
3653  * - \ref SCIP_STAGE_SOLVED
3654  */
3655 extern
3656 SCIP_Real SCIPgetVarAvgCutoffs(
3657  SCIP* scip, /**< SCIP data structure */
3658  SCIP_VAR* var, /**< problem variable */
3659  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
3660  );
3661 
3662 /** returns the average number of cutoffs found after branching on the variable in given direction in the current run;
3663  * if branching on the variable in the given direction was yet evaluated, the average number of cutoffs
3664  * over all variables for branching in the given direction is returned
3665  *
3666  * @return the average number of cutoffs found after branching on the variable in given direction in the current run
3667  *
3668  * @pre This method can be called if @p scip is in one of the following stages:
3669  * - \ref SCIP_STAGE_INITPRESOLVE
3670  * - \ref SCIP_STAGE_PRESOLVING
3671  * - \ref SCIP_STAGE_EXITPRESOLVE
3672  * - \ref SCIP_STAGE_PRESOLVED
3673  * - \ref SCIP_STAGE_INITSOLVE
3674  * - \ref SCIP_STAGE_SOLVING
3675  * - \ref SCIP_STAGE_SOLVED
3676  */
3677 extern
3678 SCIP_Real SCIPgetVarAvgCutoffsCurrentRun(
3679  SCIP* scip, /**< SCIP data structure */
3680  SCIP_VAR* var, /**< problem variable */
3681  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
3682  );
3683 
3684 /** returns the variable's average cutoff score value
3685  *
3686  * @return the variable's average cutoff score value
3687  *
3688  * @pre This method can be called if @p scip is in one of the following stages:
3689  * - \ref SCIP_STAGE_INITPRESOLVE
3690  * - \ref SCIP_STAGE_PRESOLVING
3691  * - \ref SCIP_STAGE_EXITPRESOLVE
3692  * - \ref SCIP_STAGE_PRESOLVED
3693  * - \ref SCIP_STAGE_INITSOLVE
3694  * - \ref SCIP_STAGE_SOLVING
3695  * - \ref SCIP_STAGE_SOLVED
3696  */
3697 extern
3698 SCIP_Real SCIPgetVarAvgCutoffScore(
3699  SCIP* scip, /**< SCIP data structure */
3700  SCIP_VAR* var /**< problem variable */
3701  );
3702 
3703 /** returns the variable's average cutoff score value, only using cutoffs of the current run
3704  *
3705  * @return the variable's average cutoff score value, only using cutoffs of the current run
3706  *
3707  * @pre This method can be called if @p scip is in one of the following stages:
3708  * - \ref SCIP_STAGE_INITPRESOLVE
3709  * - \ref SCIP_STAGE_PRESOLVING
3710  * - \ref SCIP_STAGE_EXITPRESOLVE
3711  * - \ref SCIP_STAGE_PRESOLVED
3712  * - \ref SCIP_STAGE_INITSOLVE
3713  * - \ref SCIP_STAGE_SOLVING
3714  * - \ref SCIP_STAGE_SOLVED
3715  */
3716 extern
3717 SCIP_Real SCIPgetVarAvgCutoffScoreCurrentRun(
3718  SCIP* scip, /**< SCIP data structure */
3719  SCIP_VAR* var /**< problem variable */
3720  );
3721 
3722 /** returns the variable's average inference/cutoff score value, weighting the cutoffs of the variable with the given
3723  * factor
3724  *
3725  * @return the variable's average inference/cutoff score value
3726  *
3727  * @pre This method can be called if @p scip is in one of the following stages:
3728  * - \ref SCIP_STAGE_INITPRESOLVE
3729  * - \ref SCIP_STAGE_PRESOLVING
3730  * - \ref SCIP_STAGE_EXITPRESOLVE
3731  * - \ref SCIP_STAGE_PRESOLVED
3732  * - \ref SCIP_STAGE_INITSOLVE
3733  * - \ref SCIP_STAGE_SOLVING
3734  * - \ref SCIP_STAGE_SOLVED
3735  */
3736 extern
3737 SCIP_Real SCIPgetVarAvgInferenceCutoffScore(
3738  SCIP* scip, /**< SCIP data structure */
3739  SCIP_VAR* var, /**< problem variable */
3740  SCIP_Real cutoffweight /**< factor to weigh average number of cutoffs in branching score */
3741  );
3742 
3743 /** returns the variable's average inference/cutoff score value, weighting the cutoffs of the variable with the given
3744  * factor, only using inferences and cutoffs of the current run
3745  *
3746  * @return the variable's average inference/cutoff score value, only using inferences and cutoffs of the current run
3747  *
3748  * @pre This method can be called if @p scip is in one of the following stages:
3749  * - \ref SCIP_STAGE_INITPRESOLVE
3750  * - \ref SCIP_STAGE_PRESOLVING
3751  * - \ref SCIP_STAGE_EXITPRESOLVE
3752  * - \ref SCIP_STAGE_PRESOLVED
3753  * - \ref SCIP_STAGE_INITSOLVE
3754  * - \ref SCIP_STAGE_SOLVING
3755  * - \ref SCIP_STAGE_SOLVED
3756  */
3757 extern
3758 SCIP_Real SCIPgetVarAvgInferenceCutoffScoreCurrentRun(
3759  SCIP* scip, /**< SCIP data structure */
3760  SCIP_VAR* var, /**< problem variable */
3761  SCIP_Real cutoffweight /**< factor to weigh average number of cutoffs in branching score */
3762  );
3763 
3764 /** outputs variable information to file stream via the message system
3765  *
3766  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3767  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3768  *
3769  * @pre This method can be called if @p scip is in one of the following stages:
3770  * - \ref SCIP_STAGE_PROBLEM
3771  * - \ref SCIP_STAGE_TRANSFORMING
3772  * - \ref SCIP_STAGE_TRANSFORMED
3773  * - \ref SCIP_STAGE_INITPRESOLVE
3774  * - \ref SCIP_STAGE_PRESOLVING
3775  * - \ref SCIP_STAGE_EXITPRESOLVE
3776  * - \ref SCIP_STAGE_PRESOLVED
3777  * - \ref SCIP_STAGE_INITSOLVE
3778  * - \ref SCIP_STAGE_SOLVING
3779  * - \ref SCIP_STAGE_SOLVED
3780  * - \ref SCIP_STAGE_EXITSOLVE
3781  * - \ref SCIP_STAGE_FREETRANS
3782  *
3783  * @note If the message handler is set to a NULL pointer nothing will be printed
3784  */
3785 extern
3786 SCIP_RETCODE SCIPprintVar(
3787  SCIP* scip, /**< SCIP data structure */
3788  SCIP_VAR* var, /**< problem variable */
3789  FILE* file /**< output file (or NULL for standard output) */
3790  );
3791 
3792 /**@} */
3793 
3794 #ifdef __cplusplus
3795 }
3796 #endif
3797 
3798 #endif
SCIP_BOUNDTYPE
enum SCIP_BoundType SCIP_BOUNDTYPE
Definition: type_lp.h:50
SCIPflattenVarAggregationGraph
SCIP_RETCODE SCIPflattenVarAggregationGraph(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:1696
SCIPchgVarLbGlobal
SCIP_RETCODE SCIPchgVarLbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_var.c:4879
SCIP_BdChgIdx
Definition: struct_var.h:99
SCIPgetVarAvgInferences
SCIP_Real SCIPgetVarAvgInferences(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:9218
SCIPgetVarAvgCutoffs
SCIP_Real SCIPgetVarAvgCutoffs(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:9472
SCIPtightenVarLb
SCIP_RETCODE SCIPtightenVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:5120
SCIPgetVarUbAtIndex
SCIP_Real SCIPgetVarUbAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: scip_var.c:2130
SCIPgetBinvarRepresentative
SCIP_RETCODE SCIPgetBinvarRepresentative(SCIP *scip, SCIP_VAR *var, SCIP_VAR **repvar, SCIP_Bool *negated)
Definition: scip_var.c:1600
tree.h
internal methods for branch and bound tree
type_misc.h
type definitions for miscellaneous datastructures
SCIPgetVarAvgInferenceCutoffScore
SCIP_Real SCIPgetVarAvgInferenceCutoffScore(SCIP *scip, SCIP_VAR *var, SCIP_Real cutoffweight)
Definition: scip_var.c:9589
type_implics.h
type definitions for implications, variable bounds, and cliques
SCIPaddVarObj
SCIP_RETCODE SCIPaddVarObj(SCIP *scip, SCIP_VAR *var, SCIP_Real addobj)
Definition: scip_var.c:4499
SCIPgetVarLbAtIndex
SCIP_Real SCIPgetVarLbAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: scip_var.c:1994
SCIPgetVarAvgInferencesCurrentRun
SCIP_Real SCIPgetVarAvgInferencesCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:9246
SCIPmarkRelaxSolValid
SCIP_RETCODE SCIPmarkRelaxSolValid(SCIP *scip, SCIP_Bool includeslp)
Definition: scip_var.c:2549
SCIPgetVarConflictlengthScoreCurrentRun
SCIP_Real SCIPgetVarConflictlengthScoreCurrentRun(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:9133
SCIP_DECL_VARTRANS
#define SCIP_DECL_VARTRANS(x)
Definition: type_var.h:138
SCIPgetVarPseudocostVal
SCIP_Real SCIPgetVarPseudocostVal(SCIP *scip, SCIP_VAR *var, SCIP_Real solvaldelta)
Definition: scip_var.c:8613
SCIPgetVarRedcost
SCIP_Real SCIPgetVarRedcost(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:1866
SCIPgetNegatedVars
SCIP_RETCODE SCIPgetNegatedVars(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **negvars)
Definition: scip_var.c:1563
SCIPgetVarStrongbranchLast
SCIP_RETCODE SCIPgetVarStrongbranchLast(SCIP *scip, SCIP_VAR *var, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Real *solval, SCIP_Real *lpobjval)
Definition: scip_var.c:3951
SCIPinferVarLbProp
SCIP_RETCODE SCIPinferVarLbProp(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_PROP *inferprop, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:5808
SCIPchgVarLbNode
SCIP_RETCODE SCIPchgVarLbNode(SCIP *scip, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_var.c:4783
SCIPpscostThresholdProbabilityTest
SCIP_Bool SCIPpscostThresholdProbabilityTest(SCIP *scip, SCIP_VAR *var, SCIP_Real frac, SCIP_Real threshold, SCIP_BRANCHDIR dir, SCIP_CONFIDENCELEVEL clevel)
Definition: scip_var.c:8858
SCIP_Var
Definition: struct_var.h:198
SCIPgetTransformedVar
SCIP_RETCODE SCIPgetTransformedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **transvar)
Definition: scip_var.c:1442
SCIPparseVarName
SCIP_RETCODE SCIPparseVarName(SCIP *scip, const char *str, SCIP_VAR **var, char **endptr)
Definition: scip_var.c:523
SCIPreleaseVar
SCIP_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)
Definition: scip_var.c:1251
SCIPchgVarUbLazy
SCIP_RETCODE SCIPchgVarUbLazy(SCIP *scip, SCIP_VAR *var, SCIP_Real lazyub)
Definition: scip_var.c:5086
SCIPgetVarPseudocostCountCurrentRun
SCIP_Real SCIPgetVarPseudocostCountCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:8749
SCIPgetVarPseudocostScoreCurrentRun
SCIP_Real SCIPgetVarPseudocostScoreCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_Real solval)
Definition: scip_var.c:8940
SCIPadjustedVarUb
SCIP_Real SCIPadjustedVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real ub)
Definition: scip_var.c:4582
SCIPgetVarVSIDS
SCIP_Real SCIPgetVarVSIDS(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:8976
SCIP_VARDATA
struct SCIP_VarData SCIP_VARDATA
Definition: type_var.h:107
SCIPinferBinvarProp
SCIP_RETCODE SCIPinferBinvarProp(SCIP *scip, SCIP_VAR *var, SCIP_Bool fixedval, SCIP_PROP *inferprop, int inferinfo, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:6031
SCIPgetVarMultaggrUbLocal
SCIP_Real SCIPgetVarMultaggrUbLocal(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:6502
SCIPgetVarPseudocostValCurrentRun
SCIP_Real SCIPgetVarPseudocostValCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_Real solvaldelta)
Definition: scip_var.c:8641
SCIP_RETCODE
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:53
SCIPaddVarLocks
SCIP_RETCODE SCIPaddVarLocks(SCIP *scip, SCIP_VAR *var, int nlocksdown, int nlocksup)
Definition: scip_var.c:4257
SCIPgetVarStrongbranchNode
SCIP_Longint SCIPgetVarStrongbranchNode(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:4100
SCIP_DECL_VARCOPY
#define SCIP_DECL_VARCOPY(x)
Definition: type_var.h:181
SCIPcreateVarBasic
SCIP_RETCODE SCIPcreateVarBasic(SCIP *scip, SCIP_VAR **var, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype)
Definition: scip_var.c:184
SCIPgetVarAvgCutoffsCurrentRun
SCIP_Real SCIPgetVarAvgCutoffsCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:9500
SCIPgetVarVSIDSCurrentRun
SCIP_Real SCIPgetVarVSIDSCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:9008
SCIPgetVarAvgCutoffScoreCurrentRun
SCIP_Real SCIPgetVarAvgCutoffScoreCurrentRun(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:9557
SCIPisVarPscostRelerrorReliable
SCIP_Bool SCIPisVarPscostRelerrorReliable(SCIP *scip, SCIP_VAR *var, SCIP_Real threshold, SCIP_CONFIDENCELEVEL clevel)
Definition: scip_var.c:8877
SCIPclearRelaxSolVals
SCIP_RETCODE SCIPclearRelaxSolVals(SCIP *scip)
Definition: scip_var.c:2366
SCIPtightenVarUb
SCIP_RETCODE SCIPtightenVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:5236
SCIPgetRelaxSolObj
SCIP_Real SCIPgetRelaxSolObj(SCIP *scip)
Definition: scip_var.c:2622
SCIPgetVarWasFixedAtIndex
SCIP_Bool SCIPgetVarWasFixedAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: scip_var.c:2284
type_retcode.h
type definitions for return codes for SCIP methods
SCIPgetVarPseudocost
SCIP_Real SCIPgetVarPseudocost(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:8667
SCIPchgVarUbNode
SCIP_RETCODE SCIPchgVarUbNode(SCIP *scip, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_var.c:4827
SCIPwriteVarsPolynomial
SCIP_RETCODE SCIPwriteVarsPolynomial(SCIP *scip, FILE *file, SCIP_VAR ***monomialvars, SCIP_Real **monomialexps, SCIP_Real *monomialcoefs, int *monomialnvars, int nmonomials, SCIP_Bool type)
Definition: scip_var.c:394
SCIPgetVarMultaggrUbGlobal
SCIP_Real SCIPgetVarMultaggrUbGlobal(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:6472
SCIPchgVarLb
SCIP_RETCODE SCIPchgVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_var.c:4613
SCIPaddVarVlb
SCIP_RETCODE SCIPaddVarVlb(SCIP *scip, SCIP_VAR *var, SCIP_VAR *vlbvar, SCIP_Real vlbcoef, SCIP_Real vlbconstant, SCIP_Bool *infeasible, int *nbdchgs)
Definition: scip_var.c:6572
SCIPmarkRelaxSolInvalid
SCIP_RETCODE SCIPmarkRelaxSolInvalid(SCIP *scip)
Definition: scip_var.c:2572
SCIPadjustedVarLb
SCIP_Real SCIPadjustedVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real lb)
Definition: scip_var.c:4550
SCIP_LPSOLSTAT
enum SCIP_LPSolStat SCIP_LPSOLSTAT
Definition: type_lp.h:42
SCIPaddVarVub
SCIP_RETCODE SCIPaddVarVub(SCIP *scip, SCIP_VAR *var, SCIP_VAR *vubvar, SCIP_Real vubcoef, SCIP_Real vubconstant, SCIP_Bool *infeasible, int *nbdchgs)
Definition: scip_var.c:6631
SCIPchgVarUbGlobal
SCIP_RETCODE SCIPchgVarUbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_var.c:4966
SCIPgetTransformedVars
SCIP_RETCODE SCIPgetTransformedVars(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **transvars)
Definition: scip_var.c:1483
SCIP_Node
Definition: struct_tree.h:133
SCIPparseVarsLinearsum
SCIP_RETCODE SCIPparseVarsLinearsum(SCIP *scip, const char *str, SCIP_VAR **vars, SCIP_Real *vals, int *nvars, int varssize, int *requiredsize, char **endptr, SCIP_Bool *success)
Definition: scip_var.c:699
SCIPgetVarClosestVlb
SCIP_RETCODE SCIPgetVarClosestVlb(SCIP *scip, SCIP_VAR *var, SCIP_SOL *sol, SCIP_Real *closestvlb, int *closestvlbidx)
Definition: scip_var.c:6520
SCIPcomputeVarUbGlobal
SCIP_Real SCIPcomputeVarUbGlobal(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:6395
SCIPcomputeVarLbLocal
SCIP_Real SCIPcomputeVarLbLocal(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:6416
SCIPisStrongbranchDownFirst
SCIP_Bool SCIPisStrongbranchDownFirst(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:2645
SCIPtransformVars
SCIP_RETCODE SCIPtransformVars(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **transvars)
Definition: scip_var.c:1392
SCIPgetVarPseudocostScore
SCIP_Real SCIPgetVarPseudocostScore(SCIP *scip, SCIP_VAR *var, SCIP_Real solval)
Definition: scip_var.c:8902
SCIPscaleVarBranchFactor
SCIP_RETCODE SCIPscaleVarBranchFactor(SCIP *scip, SCIP_VAR *var, SCIP_Real scale)
Definition: scip_var.c:7819
SCIP_DECL_VARDELTRANS
#define SCIP_DECL_VARDELTRANS(x)
Definition: type_var.h:151
type_lp.h
type definitions for LP management
SCIP_Sol
Definition: struct_sol.h:63
SCIPtryStrongbranchLPSol
SCIP_RETCODE SCIPtryStrongbranchLPSol(SCIP *scip, SCIP_Bool *foundsol, SCIP_Bool *cutoff)
Definition: scip_var.c:4020
SCIPaddVarLocksType
SCIP_RETCODE SCIPaddVarLocksType(SCIP *scip, SCIP_VAR *var, SCIP_LOCKTYPE locktype, int nlocksdown, int nlocksup)
Definition: scip_var.c:4199
SCIPupdateVarPseudocost
SCIP_RETCODE SCIPupdateVarPseudocost(SCIP *scip, SCIP_VAR *var, SCIP_Real solvaldelta, SCIP_Real objdelta, SCIP_Real weight)
Definition: scip_var.c:8579
SCIPgetVarBdAtIndex
SCIP_Real SCIPgetVarBdAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: scip_var.c:2266
SCIP_BRANCHDIR
enum SCIP_BranchDir SCIP_BRANCHDIR
Definition: type_history.h:39
SCIPchgVarType
SCIP_RETCODE SCIPchgVarType(SCIP *scip, SCIP_VAR *var, SCIP_VARTYPE vartype, SCIP_Bool *infeasible)
Definition: scip_var.c:8072
SCIPaddClique
SCIP_RETCODE SCIPaddClique(SCIP *scip, SCIP_VAR **vars, SCIP_Bool *values, int nvars, SCIP_Bool isequation, SCIP_Bool *infeasible, int *nbdchgs)
Definition: scip_var.c:6819
SCIPmultiaggregateVar
SCIP_RETCODE SCIPmultiaggregateVar(SCIP *scip, SCIP_VAR *var, int naggvars, SCIP_VAR **aggvars, SCIP_Real *scalars, SCIP_Real constant, SCIP_Bool *infeasible, SCIP_Bool *aggregated)
Definition: scip_var.c:8411
SCIPparseVarsList
SCIP_RETCODE SCIPparseVarsList(SCIP *scip, const char *str, SCIP_VAR **vars, int *nvars, int varssize, int *requiredsize, char **endptr, char delimiter, SCIP_Bool *success)
Definition: scip_var.c:600
SCIP_CONFIDENCELEVEL
enum SCIP_Confidencelevel SCIP_CONFIDENCELEVEL
Definition: type_misc.h:44
SCIPgetVarPseudocostVariance
SCIP_Real SCIPgetVarPseudocostVariance(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun)
Definition: scip_var.c:8775
SCIP_LOCKTYPE
enum SCIP_LockType SCIP_LOCKTYPE
Definition: type_var.h:87
SCIPgetBinvarRepresentatives
SCIP_RETCODE SCIPgetBinvarRepresentatives(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **repvars, SCIP_Bool *negated)
Definition: scip_var.c:1647
SCIP_Cons
Definition: struct_cons.h:37
SCIPchgVarLbLazy
SCIP_RETCODE SCIPchgVarLbLazy(SCIP *scip, SCIP_VAR *var, SCIP_Real lazylb)
Definition: scip_var.c:5053
SCIPdoNotMultaggrVar
SCIP_Bool SCIPdoNotMultaggrVar(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:8461
SCIPinferVarFixCons
SCIP_RETCODE SCIPinferVarFixCons(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:5347
SCIPinitVarBranchStats
SCIP_RETCODE SCIPinitVarBranchStats(SCIP *scip, SCIP_VAR *var, SCIP_Real downpscost, SCIP_Real uppscost, SCIP_Real downvsids, SCIP_Real upvsids, SCIP_Real downconflen, SCIP_Real upconflen, SCIP_Real downinfer, SCIP_Real upinfer, SCIP_Real downcutoff, SCIP_Real upcutoff)
Definition: scip_var.c:9336
SCIPgetProbvarSum
SCIP_RETCODE SCIPgetProbvarSum(SCIP *scip, SCIP_VAR **var, SCIP_Real *scalar, SCIP_Real *constant)
Definition: scip_var.c:1796
type_scip.h
type definitions for SCIP&#39;s main datastructure
SCIPaddVarImplication
SCIP_RETCODE SCIPaddVarImplication(SCIP *scip, SCIP_VAR *var, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_BOUNDTYPE impltype, SCIP_Real implbound, SCIP_Bool *infeasible, int *nbdchgs)
Definition: scip_var.c:6691
SCIPunlockVarCons
SCIP_RETCODE SCIPunlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)
Definition: scip_var.c:4375
SCIPchgVarUb
SCIP_RETCODE SCIPchgVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_var.c:4703
SCIPcalculatePscostConfidenceBound
SCIP_Real SCIPcalculatePscostConfidenceBound(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun, SCIP_CONFIDENCELEVEL clevel)
Definition: scip_var.c:8797
SCIPmarkDoNotMultaggrVar
SCIP_RETCODE SCIPmarkDoNotMultaggrVar(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:8514
SCIPtightenVarLbGlobal
SCIP_RETCODE SCIPtightenVarLbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:6139
misc.h
internal miscellaneous methods
SCIPgetVarStrongbranchInt
SCIP_RETCODE SCIPgetVarStrongbranchInt(SCIP *scip, SCIP_VAR *var, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Bool *downinf, SCIP_Bool *upinf, SCIP_Bool *downconflict, SCIP_Bool *upconflict, SCIP_Bool *lperror)
Definition: scip_var.c:3627
SCIPgetVarConflictlengthScore
SCIP_Real SCIPgetVarConflictlengthScore(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:9102
SCIPgetVarAvgInferenceScoreCurrentRun
SCIP_Real SCIPgetVarAvgInferenceScoreCurrentRun(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:9303
set.h
internal methods for global SCIP settings
struct_scip.h
SCIP main data structure.
SCIPsignificantVarPscostDifference
SCIP_Bool SCIPsignificantVarPscostDifference(SCIP *scip, SCIP_VAR *varx, SCIP_Real fracx, SCIP_VAR *vary, SCIP_Real fracy, SCIP_BRANCHDIR dir, SCIP_CONFIDENCELEVEL clevel, SCIP_Bool onesided)
Definition: scip_var.c:8828
SCIPcomputeVarUbLocal
SCIP_Real SCIPcomputeVarUbLocal(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:6437
SCIPinferVarUbProp
SCIP_RETCODE SCIPinferVarUbProp(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_PROP *inferprop, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:5922
SCIPgetProbvarLinearSum
SCIP_RETCODE SCIPgetProbvarLinearSum(SCIP *scip, SCIP_VAR **vars, SCIP_Real *scalars, int *nvars, int varssize, SCIP_Real *constant, int *requiredsize, SCIP_Bool mergemultiples)
Definition: scip_var.c:1740
SCIPgetVarAvgConflictlength
SCIP_Real SCIPgetVarAvgConflictlength(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:9164
SCIPremoveVarFromGlobalStructures
SCIP_RETCODE SCIPremoveVarFromGlobalStructures(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:7757
SCIPgetVarClosestVub
SCIP_RETCODE SCIPgetVarClosestVub(SCIP *scip, SCIP_VAR *var, SCIP_SOL *sol, SCIP_Real *closestvub, int *closestvubidx)
Definition: scip_var.c:6543
type_var.h
type definitions for problem variables
SCIPgetVarStrongbranchLPAge
SCIP_Longint SCIPgetVarStrongbranchLPAge(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:4134
SCIPgetVarPseudocostCount
SCIP_Real SCIPgetVarPseudocostCount(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:8721
SCIP_Prop
Definition: struct_prop.h:37
SCIPgetVarPseudocostCurrentRun
SCIP_Real SCIPgetVarPseudocostCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:8695
SCIPchgVarObj
SCIP_RETCODE SCIPchgVarObj(SCIP *scip, SCIP_VAR *var, SCIP_Real newobj)
Definition: scip_var.c:4450
var.h
internal methods for problem variables
SCIPstartStrongbranch
SCIP_RETCODE SCIPstartStrongbranch(SCIP *scip, SCIP_Bool enablepropagation)
Definition: scip_var.c:2676
SCIP_Bool
#define SCIP_Bool
Definition: def.h:62
SCIPinferVarFixProp
SCIP_RETCODE SCIPinferVarFixProp(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval, SCIP_PROP *inferprop, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:5739
SCIPgetNCliquesCreated
int SCIPgetNCliquesCreated(SCIP *scip)
Definition: scip_var.c:7500
SCIPgetVarStrongbranchWithPropagation
SCIP_RETCODE SCIPgetVarStrongbranchWithPropagation(SCIP *scip, SCIP_VAR *var, SCIP_Real solval, SCIP_Real lpobjval, int itlim, int maxproprounds, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Longint *ndomredsdown, SCIP_Longint *ndomredsup, SCIP_Bool *downinf, SCIP_Bool *upinf, SCIP_Bool *downconflict, SCIP_Bool *upconflict, SCIP_Bool *lperror, SCIP_Real *newlbs, SCIP_Real *newubs)
Definition: scip_var.c:3317
SCIPsetRelaxSolVals
SCIP_RETCODE SCIPsetRelaxSolVals(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Bool includeslp)
Definition: scip_var.c:2443
SCIPcalcCliquePartition
SCIP_RETCODE SCIPcalcCliquePartition(SCIP *const scip, SCIP_VAR **const vars, int const nvars, int *const cliquepartition, int *const ncliques)
Definition: scip_var.c:7154
debug.h
methods for debugging
SCIPwriteCliqueGraph
SCIP_RETCODE SCIPwriteCliqueGraph(SCIP *scip, const char *fname, SCIP_Bool writenodeweights)
Definition: scip_var.c:7608
SCIPsetRelaxSolValsSol
SCIP_RETCODE SCIPsetRelaxSolValsSol(SCIP *scip, SCIP_SOL *sol, SCIP_Bool includeslp)
Definition: scip_var.c:2483
SCIPenableVarHistory
void SCIPenableVarHistory(SCIP *scip)
Definition: scip_var.c:8540
SCIPcomputeVarLbGlobal
SCIP_Real SCIPcomputeVarLbGlobal(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:6374
SCIPgetVarAvgInferenceCutoffScoreCurrentRun
SCIP_Real SCIPgetVarAvgInferenceCutoffScoreCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_Real cutoffweight)
Definition: scip_var.c:9633
SCIPgetVarsStrongbranchesInt
SCIP_RETCODE SCIPgetVarsStrongbranchesInt(SCIP *scip, SCIP_VAR **vars, int nvars, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Bool *downinf, SCIP_Bool *upinf, SCIP_Bool *downconflict, SCIP_Bool *upconflict, SCIP_Bool *lperror)
Definition: scip_var.c:3825
SCIPcreateVar
SCIP_RETCODE SCIPcreateVar(SCIP *scip, SCIP_VAR **var, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype, SCIP_Bool initial, SCIP_Bool removable, SCIP_DECL_VARDELORIG((*vardelorig)), SCIP_DECL_VARTRANS((*vartrans)), SCIP_DECL_VARDELTRANS((*vardeltrans)), SCIP_DECL_VARCOPY((*varcopy)), SCIP_VARDATA *vardata)
Definition: scip_var.c:104
type_tree.h
type definitions for branch and bound tree
SCIPfixVar
SCIP_RETCODE SCIPfixVar(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval, SCIP_Bool *infeasible, SCIP_Bool *fixed)
Definition: scip_var.c:8168
SCIPchgVarBranchPriority
SCIP_RETCODE SCIPchgVarBranchPriority(SCIP *scip, SCIP_VAR *var, int branchpriority)
Definition: scip_var.c:7878
SCIPlockVarCons
SCIP_RETCODE SCIPlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)
Definition: scip_var.c:4290
struct_stat.h
datastructures for problem statistics
SCIPinferVarLbCons
SCIP_RETCODE SCIPinferVarLbCons(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:5416
type_sol.h
type definitions for storing primal CIP solutions
SCIPgetVarMultaggrLbLocal
SCIP_Real SCIPgetVarMultaggrLbLocal(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:6487
SCIPwriteVarsLinearsum
SCIP_RETCODE SCIPwriteVarsLinearsum(SCIP *scip, FILE *file, SCIP_VAR **vars, SCIP_Real *vals, int nvars, SCIP_Bool type)
Definition: scip_var.c:333
SCIP_DECL_VARDELORIG
#define SCIP_DECL_VARDELORIG(x)
Definition: type_var.h:118
type_prop.h
type definitions for propagators
SCIPgetCliques
SCIP_CLIQUE ** SCIPgetCliques(SCIP *scip)
Definition: scip_var.c:7527
SCIPgetVarAvgConflictlengthCurrentRun
SCIP_Real SCIPgetVarAvgConflictlengthCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:9190
SCIPaddVarBranchFactor
SCIP_RETCODE SCIPaddVarBranchFactor(SCIP *scip, SCIP_VAR *var, SCIP_Real addfactor)
Definition: scip_var.c:7847
SCIPgetLastStrongbranchLPSolStat
SCIP_LPSOLSTAT SCIPgetLastStrongbranchLPSolStat(SCIP *scip, SCIP_BRANCHDIR branchdir)
Definition: scip_var.c:3929
SCIPwriteVarsList
SCIP_RETCODE SCIPwriteVarsList(SCIP *scip, FILE *file, SCIP_VAR **vars, int nvars, SCIP_Bool type, char delimiter)
Definition: scip_var.c:282
SCIPsetVarStrongbranchData
SCIP_RETCODE SCIPsetVarStrongbranchData(SCIP *scip, SCIP_VAR *var, SCIP_Real lpobjval, SCIP_Real primsol, SCIP_Real down, SCIP_Real up, SCIP_Bool downvalid, SCIP_Bool upvalid, SCIP_Longint iter, int itlim)
Definition: scip_var.c:3985
SCIPsetRelaxSolVal
SCIP_RETCODE SCIPsetRelaxSolVal(SCIP *scip, SCIP_VAR *var, SCIP_Real val)
Definition: scip_var.c:2412
SCIPgetVarImplRedcost
SCIP_Real SCIPgetVarImplRedcost(SCIP *scip, SCIP_VAR *var, SCIP_Bool varfixing)
Definition: scip_var.c:1911
SCIPfreeParseVarsPolynomialData
void SCIPfreeParseVarsPolynomialData(SCIP *scip, SCIP_VAR ****monomialvars, SCIP_Real ***monomialexps, SCIP_Real **monomialcoefs, int **monomialnvars, int nmonomials)
Definition: scip_var.c:1161
scalars
static const SCIP_Real scalars[]
Definition: lp.c:5650
SCIPinferVarUbCons
SCIP_RETCODE SCIPinferVarUbCons(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:5529
SCIPgetVarsStrongbranchesFrac
SCIP_RETCODE SCIPgetVarsStrongbranchesFrac(SCIP *scip, SCIP_VAR **vars, int nvars, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Bool *downinf, SCIP_Bool *upinf, SCIP_Bool *downconflict, SCIP_Bool *upconflict, SCIP_Bool *lperror)
Definition: scip_var.c:3714
solve.h
internal methods for main solving loop and node processing
SCIPgetVarSols
SCIP_RETCODE SCIPgetVarSols(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
Definition: scip_var.c:2329
SCIPendStrongbranch
SCIP_RETCODE SCIPendStrongbranch(SCIP *scip)
Definition: scip_var.c:2734
SCIPisRelaxSolValid
SCIP_Bool SCIPisRelaxSolValid(SCIP *scip)
Definition: scip_var.c:2529
SCIPallowDualReds
SCIP_Bool SCIPallowDualReds(SCIP *scip)
Definition: scip_var.c:8478
SCIPgetNCliques
int SCIPgetNCliques(SCIP *scip)
Definition: scip_var.c:7473
SCIPaddVarBranchPriority
SCIP_RETCODE SCIPaddVarBranchPriority(SCIP *scip, SCIP_VAR *var, int addpriority)
Definition: scip_var.c:7952
SCIPcalcNegatedCliquePartition
SCIP_RETCODE SCIPcalcNegatedCliquePartition(SCIP *const scip, SCIP_VAR **const vars, int const nvars, int *const cliquepartition, int *const ncliques)
Definition: scip_var.c:7373
SCIPaggregateVars
SCIP_RETCODE SCIPaggregateVars(SCIP *scip, SCIP_VAR *varx, SCIP_VAR *vary, SCIP_Real scalarx, SCIP_Real scalary, SCIP_Real rhs, SCIP_Bool *infeasible, SCIP_Bool *redundant, SCIP_Bool *aggregated)
Definition: scip_var.c:8277
SCIPcaptureVar
SCIP_RETCODE SCIPcaptureVar(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:1217
SCIP_Real
#define SCIP_Real
Definition: def.h:150
type_result.h
result codes for SCIP callback methods
type_history.h
type definitions for branching and inference history
SCIPchgVarBranchDirection
SCIP_RETCODE SCIPchgVarBranchDirection(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR branchdirection)
Definition: scip_var.c:7983
SCIPhaveVarsCommonClique
SCIP_Bool SCIPhaveVarsCommonClique(SCIP *scip, SCIP_VAR *var1, SCIP_Bool value1, SCIP_VAR *var2, SCIP_Bool value2, SCIP_Bool regardimplics)
Definition: scip_var.c:7557
SCIP_Clique
Definition: struct_implics.h:66
SCIPdoNotAggr
SCIP_Bool SCIPdoNotAggr(SCIP *scip)
Definition: scip_var.c:8441
SCIPtransformVar
SCIP_RETCODE SCIPtransformVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **transvar)
Definition: scip_var.c:1352
cons.h
internal methods for constraints and constraint handlers
SCIP_Longint
#define SCIP_Longint
Definition: def.h:135
SCIPparseVarsPolynomial
SCIP_RETCODE SCIPparseVarsPolynomial(SCIP *scip, const char *str, SCIP_VAR ****monomialvars, SCIP_Real ***monomialexps, SCIP_Real **monomialcoefs, int **monomialnvars, int *nmonomials, char **endptr, SCIP_Bool *success)
Definition: scip_var.c:809
SCIPdoNotMultaggr
SCIP_Bool SCIPdoNotMultaggr(SCIP *scip)
Definition: scip_var.c:8451
SCIPgetVarConflictScoreCurrentRun
SCIP_Real SCIPgetVarConflictScoreCurrentRun(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:9071
SCIP_VARTYPE
enum SCIP_Vartype SCIP_VARTYPE
Definition: type_var.h:60
SCIPgetVarSol
SCIP_Real SCIPgetVarSol(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:2309
SCIPgetVarMultaggrLbGlobal
SCIP_Real SCIPgetVarMultaggrLbGlobal(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:6457
SCIPtightenVarUbGlobal
SCIP_RETCODE SCIPtightenVarUbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:6259
SCIPinitVarValueBranchStats
SCIP_RETCODE SCIPinitVarValueBranchStats(SCIP *scip, SCIP_VAR *var, SCIP_Real value, SCIP_Real downvsids, SCIP_Real upvsids, SCIP_Real downconflen, SCIP_Real upconflen, SCIP_Real downinfer, SCIP_Real upinfer, SCIP_Real downcutoff, SCIP_Real upcutoff)
Definition: scip_var.c:9407
SCIPgetVarStrongbranchFrac
SCIP_RETCODE SCIPgetVarStrongbranchFrac(SCIP *scip, SCIP_VAR *var, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Bool *downinf, SCIP_Bool *upinf, SCIP_Bool *downconflict, SCIP_Bool *upconflict, SCIP_Bool *lperror)
Definition: scip_var.c:2909
def.h
common defines and data types used in all packages of SCIP
SCIPupdateVarBranchPriority
SCIP_RETCODE SCIPupdateVarBranchPriority(SCIP *scip, SCIP_VAR *var, int branchpriority)
Definition: scip_var.c:7919
SCIPcleanupCliques
SCIP_RETCODE SCIPcleanupCliques(SCIP *scip, SCIP_Bool *infeasible)
Definition: scip_var.c:7430
SCIPgetVarFarkasCoef
SCIP_Real SCIPgetVarFarkasCoef(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:1956
SCIPwriteVarName
SCIP_RETCODE SCIPwriteVarName(SCIP *scip, FILE *file, SCIP_VAR *var, SCIP_Bool type)
Definition: scip_var.c:220
SCIPgetVarNStrongbranchs
int SCIPgetVarNStrongbranchs(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:4166
SCIPgetActiveVars
SCIP_RETCODE SCIPgetActiveVars(SCIP *scip, SCIP_VAR **vars, int *nvars, int varssize, int *requiredsize)
Definition: scip_var.c:1832
SCIPdisableVarHistory
void SCIPdisableVarHistory(SCIP *scip)
Definition: scip_var.c:8559
SCIPgetVarAvgInferenceScore
SCIP_Real SCIPgetVarAvgInferenceScore(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:9272
SCIPinferBinvarCons
SCIP_RETCODE SCIPinferBinvarCons(SCIP *scip, SCIP_VAR *var, SCIP_Bool fixedval, SCIP_CONS *infercons, int inferinfo, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:5636
SCIPparseVar
SCIP_RETCODE SCIPparseVar(SCIP *scip, SCIP_VAR **var, 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: scip_var.c:464
SCIPchgVarBranchFactor
SCIP_RETCODE SCIPchgVarBranchFactor(SCIP *scip, SCIP_VAR *var, SCIP_Real branchfactor)
Definition: scip_var.c:7791
SCIPprintVar
SCIP_RETCODE SCIPprintVar(SCIP *scip, SCIP_VAR *var, FILE *file)
Definition: scip_var.c:9684
SCIPallowObjProp
SCIP_Bool SCIPallowObjProp(SCIP *scip)
Definition: scip_var.c:8488
SCIPgetNegatedVar
SCIP_RETCODE SCIPgetNegatedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **negvar)
Definition: scip_var.c:1530
type_cons.h
type definitions for constraints and constraint handlers
SCIPgetVarConflictScore
SCIP_Real SCIPgetVarConflictScore(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:9040
SCIPgetRelaxSolVal
SCIP_Real SCIPgetRelaxSolVal(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:2593
SCIPchgVarName
SCIP_RETCODE SCIPchgVarName(SCIP *scip, SCIP_VAR *var, const char *name)
Definition: scip_var.c:1302
SCIPgetVarAvgCutoffScore
SCIP_Real SCIPgetVarAvgCutoffScore(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:9526