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