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-2022 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 terms as signomial 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 signomial 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 signomial 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_TRANSFORMED
1804  * - \ref SCIP_STAGE_PRESOLVING
1805  * - \ref SCIP_STAGE_SOLVING
1806  *
1807  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
1808  */
1809 SCIP_EXPORT
1810 SCIP_RETCODE SCIPchgVarLbGlobal(
1811  SCIP* scip, /**< SCIP data structure */
1812  SCIP_VAR* var, /**< variable to change the bound for */
1813  SCIP_Real newbound /**< new value for bound */
1814  );
1815 
1816 /** changes global upper bound of variable; if possible, adjust bound to integral value; also tightens the local bound,
1817  * if the global bound is better than the local bound
1818  *
1819  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
1820  * SCIPgetVars()) gets resorted.
1821  *
1822  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1823  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1824  *
1825  * @pre This method can be called if @p scip is in one of the following stages:
1826  * - \ref SCIP_STAGE_PROBLEM
1827  * - \ref SCIP_STAGE_TRANSFORMING
1828  * - \ref SCIP_STAGE_TRANSFORMED
1829  * - \ref SCIP_STAGE_PRESOLVING
1830  * - \ref SCIP_STAGE_SOLVING
1831  *
1832  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
1833  */
1834 SCIP_EXPORT
1835 SCIP_RETCODE SCIPchgVarUbGlobal(
1836  SCIP* scip, /**< SCIP data structure */
1837  SCIP_VAR* var, /**< variable to change the bound for */
1838  SCIP_Real newbound /**< new value for bound */
1839  );
1840 
1841 /** changes lazy lower bound of the variable, this is only possible if the variable is not in the LP yet
1842  *
1843  * Lazy bounds are bounds that are already enforced by constraints and the objective function.
1844  * Setting a lazy lower bound has the consequence that for variables which lower bound equals the lazy lower bound,
1845  * the lower bound does not need to be passed on to the LP solver.
1846  * This is especially useful in a column generation (branch-and-price) setting.
1847  *
1848  * @attention If the variable has a global lower bound below lazylb, then the global lower bound is tightened to
1849  * lazylb by a call to SCIPchgVarLbGlobal().
1850  *
1851  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1852  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1853  *
1854  * @pre This method can be called if @p scip is in one of the following stages:
1855  * - \ref SCIP_STAGE_PROBLEM
1856  * - \ref SCIP_STAGE_TRANSFORMING
1857  * - \ref SCIP_STAGE_TRANSFORMED
1858  * - \ref SCIP_STAGE_PRESOLVING
1859  * - \ref SCIP_STAGE_SOLVING
1860  */
1861 SCIP_EXPORT
1862 SCIP_RETCODE SCIPchgVarLbLazy(
1863  SCIP* scip, /**< SCIP data structure */
1864  SCIP_VAR* var, /**< problem variable */
1865  SCIP_Real lazylb /**< the lazy lower bound to be set */
1866  );
1867 
1868 /** changes lazy upper bound of the variable, this is only possible if the variable is not in the LP yet
1869  *
1870  * Lazy bounds are bounds that are already enforced by constraints and the objective function.
1871  * Setting a lazy upper bound has the consequence that for variables which upper bound equals the lazy upper bound,
1872  * the upper bound does not need to be passed on to the LP solver.
1873  * This is especially useful in a column generation (branch-and-price) setting.
1874  *
1875  * @attention If the variable has a global upper bound above lazyub, then the global upper bound is tightened to
1876  * lazyub by a call to SCIPchgVarUbGlobal().
1877  *
1878  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1879  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1880  *
1881  * @pre This method can be called if @p scip is in one of the following stages:
1882  * - \ref SCIP_STAGE_PROBLEM
1883  * - \ref SCIP_STAGE_TRANSFORMING
1884  * - \ref SCIP_STAGE_TRANSFORMED
1885  * - \ref SCIP_STAGE_PRESOLVING
1886  * - \ref SCIP_STAGE_SOLVING
1887  */
1888 SCIP_EXPORT
1889 SCIP_RETCODE SCIPchgVarUbLazy(
1890  SCIP* scip, /**< SCIP data structure */
1891  SCIP_VAR* var, /**< problem variable */
1892  SCIP_Real lazyub /**< the lazy lower bound to be set */
1893  );
1894 
1895 /** changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter
1896  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
1897  * doesn't store any inference information in the bound change, such that in conflict analysis, this change
1898  * is treated like a branching decision
1899  *
1900  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
1901  * SCIPgetVars()) gets resorted.
1902  *
1903  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1904  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1905  *
1906  * @pre This method can be called if @p scip is in one of the following stages:
1907  * - \ref SCIP_STAGE_PROBLEM
1908  * - \ref SCIP_STAGE_PRESOLVING
1909  * - \ref SCIP_STAGE_SOLVING
1910  *
1911  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
1912  */
1913 SCIP_EXPORT
1914 SCIP_RETCODE SCIPtightenVarLb(
1915  SCIP* scip, /**< SCIP data structure */
1916  SCIP_VAR* var, /**< variable to change the bound for */
1917  SCIP_Real newbound, /**< new value for bound */
1918  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
1919  SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */
1920  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
1921  );
1922 
1923 /** changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter
1924  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
1925  * doesn't store any inference information in the bound change, such that in conflict analysis, this change
1926  * is treated like a branching decision
1927  *
1928  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
1929  * SCIPgetVars()) gets resorted.
1930  *
1931  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1932  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1933  *
1934  * @pre This method can be called if @p scip is in one of the following stages:
1935  * - \ref SCIP_STAGE_PROBLEM
1936  * - \ref SCIP_STAGE_PRESOLVING
1937  * - \ref SCIP_STAGE_SOLVING
1938  *
1939  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
1940  */
1941 SCIP_EXPORT
1942 SCIP_RETCODE SCIPtightenVarUb(
1943  SCIP* scip, /**< SCIP data structure */
1944  SCIP_VAR* var, /**< variable to change the bound for */
1945  SCIP_Real newbound, /**< new value for bound */
1946  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
1947  SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */
1948  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
1949  );
1950 
1951 /** fixes variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening
1952  * epsilon) than the current bound; if possible, adjusts bound to integral value; the given inference constraint is
1953  * stored, such that the conflict analysis is able to find out the reason for the deduction of the bound change
1954  *
1955  * @note In presolving stage when not in probing mode the variable will be fixed directly, otherwise this method
1956  * changes first the lowerbound by calling SCIPinferVarLbCons and second the upperbound by calling
1957  * SCIPinferVarUbCons
1958  *
1959  * @note If SCIP is in presolving stage, it can happen that the internal variable array (which get be accessed via
1960  * SCIPgetVars()) gets resorted.
1961  *
1962  * @note During presolving, an integer variable which bound changes to {0,1} is upgraded to a binary variable.
1963  */
1964 SCIP_EXPORT
1965 SCIP_RETCODE SCIPinferVarFixCons(
1966  SCIP* scip, /**< SCIP data structure */
1967  SCIP_VAR* var, /**< variable to change the bound for */
1968  SCIP_Real fixedval, /**< new value for fixation */
1969  SCIP_CONS* infercons, /**< constraint that deduced the bound change */
1970  int inferinfo, /**< user information for inference to help resolving the conflict */
1971  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
1972  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
1973  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
1974  );
1975 
1976 /** changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter
1977  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
1978  * the given inference constraint is stored, such that the conflict analysis is able to find out the reason
1979  * for the deduction of the bound change
1980  *
1981  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
1982  * SCIPgetVars()) gets resorted.
1983  *
1984  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1985  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1986  *
1987  * @pre This method can be called if @p scip is in one of the following stages:
1988  * - \ref SCIP_STAGE_PROBLEM
1989  * - \ref SCIP_STAGE_PRESOLVING
1990  * - \ref SCIP_STAGE_SOLVING
1991  *
1992  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
1993  */
1994 SCIP_EXPORT
1995 SCIP_RETCODE SCIPinferVarLbCons(
1996  SCIP* scip, /**< SCIP data structure */
1997  SCIP_VAR* var, /**< variable to change the bound for */
1998  SCIP_Real newbound, /**< new value for bound */
1999  SCIP_CONS* infercons, /**< constraint that deduced the bound change, or NULL */
2000  int inferinfo, /**< user information for inference to help resolving the conflict */
2001  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
2002  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
2003  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
2004  );
2005 
2006 /** changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter
2007  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
2008  * the given inference constraint is stored, such that the conflict analysis is able to find out the reason
2009  * for the deduction of the bound change
2010  *
2011  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
2012  * SCIPgetVars()) gets resorted.
2013  *
2014  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2015  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2016  *
2017  * @pre This method can be called if @p scip is in one of the following stages:
2018  * - \ref SCIP_STAGE_PROBLEM
2019  * - \ref SCIP_STAGE_PRESOLVING
2020  * - \ref SCIP_STAGE_SOLVING
2021  *
2022  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
2023  */
2024 SCIP_EXPORT
2025 SCIP_RETCODE SCIPinferVarUbCons(
2026  SCIP* scip, /**< SCIP data structure */
2027  SCIP_VAR* var, /**< variable to change the bound for */
2028  SCIP_Real newbound, /**< new value for bound */
2029  SCIP_CONS* infercons, /**< constraint that deduced the bound change */
2030  int inferinfo, /**< user information for inference to help resolving the conflict */
2031  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
2032  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
2033  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
2034  );
2035 
2036 /** depending on SCIP's stage, fixes binary variable in the problem, in preprocessing, or in current node;
2037  * the given inference constraint is stored, such that the conflict analysis is able to find out the reason for the
2038  * deduction of the fixing
2039  *
2040  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2041  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2042  *
2043  * @pre This method can be called if @p scip is in one of the following stages:
2044  * - \ref SCIP_STAGE_PROBLEM
2045  * - \ref SCIP_STAGE_PRESOLVING
2046  * - \ref SCIP_STAGE_SOLVING
2047  */
2048 SCIP_EXPORT
2049 SCIP_RETCODE SCIPinferBinvarCons(
2050  SCIP* scip, /**< SCIP data structure */
2051  SCIP_VAR* var, /**< binary variable to fix */
2052  SCIP_Bool fixedval, /**< value to fix binary variable to */
2053  SCIP_CONS* infercons, /**< constraint that deduced the fixing */
2054  int inferinfo, /**< user information for inference to help resolving the conflict */
2055  SCIP_Bool* infeasible, /**< pointer to store whether the fixing is infeasible */
2056  SCIP_Bool* tightened /**< pointer to store whether the fixing tightened the local bounds, or NULL */
2057  );
2058 
2059 /** fixes variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening
2060  * epsilon) than the current bound; if possible, adjusts bound to integral value; the given inference constraint is
2061  * stored, such that the conflict analysis is able to find out the reason for the deduction of the bound change
2062  *
2063  * @note In presolving stage when not in probing mode the variable will be fixed directly, otherwise this method
2064  * changes first the lowerbound by calling SCIPinferVarLbProp and second the upperbound by calling
2065  * SCIPinferVarUbProp
2066  *
2067  * @note If SCIP is in presolving stage, it can happen that the internal variable array (which get be accessed via
2068  * SCIPgetVars()) gets resorted.
2069  *
2070  * @note During presolving, an integer variable which bound changes to {0,1} is upgraded to a binary variable.
2071  */
2072 SCIP_EXPORT
2073 SCIP_RETCODE SCIPinferVarFixProp(
2074  SCIP* scip, /**< SCIP data structure */
2075  SCIP_VAR* var, /**< variable to change the bound for */
2076  SCIP_Real fixedval, /**< new value for fixation */
2077  SCIP_PROP* inferprop, /**< propagator that deduced the bound change */
2078  int inferinfo, /**< user information for inference to help resolving the conflict */
2079  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
2080  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
2081  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
2082  );
2083 
2084 /** changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter
2085  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
2086  * the given inference propagator is stored, such that the conflict analysis is able to find out the reason
2087  * for the deduction of the bound change
2088  *
2089  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
2090  * SCIPgetVars()) gets resorted.
2091  *
2092  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2093  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2094  *
2095  * @pre This method can be called if @p scip is in one of the following stages:
2096  * - \ref SCIP_STAGE_PROBLEM
2097  * - \ref SCIP_STAGE_PRESOLVING
2098  * - \ref SCIP_STAGE_SOLVING
2099  *
2100  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
2101  */
2102 SCIP_EXPORT
2103 SCIP_RETCODE SCIPinferVarLbProp(
2104  SCIP* scip, /**< SCIP data structure */
2105  SCIP_VAR* var, /**< variable to change the bound for */
2106  SCIP_Real newbound, /**< new value for bound */
2107  SCIP_PROP* inferprop, /**< propagator that deduced the bound change, or NULL */
2108  int inferinfo, /**< user information for inference to help resolving the conflict */
2109  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
2110  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
2111  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
2112  );
2113 
2114 /** changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter
2115  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
2116  * the given inference propagator is stored, such that the conflict analysis is able to find out the reason
2117  * for the deduction of the bound change
2118  *
2119  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
2120  * SCIPgetVars()) gets resorted.
2121  *
2122  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2123  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2124  *
2125  * @pre This method can be called if @p scip is in one of the following stages:
2126  * - \ref SCIP_STAGE_PROBLEM
2127  * - \ref SCIP_STAGE_PRESOLVING
2128  * - \ref SCIP_STAGE_SOLVING
2129  *
2130  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
2131  */
2132 SCIP_EXPORT
2133 SCIP_RETCODE SCIPinferVarUbProp(
2134  SCIP* scip, /**< SCIP data structure */
2135  SCIP_VAR* var, /**< variable to change the bound for */
2136  SCIP_Real newbound, /**< new value for bound */
2137  SCIP_PROP* inferprop, /**< propagator that deduced the bound change */
2138  int inferinfo, /**< user information for inference to help resolving the conflict */
2139  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
2140  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
2141  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
2142  );
2143 
2144 /** depending on SCIP's stage, fixes binary variable in the problem, in preprocessing, or in current node;
2145  * the given inference propagator is stored, such that the conflict analysis is able to find out the reason for the
2146  * deduction of the fixing
2147  *
2148  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2149  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2150  *
2151  * @pre This method can be called if @p scip is in one of the following stages:
2152  * - \ref SCIP_STAGE_PROBLEM
2153  * - \ref SCIP_STAGE_PRESOLVING
2154  * - \ref SCIP_STAGE_PRESOLVED
2155  * - \ref SCIP_STAGE_SOLVING
2156  */
2157 SCIP_EXPORT
2158 SCIP_RETCODE SCIPinferBinvarProp(
2159  SCIP* scip, /**< SCIP data structure */
2160  SCIP_VAR* var, /**< binary variable to fix */
2161  SCIP_Bool fixedval, /**< value to fix binary variable to */
2162  SCIP_PROP* inferprop, /**< propagator that deduced the fixing */
2163  int inferinfo, /**< user information for inference to help resolving the conflict */
2164  SCIP_Bool* infeasible, /**< pointer to store whether the fixing is infeasible */
2165  SCIP_Bool* tightened /**< pointer to store whether the fixing tightened the local bounds, or NULL */
2166  );
2167 
2168 /** changes global lower bound of variable in preprocessing or in the current node, if the new bound is tighter
2169  * (w.r.t. bound strengthening epsilon) than the current global bound; if possible, adjusts bound to integral value;
2170  * also tightens the local bound, if the global bound is better than the local bound
2171  *
2172  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
2173  * SCIPgetVars()) gets resorted.
2174  *
2175  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2176  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2177  *
2178  * @pre This method can be called if @p scip is in one of the following stages:
2179  * - \ref SCIP_STAGE_PROBLEM
2180  * - \ref SCIP_STAGE_TRANSFORMING
2181  * - \ref SCIP_STAGE_PRESOLVING
2182  * - \ref SCIP_STAGE_SOLVING
2183  *
2184  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
2185  */
2186 SCIP_EXPORT
2187 SCIP_RETCODE SCIPtightenVarLbGlobal(
2188  SCIP* scip, /**< SCIP data structure */
2189  SCIP_VAR* var, /**< variable to change the bound for */
2190  SCIP_Real newbound, /**< new value for bound */
2191  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
2192  SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */
2193  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
2194  );
2195 
2196 /** changes global upper bound of variable in preprocessing or in the current node, if the new bound is tighter
2197  * (w.r.t. bound strengthening epsilon) than the current global bound; if possible, adjusts bound to integral value;
2198  * also tightens the local bound, if the global bound is better than the local bound
2199  *
2200  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
2201  * SCIPgetVars()) gets resorted.
2202  *
2203  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2204  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2205  *
2206  * @pre This method can be called if @p scip is in one of the following stages:
2207  * - \ref SCIP_STAGE_PROBLEM
2208  * - \ref SCIP_STAGE_TRANSFORMING
2209  * - \ref SCIP_STAGE_PRESOLVING
2210  * - \ref SCIP_STAGE_SOLVING
2211  *
2212  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
2213  */
2214 SCIP_EXPORT
2215 SCIP_RETCODE SCIPtightenVarUbGlobal(
2216  SCIP* scip, /**< SCIP data structure */
2217  SCIP_VAR* var, /**< variable to change the bound for */
2218  SCIP_Real newbound, /**< new value for bound */
2219  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
2220  SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */
2221  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
2222  );
2223 
2224 /** for a multi-aggregated variable, returns the global lower bound computed by adding the global bounds from all aggregation variables
2225  *
2226  * 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
2227  * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetLbGlobal.
2228  *
2229  * @return the global lower bound computed by adding the global bounds from all aggregation variables
2230  */
2231 SCIP_EXPORT
2232 SCIP_Real SCIPcomputeVarLbGlobal(
2233  SCIP* scip, /**< SCIP data structure */
2234  SCIP_VAR* var /**< variable to compute the bound for */
2235  );
2236 
2237 /** for a multi-aggregated variable, returns the global upper bound computed by adding the global bounds from all aggregation variables
2238  *
2239  * 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
2240  * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetUbGlobal.
2241  *
2242  * @return the global upper bound computed by adding the global bounds from all aggregation variables
2243  */
2244 SCIP_EXPORT
2245 SCIP_Real SCIPcomputeVarUbGlobal(
2246  SCIP* scip, /**< SCIP data structure */
2247  SCIP_VAR* var /**< variable to compute the bound for */
2248  );
2249 
2250 /** for a multi-aggregated variable, returns the local lower bound computed by adding the local bounds from all aggregation variables
2251  *
2252  * 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
2253  * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetLbLocal.
2254  *
2255  * @return the local lower bound computed by adding the global bounds from all aggregation variables
2256  */
2257 SCIP_EXPORT
2258 SCIP_Real SCIPcomputeVarLbLocal(
2259  SCIP* scip, /**< SCIP data structure */
2260  SCIP_VAR* var /**< variable to compute the bound for */
2261  );
2262 
2263 /** for a multi-aggregated variable, returns the local upper bound computed by adding the local bounds from all aggregation variables
2264  *
2265  * 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
2266  * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetUbLocal.
2267  *
2268  * @return the local upper bound computed by adding the global bounds from all aggregation variables
2269  */
2270 SCIP_EXPORT
2271 SCIP_Real SCIPcomputeVarUbLocal(
2272  SCIP* scip, /**< SCIP data structure */
2273  SCIP_VAR* var /**< variable to compute the bound for */
2274  );
2275 
2276 /** for a multi-aggregated variable, gives the global lower bound computed by adding the global bounds from all
2277  * aggregation variables, this global bound may be tighter than the one given by SCIPvarGetLbGlobal, since the latter is
2278  * not updated if bounds of aggregation variables are changing
2279  *
2280  * calling this function for a non-multi-aggregated variable is not allowed
2281  */
2282 SCIP_EXPORT
2283 SCIP_Real SCIPgetVarMultaggrLbGlobal(
2284  SCIP* scip, /**< SCIP data structure */
2285  SCIP_VAR* var /**< variable to compute the bound for */
2286  );
2287 
2288 /** for a multi-aggregated variable, gives the global upper bound computed by adding the global bounds from all
2289  * aggregation variables, this upper bound may be tighter than the one given by SCIPvarGetUbGlobal, since the latter is
2290  * not updated if bounds of aggregation variables are changing
2291  *
2292  * calling this function for a non-multi-aggregated variable is not allowed
2293  */
2294 SCIP_EXPORT
2295 SCIP_Real SCIPgetVarMultaggrUbGlobal(
2296  SCIP* scip, /**< SCIP data structure */
2297  SCIP_VAR* var /**< variable to compute the bound for */
2298  );
2299 
2300 /** for a multi-aggregated variable, gives the local lower bound computed by adding the local bounds from all
2301  * aggregation variables, this lower bound may be tighter than the one given by SCIPvarGetLbLocal, since the latter is
2302  * not updated if bounds of aggregation variables are changing
2303  *
2304  * calling this function for a non-multi-aggregated variable is not allowed
2305  */
2306 SCIP_EXPORT
2307 SCIP_Real SCIPgetVarMultaggrLbLocal(
2308  SCIP* scip, /**< SCIP data structure */
2309  SCIP_VAR* var /**< variable to compute the bound for */
2310  );
2311 
2312 /** for a multi-aggregated variable, gives the local upper bound computed by adding the local bounds from all
2313  * aggregation variables, this upper bound may be tighter than the one given by SCIPvarGetUbLocal, since the latter is
2314  * not updated if bounds of aggregation variables are changing
2315  *
2316  * calling this function for a non-multi-aggregated variable is not allowed
2317  */
2318 SCIP_EXPORT
2319 SCIP_Real SCIPgetVarMultaggrUbLocal(
2320  SCIP* scip, /**< SCIP data structure */
2321  SCIP_VAR* var /**< variable to compute the bound for */
2322  );
2323 
2324 #ifdef NDEBUG
2325 
2326 /* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
2327  * speed up the algorithms.
2328  */
2329 
2330 #define SCIPcomputeVarLbGlobal(scip, var) (SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR ? SCIPgetVarMultaggrLbGlobal(scip, var) : SCIPvarGetLbGlobal(var))
2331 #define SCIPcomputeVarUbGlobal(scip, var) (SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR ? SCIPgetVarMultaggrUbGlobal(scip, var) : SCIPvarGetUbGlobal(var))
2332 #define SCIPcomputeVarLbLocal(scip, var) (SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR ? SCIPgetVarMultaggrLbLocal(scip, var) : SCIPvarGetLbLocal(var))
2333 #define SCIPcomputeVarUbLocal(scip, var) (SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR ? SCIPgetVarMultaggrUbLocal(scip, var) : SCIPvarGetUbLocal(var))
2334 
2335 #endif
2336 
2337 /** returns solution value and index of variable lower bound that is closest to the variable's value in the given primal
2338  * solution or current LP solution if no primal solution is given; returns an index of -1 if no variable lower bound is
2339  * available
2340  *
2341  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2342  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2343  *
2344  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
2345  */
2346 SCIP_EXPORT
2347 SCIP_RETCODE SCIPgetVarClosestVlb(
2348  SCIP* scip, /**< SCIP data structure */
2349  SCIP_VAR* var, /**< active problem variable */
2350  SCIP_SOL* sol, /**< primal solution, or NULL for LP solution */
2351  SCIP_Real* closestvlb, /**< pointer to store the value of the closest variable lower bound */
2352  int* closestvlbidx /**< pointer to store the index of the closest variable lower bound */
2353  );
2354 
2355 /** returns solution value and index of variable upper bound that is closest to the variable's value in the given primal solution;
2356  * or current LP solution if no primal solution is given; returns an index of -1 if no variable upper bound is available
2357  *
2358  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2359  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2360  *
2361  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
2362  */
2363 SCIP_EXPORT
2364 SCIP_RETCODE SCIPgetVarClosestVub(
2365  SCIP* scip, /**< SCIP data structure */
2366  SCIP_VAR* var, /**< active problem variable */
2367  SCIP_SOL* sol, /**< primal solution, or NULL for LP solution */
2368  SCIP_Real* closestvub, /**< pointer to store the value of the closest variable lower bound */
2369  int* closestvubidx /**< pointer to store the index of the closest variable lower bound */
2370  );
2371 
2372 /** informs variable x about a globally valid variable lower bound x >= b*z + d with integer variable z;
2373  * if z is binary, the corresponding valid implication for z is also added;
2374  * if z is non-continuous and 1/b not too small, the corresponding valid upper/lower bound
2375  * z <= (x-d)/b or z >= (x-d)/b (depending on the sign of of b) is added, too;
2376  * improves the global bounds of the variable and the vlb variable if possible
2377  *
2378  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2379  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2380  *
2381  * @pre This method can be called if @p scip is in one of the following stages:
2382  * - \ref SCIP_STAGE_PRESOLVING
2383  * - \ref SCIP_STAGE_PRESOLVED
2384  * - \ref SCIP_STAGE_SOLVING
2385  */
2386 SCIP_EXPORT
2387 SCIP_RETCODE SCIPaddVarVlb(
2388  SCIP* scip, /**< SCIP data structure */
2389  SCIP_VAR* var, /**< problem variable */
2390  SCIP_VAR* vlbvar, /**< variable z in x >= b*z + d */
2391  SCIP_Real vlbcoef, /**< coefficient b in x >= b*z + d */
2392  SCIP_Real vlbconstant, /**< constant d in x >= b*z + d */
2393  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
2394  int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
2395  );
2396 
2397 
2398 /** informs variable x about a globally valid variable upper bound x <= b*z + d with integer variable z;
2399  * if z is binary, the corresponding valid implication for z is also added;
2400  * if z is non-continuous and 1/b not too small, the corresponding valid lower/upper bound
2401  * z >= (x-d)/b or z <= (x-d)/b (depending on the sign of of b) is added, too;
2402  * improves the global bounds of the variable and the vlb variable if possible
2403  *
2404  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2405  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2406  *
2407  * @pre This method can be called if @p scip is in one of the following stages:
2408  * - \ref SCIP_STAGE_PRESOLVING
2409  * - \ref SCIP_STAGE_PRESOLVED
2410  * - \ref SCIP_STAGE_SOLVING
2411  */
2412 SCIP_EXPORT
2413 SCIP_RETCODE SCIPaddVarVub(
2414  SCIP* scip, /**< SCIP data structure */
2415  SCIP_VAR* var, /**< problem variable */
2416  SCIP_VAR* vubvar, /**< variable z in x <= b*z + d */
2417  SCIP_Real vubcoef, /**< coefficient b in x <= b*z + d */
2418  SCIP_Real vubconstant, /**< constant d in x <= b*z + d */
2419  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
2420  int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
2421  );
2422 
2423 /** informs binary variable x about a globally valid implication: x == 0 or x == 1 ==> y <= b or y >= b;
2424  * also adds the corresponding implication or variable bound to the implied variable;
2425  * if the implication is conflicting, the variable is fixed to the opposite value;
2426  * if the variable is already fixed to the given value, the implication is performed immediately;
2427  * if the implication is redundant with respect to the variables' global bounds, it is ignored
2428  *
2429  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2430  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2431  *
2432  * @pre This method can be called if @p scip is in one of the following stages:
2433  * - \ref SCIP_STAGE_TRANSFORMED
2434  * - \ref SCIP_STAGE_PRESOLVING
2435  * - \ref SCIP_STAGE_PRESOLVED
2436  * - \ref SCIP_STAGE_SOLVING
2437  */
2438 SCIP_EXPORT
2439 SCIP_RETCODE SCIPaddVarImplication(
2440  SCIP* scip, /**< SCIP data structure */
2441  SCIP_VAR* var, /**< problem variable */
2442  SCIP_Bool varfixing, /**< FALSE if y should be added in implications for x == 0, TRUE for x == 1 */
2443  SCIP_VAR* implvar, /**< variable y in implication y <= b or y >= b */
2444  SCIP_BOUNDTYPE impltype, /**< type of implication y <= b (SCIP_BOUNDTYPE_UPPER)
2445  * or y >= b (SCIP_BOUNDTYPE_LOWER) */
2446  SCIP_Real implbound, /**< bound b in implication y <= b or y >= b */
2447  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
2448  int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
2449  );
2450 
2451 /** adds a clique information to SCIP, stating that at most one of the given binary variables can be set to 1;
2452  * if a variable appears twice in the same clique, the corresponding implications are performed
2453  *
2454  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2455  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2456  *
2457  * @pre This method can be called if @p scip is in one of the following stages:
2458  * - \ref SCIP_STAGE_TRANSFORMED
2459  * - \ref SCIP_STAGE_PRESOLVING
2460  * - \ref SCIP_STAGE_PRESOLVED
2461  * - \ref SCIP_STAGE_SOLVING
2462  */
2463 SCIP_EXPORT
2464 SCIP_RETCODE SCIPaddClique(
2465  SCIP* scip, /**< SCIP data structure */
2466  SCIP_VAR** vars, /**< binary variables in the clique from which at most one can be set to 1 */
2467  SCIP_Bool* values, /**< values of the variables in the clique; NULL to use TRUE for all vars */
2468  int nvars, /**< number of variables in the clique */
2469  SCIP_Bool isequation, /**< is the clique an equation or an inequality? */
2470  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
2471  int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
2472  );
2473 
2474 /** calculates a partition of the given set of binary variables into cliques; takes into account independent clique components
2475  *
2476  * The algorithm performs the following steps:
2477  * - recomputes connected components of the clique table, if necessary
2478  * - computes a clique partition for every connected component greedily.
2479  * - relabels the resulting clique partition such that it satisfies the description below
2480  *
2481  * afterwards the output array contains one value for each variable, such that two variables got the same value iff they
2482  * were assigned to the same clique;
2483  * the first variable is always assigned to clique 0, and a variable can only be assigned to clique i if at least one of
2484  * the preceding variables was assigned to clique i-1;
2485  * for each clique at most 1 variables can be set to TRUE in a feasible solution;
2486  *
2487  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2488  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2489  *
2490  * @pre This method can be called if @p scip is in one of the following stages:
2491  * - \ref SCIP_STAGE_INITPRESOLVE
2492  * - \ref SCIP_STAGE_PRESOLVING
2493  * - \ref SCIP_STAGE_EXITPRESOLVE
2494  * - \ref SCIP_STAGE_PRESOLVED
2495  * - \ref SCIP_STAGE_SOLVING
2496  */
2497 SCIP_EXPORT
2498 SCIP_RETCODE SCIPcalcCliquePartition(
2499  SCIP*const scip, /**< SCIP data structure */
2500  SCIP_VAR**const vars, /**< binary variables in the clique from which at most one can be set to 1 */
2501  int const nvars, /**< number of variables in the clique */
2502  int*const cliquepartition, /**< array of length nvars to store the clique partition */
2503  int*const ncliques /**< pointer to store the number of cliques actually contained in the partition */
2504  );
2505 
2506 /** calculates a partition of the given set of binary variables into negated cliques;
2507  * afterwards the output array contains one value for each variable, such that two variables got the same value iff they
2508  * were assigned to the same negated clique;
2509  * the first variable is always assigned to clique 0 and a variable can only be assigned to clique i if at least one of
2510  * the preceding variables was assigned to clique i-1;
2511  * for each clique with n_c variables at least n_c-1 variables can be set to TRUE in a feasible solution;
2512  *
2513  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2514  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2515  *
2516  * @pre This method can be called if @p scip is in one of the following stages:
2517  * - \ref SCIP_STAGE_INITPRESOLVE
2518  * - \ref SCIP_STAGE_PRESOLVING
2519  * - \ref SCIP_STAGE_EXITPRESOLVE
2520  * - \ref SCIP_STAGE_PRESOLVED
2521  * - \ref SCIP_STAGE_SOLVING
2522  */
2523 SCIP_EXPORT
2524 SCIP_RETCODE SCIPcalcNegatedCliquePartition(
2525  SCIP*const scip, /**< SCIP data structure */
2526  SCIP_VAR**const vars, /**< binary variables in the clique from which at most one can be set to 1 */
2527  int const nvars, /**< number of variables in the clique */
2528  int*const cliquepartition, /**< array of length nvars to store the clique partition */
2529  int*const ncliques /**< pointer to store the number of cliques actually contained in the partition */
2530  );
2531 
2532 /** force SCIP to clean up all cliques; cliques do not get automatically cleaned up after presolving. Use
2533  * this method to prevent inactive variables in cliques when retrieved via SCIPgetCliques()
2534  *
2535  * @return SCIP_OKAY if everything worked, otherwise a suitable error code is passed
2536  *
2537  * @pre This method can be called if @p scip is in one of the following stages:
2538  * - \ref SCIP_STAGE_TRANSFORMED
2539  * - \ref SCIP_STAGE_INITPRESOLVE
2540  * - \ref SCIP_STAGE_PRESOLVING
2541  * - \ref SCIP_STAGE_EXITPRESOLVE
2542  * - \ref SCIP_STAGE_PRESOLVED
2543  * - \ref SCIP_STAGE_INITSOLVE
2544  * - \ref SCIP_STAGE_SOLVING
2545  * - \ref SCIP_STAGE_SOLVED
2546  * - \ref SCIP_STAGE_EXITSOLVE
2547  */
2548 SCIP_EXPORT
2549 SCIP_RETCODE SCIPcleanupCliques(
2550  SCIP* scip, /**< SCIP data structure */
2551  SCIP_Bool* infeasible /**< pointer to store if cleanup detected infeasibility */
2552  );
2553 
2554 /** gets the number of cliques in the clique table
2555  *
2556  * @return number of cliques in the clique table
2557  *
2558  * @pre This method can be called if @p scip is in one of the following stages:
2559  * - \ref SCIP_STAGE_TRANSFORMED
2560  * - \ref SCIP_STAGE_INITPRESOLVE
2561  * - \ref SCIP_STAGE_PRESOLVING
2562  * - \ref SCIP_STAGE_EXITPRESOLVE
2563  * - \ref SCIP_STAGE_PRESOLVED
2564  * - \ref SCIP_STAGE_INITSOLVE
2565  * - \ref SCIP_STAGE_SOLVING
2566  * - \ref SCIP_STAGE_SOLVED
2567  * - \ref SCIP_STAGE_EXITSOLVE
2568  */
2569 SCIP_EXPORT
2570 int SCIPgetNCliques(
2571  SCIP* scip /**< SCIP data structure */
2572  );
2573 
2574 /** gets the number of cliques created so far by the cliquetable
2575  *
2576  * @return number of cliques created so far by the cliquetable
2577  *
2578  * @pre This method can be called if @p scip is in one of the following stages:
2579  * - \ref SCIP_STAGE_TRANSFORMED
2580  * - \ref SCIP_STAGE_INITPRESOLVE
2581  * - \ref SCIP_STAGE_PRESOLVING
2582  * - \ref SCIP_STAGE_EXITPRESOLVE
2583  * - \ref SCIP_STAGE_PRESOLVED
2584  * - \ref SCIP_STAGE_INITSOLVE
2585  * - \ref SCIP_STAGE_SOLVING
2586  * - \ref SCIP_STAGE_SOLVED
2587  * - \ref SCIP_STAGE_EXITSOLVE
2588  */
2589 SCIP_EXPORT
2590 int SCIPgetNCliquesCreated(
2591  SCIP* scip /**< SCIP data structure */
2592  );
2593 
2594 /** gets the array of cliques in the clique table
2595  *
2596  * @return array of cliques in the clique table
2597  *
2598  * @pre This method can be called if @p scip is in one of the following stages:
2599  * - \ref SCIP_STAGE_TRANSFORMED
2600  * - \ref SCIP_STAGE_INITPRESOLVE
2601  * - \ref SCIP_STAGE_PRESOLVING
2602  * - \ref SCIP_STAGE_EXITPRESOLVE
2603  * - \ref SCIP_STAGE_PRESOLVED
2604  * - \ref SCIP_STAGE_INITSOLVE
2605  * - \ref SCIP_STAGE_SOLVING
2606  * - \ref SCIP_STAGE_SOLVED
2607  * - \ref SCIP_STAGE_EXITSOLVE
2608  */
2609 SCIP_EXPORT
2610 SCIP_CLIQUE** SCIPgetCliques(
2611  SCIP* scip /**< SCIP data structure */
2612  );
2613 
2614 /** returns whether there is a clique that contains both given variable/value pairs;
2615  * the variables must be active binary variables;
2616  * if regardimplics is FALSE, only the cliques in the clique table are looked at;
2617  * if regardimplics is TRUE, both the cliques and the implications of the implication graph are regarded
2618  *
2619  * @return TRUE, if there is a clique that contains both variable/clique pairs; FALSE, otherwise
2620  *
2621  * @pre This method can be called if @p scip is in one of the following stages:
2622  * - \ref SCIP_STAGE_TRANSFORMED
2623  * - \ref SCIP_STAGE_INITPRESOLVE
2624  * - \ref SCIP_STAGE_PRESOLVING
2625  * - \ref SCIP_STAGE_EXITPRESOLVE
2626  * - \ref SCIP_STAGE_PRESOLVED
2627  * - \ref SCIP_STAGE_INITSOLVE
2628  * - \ref SCIP_STAGE_SOLVING
2629  * - \ref SCIP_STAGE_SOLVED
2630  * - \ref SCIP_STAGE_EXITSOLVE
2631  *
2632  * @note a variable with it's negated variable are NOT! in a clique
2633  * @note a variable with itself are in a clique
2634  */
2635 SCIP_EXPORT
2636 SCIP_Bool SCIPhaveVarsCommonClique(
2637  SCIP* scip, /**< SCIP data structure */
2638  SCIP_VAR* var1, /**< first variable */
2639  SCIP_Bool value1, /**< value of first variable */
2640  SCIP_VAR* var2, /**< second variable */
2641  SCIP_Bool value2, /**< value of second variable */
2642  SCIP_Bool regardimplics /**< should the implication graph also be searched for a clique? */
2643  );
2644 
2645 /** writes the clique graph to a gml file
2646  *
2647  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2648  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2649  *
2650  * @pre This method can be called if @p scip is in one of the following stages:
2651  * - \ref SCIP_STAGE_TRANSFORMED
2652  * - \ref SCIP_STAGE_INITPRESOLVE
2653  * - \ref SCIP_STAGE_PRESOLVING
2654  * - \ref SCIP_STAGE_EXITPRESOLVE
2655  * - \ref SCIP_STAGE_PRESOLVED
2656  * - \ref SCIP_STAGE_INITSOLVE
2657  * - \ref SCIP_STAGE_SOLVING
2658  * - \ref SCIP_STAGE_SOLVED
2659  * - \ref SCIP_STAGE_EXITSOLVE
2660  *
2661  * @note there can be duplicated arcs in the output file
2662  *
2663  * If @p writenodeweights is true, only nodes corresponding to variables that have a fractional value and only edges
2664  * between such nodes are written.
2665  */
2666 SCIP_EXPORT
2667 SCIP_RETCODE SCIPwriteCliqueGraph(
2668  SCIP* scip, /**< SCIP data structure */
2669  const char* fname, /**< name of file */
2670  SCIP_Bool writenodeweights /**< should we write weights of nodes? */
2671  );
2672 
2673 /** Removes (irrelevant) variable from all its global structures, i.e. cliques, implications and variable bounds.
2674  * This is an advanced method which should be used with care.
2675  *
2676  * @return SCIP_OKAY if everything worked, otherwise a suitable error code is passed
2677  *
2678  * @pre This method can be called if @p scip is in one of the following stages:
2679  * - \ref SCIP_STAGE_TRANSFORMED
2680  * - \ref SCIP_STAGE_INITPRESOLVE
2681  * - \ref SCIP_STAGE_PRESOLVING
2682  * - \ref SCIP_STAGE_EXITPRESOLVE
2683  * - \ref SCIP_STAGE_PRESOLVED
2684  * - \ref SCIP_STAGE_INITSOLVE
2685  * - \ref SCIP_STAGE_SOLVING
2686  * - \ref SCIP_STAGE_SOLVED
2687  * - \ref SCIP_STAGE_EXITSOLVE
2688  */
2689 SCIP_EXPORT
2690 SCIP_RETCODE SCIPremoveVarFromGlobalStructures(
2691  SCIP* scip, /**< SCIP data structure */
2692  SCIP_VAR* var /**< variable to remove from global structures */
2693  );
2694 
2695 /** sets the branch factor of the variable; this value can be used in the branching methods to scale the score
2696  * values of the variables; higher factor leads to a higher probability that this variable is chosen for branching
2697  *
2698  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2699  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2700  *
2701  * @pre This method can be called if @p scip is in one of the following stages:
2702  * - \ref SCIP_STAGE_PROBLEM
2703  * - \ref SCIP_STAGE_TRANSFORMING
2704  * - \ref SCIP_STAGE_TRANSFORMED
2705  * - \ref SCIP_STAGE_INITPRESOLVE
2706  * - \ref SCIP_STAGE_PRESOLVING
2707  * - \ref SCIP_STAGE_EXITPRESOLVE
2708  * - \ref SCIP_STAGE_PRESOLVED
2709  * - \ref SCIP_STAGE_SOLVING
2710  */
2711 SCIP_EXPORT
2712 SCIP_RETCODE SCIPchgVarBranchFactor(
2713  SCIP* scip, /**< SCIP data structure */
2714  SCIP_VAR* var, /**< problem variable */
2715  SCIP_Real branchfactor /**< factor to weigh variable's branching score with */
2716  );
2717 
2718 /** scales the branch factor of the variable with the given value
2719  *
2720  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2721  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2722  *
2723  * @pre This method can be called if @p scip is in one of the following stages:
2724  * - \ref SCIP_STAGE_PROBLEM
2725  * - \ref SCIP_STAGE_TRANSFORMING
2726  * - \ref SCIP_STAGE_TRANSFORMED
2727  * - \ref SCIP_STAGE_INITPRESOLVE
2728  * - \ref SCIP_STAGE_PRESOLVING
2729  * - \ref SCIP_STAGE_EXITPRESOLVE
2730  * - \ref SCIP_STAGE_PRESOLVED
2731  * - \ref SCIP_STAGE_SOLVING
2732  */
2733 SCIP_EXPORT
2734 SCIP_RETCODE SCIPscaleVarBranchFactor(
2735  SCIP* scip, /**< SCIP data structure */
2736  SCIP_VAR* var, /**< problem variable */
2737  SCIP_Real scale /**< factor to scale variable's branching factor with */
2738  );
2739 
2740 /** adds the given value to the branch factor of the variable
2741  *
2742  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2743  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2744  *
2745  * @pre This method can be called if @p scip is in one of the following stages:
2746  * - \ref SCIP_STAGE_PROBLEM
2747  * - \ref SCIP_STAGE_TRANSFORMING
2748  * - \ref SCIP_STAGE_TRANSFORMED
2749  * - \ref SCIP_STAGE_INITPRESOLVE
2750  * - \ref SCIP_STAGE_PRESOLVING
2751  * - \ref SCIP_STAGE_EXITPRESOLVE
2752  * - \ref SCIP_STAGE_PRESOLVED
2753  * - \ref SCIP_STAGE_SOLVING
2754  */
2755 SCIP_EXPORT
2756 SCIP_RETCODE SCIPaddVarBranchFactor(
2757  SCIP* scip, /**< SCIP data structure */
2758  SCIP_VAR* var, /**< problem variable */
2759  SCIP_Real addfactor /**< value to add to the branch factor of the variable */
2760  );
2761 
2762 /** sets the branch priority of the variable; variables with higher branch priority are always preferred to variables
2763  * with lower priority in selection of branching variable
2764  *
2765  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2766  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2767  *
2768  * @pre This method can be called if @p scip is in one of the following stages:
2769  * - \ref SCIP_STAGE_PROBLEM
2770  * - \ref SCIP_STAGE_TRANSFORMING
2771  * - \ref SCIP_STAGE_TRANSFORMED
2772  * - \ref SCIP_STAGE_INITPRESOLVE
2773  * - \ref SCIP_STAGE_PRESOLVING
2774  * - \ref SCIP_STAGE_EXITPRESOLVE
2775  * - \ref SCIP_STAGE_PRESOLVED
2776  * - \ref SCIP_STAGE_SOLVING
2777  *
2778  * @note the default branching priority is 0
2779  */
2780 SCIP_EXPORT
2781 SCIP_RETCODE SCIPchgVarBranchPriority(
2782  SCIP* scip, /**< SCIP data structure */
2783  SCIP_VAR* var, /**< problem variable */
2784  int branchpriority /**< branch priority of the variable */
2785  );
2786 
2787 /** changes the branch priority of the variable to the given value, if it is larger than the current priority
2788  *
2789  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2790  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2791  *
2792  * @pre This method can be called if @p scip is in one of the following stages:
2793  * - \ref SCIP_STAGE_PROBLEM
2794  * - \ref SCIP_STAGE_TRANSFORMING
2795  * - \ref SCIP_STAGE_TRANSFORMED
2796  * - \ref SCIP_STAGE_INITPRESOLVE
2797  * - \ref SCIP_STAGE_PRESOLVING
2798  * - \ref SCIP_STAGE_EXITPRESOLVE
2799  * - \ref SCIP_STAGE_PRESOLVED
2800  * - \ref SCIP_STAGE_SOLVING
2801  */
2802 SCIP_EXPORT
2803 SCIP_RETCODE SCIPupdateVarBranchPriority(
2804  SCIP* scip, /**< SCIP data structure */
2805  SCIP_VAR* var, /**< problem variable */
2806  int branchpriority /**< new branch priority of the variable, if it is larger than current priority */
2807  );
2808 
2809 /** adds the given value to the branch priority of the variable
2810  *
2811  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2812  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2813  *
2814  * @pre This method can be called if @p scip is in one of the following stages:
2815  * - \ref SCIP_STAGE_PROBLEM
2816  * - \ref SCIP_STAGE_TRANSFORMING
2817  * - \ref SCIP_STAGE_TRANSFORMED
2818  * - \ref SCIP_STAGE_INITPRESOLVE
2819  * - \ref SCIP_STAGE_PRESOLVING
2820  * - \ref SCIP_STAGE_EXITPRESOLVE
2821  * - \ref SCIP_STAGE_PRESOLVED
2822  * - \ref SCIP_STAGE_SOLVING
2823  */
2824 SCIP_EXPORT
2825 SCIP_RETCODE SCIPaddVarBranchPriority(
2826  SCIP* scip, /**< SCIP data structure */
2827  SCIP_VAR* var, /**< problem variable */
2828  int addpriority /**< value to add to the branch priority of the variable */
2829  );
2830 
2831 /** sets the branch direction of the variable (-1: prefer downwards branch, 0: automatic selection, +1: prefer upwards
2832  * branch)
2833  *
2834  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2835  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2836  *
2837  * @pre This method can be called if @p scip is in one of the following stages:
2838  * - \ref SCIP_STAGE_PROBLEM
2839  * - \ref SCIP_STAGE_TRANSFORMING
2840  * - \ref SCIP_STAGE_TRANSFORMED
2841  * - \ref SCIP_STAGE_INITPRESOLVE
2842  * - \ref SCIP_STAGE_PRESOLVING
2843  * - \ref SCIP_STAGE_EXITPRESOLVE
2844  * - \ref SCIP_STAGE_PRESOLVED
2845  * - \ref SCIP_STAGE_SOLVING
2846  */
2847 SCIP_EXPORT
2848 SCIP_RETCODE SCIPchgVarBranchDirection(
2849  SCIP* scip, /**< SCIP data structure */
2850  SCIP_VAR* var, /**< problem variable */
2851  SCIP_BRANCHDIR branchdirection /**< preferred branch direction of the variable (downwards, upwards, auto) */
2852  );
2853 
2854 /** changes type of variable in the problem;
2855  *
2856  * @warning This type change might change the variable array returned from SCIPgetVars() and SCIPgetVarsData();
2857  *
2858  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2859  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2860  *
2861  * @pre This method can be called if @p scip is in one of the following stages:
2862  * - \ref SCIP_STAGE_PROBLEM
2863  * - \ref SCIP_STAGE_TRANSFORMING
2864  * - \ref SCIP_STAGE_PRESOLVING
2865  *
2866  * @note If SCIP is already beyond the SCIP_STAGE_PROBLEM and a original variable is passed, the variable type of the
2867  * corresponding transformed variable is changed; the type of the original variable does not change
2868  *
2869  * @note If the type changes from a continuous variable to a non-continuous variable the bounds of the variable get
2870  * adjusted w.r.t. to integrality information
2871  */
2872 SCIP_EXPORT
2873 SCIP_RETCODE SCIPchgVarType(
2874  SCIP* scip, /**< SCIP data structure */
2875  SCIP_VAR* var, /**< variable to change the bound for */
2876  SCIP_VARTYPE vartype, /**< new type of variable */
2877  SCIP_Bool* infeasible /**< pointer to store whether an infeasibility was detected (, due to
2878  * integrality condition of the new variable type) */
2879  );
2880 
2881 /** in problem creation and solving stage, both bounds of the variable are set to the given value;
2882  * in presolving stage, the variable is converted into a fixed variable, and bounds are changed respectively;
2883  * conversion into a fixed variable changes the vars array returned from SCIPgetVars() and SCIPgetVarsData(),
2884  * and also renders arrays returned from the SCIPvarGetImpl...() methods invalid
2885  *
2886  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2887  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2888  *
2889  * @pre This method can be called if @p scip is in one of the following stages:
2890  * - \ref SCIP_STAGE_PROBLEM
2891  * - \ref SCIP_STAGE_PRESOLVING
2892  * - \ref SCIP_STAGE_SOLVING
2893  */
2894 SCIP_EXPORT
2895 SCIP_RETCODE SCIPfixVar(
2896  SCIP* scip, /**< SCIP data structure */
2897  SCIP_VAR* var, /**< variable to fix */
2898  SCIP_Real fixedval, /**< value to fix variable to */
2899  SCIP_Bool* infeasible, /**< pointer to store whether the fixing is infeasible */
2900  SCIP_Bool* fixed /**< pointer to store whether the fixing was performed (variable was unfixed) */
2901  );
2902 
2903 /** From a given equality a*x + b*y == c, aggregates one of the variables and removes it from the set of
2904  * active problem variables. This changes the vars array returned from SCIPgetVars() and SCIPgetVarsData(),
2905  * and also renders the arrays returned from the SCIPvarGetImpl...() methods for the two variables invalid.
2906  * In the first step, the equality is transformed into an equality with active problem variables
2907  * a'*x' + b'*y' == c'. If x' == y', this leads to the detection of redundancy if a' == -b' and c' == 0,
2908  * of infeasibility, if a' == -b' and c' != 0, or to a variable fixing x' == c'/(a'+b') (and possible
2909  * infeasibility) otherwise.
2910  * In the second step, the variable to be aggregated is chosen among x' and y', prefering a less strict variable
2911  * type as aggregation variable (i.e. continuous variables are preferred over implicit integers, implicit integers
2912  * over integers, and integers over binaries). If none of the variables is continuous, it is tried to find an integer
2913  * aggregation (i.e. integral coefficients a'' and b'', such that a''*x' + b''*y' == c''). This can lead to
2914  * the detection of infeasibility (e.g. if c'' is fractional), or to a rejection of the aggregation (denoted by
2915  * aggregated == FALSE), if the resulting integer coefficients are too large and thus numerically instable.
2916  *
2917  * The output flags have the following meaning:
2918  * - infeasible: the problem is infeasible
2919  * - redundant: the equality can be deleted from the constraint set
2920  * - aggregated: the aggregation was successfully performed (the variables were not aggregated before)
2921  *
2922  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2923  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2924  *
2925  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_PRESOLVING
2926  */
2927 SCIP_EXPORT
2928 SCIP_RETCODE SCIPaggregateVars(
2929  SCIP* scip, /**< SCIP data structure */
2930  SCIP_VAR* varx, /**< variable x in equality a*x + b*y == c */
2931  SCIP_VAR* vary, /**< variable y in equality a*x + b*y == c */
2932  SCIP_Real scalarx, /**< multiplier a in equality a*x + b*y == c */
2933  SCIP_Real scalary, /**< multiplier b in equality a*x + b*y == c */
2934  SCIP_Real rhs, /**< right hand side c in equality a*x + b*y == c */
2935  SCIP_Bool* infeasible, /**< pointer to store whether the aggregation is infeasible */
2936  SCIP_Bool* redundant, /**< pointer to store whether the equality is (now) redundant */
2937  SCIP_Bool* aggregated /**< pointer to store whether the aggregation was successful */
2938  );
2939 
2940 /** converts variable into multi-aggregated variable; this changes the variable array returned from
2941  * SCIPgetVars() and SCIPgetVarsData();
2942  *
2943  * @warning The integrality condition is not checked anymore on the multi-aggregated variable. You must not
2944  * multi-aggregate an integer variable without being sure, that integrality on the aggregation variables
2945  * implies integrality on the aggregated variable.
2946  *
2947  * The output flags have the following meaning:
2948  * - infeasible: the problem is infeasible
2949  * - aggregated: the aggregation was successfully performed (the variables were not aggregated before)
2950  *
2951  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2952  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2953  *
2954  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_PRESOLVING
2955  */
2956 SCIP_EXPORT
2957 SCIP_RETCODE SCIPmultiaggregateVar(
2958  SCIP* scip, /**< SCIP data structure */
2959  SCIP_VAR* var, /**< variable x to aggregate */
2960  int naggvars, /**< number n of variables in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
2961  SCIP_VAR** aggvars, /**< variables y_i in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
2962  SCIP_Real* scalars, /**< multipliers a_i in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
2963  SCIP_Real constant, /**< constant shift c in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
2964  SCIP_Bool* infeasible, /**< pointer to store whether the aggregation is infeasible */
2965  SCIP_Bool* aggregated /**< pointer to store whether the aggregation was successful */
2966  );
2967 
2968 /** returns whether aggregation of variables is not allowed */
2969 SCIP_EXPORT
2970 SCIP_Bool SCIPdoNotAggr(
2971  SCIP* scip /**< SCIP data structure */
2972  );
2973 
2974 /** returns whether multi-aggregation is disabled */
2975 SCIP_EXPORT
2976 SCIP_Bool SCIPdoNotMultaggr(
2977  SCIP* scip /**< SCIP data structure */
2978  );
2979 
2980 /** returns whether variable is not allowed to be aggregated */
2981 SCIP_EXPORT
2982 SCIP_Bool SCIPdoNotAggrVar(
2983  SCIP* scip, /**< SCIP data structure */
2984  SCIP_VAR* var /**< variable x to aggregate */
2985  );
2986 
2987 /** returns whether variable is not allowed to be multi-aggregated */
2988 SCIP_EXPORT
2989 SCIP_Bool SCIPdoNotMultaggrVar(
2990  SCIP* scip, /**< SCIP data structure */
2991  SCIP_VAR* var /**< variable x to aggregate */
2992  );
2993 
2994 /** returns whether dual reductions are allowed during propagation and presolving
2995  *
2996  * @deprecated Please use SCIPallowStrongDualReds()
2997  */
2998 SCIP_EXPORT
2999 SCIP_Bool SCIPallowDualReds(
3000  SCIP* scip /**< SCIP data structure */
3001  );
3002 
3003 /** returns whether strong dual reductions are allowed during propagation and presolving
3004  *
3005  * @note A reduction is called strong dual, if it may discard feasible/optimal solutions, but leaves at least one
3006  * optimal solution intact. Often such reductions are based on analyzing the objective function and variable
3007  * locks.
3008  */
3009 SCIP_EXPORT
3010 SCIP_Bool SCIPallowStrongDualReds(
3011  SCIP* scip /**< SCIP data structure */
3012  );
3013 
3014 /** returns whether propagation w.r.t. current objective is allowed
3015  *
3016  * @deprecated Please use SCIPallowWeakDualReds()
3017  */
3018 SCIP_EXPORT
3019 SCIP_Bool SCIPallowObjProp(
3020  SCIP* scip /**< SCIP data structure */
3021  );
3022 
3023 /** returns whether weak dual reductions are allowed during propagation and presolving
3024  *
3025  * @note A reduction is called weak dual, if it may discard feasible solutions, but leaves at all optimal solutions
3026  * intact. Often such reductions are based on analyzing the objective function, reduced costs, and/or dual LPs.
3027  */
3028 SCIP_EXPORT
3029 SCIP_Bool SCIPallowWeakDualReds(
3030  SCIP* scip /**< SCIP data structure */
3031  );
3032 
3033 /** marks the variable that it must not be aggregated
3034  *
3035  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3036  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3037  *
3038  * @pre This method can be called if @p scip is in one of the following stages:
3039  * - \ref SCIP_STAGE_INIT
3040  * - \ref SCIP_STAGE_PROBLEM
3041  * - \ref SCIP_STAGE_TRANSFORMING
3042  * - \ref SCIP_STAGE_TRANSFORMED
3043  * - \ref SCIP_STAGE_INITPRESOLVE
3044  * - \ref SCIP_STAGE_PRESOLVING
3045  * - \ref SCIP_STAGE_EXITPRESOLVE
3046  *
3047  * @note There exists no "unmark" method since it has to be ensured that if a plugin requires that a variable is not
3048  * aggregated that this is will be the case.
3049  */
3050 SCIP_EXPORT
3051 SCIP_RETCODE SCIPmarkDoNotAggrVar(
3052  SCIP* scip, /**< SCIP data structure */
3053  SCIP_VAR* var /**< variable to delete */
3054  );
3055 
3056 /** marks the variable that it must not be multi-aggregated
3057  *
3058  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3059  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3060  *
3061  * @pre This method can be called if @p scip is in one of the following stages:
3062  * - \ref SCIP_STAGE_INIT
3063  * - \ref SCIP_STAGE_PROBLEM
3064  * - \ref SCIP_STAGE_TRANSFORMING
3065  * - \ref SCIP_STAGE_TRANSFORMED
3066  * - \ref SCIP_STAGE_INITPRESOLVE
3067  * - \ref SCIP_STAGE_PRESOLVING
3068  * - \ref SCIP_STAGE_EXITPRESOLVE
3069  *
3070  * @note There exists no "unmark" method since it has to be ensured that if a plugin requires that a variable is not
3071  * multi-aggregated that this is will be the case.
3072  */
3073 SCIP_EXPORT
3074 SCIP_RETCODE SCIPmarkDoNotMultaggrVar(
3075  SCIP* scip, /**< SCIP data structure */
3076  SCIP_VAR* var /**< variable to delete */
3077  );
3078 
3079 /** enables the collection of statistics for a variable
3080  *
3081  * @pre This method can be called if @p scip is in one of the following stages:
3082  * - \ref SCIP_STAGE_PROBLEM
3083  * - \ref SCIP_STAGE_INITPRESOLVE
3084  * - \ref SCIP_STAGE_PRESOLVING
3085  * - \ref SCIP_STAGE_EXITPRESOLVE
3086  * - \ref SCIP_STAGE_SOLVING
3087  * - \ref SCIP_STAGE_SOLVED
3088  */
3089 SCIP_EXPORT
3090 void SCIPenableVarHistory(
3091  SCIP* scip /**< SCIP data structure */
3092  );
3093 
3094 /** disables the collection of any statistic for a variable
3095  *
3096  * @pre This method can be called if @p scip is in one of the following stages:
3097  * - \ref SCIP_STAGE_PROBLEM
3098  * - \ref SCIP_STAGE_INITPRESOLVE
3099  * - \ref SCIP_STAGE_PRESOLVING
3100  * - \ref SCIP_STAGE_EXITPRESOLVE
3101  * - \ref SCIP_STAGE_SOLVING
3102  * - \ref SCIP_STAGE_SOLVED
3103  */
3104 SCIP_EXPORT
3105 void SCIPdisableVarHistory(
3106  SCIP* scip /**< SCIP data structure */
3107  );
3108 
3109 /** updates the pseudo costs of the given variable and the global pseudo costs after a change of "solvaldelta" in the
3110  * variable's solution value and resulting change of "objdelta" in the in the LP's objective value;
3111  * the update is ignored, if the objective value difference is infinite
3112  *
3113  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3114  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3115  *
3116  * @pre This method can be called if @p scip is in one of the following stages:
3117  * - \ref SCIP_STAGE_SOLVING
3118  * - \ref SCIP_STAGE_SOLVED
3119  */
3120 SCIP_EXPORT
3121 SCIP_RETCODE SCIPupdateVarPseudocost(
3122  SCIP* scip, /**< SCIP data structure */
3123  SCIP_VAR* var, /**< problem variable */
3124  SCIP_Real solvaldelta, /**< difference of variable's new LP value - old LP value */
3125  SCIP_Real objdelta, /**< difference of new LP's objective value - old LP's objective value */
3126  SCIP_Real weight /**< weight in (0,1] of this update in pseudo cost sum */
3127  );
3128 
3129 /** gets the variable's pseudo cost value for the given change of the variable's LP value
3130  *
3131  * @return the variable's pseudo cost value for the given change of the variable's LP value
3132  *
3133  * @pre This method can be called if @p scip is in one of the following stages:
3134  * - \ref SCIP_STAGE_INITPRESOLVE
3135  * - \ref SCIP_STAGE_PRESOLVING
3136  * - \ref SCIP_STAGE_EXITPRESOLVE
3137  * - \ref SCIP_STAGE_PRESOLVED
3138  * - \ref SCIP_STAGE_INITSOLVE
3139  * - \ref SCIP_STAGE_SOLVING
3140  * - \ref SCIP_STAGE_SOLVED
3141  */
3142 SCIP_EXPORT
3143 SCIP_Real SCIPgetVarPseudocostVal(
3144  SCIP* scip, /**< SCIP data structure */
3145  SCIP_VAR* var, /**< problem variable */
3146  SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
3147  );
3148 
3149 /** gets the variable's pseudo cost value for the given change of the variable's LP value,
3150  * only using the pseudo cost information of the current run
3151  *
3152  * @return the variable's pseudo cost value for the given change of the variable's LP value,
3153  * only using the pseudo cost information of the current run
3154  *
3155  * @pre This method can be called if @p scip is in one of the following stages:
3156  * - \ref SCIP_STAGE_INITPRESOLVE
3157  * - \ref SCIP_STAGE_PRESOLVING
3158  * - \ref SCIP_STAGE_EXITPRESOLVE
3159  * - \ref SCIP_STAGE_PRESOLVED
3160  * - \ref SCIP_STAGE_INITSOLVE
3161  * - \ref SCIP_STAGE_SOLVING
3162  * - \ref SCIP_STAGE_SOLVED
3163  */
3164 SCIP_EXPORT
3165 SCIP_Real SCIPgetVarPseudocostValCurrentRun(
3166  SCIP* scip, /**< SCIP data structure */
3167  SCIP_VAR* var, /**< problem variable */
3168  SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
3169  );
3170 
3171 /** gets the variable's pseudo cost value for the given direction
3172  *
3173  * @return the variable's pseudo cost value for the given direction
3174  *
3175  * @pre This method can be called if @p scip is in one of the following stages:
3176  * - \ref SCIP_STAGE_INITPRESOLVE
3177  * - \ref SCIP_STAGE_PRESOLVING
3178  * - \ref SCIP_STAGE_EXITPRESOLVE
3179  * - \ref SCIP_STAGE_PRESOLVED
3180  * - \ref SCIP_STAGE_INITSOLVE
3181  * - \ref SCIP_STAGE_SOLVING
3182  * - \ref SCIP_STAGE_SOLVED
3183  */
3184 SCIP_EXPORT
3185 SCIP_Real SCIPgetVarPseudocost(
3186  SCIP* scip, /**< SCIP data structure */
3187  SCIP_VAR* var, /**< problem variable */
3188  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
3189  );
3190 
3191 /** gets the variable's pseudo cost value for the given direction,
3192  * only using the pseudo cost information of the current run
3193  *
3194  * @return the variable's pseudo cost value for the given direction,
3195  * only using the pseudo cost information of the current run
3196  *
3197  * @pre This method can be called if @p scip is in one of the following stages:
3198  * - \ref SCIP_STAGE_INITPRESOLVE
3199  * - \ref SCIP_STAGE_PRESOLVING
3200  * - \ref SCIP_STAGE_EXITPRESOLVE
3201  * - \ref SCIP_STAGE_PRESOLVED
3202  * - \ref SCIP_STAGE_INITSOLVE
3203  * - \ref SCIP_STAGE_SOLVING
3204  * - \ref SCIP_STAGE_SOLVED
3205  */
3206 SCIP_EXPORT
3207 SCIP_Real SCIPgetVarPseudocostCurrentRun(
3208  SCIP* scip, /**< SCIP data structure */
3209  SCIP_VAR* var, /**< problem variable */
3210  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
3211  );
3212 
3213 /** gets the variable's (possible fractional) number of pseudo cost updates for the given direction
3214  *
3215  * @return the variable's (possible fractional) number of pseudo cost updates for the given direction
3216  *
3217  * @pre This method can be called if @p scip is in one of the following stages:
3218  * - \ref SCIP_STAGE_INITPRESOLVE
3219  * - \ref SCIP_STAGE_PRESOLVING
3220  * - \ref SCIP_STAGE_EXITPRESOLVE
3221  * - \ref SCIP_STAGE_PRESOLVED
3222  * - \ref SCIP_STAGE_INITSOLVE
3223  * - \ref SCIP_STAGE_SOLVING
3224  * - \ref SCIP_STAGE_SOLVED
3225  */
3226 SCIP_EXPORT
3227 SCIP_Real SCIPgetVarPseudocostCount(
3228  SCIP* scip, /**< SCIP data structure */
3229  SCIP_VAR* var, /**< problem variable */
3230  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
3231  );
3232 
3233 /** gets the variable's (possible fractional) number of pseudo cost updates for the given direction,
3234  * only using the pseudo cost information of the current run
3235  *
3236  * @return the variable's (possible fractional) number of pseudo cost updates for the given direction,
3237  * only using the pseudo cost information of the current run
3238  *
3239  * @pre This method can be called if @p scip is in one of the following stages:
3240  * - \ref SCIP_STAGE_INITPRESOLVE
3241  * - \ref SCIP_STAGE_PRESOLVING
3242  * - \ref SCIP_STAGE_EXITPRESOLVE
3243  * - \ref SCIP_STAGE_PRESOLVED
3244  * - \ref SCIP_STAGE_INITSOLVE
3245  * - \ref SCIP_STAGE_SOLVING
3246  * - \ref SCIP_STAGE_SOLVED
3247  */
3248 SCIP_EXPORT
3249 SCIP_Real SCIPgetVarPseudocostCountCurrentRun(
3250  SCIP* scip, /**< SCIP data structure */
3251  SCIP_VAR* var, /**< problem variable */
3252  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
3253  );
3254 
3255 /** get pseudo cost variance of the variable, either for entire solve or only for current branch and bound run
3256  *
3257  * @return returns the (corrected) variance of pseudo code information collected so far.
3258  *
3259  * @pre This method can be called if @p scip is in one of the following stages:
3260  * - \ref SCIP_STAGE_INITPRESOLVE
3261  * - \ref SCIP_STAGE_PRESOLVING
3262  * - \ref SCIP_STAGE_EXITPRESOLVE
3263  * - \ref SCIP_STAGE_PRESOLVED
3264  * - \ref SCIP_STAGE_INITSOLVE
3265  * - \ref SCIP_STAGE_SOLVING
3266  * - \ref SCIP_STAGE_SOLVED
3267  */
3268 SCIP_EXPORT
3269 SCIP_Real SCIPgetVarPseudocostVariance(
3270  SCIP* scip, /**< SCIP data structure */
3271  SCIP_VAR* var, /**< problem variable */
3272  SCIP_BRANCHDIR dir, /**< branching direction (downwards, or upwards) */
3273  SCIP_Bool onlycurrentrun /**< only for pseudo costs of current branch and bound run */
3274  );
3275 
3276 /** calculates a confidence bound for this variable under the assumption of normally distributed pseudo costs
3277  *
3278  * The confidence bound \f$ \theta \geq 0\f$ denotes the interval borders \f$ [X - \theta, \ X + \theta]\f$, which contains
3279  * the true pseudo costs of the variable, i.e., the expected value of the normal distribution, with a probability
3280  * of 2 * clevel - 1.
3281  *
3282  * @return value of confidence bound for this variable
3283  */
3284 SCIP_EXPORT
3285 SCIP_Real SCIPcalculatePscostConfidenceBound(
3286  SCIP* scip, /**< SCIP data structure */
3287  SCIP_VAR* var, /**< variable in question */
3288  SCIP_BRANCHDIR dir, /**< the branching direction for the confidence bound */
3289  SCIP_Bool onlycurrentrun, /**< should only the current run be taken into account */
3290  SCIP_CONFIDENCELEVEL clevel /**< confidence level for the interval */
3291  );
3292 
3293 /** check if variable pseudo-costs have a significant difference in location. The significance depends on
3294  * the choice of \p clevel and on the kind of tested hypothesis. The one-sided hypothesis, which
3295  * should be rejected, is that fracy * mu_y >= fracx * mu_x, where mu_y and mu_x denote the
3296  * unknown location means of the underlying pseudo-cost distributions of x and y.
3297  *
3298  * This method is applied best if variable x has a better pseudo-cost score than y. The method hypothesizes that y were actually
3299  * better than x (despite the current information), meaning that y can be expected to yield branching
3300  * decisions as least as good as x in the long run. If the method returns TRUE, the current history information is
3301  * sufficient to safely rely on the alternative hypothesis that x yields indeed a better branching score (on average)
3302  * than y.
3303  *
3304  * @note The order of x and y matters for the one-sided hypothesis
3305  *
3306  * @note set \p onesided to FALSE if you are not sure which variable is better. The hypothesis tested then reads
3307  * fracy * mu_y == fracx * mu_x vs the alternative hypothesis fracy * mu_y != fracx * mu_x.
3308  *
3309  * @return TRUE if the hypothesis can be safely rejected at the given confidence level
3310  */
3311 SCIP_EXPORT
3312 SCIP_Bool SCIPsignificantVarPscostDifference(
3313  SCIP* scip, /**< SCIP data structure */
3314  SCIP_VAR* varx, /**< variable x */
3315  SCIP_Real fracx, /**< the fractionality of variable x */
3316  SCIP_VAR* vary, /**< variable y */
3317  SCIP_Real fracy, /**< the fractionality of variable y */
3318  SCIP_BRANCHDIR dir, /**< branching direction */
3319  SCIP_CONFIDENCELEVEL clevel, /**< confidence level for rejecting hypothesis */
3320  SCIP_Bool onesided /**< should a one-sided hypothesis y >= x be tested? */
3321  );
3322 
3323 /** tests at a given confidence level whether the variable pseudo-costs only have a small probability to
3324  * exceed a \p threshold. This is useful to determine if past observations provide enough evidence
3325  * to skip an expensive strong-branching step if there is already a candidate that has been proven to yield an improvement
3326  * of at least \p threshold.
3327  *
3328  * @note use \p clevel to adjust the level of confidence. For SCIP_CONFIDENCELEVEL_MIN, the method returns TRUE if
3329  * the estimated probability to exceed \p threshold is less than 25 %.
3330  *
3331  * @see SCIP_Confidencelevel for a list of available levels. The used probability limits refer to the one-sided levels
3332  * of confidence.
3333  *
3334  * @return TRUE if the variable pseudo-cost probabilistic model is likely to be smaller than \p threshold
3335  * at the given confidence level \p clevel.
3336  */
3337 SCIP_EXPORT
3338 SCIP_Bool SCIPpscostThresholdProbabilityTest(
3339  SCIP* scip, /**< SCIP data structure */
3340  SCIP_VAR* var, /**< variable x */
3341  SCIP_Real frac, /**< the fractionality of variable x */
3342  SCIP_Real threshold, /**< the threshold to test against */
3343  SCIP_BRANCHDIR dir, /**< branching direction */
3344  SCIP_CONFIDENCELEVEL clevel /**< confidence level for rejecting hypothesis */
3345  );
3346 
3347 /** check if the current pseudo cost relative error in a direction violates the given threshold. The Relative
3348  * Error is calculated at a specific confidence level
3349  *
3350  * @return TRUE if relative error in variable pseudo costs is smaller than \p threshold
3351  */
3352 SCIP_EXPORT
3353 SCIP_Bool SCIPisVarPscostRelerrorReliable(
3354  SCIP* scip, /**< SCIP data structure */
3355  SCIP_VAR* var, /**< variable in question */
3356  SCIP_Real threshold, /**< threshold for relative errors to be considered reliable (enough) */
3357  SCIP_CONFIDENCELEVEL clevel /**< a given confidence level */
3358  );
3359 
3360 /** gets the variable's pseudo cost score value for the given LP solution value
3361  *
3362  * @return the variable's pseudo cost score value for the given LP solution value
3363  *
3364  * @pre This method can be called if @p scip is in one of the following stages:
3365  * - \ref SCIP_STAGE_INITPRESOLVE
3366  * - \ref SCIP_STAGE_PRESOLVING
3367  * - \ref SCIP_STAGE_EXITPRESOLVE
3368  * - \ref SCIP_STAGE_PRESOLVED
3369  * - \ref SCIP_STAGE_INITSOLVE
3370  * - \ref SCIP_STAGE_SOLVING
3371  * - \ref SCIP_STAGE_SOLVED
3372  */
3373 SCIP_EXPORT
3374 SCIP_Real SCIPgetVarPseudocostScore(
3375  SCIP* scip, /**< SCIP data structure */
3376  SCIP_VAR* var, /**< problem variable */
3377  SCIP_Real solval /**< variable's LP solution value */
3378  );
3379 
3380 /** gets the variable's pseudo cost score value for the given LP solution value,
3381  * only using the pseudo cost information of the current run
3382  *
3383  * @return the variable's pseudo cost score value for the given LP solution value,
3384  * only using the pseudo cost information of the current run
3385  *
3386  * @pre This method can be called if @p scip is in one of the following stages:
3387  * - \ref SCIP_STAGE_INITPRESOLVE
3388  * - \ref SCIP_STAGE_PRESOLVING
3389  * - \ref SCIP_STAGE_EXITPRESOLVE
3390  * - \ref SCIP_STAGE_PRESOLVED
3391  * - \ref SCIP_STAGE_INITSOLVE
3392  * - \ref SCIP_STAGE_SOLVING
3393  * - \ref SCIP_STAGE_SOLVED
3394  */
3395 SCIP_EXPORT
3396 SCIP_Real SCIPgetVarPseudocostScoreCurrentRun(
3397  SCIP* scip, /**< SCIP data structure */
3398  SCIP_VAR* var, /**< problem variable */
3399  SCIP_Real solval /**< variable's LP solution value */
3400  );
3401 
3402 /** returns the variable's VSIDS value
3403  *
3404  * @return the variable's VSIDS value
3405  *
3406  * @pre This method can be called if @p scip is in one of the following stages:
3407  * - \ref SCIP_STAGE_INITPRESOLVE
3408  * - \ref SCIP_STAGE_PRESOLVING
3409  * - \ref SCIP_STAGE_EXITPRESOLVE
3410  * - \ref SCIP_STAGE_PRESOLVED
3411  * - \ref SCIP_STAGE_INITSOLVE
3412  * - \ref SCIP_STAGE_SOLVING
3413  * - \ref SCIP_STAGE_SOLVED
3414  */
3415 SCIP_EXPORT
3416 SCIP_Real SCIPgetVarVSIDS(
3417  SCIP* scip, /**< SCIP data structure */
3418  SCIP_VAR* var, /**< problem variable */
3419  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
3420  );
3421 
3422 /** returns the variable's VSIDS value only using conflicts of the current run
3423  *
3424  * @return the variable's VSIDS value only using conflicts of the current run
3425  *
3426  * @pre This method can be called if @p scip is in one of the following stages:
3427  * - \ref SCIP_STAGE_INITPRESOLVE
3428  * - \ref SCIP_STAGE_PRESOLVING
3429  * - \ref SCIP_STAGE_EXITPRESOLVE
3430  * - \ref SCIP_STAGE_PRESOLVED
3431  * - \ref SCIP_STAGE_INITSOLVE
3432  * - \ref SCIP_STAGE_SOLVING
3433  * - \ref SCIP_STAGE_SOLVED
3434  */
3435 SCIP_EXPORT
3436 SCIP_Real SCIPgetVarVSIDSCurrentRun(
3437  SCIP* scip, /**< SCIP data structure */
3438  SCIP_VAR* var, /**< problem variable */
3439  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
3440  );
3441 
3442 /** returns the variable's conflict score value
3443  *
3444  * @return the variable's conflict score value
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 SCIPgetVarConflictScore(
3457  SCIP* scip, /**< SCIP data structure */
3458  SCIP_VAR* var /**< problem variable */
3459  );
3460 
3461 /** returns the variable's conflict score value only using conflicts of the current run
3462  *
3463  * @return the variable's conflict score value 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 SCIPgetVarConflictScoreCurrentRun(
3476  SCIP* scip, /**< SCIP data structure */
3477  SCIP_VAR* var /**< problem variable */
3478  );
3479 
3480 /** returns the variable's conflict length score
3481  *
3482  * @return the variable's conflict length score
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 SCIPgetVarConflictlengthScore(
3495  SCIP* scip, /**< SCIP data structure */
3496  SCIP_VAR* var /**< problem variable */
3497  );
3498 
3499 /** returns the variable's conflict length score only using conflicts of the current run
3500  *
3501  * @return the variable's conflict length score only using conflicts of the current run
3502  *
3503  * @pre This method can be called if @p scip is in one of the following stages:
3504  * - \ref SCIP_STAGE_INITPRESOLVE
3505  * - \ref SCIP_STAGE_PRESOLVING
3506  * - \ref SCIP_STAGE_EXITPRESOLVE
3507  * - \ref SCIP_STAGE_PRESOLVED
3508  * - \ref SCIP_STAGE_INITSOLVE
3509  * - \ref SCIP_STAGE_SOLVING
3510  * - \ref SCIP_STAGE_SOLVED
3511  */
3512 SCIP_EXPORT
3513 SCIP_Real SCIPgetVarConflictlengthScoreCurrentRun(
3514  SCIP* scip, /**< SCIP data structure */
3515  SCIP_VAR* var /**< problem variable */
3516  );
3517 
3518 /** returns the variable's average conflict length
3519  *
3520  * @return the variable's average conflict length
3521  *
3522  * @pre This method can be called if @p scip is in one of the following stages:
3523  * - \ref SCIP_STAGE_INITPRESOLVE
3524  * - \ref SCIP_STAGE_PRESOLVING
3525  * - \ref SCIP_STAGE_EXITPRESOLVE
3526  * - \ref SCIP_STAGE_PRESOLVED
3527  * - \ref SCIP_STAGE_INITSOLVE
3528  * - \ref SCIP_STAGE_SOLVING
3529  * - \ref SCIP_STAGE_SOLVED
3530  */
3531 SCIP_EXPORT
3532 SCIP_Real SCIPgetVarAvgConflictlength(
3533  SCIP* scip, /**< SCIP data structure */
3534  SCIP_VAR* var, /**< problem variable */
3535  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
3536  );
3537 
3538 /** returns the variable's average conflict length only using conflicts of the current run
3539  *
3540  * @return the variable's average conflict length only using conflicts of the current run
3541  *
3542  * @pre This method can be called if @p scip is in one of the following stages:
3543  * - \ref SCIP_STAGE_INITPRESOLVE
3544  * - \ref SCIP_STAGE_PRESOLVING
3545  * - \ref SCIP_STAGE_EXITPRESOLVE
3546  * - \ref SCIP_STAGE_PRESOLVED
3547  * - \ref SCIP_STAGE_INITSOLVE
3548  * - \ref SCIP_STAGE_SOLVING
3549  * - \ref SCIP_STAGE_SOLVED
3550  */
3551 SCIP_EXPORT
3552 SCIP_Real SCIPgetVarAvgConflictlengthCurrentRun(
3553  SCIP* scip, /**< SCIP data structure */
3554  SCIP_VAR* var, /**< problem variable */
3555  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
3556  );
3557 
3558 /** returns the average number of inferences found after branching on the variable in given direction;
3559  * if branching on the variable in the given direction was yet evaluated, the average number of inferences
3560  * over all variables for branching in the given direction is returned
3561  *
3562  * @return the average number of inferences found after branching on the variable in given direction
3563  *
3564  * @pre This method can be called if @p scip is in one of the following stages:
3565  * - \ref SCIP_STAGE_INITPRESOLVE
3566  * - \ref SCIP_STAGE_PRESOLVING
3567  * - \ref SCIP_STAGE_EXITPRESOLVE
3568  * - \ref SCIP_STAGE_PRESOLVED
3569  * - \ref SCIP_STAGE_INITSOLVE
3570  * - \ref SCIP_STAGE_SOLVING
3571  * - \ref SCIP_STAGE_SOLVED
3572  */
3573 SCIP_EXPORT
3574 SCIP_Real SCIPgetVarAvgInferences(
3575  SCIP* scip, /**< SCIP data structure */
3576  SCIP_VAR* var, /**< problem variable */
3577  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
3578  );
3579 
3580 /** returns the average number of inferences found after branching on the variable in given direction in the current run;
3581  * if branching on the variable in the given direction was yet evaluated, the average number of inferences
3582  * over all variables for branching in the given direction is returned
3583  *
3584  * @return the average number of inferences found after branching on the variable in given direction in the current run
3585  *
3586  * @pre This method can be called if @p scip is in one of the following stages:
3587  * - \ref SCIP_STAGE_INITPRESOLVE
3588  * - \ref SCIP_STAGE_PRESOLVING
3589  * - \ref SCIP_STAGE_EXITPRESOLVE
3590  * - \ref SCIP_STAGE_PRESOLVED
3591  * - \ref SCIP_STAGE_INITSOLVE
3592  * - \ref SCIP_STAGE_SOLVING
3593  * - \ref SCIP_STAGE_SOLVED
3594  */
3595 SCIP_EXPORT
3596 SCIP_Real SCIPgetVarAvgInferencesCurrentRun(
3597  SCIP* scip, /**< SCIP data structure */
3598  SCIP_VAR* var, /**< problem variable */
3599  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
3600  );
3601 
3602 /** returns the variable's average inference score value
3603  *
3604  * @return the variable's average inference score value
3605  *
3606  * @pre This method can be called if @p scip is in one of the following stages:
3607  * - \ref SCIP_STAGE_INITPRESOLVE
3608  * - \ref SCIP_STAGE_PRESOLVING
3609  * - \ref SCIP_STAGE_EXITPRESOLVE
3610  * - \ref SCIP_STAGE_PRESOLVED
3611  * - \ref SCIP_STAGE_INITSOLVE
3612  * - \ref SCIP_STAGE_SOLVING
3613  * - \ref SCIP_STAGE_SOLVED
3614  */
3615 SCIP_EXPORT
3616 SCIP_Real SCIPgetVarAvgInferenceScore(
3617  SCIP* scip, /**< SCIP data structure */
3618  SCIP_VAR* var /**< problem variable */
3619  );
3620 
3621 /** returns the variable's average inference score value only using inferences of the current run
3622  *
3623  * @return the variable's average inference score value only using inferences of the current run
3624  *
3625  * @pre This method can be called if @p scip is in one of the following stages:
3626  * - \ref SCIP_STAGE_INITPRESOLVE
3627  * - \ref SCIP_STAGE_PRESOLVING
3628  * - \ref SCIP_STAGE_EXITPRESOLVE
3629  * - \ref SCIP_STAGE_PRESOLVED
3630  * - \ref SCIP_STAGE_INITSOLVE
3631  * - \ref SCIP_STAGE_SOLVING
3632  * - \ref SCIP_STAGE_SOLVED
3633  */
3634 SCIP_EXPORT
3635 SCIP_Real SCIPgetVarAvgInferenceScoreCurrentRun(
3636  SCIP* scip, /**< SCIP data structure */
3637  SCIP_VAR* var /**< problem variable */
3638  );
3639 
3640 /** initializes the upwards and downwards pseudocosts, conflict scores, conflict lengths, inference scores, cutoff scores
3641  * of a variable to the given values
3642  *
3643  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3644  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3645  *
3646  * @pre This method can be called if @p scip is in one of the following stages:
3647  * - \ref SCIP_STAGE_TRANSFORMED
3648  * - \ref SCIP_STAGE_INITPRESOLVE
3649  * - \ref SCIP_STAGE_PRESOLVING
3650  * - \ref SCIP_STAGE_EXITPRESOLVE
3651  * - \ref SCIP_STAGE_PRESOLVED
3652  * - \ref SCIP_STAGE_INITSOLVE
3653  * - \ref SCIP_STAGE_SOLVING
3654  */
3655 SCIP_EXPORT
3656 SCIP_RETCODE SCIPinitVarBranchStats(
3657  SCIP* scip, /**< SCIP data structure */
3658  SCIP_VAR* var, /**< variable which should be initialized */
3659  SCIP_Real downpscost, /**< value to which pseudocosts for downwards branching should be initialized */
3660  SCIP_Real uppscost, /**< value to which pseudocosts for upwards branching should be initialized */
3661  SCIP_Real downvsids, /**< value to which VSIDS score for downwards branching should be initialized */
3662  SCIP_Real upvsids, /**< value to which VSIDS score for upwards branching should be initialized */
3663  SCIP_Real downconflen, /**< value to which conflict length score for downwards branching should be initialized */
3664  SCIP_Real upconflen, /**< value to which conflict length score for upwards branching should be initialized */
3665  SCIP_Real downinfer, /**< value to which inference counter for downwards branching should be initialized */
3666  SCIP_Real upinfer, /**< value to which inference counter for upwards branching should be initialized */
3667  SCIP_Real downcutoff, /**< value to which cutoff counter for downwards branching should be initialized */
3668  SCIP_Real upcutoff /**< value to which cutoff counter for upwards branching should be initialized */
3669  );
3670 
3671 /** initializes the upwards and downwards conflict scores, conflict lengths, inference scores, cutoff scores of a
3672  * variable w.r.t. a value by the given values (SCIP_VALUEHISTORY)
3673  *
3674  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3675  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3676  *
3677  * @pre This method can be called if @p scip is in one of the following stages:
3678  * - \ref SCIP_STAGE_TRANSFORMED
3679  * - \ref SCIP_STAGE_INITPRESOLVE
3680  * - \ref SCIP_STAGE_PRESOLVING
3681  * - \ref SCIP_STAGE_EXITPRESOLVE
3682  * - \ref SCIP_STAGE_PRESOLVED
3683  * - \ref SCIP_STAGE_INITSOLVE
3684  * - \ref SCIP_STAGE_SOLVING
3685  */
3686 SCIP_EXPORT
3687 SCIP_RETCODE SCIPinitVarValueBranchStats(
3688  SCIP* scip, /**< SCIP data structure */
3689  SCIP_VAR* var, /**< variable which should be initialized */
3690  SCIP_Real value, /**< domain value, or SCIP_UNKNOWN */
3691  SCIP_Real downvsids, /**< value to which VSIDS score for downwards branching should be initialized */
3692  SCIP_Real upvsids, /**< value to which VSIDS score for upwards branching should be initialized */
3693  SCIP_Real downconflen, /**< value to which conflict length score for downwards branching should be initialized */
3694  SCIP_Real upconflen, /**< value to which conflict length score for upwards branching should be initialized */
3695  SCIP_Real downinfer, /**< value to which inference counter for downwards branching should be initialized */
3696  SCIP_Real upinfer, /**< value to which inference counter for upwards branching should be initialized */
3697  SCIP_Real downcutoff, /**< value to which cutoff counter for downwards branching should be initialized */
3698  SCIP_Real upcutoff /**< value to which cutoff counter for upwards branching should be initialized */
3699  );
3700 
3701 /** returns the average number of cutoffs found after branching on the variable in given direction;
3702  * if branching on the variable in the given direction was yet evaluated, the average number of cutoffs
3703  * over all variables for branching in the given direction is returned
3704  *
3705  * @return the average number of cutoffs found after branching on the variable in given direction
3706  *
3707  * @pre This method can be called if @p scip is in one of the following stages:
3708  * - \ref SCIP_STAGE_INITPRESOLVE
3709  * - \ref SCIP_STAGE_PRESOLVING
3710  * - \ref SCIP_STAGE_EXITPRESOLVE
3711  * - \ref SCIP_STAGE_PRESOLVED
3712  * - \ref SCIP_STAGE_INITSOLVE
3713  * - \ref SCIP_STAGE_SOLVING
3714  * - \ref SCIP_STAGE_SOLVED
3715  */
3716 SCIP_EXPORT
3717 SCIP_Real SCIPgetVarAvgCutoffs(
3718  SCIP* scip, /**< SCIP data structure */
3719  SCIP_VAR* var, /**< problem variable */
3720  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
3721  );
3722 
3723 /** returns the average number of cutoffs found after branching on the variable in given direction in the current run;
3724  * if branching on the variable in the given direction was yet evaluated, the average number of cutoffs
3725  * over all variables for branching in the given direction is returned
3726  *
3727  * @return the average number of cutoffs found after branching on the variable in given direction in the current run
3728  *
3729  * @pre This method can be called if @p scip is in one of the following stages:
3730  * - \ref SCIP_STAGE_INITPRESOLVE
3731  * - \ref SCIP_STAGE_PRESOLVING
3732  * - \ref SCIP_STAGE_EXITPRESOLVE
3733  * - \ref SCIP_STAGE_PRESOLVED
3734  * - \ref SCIP_STAGE_INITSOLVE
3735  * - \ref SCIP_STAGE_SOLVING
3736  * - \ref SCIP_STAGE_SOLVED
3737  */
3738 SCIP_EXPORT
3739 SCIP_Real SCIPgetVarAvgCutoffsCurrentRun(
3740  SCIP* scip, /**< SCIP data structure */
3741  SCIP_VAR* var, /**< problem variable */
3742  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
3743  );
3744 
3745 /** returns the variable's average cutoff score value
3746  *
3747  * @return the variable's average cutoff score value
3748  *
3749  * @pre This method can be called if @p scip is in one of the following stages:
3750  * - \ref SCIP_STAGE_INITPRESOLVE
3751  * - \ref SCIP_STAGE_PRESOLVING
3752  * - \ref SCIP_STAGE_EXITPRESOLVE
3753  * - \ref SCIP_STAGE_PRESOLVED
3754  * - \ref SCIP_STAGE_INITSOLVE
3755  * - \ref SCIP_STAGE_SOLVING
3756  * - \ref SCIP_STAGE_SOLVED
3757  */
3758 SCIP_EXPORT
3759 SCIP_Real SCIPgetVarAvgCutoffScore(
3760  SCIP* scip, /**< SCIP data structure */
3761  SCIP_VAR* var /**< problem variable */
3762  );
3763 
3764 /** returns the variable's average cutoff score value, only using cutoffs of the current run
3765  *
3766  * @return the variable's average cutoff score value, only using cutoffs of the current run
3767  *
3768  * @pre This method can be called if @p scip is in one of the following stages:
3769  * - \ref SCIP_STAGE_INITPRESOLVE
3770  * - \ref SCIP_STAGE_PRESOLVING
3771  * - \ref SCIP_STAGE_EXITPRESOLVE
3772  * - \ref SCIP_STAGE_PRESOLVED
3773  * - \ref SCIP_STAGE_INITSOLVE
3774  * - \ref SCIP_STAGE_SOLVING
3775  * - \ref SCIP_STAGE_SOLVED
3776  */
3777 SCIP_EXPORT
3778 SCIP_Real SCIPgetVarAvgCutoffScoreCurrentRun(
3779  SCIP* scip, /**< SCIP data structure */
3780  SCIP_VAR* var /**< problem variable */
3781  );
3782 
3783 /** returns the variable's average inference/cutoff score value, weighting the cutoffs of the variable with the given
3784  * factor
3785  *
3786  * @return the variable's average inference/cutoff score value
3787  *
3788  * @pre This method can be called if @p scip is in one of the following stages:
3789  * - \ref SCIP_STAGE_INITPRESOLVE
3790  * - \ref SCIP_STAGE_PRESOLVING
3791  * - \ref SCIP_STAGE_EXITPRESOLVE
3792  * - \ref SCIP_STAGE_PRESOLVED
3793  * - \ref SCIP_STAGE_INITSOLVE
3794  * - \ref SCIP_STAGE_SOLVING
3795  * - \ref SCIP_STAGE_SOLVED
3796  */
3797 SCIP_EXPORT
3798 SCIP_Real SCIPgetVarAvgInferenceCutoffScore(
3799  SCIP* scip, /**< SCIP data structure */
3800  SCIP_VAR* var, /**< problem variable */
3801  SCIP_Real cutoffweight /**< factor to weigh average number of cutoffs in branching score */
3802  );
3803 
3804 /** returns the variable's average inference/cutoff score value, weighting the cutoffs of the variable with the given
3805  * factor, only using inferences and cutoffs of the current run
3806  *
3807  * @return the variable's average inference/cutoff score value, only using inferences and cutoffs of the current run
3808  *
3809  * @pre This method can be called if @p scip is in one of the following stages:
3810  * - \ref SCIP_STAGE_INITPRESOLVE
3811  * - \ref SCIP_STAGE_PRESOLVING
3812  * - \ref SCIP_STAGE_EXITPRESOLVE
3813  * - \ref SCIP_STAGE_PRESOLVED
3814  * - \ref SCIP_STAGE_INITSOLVE
3815  * - \ref SCIP_STAGE_SOLVING
3816  * - \ref SCIP_STAGE_SOLVED
3817  */
3818 SCIP_EXPORT
3819 SCIP_Real SCIPgetVarAvgInferenceCutoffScoreCurrentRun(
3820  SCIP* scip, /**< SCIP data structure */
3821  SCIP_VAR* var, /**< problem variable */
3822  SCIP_Real cutoffweight /**< factor to weigh average number of cutoffs in branching score */
3823  );
3824 
3825 /** outputs variable information to file stream via the message system
3826  *
3827  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3828  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3829  *
3830  * @pre This method can be called if @p scip is in one of the following stages:
3831  * - \ref SCIP_STAGE_PROBLEM
3832  * - \ref SCIP_STAGE_TRANSFORMING
3833  * - \ref SCIP_STAGE_TRANSFORMED
3834  * - \ref SCIP_STAGE_INITPRESOLVE
3835  * - \ref SCIP_STAGE_PRESOLVING
3836  * - \ref SCIP_STAGE_EXITPRESOLVE
3837  * - \ref SCIP_STAGE_PRESOLVED
3838  * - \ref SCIP_STAGE_INITSOLVE
3839  * - \ref SCIP_STAGE_SOLVING
3840  * - \ref SCIP_STAGE_SOLVED
3841  * - \ref SCIP_STAGE_EXITSOLVE
3842  * - \ref SCIP_STAGE_FREETRANS
3843  *
3844  * @note If the message handler is set to a NULL pointer nothing will be printed
3845  */
3846 SCIP_EXPORT
3847 SCIP_RETCODE SCIPprintVar(
3848  SCIP* scip, /**< SCIP data structure */
3849  SCIP_VAR* var, /**< problem variable */
3850  FILE* file /**< output file (or NULL for standard output) */
3851  );
3852 
3853 /**@} */
3854 
3855 #ifdef __cplusplus
3856 }
3857 #endif
3858 
3859 #endif
SCIP_BOUNDTYPE
enum SCIP_BoundType SCIP_BOUNDTYPE
Definition: type_lp.h:50
SCIPflattenVarAggregationGraph
SCIP_RETCODE SCIPflattenVarAggregationGraph(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:1690
SCIPchgVarLbGlobal
SCIP_RETCODE SCIPchgVarLbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_var.c:4940
SCIP_BdChgIdx
Definition: struct_var.h:99
SCIPgetVarAvgInferences
SCIP_Real SCIPgetVarAvgInferences(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:9416
SCIPgetVarAvgCutoffs
SCIP_Real SCIPgetVarAvgCutoffs(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:9670
SCIPtightenVarLb
SCIP_RETCODE SCIPtightenVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:5200
SCIPgetVarUbAtIndex
SCIP_Real SCIPgetVarUbAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: scip_var.c:2125
SCIPsetRelaxSolValsSol
SCIP_RETCODE SCIPsetRelaxSolValsSol(SCIP *scip, SCIP_RELAX *relax, SCIP_SOL *sol, SCIP_Bool includeslp)
Definition: scip_var.c:2486
SCIPgetBinvarRepresentative
SCIP_RETCODE SCIPgetBinvarRepresentative(SCIP *scip, SCIP_VAR *var, SCIP_VAR **repvar, SCIP_Bool *negated)
Definition: scip_var.c:1594
type_misc.h
type definitions for miscellaneous datastructures
SCIPgetVarAvgInferenceCutoffScore
SCIP_Real SCIPgetVarAvgInferenceCutoffScore(SCIP *scip, SCIP_VAR *var, SCIP_Real cutoffweight)
Definition: scip_var.c:9787
type_implics.h
type definitions for implications, variable bounds, and cliques
SCIPaddVarObj
SCIP_RETCODE SCIPaddVarObj(SCIP *scip, SCIP_VAR *var, SCIP_Real addobj)
Definition: scip_var.c:4559
SCIPgetVarLbAtIndex
SCIP_Real SCIPgetVarLbAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: scip_var.c:1989
SCIPclearRelaxSolVals
SCIP_RETCODE SCIPclearRelaxSolVals(SCIP *scip, SCIP_RELAX *relax)
Definition: scip_var.c:2361
SCIPgetVarAvgInferencesCurrentRun
SCIP_Real SCIPgetVarAvgInferencesCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:9444
SCIPgetVarConflictlengthScoreCurrentRun
SCIP_Real SCIPgetVarConflictlengthScoreCurrentRun(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:9331
SCIP_DECL_VARTRANS
#define SCIP_DECL_VARTRANS(x)
Definition: type_var.h:138
SCIPgetVarPseudocostVal
SCIP_Real SCIPgetVarPseudocostVal(SCIP *scip, SCIP_VAR *var, SCIP_Real solvaldelta)
Definition: scip_var.c:8811
SCIPgetVarRedcost
SCIP_Real SCIPgetVarRedcost(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:1861
SCIPgetNegatedVars
SCIP_RETCODE SCIPgetNegatedVars(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **negvars)
Definition: scip_var.c:1557
SCIPgetVarStrongbranchLast
SCIP_RETCODE SCIPgetVarStrongbranchLast(SCIP *scip, SCIP_VAR *var, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Real *solval, SCIP_Real *lpobjval)
Definition: scip_var.c:4007
SCIPinferVarLbProp
SCIP_RETCODE SCIPinferVarLbProp(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_PROP *inferprop, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:5892
SCIPchgVarLbNode
SCIP_RETCODE SCIPchgVarLbNode(SCIP *scip, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_var.c:4843
SCIPpscostThresholdProbabilityTest
SCIP_Bool SCIPpscostThresholdProbabilityTest(SCIP *scip, SCIP_VAR *var, SCIP_Real frac, SCIP_Real threshold, SCIP_BRANCHDIR dir, SCIP_CONFIDENCELEVEL clevel)
Definition: scip_var.c:9056
SCIP_Var
Definition: struct_var.h:198
SCIPgetTransformedVar
SCIP_RETCODE SCIPgetTransformedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **transvar)
Definition: scip_var.c:1436
SCIPparseVarName
SCIP_RETCODE SCIPparseVarName(SCIP *scip, const char *str, SCIP_VAR **var, char **endptr)
Definition: scip_var.c:524
SCIPreleaseVar
SCIP_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)
Definition: scip_var.c:1245
SCIPchgVarUbLazy
SCIP_RETCODE SCIPchgVarUbLazy(SCIP *scip, SCIP_VAR *var, SCIP_Real lazyub)
Definition: scip_var.c:5161
SCIPgetVarPseudocostCountCurrentRun
SCIP_Real SCIPgetVarPseudocostCountCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:8947
SCIPsetRelaxSolVals
SCIP_RETCODE SCIPsetRelaxSolVals(SCIP *scip, SCIP_RELAX *relax, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Bool includeslp)
Definition: scip_var.c:2444
SCIPgetVarPseudocostScoreCurrentRun
SCIP_Real SCIPgetVarPseudocostScoreCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_Real solval)
Definition: scip_var.c:9138
SCIPadjustedVarUb
SCIP_Real SCIPadjustedVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real ub)
Definition: scip_var.c:4642
SCIPgetVarVSIDS
SCIP_Real SCIPgetVarVSIDS(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:9174
SCIP_VARDATA
struct SCIP_VarData SCIP_VARDATA
Definition: type_var.h:107
SCIPinferBinvarProp
SCIP_RETCODE SCIPinferBinvarProp(SCIP *scip, SCIP_VAR *var, SCIP_Bool fixedval, SCIP_PROP *inferprop, int inferinfo, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:6117
SCIPgetVarMultaggrUbLocal
SCIP_Real SCIPgetVarMultaggrUbLocal(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:6588
SCIPgetVarPseudocostValCurrentRun
SCIP_Real SCIPgetVarPseudocostValCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_Real solvaldelta)
Definition: scip_var.c:8839
SCIP_RETCODE
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:54
SCIPaddVarLocks
SCIP_RETCODE SCIPaddVarLocks(SCIP *scip, SCIP_VAR *var, int nlocksdown, int nlocksup)
Definition: scip_var.c:4314
SCIPgetVarStrongbranchNode
SCIP_Longint SCIPgetVarStrongbranchNode(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:4157
SCIP_DECL_VARCOPY
#define SCIP_DECL_VARCOPY(x)
Definition: type_var.h:181
SCIPcreateVarBasic
SCIP_RETCODE SCIPcreateVarBasic(SCIP *scip, SCIP_VAR **var, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype)
Definition: scip_var.c:185
SCIPgetVarAvgCutoffsCurrentRun
SCIP_Real SCIPgetVarAvgCutoffsCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:9698
SCIPgetVarVSIDSCurrentRun
SCIP_Real SCIPgetVarVSIDSCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:9206
SCIPgetVarAvgCutoffScoreCurrentRun
SCIP_Real SCIPgetVarAvgCutoffScoreCurrentRun(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:9755
pub_var.h
public methods for problem variables
SCIPisVarPscostRelerrorReliable
SCIP_Bool SCIPisVarPscostRelerrorReliable(SCIP *scip, SCIP_VAR *var, SCIP_Real threshold, SCIP_CONFIDENCELEVEL clevel)
Definition: scip_var.c:9075
SCIPtightenVarUb
SCIP_RETCODE SCIPtightenVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:5317
SCIPgetRelaxSolObj
SCIP_Real SCIPgetRelaxSolObj(SCIP *scip)
Definition: scip_var.c:2629
SCIPgetVarWasFixedAtIndex
SCIP_Bool SCIPgetVarWasFixedAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: scip_var.c:2279
type_retcode.h
type definitions for return codes for SCIP methods
SCIPgetVarPseudocost
SCIP_Real SCIPgetVarPseudocost(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:8865
SCIPchgVarUbNode
SCIP_RETCODE SCIPchgVarUbNode(SCIP *scip, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_var.c:4887
SCIPwriteVarsPolynomial
SCIP_RETCODE SCIPwriteVarsPolynomial(SCIP *scip, FILE *file, SCIP_VAR ***monomialvars, SCIP_Real **monomialexps, SCIP_Real *monomialcoefs, int *monomialnvars, int nmonomials, SCIP_Bool type)
Definition: scip_var.c:395
SCIPgetVarMultaggrUbGlobal
SCIP_Real SCIPgetVarMultaggrUbGlobal(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:6558
SCIPchgVarLb
SCIP_RETCODE SCIPchgVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_var.c:4673
SCIPaddVarVlb
SCIP_RETCODE SCIPaddVarVlb(SCIP *scip, SCIP_VAR *var, SCIP_VAR *vlbvar, SCIP_Real vlbcoef, SCIP_Real vlbconstant, SCIP_Bool *infeasible, int *nbdchgs)
Definition: scip_var.c:6658
SCIPmarkRelaxSolInvalid
SCIP_RETCODE SCIPmarkRelaxSolInvalid(SCIP *scip)
Definition: scip_var.c:2579
SCIPadjustedVarLb
SCIP_Real SCIPadjustedVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real lb)
Definition: scip_var.c:4610
SCIP_LPSOLSTAT
enum SCIP_LPSolStat SCIP_LPSOLSTAT
Definition: type_lp.h:42
SCIPaddVarVub
SCIP_RETCODE SCIPaddVarVub(SCIP *scip, SCIP_VAR *var, SCIP_VAR *vubvar, SCIP_Real vubcoef, SCIP_Real vubconstant, SCIP_Bool *infeasible, int *nbdchgs)
Definition: scip_var.c:6717
SCIPchgVarUbGlobal
SCIP_RETCODE SCIPchgVarUbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_var.c:5029
SCIPgetTransformedVars
SCIP_RETCODE SCIPgetTransformedVars(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **transvars)
Definition: scip_var.c:1477
SCIPgetVarStrongbranchInt
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:3659
SCIP_Node
Definition: struct_tree.h:132
SCIPparseVarsLinearsum
SCIP_RETCODE SCIPparseVarsLinearsum(SCIP *scip, const char *str, SCIP_VAR **vars, SCIP_Real *vals, int *nvars, int varssize, int *requiredsize, char **endptr, SCIP_Bool *success)
Definition: scip_var.c:700
SCIPgetVarClosestVlb
SCIP_RETCODE SCIPgetVarClosestVlb(SCIP *scip, SCIP_VAR *var, SCIP_SOL *sol, SCIP_Real *closestvlb, int *closestvlbidx)
Definition: scip_var.c:6606
SCIPcomputeVarUbGlobal
SCIP_Real SCIPcomputeVarUbGlobal(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:6481
SCIPcomputeVarLbLocal
SCIP_Real SCIPcomputeVarLbLocal(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:6502
SCIPisStrongbranchDownFirst
SCIP_Bool SCIPisStrongbranchDownFirst(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:2652
SCIPtransformVars
SCIP_RETCODE SCIPtransformVars(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **transvars)
Definition: scip_var.c:1386
SCIPgetVarPseudocostScore
SCIP_Real SCIPgetVarPseudocostScore(SCIP *scip, SCIP_VAR *var, SCIP_Real solval)
Definition: scip_var.c:9100
SCIPscaleVarBranchFactor
SCIP_RETCODE SCIPscaleVarBranchFactor(SCIP *scip, SCIP_VAR *var, SCIP_Real scale)
Definition: scip_var.c:7918
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
SCIPtryStrongbranchLPSol
SCIP_RETCODE SCIPtryStrongbranchLPSol(SCIP *scip, SCIP_Bool *foundsol, SCIP_Bool *cutoff)
Definition: scip_var.c:4076
SCIPaddVarLocksType
SCIP_RETCODE SCIPaddVarLocksType(SCIP *scip, SCIP_VAR *var, SCIP_LOCKTYPE locktype, int nlocksdown, int nlocksup)
Definition: scip_var.c:4256
SCIPupdateVarPseudocost
SCIP_RETCODE SCIPupdateVarPseudocost(SCIP *scip, SCIP_VAR *var, SCIP_Real solvaldelta, SCIP_Real objdelta, SCIP_Real weight)
Definition: scip_var.c:8777
SCIPgetVarBdAtIndex
SCIP_Real SCIPgetVarBdAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: scip_var.c:2261
SCIP_BRANCHDIR
enum SCIP_BranchDir SCIP_BRANCHDIR
Definition: type_history.h:39
SCIPchgVarType
SCIP_RETCODE SCIPchgVarType(SCIP *scip, SCIP_VAR *var, SCIP_VARTYPE vartype, SCIP_Bool *infeasible)
Definition: scip_var.c:8173
SCIPaddClique
SCIP_RETCODE SCIPaddClique(SCIP *scip, SCIP_VAR **vars, SCIP_Bool *values, int nvars, SCIP_Bool isequation, SCIP_Bool *infeasible, int *nbdchgs)
Definition: scip_var.c:6918
SCIPmultiaggregateVar
SCIP_RETCODE SCIPmultiaggregateVar(SCIP *scip, SCIP_VAR *var, int naggvars, SCIP_VAR **aggvars, SCIP_Real *scalars, SCIP_Real constant, SCIP_Bool *infeasible, SCIP_Bool *aggregated)
Definition: scip_var.c:8532
SCIPparseVarsList
SCIP_RETCODE SCIPparseVarsList(SCIP *scip, const char *str, SCIP_VAR **vars, int *nvars, int varssize, int *requiredsize, char **endptr, char delimiter, SCIP_Bool *success)
Definition: scip_var.c:601
SCIP_CONFIDENCELEVEL
enum SCIP_Confidencelevel SCIP_CONFIDENCELEVEL
Definition: type_misc.h:44
SCIPmarkDoNotAggrVar
SCIP_RETCODE SCIPmarkDoNotAggrVar(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:8679
SCIPgetVarPseudocostVariance
SCIP_Real SCIPgetVarPseudocostVariance(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun)
Definition: scip_var.c:8973
SCIP_LOCKTYPE
enum SCIP_LockType SCIP_LOCKTYPE
Definition: type_var.h:87
SCIPgetBinvarRepresentatives
SCIP_RETCODE SCIPgetBinvarRepresentatives(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **repvars, SCIP_Bool *negated)
Definition: scip_var.c:1641
SCIP_Cons
Definition: struct_cons.h:37
SCIPdoNotAggrVar
SCIP_Bool SCIPdoNotAggrVar(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:8582
SCIPchgVarLbLazy
SCIP_RETCODE SCIPchgVarLbLazy(SCIP *scip, SCIP_VAR *var, SCIP_Real lazylb)
Definition: scip_var.c:5120
SCIPdoNotMultaggrVar
SCIP_Bool SCIPdoNotMultaggrVar(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:8595
SCIPinferVarFixCons
SCIP_RETCODE SCIPinferVarFixCons(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:5429
SCIPinitVarBranchStats
SCIP_RETCODE SCIPinitVarBranchStats(SCIP *scip, SCIP_VAR *var, SCIP_Real downpscost, SCIP_Real uppscost, SCIP_Real downvsids, SCIP_Real upvsids, SCIP_Real downconflen, SCIP_Real upconflen, SCIP_Real downinfer, SCIP_Real upinfer, SCIP_Real downcutoff, SCIP_Real upcutoff)
Definition: scip_var.c:9534
SCIPgetProbvarSum
SCIP_RETCODE SCIPgetProbvarSum(SCIP *scip, SCIP_VAR **var, SCIP_Real *scalar, SCIP_Real *constant)
Definition: scip_var.c:1791
type_scip.h
type definitions for SCIP&#39;s main datastructure
SCIPaddVarImplication
SCIP_RETCODE SCIPaddVarImplication(SCIP *scip, SCIP_VAR *var, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_BOUNDTYPE impltype, SCIP_Real implbound, SCIP_Bool *infeasible, int *nbdchgs)
Definition: scip_var.c:6777
SCIPunlockVarCons
SCIP_RETCODE SCIPunlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)
Definition: scip_var.c:4434
SCIPchgVarUb
SCIP_RETCODE SCIPchgVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_var.c:4763
SCIPcalculatePscostConfidenceBound
SCIP_Real SCIPcalculatePscostConfidenceBound(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun, SCIP_CONFIDENCELEVEL clevel)
Definition: scip_var.c:8995
SCIPmarkDoNotMultaggrVar
SCIP_RETCODE SCIPmarkDoNotMultaggrVar(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:8712
SCIPsetRelaxSolVal
SCIP_RETCODE SCIPsetRelaxSolVal(SCIP *scip, SCIP_RELAX *relax, SCIP_VAR *var, SCIP_Real val)
Definition: scip_var.c:2411
SCIPtightenVarLbGlobal
SCIP_RETCODE SCIPtightenVarLbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:6225
SCIPgetVarConflictlengthScore
SCIP_Real SCIPgetVarConflictlengthScore(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:9300
SCIPgetVarAvgInferenceScoreCurrentRun
SCIP_Real SCIPgetVarAvgInferenceScoreCurrentRun(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:9501
SCIPsignificantVarPscostDifference
SCIP_Bool SCIPsignificantVarPscostDifference(SCIP *scip, SCIP_VAR *varx, SCIP_Real fracx, SCIP_VAR *vary, SCIP_Real fracy, SCIP_BRANCHDIR dir, SCIP_CONFIDENCELEVEL clevel, SCIP_Bool onesided)
Definition: scip_var.c:9026
SCIPcomputeVarUbLocal
SCIP_Real SCIPcomputeVarUbLocal(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:6523
SCIPinferVarUbProp
SCIP_RETCODE SCIPinferVarUbProp(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_PROP *inferprop, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:6007
SCIPgetProbvarLinearSum
SCIP_RETCODE SCIPgetProbvarLinearSum(SCIP *scip, SCIP_VAR **vars, SCIP_Real *scalars, int *nvars, int varssize, SCIP_Real *constant, int *requiredsize, SCIP_Bool mergemultiples)
Definition: scip_var.c:1735
SCIPgetVarAvgConflictlength
SCIP_Real SCIPgetVarAvgConflictlength(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:9362
SCIPremoveVarFromGlobalStructures
SCIP_RETCODE SCIPremoveVarFromGlobalStructures(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:7856
SCIPgetVarClosestVub
SCIP_RETCODE SCIPgetVarClosestVub(SCIP *scip, SCIP_VAR *var, SCIP_SOL *sol, SCIP_Real *closestvub, int *closestvubidx)
Definition: scip_var.c:6629
type_var.h
type definitions for problem variables
SCIPgetVarStrongbranchLPAge
SCIP_Longint SCIPgetVarStrongbranchLPAge(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:4191
type_relax.h
type definitions for relaxators
SCIPgetVarPseudocostCount
SCIP_Real SCIPgetVarPseudocostCount(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:8919
SCIP_Prop
Definition: struct_prop.h:37
SCIPgetVarPseudocostCurrentRun
SCIP_Real SCIPgetVarPseudocostCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:8893
SCIPchgVarObj
SCIP_RETCODE SCIPchgVarObj(SCIP *scip, SCIP_VAR *var, SCIP_Real newobj)
Definition: scip_var.c:4510
SCIPstartStrongbranch
SCIP_RETCODE SCIPstartStrongbranch(SCIP *scip, SCIP_Bool enablepropagation)
Definition: scip_var.c:2683
SCIP_Bool
#define SCIP_Bool
Definition: def.h:84
SCIPinferVarFixProp
SCIP_RETCODE SCIPinferVarFixProp(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval, SCIP_PROP *inferprop, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:5823
SCIPgetNCliquesCreated
int SCIPgetNCliquesCreated(SCIP *scip)
Definition: scip_var.c:7599
SCIPgetVarStrongbranchWithPropagation
SCIP_RETCODE SCIPgetVarStrongbranchWithPropagation(SCIP *scip, SCIP_VAR *var, SCIP_Real solval, SCIP_Real lpobjval, int itlim, int maxproprounds, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Longint *ndomredsdown, SCIP_Longint *ndomredsup, SCIP_Bool *downinf, SCIP_Bool *upinf, SCIP_Bool *downconflict, SCIP_Bool *upconflict, SCIP_Bool *lperror, SCIP_Real *newlbs, SCIP_Real *newubs)
Definition: scip_var.c:3349
SCIPmarkRelaxSolValid
SCIP_RETCODE SCIPmarkRelaxSolValid(SCIP *scip, SCIP_RELAX *relax, SCIP_Bool includeslp)
Definition: scip_var.c:2554
SCIPcalcCliquePartition
SCIP_RETCODE SCIPcalcCliquePartition(SCIP *const scip, SCIP_VAR **const vars, int const nvars, int *const cliquepartition, int *const ncliques)
Definition: scip_var.c:7253
SCIPwriteCliqueGraph
SCIP_RETCODE SCIPwriteCliqueGraph(SCIP *scip, const char *fname, SCIP_Bool writenodeweights)
Definition: scip_var.c:7707
SCIPenableVarHistory
void SCIPenableVarHistory(SCIP *scip)
Definition: scip_var.c:8738
SCIPcomputeVarLbGlobal
SCIP_Real SCIPcomputeVarLbGlobal(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:6460
SCIPgetVarAvgInferenceCutoffScoreCurrentRun
SCIP_Real SCIPgetVarAvgInferenceCutoffScoreCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_Real cutoffweight)
Definition: scip_var.c:9831
SCIPgetVarsStrongbranchesInt
SCIP_RETCODE SCIPgetVarsStrongbranchesInt(SCIP *scip, SCIP_VAR **vars, int nvars, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Bool *downinf, SCIP_Bool *upinf, SCIP_Bool *downconflict, SCIP_Bool *upconflict, SCIP_Bool *lperror)
Definition: scip_var.c:3881
SCIPcreateVar
SCIP_RETCODE SCIPcreateVar(SCIP *scip, SCIP_VAR **var, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype, SCIP_Bool initial, SCIP_Bool removable, SCIP_DECL_VARDELORIG((*vardelorig)), SCIP_DECL_VARTRANS((*vartrans)), SCIP_DECL_VARDELTRANS((*vardeltrans)), SCIP_DECL_VARCOPY((*varcopy)), SCIP_VARDATA *vardata)
Definition: scip_var.c:105
type_tree.h
type definitions for branch and bound tree
SCIPallowWeakDualReds
SCIP_Bool SCIPallowWeakDualReds(SCIP *scip)
Definition: scip_var.c:8653
SCIPfixVar
SCIP_RETCODE SCIPfixVar(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval, SCIP_Bool *infeasible, SCIP_Bool *fixed)
Definition: scip_var.c:8273
SCIPchgVarBranchPriority
SCIP_RETCODE SCIPchgVarBranchPriority(SCIP *scip, SCIP_VAR *var, int branchpriority)
Definition: scip_var.c:7977
SCIPlockVarCons
SCIP_RETCODE SCIPlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)
Definition: scip_var.c:4348
SCIPinferVarLbCons
SCIP_RETCODE SCIPinferVarLbCons(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:5498
SCIPgetVarStrongbranchFrac
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:2916
type_sol.h
type definitions for storing primal CIP solutions
SCIPgetVarMultaggrLbLocal
SCIP_Real SCIPgetVarMultaggrLbLocal(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:6573
SCIPwriteVarsLinearsum
SCIP_RETCODE SCIPwriteVarsLinearsum(SCIP *scip, FILE *file, SCIP_VAR **vars, SCIP_Real *vals, int nvars, SCIP_Bool type)
Definition: scip_var.c:334
SCIP_DECL_VARDELORIG
#define SCIP_DECL_VARDELORIG(x)
Definition: type_var.h:118
type_prop.h
type definitions for propagators
SCIPgetCliques
SCIP_CLIQUE ** SCIPgetCliques(SCIP *scip)
Definition: scip_var.c:7626
SCIPgetVarAvgConflictlengthCurrentRun
SCIP_Real SCIPgetVarAvgConflictlengthCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:9388
SCIPaddVarBranchFactor
SCIP_RETCODE SCIPaddVarBranchFactor(SCIP *scip, SCIP_VAR *var, SCIP_Real addfactor)
Definition: scip_var.c:7946
SCIPgetLastStrongbranchLPSolStat
SCIP_LPSOLSTAT SCIPgetLastStrongbranchLPSolStat(SCIP *scip, SCIP_BRANCHDIR branchdir)
Definition: scip_var.c:3985
SCIPwriteVarsList
SCIP_RETCODE SCIPwriteVarsList(SCIP *scip, FILE *file, SCIP_VAR **vars, int nvars, SCIP_Bool type, char delimiter)
Definition: scip_var.c:283
SCIPsetVarStrongbranchData
SCIP_RETCODE SCIPsetVarStrongbranchData(SCIP *scip, SCIP_VAR *var, SCIP_Real lpobjval, SCIP_Real primsol, SCIP_Real down, SCIP_Real up, SCIP_Bool downvalid, SCIP_Bool upvalid, SCIP_Longint iter, int itlim)
Definition: scip_var.c:4041
SCIPgetVarImplRedcost
SCIP_Real SCIPgetVarImplRedcost(SCIP *scip, SCIP_VAR *var, SCIP_Bool varfixing)
Definition: scip_var.c:1906
SCIPfreeParseVarsPolynomialData
void SCIPfreeParseVarsPolynomialData(SCIP *scip, SCIP_VAR ****monomialvars, SCIP_Real ***monomialexps, SCIP_Real **monomialcoefs, int **monomialnvars, int nmonomials)
Definition: scip_var.c:1155
scalars
static const SCIP_Real scalars[]
Definition: lp.c:5738
SCIPinferVarUbCons
SCIP_RETCODE SCIPinferVarUbCons(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:5612
SCIPgetVarsStrongbranchesFrac
SCIP_RETCODE SCIPgetVarsStrongbranchesFrac(SCIP *scip, SCIP_VAR **vars, int nvars, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Bool *downinf, SCIP_Bool *upinf, SCIP_Bool *downconflict, SCIP_Bool *upconflict, SCIP_Bool *lperror)
Definition: scip_var.c:3770
SCIPgetVarSols
SCIP_RETCODE SCIPgetVarSols(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
Definition: scip_var.c:2324
SCIPendStrongbranch
SCIP_RETCODE SCIPendStrongbranch(SCIP *scip)
Definition: scip_var.c:2741
SCIPisRelaxSolValid
SCIP_Bool SCIPisRelaxSolValid(SCIP *scip)
Definition: scip_var.c:2534
SCIPallowDualReds
SCIP_Bool SCIPallowDualReds(SCIP *scip)
Definition: scip_var.c:8611
SCIPgetNCliques
int SCIPgetNCliques(SCIP *scip)
Definition: scip_var.c:7572
SCIPaddVarBranchPriority
SCIP_RETCODE SCIPaddVarBranchPriority(SCIP *scip, SCIP_VAR *var, int addpriority)
Definition: scip_var.c:8051
SCIPcalcNegatedCliquePartition
SCIP_RETCODE SCIPcalcNegatedCliquePartition(SCIP *const scip, SCIP_VAR **const vars, int const nvars, int *const cliquepartition, int *const ncliques)
Definition: scip_var.c:7472
SCIPaggregateVars
SCIP_RETCODE SCIPaggregateVars(SCIP *scip, SCIP_VAR *varx, SCIP_VAR *vary, SCIP_Real scalarx, SCIP_Real scalary, SCIP_Real rhs, SCIP_Bool *infeasible, SCIP_Bool *redundant, SCIP_Bool *aggregated)
Definition: scip_var.c:8398
SCIPcaptureVar
SCIP_RETCODE SCIPcaptureVar(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:1211
SCIP_Real
#define SCIP_Real
Definition: def.h:177
type_result.h
result codes for SCIP callback methods
type_history.h
type definitions for branching and inference history
SCIPchgVarBranchDirection
SCIP_RETCODE SCIPchgVarBranchDirection(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR branchdirection)
Definition: scip_var.c:8082
SCIPhaveVarsCommonClique
SCIP_Bool SCIPhaveVarsCommonClique(SCIP *scip, SCIP_VAR *var1, SCIP_Bool value1, SCIP_VAR *var2, SCIP_Bool value2, SCIP_Bool regardimplics)
Definition: scip_var.c:7656
SCIP_Clique
Definition: struct_implics.h:66
SCIPdoNotAggr
SCIP_Bool SCIPdoNotAggr(SCIP *scip)
Definition: scip_var.c:8562
SCIPtransformVar
SCIP_RETCODE SCIPtransformVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **transvar)
Definition: scip_var.c:1346
SCIP_Longint
#define SCIP_Longint
Definition: def.h:162
SCIP_Relax
Definition: struct_relax.h:37
SCIPparseVarsPolynomial
SCIP_RETCODE SCIPparseVarsPolynomial(SCIP *scip, const char *str, SCIP_VAR ****monomialvars, SCIP_Real ***monomialexps, SCIP_Real **monomialcoefs, int **monomialnvars, int *nmonomials, char **endptr, SCIP_Bool *success)
Definition: scip_var.c:809
SCIPdoNotMultaggr
SCIP_Bool SCIPdoNotMultaggr(SCIP *scip)
Definition: scip_var.c:8572
SCIPgetVarConflictScoreCurrentRun
SCIP_Real SCIPgetVarConflictScoreCurrentRun(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:9269
SCIP_VARTYPE
enum SCIP_Vartype SCIP_VARTYPE
Definition: type_var.h:60
SCIPgetVarSol
SCIP_Real SCIPgetVarSol(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:2304
SCIPgetVarMultaggrLbGlobal
SCIP_Real SCIPgetVarMultaggrLbGlobal(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:6543
SCIPtightenVarUbGlobal
SCIP_RETCODE SCIPtightenVarUbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:6345
SCIPinitVarValueBranchStats
SCIP_RETCODE SCIPinitVarValueBranchStats(SCIP *scip, SCIP_VAR *var, SCIP_Real value, SCIP_Real downvsids, SCIP_Real upvsids, SCIP_Real downconflen, SCIP_Real upconflen, SCIP_Real downinfer, SCIP_Real upinfer, SCIP_Real downcutoff, SCIP_Real upcutoff)
Definition: scip_var.c:9605
def.h
common defines and data types used in all packages of SCIP
SCIPupdateVarBranchPriority
SCIP_RETCODE SCIPupdateVarBranchPriority(SCIP *scip, SCIP_VAR *var, int branchpriority)
Definition: scip_var.c:8018
SCIPcleanupCliques
SCIP_RETCODE SCIPcleanupCliques(SCIP *scip, SCIP_Bool *infeasible)
Definition: scip_var.c:7529
SCIPgetVarFarkasCoef
SCIP_Real SCIPgetVarFarkasCoef(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:1951
SCIPwriteVarName
SCIP_RETCODE SCIPwriteVarName(SCIP *scip, FILE *file, SCIP_VAR *var, SCIP_Bool type)
Definition: scip_var.c:221
SCIPgetVarNStrongbranchs
int SCIPgetVarNStrongbranchs(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:4223
SCIPgetActiveVars
SCIP_RETCODE SCIPgetActiveVars(SCIP *scip, SCIP_VAR **vars, int *nvars, int varssize, int *requiredsize)
Definition: scip_var.c:1827
SCIPdisableVarHistory
void SCIPdisableVarHistory(SCIP *scip)
Definition: scip_var.c:8757
SCIPgetVarAvgInferenceScore
SCIP_Real SCIPgetVarAvgInferenceScore(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:9470
SCIPallowStrongDualReds
SCIP_Bool SCIPallowStrongDualReds(SCIP *scip)
Definition: scip_var.c:8626
SCIPinferBinvarCons
SCIP_RETCODE SCIPinferBinvarCons(SCIP *scip, SCIP_VAR *var, SCIP_Bool fixedval, SCIP_CONS *infercons, int inferinfo, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:5720
SCIPparseVar
SCIP_RETCODE SCIPparseVar(SCIP *scip, SCIP_VAR **var, const char *str, SCIP_Bool initial, SCIP_Bool removable, SCIP_DECL_VARCOPY((*varcopy)), SCIP_DECL_VARDELORIG((*vardelorig)), SCIP_DECL_VARTRANS((*vartrans)), SCIP_DECL_VARDELTRANS((*vardeltrans)), SCIP_VARDATA *vardata, char **endptr, SCIP_Bool *success)
Definition: scip_var.c:465
SCIPchgVarBranchFactor
SCIP_RETCODE SCIPchgVarBranchFactor(SCIP *scip, SCIP_VAR *var, SCIP_Real branchfactor)
Definition: scip_var.c:7890
SCIPprintVar
SCIP_RETCODE SCIPprintVar(SCIP *scip, SCIP_VAR *var, FILE *file)
Definition: scip_var.c:9882
SCIPallowObjProp
SCIP_Bool SCIPallowObjProp(SCIP *scip)
Definition: scip_var.c:8639
SCIPgetNegatedVar
SCIP_RETCODE SCIPgetNegatedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **negvar)
Definition: scip_var.c:1524
type_cons.h
type definitions for constraints and constraint handlers
SCIPgetVarConflictScore
SCIP_Real SCIPgetVarConflictScore(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:9238
SCIPgetRelaxSolVal
SCIP_Real SCIPgetRelaxSolVal(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:2600
SCIPchgVarName
SCIP_RETCODE SCIPchgVarName(SCIP *scip, SCIP_VAR *var, const char *name)
Definition: scip_var.c:1296
SCIPgetVarAvgCutoffScore
SCIP_Real SCIPgetVarAvgCutoffScore(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:9724