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