Scippy

SCIP

Solving Constraint Integer Programs

scip_var.c
Go to the documentation of this file.
1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2 /* */
3 /* This file is part of the program and library */
4 /* SCIP --- Solving Constraint Integer Programs */
5 /* */
6 /* Copyright (C) 2002-2018 Konrad-Zuse-Zentrum */
7 /* fuer Informationstechnik Berlin */
8 /* */
9 /* SCIP is distributed under the terms of the ZIB Academic License. */
10 /* */
11 /* You should have received a copy of the ZIB Academic License */
12 /* along with SCIP; see the file COPYING. If not visit scip.zib.de. */
13 /* */
14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15 
16 /**@file scip_var.c
17  * @brief public methods for SCIP variables
18  * @author Tobias Achterberg
19  * @author Timo Berthold
20  * @author Gerald Gamrath
21  * @author Robert Lion Gottwald
22  * @author Stefan Heinz
23  * @author Gregor Hendel
24  * @author Thorsten Koch
25  * @author Alexander Martin
26  * @author Marc Pfetsch
27  * @author Michael Winkler
28  * @author Kati Wolter
29  *
30  * @todo check all SCIP_STAGE_* switches, and include the new stages TRANSFORMED and INITSOLVE
31  */
32 
33 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
34 
35 #include "blockmemshell/memory.h"
36 #include "lpi/lpi.h"
37 #include "scip/branch.h"
38 #include "scip/clock.h"
39 #include "scip/conflict.h"
40 #include "scip/debug.h"
41 #include "scip/history.h"
42 #include "scip/implics.h"
43 #include "scip/lp.h"
44 #include "scip/prob.h"
45 #include "scip/pub_cons.h"
46 #include "scip/pub_implics.h"
47 #include "scip/pub_lp.h"
48 #include "scip/pub_message.h"
49 #include "scip/pub_misc.h"
50 #include "scip/pub_tree.h"
51 #include "scip/pub_var.h"
52 #include "scip/relax.h"
53 #include "scip/scip_general.h"
54 #include "scip/scip_lp.h"
55 #include "scip/scip_mem.h"
56 #include "scip/scip_message.h"
57 #include "scip/scip_numerics.h"
58 #include "scip/scip_prob.h"
59 #include "scip/scip_probing.h"
60 #include "scip/scip_sol.h"
61 #include "scip/scip_solvingstats.h"
62 #include "scip/scip_tree.h"
63 #include "scip/scip_var.h"
64 #include "scip/set.h"
65 #include "scip/sol.h"
66 #include "scip/solve.h"
67 #include "scip/stat.h"
68 #include "scip/struct_lp.h"
69 #include "scip/struct_mem.h"
70 #include "scip/struct_primal.h"
71 #include "scip/struct_prob.h"
72 #include "scip/struct_scip.h"
73 #include "scip/struct_set.h"
74 #include "scip/struct_stat.h"
75 #include "scip/struct_tree.h"
76 #include "scip/struct_var.h"
77 #include "scip/tree.h"
78 #include "scip/var.h"
79 #include <ctype.h>
80 
81 
82 /** creates and captures problem variable; if variable is of integral type, fractional bounds are automatically rounded;
83  * an integer variable with bounds zero and one is automatically converted into a binary variable;
84  *
85  * @warning When doing column generation and the original problem is a maximization problem, notice that SCIP will
86  * transform the problem into a minimization problem by multiplying the objective function by -1. Thus, the
87  * original objective function value of variables created during the solving process has to be multiplied by
88  * -1, too.
89  *
90  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
91  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
92  *
93  * @pre This method can be called if @p scip is in one of the following stages:
94  * - \ref SCIP_STAGE_PROBLEM
95  * - \ref SCIP_STAGE_TRANSFORMING
96  * - \ref SCIP_STAGE_INITPRESOLVE
97  * - \ref SCIP_STAGE_PRESOLVING
98  * - \ref SCIP_STAGE_EXITPRESOLVE
99  * - \ref SCIP_STAGE_PRESOLVED
100  * - \ref SCIP_STAGE_SOLVING
101  *
102  * @note the variable gets captured, hence at one point you have to release it using the method SCIPreleaseVar()
103  */
105  SCIP* scip, /**< SCIP data structure */
106  SCIP_VAR** var, /**< pointer to variable object */
107  const char* name, /**< name of variable, or NULL for automatic name creation */
108  SCIP_Real lb, /**< lower bound of variable */
109  SCIP_Real ub, /**< upper bound of variable */
110  SCIP_Real obj, /**< objective function value */
111  SCIP_VARTYPE vartype, /**< type of variable */
112  SCIP_Bool initial, /**< should var's column be present in the initial root LP? */
113  SCIP_Bool removable, /**< is var's column removable from the LP (due to aging or cleanup)? */
114  SCIP_DECL_VARDELORIG ((*vardelorig)), /**< frees user data of original variable, or NULL */
115  SCIP_DECL_VARTRANS ((*vartrans)), /**< creates transformed user data by transforming original user data, or NULL */
116  SCIP_DECL_VARDELTRANS ((*vardeltrans)), /**< frees user data of transformed variable, or NULL */
117  SCIP_DECL_VARCOPY ((*varcopy)), /**< copies variable data if wanted to subscip, or NULL */
118  SCIP_VARDATA* vardata /**< user data for this specific variable */
119  )
120 {
121  assert(var != NULL);
122  assert(lb <= ub);
123 
124  SCIP_CALL( SCIPcheckStage(scip, "SCIPcreateVar", FALSE, TRUE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
125 
126  /* forbid infinite objective function values */
127  if( SCIPisInfinity(scip, REALABS(obj)) )
128  {
129  SCIPerrorMessage("invalid objective function value: value is infinite\n");
130  return SCIP_INVALIDDATA;
131  }
132 
133  switch( scip->set->stage )
134  {
135  case SCIP_STAGE_PROBLEM:
136  SCIP_CALL( SCIPvarCreateOriginal(var, scip->mem->probmem, scip->set, scip->stat,
137  name, lb, ub, obj, vartype, initial, removable, vardelorig, vartrans, vardeltrans, varcopy, vardata) );
138  break;
139 
145  case SCIP_STAGE_SOLVING:
146  SCIP_CALL( SCIPvarCreateTransformed(var, scip->mem->probmem, scip->set, scip->stat,
147  name, lb, ub, obj, vartype, initial, removable, vardelorig, vartrans, vardeltrans, varcopy, vardata) );
148  break;
149 
150  default:
151  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
152  return SCIP_INVALIDCALL;
153  } /*lint !e788*/
154 
155  return SCIP_OKAY;
156 }
157 
158 /** creates and captures problem variable with optional callbacks and variable data set to NULL, which can be set
159  * afterwards using SCIPvarSetDelorigData(), SCIPvarSetTransData(),
160  * SCIPvarSetDeltransData(), SCIPvarSetCopy(), and SCIPvarSetData(); sets variable flags initial=TRUE
161  * and removable = FALSE, which can be adjusted by using SCIPvarSetInitial() and SCIPvarSetRemovable(), resp.;
162  * if variable is of integral type, fractional bounds are automatically rounded;
163  * an integer variable with bounds zero and one is automatically converted into a binary variable;
164  *
165  * @warning When doing column generation and the original problem is a maximization problem, notice that SCIP will
166  * transform the problem into a minimization problem by multiplying the objective function by -1. Thus, the
167  * original objective function value of variables created during the solving process has to be multiplied by
168  * -1, too.
169  *
170  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
171  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
172  *
173  * @pre This method can be called if @p scip is in one of the following stages:
174  * - \ref SCIP_STAGE_PROBLEM
175  * - \ref SCIP_STAGE_TRANSFORMING
176  * - \ref SCIP_STAGE_INITPRESOLVE
177  * - \ref SCIP_STAGE_PRESOLVING
178  * - \ref SCIP_STAGE_EXITPRESOLVE
179  * - \ref SCIP_STAGE_PRESOLVED
180  * - \ref SCIP_STAGE_SOLVING
181  *
182  * @note the variable gets captured, hence at one point you have to release it using the method SCIPreleaseVar()
183  */
185  SCIP* scip, /**< SCIP data structure */
186  SCIP_VAR** var, /**< pointer to variable object */
187  const char* name, /**< name of variable, or NULL for automatic name creation */
188  SCIP_Real lb, /**< lower bound of variable */
189  SCIP_Real ub, /**< upper bound of variable */
190  SCIP_Real obj, /**< objective function value */
191  SCIP_VARTYPE vartype /**< type of variable */
192  )
193 {
194  SCIP_CALL( SCIPcheckStage(scip, "SCIPcreateVarBasic", FALSE, TRUE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
195 
196  SCIP_CALL( SCIPcreateVar(scip, var, name, lb, ub, obj, vartype, TRUE, FALSE, NULL, NULL, NULL, NULL, NULL) );
197 
198  return SCIP_OKAY;
199 }
200 
201 /** outputs the variable name to the file stream
202  *
203  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
204  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
205  *
206  * @pre This method can be called if @p scip is in one of the following stages:
207  * - \ref SCIP_STAGE_PROBLEM
208  * - \ref SCIP_STAGE_TRANSFORMING
209  * - \ref SCIP_STAGE_TRANSFORMED
210  * - \ref SCIP_STAGE_INITPRESOLVE
211  * - \ref SCIP_STAGE_PRESOLVING
212  * - \ref SCIP_STAGE_EXITPRESOLVE
213  * - \ref SCIP_STAGE_PRESOLVED
214  * - \ref SCIP_STAGE_INITSOLVE
215  * - \ref SCIP_STAGE_SOLVING
216  * - \ref SCIP_STAGE_SOLVED
217  * - \ref SCIP_STAGE_EXITSOLVE
218  * - \ref SCIP_STAGE_FREETRANS
219  */
221  SCIP* scip, /**< SCIP data structure */
222  FILE* file, /**< output file, or NULL for stdout */
223  SCIP_VAR* var, /**< variable to output */
224  SCIP_Bool type /**< should the variable type be also posted */
225  )
226 {
227  assert(scip != NULL);
228  assert(var != NULL);
229 
230  SCIP_CALL( SCIPcheckStage(scip, "SCIPwriteVarName", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
231 
232  /* print variable name */
233  if( SCIPvarIsNegated(var) )
234  {
235  SCIP_VAR* negatedvar;
236 
237  SCIP_CALL( SCIPgetNegatedVar(scip, var, &negatedvar) );
238  SCIPinfoMessage(scip, file, "<~%s>", SCIPvarGetName(negatedvar));
239  }
240  else
241  {
242  SCIPinfoMessage(scip, file, "<%s>", SCIPvarGetName(var));
243  }
244 
245  if( type )
246  {
247  /* print variable type */
248  SCIPinfoMessage(scip, file, "[%c]",
252  }
253 
254  return SCIP_OKAY;
255 }
256 
257 /** print the given list of variables to output stream separated by the given delimiter character;
258  *
259  * i. e. the variables x1, x2, ..., xn with given delimiter ',' are written as: <x1>, <x2>, ..., <xn>;
260  *
261  * the method SCIPparseVarsList() can parse such a string
262  *
263  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
264  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
265  *
266  * @pre This method can be called if @p scip is in one of the following stages:
267  * - \ref SCIP_STAGE_PROBLEM
268  * - \ref SCIP_STAGE_TRANSFORMING
269  * - \ref SCIP_STAGE_TRANSFORMED
270  * - \ref SCIP_STAGE_INITPRESOLVE
271  * - \ref SCIP_STAGE_PRESOLVING
272  * - \ref SCIP_STAGE_EXITPRESOLVE
273  * - \ref SCIP_STAGE_PRESOLVED
274  * - \ref SCIP_STAGE_INITSOLVE
275  * - \ref SCIP_STAGE_SOLVING
276  * - \ref SCIP_STAGE_SOLVED
277  * - \ref SCIP_STAGE_EXITSOLVE
278  * - \ref SCIP_STAGE_FREETRANS
279  *
280  * @note The printing process is done via the message handler system.
281  */
283  SCIP* scip, /**< SCIP data structure */
284  FILE* file, /**< output file, or NULL for stdout */
285  SCIP_VAR** vars, /**< variable array to output */
286  int nvars, /**< number of variables */
287  SCIP_Bool type, /**< should the variable type be also posted */
288  char delimiter /**< character which is used for delimitation */
289  )
290 {
291  int v;
292 
293  SCIP_CALL( SCIPcheckStage(scip, "SCIPwriteVarsList", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
294 
295  for( v = 0; v < nvars; ++v )
296  {
297  if( v > 0 )
298  {
299  SCIPinfoMessage(scip, file, "%c", delimiter);
300  }
301 
302  /* print variable name */
303  SCIP_CALL( SCIPwriteVarName(scip, file, vars[v], type) );
304  }
305 
306  return SCIP_OKAY;
307 }
308 
309 /** print the given variables and coefficients as linear sum in the following form
310  * c1 <x1> + c2 <x2> ... + cn <xn>
311  *
312  * This string can be parsed by the method SCIPparseVarsLinearsum().
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_TRANSFORMED
321  * - \ref SCIP_STAGE_INITPRESOLVE
322  * - \ref SCIP_STAGE_PRESOLVING
323  * - \ref SCIP_STAGE_EXITPRESOLVE
324  * - \ref SCIP_STAGE_PRESOLVED
325  * - \ref SCIP_STAGE_INITSOLVE
326  * - \ref SCIP_STAGE_SOLVING
327  * - \ref SCIP_STAGE_SOLVED
328  * - \ref SCIP_STAGE_EXITSOLVE
329  * - \ref SCIP_STAGE_FREETRANS
330  *
331  * @note The printing process is done via the message handler system.
332  */
334  SCIP* scip, /**< SCIP data structure */
335  FILE* file, /**< output file, or NULL for stdout */
336  SCIP_VAR** vars, /**< variable array to output */
337  SCIP_Real* vals, /**< array of coefficients or NULL if all coefficients are 1.0 */
338  int nvars, /**< number of variables */
339  SCIP_Bool type /**< should the variable type be also posted */
340  )
341 {
342  int v;
343 
344  SCIP_CALL( SCIPcheckStage(scip, "SCIPwriteVarsLinearsum", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
345 
346  for( v = 0; v < nvars; ++v )
347  {
348  if( vals != NULL )
349  {
350  if( vals[v] == 1.0 )
351  {
352  if( v > 0 )
353  SCIPinfoMessage(scip, file, " +");
354  }
355  else if( vals[v] == -1.0 )
356  SCIPinfoMessage(scip, file, " -");
357  else
358  SCIPinfoMessage(scip, file, " %+.15g", vals[v]);
359  }
360  else if( nvars > 0 )
361  SCIPinfoMessage(scip, file, " +");
362 
363  /* print variable name */
364  SCIP_CALL( SCIPwriteVarName(scip, file, vars[v], type) );
365  }
366 
367  return SCIP_OKAY;
368 }
369 
370 /** print the given monomials as polynomial in the following form
371  * c1 <x11>^e11 <x12>^e12 ... <x1n>^e1n + c2 <x21>^e21 <x22>^e22 ... + ... + cn <xn1>^en1 ...
372  *
373  * This string can be parsed by the method SCIPparseVarsPolynomial().
374  *
375  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
376  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
377  *
378  * @pre This method can be called if @p scip is in one of the following stages:
379  * - \ref SCIP_STAGE_PROBLEM
380  * - \ref SCIP_STAGE_TRANSFORMING
381  * - \ref SCIP_STAGE_TRANSFORMED
382  * - \ref SCIP_STAGE_INITPRESOLVE
383  * - \ref SCIP_STAGE_PRESOLVING
384  * - \ref SCIP_STAGE_EXITPRESOLVE
385  * - \ref SCIP_STAGE_PRESOLVED
386  * - \ref SCIP_STAGE_INITSOLVE
387  * - \ref SCIP_STAGE_SOLVING
388  * - \ref SCIP_STAGE_SOLVED
389  * - \ref SCIP_STAGE_EXITSOLVE
390  * - \ref SCIP_STAGE_FREETRANS
391  *
392  * @note The printing process is done via the message handler system.
393  */
395  SCIP* scip, /**< SCIP data structure */
396  FILE* file, /**< output file, or NULL for stdout */
397  SCIP_VAR*** monomialvars, /**< arrays with variables for each monomial */
398  SCIP_Real** monomialexps, /**< arrays with variable exponents, or NULL if always 1.0 */
399  SCIP_Real* monomialcoefs, /**< array with monomial coefficients */
400  int* monomialnvars, /**< array with number of variables for each monomial */
401  int nmonomials, /**< number of monomials */
402  SCIP_Bool type /**< should the variable type be also posted */
403  )
404 {
405  int i;
406  int v;
407 
408  assert(scip != NULL);
409  assert(monomialvars != NULL || nmonomials == 0);
410  assert(monomialcoefs != NULL || nmonomials == 0);
411  assert(monomialnvars != NULL || nmonomials == 0);
412 
413  SCIP_CALL( SCIPcheckStage(scip, "SCIPwriteVarsPolynomial", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
414 
415  if( nmonomials == 0 )
416  {
417  SCIPinfoMessage(scip, file, " 0 ");
418  return SCIP_OKAY;
419  }
420 
421  for( i = 0; i < nmonomials; ++i )
422  {
423  if( monomialcoefs[i] == 1.0 ) /*lint !e613*/
424  {
425  if( i > 0 )
426  SCIPinfoMessage(scip, file, " +");
427  }
428  else if( monomialcoefs[i] == -1.0 ) /*lint !e613*/
429  SCIPinfoMessage(scip, file, " -");
430  else
431  SCIPinfoMessage(scip, file, " %+.15g", monomialcoefs[i]); /*lint !e613*/
432 
433  assert(monomialvars[i] != NULL || monomialnvars[i] == 0); /*lint !e613*/
434 
435  for( v = 0; v < monomialnvars[i]; ++v ) /*lint !e613*/
436  {
437  SCIP_CALL( SCIPwriteVarName(scip, file, monomialvars[i][v], type) ); /*lint !e613*/
438  if( monomialexps != NULL && monomialexps[i] != NULL && monomialexps[i][v] != 1.0 )
439  {
440  SCIPinfoMessage(scip, file, "^%.15g", monomialexps[i][v]);
441  }
442  }
443  }
444 
445  return SCIP_OKAY;
446 }
447 
448 /** parses variable information (in cip format) out of a string; if the parsing process was successful a variable is
449  * created and captured; if variable is of integral type, fractional bounds are automatically rounded; an integer
450  * variable with bounds zero and one is automatically converted into a binary variable
451  *
452  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
453  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
454  *
455  * @pre This method can be called if @p scip is in one of the following stages:
456  * - \ref SCIP_STAGE_PROBLEM
457  * - \ref SCIP_STAGE_TRANSFORMING
458  * - \ref SCIP_STAGE_INITPRESOLVE
459  * - \ref SCIP_STAGE_PRESOLVING
460  * - \ref SCIP_STAGE_EXITPRESOLVE
461  * - \ref SCIP_STAGE_PRESOLVED
462  * - \ref SCIP_STAGE_SOLVING
463  */
465  SCIP* scip, /**< SCIP data structure */
466  SCIP_VAR** var, /**< pointer to store the problem variable */
467  const char* str, /**< string to parse */
468  SCIP_Bool initial, /**< should var's column be present in the initial root LP? */
469  SCIP_Bool removable, /**< is var's column removable from the LP (due to aging or cleanup)? */
470  SCIP_DECL_VARCOPY ((*varcopy)), /**< copies variable data if wanted to subscip, or NULL */
471  SCIP_DECL_VARDELORIG ((*vardelorig)), /**< frees user data of original variable */
472  SCIP_DECL_VARTRANS ((*vartrans)), /**< creates transformed user data by transforming original user data */
473  SCIP_DECL_VARDELTRANS ((*vardeltrans)), /**< frees user data of transformed variable */
474  SCIP_VARDATA* vardata, /**< user data for this specific variable */
475  char** endptr, /**< pointer to store the final string position if successful */
476  SCIP_Bool* success /**< pointer store if the paring process was successful */
477  )
478 {
479  assert(var != NULL);
480 
481  SCIP_CALL( SCIPcheckStage(scip, "SCIPparseVar", FALSE, TRUE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
482 
483  switch( scip->set->stage )
484  {
485  case SCIP_STAGE_PROBLEM:
486  SCIP_CALL( SCIPvarParseOriginal(var, scip->mem->probmem, scip->set, scip->messagehdlr, scip->stat,
487  str, initial, removable, varcopy, vardelorig, vartrans, vardeltrans, vardata, endptr, success) );
488  break;
489 
495  case SCIP_STAGE_SOLVING:
496  SCIP_CALL( SCIPvarParseTransformed(var, scip->mem->probmem, scip->set, scip->messagehdlr, scip->stat,
497  str, initial, removable, varcopy, vardelorig, vartrans, vardeltrans, vardata, endptr, success) );
498  break;
499 
500  default:
501  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
502  return SCIP_INVALIDCALL;
503  } /*lint !e788*/
504 
505  return SCIP_OKAY;
506 }
507 
508 /** parses the given string for a variable name and stores the variable in the corresponding pointer if such a variable
509  * exits and returns the position where the parsing stopped
510  *
511  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
512  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
513  *
514  * @pre This method can be called if @p scip is in one of the following stages:
515  * - \ref SCIP_STAGE_PROBLEM
516  * - \ref SCIP_STAGE_TRANSFORMING
517  * - \ref SCIP_STAGE_INITPRESOLVE
518  * - \ref SCIP_STAGE_PRESOLVING
519  * - \ref SCIP_STAGE_EXITPRESOLVE
520  * - \ref SCIP_STAGE_PRESOLVED
521  * - \ref SCIP_STAGE_SOLVING
522  */
524  SCIP* scip, /**< SCIP data structure */
525  const char* str, /**< string to parse */
526  SCIP_VAR** var, /**< pointer to store the problem variable, or NULL if it does not exit */
527  char** endptr /**< pointer to store the final string position if successful */
528  )
529 {
530  char varname[SCIP_MAXSTRLEN];
531 
532  assert(str != NULL);
533  assert(var != NULL);
534  assert(endptr != NULL);
535 
536  SCIP_CALL( SCIPcheckStage(scip, "SCIPparseVarName", FALSE, TRUE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
537 
538  SCIPstrCopySection(str, '<', '>', varname, SCIP_MAXSTRLEN, endptr);
539  assert(*endptr != NULL);
540 
541  if( *varname == '\0' )
542  {
543  SCIPerrorMessage("invalid variable name string given: could not find '<'\n");
544  return SCIP_INVALIDDATA;
545  }
546 
547  /* check if we have a negated variable */
548  if( *varname == '~' )
549  {
550  SCIPdebugMsg(scip, "parsed negated variable name <%s>\n", &varname[1]);
551 
552  /* search for the variable and ignore '~' */
553  (*var) = SCIPfindVar(scip, &varname[1]);
554 
555  if( *var != NULL )
556  {
557  SCIP_CALL( SCIPgetNegatedVar(scip, *var, var) );
558  }
559  }
560  else
561  {
562  SCIPdebugMsg(scip, "parsed variable name <%s>\n", varname);
563 
564  /* search for the variable */
565  (*var) = SCIPfindVar(scip, varname);
566  }
567 
568  str = *endptr;
569 
570  /* skip additional variable type marker */
571  if( *str == '[' && (str[1] == SCIP_VARTYPE_BINARY_CHAR || str[1] == SCIP_VARTYPE_INTEGER_CHAR ||
572  str[1] == SCIP_VARTYPE_IMPLINT_CHAR || str[1] == SCIP_VARTYPE_CONTINUOUS_CHAR ) && str[2] == ']' )
573  (*endptr) += 3;
574 
575  return SCIP_OKAY;
576 }
577 
578 /** parse the given string as variable list (here ',' is the delimiter)) (<x1>, <x2>, ..., <xn>) (see
579  * SCIPwriteVarsList() ); if it was successful, the pointer success is set to TRUE
580  *
581  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
582  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
583  *
584  * @pre This method can be called if @p scip is in one of the following stages:
585  * - \ref SCIP_STAGE_PROBLEM
586  * - \ref SCIP_STAGE_TRANSFORMING
587  * - \ref SCIP_STAGE_INITPRESOLVE
588  * - \ref SCIP_STAGE_PRESOLVING
589  * - \ref SCIP_STAGE_EXITPRESOLVE
590  * - \ref SCIP_STAGE_PRESOLVED
591  * - \ref SCIP_STAGE_SOLVING
592  *
593  * @note The pointer success in only set to FALSE in the case that a variable with a parsed variable name does not exist.
594  *
595  * @note If the number of (parsed) variables is greater than the available slots in the variable array, nothing happens
596  * except that the required size is stored in the corresponding integer; the reason for this approach is that we
597  * cannot reallocate memory, since we do not know how the memory has been allocated (e.g., by a C++ 'new' or SCIP
598  * memory functions).
599  */
601  SCIP* scip, /**< SCIP data structure */
602  const char* str, /**< string to parse */
603  SCIP_VAR** vars, /**< array to store the parsed variable */
604  int* nvars, /**< pointer to store number of parsed variables */
605  int varssize, /**< size of the variable array */
606  int* requiredsize, /**< pointer to store the required array size for the active variables */
607  char** endptr, /**< pointer to store the final string position if successful */
608  char delimiter, /**< character which is used for delimitation */
609  SCIP_Bool* success /**< pointer to store the whether the parsing was successful or not */
610  )
611 {
612  SCIP_VAR** tmpvars;
613  SCIP_VAR* var;
614  int ntmpvars = 0;
615  int v;
616 
617  assert( nvars != NULL );
618  assert( requiredsize != NULL );
619  assert( endptr != NULL );
620  assert( success != NULL );
621 
622  SCIP_CALL( SCIPcheckStage(scip, "SCIPparseVarsList", FALSE, TRUE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
623 
624  /* allocate buffer memory for temporary storing the parsed variables */
625  SCIP_CALL( SCIPallocBufferArray(scip, &tmpvars, varssize) );
626 
627  (*success) = TRUE;
628 
629  do
630  {
631  *endptr = (char*)str;
632 
633  /* parse variable name */
634  SCIP_CALL( SCIPparseVarName(scip, str, &var, endptr) );
635 
636  if( var == NULL )
637  {
638  SCIPdebugMsg(scip, "variable with name <%s> does not exist\n", SCIPvarGetName(var));
639  (*success) = FALSE;
640  break;
641  }
642 
643  /* store the variable in the tmp array */
644  if( ntmpvars < varssize )
645  tmpvars[ntmpvars] = var;
646 
647  ntmpvars++;
648 
649  str = *endptr;
650 
651  while( isspace((unsigned char)*str) )
652  str++;
653  }
654  while( *str == delimiter );
655 
656  *endptr = (char*)str;
657 
658  /* if all variable name searches were successful and the variable array has enough slots, copy the collected variables */
659  if( (*success) && ntmpvars <= varssize )
660  {
661  for( v = 0; v < ntmpvars; ++v )
662  vars[v] = tmpvars[v];
663 
664  (*nvars) = ntmpvars;
665  }
666  else
667  (*nvars) = 0;
668 
669  (*requiredsize) = ntmpvars;
670 
671  /* free buffer arrays */
672  SCIPfreeBufferArray(scip, &tmpvars);
673 
674  return SCIP_OKAY;
675 }
676 
677 /** parse the given string as linear sum of variables and coefficients (c1 <x1> + c2 <x2> + ... + cn <xn>)
678  * (see SCIPwriteVarsLinearsum() ); if it was successful, the pointer success is set to TRUE
679  *
680  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
681  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
682  *
683  * @pre This method can be called if @p scip is in one of the following stages:
684  * - \ref SCIP_STAGE_PROBLEM
685  * - \ref SCIP_STAGE_TRANSFORMING
686  * - \ref SCIP_STAGE_INITPRESOLVE
687  * - \ref SCIP_STAGE_PRESOLVING
688  * - \ref SCIP_STAGE_EXITPRESOLVE
689  * - \ref SCIP_STAGE_PRESOLVED
690  * - \ref SCIP_STAGE_SOLVING
691  *
692  * @note The pointer success in only set to FALSE in the case that a variable with a parsed variable name does not exist.
693  *
694  * @note If the number of (parsed) variables is greater than the available slots in the variable array, nothing happens
695  * except that the required size is stored in the corresponding integer; the reason for this approach is that we
696  * cannot reallocate memory, since we do not know how the memory has been allocated (e.g., by a C++ 'new' or SCIP
697  * memory functions).
698  */
700  SCIP* scip, /**< SCIP data structure */
701  const char* str, /**< string to parse */
702  SCIP_VAR** vars, /**< array to store the parsed variables */
703  SCIP_Real* vals, /**< array to store the parsed coefficients */
704  int* nvars, /**< pointer to store number of parsed variables */
705  int varssize, /**< size of the variable array */
706  int* requiredsize, /**< pointer to store the required array size for the active variables */
707  char** endptr, /**< pointer to store the final string position if successful */
708  SCIP_Bool* success /**< pointer to store the whether the parsing was successful or not */
709  )
710 {
711  SCIP_VAR*** monomialvars;
712  SCIP_Real** monomialexps;
713  SCIP_Real* monomialcoefs;
714  int* monomialnvars;
715  int nmonomials;
716 
717  SCIP_CALL( SCIPcheckStage(scip, "SCIPparseVarsLinearsum", FALSE, TRUE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
718 
719  assert(scip != NULL);
720  assert(str != NULL);
721  assert(vars != NULL || varssize == 0);
722  assert(vals != NULL || varssize == 0);
723  assert(nvars != NULL);
724  assert(requiredsize != NULL);
725  assert(endptr != NULL);
726  assert(success != NULL);
727 
728  *requiredsize = 0;
729 
730  SCIP_CALL( SCIPparseVarsPolynomial(scip, str, &monomialvars, &monomialexps, &monomialcoefs, &monomialnvars, &nmonomials, endptr, success) );
731 
732  if( !*success )
733  {
734  assert(nmonomials == 0); /* SCIPparseVarsPolynomial should have freed all buffers, so no need to call free here */
735  return SCIP_OKAY;
736  }
737 
738  /* check if linear sum is just "0" */
739  if( nmonomials == 1 && monomialnvars[0] == 0 && monomialcoefs[0] == 0.0 )
740  {
741  *nvars = 0;
742  *requiredsize = 0;
743 
744  SCIPfreeParseVarsPolynomialData(scip, &monomialvars, &monomialexps, &monomialcoefs, &monomialnvars, nmonomials);
745 
746  return SCIP_OKAY;
747  }
748 
749  *nvars = nmonomials;
750  *requiredsize = nmonomials;
751 
752  /* if we have enough slots in the variables array, copy variables over */
753  if( varssize >= nmonomials )
754  {
755  int v;
756 
757  for( v = 0; v < nmonomials; ++v )
758  {
759  if( monomialnvars[v] == 0 )
760  {
761  SCIPerrorMessage("constant in linear sum\n");
762  *success = FALSE;
763  break;
764  }
765  if( monomialnvars[v] > 1 || monomialexps[v][0] != 1.0 )
766  {
767  SCIPerrorMessage("nonlinear monomial in linear sum\n");
768  *success = FALSE;
769  break;
770  }
771  assert(monomialnvars[v] == 1);
772  assert(monomialvars[v][0] != NULL);
773  assert(monomialexps[v][0] == 1.0);
774 
775  vars[v] = monomialvars[v][0]; /*lint !e613*/
776  vals[v] = monomialcoefs[v]; /*lint !e613*/
777  }
778  }
779 
780  SCIPfreeParseVarsPolynomialData(scip, &monomialvars, &monomialexps, &monomialcoefs, &monomialnvars, nmonomials);
781 
782  return SCIP_OKAY;
783 }
784 
785 /** parse the given string as polynomial of variables and coefficients
786  * (c1 <x11>^e11 <x12>^e12 ... <x1n>^e1n + c2 <x21>^e21 <x22>^e22 ... + ... + cn <xn1>^en1 ...)
787  * (see SCIPwriteVarsPolynomial()); if it was successful, the pointer success is set to TRUE
788  *
789  * The user has to call SCIPfreeParseVarsPolynomialData(scip, monomialvars, monomialexps,
790  * monomialcoefs, monomialnvars, *nmonomials) short after SCIPparseVarsPolynomial to free all the
791  * allocated memory again. Do not keep the arrays created by SCIPparseVarsPolynomial around, since
792  * they use buffer memory that is intended for short term use only.
793  *
794  * Parsing is stopped at the end of string (indicated by the \\0-character) or when no more monomials
795  * are recognized.
796  *
797  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
798  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
799  *
800  * @pre This method can be called if @p scip is in one of the following stages:
801  * - \ref SCIP_STAGE_PROBLEM
802  * - \ref SCIP_STAGE_TRANSFORMING
803  * - \ref SCIP_STAGE_INITPRESOLVE
804  * - \ref SCIP_STAGE_PRESOLVING
805  * - \ref SCIP_STAGE_EXITPRESOLVE
806  * - \ref SCIP_STAGE_PRESOLVED
807  * - \ref SCIP_STAGE_SOLVING
808  */
810  SCIP* scip, /**< SCIP data structure */
811  const char* str, /**< string to parse */
812  SCIP_VAR**** monomialvars, /**< pointer to store arrays with variables for each monomial */
813  SCIP_Real*** monomialexps, /**< pointer to store arrays with variable exponents */
814  SCIP_Real** monomialcoefs, /**< pointer to store array with monomial coefficients */
815  int** monomialnvars, /**< pointer to store array with number of variables for each monomial */
816  int* nmonomials, /**< pointer to store number of parsed monomials */
817  char** endptr, /**< pointer to store the final string position if successful */
818  SCIP_Bool* success /**< pointer to store the whether the parsing was successful or not */
819  )
820 {
821  typedef enum
822  {
823  SCIPPARSEPOLYNOMIAL_STATE_BEGIN, /* we are at the beginning of a monomial */
824  SCIPPARSEPOLYNOMIAL_STATE_INTERMED, /* we are in between the factors of a monomial */
825  SCIPPARSEPOLYNOMIAL_STATE_COEF, /* we parse the coefficient of a monomial */
826  SCIPPARSEPOLYNOMIAL_STATE_VARS, /* we parse monomial variables */
827  SCIPPARSEPOLYNOMIAL_STATE_EXPONENT, /* we parse the exponent of a variable */
828  SCIPPARSEPOLYNOMIAL_STATE_END, /* we are at the end the polynomial */
829  SCIPPARSEPOLYNOMIAL_STATE_ERROR /* a parsing error occured */
830  } SCIPPARSEPOLYNOMIAL_STATES;
831 
832  SCIPPARSEPOLYNOMIAL_STATES state;
833  int monomialssize;
834 
835  /* data of currently parsed monomial */
836  int varssize;
837  int nvars;
838  SCIP_VAR** vars;
839  SCIP_Real* exponents;
840  SCIP_Real coef;
841 
842  assert(scip != NULL);
843  assert(str != NULL);
844  assert(monomialvars != NULL);
845  assert(monomialexps != NULL);
846  assert(monomialnvars != NULL);
847  assert(monomialcoefs != NULL);
848  assert(nmonomials != NULL);
849  assert(endptr != NULL);
850  assert(success != NULL);
851 
852  SCIP_CALL( SCIPcheckStage(scip, "SCIPparseVarsPolynomial", FALSE, TRUE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
853 
854  *success = FALSE;
855  *nmonomials = 0;
856  monomialssize = 0;
857  *monomialvars = NULL;
858  *monomialexps = NULL;
859  *monomialcoefs = NULL;
860  *monomialnvars = NULL;
861 
862  /* initialize state machine */
863  state = SCIPPARSEPOLYNOMIAL_STATE_BEGIN;
864  varssize = 0;
865  nvars = 0;
866  vars = NULL;
867  exponents = NULL;
868  coef = SCIP_INVALID;
869 
870  SCIPdebugMsg(scip, "parsing polynomial from '%s'\n", str);
871 
872  while( *str && state != SCIPPARSEPOLYNOMIAL_STATE_END && state != SCIPPARSEPOLYNOMIAL_STATE_ERROR )
873  {
874  /* skip white space */
875  while( isspace((unsigned char)*str) )
876  str++;
877 
878  assert(state != SCIPPARSEPOLYNOMIAL_STATE_END);
879 
880  switch( state )
881  {
882  case SCIPPARSEPOLYNOMIAL_STATE_BEGIN:
883  {
884  if( coef != SCIP_INVALID ) /*lint !e777*/
885  {
886  SCIPdebugMsg(scip, "push monomial with coefficient <%g> and <%d> vars\n", coef, nvars);
887  /* push previous monomial */
888  if( monomialssize <= *nmonomials )
889  {
890  monomialssize = SCIPcalcMemGrowSize(scip, *nmonomials+1);
891 
892  SCIP_CALL( SCIPreallocBufferArray(scip, monomialvars, monomialssize) );
893  SCIP_CALL( SCIPreallocBufferArray(scip, monomialexps, monomialssize) );
894  SCIP_CALL( SCIPreallocBufferArray(scip, monomialnvars, monomialssize) );
895  SCIP_CALL( SCIPreallocBufferArray(scip, monomialcoefs, monomialssize) );
896  }
897 
898  if( nvars > 0 )
899  {
900  SCIP_CALL( SCIPduplicateBufferArray(scip, &(*monomialvars)[*nmonomials], vars, nvars) ); /*lint !e866*/
901  SCIP_CALL( SCIPduplicateBufferArray(scip, &(*monomialexps)[*nmonomials], exponents, nvars) ); /*lint !e866*/
902  }
903  else
904  {
905  (*monomialvars)[*nmonomials] = NULL;
906  (*monomialexps)[*nmonomials] = NULL;
907  }
908  (*monomialcoefs)[*nmonomials] = coef;
909  (*monomialnvars)[*nmonomials] = nvars;
910  ++*nmonomials;
911 
912  nvars = 0;
913  coef = SCIP_INVALID;
914  }
915 
916  if( *str == '<' )
917  {
918  /* there seem to come a variable at the beginning of a monomial
919  * so assume the coefficient is 1.0
920  */
921  state = SCIPPARSEPOLYNOMIAL_STATE_VARS;
922  coef = 1.0;
923  break;
924  }
925  if( *str == '-' || *str == '+' || isdigit(*str) )
926  {
927  state = SCIPPARSEPOLYNOMIAL_STATE_COEF;
928  break;
929  }
930 
931  state = SCIPPARSEPOLYNOMIAL_STATE_END;
932 
933  break;
934  }
935 
936  case SCIPPARSEPOLYNOMIAL_STATE_INTERMED:
937  {
938  if( *str == '<' )
939  {
940  /* there seem to come another variable */
941  state = SCIPPARSEPOLYNOMIAL_STATE_VARS;
942  break;
943  }
944 
945  if( *str == '-' || *str == '+' || isdigit(*str) )
946  {
947  /* there seem to come a coefficient, which means the next monomial */
948  state = SCIPPARSEPOLYNOMIAL_STATE_BEGIN;
949  break;
950  }
951 
952  /* since we cannot detect the symbols we stop parsing the polynomial */
953  state = SCIPPARSEPOLYNOMIAL_STATE_END;
954  break;
955  }
956 
957  case SCIPPARSEPOLYNOMIAL_STATE_COEF:
958  {
959  if( *str == '+' && !isdigit(str[1]) )
960  {
961  /* only a plus sign, without number */
962  coef = 1.0;
963  ++str;
964  }
965  else if( *str == '-' && !isdigit(str[1]) )
966  {
967  /* only a minus sign, without number */
968  coef = -1.0;
969  ++str;
970  }
971  else if( SCIPstrToRealValue(str, &coef, endptr) )
972  {
973  str = *endptr;
974  }
975  else
976  {
977  SCIPerrorMessage("could not parse number in the beginning of '%s'\n", str);
978  state = SCIPPARSEPOLYNOMIAL_STATE_ERROR;
979  break;
980  }
981 
982  /* after the coefficient we go into the intermediate state, i.e., expecting next variables */
983  state = SCIPPARSEPOLYNOMIAL_STATE_INTERMED;
984 
985  break;
986  }
987 
988  case SCIPPARSEPOLYNOMIAL_STATE_VARS:
989  {
990  SCIP_VAR* var;
991 
992  assert(*str == '<');
993 
994  /* parse variable name */
995  SCIP_CALL( SCIPparseVarName(scip, str, &var, endptr) );
996 
997  /* check if variable name was parsed */
998  if( *endptr == str )
999  {
1000  state = SCIPPARSEPOLYNOMIAL_STATE_END;
1001  break;
1002  }
1003 
1004  if( var == NULL )
1005  {
1006  SCIPerrorMessage("did not find variable in the beginning of %s\n", str);
1007  state = SCIPPARSEPOLYNOMIAL_STATE_ERROR;
1008  break;
1009  }
1010 
1011  /* add variable to vars array */
1012  if( nvars + 1 > varssize )
1013  {
1014  varssize = SCIPcalcMemGrowSize(scip, nvars+1);
1015  SCIP_CALL( SCIPreallocBufferArray(scip, &vars, varssize) );
1016  SCIP_CALL( SCIPreallocBufferArray(scip, &exponents, varssize) );
1017  }
1018  assert(vars != NULL);
1019  assert(exponents != NULL);
1020 
1021  vars[nvars] = var;
1022  exponents[nvars] = 1.0;
1023  ++nvars;
1024 
1025  str = *endptr;
1026 
1027  if( *str == '^' )
1028  state = SCIPPARSEPOLYNOMIAL_STATE_EXPONENT;
1029  else
1030  state = SCIPPARSEPOLYNOMIAL_STATE_INTERMED;
1031 
1032  break;
1033  }
1034 
1035  case SCIPPARSEPOLYNOMIAL_STATE_EXPONENT:
1036  {
1037  assert(*str == '^');
1038  assert(nvars > 0); /* we should be in a monomial that has already a variable */
1039  assert(exponents != NULL);
1040  ++str;
1041 
1042  if( !SCIPstrToRealValue(str, &exponents[nvars-1], endptr) )
1043  {
1044  SCIPerrorMessage("could not parse number in the beginning of '%s'\n", str);
1045  state = SCIPPARSEPOLYNOMIAL_STATE_ERROR;
1046  break;
1047  }
1048  str = *endptr;
1049 
1050  /* after the exponent we go into the intermediate state, i.e., expecting next variables */
1051  state = SCIPPARSEPOLYNOMIAL_STATE_INTERMED;
1052  break;
1053  }
1054 
1055  case SCIPPARSEPOLYNOMIAL_STATE_END:
1056  case SCIPPARSEPOLYNOMIAL_STATE_ERROR:
1057  default:
1058  SCIPerrorMessage("unexpected state\n");
1059  return SCIP_READERROR;
1060  }
1061  }
1062 
1063  /* set end pointer */
1064  *endptr = (char*)str;
1065 
1066  /* check state at end of string */
1067  switch( state )
1068  {
1069  case SCIPPARSEPOLYNOMIAL_STATE_BEGIN:
1070  case SCIPPARSEPOLYNOMIAL_STATE_END:
1071  case SCIPPARSEPOLYNOMIAL_STATE_INTERMED:
1072  {
1073  if( coef != SCIP_INVALID ) /*lint !e777*/
1074  {
1075  /* push last monomial */
1076  SCIPdebugMsg(scip, "push monomial with coefficient <%g> and <%d> vars\n", coef, nvars);
1077  if( monomialssize <= *nmonomials )
1078  {
1079  monomialssize = *nmonomials+1;
1080  SCIP_CALL( SCIPreallocBufferArray(scip, monomialvars, monomialssize) );
1081  SCIP_CALL( SCIPreallocBufferArray(scip, monomialexps, monomialssize) );
1082  SCIP_CALL( SCIPreallocBufferArray(scip, monomialnvars, monomialssize) );
1083  SCIP_CALL( SCIPreallocBufferArray(scip, monomialcoefs, monomialssize) );
1084  }
1085 
1086  if( nvars > 0 )
1087  {
1088  /* shrink vars and exponents array to needed size and take over ownership */
1089  SCIP_CALL( SCIPreallocBufferArray(scip, &vars, nvars) );
1090  SCIP_CALL( SCIPreallocBufferArray(scip, &exponents, nvars) );
1091  (*monomialvars)[*nmonomials] = vars;
1092  (*monomialexps)[*nmonomials] = exponents;
1093  vars = NULL;
1094  exponents = NULL;
1095  }
1096  else
1097  {
1098  (*monomialvars)[*nmonomials] = NULL;
1099  (*monomialexps)[*nmonomials] = NULL;
1100  }
1101  (*monomialcoefs)[*nmonomials] = coef;
1102  (*monomialnvars)[*nmonomials] = nvars;
1103  ++*nmonomials;
1104  }
1105 
1106  *success = TRUE;
1107  break;
1108  }
1109 
1110  case SCIPPARSEPOLYNOMIAL_STATE_COEF:
1111  case SCIPPARSEPOLYNOMIAL_STATE_VARS:
1112  case SCIPPARSEPOLYNOMIAL_STATE_EXPONENT:
1113  {
1114  SCIPerrorMessage("unexpected parsing state at end of polynomial string\n");
1115  }
1116  /*lint -fallthrough*/
1117  case SCIPPARSEPOLYNOMIAL_STATE_ERROR:
1118  assert(!*success);
1119  break;
1120  }
1121 
1122  /* free memory to store current monomial, if still existing */
1123  SCIPfreeBufferArrayNull(scip, &vars);
1124  SCIPfreeBufferArrayNull(scip, &exponents);
1125 
1126  if( *success && *nmonomials > 0 )
1127  {
1128  /* shrink arrays to required size, so we do not need to keep monomialssize around */
1129  assert(*nmonomials <= monomialssize);
1130  SCIP_CALL( SCIPreallocBufferArray(scip, monomialvars, *nmonomials) );
1131  SCIP_CALL( SCIPreallocBufferArray(scip, monomialexps, *nmonomials) );
1132  SCIP_CALL( SCIPreallocBufferArray(scip, monomialnvars, *nmonomials) );
1133  SCIP_CALL( SCIPreallocBufferArray(scip, monomialcoefs, *nmonomials) );
1134 
1135  /* SCIPwriteVarsPolynomial(scip, NULL, *monomialvars, *monomialexps, *monomialcoefs, *monomialnvars, *nmonomials, FALSE); */
1136  }
1137  else
1138  {
1139  /* in case of error, cleanup all data here */
1140  SCIPfreeParseVarsPolynomialData(scip, monomialvars, monomialexps, monomialcoefs, monomialnvars, *nmonomials);
1141  *nmonomials = 0;
1142  }
1143 
1144  return SCIP_OKAY;
1145 }
1146 
1147 /** frees memory allocated when parsing a polynomial from a string
1148  *
1149  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1150  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1151  *
1152  * @pre This method can be called if @p scip is in one of the following stages:
1153  * - \ref SCIP_STAGE_PROBLEM
1154  * - \ref SCIP_STAGE_TRANSFORMING
1155  * - \ref SCIP_STAGE_INITPRESOLVE
1156  * - \ref SCIP_STAGE_PRESOLVING
1157  * - \ref SCIP_STAGE_EXITPRESOLVE
1158  * - \ref SCIP_STAGE_PRESOLVED
1159  * - \ref SCIP_STAGE_SOLVING
1160  */
1162  SCIP* scip, /**< SCIP data structure */
1163  SCIP_VAR**** monomialvars, /**< pointer to store arrays with variables for each monomial */
1164  SCIP_Real*** monomialexps, /**< pointer to store arrays with variable exponents */
1165  SCIP_Real** monomialcoefs, /**< pointer to store array with monomial coefficients */
1166  int** monomialnvars, /**< pointer to store array with number of variables for each monomial */
1167  int nmonomials /**< pointer to store number of parsed monomials */
1168  )
1169 {
1170  int i;
1171 
1172  assert(scip != NULL);
1173  assert(monomialvars != NULL);
1174  assert(monomialexps != NULL);
1175  assert(monomialcoefs != NULL);
1176  assert(monomialnvars != NULL);
1177  assert((*monomialvars != NULL) == (nmonomials > 0));
1178  assert((*monomialexps != NULL) == (nmonomials > 0));
1179  assert((*monomialcoefs != NULL) == (nmonomials > 0));
1180  assert((*monomialnvars != NULL) == (nmonomials > 0));
1181 
1182  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPfreeParseVarsPolynomialData", FALSE, TRUE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1183 
1184  if( nmonomials == 0 )
1185  return;
1186 
1187  for( i = nmonomials - 1; i >= 0; --i )
1188  {
1189  SCIPfreeBufferArrayNull(scip, &(*monomialvars)[i]);
1190  SCIPfreeBufferArrayNull(scip, &(*monomialexps)[i]);
1191  }
1192 
1193  SCIPfreeBufferArray(scip, monomialvars);
1194  SCIPfreeBufferArray(scip, monomialexps);
1195  SCIPfreeBufferArray(scip, monomialcoefs);
1196  SCIPfreeBufferArray(scip, monomialnvars);
1197 }
1198 
1199 /** increases usage counter of variable
1200  *
1201  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1202  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1203  *
1204  * @pre This method can be called if @p scip is in one of the following stages:
1205  * - \ref SCIP_STAGE_PROBLEM
1206  * - \ref SCIP_STAGE_TRANSFORMING
1207  * - \ref SCIP_STAGE_TRANSFORMED
1208  * - \ref SCIP_STAGE_INITPRESOLVE
1209  * - \ref SCIP_STAGE_PRESOLVING
1210  * - \ref SCIP_STAGE_EXITPRESOLVE
1211  * - \ref SCIP_STAGE_PRESOLVED
1212  * - \ref SCIP_STAGE_INITSOLVE
1213  * - \ref SCIP_STAGE_SOLVING
1214  * - \ref SCIP_STAGE_SOLVED
1215  * - \ref SCIP_STAGE_EXITSOLVE
1216  */
1218  SCIP* scip, /**< SCIP data structure */
1219  SCIP_VAR* var /**< variable to capture */
1220  )
1221 {
1222  SCIP_CALL( SCIPcheckStage(scip, "SCIPcaptureVar", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
1223  assert(var->scip == scip);
1224 
1225  SCIPvarCapture(var);
1226 
1227  return SCIP_OKAY;
1228 }
1229 
1230 /** decreases usage counter of variable, if the usage pointer reaches zero the variable gets freed
1231  *
1232  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1233  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1234  *
1235  * @pre This method can be called if @p scip is in one of the following stages:
1236  * - \ref SCIP_STAGE_PROBLEM
1237  * - \ref SCIP_STAGE_TRANSFORMING
1238  * - \ref SCIP_STAGE_TRANSFORMED
1239  * - \ref SCIP_STAGE_INITPRESOLVE
1240  * - \ref SCIP_STAGE_PRESOLVING
1241  * - \ref SCIP_STAGE_EXITPRESOLVE
1242  * - \ref SCIP_STAGE_PRESOLVED
1243  * - \ref SCIP_STAGE_INITSOLVE
1244  * - \ref SCIP_STAGE_SOLVING
1245  * - \ref SCIP_STAGE_SOLVED
1246  * - \ref SCIP_STAGE_EXITSOLVE
1247  * - \ref SCIP_STAGE_FREETRANS
1248  *
1249  * @note the pointer of the variable will be NULLed
1250  */
1252  SCIP* scip, /**< SCIP data structure */
1253  SCIP_VAR** var /**< pointer to variable */
1254  )
1255 {
1256  assert(var != NULL);
1257  assert(*var != NULL);
1258  assert((*var)->scip == scip);
1259 
1260  SCIP_CALL( SCIPcheckStage(scip, "SCIPreleaseVar", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
1261 
1262  switch( scip->set->stage )
1263  {
1264  case SCIP_STAGE_PROBLEM:
1265  SCIP_CALL( SCIPvarRelease(var, scip->mem->probmem, scip->set, scip->eventqueue, scip->lp) );
1266  return SCIP_OKAY;
1267 
1271  case SCIP_STAGE_PRESOLVING:
1273  case SCIP_STAGE_PRESOLVED:
1274  case SCIP_STAGE_INITSOLVE:
1275  case SCIP_STAGE_SOLVING:
1276  case SCIP_STAGE_SOLVED:
1277  case SCIP_STAGE_EXITSOLVE:
1278  case SCIP_STAGE_FREETRANS:
1279  if( !SCIPvarIsTransformed(*var) && (*var)->nuses == 1 )
1280  {
1281  SCIPerrorMessage("cannot release last use of original variable while the transformed problem exists\n");
1282  return SCIP_INVALIDCALL;
1283  }
1284  SCIP_CALL( SCIPvarRelease(var, scip->mem->probmem, scip->set, scip->eventqueue, scip->lp) );
1285  return SCIP_OKAY;
1286 
1287  default:
1288  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
1289  return SCIP_INVALIDCALL;
1290  } /*lint !e788*/
1291 }
1292 
1293 /** changes the name of a variable
1294  *
1295  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1296  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1297  *
1298  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_PROBLEM
1299  *
1300  * @note to get the current name of a variable, use SCIPvarGetName() from pub_var.h
1301  */
1303  SCIP* scip, /**< SCIP data structure */
1304  SCIP_VAR* var, /**< variable */
1305  const char* name /**< new name of constraint */
1306  )
1307 {
1308  SCIP_CALL( SCIPcheckStage(scip, "SCIPchgVarName", FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
1309  assert( var->scip == scip );
1310 
1311  if( SCIPgetStage(scip) != SCIP_STAGE_PROBLEM )
1312  {
1313  SCIPerrorMessage("variable names can only be changed in problem creation stage\n");
1314  SCIPABORT();
1315  return SCIP_INVALIDCALL; /*lint !e527*/
1316  }
1317 
1318  /* remove variable's name from the namespace if the variable was already added */
1319  if( SCIPvarGetProbindex(var) != -1 )
1320  {
1321  SCIP_CALL( SCIPprobRemoveVarName(scip->origprob, var) );
1322  }
1323 
1324  /* change variable name */
1325  SCIP_CALL( SCIPvarChgName(var, SCIPblkmem(scip), name) );
1326 
1327  /* add variable's name to the namespace if the variable was already added */
1328  if( SCIPvarGetProbindex(var) != -1 )
1329  {
1330  SCIP_CALL( SCIPprobAddVarName(scip->origprob, var) );
1331  }
1332 
1333  return SCIP_OKAY;
1334 }
1335 
1336 /** gets and captures transformed variable of a given variable; if the variable is not yet transformed,
1337  * a new transformed variable for this variable is created
1338  *
1339  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1340  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1341  *
1342  * @pre This method can be called if @p scip is in one of the following stages:
1343  * - \ref SCIP_STAGE_TRANSFORMING
1344  * - \ref SCIP_STAGE_TRANSFORMED
1345  * - \ref SCIP_STAGE_INITPRESOLVE
1346  * - \ref SCIP_STAGE_PRESOLVING
1347  * - \ref SCIP_STAGE_EXITPRESOLVE
1348  * - \ref SCIP_STAGE_PRESOLVED
1349  * - \ref SCIP_STAGE_INITSOLVE
1350  * - \ref SCIP_STAGE_SOLVING
1351  */
1353  SCIP* scip, /**< SCIP data structure */
1354  SCIP_VAR* var, /**< variable to get/create transformed variable for */
1355  SCIP_VAR** transvar /**< pointer to store the transformed variable */
1356  )
1357 {
1358  assert(transvar != NULL);
1359 
1360  SCIP_CALL( SCIPcheckStage(scip, "SCIPtransformVar", FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1361 
1362  if( SCIPvarIsTransformed(var) )
1363  {
1364  *transvar = var;
1365  SCIPvarCapture(*transvar);
1366  }
1367  else
1368  {
1369  SCIP_CALL( SCIPvarTransform(var, scip->mem->probmem, scip->set, scip->stat, scip->origprob->objsense, transvar) );
1370  }
1371 
1372  return SCIP_OKAY;
1373 }
1374 
1375 /** gets and captures transformed variables for an array of variables;
1376  * if a variable of the array is not yet transformed, a new transformed variable for this variable is created;
1377  * it is possible to call this method with vars == transvars
1378  *
1379  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1380  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1381  *
1382  * @pre This method can be called if @p scip is in one of the following stages:
1383  * - \ref SCIP_STAGE_TRANSFORMING
1384  * - \ref SCIP_STAGE_TRANSFORMED
1385  * - \ref SCIP_STAGE_INITPRESOLVE
1386  * - \ref SCIP_STAGE_PRESOLVING
1387  * - \ref SCIP_STAGE_EXITPRESOLVE
1388  * - \ref SCIP_STAGE_PRESOLVED
1389  * - \ref SCIP_STAGE_INITSOLVE
1390  * - \ref SCIP_STAGE_SOLVING
1391  */
1393  SCIP* scip, /**< SCIP data structure */
1394  int nvars, /**< number of variables to get/create transformed variables for */
1395  SCIP_VAR** vars, /**< array with variables to get/create transformed variables for */
1396  SCIP_VAR** transvars /**< array to store the transformed variables */
1397  )
1398 {
1399  int v;
1400 
1401  assert(nvars == 0 || vars != NULL);
1402  assert(nvars == 0 || transvars != NULL);
1403 
1404  SCIP_CALL( SCIPcheckStage(scip, "SCIPtransformVars", FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1405 
1406  for( v = 0; v < nvars; ++v )
1407  {
1408  if( SCIPvarIsTransformed(vars[v]) )
1409  {
1410  transvars[v] = vars[v];
1411  SCIPvarCapture(transvars[v]);
1412  }
1413  else
1414  {
1415  SCIP_CALL( SCIPvarTransform(vars[v], scip->mem->probmem, scip->set, scip->stat, scip->origprob->objsense,
1416  &transvars[v]) );
1417  }
1418  }
1419 
1420  return SCIP_OKAY;
1421 }
1422 
1423 /** gets corresponding transformed variable of a given variable;
1424  * returns NULL as transvar, if transformed variable is not yet existing
1425  *
1426  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1427  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1428  *
1429  * @pre This method can be called if @p scip is in one of the following stages:
1430  * - \ref SCIP_STAGE_TRANSFORMING
1431  * - \ref SCIP_STAGE_TRANSFORMED
1432  * - \ref SCIP_STAGE_INITPRESOLVE
1433  * - \ref SCIP_STAGE_PRESOLVING
1434  * - \ref SCIP_STAGE_EXITPRESOLVE
1435  * - \ref SCIP_STAGE_PRESOLVED
1436  * - \ref SCIP_STAGE_INITSOLVE
1437  * - \ref SCIP_STAGE_SOLVING
1438  * - \ref SCIP_STAGE_SOLVED
1439  * - \ref SCIP_STAGE_EXITSOLVE
1440  * - \ref SCIP_STAGE_FREETRANS
1441  */
1443  SCIP* scip, /**< SCIP data structure */
1444  SCIP_VAR* var, /**< variable to get transformed variable for */
1445  SCIP_VAR** transvar /**< pointer to store the transformed variable */
1446  )
1447 {
1448  assert(transvar != NULL);
1449 
1450  SCIP_CALL( SCIPcheckStage(scip, "SCIPgetTransformedVar", FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
1451 
1452  if( SCIPvarIsTransformed(var) )
1453  *transvar = var;
1454  else
1455  {
1456  SCIP_CALL( SCIPvarGetTransformed(var, scip->mem->probmem, scip->set, scip->stat, transvar) );
1457  }
1458 
1459  return SCIP_OKAY;
1460 }
1461 
1462 /** gets corresponding transformed variables for an array of variables;
1463  * stores NULL in a transvars slot, if the transformed variable is not yet existing;
1464  * it is possible to call this method with vars == transvars, but remember that variables that are not
1465  * yet transformed will be replaced with NULL
1466  *
1467  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1468  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1469  *
1470  * @pre This method can be called if @p scip is in one of the following stages:
1471  * - \ref SCIP_STAGE_TRANSFORMING
1472  * - \ref SCIP_STAGE_TRANSFORMED
1473  * - \ref SCIP_STAGE_INITPRESOLVE
1474  * - \ref SCIP_STAGE_PRESOLVING
1475  * - \ref SCIP_STAGE_EXITPRESOLVE
1476  * - \ref SCIP_STAGE_PRESOLVED
1477  * - \ref SCIP_STAGE_INITSOLVE
1478  * - \ref SCIP_STAGE_SOLVING
1479  * - \ref SCIP_STAGE_SOLVED
1480  * - \ref SCIP_STAGE_EXITSOLVE
1481  * - \ref SCIP_STAGE_FREETRANS
1482  */
1484  SCIP* scip, /**< SCIP data structure */
1485  int nvars, /**< number of variables to get transformed variables for */
1486  SCIP_VAR** vars, /**< array with variables to get transformed variables for */
1487  SCIP_VAR** transvars /**< array to store the transformed variables */
1488  )
1489 {
1490  int v;
1491 
1492  assert(nvars == 0 || vars != NULL);
1493  assert(nvars == 0 || transvars != NULL);
1494 
1495  SCIP_CALL( SCIPcheckStage(scip, "SCIPgetTransformedVars", FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
1496 
1497  for( v = 0; v < nvars; ++v )
1498  {
1499  if( SCIPvarIsTransformed(vars[v]) )
1500  transvars[v] = vars[v];
1501  else
1502  {
1503  SCIP_CALL( SCIPvarGetTransformed(vars[v], scip->mem->probmem, scip->set, scip->stat, &transvars[v]) );
1504  }
1505  }
1506 
1507  return SCIP_OKAY;
1508 }
1509 
1510 /** gets negated variable x' = lb + ub - x of variable x; negated variable is created, if not yet existing;
1511  * in difference to \ref SCIPcreateVar, the negated variable must not be released (unless captured explicitly)
1512  *
1513  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1514  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1515  *
1516  * @pre This method can be called if @p scip is in one of the following stages:
1517  * - \ref SCIP_STAGE_PROBLEM
1518  * - \ref SCIP_STAGE_TRANSFORMING
1519  * - \ref SCIP_STAGE_TRANSFORMED
1520  * - \ref SCIP_STAGE_INITPRESOLVE
1521  * - \ref SCIP_STAGE_PRESOLVING
1522  * - \ref SCIP_STAGE_EXITPRESOLVE
1523  * - \ref SCIP_STAGE_PRESOLVED
1524  * - \ref SCIP_STAGE_INITSOLVE
1525  * - \ref SCIP_STAGE_SOLVING
1526  * - \ref SCIP_STAGE_SOLVED
1527  * - \ref SCIP_STAGE_EXITSOLVE
1528  * - \ref SCIP_STAGE_FREETRANS
1529  */
1531  SCIP* scip, /**< SCIP data structure */
1532  SCIP_VAR* var, /**< variable to get negated variable for */
1533  SCIP_VAR** negvar /**< pointer to store the negated variable */
1534  )
1535 {
1536  SCIP_CALL( SCIPcheckStage(scip, "SCIPgetNegatedVar", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
1537  assert( var->scip == scip );
1538 
1539  SCIP_CALL( SCIPvarNegate(var, scip->mem->probmem, scip->set, scip->stat, negvar) );
1540 
1541  return SCIP_OKAY;
1542 }
1543 
1544 /** gets negated variables x' = lb + ub - x of variables x; negated variables are created, if not yet existing
1545  *
1546  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1547  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1548  *
1549  * @pre This method can be called if @p scip is in one of the following stages:
1550  * - \ref SCIP_STAGE_PROBLEM
1551  * - \ref SCIP_STAGE_TRANSFORMING
1552  * - \ref SCIP_STAGE_TRANSFORMED
1553  * - \ref SCIP_STAGE_INITPRESOLVE
1554  * - \ref SCIP_STAGE_PRESOLVING
1555  * - \ref SCIP_STAGE_EXITPRESOLVE
1556  * - \ref SCIP_STAGE_PRESOLVED
1557  * - \ref SCIP_STAGE_INITSOLVE
1558  * - \ref SCIP_STAGE_SOLVING
1559  * - \ref SCIP_STAGE_SOLVED
1560  * - \ref SCIP_STAGE_EXITSOLVE
1561  * - \ref SCIP_STAGE_FREETRANS
1562  */
1564  SCIP* scip, /**< SCIP data structure */
1565  int nvars, /**< number of variables to get negated variables for */
1566  SCIP_VAR** vars, /**< array of variables to get negated variables for */
1567  SCIP_VAR** negvars /**< array to store the negated variables */
1568  )
1569 {
1570  int v;
1571 
1572  SCIP_CALL( SCIPcheckStage(scip, "SCIPgetNegatedVars", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
1573 
1574  for( v = 0; v < nvars; ++v )
1575  {
1576  SCIP_CALL( SCIPvarNegate(vars[v], scip->mem->probmem, scip->set, scip->stat, &(negvars[v])) );
1577  }
1578 
1579  return SCIP_OKAY;
1580 }
1581 
1582 /** gets a binary variable that is equal to the given binary variable, and that is either active, fixed, or
1583  * multi-aggregated, or the negated variable of an active, fixed, or multi-aggregated variable
1584  *
1585  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1586  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1587  *
1588  * @pre This method can be called if @p scip is in one of the following stages:
1589  * - \ref SCIP_STAGE_PROBLEM
1590  * - \ref SCIP_STAGE_TRANSFORMED
1591  * - \ref SCIP_STAGE_INITPRESOLVE
1592  * - \ref SCIP_STAGE_PRESOLVING
1593  * - \ref SCIP_STAGE_EXITPRESOLVE
1594  * - \ref SCIP_STAGE_PRESOLVED
1595  * - \ref SCIP_STAGE_INITSOLVE
1596  * - \ref SCIP_STAGE_SOLVING
1597  * - \ref SCIP_STAGE_SOLVED
1598  * - \ref SCIP_STAGE_EXITSOLVE
1599  */
1601  SCIP* scip, /**< SCIP data structure */
1602  SCIP_VAR* var, /**< binary variable to get binary representative for */
1603  SCIP_VAR** repvar, /**< pointer to store the binary representative */
1604  SCIP_Bool* negated /**< pointer to store whether the negation of an active variable was returned */
1605  )
1606 {
1607  assert(scip != NULL);
1608  assert(var != NULL);
1609  assert(repvar != NULL);
1610  assert(negated != NULL);
1611  assert(var->scip == scip);
1612 
1613  SCIP_CALL( SCIPcheckStage(scip, "SCIPgetBinvarRepresentative", FALSE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
1614 
1615  /* get the active representative of the given variable */
1616  *repvar = var;
1617  *negated = FALSE;
1618  SCIP_CALL( SCIPvarGetProbvarBinary(repvar, negated) );
1619 
1620  /* negate the representative, if it corresponds to the negation of the given variable */
1621  if( *negated )
1622  {
1623  SCIP_CALL( SCIPgetNegatedVar(scip, *repvar, repvar) );
1624  }
1625 
1626  return SCIP_OKAY;
1627 }
1628 
1629 /** gets binary variables that are equal to the given binary variables, and which are either active, fixed, or
1630  * multi-aggregated, or the negated variables of active, fixed, or multi-aggregated variables
1631  *
1632  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1633  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1634  *
1635  * @pre This method can be called if @p scip is in one of the following stages:
1636  * - \ref SCIP_STAGE_PROBLEM
1637  * - \ref SCIP_STAGE_TRANSFORMED
1638  * - \ref SCIP_STAGE_INITPRESOLVE
1639  * - \ref SCIP_STAGE_PRESOLVING
1640  * - \ref SCIP_STAGE_EXITPRESOLVE
1641  * - \ref SCIP_STAGE_PRESOLVED
1642  * - \ref SCIP_STAGE_INITSOLVE
1643  * - \ref SCIP_STAGE_SOLVING
1644  * - \ref SCIP_STAGE_SOLVED
1645  * - \ref SCIP_STAGE_EXITSOLVE
1646  */
1648  SCIP* scip, /**< SCIP data structure */
1649  int nvars, /**< number of binary variables to get representatives for */
1650  SCIP_VAR** vars, /**< binary variables to get binary representatives for */
1651  SCIP_VAR** repvars, /**< array to store the binary representatives */
1652  SCIP_Bool* negated /**< array to store whether the negation of an active variable was returned */
1653  )
1654 {
1655  int v;
1656 
1657  assert(scip != NULL);
1658  assert(vars != NULL || nvars == 0);
1659  assert(repvars != NULL || nvars == 0);
1660  assert(negated != NULL || nvars == 0);
1661 
1662  SCIP_CALL( SCIPcheckStage(scip, "SCIPgetBinvarRepresentatives", FALSE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
1663 
1664  if( nvars == 0 )
1665  return SCIP_OKAY;
1666 
1667  /* get the active representative of the given variable */
1668  BMScopyMemoryArray(repvars, vars, nvars);
1669  BMSclearMemoryArray(negated, nvars);
1670  SCIP_CALL( SCIPvarsGetProbvarBinary(&repvars, &negated, nvars) );
1671 
1672  /* negate the representatives, if they correspond to the negation of the given variables */
1673  for( v = nvars - 1; v >= 0; --v )
1674  if( negated[v] )
1675  {
1676  SCIP_CALL( SCIPgetNegatedVar(scip, repvars[v], &(repvars[v])) );
1677  }
1678 
1679  return SCIP_OKAY;
1680 }
1681 
1682 /** flattens aggregation graph of multi-aggregated variable in order to avoid exponential recursion later on
1683  *
1684  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1685  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1686  *
1687  * @pre This method can be called if @p scip is in one of the following stages:
1688  * - \ref SCIP_STAGE_INITPRESOLVE
1689  * - \ref SCIP_STAGE_PRESOLVING
1690  * - \ref SCIP_STAGE_EXITPRESOLVE
1691  * - \ref SCIP_STAGE_PRESOLVED
1692  * - \ref SCIP_STAGE_INITSOLVE
1693  * - \ref SCIP_STAGE_SOLVING
1694  * - \ref SCIP_STAGE_SOLVED
1695  */
1697  SCIP* scip, /**< SCIP data structure */
1698  SCIP_VAR* var /**< problem variable */
1699  )
1700 {
1701  assert( scip != NULL );
1702  assert( var != NULL );
1703  SCIP_CALL( SCIPcheckStage(scip, "SCIPflattenVarAggregationGraph", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1704 
1705  SCIP_CALL( SCIPvarFlattenAggregationGraph(var, scip->mem->probmem, scip->set) );
1706  return SCIP_OKAY;
1707 }
1708 
1709 /** Transforms a given linear sum of variables, that is a_1*x_1 + ... + a_n*x_n + c into a corresponding linear sum of
1710  * active variables, that is b_1*y_1 + ... + b_m*y_m + d.
1711  *
1712  * If the number of needed active variables is greater than the available slots in the variable array, nothing happens
1713  * except that the required size is stored in the corresponding variable (requiredsize). Otherwise, the active variable
1714  * representation is stored in the variable array, scalar array and constant.
1715  *
1716  * The reason for this approach is that we cannot reallocate memory, since we do not know how the memory has been
1717  * allocated (e.g., by a C++ 'new' or SCIP functions).
1718  *
1719  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1720  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1721  *
1722  * @pre This method can be called if @p scip is in one of the following stages:
1723  * - \ref SCIP_STAGE_TRANSFORMED
1724  * - \ref SCIP_STAGE_INITPRESOLVE
1725  * - \ref SCIP_STAGE_PRESOLVING
1726  * - \ref SCIP_STAGE_EXITPRESOLVE
1727  * - \ref SCIP_STAGE_PRESOLVED
1728  * - \ref SCIP_STAGE_INITSOLVE
1729  * - \ref SCIP_STAGE_SOLVING
1730  * - \ref SCIP_STAGE_SOLVED
1731  * - \ref SCIP_STAGE_EXITSOLVE
1732  * - \ref SCIP_STAGE_FREETRANS
1733  *
1734  * @note The resulting linear sum is stored into the given variable array, scalar array, and constant. That means the
1735  * given entries are overwritten.
1736  *
1737  * @note That method can be used to convert a single variables into variable space of active variables. Therefore call
1738  * the method with the linear sum 1.0*x + 0.0.
1739  */
1741  SCIP* scip, /**< SCIP data structure */
1742  SCIP_VAR** vars, /**< variable array x_1, ..., x_n in the linear sum which will be
1743  * overwritten by the variable array y_1, ..., y_m in the linear sum
1744  * w.r.t. active variables */
1745  SCIP_Real* scalars, /**< scalars a_1, ..., a_n in linear sum which will be overwritten to the
1746  * scalars b_1, ..., b_m in the linear sum of the active variables */
1747  int* nvars, /**< pointer to number of variables in the linear sum which will be
1748  * overwritten by the number of variables in the linear sum corresponding
1749  * to the active variables */
1750  int varssize, /**< available slots in vars and scalars array which is needed to check if
1751  * the array are large enough for the linear sum w.r.t. active
1752  * variables */
1753  SCIP_Real* constant, /**< pointer to constant c in linear sum a_1*x_1 + ... + a_n*x_n + c which
1754  * will chnage to constant d in the linear sum b_1*y_1 + ... + b_m*y_m +
1755  * d w.r.t. the active variables */
1756  int* requiredsize, /**< pointer to store the required array size for the linear sum w.r.t. the
1757  * active variables */
1758  SCIP_Bool mergemultiples /**< should multiple occurrences of a var be replaced by a single coeff? */
1759  )
1760 {
1761  assert( scip != NULL );
1762  assert( nvars != NULL );
1763  assert( vars != NULL || *nvars == 0 );
1764  assert( scalars != NULL || *nvars == 0 );
1765  assert( constant != NULL );
1766  assert( requiredsize != NULL );
1767  assert( *nvars <= varssize );
1768 
1769  SCIP_CALL( SCIPcheckStage(scip, "SCIPgetProbvarLinearSum", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
1770  SCIP_CALL( SCIPvarGetActiveRepresentatives(scip->set, vars, scalars, nvars, varssize, constant, requiredsize, mergemultiples) );
1771 
1772  return SCIP_OKAY;
1773 }
1774 
1775 /** transforms given variable, scalar and constant to the corresponding active, fixed, or
1776  * multi-aggregated variable, scalar and constant; if the variable resolves to a fixed variable,
1777  * "scalar" will be 0.0 and the value of the sum will be stored in "constant"; a multi-aggregation
1778  * with only one active variable (this can happen due to fixings after the multi-aggregation),
1779  * is treated like an aggregation; if the multi-aggregation constant is infinite, "scalar" will be 0.0
1780  *
1781  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1782  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1783  *
1784  * @pre This method can be called if @p scip is in one of the following stages:
1785  * - \ref SCIP_STAGE_TRANSFORMED
1786  * - \ref SCIP_STAGE_INITPRESOLVE
1787  * - \ref SCIP_STAGE_PRESOLVING
1788  * - \ref SCIP_STAGE_EXITPRESOLVE
1789  * - \ref SCIP_STAGE_PRESOLVED
1790  * - \ref SCIP_STAGE_INITSOLVE
1791  * - \ref SCIP_STAGE_SOLVING
1792  * - \ref SCIP_STAGE_SOLVED
1793  * - \ref SCIP_STAGE_EXITSOLVE
1794  * - \ref SCIP_STAGE_FREETRANS
1795  */
1797  SCIP* scip, /**< SCIP data structure */
1798  SCIP_VAR** var, /**< pointer to problem variable x in sum a*x + c */
1799  SCIP_Real* scalar, /**< pointer to scalar a in sum a*x + c */
1800  SCIP_Real* constant /**< pointer to constant c in sum a*x + c */
1801  )
1802 {
1803  assert(scip != NULL);
1804  assert(var != NULL);
1805  assert(scalar != NULL);
1806  assert(constant != NULL);
1807 
1808  SCIP_CALL( SCIPcheckStage(scip, "SCIPgetProbvarSum", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
1809  SCIP_CALL( SCIPvarGetProbvarSum(var, scip->set, scalar, constant) );
1810 
1811  return SCIP_OKAY;
1812 }
1813 
1814 /** return for given variables all their active counterparts; all active variables will be pairwise different
1815  * @note It does not hold that the first output variable is the active variable for the first input variable.
1816  *
1817  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1818  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1819  *
1820  * @pre This method can be called if @p scip is in one of the following stages:
1821  * - \ref SCIP_STAGE_TRANSFORMED
1822  * - \ref SCIP_STAGE_INITPRESOLVE
1823  * - \ref SCIP_STAGE_PRESOLVING
1824  * - \ref SCIP_STAGE_EXITPRESOLVE
1825  * - \ref SCIP_STAGE_PRESOLVED
1826  * - \ref SCIP_STAGE_INITSOLVE
1827  * - \ref SCIP_STAGE_SOLVING
1828  * - \ref SCIP_STAGE_SOLVED
1829  * - \ref SCIP_STAGE_EXITSOLVE
1830  * - \ref SCIP_STAGE_FREETRANS
1831  */
1833  SCIP* scip, /**< SCIP data structure */
1834  SCIP_VAR** vars, /**< variable array with given variables and as output all active
1835  * variables, if enough slots exist
1836  */
1837  int* nvars, /**< number of given variables, and as output number of active variables,
1838  * if enough slots exist
1839  */
1840  int varssize, /**< available slots in vars array */
1841  int* requiredsize /**< pointer to store the required array size for the active variables */
1842  )
1843 {
1844  assert(scip != NULL);
1845  assert(nvars != NULL);
1846  assert(vars != NULL || *nvars == 0);
1847  assert(varssize >= *nvars);
1848  assert(requiredsize != NULL);
1849 
1850  SCIP_CALL( SCIPcheckStage(scip, "SCIPgetActiveVars", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
1851  SCIP_CALL( SCIPvarsGetActiveVars(scip->set, vars, nvars, varssize, requiredsize) );
1852 
1853  return SCIP_OKAY;
1854 }
1855 
1856 /** returns the reduced costs of the variable in the current node's LP relaxation;
1857  * the current node has to have a feasible LP.
1858  *
1859  * returns SCIP_INVALID if the variable is active but not in the current LP;
1860  * returns 0 if the variable has been aggregated out or fixed in presolving.
1861  *
1862  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
1863  *
1864  * @note The return value of this method should be used carefully if the dual feasibility check was explictely disabled.
1865  */
1867  SCIP* scip, /**< SCIP data structure */
1868  SCIP_VAR* var /**< variable to get reduced costs, should be a column in current node LP */
1869  )
1870 {
1871  assert( scip != NULL );
1872  assert( var != NULL );
1873  assert( var->scip == scip );
1874 
1875  switch( SCIPvarGetStatus(var) )
1876  {
1878  if( var->data.original.transvar == NULL )
1879  return SCIP_INVALID;
1880  return SCIPgetVarRedcost(scip, var->data.original.transvar);
1881 
1882  case SCIP_VARSTATUS_COLUMN:
1883  return SCIPgetColRedcost(scip, SCIPvarGetCol(var));
1884 
1885  case SCIP_VARSTATUS_LOOSE:
1886  return SCIP_INVALID;
1887 
1888  case SCIP_VARSTATUS_FIXED:
1892  return 0.0;
1893 
1894  default:
1895  SCIPerrorMessage("unknown variable status\n");
1896  SCIPABORT();
1897  return 0.0; /*lint !e527*/
1898  }
1899 }
1900 
1901 /** returns the implied reduced costs of the variable in the current node's LP relaxation;
1902  * the current node has to have a feasible LP.
1903  *
1904  * returns SCIP_INVALID if the variable is active but not in the current LP;
1905  * returns 0 if the variable has been aggregated out or fixed in presolving.
1906  *
1907  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
1908  *
1909  * @note The return value of this method should be used carefully if the dual feasibility check was explictely disabled.
1910  */
1912  SCIP* scip, /**< SCIP data structure */
1913  SCIP_VAR* var, /**< variable to get reduced costs, should be a column in current node LP */
1914  SCIP_Bool varfixing /**< FALSE if for x == 0, TRUE for x == 1 */
1915  )
1916 {
1917  assert( scip != NULL );
1918  assert( var != NULL );
1919  assert( var->scip == scip );
1920 
1921  switch( SCIPvarGetStatus(var) )
1922  {
1924  if( var->data.original.transvar == NULL )
1925  return SCIP_INVALID;
1926  return SCIPgetVarImplRedcost(scip, var->data.original.transvar, varfixing);
1927 
1928  case SCIP_VARSTATUS_COLUMN:
1929  return SCIPvarGetImplRedcost(var, scip->set, varfixing, scip->stat, scip->transprob, scip->lp);
1930 
1931  case SCIP_VARSTATUS_LOOSE:
1932  return SCIP_INVALID;
1933 
1934  case SCIP_VARSTATUS_FIXED:
1938  return 0.0;
1939 
1940  default:
1941  SCIPerrorMessage("unknown variable status\n");
1942  SCIPABORT();
1943  return 0.0; /*lint !e527*/
1944  }
1945 }
1946 
1947 
1948 /** returns the Farkas coefficient of the variable in the current node's LP relaxation;
1949  * the current node has to have an infeasible LP.
1950  *
1951  * returns SCIP_INVALID if the variable is active but not in the current LP;
1952  * returns 0 if the variable has been aggregated out or fixed in presolving.
1953  *
1954  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
1955  */
1957  SCIP* scip, /**< SCIP data structure */
1958  SCIP_VAR* var /**< variable to get reduced costs, should be a column in current node LP */
1959  )
1960 {
1961  assert(scip != NULL);
1962  assert(var != NULL);
1963  assert(var->scip == scip);
1964 
1965  switch( SCIPvarGetStatus(var) )
1966  {
1968  if( var->data.original.transvar == NULL )
1969  return SCIP_INVALID;
1970  return SCIPgetVarFarkasCoef(scip,var->data.original.transvar);
1971 
1972  case SCIP_VARSTATUS_COLUMN:
1973  return SCIPgetColFarkasCoef(scip,SCIPvarGetCol(var));
1974 
1975  case SCIP_VARSTATUS_LOOSE:
1976  return SCIP_INVALID;
1977 
1978  case SCIP_VARSTATUS_FIXED:
1982  return 0.0;
1983 
1984  default:
1985  SCIPerrorMessage("unknown variable status\n");
1986  SCIPABORT();
1987  return 0.0; /*lint !e527*/
1988  }
1989 }
1990 
1991 /** returns lower bound of variable directly before or after the bound change given by the bound change index
1992  * was applied
1993  */
1995  SCIP* scip, /**< SCIP data structure */
1996  SCIP_VAR* var, /**< problem variable */
1997  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
1998  SCIP_Bool after /**< should the bound change with given index be included? */
1999  )
2000 {
2001  SCIP_VARSTATUS varstatus;
2002  SCIP_BDCHGINFO* bdchginfo;
2003  assert(var != NULL);
2004 
2005  varstatus = SCIPvarGetStatus(var);
2006 
2007  /* get bounds of attached variables */
2008  switch( varstatus )
2009  {
2011  assert(var->data.original.transvar != NULL);
2012  return SCIPgetVarLbAtIndex(scip, var->data.original.transvar, bdchgidx, after);
2013 
2014  case SCIP_VARSTATUS_COLUMN:
2015  case SCIP_VARSTATUS_LOOSE:
2016  if( bdchgidx == NULL )
2017  return SCIPvarGetLbLocal(var);
2018  else
2019  {
2020  bdchginfo = SCIPvarGetLbchgInfo(var, bdchgidx, after);
2021  if( bdchginfo != NULL )
2022  return SCIPbdchginfoGetNewbound(bdchginfo);
2023  else
2024  return var->glbdom.lb;
2025  }
2026 
2027  case SCIP_VARSTATUS_FIXED:
2028  return var->glbdom.lb;
2029 
2030  case SCIP_VARSTATUS_AGGREGATED: /* x = a*y + c -> y = (x-c)/a */
2031  assert(var->data.aggregate.var != NULL);
2032  if( var->data.aggregate.scalar > 0.0 )
2033  {
2034  SCIP_Real lb;
2035 
2036  lb = SCIPgetVarLbAtIndex(scip, var->data.aggregate.var, bdchgidx, after);
2037 
2038  /* a > 0 -> get lower bound of y */
2039  if( SCIPisInfinity(scip, -lb) )
2040  return -SCIPinfinity(scip);
2041  else if( SCIPisInfinity(scip, lb) )
2042  return SCIPinfinity(scip);
2043  else
2044  return var->data.aggregate.scalar * lb + var->data.aggregate.constant;
2045  }
2046  else if( var->data.aggregate.scalar < 0.0 )
2047  {
2048  SCIP_Real ub;
2049 
2050  ub = SCIPgetVarUbAtIndex(scip, var->data.aggregate.var, bdchgidx, after);
2051 
2052  /* a < 0 -> get upper bound of y */
2053  if( SCIPisInfinity(scip, -ub) )
2054  return SCIPinfinity(scip);
2055  else if( SCIPisInfinity(scip, ub) )
2056  return -SCIPinfinity(scip);
2057  else
2058  return var->data.aggregate.scalar * ub + var->data.aggregate.constant;
2059  }
2060  else
2061  {
2062  SCIPerrorMessage("scalar is zero in aggregation\n");
2063  SCIPABORT();
2064  return SCIP_INVALID; /*lint !e527*/
2065  }
2066 
2068  /* handle multi-aggregated variables depending on one variable only (possibly caused by SCIPvarFlattenAggregationGraph()) */
2069  if ( var->data.multaggr.nvars == 1 )
2070  {
2071  assert(var->data.multaggr.vars != NULL);
2072  assert(var->data.multaggr.scalars != NULL);
2073  assert(var->data.multaggr.vars[0] != NULL);
2074 
2075  if( var->data.multaggr.scalars[0] > 0.0 )
2076  {
2077  SCIP_Real lb;
2078 
2079  lb = SCIPgetVarLbAtIndex(scip, var->data.multaggr.vars[0], bdchgidx, after);
2080 
2081  /* a > 0 -> get lower bound of y */
2082  if( SCIPisInfinity(scip, -lb) )
2083  return -SCIPinfinity(scip);
2084  else if( SCIPisInfinity(scip, lb) )
2085  return SCIPinfinity(scip);
2086  else
2087  return var->data.multaggr.scalars[0] * lb + var->data.multaggr.constant;
2088  }
2089  else if( var->data.multaggr.scalars[0] < 0.0 )
2090  {
2091  SCIP_Real ub;
2092 
2093  ub = SCIPgetVarUbAtIndex(scip, var->data.multaggr.vars[0], bdchgidx, after);
2094 
2095  /* a < 0 -> get upper bound of y */
2096  if( SCIPisInfinity(scip, -ub) )
2097  return SCIPinfinity(scip);
2098  else if( SCIPisInfinity(scip, ub) )
2099  return -SCIPinfinity(scip);
2100  else
2101  return var->data.multaggr.scalars[0] * ub + var->data.multaggr.constant;
2102  }
2103  else
2104  {
2105  SCIPerrorMessage("scalar is zero in multi-aggregation\n");
2106  SCIPABORT();
2107  return SCIP_INVALID; /*lint !e527*/
2108  }
2109  }
2110  SCIPerrorMessage("cannot get the bounds of a multi-aggregated variable.\n");
2111  SCIPABORT();
2112  return SCIP_INVALID; /*lint !e527*/
2113 
2114  case SCIP_VARSTATUS_NEGATED: /* x' = offset - x -> x = offset - x' */
2115  assert(var->negatedvar != NULL);
2117  assert(var->negatedvar->negatedvar == var);
2118  return var->data.negate.constant - SCIPgetVarUbAtIndex(scip, var->negatedvar, bdchgidx, after);
2119 
2120  default:
2121  SCIPerrorMessage("unknown variable status\n");
2122  SCIPABORT();
2123  return SCIP_INVALID; /*lint !e527*/
2124  }
2125 }
2126 
2127 /** returns upper bound of variable directly before or after the bound change given by the bound change index
2128  * was applied
2129  */
2131  SCIP* scip, /**< SCIP data structure */
2132  SCIP_VAR* var, /**< problem variable */
2133  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
2134  SCIP_Bool after /**< should the bound change with given index be included? */
2135  )
2136 {
2137  SCIP_VARSTATUS varstatus;
2138  SCIP_BDCHGINFO* bdchginfo;
2139  assert(var != NULL);
2140 
2141  varstatus = SCIPvarGetStatus(var);
2142 
2143  /* get bounds of attached variables */
2144  switch( varstatus )
2145  {
2147  assert(var->data.original.transvar != NULL);
2148  return SCIPgetVarUbAtIndex(scip, var->data.original.transvar, bdchgidx, after);
2149 
2150  case SCIP_VARSTATUS_COLUMN:
2151  case SCIP_VARSTATUS_LOOSE:
2152  if( bdchgidx == NULL )
2153  return SCIPvarGetUbLocal(var);
2154  else
2155  {
2156  bdchginfo = SCIPvarGetUbchgInfo(var, bdchgidx, after);
2157  if( bdchginfo != NULL )
2158  return SCIPbdchginfoGetNewbound(bdchginfo);
2159  else
2160  return var->glbdom.ub;
2161  }
2162 
2163  case SCIP_VARSTATUS_FIXED:
2164  return var->glbdom.ub;
2165 
2166  case SCIP_VARSTATUS_AGGREGATED: /* x = a*y + c -> y = (x-c)/a */
2167  assert(var->data.aggregate.var != NULL);
2168  if( var->data.aggregate.scalar > 0.0 )
2169  {
2170  SCIP_Real ub;
2171 
2172  ub = SCIPgetVarUbAtIndex(scip, var->data.aggregate.var, bdchgidx, after);
2173 
2174  /* a > 0 -> get lower bound of y */
2175  if( SCIPisInfinity(scip, -ub) )
2176  return -SCIPinfinity(scip);
2177  else if( SCIPisInfinity(scip, ub) )
2178  return SCIPinfinity(scip);
2179  else
2180  return var->data.aggregate.scalar * ub + var->data.aggregate.constant;
2181  }
2182  else if( var->data.aggregate.scalar < 0.0 )
2183  {
2184  SCIP_Real lb;
2185 
2186  lb = SCIPgetVarLbAtIndex(scip, var->data.aggregate.var, bdchgidx, after);
2187 
2188  /* a < 0 -> get upper bound of y */
2189  if ( SCIPisInfinity(scip, -lb) )
2190  return SCIPinfinity(scip);
2191  else if ( SCIPisInfinity(scip, lb) )
2192  return -SCIPinfinity(scip);
2193  else
2194  return var->data.aggregate.scalar * lb + var->data.aggregate.constant;
2195  }
2196  else
2197  {
2198  SCIPerrorMessage("scalar is zero in aggregation\n");
2199  SCIPABORT();
2200  return SCIP_INVALID; /*lint !e527*/
2201  }
2202 
2204  /* handle multi-aggregated variables depending on one variable only (possibly caused by SCIPvarFlattenAggregationGraph()) */
2205  if ( var->data.multaggr.nvars == 1 )
2206  {
2207  assert(var->data.multaggr.vars != NULL);
2208  assert(var->data.multaggr.scalars != NULL);
2209  assert(var->data.multaggr.vars[0] != NULL);
2210 
2211  if( var->data.multaggr.scalars[0] > 0.0 )
2212  {
2213  SCIP_Real ub;
2214 
2215  ub = SCIPgetVarUbAtIndex(scip, var->data.multaggr.vars[0], bdchgidx, after);
2216 
2217  /* a > 0 -> get lower bound of y */
2218  if ( SCIPisInfinity(scip, -ub) )
2219  return -SCIPinfinity(scip);
2220  else if ( SCIPisInfinity(scip, ub) )
2221  return SCIPinfinity(scip);
2222  else
2223  return var->data.multaggr.scalars[0] * ub + var->data.multaggr.constant;
2224  }
2225  else if( var->data.multaggr.scalars[0] < 0.0 )
2226  {
2227  SCIP_Real lb;
2228 
2229  lb = SCIPgetVarLbAtIndex(scip, var->data.multaggr.vars[0], bdchgidx, after);
2230 
2231  /* a < 0 -> get upper bound of y */
2232  if ( SCIPisInfinity(scip, -lb) )
2233  return SCIPinfinity(scip);
2234  else if ( SCIPisInfinity(scip, lb) )
2235  return -SCIPinfinity(scip);
2236  else
2237  return var->data.multaggr.scalars[0] * lb + var->data.multaggr.constant;
2238  }
2239  else
2240  {
2241  SCIPerrorMessage("scalar is zero in multi-aggregation\n");
2242  SCIPABORT();
2243  return SCIP_INVALID; /*lint !e527*/
2244  }
2245  }
2246  SCIPerrorMessage("cannot get the bounds of a multiple aggregated variable.\n");
2247  SCIPABORT();
2248  return SCIP_INVALID; /*lint !e527*/
2249 
2250  case SCIP_VARSTATUS_NEGATED: /* x' = offset - x -> x = offset - x' */
2251  assert(var->negatedvar != NULL);
2253  assert(var->negatedvar->negatedvar == var);
2254  return var->data.negate.constant - SCIPgetVarLbAtIndex(scip, var->negatedvar, bdchgidx, after);
2255 
2256  default:
2257  SCIPerrorMessage("unknown variable status\n");
2258  SCIPABORT();
2259  return SCIP_INVALID; /*lint !e527*/
2260  }
2261 }
2262 
2263 /** returns lower or upper bound of variable directly before or after the bound change given by the bound change index
2264  * was applied
2265  */
2267  SCIP* scip, /**< SCIP data structure */
2268  SCIP_VAR* var, /**< problem variable */
2269  SCIP_BOUNDTYPE boundtype, /**< type of bound: lower or upper bound */
2270  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
2271  SCIP_Bool after /**< should the bound change with given index be included? */
2272  )
2273 {
2274  if( boundtype == SCIP_BOUNDTYPE_LOWER )
2275  return SCIPgetVarLbAtIndex(scip, var, bdchgidx, after);
2276  else
2277  {
2278  assert(boundtype == SCIP_BOUNDTYPE_UPPER);
2279  return SCIPgetVarUbAtIndex(scip, var, bdchgidx, after);
2280  }
2281 }
2282 
2283 /** returns whether the binary variable was fixed at the time given by the bound change index */
2285  SCIP* scip, /**< SCIP data structure */
2286  SCIP_VAR* var, /**< problem variable */
2287  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
2288  SCIP_Bool after /**< should the bound change with given index be included? */
2289  )
2290 {
2291  assert(var != NULL);
2292  assert(SCIPvarIsBinary(var));
2293 
2294  /* check the current bounds first in order to decide at which bound change information we have to look
2295  * (which is expensive because we have to follow the aggregation tree to the active variable)
2296  */
2297  return ((SCIPvarGetLbLocal(var) > 0.5 && SCIPgetVarLbAtIndex(scip, var, bdchgidx, after) > 0.5)
2298  || (SCIPvarGetUbLocal(var) < 0.5 && SCIPgetVarUbAtIndex(scip, var, bdchgidx, after) < 0.5));
2299 }
2300 
2301 /** gets solution value for variable in current node
2302  *
2303  * @return solution value for variable in current node
2304  *
2305  * @pre This method can be called if @p scip is in one of the following stages:
2306  * - \ref SCIP_STAGE_PRESOLVED
2307  * - \ref SCIP_STAGE_SOLVING
2308  */
2310  SCIP* scip, /**< SCIP data structure */
2311  SCIP_VAR* var /**< variable to get solution value for */
2312  )
2313 {
2315  assert( var->scip == scip );
2316 
2317  return SCIPvarGetSol(var, SCIPtreeHasCurrentNodeLP(scip->tree));
2318 }
2319 
2320 /** gets solution values of multiple variables in current node
2321  *
2322  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2323  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2324  *
2325  * @pre This method can be called if @p scip is in one of the following stages:
2326  * - \ref SCIP_STAGE_PRESOLVED
2327  * - \ref SCIP_STAGE_SOLVING
2328  */
2330  SCIP* scip, /**< SCIP data structure */
2331  int nvars, /**< number of variables to get solution value for */
2332  SCIP_VAR** vars, /**< array with variables to get value for */
2333  SCIP_Real* vals /**< array to store solution values of variables */
2334  )
2335 {
2336  int v;
2337 
2338  assert(nvars == 0 || vars != NULL);
2339  assert(nvars == 0 || vals != NULL);
2340 
2341  SCIP_CALL( SCIPcheckStage(scip, "SCIPgetVarSols", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2342 
2343  if( SCIPtreeHasCurrentNodeLP(scip->tree) )
2344  {
2345  for( v = 0; v < nvars; ++v )
2346  vals[v] = SCIPvarGetLPSol(vars[v]);
2347  }
2348  else
2349  {
2350  for( v = 0; v < nvars; ++v )
2351  vals[v] = SCIPvarGetPseudoSol(vars[v]);
2352  }
2353 
2354  return SCIP_OKAY;
2355 }
2356 
2357 /** sets the solution value of all variables in the global relaxation solution to zero
2358  *
2359  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2360  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2361  *
2362  * @pre This method can be called if @p scip is in one of the following stages:
2363  * - \ref SCIP_STAGE_PRESOLVED
2364  * - \ref SCIP_STAGE_SOLVING
2365  */
2367  SCIP* scip /**< SCIP data structure */
2368  )
2369 {
2370  SCIP_VAR** vars;
2371  int nvars;
2372  int v;
2373 
2374  assert(scip != NULL);
2375 
2376  SCIP_CALL( SCIPcheckStage(scip, "SCIPclearRelaxSolVals", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2377 
2378  /* the relaxation solution is already cleared */
2379  if( SCIPrelaxationIsSolZero(scip->relaxation) )
2380  return SCIP_OKAY;
2381 
2382  SCIP_CALL( SCIPgetVarsData(scip, &vars, &nvars, NULL, NULL, NULL, NULL) );
2383 
2384  for( v = 0; v < nvars; v++ )
2385  {
2386  SCIP_CALL( SCIPvarSetRelaxSol(vars[v], scip->set, scip->relaxation, 0.0, FALSE) );
2387  }
2388 
2389  SCIPrelaxationSetSolObj(scip->relaxation, 0.0);
2391 
2392  return SCIP_OKAY;
2393 }
2394 
2395 /** sets the value of the given variable in the global relaxation solution;
2396  * this solution can be filled by the relaxation handlers and can be used by heuristics and for separation;
2397  * You can use SCIPclearRelaxSolVals() to set all values to zero, initially;
2398  * after setting all solution values, you have to call SCIPmarkRelaxSolValid()
2399  * to inform SCIP that the stored solution is valid
2400  *
2401  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2402  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2403  *
2404  * @pre This method can be called if @p scip is in one of the following stages:
2405  * - \ref SCIP_STAGE_PRESOLVED
2406  * - \ref SCIP_STAGE_SOLVING
2407  *
2408  * @note This method incrementally updates the objective value of the relaxation solution. If the whole solution
2409  * should be updated, using SCIPsetRelaxSolVals() instead or calling SCIPclearRelaxSolVals() before setting
2410  * the first value to reset the solution and the objective value to 0 may help the numerics.
2411  */
2413  SCIP* scip, /**< SCIP data structure */
2414  SCIP_VAR* var, /**< variable to set value for */
2415  SCIP_Real val /**< solution value of variable */
2416  )
2417 {
2418  assert(scip != NULL);
2419 
2420  SCIP_CALL( SCIPcheckStage(scip, "SCIPsetRelaxSolVal", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2421 
2422  SCIP_CALL( SCIPvarSetRelaxSol(var, scip->set, scip->relaxation, val, TRUE) );
2423 
2424  if( val != 0.0 )
2427 
2428  return SCIP_OKAY;
2429 }
2430 
2431 /** sets the values of the given variables in the global relaxation solution and informs SCIP about the validity
2432  * and whether the solution can be enforced via linear cuts;
2433  * this solution can be filled by the relaxation handlers and can be used by heuristics and for separation;
2434  * the solution is automatically cleared, s.t. all other variables get value 0.0
2435  *
2436  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2437  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2438  *
2439  * @pre This method can be called if @p scip is in one of the following stages:
2440  * - \ref SCIP_STAGE_PRESOLVED
2441  * - \ref SCIP_STAGE_SOLVING
2442  */
2444  SCIP* scip, /**< SCIP data structure */
2445  int nvars, /**< number of variables to set relaxation solution value for */
2446  SCIP_VAR** vars, /**< array with variables to set value for */
2447  SCIP_Real* vals, /**< array with solution values of variables */
2448  SCIP_Bool includeslp /**< does the relaxator contain all cuts in the LP? */
2449  )
2450 {
2451  int v;
2452 
2453  assert(scip != NULL);
2454  assert(nvars == 0 || vars != NULL);
2455  assert(nvars == 0 || vals != NULL);
2456 
2457  SCIP_CALL( SCIPcheckStage(scip, "SCIPsetRelaxSolVals", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2458 
2460 
2461  for( v = 0; v < nvars; v++ )
2462  {
2463  SCIP_CALL( SCIPvarSetRelaxSol(vars[v], scip->set, scip->relaxation, vals[v], TRUE) );
2464  }
2465 
2467  SCIPrelaxationSetSolValid(scip->relaxation, TRUE, includeslp);
2468 
2469  return SCIP_OKAY;
2470 }
2471 
2472 /** sets the values of the variables in the global relaxation solution to the values in the given primal solution
2473  * and informs SCIP about the validity and whether the solution can be enforced via linear cuts;
2474  * the relaxation solution can be filled by the relaxation handlers and might be used by heuristics and for separation
2475  *
2476  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2477  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2478  *
2479  * @pre This method can be called if @p scip is in one of the following stages:
2480  * - \ref SCIP_STAGE_PRESOLVED
2481  * - \ref SCIP_STAGE_SOLVING
2482  */
2484  SCIP* scip, /**< SCIP data structure */
2485  SCIP_SOL* sol, /**< primal relaxation solution */
2486  SCIP_Bool includeslp /**< does the relaxator contain all cuts in the LP? */
2487  )
2488 {
2489  SCIP_VAR** vars;
2490  SCIP_Real* vals;
2491  int nvars;
2492  int v;
2493 
2494  assert(scip != NULL);
2495 
2496  SCIP_CALL( SCIPcheckStage(scip, "SCIPsetRelaxSolValsSol", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2497 
2498  SCIP_CALL( SCIPgetVarsData(scip, &vars, &nvars, NULL, NULL, NULL, NULL) );
2499 
2500  /* alloc buffer array for solution values of the variables and get the values */
2501  SCIP_CALL( SCIPallocBufferArray(scip, &vals, nvars) );
2502  SCIP_CALL( SCIPgetSolVals(scip, sol, nvars, vars, vals) );
2503 
2505 
2506  for( v = 0; v < nvars; v++ )
2507  {
2508  SCIP_CALL( SCIPvarSetRelaxSol(vars[v], scip->set, scip->relaxation, vals[v], FALSE) );
2509  }
2510 
2511  SCIPrelaxationSetSolObj(scip->relaxation, SCIPsolGetObj(sol, scip->set, scip->transprob, scip->origprob));
2512 
2514  SCIPrelaxationSetSolValid(scip->relaxation, TRUE, includeslp);
2515 
2516  SCIPfreeBufferArray(scip, &vals);
2517 
2518  return SCIP_OKAY;
2519 }
2520 
2521 /** returns whether the relaxation solution is valid
2522  *
2523  * @return TRUE, if the relaxation solution is valid; FALSE, otherwise
2524  *
2525  * @pre This method can be called if @p scip is in one of the following stages:
2526  * - \ref SCIP_STAGE_PRESOLVED
2527  * - \ref SCIP_STAGE_SOLVING
2528  */
2530  SCIP* scip /**< SCIP data structure */
2531  )
2532 {
2533  assert(scip != NULL);
2534 
2535  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPisRelaxSolValid", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2536 
2537  return SCIPrelaxationIsSolValid(scip->relaxation);
2538 }
2539 
2540 /** informs SCIP that the relaxation solution is valid and whether the relaxation can be enforced through linear cuts
2541  *
2542  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2543  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2544  *
2545  * @pre This method can be called if @p scip is in one of the following stages:
2546  * - \ref SCIP_STAGE_PRESOLVED
2547  * - \ref SCIP_STAGE_SOLVING
2548  */
2550  SCIP* scip, /**< SCIP data structure */
2551  SCIP_Bool includeslp /**< does the relaxator contain all cuts in the LP? */
2552  )
2553 {
2554  assert(scip != NULL);
2555 
2556  SCIP_CALL( SCIPcheckStage(scip, "SCIPmarkRelaxSolValid", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2557 
2558  SCIPrelaxationSetSolValid(scip->relaxation, TRUE, includeslp);
2559 
2560  return SCIP_OKAY;
2561 }
2562 
2563 /** informs SCIP, that the relaxation solution is invalid
2564  *
2565  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2566  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2567  *
2568  * @pre This method can be called if @p scip is in one of the following stages:
2569  * - \ref SCIP_STAGE_PRESOLVED
2570  * - \ref SCIP_STAGE_SOLVING
2571  */
2573  SCIP* scip /**< SCIP data structure */
2574  )
2575 {
2576  assert(scip != NULL);
2577 
2578  SCIP_CALL( SCIPcheckStage(scip, "SCIPmarkRelaxSolInvalid", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2579 
2581 
2582  return SCIP_OKAY;
2583 }
2584 
2585 /** gets the relaxation solution value of the given variable
2586  *
2587  * @return the relaxation solution value of the given variable
2588  *
2589  * @pre This method can be called if @p scip is in one of the following stages:
2590  * - \ref SCIP_STAGE_PRESOLVED
2591  * - \ref SCIP_STAGE_SOLVING
2592  */
2594  SCIP* scip, /**< SCIP data structure */
2595  SCIP_VAR* var /**< variable to get value for */
2596  )
2597 {
2598  assert(scip != NULL);
2599  assert(var != NULL);
2600  assert(var->scip == scip);
2601 
2602  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetRelaxSolVal", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2603 
2604  if( !SCIPrelaxationIsSolValid(scip->relaxation) )
2605  {
2606  SCIPerrorMessage("Relaxation Solution is not valid!\n");
2607  SCIPABORT();
2608  return SCIP_INVALID; /*lint !e527*/
2609  }
2610 
2611  return SCIPvarGetRelaxSol(var, scip->set);
2612 }
2613 
2614 /** gets the relaxation solution objective value
2615  *
2616  * @return the objective value of the relaxation solution
2617  *
2618  * @pre This method can be called if @p scip is in one of the following stages:
2619  * - \ref SCIP_STAGE_PRESOLVED
2620  * - \ref SCIP_STAGE_SOLVING
2621  */
2623  SCIP* scip /**< SCIP data structure */
2624  )
2625 {
2626  assert(scip != NULL);
2627 
2628  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetRelaxSolObj", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2629 
2630  if( !SCIPrelaxationIsSolValid(scip->relaxation) )
2631  {
2632  SCIPerrorMessage("Relaxation Solution is not valid!\n");
2633  SCIPABORT();
2634  return SCIP_INVALID; /*lint !e527*/
2635  }
2636 
2637  return SCIPrelaxationGetSolObj(scip->relaxation);
2638 }
2639 
2640 /** determine which branching direction should be evaluated first by strong branching
2641  *
2642  * @return TRUE iff strong branching should first evaluate the down child
2643  *
2644  */
2646  SCIP* scip, /**< SCIP data structure */
2647  SCIP_VAR* var /**< variable to determine the branching direction on */
2648  )
2649 {
2650  switch( scip->set->branch_firstsbchild )
2651  {
2652  case 'u':
2653  return FALSE;
2654  case 'd':
2655  return TRUE;
2656  case 'a':
2657  return (SCIPvarGetNLocksDown(var) > SCIPvarGetNLocksUp(var));
2658  default:
2659  assert(scip->set->branch_firstsbchild == 'h');
2661  }
2662 }
2663 
2664 /** start strong branching - call before any strong branching
2665  *
2666  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2667  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2668  *
2669  * @pre This method can be called if @p scip is in one of the following stages:
2670  * - \ref SCIP_STAGE_PRESOLVED
2671  * - \ref SCIP_STAGE_SOLVING
2672  *
2673  * @note if propagation is enabled, strong branching is not done directly on the LP, but probing nodes are created
2674  * which allow to perform propagation but also creates some overhead
2675  */
2677  SCIP* scip, /**< SCIP data structure */
2678  SCIP_Bool enablepropagation /**< should propagation be done before solving the strong branching LP? */
2679  )
2680 {
2681  assert( scip != NULL );
2682  SCIP_CALL( SCIPcheckStage(scip, "SCIPstartStrongbranch", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2683 
2684  assert(!SCIPinProbing(scip));
2685 
2686  SCIPdebugMsg(scip, "starting strong branching mode%s: lpcount=%" SCIP_LONGINT_FORMAT "\n", enablepropagation ? " with propagation" : "", scip->stat->lpcount - scip->stat->nsbdivinglps);
2687 
2688  /* start probing mode to allow propagation before solving the strong branching LPs; if no propagation should be done,
2689  * start the strong branching mode in the LP interface
2690  */
2691  if( enablepropagation )
2692  {
2693  if( SCIPtreeProbing(scip->tree) )
2694  {
2695  SCIPerrorMessage("cannot start strong branching with propagation while in probing mode\n");
2696  return SCIP_INVALIDCALL;
2697  }
2698 
2699  if( scip->lp != NULL && SCIPlpDiving(scip->lp) )
2700  {
2701  SCIPerrorMessage("cannot start strong branching with propagation while in diving mode\n");
2702  return SCIP_INVALIDCALL;
2703  }
2704 
2705  /* other then in SCIPstartProbing(), we do not disable collecting variable statistics during strong branching;
2706  * we cannot disable it, because the pseudo costs would not be updated, otherwise,
2707  * and reliability branching would end up doing strong branching all the time
2708  */
2709  SCIP_CALL( SCIPtreeStartProbing(scip->tree, scip->mem->probmem, scip->set, scip->lp, scip->relaxation, scip->transprob, TRUE) );
2710 
2711  /* inform the LP that the current probing mode is used for strong branching */
2713  }
2714  else
2715  {
2717  }
2718 
2719  /* reset local strong branching info */
2721 
2722  return SCIP_OKAY;
2723 }
2724 
2725 /** end strong branching - call after any strong branching
2726  *
2727  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2728  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2729  *
2730  * @pre This method can be called if @p scip is in one of the following stages:
2731  * - \ref SCIP_STAGE_PRESOLVED
2732  * - \ref SCIP_STAGE_SOLVING
2733  */
2735  SCIP* scip /**< SCIP data structure */
2736  )
2737 {
2738  assert( scip != NULL );
2739 
2740  SCIP_CALL( SCIPcheckStage(scip, "SCIPendStrongbranch", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2741 
2742  /* depending on whether the strong branching mode was started with propagation enabled or not, we end the strong
2743  * branching probing mode or the LP strong branching mode
2744  */
2745  if( SCIPtreeProbing(scip->tree) )
2746  {
2747  SCIP_NODE* node;
2748  SCIP_DOMCHG* domchg;
2749  SCIP_VAR** boundchgvars;
2750  SCIP_Real* bounds;
2751  SCIP_BOUNDTYPE* boundtypes;
2752  int nboundchgs;
2753  int nbnds;
2754  int i;
2755 
2756  /* collect all bound changes deducted during probing, which were applied at the probing root and apply them to the
2757  * focusnode
2758  */
2759  node = SCIPgetCurrentNode(scip);
2760  assert(SCIPnodeGetType(node) == SCIP_NODETYPE_PROBINGNODE);
2761  assert(SCIPgetProbingDepth(scip) == 0);
2762 
2763  domchg = SCIPnodeGetDomchg(node);
2764  nboundchgs = SCIPdomchgGetNBoundchgs(domchg);
2765 
2766  SCIP_CALL( SCIPallocBufferArray(scip, &boundchgvars, nboundchgs) );
2767  SCIP_CALL( SCIPallocBufferArray(scip, &bounds, nboundchgs) );
2768  SCIP_CALL( SCIPallocBufferArray(scip, &boundtypes, nboundchgs) );
2769 
2770  for( i = 0, nbnds = 0; i < nboundchgs; ++i )
2771  {
2772  SCIP_BOUNDCHG* boundchg;
2773 
2774  boundchg = SCIPdomchgGetBoundchg(domchg, i);
2775 
2776  /* ignore redundant bound changes */
2777  if( SCIPboundchgIsRedundant(boundchg) )
2778  continue;
2779 
2780  boundchgvars[nbnds] = SCIPboundchgGetVar(boundchg);
2781  bounds[nbnds] = SCIPboundchgGetNewbound(boundchg);
2782  boundtypes[nbnds] = SCIPboundchgGetBoundtype(boundchg);
2783  ++nbnds;
2784  }
2785 
2786  SCIPdebugMsg(scip, "ending strong branching with probing: %d bound changes collected\n", nbnds);
2787 
2788  /* inform the LP that the probing mode is not used for strong branching anymore */
2790 
2791  /* switch back from probing to normal operation mode and restore variables and constraints to focus node */
2792  SCIP_CALL( SCIPtreeEndProbing(scip->tree, scip->reopt, scip->mem->probmem, scip->set, scip->messagehdlr, scip->stat,
2793  scip->transprob, scip->origprob, scip->lp, scip->relaxation, scip->primal,
2794  scip->branchcand, scip->eventqueue, scip->eventfilter, scip->cliquetable) );
2795 
2796  /* apply the collected bound changes */
2797  for( i = 0; i < nbnds; ++i )
2798  {
2799  if( boundtypes[i] == SCIP_BOUNDTYPE_LOWER )
2800  {
2801  SCIPdebugMsg(scip, "apply probing lower bound change <%s> >= %.9g\n", SCIPvarGetName(boundchgvars[i]), bounds[i]);
2802  SCIP_CALL( SCIPchgVarLb(scip, boundchgvars[i], bounds[i]) );
2803  }
2804  else
2805  {
2806  SCIPdebugMsg(scip, "apply probing upper bound change <%s> <= %.9g\n", SCIPvarGetName(boundchgvars[i]), bounds[i]);
2807  SCIP_CALL( SCIPchgVarUb(scip, boundchgvars[i], bounds[i]) );
2808  }
2809  }
2810 
2811  SCIPfreeBufferArray(scip, &boundtypes);
2812  SCIPfreeBufferArray(scip, &bounds);
2813  SCIPfreeBufferArray(scip, &boundchgvars);
2814  }
2815  else
2816  {
2817  SCIPdebugMsg(scip, "ending strong branching\n");
2818 
2820  }
2821 
2822  return SCIP_OKAY;
2823 }
2824 
2825 /** analyze the strong branching for the given variable; that includes conflict analysis for infeasible branches and
2826  * storing of root reduced cost information
2827  */
2828 static
2830  SCIP* scip, /**< SCIP data structure */
2831  SCIP_VAR* var, /**< variable to analyze */
2832  SCIP_Bool* downinf, /**< pointer to store whether the downwards branch is infeasible, or NULL */
2833  SCIP_Bool* upinf, /**< pointer to store whether the upwards branch is infeasible, or NULL */
2834  SCIP_Bool* downconflict, /**< pointer to store whether a conflict constraint was created for an
2835  * infeasible downwards branch, or NULL */
2836  SCIP_Bool* upconflict /**< pointer to store whether a conflict constraint was created for an
2837  * infeasible upwards branch, or NULL */
2838  )
2839 {
2840  SCIP_COL* col;
2841  SCIP_Bool downcutoff;
2842  SCIP_Bool upcutoff;
2843 
2844  col = SCIPvarGetCol(var);
2845  assert(col != NULL);
2846 
2847  downcutoff = col->sbdownvalid && SCIPsetIsGE(scip->set, col->sbdown, scip->lp->cutoffbound);
2848  upcutoff = col->sbupvalid && SCIPsetIsGE(scip->set, col->sbup, scip->lp->cutoffbound);
2849 
2850  if( downinf != NULL )
2851  *downinf = downcutoff;
2852  if( upinf != NULL )
2853  *upinf = upcutoff;
2854 
2855  /* analyze infeasible strong branching sub problems:
2856  * because the strong branching's bound change is necessary for infeasibility, it cannot be undone;
2857  * therefore, infeasible strong branchings on non-binary variables will not produce a valid conflict constraint
2858  */
2859  if( scip->set->conf_enable && scip->set->conf_usesb && scip->set->nconflicthdlrs > 0
2860  && SCIPvarIsBinary(var) && SCIPtreeGetCurrentDepth(scip->tree) > 0 )
2861  {
2862  if( (downcutoff && SCIPsetFeasCeil(scip->set, col->primsol-1.0) >= col->lb - 0.5)
2863  || (upcutoff && SCIPsetFeasFloor(scip->set, col->primsol+1.0) <= col->ub + 0.5) )
2864  {
2865  assert(downconflict != NULL);
2866  assert(upconflict != NULL);
2867  SCIP_CALL( SCIPconflictAnalyzeStrongbranch(scip->conflict, scip->conflictstore, scip->mem->probmem, scip->set, scip->stat,
2868  scip->transprob, scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable, col, downconflict, upconflict) );
2869  }
2870  }
2871 
2872  /* the strong branching results can be used to strengthen the root reduced cost information which is used for example
2873  * to propagate against the cutoff bound
2874  *
2875  * @note Ignore the results if the LP solution of the down (up) branch LP is smaller which should not happened by
2876  * theory but can arise due to numerical issues.
2877  */
2878  if( SCIPtreeGetCurrentDepth(scip->tree) == 0 && SCIPvarIsBinary(var) && SCIPlpIsDualReliable(scip->lp) )
2879  {
2880  SCIP_Real lpobjval;
2881 
2882  assert(SCIPgetLPSolstat(scip) == SCIP_LPSOLSTAT_OPTIMAL);
2883 
2884  lpobjval = SCIPlpGetObjval(scip->lp, scip->set, scip->transprob);
2885 
2886  if( col->sbdownvalid && SCIPsetFeasCeil(scip->set, col->primsol-1.0) >= col->lb - 0.5 && lpobjval < col->sbdown )
2887  SCIPvarUpdateBestRootSol(var, scip->set, SCIPvarGetUbGlobal(var), -(col->sbdown - lpobjval), lpobjval);
2888  if( col->sbupvalid && SCIPsetFeasFloor(scip->set, col->primsol+1.0) <= col->ub + 0.5 && lpobjval < col->sbup )
2889  SCIPvarUpdateBestRootSol(var, scip->set, SCIPvarGetLbGlobal(var), col->sbup - lpobjval, lpobjval);
2890  }
2891 
2892  return SCIP_OKAY;
2893 }
2894 
2895 /** gets strong branching information on column variable with fractional value
2896  *
2897  * Before calling this method, the strong branching mode must have been activated by calling SCIPstartStrongbranch();
2898  * after strong branching was done for all candidate variables, the strong branching mode must be ended by
2899  * SCIPendStrongbranch(). Since this method does not apply domain propagation before strongbranching,
2900  * propagation should not be enabled in the SCIPstartStrongbranch() call.
2901  *
2902  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2903  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2904  *
2905  * @pre This method can be called if @p scip is in one of the following stages:
2906  * - \ref SCIP_STAGE_PRESOLVED
2907  * - \ref SCIP_STAGE_SOLVING
2908  */
2910  SCIP* scip, /**< SCIP data structure */
2911  SCIP_VAR* var, /**< variable to get strong branching values for */
2912  int itlim, /**< iteration limit for strong branchings */
2913  SCIP_Real* down, /**< stores dual bound after branching column down */
2914  SCIP_Real* up, /**< stores dual bound after branching column up */
2915  SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL;
2916  * otherwise, it can only be used as an estimate value */
2917  SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound, or NULL;
2918  * otherwise, it can only be used as an estimate value */
2919  SCIP_Bool* downinf, /**< pointer to store whether the downwards branch is infeasible, or NULL */
2920  SCIP_Bool* upinf, /**< pointer to store whether the upwards branch is infeasible, or NULL */
2921  SCIP_Bool* downconflict, /**< pointer to store whether a conflict constraint was created for an
2922  * infeasible downwards branch, or NULL */
2923  SCIP_Bool* upconflict, /**< pointer to store whether a conflict constraint was created for an
2924  * infeasible upwards branch, or NULL */
2925  SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred or the
2926  * solving process should be stopped (e.g., due to a time limit) */
2927  )
2928 {
2929  SCIP_COL* col;
2930 
2931  assert(scip != NULL);
2932  assert(var != NULL);
2933  assert(lperror != NULL);
2934  assert(!SCIPtreeProbing(scip->tree)); /* we should not be in strong branching with propagation mode */
2935  assert(var->scip == scip);
2936 
2937  SCIP_CALL( SCIPcheckStage(scip, "SCIPgetVarStrongbranchFrac", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2938 
2939  if( downvalid != NULL )
2940  *downvalid = FALSE;
2941  if( upvalid != NULL )
2942  *upvalid = FALSE;
2943  if( downinf != NULL )
2944  *downinf = FALSE;
2945  if( upinf != NULL )
2946  *upinf = FALSE;
2947  if( downconflict != NULL )
2948  *downconflict = FALSE;
2949  if( upconflict != NULL )
2950  *upconflict = FALSE;
2951 
2953  {
2954  SCIPerrorMessage("cannot get strong branching information on non-COLUMN variable <%s>\n", SCIPvarGetName(var));
2955  return SCIP_INVALIDDATA;
2956  }
2957 
2958  col = SCIPvarGetCol(var);
2959  assert(col != NULL);
2960 
2961  if( !SCIPcolIsInLP(col) )
2962  {
2963  SCIPerrorMessage("cannot get strong branching information on variable <%s> not in current LP\n", SCIPvarGetName(var));
2964  return SCIP_INVALIDDATA;
2965  }
2966 
2967  /* check if the solving process should be aborted */
2968  if( SCIPsolveIsStopped(scip->set, scip->stat, FALSE) )
2969  {
2970  /* mark this as if the LP failed */
2971  *lperror = TRUE;
2972  return SCIP_OKAY;
2973  }
2974 
2975  /* call strong branching for column with fractional value */
2976  SCIP_CALL( SCIPcolGetStrongbranch(col, FALSE, scip->set, scip->stat, scip->transprob, scip->lp, itlim,
2977  down, up, downvalid, upvalid, lperror) );
2978 
2979  /* check, if the branchings are infeasible; in exact solving mode, we cannot trust the strong branching enough to
2980  * declare the sub nodes infeasible
2981  */
2982  if( !(*lperror) && SCIPprobAllColsInLP(scip->transprob, scip->set, scip->lp) && !scip->set->misc_exactsolve )
2983  {
2984  SCIP_CALL( analyzeStrongbranch(scip, var, downinf, upinf, downconflict, upconflict) );
2985  }
2986 
2987  return SCIP_OKAY;
2988 }
2989 
2990 /** create, solve, and evaluate a single strong branching child (for strong branching with propagation) */
2991 static
2993  SCIP* scip, /**< SCIP data structure */
2994  SCIP_VAR* var, /**< variable to get strong branching values for */
2995  SCIP_Bool down, /**< do we regard the down child? */
2996  SCIP_Bool firstchild, /**< is this the first of the two strong branching children? */
2997  SCIP_Bool propagate, /**< should domain propagation be performed? */
2998  SCIP_Real newbound, /**< new bound to apply at the strong branching child */
2999  int itlim, /**< iteration limit for strong branchings */
3000  int maxproprounds, /**< maximum number of propagation rounds (-1: no limit, -2: parameter
3001  * settings) */
3002  SCIP_Real* value, /**< stores dual bound for strong branching child */
3003  SCIP_Bool* valid, /**< stores whether the returned value is a valid dual bound, or NULL;
3004  * otherwise, it can only be used as an estimate value */
3005  SCIP_Longint* ndomreductions, /**< pointer to store the number of domain reductions found, or NULL */
3006  SCIP_Bool* conflict, /**< pointer to store whether a conflict constraint was created for an
3007  * infeasible strong branching child, or NULL */
3008  SCIP_Bool* lperror, /**< pointer to store whether an unresolved LP error occurred or the
3009  * solving process should be stopped (e.g., due to a time limit) */
3010  SCIP_VAR** vars, /**< active problem variables */
3011  int nvars, /**< number of active problem variables */
3012  SCIP_Real* newlbs, /**< array to store valid lower bounds for all active variables, or NULL */
3013  SCIP_Real* newubs, /**< array to store valid upper bounds for all active variables, or NULL */
3014  SCIP_Bool* foundsol, /**< pointer to store whether a primal solution was found during strong branching */
3015  SCIP_Bool* cutoff /**< pointer to store whether the strong branching child is infeasible */
3016  )
3017 {
3018  SCIP_Longint ndomreds;
3019 
3020  assert(value != NULL);
3021  assert(foundsol != NULL);
3022  assert(cutoff != NULL);
3023  assert(valid != NULL ? !(*valid) : TRUE);
3024 
3025  *foundsol = FALSE;
3026  *cutoff = FALSE;
3027 
3028  /* check whether the strong branching child is already infeasible due to the bound change */
3029  if( down )
3030  {
3031  /* the down branch is infeasible due to the branching bound change; since this means that solval is not within the
3032  * bounds, this should only happen if previous strong branching calls on other variables detected bound changes which
3033  * are valid for and were already applied at the probing root
3034  */
3035  if( newbound < SCIPvarGetLbLocal(var) - 0.5 )
3036  {
3037  *value = SCIPinfinity(scip);
3038 
3039  if( valid != NULL )
3040  *valid = TRUE;
3041 
3042  /* bound changes are applied in SCIPendStrongbranch(), which can be seen as a conflict constraint */
3043  if( conflict != NULL )
3044  *conflict = TRUE;
3045 
3046  *cutoff = TRUE;
3047 
3048  return SCIP_OKAY;
3049  }
3050  }
3051  else
3052  {
3053  /* the up branch is infeasible due to the branching bound change; since this means that solval is not within the
3054  * bounds, this should only happen if previous strong branching calls on other variables detected bound changes which
3055  * are valid for and were already applied at the probing root
3056  */
3057  if( newbound > SCIPvarGetUbLocal(var) + 0.5 )
3058  {
3059  *value = SCIPinfinity(scip);
3060 
3061  if( valid != NULL )
3062  *valid = TRUE;
3063 
3064  /* bound changes are applied in SCIPendStrongbranch(), which can be seen as a conflict constraint */
3065  if( conflict != NULL )
3066  *conflict = TRUE;
3067 
3068  *cutoff = TRUE;
3069 
3070  return SCIP_OKAY;
3071  }
3072  }
3073 
3074  /* we need to ensure that we can create at least one new probing node without exceeding the maximal tree depth */
3076  {
3077  /* create a new probing node for the strong branching child and apply the new bound for the variable */
3078  SCIP_CALL( SCIPnewProbingNode(scip) );
3079 
3080  if( down )
3081  {
3082  assert(SCIPisGE(scip, newbound, SCIPvarGetLbLocal(var)));
3083  if( SCIPisLT(scip, newbound, SCIPvarGetUbLocal(var)) )
3084  {
3085  SCIP_CALL( SCIPchgVarUbProbing(scip, var, newbound) );
3086  }
3087  }
3088  else
3089  {
3090  assert(SCIPisLE(scip, newbound, SCIPvarGetUbLocal(var)));
3091  if( SCIPisGT(scip, newbound, SCIPvarGetLbLocal(var)) )
3092  {
3093  SCIP_CALL( SCIPchgVarLbProbing(scip, var, newbound) );
3094  }
3095  }
3096  }
3097  else
3098  {
3099  if( valid != NULL )
3100  *valid = FALSE;
3101 
3102  if( cutoff != NULL ) /*lint !e774*/
3103  *cutoff = FALSE;
3104 
3105  if( conflict != NULL )
3106  *conflict = FALSE;
3107 
3108  return SCIP_OKAY;
3109  }
3110 
3111  /* propagate domains at the probing node */
3112  if( propagate )
3113  {
3114  /* start time measuring */
3115  SCIPclockStart(scip->stat->strongpropclock, scip->set);
3116 
3117  ndomreds = 0;
3118  SCIP_CALL( SCIPpropagateProbing(scip, maxproprounds, cutoff, &ndomreds) );
3119 
3120  /* store number of domain reductions in strong branching */
3121  if( down )
3122  SCIPstatAdd(scip->stat, scip->set, nsbdowndomchgs, ndomreds);
3123  else
3124  SCIPstatAdd(scip->stat, scip->set, nsbupdomchgs, ndomreds);
3125 
3126  if( ndomreductions != NULL )
3127  *ndomreductions = ndomreds;
3128 
3129  /* stop time measuring */
3130  SCIPclockStop(scip->stat->strongpropclock, scip->set);
3131 
3132  if( *cutoff )
3133  {
3134  *value = SCIPinfinity(scip);
3135 
3136  if( valid != NULL )
3137  *valid = TRUE;
3138 
3139  SCIPdebugMsg(scip, "%s branch of var <%s> detected infeasible during propagation\n",
3140  down ? "down" : "up", SCIPvarGetName(var));
3141  }
3142  }
3143 
3144  /* if propagation did not already detect infeasibility, solve the probing LP */
3145  if( !(*cutoff) )
3146  {
3147  SCIP_CALL( SCIPsolveProbingLP(scip, itlim, lperror, cutoff) );
3148  assert(SCIPisLPRelax(scip));
3149 
3150  if( *cutoff )
3151  {
3152  assert(!(*lperror));
3153 
3154  *value = SCIPinfinity(scip);
3155 
3156  if( valid != NULL )
3157  *valid = TRUE;
3158 
3159  SCIPdebugMsg(scip, "%s branch of var <%s> detected infeasible in LP solving: status=%d\n",
3160  down ? "down" : "up", SCIPvarGetName(var), SCIPgetLPSolstat(scip));
3161  }
3162  else if( !(*lperror) )
3163  {
3164  /* save the lp solution status */
3165  scip->stat->lastsblpsolstats[down ? 0 : 1] = SCIPgetLPSolstat(scip);
3166 
3167  switch( SCIPgetLPSolstat(scip) )
3168  {
3170  {
3171  *value = SCIPgetLPObjval(scip);
3172  assert(SCIPisLT(scip, *value, SCIPgetCutoffbound(scip)));
3173 
3174  SCIPdebugMsg(scip, "probing LP solved to optimality, objective value: %16.9g\n", *value);
3175 
3176  if( valid != NULL )
3177  *valid = TRUE;
3178 
3179  /* check the strong branching LP solution for feasibility */
3180  SCIP_CALL( SCIPtryStrongbranchLPSol(scip, foundsol, cutoff) );
3181  break;
3182  }
3184  ++scip->stat->nsbtimesiterlimhit;
3185  /*lint -fallthrough*/
3187  {
3188  /* use LP value as estimate */
3189  SCIP_LPI* lpi;
3190  SCIP_Real objval;
3191  SCIP_Real looseobjval;
3192 
3193  SCIPdebugMsg(scip, "probing LP hit %s limit\n", SCIPgetLPSolstat(scip) == SCIP_LPSOLSTAT_ITERLIMIT ? "iteration" : "time");
3194 
3195  /* we access the LPI directly, because when a time limit was hit, we cannot access objective value and dual
3196  * feasibility using the SCIPlp... methods; we should try to avoid direct calls to the LPI, but this is rather
3197  * uncritical here, because we are immediately after the SCIPsolveProbingLP() call, because we access the LPI
3198  * read-only, and we check SCIPlpiWasSolved() first
3199  */
3200  SCIP_CALL( SCIPgetLPI(scip, &lpi) );
3201 
3202  if( SCIPlpiWasSolved(lpi) )
3203  {
3204  SCIP_CALL( SCIPlpiGetObjval(lpi, &objval) );
3205  looseobjval = SCIPlpGetLooseObjval(scip->lp, scip->set, scip->transprob);
3206 
3207  /* the infinity value in the LPI should not be smaller than SCIP's infinity value */
3208  assert(!SCIPlpiIsInfinity(lpi, objval) || SCIPisInfinity(scip, objval));
3209 
3210  /* we use SCIP's infinity value here because a value larger than this is counted as infeasible by SCIP */
3211  if( SCIPisInfinity(scip, objval) )
3212  *value = SCIPinfinity(scip);
3213  else if( SCIPisInfinity(scip, -looseobjval) )
3214  *value = -SCIPinfinity(scip);
3215  else
3216  *value = objval + looseobjval;
3217 
3218  if( SCIPlpiIsDualFeasible(lpi) )
3219  {
3220  if( valid != NULL )
3221  *valid = TRUE;
3222 
3223  if( SCIPisGE(scip, *value, SCIPgetCutoffbound(scip)) )
3224  *cutoff = TRUE;
3225  }
3226  }
3227  break;
3228  }
3229  case SCIP_LPSOLSTAT_ERROR:
3231  *lperror = TRUE;
3232  break;
3233  case SCIP_LPSOLSTAT_NOTSOLVED: /* should only be the case for *cutoff = TRUE or *lperror = TRUE */
3234  case SCIP_LPSOLSTAT_OBJLIMIT: /* in this case, *cutoff should be TRUE and we should not get here */
3235  case SCIP_LPSOLSTAT_INFEASIBLE: /* in this case, *cutoff should be TRUE and we should not get here */
3236  default:
3237  SCIPerrorMessage("invalid LP solution status <%d>\n", SCIPgetLPSolstat(scip));
3238  return SCIP_INVALIDDATA;
3239  } /*lint !e788*/
3240  }
3241 
3242  /* If columns are missing in the LP, the cutoff flag may be wrong. Therefore, we need to set it and the valid pointer
3243  * to false here.
3244  */
3245  if( (*cutoff) && !SCIPallColsInLP(scip) )
3246  {
3247  *cutoff = FALSE;
3248  }
3249 
3250 #ifndef NDEBUG
3251  if( *lperror )
3252  {
3253  SCIPdebugMsg(scip, "error during strong branching probing LP solving: status=%d\n", SCIPgetLPSolstat(scip));
3254  }
3255 #endif
3256  }
3257 
3258  /* if the subproblem was feasible, we store the local bounds of the variables after propagation and (possibly)
3259  * conflict analysis
3260  * @todo do this after propagation? should be able to get valid bounds more often, but they might be weaker
3261  */
3262  if( !(*cutoff) && newlbs != NULL)
3263  {
3264  int v;
3265 
3266  assert(newubs != NULL);
3267 
3268  /* initialize the newlbs and newubs to the current local bounds */
3269  if( firstchild )
3270  {
3271  for( v = 0; v < nvars; ++v )
3272  {
3273  newlbs[v] = SCIPvarGetLbLocal(vars[v]);
3274  newubs[v] = SCIPvarGetUbLocal(vars[v]);
3275  }
3276  }
3277  /* update newlbs and newubs: take the weaker of the already stored bounds and the current local bounds */
3278  else
3279  {
3280  for( v = 0; v < nvars; ++v )
3281  {
3282  SCIP_Real lb = SCIPvarGetLbLocal(vars[v]);
3283  SCIP_Real ub = SCIPvarGetUbLocal(vars[v]);
3284 
3285  newlbs[v] = MIN(newlbs[v], lb);
3286  newubs[v] = MAX(newubs[v], ub);
3287  }
3288  }
3289  }
3290 
3291  /* revert all changes at the probing node */
3292  SCIP_CALL( SCIPbacktrackProbing(scip, 0) );
3293 
3294  return SCIP_OKAY;
3295 }
3296 
3297 /** gets strong branching information with previous domain propagation on column variable
3298  *
3299  * Before calling this method, the strong branching mode must have been activated by calling SCIPstartStrongbranch();
3300  * after strong branching was done for all candidate variables, the strong branching mode must be ended by
3301  * SCIPendStrongbranch(). Since this method applies domain propagation before strongbranching, propagation has to be be
3302  * enabled in the SCIPstartStrongbranch() call.
3303  *
3304  * Before solving the strong branching LP, domain propagation can be performed. The number of propagation rounds
3305  * can be specified by the parameter @p maxproprounds.
3306  *
3307  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3308  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3309  *
3310  * @pre This method can be called if @p scip is in one of the following stages:
3311  * - \ref SCIP_STAGE_PRESOLVED
3312  * - \ref SCIP_STAGE_SOLVING
3313  *
3314  * @warning When using this method, LP banching candidates and solution values must be copied beforehand, because
3315  * they are updated w.r.t. the strong branching LP solution.
3316  */
3318  SCIP* scip, /**< SCIP data structure */
3319  SCIP_VAR* var, /**< variable to get strong branching values for */
3320  SCIP_Real solval, /**< value of the variable in the current LP solution */
3321  SCIP_Real lpobjval, /**< LP objective value of the current LP solution */
3322  int itlim, /**< iteration limit for strong branchings */
3323  int maxproprounds, /**< maximum number of propagation rounds (-1: no limit, -2: parameter
3324  * settings) */
3325  SCIP_Real* down, /**< stores dual bound after branching column down */
3326  SCIP_Real* up, /**< stores dual bound after branching column up */
3327  SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL;
3328  * otherwise, it can only be used as an estimate value */
3329  SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound, or NULL;
3330  * otherwise, it can only be used as an estimate value */
3331  SCIP_Longint* ndomredsdown, /**< pointer to store the number of domain reductions down, or NULL */
3332  SCIP_Longint* ndomredsup, /**< pointer to store the number of domain reductions up, or NULL */
3333  SCIP_Bool* downinf, /**< pointer to store whether the downwards branch is infeasible, or NULL */
3334  SCIP_Bool* upinf, /**< pointer to store whether the upwards branch is infeasible, or NULL */
3335  SCIP_Bool* downconflict, /**< pointer to store whether a conflict constraint was created for an
3336  * infeasible downwards branch, or NULL */
3337  SCIP_Bool* upconflict, /**< pointer to store whether a conflict constraint was created for an
3338  * infeasible upwards branch, or NULL */
3339  SCIP_Bool* lperror, /**< pointer to store whether an unresolved LP error occurred or the
3340  * solving process should be stopped (e.g., due to a time limit) */
3341  SCIP_Real* newlbs, /**< array to store valid lower bounds for all active variables, or NULL */
3342  SCIP_Real* newubs /**< array to store valid upper bounds for all active variables, or NULL */
3343  )
3344 {
3345  SCIP_COL* col;
3346  SCIP_VAR** vars;
3347  SCIP_Longint oldniters;
3348  SCIP_Real newub;
3349  SCIP_Real newlb;
3350  SCIP_Bool propagate;
3351  SCIP_Bool cutoff;
3352  SCIP_Bool downchild;
3353  SCIP_Bool firstchild;
3354  SCIP_Bool foundsol;
3355  SCIP_Bool downvalidlocal;
3356  SCIP_Bool upvalidlocal;
3357  SCIP_Bool allcolsinlp;
3358  SCIP_Bool enabledconflict;
3359  int oldnconflicts;
3360  int nvars;
3361 
3362  assert(scip != NULL);
3363  assert(var != NULL);
3364  assert(SCIPvarIsIntegral(var));
3365  assert(down != NULL);
3366  assert(up != NULL);
3367  assert(lperror != NULL);
3368  assert((newlbs != NULL) == (newubs != NULL));
3369  assert(SCIPinProbing(scip));
3370  assert(var->scip == scip);
3371 
3372  SCIP_CALL( SCIPcheckStage(scip, "SCIPgetVarStrongbranchWithPropagation", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
3373 
3374  /* check whether propagation should be performed */
3375  propagate = (maxproprounds != 0 && maxproprounds != -3);
3376 
3377  /* Check, if all existing columns are in LP.
3378  * If this is not the case, we may still return that the up and down dual bounds are valid, because the branching
3379  * rule should not apply them otherwise.
3380  * However, we must not set the downinf or upinf pointers to TRUE based on the dual bound, because we cannot
3381  * guarantee that this node can be cut off.
3382  */
3383  allcolsinlp = SCIPallColsInLP(scip);
3384 
3385  /* if maxproprounds is -2, change it to 0, which for the following calls means using the parameter settings */
3386  if( maxproprounds == -2 )
3387  maxproprounds = 0;
3388 
3389  *down = lpobjval;
3390  *up = lpobjval;
3391  if( downvalid != NULL )
3392  *downvalid = FALSE;
3393  if( upvalid != NULL )
3394  *upvalid = FALSE;
3395  if( downinf != NULL )
3396  *downinf = FALSE;
3397  if( upinf != NULL )
3398  *upinf = FALSE;
3399  if( downconflict != NULL )
3400  *downconflict = FALSE;
3401  if( upconflict != NULL )
3402  *upconflict = FALSE;
3403  if( ndomredsdown != NULL )
3404  *ndomredsdown = 0;
3405  if( ndomredsup != NULL )
3406  *ndomredsup = 0;
3407 
3408  *lperror = FALSE;
3409 
3410  vars = SCIPgetVars(scip);
3411  nvars = SCIPgetNVars(scip);
3412 
3414 
3415  /* check if the solving process should be aborted */
3416  if( SCIPsolveIsStopped(scip->set, scip->stat, FALSE) )
3417  {
3418  /* mark this as if the LP failed */
3419  *lperror = TRUE;
3420  return SCIP_OKAY;
3421  }
3422 
3424  {
3425  SCIPerrorMessage("cannot get strong branching information on non-COLUMN variable <%s>\n", SCIPvarGetName(var));
3426  return SCIP_INVALIDDATA;
3427  }
3428 
3429  col = SCIPvarGetCol(var);
3430  assert(col != NULL);
3431 
3432  if( !SCIPcolIsInLP(col) )
3433  {
3434  SCIPerrorMessage("cannot get strong branching information on variable <%s> not in current LP\n", SCIPvarGetName(var));
3435  return SCIP_INVALIDDATA;
3436  }
3437 
3438  newlb = SCIPfeasFloor(scip, solval + 1.0);
3439  newub = SCIPfeasCeil(scip, solval - 1.0);
3440 
3441  SCIPdebugMsg(scip, "strong branching on var <%s>: solval=%g, lb=%g, ub=%g\n", SCIPvarGetName(var), solval,
3443 
3444  /* the up branch is infeasible due to the branching bound change; since this means that solval is not within the
3445  * bounds, this should only happen if previous strong branching calls on other variables detected bound changes which
3446  * are valid for and were already applied at the probing root
3447  */
3448  if( newlb > SCIPvarGetUbLocal(var) + 0.5 )
3449  {
3450  *up = SCIPinfinity(scip);
3451 
3452  if( upinf != NULL )
3453  *upinf = TRUE;
3454 
3455  if( upvalid != NULL )
3456  *upvalid = TRUE;
3457 
3458  /* bound changes are applied in SCIPendStrongbranch(), which can be seen as a conflict constraint */
3459  if( upconflict != NULL )
3460  *upconflict = TRUE;
3461 
3462  SCIPcolSetStrongbranchData(col, scip->set, scip->stat, scip->lp, lpobjval, solval,
3463  *down, *up, FALSE, TRUE, 0LL, INT_MAX);
3464 
3465  /* we do not regard the down branch; its valid pointer stays set to FALSE */
3466  return SCIP_OKAY;
3467  }
3468 
3469  /* the down branch is infeasible due to the branching bound change; since this means that solval is not within the
3470  * bounds, this should only happen if previous strong branching calls on other variables detected bound changes which
3471  * are valid for and were already applied at the probing root
3472  */
3473  if( newub < SCIPvarGetLbLocal(var) - 0.5 )
3474  {
3475  *down = SCIPinfinity(scip);
3476 
3477  if( downinf != NULL )
3478  *downinf = TRUE;
3479 
3480  if( downvalid != NULL )
3481  *downvalid = TRUE;
3482 
3483  /* bound changes are applied in SCIPendStrongbranch(), which can be seen as a conflict constraint */
3484  if( downconflict != NULL )
3485  *downconflict = TRUE;
3486 
3487  SCIPcolSetStrongbranchData(col, scip->set, scip->stat, scip->lp, lpobjval, solval,
3488  *down, *up, TRUE, FALSE, 0LL, INT_MAX);
3489 
3490  /* we do not regard the up branch; its valid pointer stays set to FALSE */
3491  return SCIP_OKAY;
3492  }
3493 
3494  /* We now do strong branching by creating the two potential child nodes as probing nodes and solving them one after
3495  * the other. We will stop when the first child is detected infeasible, saving the effort we would need for the
3496  * second child. Since empirically, the up child tends to be infeasible more often, we do strongbranching first on
3497  * the up branch.
3498  */
3499  oldniters = scip->stat->nsbdivinglpiterations;
3500  firstchild = TRUE;
3501  cutoff = FALSE;
3502 
3503  /* switch conflict analysis according to usesb parameter */
3504  enabledconflict = scip->set->conf_enable;
3505  scip->set->conf_enable = (scip->set->conf_enable && scip->set->conf_usesb);
3506 
3507  /* @todo: decide the branch to look at first based on the cutoffs in previous calls? */
3508  downchild = SCIPisStrongbranchDownFirst(scip, var);
3509 
3510  downvalidlocal = FALSE;
3511  upvalidlocal = FALSE;
3512 
3513  do
3514  {
3515  oldnconflicts = SCIPconflictGetNConflicts(scip->conflict);
3516 
3517  if( downchild )
3518  {
3519  SCIP_CALL( performStrongbranchWithPropagation(scip, var, downchild, firstchild, propagate, newub, itlim, maxproprounds,
3520  down, &downvalidlocal, ndomredsdown, downconflict, lperror, vars, nvars, newlbs, newubs, &foundsol, &cutoff) );
3521 
3522  /* check whether a new solutions rendered the previous child infeasible */
3523  if( foundsol && !firstchild && allcolsinlp )
3524  {
3525  if( SCIPisGE(scip, *up, SCIPgetCutoffbound(scip)) )
3526  {
3527  if( upinf != NULL )
3528  *upinf = TRUE;
3529  }
3530  }
3531 
3532  /* check for infeasibility */
3533  if( cutoff )
3534  {
3535  if( downinf != NULL )
3536  *downinf = TRUE;
3537 
3538  if( downconflict != NULL &&
3539  (SCIPvarGetLbLocal(var) > newub + 0.5 || SCIPconflictGetNConflicts(scip->conflict) > oldnconflicts) )
3540  {
3541  *downconflict = TRUE;
3542  }
3543 
3544  if( !scip->set->branch_forceall )
3545  {
3546  /* if this is the first call, we do not regard the up branch, its valid pointer is initially set to FALSE */
3547  break;
3548  }
3549  }
3550  }
3551  else
3552  {
3553  SCIP_CALL( performStrongbranchWithPropagation(scip, var, downchild, firstchild, propagate, newlb, itlim, maxproprounds,
3554  up, &upvalidlocal, ndomredsup, upconflict, lperror, vars, nvars, newlbs, newubs, &foundsol, &cutoff) );
3555 
3556  /* check whether a new solutions rendered the previous child infeasible */
3557  if( foundsol && !firstchild && allcolsinlp )
3558  {
3559  if( SCIPisGE(scip, *down, SCIPgetCutoffbound(scip)) )
3560  {
3561  if( downinf != NULL )
3562  *downinf = TRUE;
3563  }
3564  }
3565 
3566  /* check for infeasibility */
3567  if( cutoff )
3568  {
3569  if( upinf != NULL )
3570  *upinf = TRUE;
3571 
3572  assert(upinf == NULL || (*upinf) == TRUE);
3573 
3574  if( upconflict != NULL &&
3575  (SCIPvarGetUbLocal(var) < newlb - 0.5 || SCIPconflictGetNConflicts(scip->conflict) > oldnconflicts) )
3576  {
3577  *upconflict = TRUE;
3578  }
3579 
3580  if( !scip->set->branch_forceall )
3581  {
3582  /* if this is the first call, we do not regard the down branch, its valid pointer is initially set to FALSE */
3583  break;
3584  }
3585  }
3586  }
3587 
3588  downchild = !downchild;
3589  firstchild = !firstchild;
3590  }
3591  while( !firstchild );
3592 
3593  /* set strong branching information in column */
3594  if( *lperror )
3595  {
3596  SCIPcolInvalidateStrongbranchData(col, scip->set, scip->stat, scip->lp);
3597  }
3598  else
3599  {
3600  SCIPcolSetStrongbranchData(col, scip->set, scip->stat, scip->lp, lpobjval, solval,
3601  *down, *up, downvalidlocal, upvalidlocal, scip->stat->nsbdivinglpiterations - oldniters, itlim);
3602  }
3603 
3604  if( downvalid != NULL )
3605  *downvalid = downvalidlocal;
3606  if( upvalid != NULL )
3607  *upvalid = upvalidlocal;
3608 
3609  scip->set->conf_enable = enabledconflict;
3610 
3611  return SCIP_OKAY;
3612 }
3613 
3614 /** gets strong branching information on column variable x with integral LP solution value (val); that is, the down branch
3615  * is (val -1.0) and the up brach ins (val +1.0)
3616  *
3617  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3618  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3619  *
3620  * @pre This method can be called if @p scip is in one of the following stages:
3621  * - \ref SCIP_STAGE_PRESOLVED
3622  * - \ref SCIP_STAGE_SOLVING
3623  *
3624  * @note If the integral LP solution value is the lower or upper bound of the variable, the corresponding branch will be
3625  * marked as infeasible. That is, the valid pointer and the infeasible pointer are set to TRUE.
3626  */
3628  SCIP* scip, /**< SCIP data structure */
3629  SCIP_VAR* var, /**< variable to get strong branching values for */
3630  int itlim, /**< iteration limit for strong branchings */
3631  SCIP_Real* down, /**< stores dual bound after branching column down */
3632  SCIP_Real* up, /**< stores dual bound after branching column up */
3633  SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL;
3634  * otherwise, it can only be used as an estimate value */
3635  SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound, or NULL;
3636  * otherwise, it can only be used as an estimate value */
3637  SCIP_Bool* downinf, /**< pointer to store whether the downwards branch is infeasible, or NULL */
3638  SCIP_Bool* upinf, /**< pointer to store whether the upwards branch is infeasible, or NULL */
3639  SCIP_Bool* downconflict, /**< pointer to store whether a conflict constraint was created for an
3640  * infeasible downwards branch, or NULL */
3641  SCIP_Bool* upconflict, /**< pointer to store whether a conflict constraint was created for an
3642  * infeasible upwards branch, or NULL */
3643  SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred or the
3644  * solving process should be stopped (e.g., due to a time limit) */
3645  )
3646 {
3647  SCIP_COL* col;
3648 
3649  SCIP_CALL( SCIPcheckStage(scip, "SCIPgetVarStrongbranchInt", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
3650 
3651  assert(lperror != NULL);
3652  assert(var->scip == scip);
3653 
3654  if( downvalid != NULL )
3655  *downvalid = FALSE;
3656  if( upvalid != NULL )
3657  *upvalid = FALSE;
3658  if( downinf != NULL )
3659  *downinf = FALSE;
3660  if( upinf != NULL )
3661  *upinf = FALSE;
3662  if( downconflict != NULL )
3663  *downconflict = FALSE;
3664  if( upconflict != NULL )
3665  *upconflict = FALSE;
3666 
3668  {
3669  SCIPerrorMessage("cannot get strong branching information on non-COLUMN variable <%s>\n", SCIPvarGetName(var));
3670  return SCIP_INVALIDDATA;
3671  }
3672 
3673  col = SCIPvarGetCol(var);
3674  assert(col != NULL);
3675 
3676  if( !SCIPcolIsInLP(col) )
3677  {
3678  SCIPerrorMessage("cannot get strong branching information on variable <%s> not in current LP\n", SCIPvarGetName(var));
3679  return SCIP_INVALIDDATA;
3680  }
3681 
3682  /* check if the solving process should be aborted */
3683  if( SCIPsolveIsStopped(scip->set, scip->stat, FALSE) )
3684  {
3685  /* mark this as if the LP failed */
3686  *lperror = TRUE;
3687  return SCIP_OKAY;
3688  }
3689 
3690  /* call strong branching for column */
3691  SCIP_CALL( SCIPcolGetStrongbranch(col, TRUE, scip->set, scip->stat, scip->transprob, scip->lp, itlim,
3692  down, up, downvalid, upvalid, lperror) );
3693 
3694  /* check, if the branchings are infeasible; in exact solving mode, we cannot trust the strong branching enough to
3695  * declare the sub nodes infeasible
3696  */
3697  if( !(*lperror) && SCIPprobAllColsInLP(scip->transprob, scip->set, scip->lp) && !scip->set->misc_exactsolve )
3698  {
3699  SCIP_CALL( analyzeStrongbranch(scip, var, downinf, upinf, downconflict, upconflict) );
3700  }
3701 
3702  return SCIP_OKAY;
3703 }
3704 
3705 /** gets strong branching information on column variables with fractional values
3706  *
3707  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3708  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3709  *
3710  * @pre This method can be called if @p scip is in one of the following stages:
3711  * - \ref SCIP_STAGE_PRESOLVED
3712  * - \ref SCIP_STAGE_SOLVING
3713  */
3715  SCIP* scip, /**< SCIP data structure */
3716  SCIP_VAR** vars, /**< variables to get strong branching values for */
3717  int nvars, /**< number of variables */
3718  int itlim, /**< iteration limit for strong branchings */
3719  SCIP_Real* down, /**< stores dual bounds after branching variables down */
3720  SCIP_Real* up, /**< stores dual bounds after branching variables up */
3721  SCIP_Bool* downvalid, /**< stores whether the returned down values are valid dual bounds, or NULL;
3722  * otherwise, they can only be used as an estimate value */
3723  SCIP_Bool* upvalid, /**< stores whether the returned up values are valid dual bounds, or NULL;
3724  * otherwise, they can only be used as an estimate value */
3725  SCIP_Bool* downinf, /**< array to store whether the downward branches are infeasible, or NULL */
3726  SCIP_Bool* upinf, /**< array to store whether the upward branches are infeasible, or NULL */
3727  SCIP_Bool* downconflict, /**< array to store whether conflict constraints were created for
3728  * infeasible downward branches, or NULL */
3729  SCIP_Bool* upconflict, /**< array to store whether conflict constraints were created for
3730  * infeasible upward branches, or NULL */
3731  SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred or the
3732  * solving process should be stopped (e.g., due to a time limit) */
3733  )
3734 {
3735  SCIP_COL** cols;
3736  int j;
3737 
3738  SCIP_CALL( SCIPcheckStage(scip, "SCIPgetVarsStrongbranchesFrac", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
3739 
3740  assert( lperror != NULL );
3741  assert( vars != NULL );
3742 
3743  /* set up data */
3744  cols = NULL;
3745  SCIP_CALL( SCIPallocBufferArray(scip, &cols, nvars) );
3746  assert(cols != NULL);
3747  for( j = 0; j < nvars; ++j )
3748  {
3749  SCIP_VAR* var;
3750  SCIP_COL* col;
3751 
3752  if( downvalid != NULL )
3753  downvalid[j] = FALSE;
3754  if( upvalid != NULL )
3755  upvalid[j] = FALSE;
3756  if( downinf != NULL )
3757  downinf[j] = FALSE;
3758  if( upinf != NULL )
3759  upinf[j] = FALSE;
3760  if( downconflict != NULL )
3761  downconflict[j] = FALSE;
3762  if( upconflict != NULL )
3763  upconflict[j] = FALSE;
3764 
3765  var = vars[j];
3766  assert( var != NULL );
3768  {
3769  SCIPerrorMessage("cannot get strong branching information on non-COLUMN variable <%s>\n", SCIPvarGetName(var));
3770  SCIPfreeBufferArray(scip, &cols);
3771  return SCIP_INVALIDDATA;
3772  }
3773 
3774  col = SCIPvarGetCol(var);
3775  assert(col != NULL);
3776  cols[j] = col;
3777 
3778  if( !SCIPcolIsInLP(col) )
3779  {
3780  SCIPerrorMessage("cannot get strong branching information on variable <%s> not in current LP\n", SCIPvarGetName(var));
3781  SCIPfreeBufferArray(scip, &cols);
3782  return SCIP_INVALIDDATA;
3783  }
3784  }
3785 
3786  /* check if the solving process should be aborted */
3787  if( SCIPsolveIsStopped(scip->set, scip->stat, FALSE) )
3788  {
3789  /* mark this as if the LP failed */
3790  *lperror = TRUE;
3791  }
3792  else
3793  {
3794  /* call strong branching for columns with fractional value */
3795  SCIP_CALL( SCIPcolGetStrongbranches(cols, nvars, FALSE, scip->set, scip->stat, scip->transprob, scip->lp, itlim,
3796  down, up, downvalid, upvalid, lperror) );
3797 
3798  /* check, if the branchings are infeasible; in exact solving mode, we cannot trust the strong branching enough to
3799  * declare the sub nodes infeasible
3800  */
3801  if( !(*lperror) && SCIPprobAllColsInLP(scip->transprob, scip->set, scip->lp) && !scip->set->misc_exactsolve )
3802  {
3803  for( j = 0; j < nvars; ++j )
3804  {
3805  SCIP_CALL( analyzeStrongbranch(scip, vars[j], (downinf != NULL) ? (&(downinf[j])) : NULL,
3806  (upinf != NULL) ? (&(upinf[j])) : NULL, (downconflict != NULL) ? (&(downconflict[j])) : NULL,
3807  (upconflict != NULL) ? (&(upconflict[j])) : NULL) );
3808  }
3809  }
3810  }
3811  SCIPfreeBufferArray(scip, &cols);
3812 
3813  return SCIP_OKAY;
3814 }
3815 
3816 /** gets strong branching information on column variables with integral values
3817  *
3818  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3819  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3820  *
3821  * @pre This method can be called if @p scip is in one of the following stages:
3822  * - \ref SCIP_STAGE_PRESOLVED
3823  * - \ref SCIP_STAGE_SOLVING
3824  */
3826  SCIP* scip, /**< SCIP data structure */
3827  SCIP_VAR** vars, /**< variables to get strong branching values for */
3828  int nvars, /**< number of variables */
3829  int itlim, /**< iteration limit for strong branchings */
3830  SCIP_Real* down, /**< stores dual bounds after branching variables down */
3831  SCIP_Real* up, /**< stores dual bounds after branching variables up */
3832  SCIP_Bool* downvalid, /**< stores whether the returned down values are valid dual bounds, or NULL;
3833  * otherwise, they can only be used as an estimate value */
3834  SCIP_Bool* upvalid, /**< stores whether the returned up values are valid dual bounds, or NULL;
3835  * otherwise, they can only be used as an estimate value */
3836  SCIP_Bool* downinf, /**< array to store whether the downward branches are infeasible, or NULL */
3837  SCIP_Bool* upinf, /**< array to store whether the upward branches are infeasible, or NULL */
3838  SCIP_Bool* downconflict, /**< array to store whether conflict constraints were created for
3839  * infeasible downward branches, or NULL */
3840  SCIP_Bool* upconflict, /**< array to store whether conflict constraints were created for
3841  * infeasible upward branches, or NULL */
3842  SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred or the
3843  * solving process should be stopped (e.g., due to a time limit) */
3844  )
3845 {
3846  SCIP_COL** cols;
3847  int j;
3848 
3849  assert(lperror != NULL);
3850 
3851  SCIP_CALL( SCIPcheckStage(scip, "SCIPgetVarsStrongbranchesInt", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
3852 
3853  assert( vars != NULL );
3854 
3855  /* set up data */
3856  cols = NULL;
3857  SCIP_CALL( SCIPallocBufferArray(scip, &cols, nvars) );
3858  assert(cols != NULL);
3859  for( j = 0; j < nvars; ++j )
3860  {
3861  SCIP_VAR* var;
3862  SCIP_COL* col;
3863 
3864  if( downvalid != NULL )
3865  downvalid[j] = FALSE;
3866  if( upvalid != NULL )
3867  upvalid[j] = FALSE;
3868  if( downinf != NULL )
3869  downinf[j] = FALSE;
3870  if( upinf != NULL )
3871  upinf[j] = FALSE;
3872  if( downconflict != NULL )
3873  downconflict[j] = FALSE;
3874  if( upconflict != NULL )
3875  upconflict[j] = FALSE;
3876 
3877  var = vars[j];
3878  assert( var != NULL );
3880  {
3881  SCIPerrorMessage("cannot get strong branching information on non-COLUMN variable <%s>\n", SCIPvarGetName(var));
3882  SCIPfreeBufferArray(scip, &cols);
3883  return SCIP_INVALIDDATA;
3884  }
3885 
3886  col = SCIPvarGetCol(var);
3887  assert(col != NULL);
3888  cols[j] = col;
3889 
3890  if( !SCIPcolIsInLP(col) )
3891  {
3892  SCIPerrorMessage("cannot get strong branching information on variable <%s> not in current LP\n", SCIPvarGetName(var));
3893  SCIPfreeBufferArray(scip, &cols);
3894  return SCIP_INVALIDDATA;
3895  }
3896  }
3897 
3898  /* check if the solving process should be aborted */
3899  if( SCIPsolveIsStopped(scip->set, scip->stat, FALSE) )
3900  {
3901  /* mark this as if the LP failed */
3902  *lperror = TRUE;
3903  }
3904  else
3905  {
3906  /* call strong branching for columns */
3907  SCIP_CALL( SCIPcolGetStrongbranches(cols, nvars, TRUE, scip->set, scip->stat, scip->transprob, scip->lp, itlim,
3908  down, up, downvalid, upvalid, lperror) );
3909 
3910  /* check, if the branchings are infeasible; in exact solving mode, we cannot trust the strong branching enough to
3911  * declare the sub nodes infeasible
3912  */
3913  if( !(*lperror) && SCIPprobAllColsInLP(scip->transprob, scip->set, scip->lp) && !scip->set->misc_exactsolve )
3914  {
3915  for( j = 0; j < nvars; ++j )
3916  {
3917  SCIP_CALL( analyzeStrongbranch(scip, vars[j], (downinf != NULL) ? (&(downinf[j])) : NULL,
3918  (upinf != NULL) ? (&(upinf[j])) : NULL, (downconflict != NULL) ? (&(downconflict[j])) : NULL,
3919  (upconflict != NULL) ? (&(upconflict[j])) : NULL) );
3920  }
3921  }
3922  }
3923  SCIPfreeBufferArray(scip, &cols);
3924 
3925  return SCIP_OKAY;
3926 }
3927 
3928 /** get LP solution status of last strong branching call (currently only works for strong branching with propagation) */
3930  SCIP* scip, /**< SCIP data structure */
3931  SCIP_BRANCHDIR branchdir /**< branching direction for which LP solution status is requested */
3932  )
3933 {
3934  assert(NULL != scip);
3935  assert(branchdir == SCIP_BRANCHDIR_DOWNWARDS || branchdir == SCIP_BRANCHDIR_UPWARDS);
3936 
3937  return scip->stat->lastsblpsolstats[branchdir == SCIP_BRANCHDIR_DOWNWARDS ? 0 : 1];
3938 }
3939 
3940 /** gets strong branching information on COLUMN variable of the last SCIPgetVarStrongbranch() call;
3941  * returns values of SCIP_INVALID, if strong branching was not yet called on the given variable;
3942  * keep in mind, that the returned old values may have nothing to do with the current LP solution
3943  *
3944  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3945  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3946  *
3947  * @pre This method can be called if @p scip is in one of the following stages:
3948  * - \ref SCIP_STAGE_SOLVING
3949  * - \ref SCIP_STAGE_SOLVED
3950  */
3952  SCIP* scip, /**< SCIP data structure */
3953  SCIP_VAR* var, /**< variable to get last strong branching values for */
3954  SCIP_Real* down, /**< stores dual bound after branching column down */
3955  SCIP_Real* up, /**< stores dual bound after branching column up */
3956  SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL;
3957  * otherwise, it can only be used as an estimate value */
3958  SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound, or NULL;
3959  * otherwise, it can only be used as an estimate value */
3960  SCIP_Real* solval, /**< stores LP solution value of variable at the last strong branching call, or NULL */
3961  SCIP_Real* lpobjval /**< stores LP objective value at last strong branching call, or NULL */
3962  )
3963 {
3964  SCIP_CALL( SCIPcheckStage(scip, "SCIPgetVarStrongbranchLast", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
3965 
3967  {
3968  SCIPerrorMessage("cannot get strong branching information on non-COLUMN variable\n");
3969  return SCIP_INVALIDDATA;
3970  }
3971 
3972  SCIPcolGetStrongbranchLast(SCIPvarGetCol(var), down, up, downvalid, upvalid, solval, lpobjval);
3973 
3974  return SCIP_OKAY;
3975 }
3976 
3977 /** sets strong branching information for a column variable
3978  *
3979  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3980  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3981  *
3982  * @pre This method can be called if @p scip is in one of the following stages:
3983  * - \ref SCIP_STAGE_SOLVING
3984  */
3986  SCIP* scip, /**< SCIP data structure */
3987  SCIP_VAR* var, /**< variable to set last strong branching values for */
3988  SCIP_Real lpobjval, /**< objective value of the current LP */
3989  SCIP_Real primsol, /**< primal solution value of the column in the current LP */
3990  SCIP_Real down, /**< dual bound after branching column down */
3991  SCIP_Real up, /**< dual bound after branching column up */
3992  SCIP_Bool downvalid, /**< is the returned down value a valid dual bound? */
3993  SCIP_Bool upvalid, /**< is the returned up value a valid dual bound? */
3994  SCIP_Longint iter, /**< total number of strong branching iterations */
3995  int itlim /**< iteration limit applied to the strong branching call */
3996  )
3997 {
3998  SCIP_CALL( SCIPcheckStage(scip, "SCIPsetVarStrongbranchData", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
3999 
4001  {
4002  SCIPerrorMessage("cannot set strong branching information on non-COLUMN variable\n");
4003  return SCIP_INVALIDDATA;
4004  }
4005 
4006  SCIPcolSetStrongbranchData(SCIPvarGetCol(var), scip->set, scip->stat, scip->lp, lpobjval, primsol,
4007  down, up, downvalid, upvalid, iter, itlim);
4008 
4009  return SCIP_OKAY;
4010 }
4011 
4012 /** rounds the current solution and tries it afterwards; if feasible, adds it to storage
4013  *
4014  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4015  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4016  *
4017  * @pre This method can be called if @p scip is in one of the following stages:
4018  * - \ref SCIP_STAGE_SOLVING
4019  */
4021  SCIP* scip, /**< SCIP data structure */
4022  SCIP_Bool* foundsol, /**< stores whether solution was feasible and good enough to keep */
4023  SCIP_Bool* cutoff /**< stores whether solution was cutoff due to exceeding the cutoffbound */
4024  )
4025 {
4026  assert(scip != NULL);
4027  assert(foundsol != NULL);
4028  assert(cutoff != NULL);
4029 
4030  SCIP_CALL( SCIPcheckStage(scip, "SCIPtryStrongbranchLPSol", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
4031 
4032  if( scip->set->branch_checksbsol )
4033  {
4034  SCIP_SOL* sol;
4035  SCIP_Bool rounded = TRUE;
4036  SCIP_Real value = SCIPgetLPObjval(scip);
4037  SCIP_Longint oldnbestsolsfound = scip->primal->nbestsolsfound;
4038 
4039  /* start clock for strong branching solutions */
4040  SCIPclockStart(scip->stat->sbsoltime, scip->set);
4041 
4042  SCIP_CALL( SCIPcreateLPSol(scip, &sol, NULL) );
4043 
4044  /* try to round the strong branching solution */
4045  if( scip->set->branch_roundsbsol )
4046  {
4047  SCIP_CALL( SCIProundSol(scip, sol, &rounded) );
4048  }
4049 
4050  /* check the solution for feasibility if rounding worked well (or was not tried) */
4051  if( rounded )
4052  {
4053  SCIP_CALL( SCIPtrySolFree(scip, &sol, FALSE, FALSE, FALSE, TRUE, FALSE, foundsol) );
4054  }
4055  else
4056  {
4057  SCIP_CALL( SCIPfreeSol(scip, &sol) );
4058  }
4059 
4060  if( *foundsol )
4061  {
4062  SCIPdebugMsg(scip, "found new solution in strong branching\n");
4063 
4064  scip->stat->nsbsolsfound++;
4065 
4066  if( scip->primal->nbestsolsfound != oldnbestsolsfound )
4067  {
4068  scip->stat->nsbbestsolsfound++;
4069  }
4070 
4071  if( SCIPisGE(scip, value, SCIPgetCutoffbound(scip)) )
4072  *cutoff = TRUE;
4073  }
4074 
4075  /* stop clock for strong branching solutions */
4076  SCIPclockStop(scip->stat->sbsoltime, scip->set);
4077  }
4078  return SCIP_OKAY;
4079 }
4080 
4081 
4082 /** gets node number of the last node in current branch and bound run, where strong branching was used on the
4083  * given variable, or -1 if strong branching was never applied to the variable in current run
4084  *
4085  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4086  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4087  *
4088  * @pre This method can be called if @p scip is in one of the following stages:
4089  * - \ref SCIP_STAGE_TRANSFORMING
4090  * - \ref SCIP_STAGE_TRANSFORMED
4091  * - \ref SCIP_STAGE_INITPRESOLVE
4092  * - \ref SCIP_STAGE_PRESOLVING
4093  * - \ref SCIP_STAGE_EXITPRESOLVE
4094  * - \ref SCIP_STAGE_PRESOLVED
4095  * - \ref SCIP_STAGE_INITSOLVE
4096  * - \ref SCIP_STAGE_SOLVING
4097  * - \ref SCIP_STAGE_SOLVED
4098  * - \ref SCIP_STAGE_EXITSOLVE
4099  */
4101  SCIP* scip, /**< SCIP data structure */
4102  SCIP_VAR* var /**< variable to get last strong branching node for */
4103  )
4104 {
4105  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarStrongbranchNode", FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
4106 
4107  assert( var->scip == scip );
4108 
4110  return -1;
4111 
4113 }
4114 
4115 /** if strong branching was already applied on the variable at the current node, returns the number of LPs solved after
4116  * the LP where the strong branching on this variable was applied;
4117  * if strong branching was not yet applied on the variable at the current node, returns INT_MAX
4118  *
4119  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4120  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4121  *
4122  * @pre This method can be called if @p scip is in one of the following stages:
4123  * - \ref SCIP_STAGE_TRANSFORMING
4124  * - \ref SCIP_STAGE_TRANSFORMED
4125  * - \ref SCIP_STAGE_INITPRESOLVE
4126  * - \ref SCIP_STAGE_PRESOLVING
4127  * - \ref SCIP_STAGE_EXITPRESOLVE
4128  * - \ref SCIP_STAGE_PRESOLVED
4129  * - \ref SCIP_STAGE_INITSOLVE
4130  * - \ref SCIP_STAGE_SOLVING
4131  * - \ref SCIP_STAGE_SOLVED
4132  * - \ref SCIP_STAGE_EXITSOLVE
4133  */
4135  SCIP* scip, /**< SCIP data structure */
4136  SCIP_VAR* var /**< variable to get strong branching LP age for */
4137  )
4138 {
4139  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarStrongbranchLPAge", FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
4140 
4141  assert( var->scip == scip );
4142 
4144  return SCIP_LONGINT_MAX;
4145 
4146  return SCIPcolGetStrongbranchLPAge(SCIPvarGetCol(var), scip->stat);
4147 }
4148 
4149 /** gets number of times, strong branching was applied in current run on the given variable
4150  *
4151  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4152  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4153  *
4154  * @pre This method can be called if @p scip is in one of the following stages:
4155  * - \ref SCIP_STAGE_TRANSFORMING
4156  * - \ref SCIP_STAGE_TRANSFORMED
4157  * - \ref SCIP_STAGE_INITPRESOLVE
4158  * - \ref SCIP_STAGE_PRESOLVING
4159  * - \ref SCIP_STAGE_EXITPRESOLVE
4160  * - \ref SCIP_STAGE_PRESOLVED
4161  * - \ref SCIP_STAGE_INITSOLVE
4162  * - \ref SCIP_STAGE_SOLVING
4163  * - \ref SCIP_STAGE_SOLVED
4164  * - \ref SCIP_STAGE_EXITSOLVE
4165  */
4167  SCIP* scip, /**< SCIP data structure */
4168  SCIP_VAR* var /**< variable to get last strong branching node for */
4169  )
4170 {
4171  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarNStrongbranchs", FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
4172 
4173  assert( var->scip == scip );
4174 
4176  return 0;
4177 
4179 }
4180 
4181 /** adds given values to lock numbers of type @p locktype of variable for rounding
4182  *
4183  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4184  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4185  *
4186  * @pre This method can be called if @p scip is in one of the following stages:
4187  * - \ref SCIP_STAGE_PROBLEM
4188  * - \ref SCIP_STAGE_TRANSFORMING
4189  * - \ref SCIP_STAGE_TRANSFORMED
4190  * - \ref SCIP_STAGE_INITPRESOLVE
4191  * - \ref SCIP_STAGE_PRESOLVING
4192  * - \ref SCIP_STAGE_EXITPRESOLVE
4193  * - \ref SCIP_STAGE_PRESOLVED
4194  * - \ref SCIP_STAGE_INITSOLVE
4195  * - \ref SCIP_STAGE_SOLVING
4196  * - \ref SCIP_STAGE_EXITSOLVE
4197  * - \ref SCIP_STAGE_FREETRANS
4198  */
4200  SCIP* scip, /**< SCIP data structure */
4201  SCIP_VAR* var, /**< problem variable */
4202  SCIP_LOCKTYPE locktype, /**< type of the variable locks */
4203  int nlocksdown, /**< modification in number of rounding down locks */
4204  int nlocksup /**< modification in number of rounding up locks */
4205  )
4206 {
4207  SCIP_CALL( SCIPcheckStage(scip, "SCIPaddVarLocksType", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE) );
4208 
4209  assert( var->scip == scip );
4210 
4211  switch( scip->set->stage )
4212  {
4213  case SCIP_STAGE_PROBLEM:
4214  assert(!SCIPvarIsTransformed(var));
4215  /*lint -fallthrough*/
4219  case SCIP_STAGE_PRESOLVING:
4221  case SCIP_STAGE_PRESOLVED:
4222  case SCIP_STAGE_INITSOLVE:
4223  case SCIP_STAGE_SOLVING:
4224  case SCIP_STAGE_EXITSOLVE:
4225  case SCIP_STAGE_FREETRANS:
4226  SCIP_CALL( SCIPvarAddLocks(var, scip->mem->probmem, scip->set, scip->eventqueue, locktype, nlocksdown, nlocksup) );
4227  return SCIP_OKAY;
4228 
4229  default:
4230  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
4231  return SCIP_INVALIDCALL;
4232  } /*lint !e788*/
4233 }
4234 
4235 /** adds given values to lock numbers of variable for rounding
4236  *
4237  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4238  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4239  *
4240  * @pre This method can be called if @p scip is in one of the following stages:
4241  * - \ref SCIP_STAGE_PROBLEM
4242  * - \ref SCIP_STAGE_TRANSFORMING
4243  * - \ref SCIP_STAGE_TRANSFORMED
4244  * - \ref SCIP_STAGE_INITPRESOLVE
4245  * - \ref SCIP_STAGE_PRESOLVING
4246  * - \ref SCIP_STAGE_EXITPRESOLVE
4247  * - \ref SCIP_STAGE_PRESOLVED
4248  * - \ref SCIP_STAGE_INITSOLVE
4249  * - \ref SCIP_STAGE_SOLVING
4250  * - \ref SCIP_STAGE_EXITSOLVE
4251  * - \ref SCIP_STAGE_FREETRANS
4252  *
4253  * @note This method will always add variable locks of type model
4254  *
4255  * @note It is recommented to use SCIPaddVarLocksType()
4256  */
4258  SCIP* scip, /**< SCIP data structure */
4259  SCIP_VAR* var, /**< problem variable */
4260  int nlocksdown, /**< modification in number of rounding down locks */
4261  int nlocksup /**< modification in number of rounding up locks */
4262  )
4263 {
4264  SCIP_CALL( SCIPcheckStage(scip, "SCIPaddVarLocks", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE) );
4265 
4266  SCIP_CALL( SCIPaddVarLocksType(scip, var, SCIP_LOCKTYPE_MODEL, nlocksdown, nlocksup) );
4267 
4268  return SCIP_OKAY;
4269 }
4270 
4271 /** add locks of variable with respect to the lock status of the constraint and its negation;
4272  * this method should be called whenever the lock status of a variable in a constraint changes, for example if
4273  * the coefficient of the variable changed its sign or if the left or right hand sides of the constraint were
4274  * added or removed
4275  *
4276  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4277  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4278  *
4279  * @pre This method can be called if @p scip is in one of the following stages:
4280  * - \ref SCIP_STAGE_PROBLEM
4281  * - \ref SCIP_STAGE_TRANSFORMING
4282  * - \ref SCIP_STAGE_INITPRESOLVE
4283  * - \ref SCIP_STAGE_PRESOLVING
4284  * - \ref SCIP_STAGE_EXITPRESOLVE
4285  * - \ref SCIP_STAGE_INITSOLVE
4286  * - \ref SCIP_STAGE_SOLVING
4287  * - \ref SCIP_STAGE_EXITSOLVE
4288  * - \ref SCIP_STAGE_FREETRANS
4289  */
4291  SCIP* scip, /**< SCIP data structure */
4292  SCIP_VAR* var, /**< problem variable */
4293  SCIP_CONS* cons, /**< constraint */
4294  SCIP_Bool lockdown, /**< should the rounding be locked in downwards direction? */
4295  SCIP_Bool lockup /**< should the rounding be locked in upwards direction? */
4296  )
4297 {
4298  int nlocksdown[NLOCKTYPES];
4299  int nlocksup[NLOCKTYPES];
4300  int i;
4301 
4302  SCIP_CALL( SCIPcheckStage(scip, "SCIPlockVarCons", FALSE, TRUE, TRUE, FALSE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE) );
4303 
4304  assert( var->scip == scip );
4305 
4306  for( i = 0; i < NLOCKTYPES; i++ )
4307  {
4308  nlocksdown[i] = 0;
4309  nlocksup[i] = 0;
4310 
4311  if( SCIPconsIsLockedTypePos(cons, (SCIP_LOCKTYPE) i) )
4312  {
4313  if( lockdown )
4314  ++nlocksdown[i];
4315  if( lockup )
4316  ++nlocksup[i];
4317  }
4318  if( SCIPconsIsLockedTypeNeg(cons, (SCIP_LOCKTYPE) i) )
4319  {
4320  if( lockdown )
4321  ++nlocksup[i];
4322  if( lockup )
4323  ++nlocksdown[i];
4324  }
4325  }
4326 
4327  switch( scip->set->stage )
4328  {
4329  case SCIP_STAGE_PROBLEM:
4330  assert(!SCIPvarIsTransformed(var));
4331  /*lint -fallthrough*/
4335  case SCIP_STAGE_PRESOLVING:
4337  case SCIP_STAGE_INITSOLVE:
4338  case SCIP_STAGE_SOLVING:
4339  case SCIP_STAGE_EXITSOLVE:
4340  case SCIP_STAGE_FREETRANS:
4341  for( i = 0; i < NLOCKTYPES; i++ )
4342  {
4343  if( nlocksdown[i] == 0 && nlocksup[i] == 0 )
4344  continue;
4345 
4346  SCIP_CALL( SCIPvarAddLocks(var, scip->mem->probmem, scip->set, scip->eventqueue, (SCIP_LOCKTYPE) i, nlocksdown[i], nlocksup[i]) );
4347  }
4348  return SCIP_OKAY;
4349 
4350  default:
4351  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
4352  return SCIP_INVALIDCALL;
4353  } /*lint !e788*/
4354 }
4355 
4356 /** remove locks of type @p locktype of variable with respect to the lock status of the constraint and its negation;
4357  * this method should be called whenever the lock status of a variable in a constraint changes, for example if
4358  * the coefficient of the variable changed its sign or if the left or right hand sides of the constraint were
4359  * added or removed
4360  *
4361  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4362  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4363  *
4364  * @pre This method can be called if @p scip is in one of the following stages:
4365  * - \ref SCIP_STAGE_PROBLEM
4366  * - \ref SCIP_STAGE_TRANSFORMING
4367  * - \ref SCIP_STAGE_INITPRESOLVE
4368  * - \ref SCIP_STAGE_PRESOLVING
4369  * - \ref SCIP_STAGE_EXITPRESOLVE
4370  * - \ref SCIP_STAGE_INITSOLVE
4371  * - \ref SCIP_STAGE_SOLVING
4372  * - \ref SCIP_STAGE_EXITSOLVE
4373  * - \ref SCIP_STAGE_FREETRANS
4374  */
4376  SCIP* scip, /**< SCIP data structure */
4377  SCIP_VAR* var, /**< problem variable */
4378  SCIP_CONS* cons, /**< constraint */
4379  SCIP_Bool lockdown, /**< should the rounding be unlocked in downwards direction? */
4380  SCIP_Bool lockup /**< should the rounding be unlocked in upwards direction? */
4381  )
4382 {
4383  int nlocksdown[NLOCKTYPES];
4384  int nlocksup[NLOCKTYPES];
4385  int i;
4386 
4387  SCIP_CALL( SCIPcheckStage(scip, "SCIPunlockVarCons", FALSE, TRUE, TRUE, FALSE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE) );
4388 
4389  assert( var->scip == scip );
4390 
4391  for( i = 0; i < NLOCKTYPES; i++ )
4392  {
4393  nlocksdown[i] = 0;
4394  nlocksup[i] = 0;
4395 
4396  if( SCIPconsIsLockedTypePos(cons, (SCIP_LOCKTYPE) i) )
4397  {
4398  if( lockdown )
4399  ++nlocksdown[i];
4400  if( lockup )
4401  ++nlocksup[i];
4402  }
4403  if( SCIPconsIsLockedTypeNeg(cons, (SCIP_LOCKTYPE) i) )
4404  {
4405  if( lockdown )
4406  ++nlocksup[i];
4407  if( lockup )
4408  ++nlocksdown[i];
4409  }
4410  }
4411  switch( scip->set->stage )
4412  {
4413  case SCIP_STAGE_PROBLEM:
4414  assert(!SCIPvarIsTransformed(var));
4415  /*lint -fallthrough*/
4418  case SCIP_STAGE_PRESOLVING:
4420  case SCIP_STAGE_INITSOLVE:
4421  case SCIP_STAGE_SOLVING:
4422  case SCIP_STAGE_EXITSOLVE:
4423  case SCIP_STAGE_FREETRANS:
4424  for( i = 0; i < NLOCKTYPES; i++ )
4425  {
4426  if( nlocksdown[i] == 0 && nlocksup[i] == 0 )
4427  continue;
4428 
4429  SCIP_CALL( SCIPvarAddLocks(var, scip->mem->probmem, scip->set, scip->eventqueue, (SCIP_LOCKTYPE) i, -nlocksdown[i], -nlocksup[i]) );
4430  }
4431  return SCIP_OKAY;
4432 
4433  default:
4434  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
4435  return SCIP_INVALIDCALL;
4436  } /*lint !e788*/
4437 }
4438 
4439 /** changes variable's objective value
4440  *
4441  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4442  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4443  *
4444  * @pre This method can be called if @p scip is in one of the following stages:
4445  * - \ref SCIP_STAGE_PROBLEM
4446  * - \ref SCIP_STAGE_TRANSFORMING
4447  * - \ref SCIP_STAGE_PRESOLVING
4448  * - \ref SCIP_STAGE_PRESOLVED
4449  */
4451  SCIP* scip, /**< SCIP data structure */
4452  SCIP_VAR* var, /**< variable to change the objective value for */
4453  SCIP_Real newobj /**< new objective value */
4454  )
4455 {
4456  SCIP_CALL( SCIPcheckStage(scip, "SCIPchgVarObj", FALSE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
4457 
4458  assert( var->scip == scip );
4459 
4460  /* forbid infinite objective values */
4461  if( SCIPisInfinity(scip, REALABS(newobj)) )
4462  {
4463  SCIPerrorMessage("invalid objective value: objective value is infinite\n");
4464  return SCIP_INVALIDDATA;
4465  }
4466 
4467  switch( scip->set->stage )
4468  {
4469  case SCIP_STAGE_PROBLEM:
4470  assert(!SCIPvarIsTransformed(var));
4471  SCIP_CALL( SCIPvarChgObj(var, scip->mem->probmem, scip->set, scip->origprob, scip->primal, scip->lp, scip->eventqueue, newobj) );
4472  return SCIP_OKAY;
4473 
4476  case SCIP_STAGE_PRESOLVING:
4477  case SCIP_STAGE_PRESOLVED:
4478  SCIP_CALL( SCIPvarChgObj(var, scip->mem->probmem, scip->set, scip->transprob, scip->primal, scip->lp, scip->eventqueue, newobj) );
4479  return SCIP_OKAY;
4480 
4481  default:
4482  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
4483  return SCIP_INVALIDCALL;
4484  } /*lint !e788*/
4485 }
4486 
4487 /** adds value to variable's objective value
4488  *
4489  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4490  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4491  *
4492  * @pre This method can be called if @p scip is in one of the following stages:
4493  * - \ref SCIP_STAGE_PROBLEM
4494  * - \ref SCIP_STAGE_TRANSFORMING
4495  * - \ref SCIP_STAGE_PRESOLVING
4496  * - \ref SCIP_STAGE_EXITPRESOLVE
4497  * - \ref SCIP_STAGE_PRESOLVED
4498  */
4500  SCIP* scip, /**< SCIP data structure */
4501  SCIP_VAR* var, /**< variable to change the objective value for */
4502  SCIP_Real addobj /**< additional objective value */
4503  )
4504 {
4505  SCIP_CALL( SCIPcheckStage(scip, "SCIPaddVarObj", FALSE, TRUE, TRUE, FALSE, FALSE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
4506 
4507  assert( var->scip == scip );
4508 
4509  switch( scip->set->stage )
4510  {
4511  case SCIP_STAGE_PROBLEM:
4512  assert(!SCIPvarIsTransformed(var));
4513  SCIP_CALL( SCIPvarAddObj(var, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob, scip->primal,
4514  scip->tree, scip->reopt, scip->lp, scip->eventqueue, addobj) );
4515  return SCIP_OKAY;
4516 
4518  case SCIP_STAGE_PRESOLVING:
4520  case SCIP_STAGE_PRESOLVED:
4521  SCIP_CALL( SCIPvarAddObj(var, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob, scip->primal,
4522  scip->tree, scip->reopt, scip->lp, scip->eventqueue, addobj) );
4523  return SCIP_OKAY;
4524 
4525  default:
4526  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
4527  return SCIP_INVALIDCALL;
4528  } /*lint !e788*/
4529 }
4530 
4531 /** returns the adjusted (i.e. rounded, if the given variable is of integral type) lower bound value;
4532  * does not change the bounds of the variable
4533  *
4534  * @return adjusted lower bound for the given variable; the bound of the variable is not changed
4535  *
4536  * @pre This method can be called if @p scip is in one of the following stages:
4537  * - \ref SCIP_STAGE_PROBLEM
4538  * - \ref SCIP_STAGE_TRANSFORMING
4539  * - \ref SCIP_STAGE_TRANSFORMED
4540  * - \ref SCIP_STAGE_INITPRESOLVE
4541  * - \ref SCIP_STAGE_PRESOLVING
4542  * - \ref SCIP_STAGE_EXITPRESOLVE
4543  * - \ref SCIP_STAGE_PRESOLVED
4544  * - \ref SCIP_STAGE_INITSOLVE
4545  * - \ref SCIP_STAGE_SOLVING
4546  * - \ref SCIP_STAGE_SOLVED
4547  * - \ref SCIP_STAGE_EXITSOLVE
4548  * - \ref SCIP_STAGE_FREETRANS
4549  */
4551  SCIP* scip, /**< SCIP data structure */
4552  SCIP_VAR* var, /**< variable to adjust the bound for */
4553  SCIP_Real lb /**< lower bound value to adjust */
4554  )
4555 {
4556  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPadjustedVarLb", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
4557 
4558  SCIPvarAdjustLb(var, scip->set, &lb);
4559 
4560  return lb;
4561 }
4562 
4563 /** returns the adjusted (i.e. rounded, if the given variable is of integral type) upper bound value;
4564  * does not change the bounds of the variable
4565  *
4566  * @return adjusted upper bound for the given variable; the bound of the variable is not changed
4567  *
4568  * @pre This method can be called if @p scip is in one of the following stages:
4569  * - \ref SCIP_STAGE_PROBLEM
4570  * - \ref SCIP_STAGE_TRANSFORMING
4571  * - \ref SCIP_STAGE_TRANSFORMED
4572  * - \ref SCIP_STAGE_INITPRESOLVE
4573  * - \ref SCIP_STAGE_PRESOLVING
4574  * - \ref SCIP_STAGE_EXITPRESOLVE
4575  * - \ref SCIP_STAGE_PRESOLVED
4576  * - \ref SCIP_STAGE_INITSOLVE
4577  * - \ref SCIP_STAGE_SOLVING
4578  * - \ref SCIP_STAGE_SOLVED
4579  * - \ref SCIP_STAGE_EXITSOLVE
4580  * - \ref SCIP_STAGE_FREETRANS
4581  */
4583  SCIP* scip, /**< SCIP data structure */
4584  SCIP_VAR* var, /**< variable to adjust the bound for */
4585  SCIP_Real ub /**< upper bound value to adjust */
4586  )
4587 {
4588  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPadjustedVarUb", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
4589 
4590  SCIPvarAdjustUb(var, scip->set, &ub);
4591 
4592  return ub;
4593 }
4594 
4595 /** depending on SCIP's stage, changes lower bound of variable in the problem, in preprocessing, or in current node;
4596  * if possible, adjusts bound to integral value; doesn't store any inference information in the bound change, such
4597  * that in conflict analysis, this change is treated like a branching decision
4598  *
4599  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
4600  * SCIPgetVars()) gets resorted.
4601  *
4602  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4603  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4604  *
4605  * @pre This method can be called if @p scip is in one of the following stages:
4606  * - \ref SCIP_STAGE_PROBLEM
4607  * - \ref SCIP_STAGE_TRANSFORMING
4608  * - \ref SCIP_STAGE_PRESOLVING
4609  * - \ref SCIP_STAGE_SOLVING
4610  *
4611  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
4612  */
4614  SCIP* scip, /**< SCIP data structure */
4615  SCIP_VAR* var, /**< variable to change the bound for */
4616  SCIP_Real newbound /**< new value for bound */
4617  )
4618 {
4619  SCIP_CALL( SCIPcheckStage(scip, "SCIPchgVarLb", FALSE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
4620 
4621  SCIPvarAdjustLb(var, scip->set, &newbound);
4622 
4623  /* ignore tightenings of lower bounds to +infinity during solving process */
4624  if( SCIPisInfinity(scip, newbound) && SCIPgetStage(scip) == SCIP_STAGE_SOLVING )
4625  {
4626 #ifndef NDEBUG
4627  SCIPwarningMessage(scip, "ignore lower bound tightening for %s from %e to +infinity\n", SCIPvarGetName(var),
4628  SCIPvarGetLbLocal(var));
4629 #endif
4630  return SCIP_OKAY;
4631  }
4632 
4633  switch( scip->set->stage )
4634  {
4635  case SCIP_STAGE_PROBLEM:
4636  assert(!SCIPvarIsTransformed(var));
4637  SCIP_CALL( SCIPvarChgLbGlobal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
4638  scip->branchcand, scip->eventqueue, scip->cliquetable, newbound) );
4639  SCIP_CALL( SCIPvarChgLbLocal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
4640  scip->branchcand, scip->eventqueue, newbound) );
4641  SCIP_CALL( SCIPvarChgLbOriginal(var, scip->set, newbound) );
4642  break;
4643 
4645  case SCIP_STAGE_PRESOLVED:
4646  SCIP_CALL( SCIPvarChgLbGlobal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
4647  scip->branchcand, scip->eventqueue, scip->cliquetable, newbound) );
4648  break;
4649 
4650  case SCIP_STAGE_PRESOLVING:
4651  if( !SCIPinProbing(scip) )
4652  {
4653  assert(SCIPtreeGetCurrentDepth(scip->tree) == 0);
4654  assert(scip->tree->root == SCIPtreeGetCurrentNode(scip->tree));
4655 
4656  SCIP_CALL( SCIPnodeAddBoundchg(scip->tree->root, scip->mem->probmem, scip->set, scip->stat, scip->transprob,
4657  scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable,
4658  var, newbound, SCIP_BOUNDTYPE_LOWER, FALSE) );
4659 
4661  {
4662  SCIP_Bool infeasible;
4663 
4664  SCIP_CALL( SCIPchgVarType(scip, var, SCIP_VARTYPE_BINARY, &infeasible) );
4665  assert(!infeasible);
4666  }
4667  break;
4668  }
4669  /*lint -fallthrough*/
4670  case SCIP_STAGE_SOLVING:
4672  scip->transprob, scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue,
4673  scip->cliquetable, var, newbound,
4675  break;
4676 
4677  default:
4678  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
4679  return SCIP_INVALIDCALL;
4680  } /*lint !e788*/
4681 
4682  return SCIP_OKAY;
4683 }
4684 
4685 /** depending on SCIP's stage, changes upper bound of variable in the problem, in preprocessing, or in current node;
4686  * if possible, adjusts bound to integral value; doesn't store any inference information in the bound change, such
4687  * that in conflict analysis, this change is treated like a branching decision
4688  *
4689  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
4690  * SCIPgetVars()) gets resorted.
4691  *
4692  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4693  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4694  *
4695  * @pre This method can be called if @p scip is in one of the following stages:
4696  * - \ref SCIP_STAGE_PROBLEM
4697  * - \ref SCIP_STAGE_TRANSFORMING
4698  * - \ref SCIP_STAGE_PRESOLVING
4699  * - \ref SCIP_STAGE_SOLVING
4700  *
4701  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
4702  */
4704  SCIP* scip, /**< SCIP data structure */
4705  SCIP_VAR* var, /**< variable to change the bound for */
4706  SCIP_Real newbound /**< new value for bound */
4707  )
4708 {
4709  SCIP_CALL( SCIPcheckStage(scip, "SCIPchgVarUb", FALSE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
4710 
4711  SCIPvarAdjustUb(var, scip->set, &newbound);
4712 
4713  /* ignore tightenings of upper bounds to -infinity during solving process */
4714  if( SCIPisInfinity(scip, -newbound) && SCIPgetStage(scip) == SCIP_STAGE_SOLVING )
4715  {
4716 #ifndef NDEBUG
4717  SCIPwarningMessage(scip, "ignore upper bound tightening for %s from %e to -infinity\n", SCIPvarGetName(var),
4718  SCIPvarGetUbLocal(var));
4719 #endif
4720  return SCIP_OKAY;
4721  }
4722 
4723  switch( scip->set->stage )
4724  {
4725  case SCIP_STAGE_PROBLEM:
4726  assert(!SCIPvarIsTransformed(var));
4727  SCIP_CALL( SCIPvarChgUbGlobal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
4728  scip->branchcand, scip->eventqueue, scip->cliquetable, newbound) );
4729  SCIP_CALL( SCIPvarChgUbLocal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
4730  scip->branchcand, scip->eventqueue, newbound) );
4731  SCIP_CALL( SCIPvarChgUbOriginal(var, scip->set, newbound) );
4732  break;
4733 
4735  case SCIP_STAGE_PRESOLVED:
4736  SCIP_CALL( SCIPvarChgUbGlobal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
4737  scip->branchcand, scip->eventqueue, scip->cliquetable, newbound) );
4738  break;
4739 
4740  case SCIP_STAGE_PRESOLVING:
4741  if( !SCIPinProbing(scip) )
4742  {
4743  assert(SCIPtreeGetCurrentDepth(scip->tree) == 0);
4744  assert(scip->tree->root == SCIPtreeGetCurrentNode(scip->tree));
4745 
4746  SCIP_CALL( SCIPnodeAddBoundchg(scip->tree->root, scip->mem->probmem, scip->set, scip->stat, scip->transprob,
4747  scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue,
4748  scip->cliquetable, var, newbound, SCIP_BOUNDTYPE_UPPER, FALSE) );
4749 
4751  {
4752  SCIP_Bool infeasible;
4753 
4754  SCIP_CALL( SCIPchgVarType(scip, var, SCIP_VARTYPE_BINARY, &infeasible) );
4755  assert(!infeasible);
4756  }
4757  break;
4758  }
4759  /*lint -fallthrough*/
4760  case SCIP_STAGE_SOLVING:
4762  scip->transprob, scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue,
4763  scip->cliquetable, var, newbound, SCIP_BOUNDTYPE_UPPER, FALSE) );
4764  break;
4765 
4766  default:
4767  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
4768  return SCIP_INVALIDCALL;
4769  } /*lint !e788*/
4770 
4771  return SCIP_OKAY;
4772 }
4773 
4774 /** changes lower bound of variable in the given node; if possible, adjust bound to integral value; doesn't store any
4775  * inference information in the bound change, such that in conflict analysis, this change is treated like a branching
4776  * decision
4777  *
4778  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4779  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4780  *
4781  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
4782  */
4784  SCIP* scip, /**< SCIP data structure */
4785  SCIP_NODE* node, /**< node to change bound at, or NULL for current node */
4786  SCIP_VAR* var, /**< variable to change the bound for */
4787  SCIP_Real newbound /**< new value for bound */
4788  )
4789 {
4790  SCIP_CALL( SCIPcheckStage(scip, "SCIPchgVarLbNode", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
4791 
4792  if( node == NULL )
4793  {
4794  SCIP_CALL( SCIPchgVarLb(scip, var, newbound) );
4795  }
4796  else
4797  {
4798  SCIPvarAdjustLb(var, scip->set, &newbound);
4799 
4800  /* ignore tightenings of lower bounds to +infinity during solving process */
4801  if( SCIPisInfinity(scip, newbound) && SCIPgetStage(scip) == SCIP_STAGE_SOLVING )
4802  {
4803 #ifndef NDEBUG
4804  SCIPwarningMessage(scip, "ignore lower bound tightening for %s from %e to +infinity\n", SCIPvarGetName(var),
4805  SCIPvarGetLbLocal(var));
4806 #endif
4807  return SCIP_OKAY;
4808  }
4809 
4810  SCIP_CALL( SCIPnodeAddBoundchg(node, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob,
4811  scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable, var, newbound,
4813  }
4814 
4815  return SCIP_OKAY;
4816 }
4817 
4818 /** changes upper bound of variable in the given node; if possible, adjust bound to integral value; doesn't store any
4819  * inference information in the bound change, such that in conflict analysis, this change is treated like a branching
4820  * decision
4821  *
4822  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4823  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4824  *
4825  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
4826  */
4828  SCIP* scip, /**< SCIP data structure */
4829  SCIP_NODE* node, /**< node to change bound at, or NULL for current node */
4830  SCIP_VAR* var, /**< variable to change the bound for */
4831  SCIP_Real newbound /**< new value for bound */
4832  )
4833 {
4834  SCIP_CALL( SCIPcheckStage(scip, "SCIPchgVarUbNode", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
4835 
4836  if( node == NULL )
4837  {
4838  SCIP_CALL( SCIPchgVarUb(scip, var, newbound) );
4839  }
4840  else
4841  {
4842  SCIPvarAdjustUb(var, scip->set, &newbound);
4843 
4844  /* ignore tightenings of upper bounds to -infinity during solving process */
4845  if( SCIPisInfinity(scip, -newbound) && SCIPgetStage(scip) == SCIP_STAGE_SOLVING )
4846  {
4847 #ifndef NDEBUG
4848  SCIPwarningMessage(scip, "ignore upper bound tightening for %s from %e to -infinity\n", SCIPvarGetName(var),
4849  SCIPvarGetUbLocal(var));
4850 #endif
4851  return SCIP_OKAY;
4852  }
4853 
4854  SCIP_CALL( SCIPnodeAddBoundchg(node, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob,
4855  scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable, var, newbound,
4857  }
4858 
4859  return SCIP_OKAY;
4860 }
4861 
4862 /** changes global lower bound of variable; if possible, adjust bound to integral value; also tightens the local bound,
4863  * if the global bound is better than the local bound
4864  *
4865  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
4866  * SCIPgetVars()) gets resorted.
4867  *
4868  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4869  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4870  *
4871  * @pre This method can be called if @p scip is in one of the following stages:
4872  * - \ref SCIP_STAGE_PROBLEM
4873  * - \ref SCIP_STAGE_TRANSFORMING
4874  * - \ref SCIP_STAGE_PRESOLVING
4875  * - \ref SCIP_STAGE_SOLVING
4876  *
4877  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
4878  */
4880  SCIP* scip, /**< SCIP data structure */
4881  SCIP_VAR* var, /**< variable to change the bound for */
4882  SCIP_Real newbound /**< new value for bound */
4883  )
4884 {
4885  SCIP_CALL( SCIPcheckStage(scip, "SCIPchgVarLbGlobal", FALSE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
4886 
4887  SCIPvarAdjustLb(var, scip->set, &newbound);
4888 
4889  /* ignore tightenings of lower bounds to +infinity during solving process */
4890  if( SCIPisInfinity(scip, newbound) && SCIPgetStage(scip) == SCIP_STAGE_SOLVING )
4891  {
4892 #ifndef NDEBUG
4893  SCIPwarningMessage(scip, "ignore lower bound tightening for %s from %e to +infinity\n", SCIPvarGetName(var),
4894  SCIPvarGetLbLocal(var));
4895 #endif
4896  return SCIP_OKAY;
4897  }
4898 
4899  switch( scip->set->stage )
4900  {
4901  case SCIP_STAGE_PROBLEM:
4902  assert(!SCIPvarIsTransformed(var));
4903  SCIP_CALL( SCIPvarChgLbGlobal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
4904  scip->branchcand, scip->eventqueue, scip->cliquetable, newbound) );
4905  SCIP_CALL( SCIPvarChgLbLocal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
4906  scip->branchcand, scip->eventqueue, newbound) );
4907  SCIP_CALL( SCIPvarChgLbOriginal(var, scip->set, newbound) );
4908  break;
4909 
4911  SCIP_CALL( SCIPvarChgLbGlobal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
4912  scip->branchcand, scip->eventqueue, scip->cliquetable, newbound) );
4913  break;
4914 
4915  case SCIP_STAGE_PRESOLVING:
4916  if( !SCIPinProbing(scip) )
4917  {
4918  assert(SCIPtreeGetCurrentDepth(scip->tree) == 0);
4919  assert(scip->tree->root == SCIPtreeGetCurrentNode(scip->tree));
4920 
4921  SCIP_CALL( SCIPnodeAddBoundchg(scip->tree->root, scip->mem->probmem, scip->set, scip->stat, scip->transprob,
4922  scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable, var, newbound,
4924 
4926  {
4927  SCIP_Bool infeasible;
4928 
4929  SCIP_CALL( SCIPchgVarType(scip, var, SCIP_VARTYPE_BINARY, &infeasible) );
4930  assert(!infeasible);
4931  }
4932  break;
4933  }
4934  /*lint -fallthrough*/
4935  case SCIP_STAGE_SOLVING:
4936  SCIP_CALL( SCIPnodeAddBoundchg(scip->tree->root, scip->mem->probmem, scip->set, scip->stat, scip->transprob,
4937  scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable, var, newbound,
4939  break;
4940 
4941  default:
4942  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
4943  return SCIP_INVALIDCALL;
4944  } /*lint !e788*/
4945 
4946  return SCIP_OKAY;
4947 }
4948 
4949 /** changes global upper bound of variable; if possible, adjust bound to integral value; also tightens the local bound,
4950  * if the global bound is better than the local bound
4951  *
4952  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
4953  * SCIPgetVars()) gets resorted.
4954  *
4955  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4956  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4957  *
4958  * @pre This method can be called if @p scip is in one of the following stages:
4959  * - \ref SCIP_STAGE_PROBLEM
4960  * - \ref SCIP_STAGE_TRANSFORMING
4961  * - \ref SCIP_STAGE_PRESOLVING
4962  * - \ref SCIP_STAGE_SOLVING
4963  *
4964  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
4965  */
4967  SCIP* scip, /**< SCIP data structure */
4968  SCIP_VAR* var, /**< variable to change the bound for */
4969  SCIP_Real newbound /**< new value for bound */
4970  )
4971 {
4972  SCIP_CALL( SCIPcheckStage(scip, "SCIPchgVarUbGlobal", FALSE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
4973 
4974  SCIPvarAdjustUb(var, scip->set, &newbound);
4975 
4976  /* ignore tightenings of upper bounds to -infinity during solving process */
4977  if( SCIPisInfinity(scip, -newbound) && SCIPgetStage(scip) == SCIP_STAGE_SOLVING )
4978  {
4979 #ifndef NDEBUG
4980  SCIPwarningMessage(scip, "ignore upper bound tightening for %s from %e to -infinity\n", SCIPvarGetName(var),
4981  SCIPvarGetUbLocal(var));
4982 #endif
4983  return SCIP_OKAY;
4984  }
4985 
4986  switch( scip->set->stage )
4987  {
4988  case SCIP_STAGE_PROBLEM:
4989  assert(!SCIPvarIsTransformed(var));
4990  SCIP_CALL( SCIPvarChgUbGlobal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
4991  scip->branchcand, scip->eventqueue, scip->cliquetable, newbound) );
4992  SCIP_CALL( SCIPvarChgUbLocal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
4993  scip->branchcand, scip->eventqueue, newbound) );
4994  SCIP_CALL( SCIPvarChgUbOriginal(var, scip->set, newbound) );
4995  break;
4996 
4998  SCIP_CALL( SCIPvarChgUbGlobal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
4999  scip->branchcand, scip->eventqueue, scip->cliquetable, newbound) );
5000  break;
5001 
5002  case SCIP_STAGE_PRESOLVING:
5003  if( !SCIPinProbing(scip) )
5004  {
5005  assert(SCIPtreeGetCurrentDepth(scip->tree) == 0);
5006  assert(scip->tree->root == SCIPtreeGetCurrentNode(scip->tree));
5007 
5008  SCIP_CALL( SCIPnodeAddBoundchg(scip->tree->root, scip->mem->probmem, scip->set, scip->stat, scip->transprob,
5009  scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable, var, newbound,
5011 
5013  {
5014  SCIP_Bool infeasible;
5015 
5016  SCIP_CALL( SCIPchgVarType(scip, var, SCIP_VARTYPE_BINARY, &infeasible) );
5017  assert(!infeasible);
5018  }
5019  break;
5020  }
5021  /*lint -fallthrough*/
5022  case SCIP_STAGE_SOLVING:
5023  SCIP_CALL( SCIPnodeAddBoundchg(scip->tree->root, scip->mem->probmem, scip->set, scip->stat, scip->transprob,
5024  scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable, var, newbound,
5026  break;
5027 
5028  default:
5029  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
5030  return SCIP_INVALIDCALL;
5031  } /*lint !e788*/
5032 
5033  return SCIP_OKAY;
5034 }
5035 
5036 /** changes lazy lower bound of the variable, this is only possible if the variable is not in the LP yet
5037  *
5038  * lazy bounds are bounds, that are enforced by constraints and the objective function; hence, these bounds do not need
5039  * to be put into the LP explicitly.
5040  *
5041  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5042  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5043  *
5044  * @pre This method can be called if @p scip is in one of the following stages:
5045  * - \ref SCIP_STAGE_PROBLEM
5046  * - \ref SCIP_STAGE_TRANSFORMING
5047  * - \ref SCIP_STAGE_TRANSFORMED
5048  * - \ref SCIP_STAGE_PRESOLVING
5049  * - \ref SCIP_STAGE_SOLVING
5050  *
5051  * @note lazy bounds are useful for branch-and-price since the corresponding variable bounds are not part of the LP
5052  */
5054  SCIP* scip, /**< SCIP data structure */
5055  SCIP_VAR* var, /**< problem variable */
5056  SCIP_Real lazylb /**< the lazy lower bound to be set */
5057  )
5058 {
5059  assert(scip != NULL);
5060  assert(var != NULL);
5061 
5062  SCIP_CALL( SCIPcheckStage(scip, "SCIPchgVarLbLazy", FALSE, TRUE, TRUE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
5063 
5064  SCIP_CALL( SCIPvarChgLbLazy(var, scip->set, lazylb) );
5065 
5066  return SCIP_OKAY;
5067 }
5068 
5069 /** changes lazy upper bound of the variable, this is only possible if the variable is not in the LP yet
5070  *
5071  * lazy bounds are bounds, that are enforced by constraints and the objective function; hence, these bounds do not need
5072  * to be put into the LP explicitly.
5073  *
5074  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5075  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5076  *
5077  * @pre This method can be called if @p scip is in one of the following stages:
5078  * - \ref SCIP_STAGE_PROBLEM
5079  * - \ref SCIP_STAGE_TRANSFORMING
5080  * - \ref SCIP_STAGE_TRANSFORMED
5081  * - \ref SCIP_STAGE_PRESOLVING
5082  * - \ref SCIP_STAGE_SOLVING
5083  *
5084  * @note lazy bounds are useful for branch-and-price since the corresponding variable bounds are not part of the LP
5085  */
5087  SCIP* scip, /**< SCIP data structure */
5088  SCIP_VAR* var, /**< problem variable */
5089  SCIP_Real lazyub /**< the lazy lower bound to be set */
5090  )
5091 {
5092  assert(scip != NULL);
5093  assert(var != NULL);
5094 
5095  SCIP_CALL( SCIPcheckStage(scip, "SCIPchgVarUbLazy", FALSE, TRUE, TRUE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
5096 
5097  SCIP_CALL( SCIPvarChgUbLazy(var, scip->set, lazyub) );
5098 
5099  return SCIP_OKAY;
5100 }
5101 
5102 /** changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter
5103  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
5104  * doesn't store any inference information in the bound change, such that in conflict analysis, this change
5105  * is treated like a branching decision
5106  *
5107  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
5108  * SCIPgetVars()) gets resorted.
5109  *
5110  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5111  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5112  *
5113  * @pre This method can be called if @p scip is in one of the following stages:
5114  * - \ref SCIP_STAGE_PROBLEM
5115  * - \ref SCIP_STAGE_PRESOLVING
5116  * - \ref SCIP_STAGE_SOLVING
5117  *
5118  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
5119  */
5121  SCIP* scip, /**< SCIP data structure */
5122  SCIP_VAR* var, /**< variable to change the bound for */
5123  SCIP_Real newbound, /**< new value for bound */
5124  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
5125  SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */
5126  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
5127  )
5128 {
5129  SCIP_Real lb;
5130  SCIP_Real ub;
5131 
5132  assert(infeasible != NULL);
5133  /** @todo if needed provide pending local/global bound changes that will be flushed after leaving diving mode (as in struct_tree.h) */
5134  assert(!SCIPinDive(scip));
5135 
5136  SCIP_CALL( SCIPcheckStage(scip, "SCIPtightenVarLb", FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
5137 
5138  *infeasible = FALSE;
5139  if( tightened != NULL )
5140  *tightened = FALSE;
5141 
5142  SCIPvarAdjustLb(var, scip->set, &newbound);
5143 
5144  /* ignore tightenings of lower bounds to +infinity during solving process */
5145  if( SCIPisInfinity(scip, newbound) && SCIPgetStage(scip) == SCIP_STAGE_SOLVING )
5146  {
5147 #ifndef NDEBUG
5148  SCIPwarningMessage(scip, "ignore lower bound tightening for %s from %e to +infinity\n", SCIPvarGetName(var),
5149  SCIPvarGetLbLocal(var));
5150 #endif
5151  return SCIP_OKAY;
5152  }
5153 
5154  /* get current bounds */
5155  lb = SCIPcomputeVarLbLocal(scip, var);
5156  ub = SCIPcomputeVarUbLocal(scip, var);
5157  assert(SCIPsetIsLE(scip->set, lb, ub));
5158 
5159  if( SCIPsetIsFeasGT(scip->set, newbound, ub) )
5160  {
5161  *infeasible = TRUE;
5162  return SCIP_OKAY;
5163  }
5164  newbound = MIN(newbound, ub);
5165 
5166  if( (force && SCIPsetIsLE(scip->set, newbound, lb)) || (!force && !SCIPsetIsLbBetter(scip->set, newbound, lb, ub)) )
5167  return SCIP_OKAY;
5168 
5169  switch( scip->set->stage )
5170  {
5171  case SCIP_STAGE_PROBLEM:
5172  assert(!SCIPvarIsTransformed(var));
5173  SCIP_CALL( SCIPvarChgLbGlobal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
5174  scip->branchcand, scip->eventqueue, scip->cliquetable, newbound) );
5175  SCIP_CALL( SCIPvarChgLbLocal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
5176  scip->branchcand, scip->eventqueue, newbound) );
5177  SCIP_CALL( SCIPvarChgLbOriginal(var, scip->set, newbound) );
5178  break;
5180  SCIP_CALL( SCIPvarChgLbGlobal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
5181  scip->branchcand, scip->eventqueue, scip->cliquetable, newbound) );
5182  break;
5183  case SCIP_STAGE_PRESOLVING:
5184  if( !SCIPinProbing(scip) )
5185  {
5186  assert(SCIPtreeGetCurrentDepth(scip->tree) == 0);
5187  assert(scip->tree->root == SCIPtreeGetCurrentNode(scip->tree));
5188 
5189  SCIP_CALL( SCIPnodeAddBoundchg(scip->tree->root, scip->mem->probmem, scip->set, scip->stat, scip->transprob,
5190  scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable, var, newbound,
5192 
5194  {
5195  SCIP_CALL( SCIPchgVarType(scip, var, SCIP_VARTYPE_BINARY, infeasible) );
5196  assert(!(*infeasible));
5197  }
5198  break;
5199  }
5200  /*lint -fallthrough*/
5201  case SCIP_STAGE_SOLVING:
5203  scip->transprob, scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable,
5204  var, newbound, SCIP_BOUNDTYPE_LOWER, FALSE) );
5205  break;
5206 
5207  default:
5208  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
5209  return SCIP_INVALIDCALL;
5210  } /*lint !e788*/
5211 
5212  if( tightened != NULL )
5213  *tightened = TRUE;
5214 
5215  return SCIP_OKAY;
5216 }
5217 
5218 /** changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter
5219  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
5220  * doesn't store any inference information in the bound change, such that in conflict analysis, this change
5221  * is treated like a branching decision
5222  *
5223  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
5224  * SCIPgetVars()) gets resorted.
5225  *
5226  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5227  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5228  *
5229  * @pre This method can be called if @p scip is in one of the following stages:
5230  * - \ref SCIP_STAGE_PROBLEM
5231  * - \ref SCIP_STAGE_PRESOLVING
5232  * - \ref SCIP_STAGE_SOLVING
5233  *
5234  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
5235  */
5237  SCIP* scip, /**< SCIP data structure */
5238  SCIP_VAR* var, /**< variable to change the bound for */
5239  SCIP_Real newbound, /**< new value for bound */
5240  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
5241  SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */
5242  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
5243  )
5244 {
5245  SCIP_Real lb;
5246  SCIP_Real ub;
5247 
5248  assert(infeasible != NULL);
5249  /** @todo if needed provide pending local/global bound changes that will be flushed after leaving diving mode (as in struct_tree.h) */
5250  assert(!SCIPinDive(scip));
5251 
5252  SCIP_CALL( SCIPcheckStage(scip, "SCIPtightenVarUb", FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
5253 
5254  *infeasible = FALSE;
5255  if( tightened != NULL )
5256  *tightened = FALSE;
5257 
5258  SCIPvarAdjustUb(var, scip->set, &newbound);
5259 
5260  /* ignore tightenings of upper bounds to -infinity during solving process */
5261  if( SCIPisInfinity(scip, -newbound) && SCIPgetStage(scip) == SCIP_STAGE_SOLVING )
5262  {
5263 #ifndef NDEBUG
5264  SCIPwarningMessage(scip, "ignore upper bound tightening for %s from %e to -infinity\n", SCIPvarGetName(var),
5265  SCIPvarGetUbLocal(var));
5266 #endif
5267  return SCIP_OKAY;
5268  }
5269 
5270  /* get current bounds */
5271  lb = SCIPcomputeVarLbLocal(scip, var);
5272  ub = SCIPcomputeVarUbLocal(scip, var);
5273  assert(SCIPsetIsLE(scip->set, lb, ub));
5274 
5275  if( SCIPsetIsFeasLT(scip->set, newbound, lb) )
5276  {
5277  *infeasible = TRUE;
5278  return SCIP_OKAY;
5279  }
5280  newbound = MAX(newbound, lb);
5281 
5282  if( (force && SCIPsetIsGE(scip->set, newbound, ub)) || (!force && !SCIPsetIsUbBetter(scip->set, newbound, lb, ub)) )
5283  return SCIP_OKAY;
5284 
5285  switch( scip->set->stage )
5286  {
5287  case SCIP_STAGE_PROBLEM:
5288  assert(!SCIPvarIsTransformed(var));
5289  SCIP_CALL( SCIPvarChgUbGlobal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
5290  scip->branchcand, scip->eventqueue, scip->cliquetable, newbound) );
5291  SCIP_CALL( SCIPvarChgUbLocal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
5292  scip->branchcand, scip->eventqueue, newbound) );
5293  SCIP_CALL( SCIPvarChgUbOriginal(var, scip->set, newbound) );
5294  break;
5296  SCIP_CALL( SCIPvarChgUbGlobal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
5297  scip->branchcand, scip->eventqueue, scip->cliquetable, newbound) );
5298  break;
5299  case SCIP_STAGE_PRESOLVING:
5300  if( !SCIPinProbing(scip) )
5301  {
5302  assert(SCIPtreeGetCurrentDepth(scip->tree) == 0);
5303  assert(scip->tree->root == SCIPtreeGetCurrentNode(scip->tree));
5304 
5305  SCIP_CALL( SCIPnodeAddBoundchg(scip->tree->root, scip->mem->probmem, scip->set, scip->stat, scip->transprob,
5306  scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable, var, newbound,
5308 
5310  {
5311  SCIP_CALL( SCIPchgVarType(scip, var, SCIP_VARTYPE_BINARY, infeasible) );
5312  assert(!(*infeasible));
5313  }
5314  break;
5315  }
5316  /*lint -fallthrough*/
5317  case SCIP_STAGE_SOLVING:
5319  scip->transprob, scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue,
5320  scip->cliquetable, var, newbound, SCIP_BOUNDTYPE_UPPER, FALSE) );
5321  break;
5322 
5323  default:
5324  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
5325  return SCIP_INVALIDCALL;
5326  } /*lint !e788*/
5327 
5328  if( tightened != NULL )
5329  *tightened = TRUE;
5330 
5331  return SCIP_OKAY;
5332 }
5333 
5334 /** fixes variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening
5335  * epsilon) than the current bound; if possible, adjusts bound to integral value; the given inference constraint is
5336  * stored, such that the conflict analysis is able to find out the reason for the deduction of the bound change
5337  *
5338  * @note In presolving stage when not in probing mode the variable will be fixed directly, otherwise this method
5339  * changes first the lowerbound by calling SCIPinferVarLbCons and second the upperbound by calling
5340  * SCIPinferVarUbCons
5341  *
5342  * @note If SCIP is in presolving stage, it can happen that the internal variable array (which get be accessed via
5343  * SCIPgetVars()) gets resorted.
5344  *
5345  * @note During presolving, an integer variable which bound changes to {0,1} is upgraded to a binary variable.
5346  */
5348  SCIP* scip, /**< SCIP data structure */
5349  SCIP_VAR* var, /**< variable to change the bound for */
5350  SCIP_Real fixedval, /**< new value for fixation */
5351  SCIP_CONS* infercons, /**< constraint that deduced the bound change */
5352  int inferinfo, /**< user information for inference to help resolving the conflict */
5353  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
5354  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
5355  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
5356  )
5357 {
5358  assert(scip != NULL);
5359  assert(var != NULL);
5360  assert(infeasible != NULL);
5361 
5362  SCIP_CALL( SCIPcheckStage(scip, "SCIPinferVarFixCons", FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
5363 
5364  if( tightened != NULL )
5365  *tightened = FALSE;
5366 
5367  /* in presolving case we take the shortcut to directly fix the variables */
5368  if( SCIPgetStage(scip) == SCIP_STAGE_PRESOLVING && SCIPtreeGetCurrentDepth(scip->tree) == 0 )
5369  {
5370  SCIP_Bool fixed;
5371 
5372  SCIP_CALL( SCIPvarFix(var, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob,
5373  scip->primal, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable,
5374  fixedval, infeasible, &fixed) );
5375 
5376  if( tightened != NULL )
5377  *tightened = fixed;
5378  }
5379  /* otherwise we use the lb and ub methods */
5380  else
5381  {
5382  SCIP_Bool lbtightened;
5383 
5384  SCIP_CALL( SCIPinferVarLbCons(scip, var, fixedval, infercons, inferinfo, force, infeasible, &lbtightened) );
5385 
5386  if( ! (*infeasible) )
5387  {
5388  SCIP_CALL( SCIPinferVarUbCons(scip, var, fixedval, infercons, inferinfo, force, infeasible, tightened) );
5389 
5390  if( tightened != NULL )
5391  *tightened |= lbtightened;
5392  }
5393  }
5394 
5395  return SCIP_OKAY;
5396 }
5397 
5398 /** changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter
5399  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
5400  * the given inference constraint is stored, such that the conflict analysis is able to find out the reason
5401  * for the deduction of the bound change
5402  *
5403  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
5404  * SCIPgetVars()) gets resorted.
5405  *
5406  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5407  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5408  *
5409  * @pre This method can be called if @p scip is in one of the following stages:
5410  * - \ref SCIP_STAGE_PROBLEM
5411  * - \ref SCIP_STAGE_PRESOLVING
5412  * - \ref SCIP_STAGE_SOLVING
5413  *
5414  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
5415  */
5417  SCIP* scip, /**< SCIP data structure */
5418  SCIP_VAR* var, /**< variable to change the bound for */
5419  SCIP_Real newbound, /**< new value for bound */
5420  SCIP_CONS* infercons, /**< constraint that deduced the bound change */
5421  int inferinfo, /**< user information for inference to help resolving the conflict */
5422  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
5423  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
5424  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
5425  )
5426 {
5427  SCIP_Real lb;
5428  SCIP_Real ub;
5429 
5430  assert(infeasible != NULL);
5431 
5432  SCIP_CALL( SCIPcheckStage(scip, "SCIPinferVarLbCons", FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
5433 
5434  *infeasible = FALSE;
5435  if( tightened != NULL )
5436  *tightened = FALSE;
5437 
5438  SCIPvarAdjustLb(var, scip->set, &newbound);
5439 
5440  /* ignore tightenings of lower bounds to +infinity during solving process */
5441  if( SCIPisInfinity(scip, newbound) && SCIPgetStage(scip) == SCIP_STAGE_SOLVING )
5442  {
5443 #ifndef NDEBUG
5444  SCIPwarningMessage(scip, "ignore lower bound tightening for %s from %e to +infinity\n", SCIPvarGetName(var),
5445  SCIPvarGetLbLocal(var));
5446 #endif
5447  return SCIP_OKAY;
5448  }
5449 
5450  /* get current bounds */
5451  lb = SCIPvarGetLbLocal(var);
5452  ub = SCIPvarGetUbLocal(var);
5453  assert(SCIPsetIsLE(scip->set, lb, ub));
5454 
5455  if( SCIPsetIsFeasGT(scip->set, newbound, ub) )
5456  {
5457  *infeasible = TRUE;
5458  return SCIP_OKAY;
5459  }
5460  newbound = MIN(newbound, ub);
5461 
5462  if( (force && SCIPsetIsLE(scip->set, newbound, lb)) || (!force && !SCIPsetIsLbBetter(scip->set, newbound, lb, ub)) )
5463  return SCIP_OKAY;
5464 
5465  switch( scip->set->stage )
5466  {
5467  case SCIP_STAGE_PROBLEM:
5468  assert(!SCIPvarIsTransformed(var));
5469  SCIP_CALL( SCIPvarChgLbGlobal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
5470  scip->branchcand, scip->eventqueue, scip->cliquetable, newbound) );
5471  SCIP_CALL( SCIPvarChgLbLocal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
5472  scip->branchcand, scip->eventqueue, newbound) );
5473  SCIP_CALL( SCIPvarChgLbOriginal(var, scip->set, newbound) );
5474  break;
5475 
5476  case SCIP_STAGE_PRESOLVING:
5477  if( !SCIPinProbing(scip) )
5478  {
5479  assert(SCIPtreeGetCurrentDepth(scip->tree) == 0);
5480  assert(scip->tree->root == SCIPtreeGetCurrentNode(scip->tree));
5481 
5482  SCIP_CALL( SCIPnodeAddBoundchg(scip->tree->root, scip->mem->probmem, scip->set, scip->stat, scip->transprob,
5483  scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable, var, newbound,
5485 
5487  {
5488  SCIP_CALL( SCIPchgVarType(scip, var, SCIP_VARTYPE_BINARY, infeasible) );
5489  assert(!(*infeasible));
5490  }
5491  break;
5492  }
5493  /*lint -fallthrough*/
5494  case SCIP_STAGE_SOLVING:
5496  scip->transprob, scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue,
5497  scip->cliquetable, var, newbound, SCIP_BOUNDTYPE_LOWER, infercons, NULL, inferinfo, FALSE) );
5498  break;
5499 
5500  default:
5501  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
5502  return SCIP_INVALIDCALL;
5503  } /*lint !e788*/
5504 
5505  if( tightened != NULL )
5506  *tightened = TRUE;
5507 
5508  return SCIP_OKAY;
5509 }
5510 
5511 /** changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter
5512  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
5513  * the given inference constraint is stored, such that the conflict analysis is able to find out the reason
5514  * for the deduction of the bound change
5515  *
5516  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
5517  * SCIPgetVars()) gets resorted.
5518  *
5519  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5520  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5521  *
5522  * @pre This method can be called if @p scip is in one of the following stages:
5523  * - \ref SCIP_STAGE_PROBLEM
5524  * - \ref SCIP_STAGE_PRESOLVING
5525  * - \ref SCIP_STAGE_SOLVING
5526  *
5527  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
5528  */
5530  SCIP* scip, /**< SCIP data structure */
5531  SCIP_VAR* var, /**< variable to change the bound for */
5532  SCIP_Real newbound, /**< new value for bound */
5533  SCIP_CONS* infercons, /**< constraint that deduced the bound change */
5534  int inferinfo, /**< user information for inference to help resolving the conflict */
5535  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
5536  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
5537  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
5538  )
5539 {
5540  SCIP_Real lb;
5541  SCIP_Real ub;
5542 
5543  assert(infeasible != NULL);
5544 
5545  SCIP_CALL( SCIPcheckStage(scip, "SCIPinferVarUbCons", FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
5546 
5547  *infeasible = FALSE;
5548  if( tightened != NULL )
5549  *tightened = FALSE;
5550 
5551  SCIPvarAdjustUb(var, scip->set, &newbound);
5552 
5553  /* ignore tightenings of upper bounds to -infinity during solving process */
5554  if( SCIPisInfinity(scip, -newbound) && SCIPgetStage(scip) == SCIP_STAGE_SOLVING )
5555  {
5556 #ifndef NDEBUG
5557  SCIPwarningMessage(scip, "ignore upper bound tightening for %s from %e to -infinity\n", SCIPvarGetName(var),
5558  SCIPvarGetUbLocal(var));
5559 #endif
5560  return SCIP_OKAY;
5561  }
5562 
5563  /* get current bounds */
5564  lb = SCIPvarGetLbLocal(var);
5565  ub = SCIPvarGetUbLocal(var);
5566  assert(SCIPsetIsLE(scip->set, lb, ub));
5567 
5568  if( SCIPsetIsFeasLT(scip->set, newbound, lb) )
5569  {
5570  *infeasible = TRUE;
5571  return SCIP_OKAY;
5572  }
5573  newbound = MAX(newbound, lb);
5574 
5575  if( (force && SCIPsetIsGE(scip->set, newbound, ub)) || (!force && !SCIPsetIsUbBetter(scip->set, newbound, lb, ub)) )
5576  return SCIP_OKAY;
5577 
5578  switch( scip->set->stage )
5579  {
5580  case SCIP_STAGE_PROBLEM:
5581  assert(!SCIPvarIsTransformed(var));
5582  SCIP_CALL( SCIPvarChgUbGlobal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
5583  scip->branchcand, scip->eventqueue, scip->cliquetable, newbound) );
5584  SCIP_CALL( SCIPvarChgUbLocal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
5585  scip->branchcand, scip->eventqueue, newbound) );
5586  SCIP_CALL( SCIPvarChgUbOriginal(var, scip->set, newbound) );
5587  break;
5588 
5589  case SCIP_STAGE_PRESOLVING:
5590  if( !SCIPinProbing(scip) )
5591  {
5592  assert(SCIPtreeGetCurrentDepth(scip->tree) == 0);
5593  assert(scip->tree->root == SCIPtreeGetCurrentNode(scip->tree));
5594 
5595  SCIP_CALL( SCIPnodeAddBoundchg(scip->tree->root, scip->mem->probmem, scip->set, scip->stat, scip->transprob,
5596  scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable, var, newbound,
5598 
5600  {
5601  SCIP_CALL( SCIPchgVarType(scip, var, SCIP_VARTYPE_BINARY, infeasible) );
5602  assert(!(*infeasible));
5603  }
5604  break;
5605  }
5606  /*lint -fallthrough*/
5607  case SCIP_STAGE_SOLVING:
5609  scip->transprob, scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue,
5610  scip->cliquetable, var, newbound, SCIP_BOUNDTYPE_UPPER, infercons, NULL, inferinfo, FALSE) );
5611  break;
5612 
5613  default:
5614  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
5615  return SCIP_INVALIDCALL;
5616  } /*lint !e788*/
5617 
5618  if( tightened != NULL )
5619  *tightened = TRUE;
5620 
5621  return SCIP_OKAY;
5622 }
5623 
5624 /** depending on SCIP's stage, fixes binary variable in the problem, in preprocessing, or in current node;
5625  * the given inference constraint is stored, such that the conflict analysis is able to find out the reason for the
5626  * deduction of the fixing
5627  *
5628  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5629  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5630  *
5631  * @pre This method can be called if @p scip is in one of the following stages:
5632  * - \ref SCIP_STAGE_PROBLEM
5633  * - \ref SCIP_STAGE_PRESOLVING
5634  * - \ref SCIP_STAGE_SOLVING
5635  */
5637  SCIP* scip, /**< SCIP data structure */
5638  SCIP_VAR* var, /**< binary variable to fix */
5639  SCIP_Bool fixedval, /**< value to fix binary variable to */
5640  SCIP_CONS* infercons, /**< constraint that deduced the fixing */
5641  int inferinfo, /**< user information for inference to help resolving the conflict */
5642  SCIP_Bool* infeasible, /**< pointer to store whether the fixing is infeasible */
5643  SCIP_Bool* tightened /**< pointer to store whether the fixing tightened the local bounds, or NULL */
5644  )
5645 {
5646  SCIP_Real lb;
5647  SCIP_Real ub;
5648 
5649  assert(SCIPvarIsBinary(var));
5650  assert(fixedval == TRUE || fixedval == FALSE);
5651  assert(infeasible != NULL);
5652 
5653  SCIP_CALL( SCIPcheckStage(scip, "SCIPinferBinvarCons", FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
5654 
5655  *infeasible = FALSE;
5656  if( tightened != NULL )
5657  *tightened = FALSE;
5658 
5659  /* get current bounds */
5660  lb = SCIPvarGetLbLocal(var);
5661  ub = SCIPvarGetUbLocal(var);
5662  assert(SCIPsetIsEQ(scip->set, lb, 0.0) || SCIPsetIsEQ(scip->set, lb, 1.0));
5663  assert(SCIPsetIsEQ(scip->set, ub, 0.0) || SCIPsetIsEQ(scip->set, ub, 1.0));
5664  assert(SCIPsetIsLE(scip->set, lb, ub));
5665 
5666  /* check, if variable is already fixed */
5667  if( (lb > 0.5) || (ub < 0.5) )
5668  {
5669  *infeasible = (fixedval == (lb < 0.5));
5670 
5671  return SCIP_OKAY;
5672  }
5673 
5674  /* apply the fixing */
5675  switch( scip->set->stage )
5676  {
5677  case SCIP_STAGE_PROBLEM:
5678  assert(!SCIPvarIsTransformed(var));
5679  if( fixedval == TRUE )
5680  {
5681  SCIP_CALL( SCIPchgVarLb(scip, var, 1.0) );
5682  }
5683  else
5684  {
5685  SCIP_CALL( SCIPchgVarUb(scip, var, 0.0) );
5686  }
5687  break;
5688 
5689  case SCIP_STAGE_PRESOLVING:
5690  if( SCIPtreeGetCurrentDepth(scip->tree) == 0 )
5691  {
5692  SCIP_Bool fixed;
5693 
5694  SCIP_CALL( SCIPvarFix(var, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob,
5695  scip->primal, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable,
5696  (SCIP_Real)fixedval, infeasible, &fixed) );
5697  break;
5698  }
5699  /*lint -fallthrough*/
5700  case SCIP_STAGE_SOLVING:
5701  if( fixedval == TRUE )
5702  {
5704  scip->transprob, scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue,
5705  scip->cliquetable, var, 1.0, SCIP_BOUNDTYPE_LOWER, infercons, NULL, inferinfo, FALSE) );
5706  }
5707  else
5708  {
5710  scip->transprob, scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue,
5711  scip->cliquetable, var, 0.0, SCIP_BOUNDTYPE_UPPER, infercons, NULL, inferinfo, FALSE) );
5712  }
5713  break;
5714 
5715  default:
5716  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
5717  return SCIP_INVALIDCALL;
5718  } /*lint !e788*/
5719 
5720  if( tightened != NULL )
5721  *tightened = TRUE;
5722 
5723  return SCIP_OKAY;
5724 }
5725 
5726 /** fixes variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening
5727  * epsilon) than the current bound; if possible, adjusts bound to integral value; the given inference constraint is
5728  * stored, such that the conflict analysis is able to find out the reason for the deduction of the bound change
5729  *
5730  * @note In presolving stage when not in probing mode the variable will be fixed directly, otherwise this method
5731  * changes first the lowerbound by calling SCIPinferVarLbProp and second the upperbound by calling
5732  * SCIPinferVarUbProp
5733  *
5734  * @note If SCIP is in presolving stage, it can happen that the internal variable array (which get be accessed via
5735  * SCIPgetVars()) gets resorted.
5736  *
5737  * @note During presolving, an integer variable which bound changes to {0,1} is upgraded to a binary variable.
5738  */
5740  SCIP* scip, /**< SCIP data structure */
5741  SCIP_VAR* var, /**< variable to change the bound for */
5742  SCIP_Real fixedval, /**< new value for fixation */
5743  SCIP_PROP* inferprop, /**< propagator that deduced the bound change */
5744  int inferinfo, /**< user information for inference to help resolving the conflict */
5745  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
5746  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
5747  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
5748  )
5749 {
5750  assert(scip != NULL);
5751  assert(var != NULL);
5752  assert(infeasible != NULL);
5753 
5754  SCIP_CALL( SCIPcheckStage(scip, "SCIPinferVarFixProp", FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
5755 
5756  if( tightened != NULL )
5757  *tightened = FALSE;
5758 
5759  /* in presolving case we take the shortcut to directly fix the variables */
5760  if( SCIPgetStage(scip) == SCIP_STAGE_PRESOLVING && SCIPtreeGetCurrentDepth(scip->tree) == 0 )
5761  {
5762  SCIP_Bool fixed;
5763 
5764  SCIP_CALL( SCIPvarFix(var, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob,
5765  scip->primal, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable,
5766  fixedval, infeasible, &fixed) );
5767 
5768  if( tightened != NULL )
5769  *tightened = fixed;
5770  }
5771  /* otherwise we use the lb and ub methods */
5772  else
5773  {
5774  SCIP_Bool lbtightened;
5775 
5776  SCIP_CALL( SCIPinferVarLbProp(scip, var, fixedval, inferprop, inferinfo, force, infeasible, &lbtightened) );
5777 
5778  if( ! (*infeasible) )
5779  {
5780  SCIP_CALL( SCIPinferVarUbProp(scip, var, fixedval, inferprop, inferinfo, force, infeasible, tightened) );
5781 
5782  if( tightened != NULL )
5783  *tightened |= lbtightened;
5784  }
5785  }
5786 
5787  return SCIP_OKAY;
5788 }
5789 
5790 /** changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter
5791  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
5792  * the given inference propagator is stored, such that the conflict analysis is able to find out the reason
5793  * for the deduction of the bound change
5794  *
5795  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
5796  * SCIPgetVars()) gets resorted.
5797  *
5798  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5799  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5800  *
5801  * @pre This method can be called if @p scip is in one of the following stages:
5802  * - \ref SCIP_STAGE_PROBLEM
5803  * - \ref SCIP_STAGE_PRESOLVING
5804  * - \ref SCIP_STAGE_SOLVING
5805  *
5806  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
5807  */
5809  SCIP* scip, /**< SCIP data structure */
5810  SCIP_VAR* var, /**< variable to change the bound for */
5811  SCIP_Real newbound, /**< new value for bound */
5812  SCIP_PROP* inferprop, /**< propagator that deduced the bound change */
5813  int inferinfo, /**< user information for inference to help resolving the conflict */
5814  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
5815  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
5816  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
5817  )
5818 {
5819  SCIP_Real lb;
5820  SCIP_Real ub;
5821 
5822  assert(infeasible != NULL);
5823 
5824  SCIP_CALL( SCIPcheckStage(scip, "SCIPinferVarLbProp", FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
5825 
5826  *infeasible = FALSE;
5827  if( tightened != NULL )
5828  *tightened = FALSE;
5829 
5830  SCIPvarAdjustLb(var, scip->set, &newbound);
5831 
5832  /* ignore tightenings of lower bounds to +infinity during solving process */
5833  if( SCIPisInfinity(scip, newbound) && SCIPgetStage(scip) == SCIP_STAGE_SOLVING )
5834  {
5835 #ifndef NDEBUG
5836  SCIPwarningMessage(scip, "ignore lower bound tightening for %s from %e to +infinity\n", SCIPvarGetName(var),
5837  SCIPvarGetLbLocal(var));
5838 #endif
5839  return SCIP_OKAY;
5840  }
5841 
5842  /* get current bounds */
5843  lb = SCIPvarGetLbLocal(var);
5844  ub = SCIPvarGetUbLocal(var);
5845  assert(SCIPsetIsLE(scip->set, lb, ub));
5846 
5847  if( SCIPsetIsFeasGT(scip->set, newbound, ub) )
5848  {
5849  *infeasible = TRUE;
5850  return SCIP_OKAY;
5851  }
5852  newbound = MIN(newbound, ub);
5853 
5854  if( (!force && !SCIPsetIsLbBetter(scip->set, newbound, lb, ub))
5855  || SCIPsetIsLE(scip->set, newbound, lb) )
5856  return SCIP_OKAY;
5857 
5858  switch( scip->set->stage )
5859  {
5860  case SCIP_STAGE_PROBLEM:
5861  assert(!SCIPvarIsTransformed(var));
5862  SCIP_CALL( SCIPvarChgLbGlobal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
5863  scip->branchcand, scip->eventqueue, scip->cliquetable, newbound) );
5864  SCIP_CALL( SCIPvarChgLbLocal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
5865  scip->branchcand, scip->eventqueue, newbound) );
5866  SCIP_CALL( SCIPvarChgLbOriginal(var, scip->set, newbound) );
5867  break;
5868 
5869  case SCIP_STAGE_PRESOLVING:
5870  if( !SCIPinProbing(scip) )
5871  {
5872  assert(SCIPtreeGetCurrentDepth(scip->tree) == 0);
5873  assert(scip->tree->root == SCIPtreeGetCurrentNode(scip->tree));
5874 
5875  SCIP_CALL( SCIPnodeAddBoundchg(scip->tree->root, scip->mem->probmem, scip->set, scip->stat, scip->transprob,
5876  scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable, var, newbound,
5878 
5880  {
5881  SCIP_CALL( SCIPchgVarType(scip, var, SCIP_VARTYPE_BINARY, infeasible) );
5882  assert(!(*infeasible));
5883  }
5884  break;
5885  }
5886  /*lint -fallthrough*/
5887  case SCIP_STAGE_SOLVING:
5889  scip->transprob, scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue,
5890  scip->cliquetable, var, newbound, SCIP_BOUNDTYPE_LOWER, NULL, inferprop, inferinfo, FALSE) );
5891  break;
5892 
5893  default:
5894  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
5895  return SCIP_INVALIDCALL;
5896  } /*lint !e788*/
5897 
5898  if( tightened != NULL )
5899  *tightened = TRUE;
5900 
5901  return SCIP_OKAY;
5902 }
5903 
5904 /** changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter
5905  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
5906  * the given inference propagator is stored, such that the conflict analysis is able to find out the reason
5907  * for the deduction of the bound change
5908  *
5909  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
5910  * SCIPgetVars()) gets resorted.
5911  *
5912  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5913  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5914  *
5915  * @pre This method can be called if @p scip is in one of the following stages:
5916  * - \ref SCIP_STAGE_PROBLEM
5917  * - \ref SCIP_STAGE_PRESOLVING
5918  * - \ref SCIP_STAGE_SOLVING
5919  *
5920  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
5921  */
5923  SCIP* scip, /**< SCIP data structure */
5924  SCIP_VAR* var, /**< variable to change the bound for */
5925  SCIP_Real newbound, /**< new value for bound */
5926  SCIP_PROP* inferprop, /**< propagator that deduced the bound change */
5927  int inferinfo, /**< user information for inference to help resolving the conflict */
5928  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
5929  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
5930  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
5931  )
5932 {
5933  SCIP_Real lb;
5934  SCIP_Real ub;
5935 
5936  assert(infeasible != NULL);
5937 
5938  SCIP_CALL( SCIPcheckStage(scip, "SCIPinferVarUbProp", FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
5939 
5940  *infeasible = FALSE;
5941  if( tightened != NULL )
5942  *tightened = FALSE;
5943 
5944  SCIPvarAdjustUb(var, scip->set, &newbound);
5945 
5946  /* ignore tightenings of upper bounds to -infinity during solving process */
5947  if( SCIPisInfinity(scip, -newbound) && SCIPgetStage(scip) == SCIP_STAGE_SOLVING )
5948  {
5949 #ifndef NDEBUG
5950  SCIPwarningMessage(scip, "ignore upper bound tightening for %s from %e to -infinity\n", SCIPvarGetName(var),
5951  SCIPvarGetUbLocal(var));
5952 #endif
5953  return SCIP_OKAY;
5954  }
5955 
5956  /* get current bounds */
5957  lb = SCIPvarGetLbLocal(var);
5958  ub = SCIPvarGetUbLocal(var);
5959  assert(SCIPsetIsLE(scip->set, lb, ub));
5960 
5961  if( SCIPsetIsFeasLT(scip->set, newbound, lb) )
5962  {
5963  *infeasible = TRUE;
5964  return SCIP_OKAY;
5965  }
5966  newbound = MAX(newbound, lb);
5967 
5968  if( (!force && !SCIPsetIsUbBetter(scip->set, newbound, lb, ub))
5969  || SCIPsetIsGE(scip->set, newbound, ub) )
5970  return SCIP_OKAY;
5971 
5972  switch( scip->set->stage )
5973  {
5974  case SCIP_STAGE_PROBLEM:
5975  assert(!SCIPvarIsTransformed(var));
5976  SCIP_CALL( SCIPvarChgUbGlobal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
5977  scip->branchcand, scip->eventqueue, scip->cliquetable, newbound) );
5978  SCIP_CALL( SCIPvarChgUbLocal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
5979  scip->branchcand, scip->eventqueue, newbound) );
5980  SCIP_CALL( SCIPvarChgUbOriginal(var, scip->set, newbound) );
5981  break;
5982 
5983  case SCIP_STAGE_PRESOLVING:
5984  if( !SCIPinProbing(scip) )
5985  {
5986  assert(SCIPtreeGetCurrentDepth(scip->tree) == 0);
5987  assert(scip->tree->root == SCIPtreeGetCurrentNode(scip->tree));
5988 
5989  SCIP_CALL( SCIPnodeAddBoundchg(scip->tree->root, scip->mem->probmem, scip->set, scip->stat, scip->transprob,
5990  scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable, var, newbound,
5992 
5994  {
5995  SCIP_CALL( SCIPchgVarType(scip, var, SCIP_VARTYPE_BINARY, infeasible) );
5996  assert(!(*infeasible));
5997  }
5998  break;
5999  }
6000  /*lint -fallthrough*/
6001  case SCIP_STAGE_SOLVING:
6003  scip->transprob, scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue,
6004  scip->cliquetable, var, newbound, SCIP_BOUNDTYPE_UPPER, NULL, inferprop, inferinfo, FALSE) );
6005  break;
6006 
6007  default:
6008  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
6009  return SCIP_INVALIDCALL;
6010  } /*lint !e788*/
6011 
6012  if( tightened != NULL )
6013  *tightened = TRUE;
6014 
6015  return SCIP_OKAY;
6016 }
6017 
6018 /** depending on SCIP's stage, fixes binary variable in the problem, in preprocessing, or in current node;
6019  * the given inference propagator is stored, such that the conflict analysis is able to find out the reason for the
6020  * deduction of the fixing
6021  *
6022  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6023  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6024  *
6025  * @pre This method can be called if @p scip is in one of the following stages:
6026  * - \ref SCIP_STAGE_PROBLEM
6027  * - \ref SCIP_STAGE_PRESOLVING
6028  * - \ref SCIP_STAGE_PRESOLVED
6029  * - \ref SCIP_STAGE_SOLVING
6030  */
6032  SCIP* scip, /**< SCIP data structure */
6033  SCIP_VAR* var, /**< binary variable to fix */
6034  SCIP_Bool fixedval, /**< value to fix binary variable to */
6035  SCIP_PROP* inferprop, /**< propagator that deduced the fixing */
6036  int inferinfo, /**< user information for inference to help resolving the conflict */
6037  SCIP_Bool* infeasible, /**< pointer to store whether the fixing is infeasible */
6038  SCIP_Bool* tightened /**< pointer to store whether the fixing tightened the local bounds, or NULL */
6039  )
6040 {
6041  SCIP_Real lb;
6042  SCIP_Real ub;
6043 
6044  assert(SCIPvarIsBinary(var));
6045  assert(fixedval == TRUE || fixedval == FALSE);
6046  assert(infeasible != NULL);
6047 
6048  SCIP_CALL( SCIPcheckStage(scip, "SCIPinferBinvarProp", FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
6049 
6050  *infeasible = FALSE;
6051  if( tightened != NULL )
6052  *tightened = FALSE;
6053 
6054  /* get current bounds */
6055  lb = SCIPvarGetLbLocal(var);
6056  ub = SCIPvarGetUbLocal(var);
6057  assert(SCIPsetIsEQ(scip->set, lb, 0.0) || SCIPsetIsEQ(scip->set, lb, 1.0));
6058  assert(SCIPsetIsEQ(scip->set, ub, 0.0) || SCIPsetIsEQ(scip->set, ub, 1.0));
6059  assert(SCIPsetIsLE(scip->set, lb, ub));
6060 
6061  /* check, if variable is already fixed */
6062  if( (lb > 0.5) || (ub < 0.5) )
6063  {
6064  *infeasible = (fixedval == (lb < 0.5));
6065 
6066  return SCIP_OKAY;
6067  }
6068 
6069  /* apply the fixing */
6070  switch( scip->set->stage )
6071  {
6072  case SCIP_STAGE_PROBLEM:
6073  assert(!SCIPvarIsTransformed(var));
6074  if( fixedval == TRUE )
6075  {
6076  SCIP_CALL( SCIPchgVarLb(scip, var, 1.0) );
6077  }
6078  else
6079  {
6080  SCIP_CALL( SCIPchgVarUb(scip, var, 0.0) );
6081  }
6082  break;
6083 
6084  case SCIP_STAGE_PRESOLVING:
6085  if( SCIPtreeGetCurrentDepth(scip->tree) == 0 )
6086  {
6087  SCIP_Bool fixed;
6088 
6089  SCIP_CALL( SCIPvarFix(var, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob,
6090  scip->primal, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable,
6091  (SCIP_Real)fixedval, infeasible, &fixed) );
6092  break;
6093  }
6094  /*lint -fallthrough*/
6095  case SCIP_STAGE_SOLVING:
6096  if( fixedval == TRUE )
6097  {
6099  scip->transprob, scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable, var, 1.0,
6100  SCIP_BOUNDTYPE_LOWER, NULL, inferprop, inferinfo, FALSE) );
6101  }
6102  else
6103  {
6105  scip->transprob, scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable, var, 0.0,
6106  SCIP_BOUNDTYPE_UPPER, NULL, inferprop, inferinfo, FALSE) );
6107  }
6108  break;
6109 
6110  default:
6111  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
6112  return SCIP_INVALIDCALL;
6113  } /*lint !e788*/
6114 
6115  if( tightened != NULL )
6116  *tightened = TRUE;
6117 
6118  return SCIP_OKAY;
6119 }
6120 
6121 /** changes global lower bound of variable in preprocessing or in the current node, if the new bound is tighter
6122  * (w.r.t. bound strengthening epsilon) than the current global bound; if possible, adjusts bound to integral value;
6123  * also tightens the local bound, if the global bound is better than the local bound
6124  *
6125  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
6126  * SCIPgetVars()) gets resorted.
6127  *
6128  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6129  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6130  *
6131  * @pre This method can be called if @p scip is in one of the following stages:
6132  * - \ref SCIP_STAGE_PROBLEM
6133  * - \ref SCIP_STAGE_TRANSFORMING
6134  * - \ref SCIP_STAGE_PRESOLVING
6135  * - \ref SCIP_STAGE_SOLVING
6136  *
6137  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
6138  */
6140  SCIP* scip, /**< SCIP data structure */
6141  SCIP_VAR* var, /**< variable to change the bound for */
6142  SCIP_Real newbound, /**< new value for bound */
6143  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
6144  SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */
6145  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
6146  )
6147 {
6148  SCIP_Real lb;
6149  SCIP_Real ub;
6150 
6151  assert(infeasible != NULL);
6152 
6153  SCIP_CALL( SCIPcheckStage(scip, "SCIPtightenVarLbGlobal", FALSE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
6154 
6155  *infeasible = FALSE;
6156  if( tightened != NULL )
6157  *tightened = FALSE;
6158 
6159  SCIPvarAdjustLb(var, scip->set, &newbound);
6160 
6161  /* ignore tightenings of lower bounds to +infinity during solving process */
6162  if( SCIPisInfinity(scip, newbound) && SCIPgetStage(scip) == SCIP_STAGE_SOLVING )
6163  {
6164 #ifndef NDEBUG
6165  SCIPwarningMessage(scip, "ignore lower bound tightening for %s from %e to +infinity\n", SCIPvarGetName(var),
6166  SCIPvarGetLbLocal(var));
6167 #endif
6168  return SCIP_OKAY;
6169  }
6170 
6171  /* get current bounds */
6172  lb = SCIPvarGetLbGlobal(var);
6173  ub = SCIPvarGetUbGlobal(var);
6174  assert(scip->set->stage == SCIP_STAGE_PROBLEM || SCIPsetIsLE(scip->set, lb, ub));
6175 
6176  if( SCIPsetIsFeasGT(scip->set, newbound, ub) )
6177  {
6178  *infeasible = TRUE;
6179  return SCIP_OKAY;
6180  }
6181  newbound = MIN(newbound, ub);
6182 
6183  /* bound changes of less than epsilon are ignored by SCIPvarChgLb or raise an assert in SCIPnodeAddBoundinfer,
6184  * so don't apply them even if force is set
6185  */
6186  if( SCIPsetIsEQ(scip->set, lb, newbound) || (!force && !SCIPsetIsLbBetter(scip->set, newbound, lb, ub)) )
6187  return SCIP_OKAY;
6188 
6189  switch( scip->set->stage )
6190  {
6191  case SCIP_STAGE_PROBLEM:
6192  assert(!SCIPvarIsTransformed(var));
6193  SCIP_CALL( SCIPvarChgLbGlobal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
6194  scip->branchcand, scip->eventqueue, scip->cliquetable, newbound) );
6195  SCIP_CALL( SCIPvarChgLbLocal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
6196  scip->branchcand, scip->eventqueue, newbound) );
6197  SCIP_CALL( SCIPvarChgLbOriginal(var, scip->set, newbound) );
6198  break;
6199 
6201  SCIP_CALL( SCIPvarChgLbGlobal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
6202  scip->branchcand, scip->eventqueue, scip->cliquetable, newbound) );
6203  break;
6204 
6205  case SCIP_STAGE_PRESOLVING:
6206  if( !SCIPinProbing(scip) )
6207  {
6208  assert(SCIPtreeGetCurrentDepth(scip->tree) == 0);
6209  assert(scip->tree->root == SCIPtreeGetCurrentNode(scip->tree));
6210 
6211  SCIP_CALL( SCIPnodeAddBoundchg(scip->tree->root, scip->mem->probmem, scip->set, scip->stat, scip->transprob,
6212  scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable, var, newbound,
6214 
6216  {
6217  SCIP_CALL( SCIPchgVarType(scip, var, SCIP_VARTYPE_BINARY, infeasible) );
6218  assert(!(*infeasible));
6219  }
6220  break;
6221  }
6222  /*lint -fallthrough*/
6223  case SCIP_STAGE_SOLVING:
6224  SCIP_CALL( SCIPnodeAddBoundchg(scip->tree->root, scip->mem->probmem, scip->set, scip->stat, scip->transprob,
6225  scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable, var, newbound,
6227  break;
6228 
6229  default:
6230  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
6231  return SCIP_INVALIDCALL;
6232  } /*lint !e788*/
6233 
6234  /* coverity: unreachable code */
6235  if( tightened != NULL )
6236  *tightened = TRUE;
6237 
6238  return SCIP_OKAY;
6239 }
6240 
6241 /** changes global upper bound of variable in preprocessing or in the current node, if the new bound is tighter
6242  * (w.r.t. bound strengthening epsilon) than the current global bound; if possible, adjusts bound to integral value;
6243  * also tightens the local bound, if the global bound is better than the local bound
6244  *
6245  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
6246  * SCIPgetVars()) gets resorted.
6247  *
6248  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6249  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6250  *
6251  * @pre This method can be called if @p scip is in one of the following stages:
6252  * - \ref SCIP_STAGE_PROBLEM
6253  * - \ref SCIP_STAGE_TRANSFORMING
6254  * - \ref SCIP_STAGE_PRESOLVING
6255  * - \ref SCIP_STAGE_SOLVING
6256  *
6257  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
6258  */
6260  SCIP* scip, /**< SCIP data structure */
6261  SCIP_VAR* var, /**< variable to change the bound for */
6262  SCIP_Real newbound, /**< new value for bound */
6263  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
6264  SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */
6265  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
6266  )
6267 {
6268  SCIP_Real lb;
6269  SCIP_Real ub;
6270 
6271  assert(infeasible != NULL);
6272 
6273  SCIP_CALL( SCIPcheckStage(scip, "SCIPtightenVarUbGlobal", FALSE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
6274 
6275  *infeasible = FALSE;
6276  if( tightened != NULL )
6277  *tightened = FALSE;
6278 
6279  SCIPvarAdjustUb(var, scip->set, &newbound);
6280 
6281  /* ignore tightenings of upper bounds to -infinity during solving process */
6282  if( SCIPisInfinity(scip, -newbound) && SCIPgetStage(scip) == SCIP_STAGE_SOLVING )
6283  {
6284 #ifndef NDEBUG
6285  SCIPwarningMessage(scip, "ignore upper bound tightening for %s from %e to -infinity\n", SCIPvarGetName(var),
6286  SCIPvarGetUbLocal(var));
6287 #endif
6288  return SCIP_OKAY;
6289  }
6290 
6291  /* get current bounds */
6292  lb = SCIPvarGetLbGlobal(var);
6293  ub = SCIPvarGetUbGlobal(var);
6294  assert(scip->set->stage == SCIP_STAGE_PROBLEM || SCIPsetIsLE(scip->set, lb, ub));
6295 
6296  if( SCIPsetIsFeasLT(scip->set, newbound, lb) )
6297  {
6298  *infeasible = TRUE;
6299  return SCIP_OKAY;
6300  }
6301  newbound = MAX(newbound, lb);
6302 
6303  /* bound changes of less than epsilon are ignored by SCIPvarChgUb or raise an assert in SCIPnodeAddBoundinfer,
6304  * so don't apply them even if force is set
6305  */
6306  if( SCIPsetIsEQ(scip->set, ub, newbound) || (!force && !SCIPsetIsUbBetter(scip->set, newbound, lb, ub)) )
6307  return SCIP_OKAY;
6308 
6309  switch( scip->set->stage )
6310  {
6311  case SCIP_STAGE_PROBLEM:
6312  assert(!SCIPvarIsTransformed(var));
6313  SCIP_CALL( SCIPvarChgUbGlobal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
6314  scip->branchcand, scip->eventqueue, scip->cliquetable, newbound) );
6315  SCIP_CALL( SCIPvarChgUbLocal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
6316  scip->branchcand, scip->eventqueue, newbound) );
6317  SCIP_CALL( SCIPvarChgUbOriginal(var, scip->set, newbound) );
6318  break;
6319 
6321  SCIP_CALL( SCIPvarChgUbGlobal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
6322  scip->branchcand, scip->eventqueue, scip->cliquetable, newbound) );
6323  break;
6324 
6325  case SCIP_STAGE_PRESOLVING:
6326  if( !SCIPinProbing(scip) )
6327  {
6328  assert(SCIPtreeGetCurrentDepth(scip->tree) == 0);
6329  assert(scip->tree->root == SCIPtreeGetCurrentNode(scip->tree));
6330 
6331  SCIP_CALL( SCIPnodeAddBoundchg(scip->tree->root, scip->mem->probmem, scip->set, scip->stat, scip->transprob,
6332  scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable, var, newbound,
6334 
6336  {
6337  SCIP_CALL( SCIPchgVarType(scip, var, SCIP_VARTYPE_BINARY, infeasible) );
6338  assert(!(*infeasible));
6339  }
6340  break;
6341  }
6342  /*lint -fallthrough*/
6343  case SCIP_STAGE_SOLVING:
6344  SCIP_CALL( SCIPnodeAddBoundchg(scip->tree->root, scip->mem->probmem, scip->set, scip->stat, scip->transprob,
6345  scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable, var, newbound,
6347  break;
6348 
6349  default:
6350  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
6351  return SCIP_INVALIDCALL;
6352  } /*lint !e788*/
6353 
6354  /* coverity: unreachable code */
6355  if( tightened != NULL )
6356  *tightened = TRUE;
6357 
6358  return SCIP_OKAY;
6359 }
6360 
6361 /* some simple variable functions implemented as defines */
6362 #undef SCIPcomputeVarLbGlobal
6363 #undef SCIPcomputeVarUbGlobal
6364 #undef SCIPcomputeVarLbLocal
6365 #undef SCIPcomputeVarUbLocal
6366 
6367 /** for a multi-aggregated variable, returns the global lower bound computed by adding the global bounds from all aggregation variables
6368  *
6369  * 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
6370  * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetLbGlobal.
6371  *
6372  * @return the global lower bound computed by adding the global bounds from all aggregation variables
6373  */
6375  SCIP* scip, /**< SCIP data structure */
6376  SCIP_VAR* var /**< variable to compute the bound for */
6377  )
6378 {
6379  assert(scip != NULL);
6380  assert(var != NULL);
6381 
6383  return SCIPvarGetMultaggrLbGlobal(var, scip->set);
6384  else
6385  return SCIPvarGetLbGlobal(var);
6386 }
6387 
6388 /** for a multi-aggregated variable, returns the global upper bound computed by adding the global bounds from all aggregation variables
6389  *
6390  * 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
6391  * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetUbGlobal
6392  *
6393  * @return the global upper bound computed by adding the global bounds from all aggregation variables
6394  */
6396  SCIP* scip, /**< SCIP data structure */
6397  SCIP_VAR* var /**< variable to compute the bound for */
6398  )
6399 {
6400  assert(scip != NULL);
6401  assert(var != NULL);
6402 
6404  return SCIPvarGetMultaggrUbGlobal(var, scip->set);
6405  else
6406  return SCIPvarGetUbGlobal(var);
6407 }
6408 
6409 /** for a multi-aggregated variable, returns the local lower bound computed by adding the local bounds from all aggregation variables
6410  *
6411  * 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
6412  * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetLbLocal.
6413  *
6414  * @return the local lower bound computed by adding the global bounds from all aggregation variables
6415  */
6417  SCIP* scip, /**< SCIP data structure */
6418  SCIP_VAR* var /**< variable to compute the bound for */
6419  )
6420 {
6421  assert(scip != NULL);
6422  assert(var != NULL);
6423 
6425  return SCIPvarGetMultaggrLbLocal(var, scip->set);
6426  else
6427  return SCIPvarGetLbLocal(var);
6428 }
6429 
6430 /** for a multi-aggregated variable, returns the local upper bound computed by adding the local bounds from all aggregation variables
6431  *
6432  * 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
6433  * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetUbLocal.
6434  *
6435  * @return the local upper bound computed by adding the global bounds from all aggregation variables
6436  */
6438  SCIP* scip, /**< SCIP data structure */
6439  SCIP_VAR* var /**< variable to compute the bound for */
6440  )
6441 {
6442  assert(scip != NULL);
6443  assert(var != NULL);
6444 
6446  return SCIPvarGetMultaggrUbLocal(var, scip->set);
6447  else
6448  return SCIPvarGetUbLocal(var);
6449 }
6450 
6451 /** for a multi-aggregated variable, gives the global lower bound computed by adding the global bounds from all
6452  * aggregation variables, this global bound may be tighter than the one given by SCIPvarGetLbGlobal, since the latter is
6453  * not updated if bounds of aggregation variables are changing
6454  *
6455  * calling this function for a non-multi-aggregated variable is not allowed
6456  */
6458  SCIP* scip, /**< SCIP data structure */
6459  SCIP_VAR* var /**< variable to compute the bound for */
6460  )
6461 {
6462  assert(SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR);
6463  return SCIPvarGetMultaggrLbGlobal(var, scip->set);
6464 }
6465 
6466 /** for a multi-aggregated variable, gives the global upper bound computed by adding the global bounds from all
6467  * aggregation variables, this upper bound may be tighter than the one given by SCIPvarGetUbGlobal, since the latter is
6468  * not updated if bounds of aggregation variables are changing
6469  *
6470  * calling this function for a non-multi-aggregated variable is not allowed
6471  */
6473  SCIP* scip, /**< SCIP data structure */
6474  SCIP_VAR* var /**< variable to compute the bound for */
6475  )
6476 {
6477  assert(SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR);
6478  return SCIPvarGetMultaggrUbGlobal(var, scip->set);
6479 }
6480 
6481 /** for a multi-aggregated variable, gives the local lower bound computed by adding the local bounds from all
6482  * aggregation variables, this lower bound may be tighter than the one given by SCIPvarGetLbLocal, since the latter is
6483  * not updated if bounds of aggregation variables are changing
6484  *
6485  * calling this function for a non-multi-aggregated variable is not allowed
6486  */
6488  SCIP* scip, /**< SCIP data structure */
6489  SCIP_VAR* var /**< variable to compute the bound for */
6490  )
6491 {
6492  assert(SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR);
6493  return SCIPvarGetMultaggrLbLocal(var, scip->set);
6494 }
6495 
6496 /** for a multi-aggregated variable, gives the local upper bound computed by adding the local bounds from all
6497  * aggregation variables, this upper bound may be tighter than the one given by SCIPvarGetUbLocal, since the latter is
6498  * not updated if bounds of aggregation variables are changing
6499  *
6500  * calling this function for a non-multi-aggregated variable is not allowed
6501  */
6503  SCIP* scip, /**< SCIP data structure */
6504  SCIP_VAR* var /**< variable to compute the bound for */
6505  )
6506 {
6507  assert(SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR);
6508  return SCIPvarGetMultaggrUbLocal(var, scip->set);
6509 }
6510 
6511 /** returns solution value and index of variable lower bound that is closest to the variable's value in the given primal
6512  * solution or current LP solution if no primal solution is given; returns an index of -1 if no variable lower bound is
6513  * available
6514  *
6515  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6516  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6517  *
6518  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
6519  */
6521  SCIP* scip, /**< SCIP data structure */
6522  SCIP_VAR* var, /**< active problem variable */
6523  SCIP_SOL* sol, /**< primal solution, or NULL for LP solution */
6524  SCIP_Real* closestvlb, /**< pointer to store the value of the closest variable lower bound */
6525  int* closestvlbidx /**< pointer to store the index of the closest variable lower bound */
6526  )
6527 {
6528  SCIP_CALL( SCIPcheckStage(scip, "SCIPgetVarClosestVlb", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
6529 
6530  SCIPvarGetClosestVlb(var, sol, scip->set, scip->stat, closestvlb, closestvlbidx);
6531 
6532  return SCIP_OKAY;
6533 }
6534 
6535 /** returns solution value and index of variable upper bound that is closest to the variable's value in the given primal solution;
6536  * or current LP solution if no primal solution is given; returns an index of -1 if no variable upper bound is available
6537  *
6538  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6539  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6540  *
6541  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
6542  */
6544  SCIP* scip, /**< SCIP data structure */
6545  SCIP_VAR* var, /**< active problem variable */
6546  SCIP_SOL* sol, /**< primal solution, or NULL for LP solution */
6547  SCIP_Real* closestvub, /**< pointer to store the value of the closest variable lower bound */
6548  int* closestvubidx /**< pointer to store the index of the closest variable lower bound */
6549  )
6550 {
6551  SCIP_CALL( SCIPcheckStage(scip, "SCIPgetVarClosestVub", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
6552 
6553  SCIPvarGetClosestVub(var, sol, scip->set, scip->stat, closestvub, closestvubidx);
6554 
6555  return SCIP_OKAY;
6556 }
6557 
6558 /** informs variable x about a globally valid variable lower bound x >= b*z + d with integer variable z;
6559  * if z is binary, the corresponding valid implication for z is also added;
6560  * if z is non-continuous and 1/b not too small, the corresponding valid upper/lower bound
6561  * z <= (x-d)/b or z >= (x-d)/b (depending on the sign of of b) is added, too;
6562  * improves the global bounds of the variable and the vlb variable if possible
6563  *
6564  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6565  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6566  *
6567  * @pre This method can be called if @p scip is in one of the following stages:
6568  * - \ref SCIP_STAGE_PRESOLVING
6569  * - \ref SCIP_STAGE_PRESOLVED
6570  * - \ref SCIP_STAGE_SOLVING
6571  */
6573  SCIP* scip, /**< SCIP data structure */
6574  SCIP_VAR* var, /**< problem variable */
6575  SCIP_VAR* vlbvar, /**< variable z in x >= b*z + d */
6576  SCIP_Real vlbcoef, /**< coefficient b in x >= b*z + d */
6577  SCIP_Real vlbconstant, /**< constant d in x >= b*z + d */
6578  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
6579  int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
6580  )
6581 {
6582  int nlocalbdchgs;
6583 
6584  SCIP_CALL( SCIPcheckStage(scip, "SCIPaddVarVlb", FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
6585 
6586  SCIP_CALL( SCIPvarAddVlb(var, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob, scip->tree,
6587  scip->reopt, scip->lp, scip->cliquetable, scip->branchcand, scip->eventqueue, vlbvar, vlbcoef, vlbconstant,
6588  TRUE, infeasible, &nlocalbdchgs) );
6589 
6590  *nbdchgs = nlocalbdchgs;
6591 
6592  /* if x is not continuous we add a variable bound for z; do not add it if cofficient would be too small or we already
6593  * detected infeasibility
6594  */
6595  if( !(*infeasible) && SCIPvarGetType(var) != SCIP_VARTYPE_CONTINUOUS && !SCIPisZero(scip, 1.0/vlbcoef) )
6596  {
6597  if( vlbcoef > 0.0 )
6598  {
6599  /* if b > 0, we have a variable upper bound: x >= b*z + d => z <= (x-d)/b */
6600  SCIP_CALL( SCIPvarAddVub(vlbvar, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob,
6601  scip->tree, scip->reopt, scip->lp, scip->cliquetable, scip->branchcand, scip->eventqueue, var, 1.0/vlbcoef,
6602  -vlbconstant/vlbcoef, TRUE, infeasible, &nlocalbdchgs) );
6603  }
6604  else
6605  {
6606  /* if b < 0, we have a variable lower bound: x >= b*z + d => z >= (x-d)/b */
6607  SCIP_CALL( SCIPvarAddVlb(vlbvar, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob,
6608  scip->tree, scip->reopt, scip->lp, scip->cliquetable, scip->branchcand, scip->eventqueue, var, 1.0/vlbcoef,
6609  -vlbconstant/vlbcoef, TRUE, infeasible, &nlocalbdchgs) );
6610  }
6611  *nbdchgs += nlocalbdchgs;
6612  }
6613 
6614  return SCIP_OKAY;
6615 }
6616 
6617 /** informs variable x about a globally valid variable upper bound x <= b*z + d with integer variable z;
6618  * if z is binary, the corresponding valid implication for z is also added;
6619  * if z is non-continuous and 1/b not too small, the corresponding valid lower/upper bound
6620  * z >= (x-d)/b or z <= (x-d)/b (depending on the sign of of b) is added, too;
6621  * improves the global bounds of the variable and the vlb variable if possible
6622  *
6623  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6624  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6625  *
6626  * @pre This method can be called if @p scip is in one of the following stages:
6627  * - \ref SCIP_STAGE_PRESOLVING
6628  * - \ref SCIP_STAGE_PRESOLVED
6629  * - \ref SCIP_STAGE_SOLVING
6630  */
6632  SCIP* scip, /**< SCIP data structure */
6633  SCIP_VAR* var, /**< problem variable */
6634  SCIP_VAR* vubvar, /**< variable z in x <= b*z + d */
6635  SCIP_Real vubcoef, /**< coefficient b in x <= b*z + d */
6636  SCIP_Real vubconstant, /**< constant d in x <= b*z + d */
6637  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
6638  int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
6639  )
6640 {
6641  int nlocalbdchgs;
6642 
6643  SCIP_CALL( SCIPcheckStage(scip, "SCIPaddVarVub", FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
6644 
6645  SCIP_CALL( SCIPvarAddVub(var, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob, scip->tree,
6646  scip->reopt, scip->lp, scip->cliquetable, scip->branchcand, scip->eventqueue, vubvar, vubcoef, vubconstant, TRUE,
6647  infeasible, &nlocalbdchgs) );
6648 
6649  *nbdchgs = nlocalbdchgs;
6650 
6651  /* if x is not continuous we add a variable bound for z; do not add it if cofficient would be too small or we already
6652  * detected infeasibility
6653  */
6654  if( !(*infeasible) && SCIPvarGetType(var) != SCIP_VARTYPE_CONTINUOUS && !SCIPisZero(scip, 1.0/vubcoef) )
6655  {
6656  if( vubcoef > 0.0 )
6657  {
6658  /* if b < 0, we have a variable lower bound: x >= b*z + d => z >= (x-d)/b */
6659  SCIP_CALL( SCIPvarAddVlb(vubvar, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob,
6660  scip->tree, scip->reopt, scip->lp, scip->cliquetable, scip->branchcand, scip->eventqueue, var, 1.0/vubcoef,
6661  -vubconstant/vubcoef, TRUE, infeasible, &nlocalbdchgs) );
6662  }
6663  else
6664  {
6665  /* if b > 0, we have a variable upper bound: x >= b*z + d => z <= (x-d)/b */
6666  SCIP_CALL( SCIPvarAddVub(vubvar, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob,
6667  scip->tree, scip->reopt, scip->lp, scip->cliquetable, scip->branchcand, scip->eventqueue, var, 1.0/vubcoef,
6668  -vubconstant/vubcoef, TRUE, infeasible, &nlocalbdchgs) );
6669  }
6670  *nbdchgs += nlocalbdchgs;
6671  }
6672 
6673  return SCIP_OKAY;
6674 }
6675 
6676 /** informs binary variable x about a globally valid implication: x == 0 or x == 1 ==> y <= b or y >= b;
6677  * also adds the corresponding implication or variable bound to the implied variable;
6678  * if the implication is conflicting, the variable is fixed to the opposite value;
6679  * if the variable is already fixed to the given value, the implication is performed immediately;
6680  * if the implication is redundant with respect to the variables' global bounds, it is ignored
6681  *
6682  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6683  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6684  *
6685  * @pre This method can be called if @p scip is in one of the following stages:
6686  * - \ref SCIP_STAGE_TRANSFORMED
6687  * - \ref SCIP_STAGE_PRESOLVING
6688  * - \ref SCIP_STAGE_PRESOLVED
6689  * - \ref SCIP_STAGE_SOLVING
6690  */
6692  SCIP* scip, /**< SCIP data structure */
6693  SCIP_VAR* var, /**< problem variable */
6694  SCIP_Bool varfixing, /**< FALSE if y should be added in implications for x == 0, TRUE for x == 1 */
6695  SCIP_VAR* implvar, /**< variable y in implication y <= b or y >= b */
6696  SCIP_BOUNDTYPE impltype, /**< type of implication y <= b (SCIP_BOUNDTYPE_UPPER)
6697  * or y >= b (SCIP_BOUNDTYPE_LOWER) */
6698  SCIP_Real implbound, /**< bound b in implication y <= b or y >= b */
6699  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
6700  int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
6701  )
6702 {
6703  SCIP_CALL( SCIPcheckStage(scip, "SCIPaddVarImplication", FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
6704 
6705  if ( nbdchgs != NULL )
6706  *nbdchgs = 0;
6707 
6708  if( !SCIPvarIsBinary(var) )
6709  {
6710  SCIPerrorMessage("can't add implication for nonbinary variable\n");
6711  return SCIP_INVALIDDATA;
6712  }
6713 
6714  /* transform implication containing two binary variables to clique */
6715  if( SCIPvarIsBinary(implvar) )
6716  {
6717  SCIP_VAR* vars[2];
6718  SCIP_Bool vals[2];
6719 
6720  assert(SCIPisFeasEQ(scip, implbound, 1.0) || SCIPisFeasZero(scip, implbound));
6721  assert((impltype == SCIP_BOUNDTYPE_UPPER) == SCIPisFeasZero(scip, implbound));
6722 
6723  vars[0] = var;
6724  vars[1] = implvar;
6725  vals[0] = varfixing;
6726  vals[1] = (impltype == SCIP_BOUNDTYPE_UPPER);
6727 
6728  SCIP_CALL( SCIPaddClique(scip, vars, vals, 2, FALSE, infeasible, nbdchgs) );
6729 
6730  return SCIP_OKAY;
6731  }
6732 
6733  /* the implication graph can only handle 'real' binary (SCIP_VARTYPE_BINARY) variables, therefore we transform the
6734  * implication in variable bounds, (lowerbound of y will be abbreviated by lby, upperbound equivlaent) the follwing
6735  * four cases are:
6736  *
6737  * 1. (x >= 1 => y >= b) => y >= (b - lby) * x + lby
6738  * 2. (x >= 1 => y <= b) => y <= (b - uby) * x + uby
6739  * 3. (x <= 0 => y >= b) => y >= (lby - b) * x + b
6740  * 4. (x <= 0 => y <= b) => y <= (uby - b) * x + b
6741  */
6742  if( SCIPvarGetType(var) != SCIP_VARTYPE_BINARY )
6743  {
6744  SCIP_Real lby;
6745  SCIP_Real uby;
6746 
6747  lby = SCIPvarGetLbGlobal(implvar);
6748  uby = SCIPvarGetUbGlobal(implvar);
6749 
6750  if( varfixing == TRUE )
6751  {
6752  if( impltype == SCIP_BOUNDTYPE_LOWER )
6753  {
6754  /* we return if the lower bound is infinity */
6755  if( SCIPisInfinity(scip, -lby) )
6756  return SCIP_OKAY;
6757 
6758  SCIP_CALL( SCIPvarAddVlb(implvar, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob,
6759  scip->tree, scip->reopt, scip->lp, scip->cliquetable, scip->branchcand, scip->eventqueue, var,
6760  implbound - lby, lby, TRUE, infeasible, nbdchgs) );
6761  }
6762  else
6763  {
6764  /* we return if the upper bound is infinity */
6765  if( SCIPisInfinity(scip, uby) )
6766  return SCIP_OKAY;
6767 
6768  SCIP_CALL( SCIPvarAddVub(implvar, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob,
6769  scip->tree, scip->reopt, scip->lp, scip->cliquetable, scip->branchcand, scip->eventqueue, var,
6770  implbound - uby, uby, TRUE, infeasible, nbdchgs) );
6771  }
6772  }
6773  else
6774  {
6775  if( impltype == SCIP_BOUNDTYPE_LOWER )
6776  {
6777  /* we return if the lower bound is infinity */
6778  if( SCIPisInfinity(scip, -lby) )
6779  return SCIP_OKAY;
6780 
6781  SCIP_CALL( SCIPvarAddVlb(implvar, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob,
6782  scip->tree, scip->reopt, scip->lp, scip->cliquetable, scip->branchcand, scip->eventqueue, var,
6783  lby - implbound, implbound, TRUE, infeasible, nbdchgs) );
6784  }
6785  else
6786  {
6787  /* we return if the upper bound is infinity */
6788  if( SCIPisInfinity(scip, uby) )
6789  return SCIP_OKAY;
6790 
6791  SCIP_CALL( SCIPvarAddVub(implvar, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob,
6792  scip->tree, scip->reopt, scip->lp, scip->cliquetable, scip->branchcand, scip->eventqueue, var,
6793  uby - implbound, implbound, TRUE, infeasible, nbdchgs) );
6794  }
6795  }
6796  }
6797  else
6798  {
6799  SCIP_CALL( SCIPvarAddImplic(var, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob,
6800  scip->tree, scip->reopt, scip->lp, scip->cliquetable, scip->branchcand, scip->eventqueue, varfixing, implvar, impltype,
6801  implbound, TRUE, infeasible, nbdchgs) );
6802  }
6803 
6804  return SCIP_OKAY;
6805 }
6806 
6807 /** adds a clique information to SCIP, stating that at most one of the given binary variables can be set to 1;
6808  * if a variable appears twice in the same clique, the corresponding implications are performed
6809  *
6810  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6811  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6812  *
6813  * @pre This method can be called if @p scip is in one of the following stages:
6814  * - \ref SCIP_STAGE_TRANSFORMED
6815  * - \ref SCIP_STAGE_PRESOLVING
6816  * - \ref SCIP_STAGE_PRESOLVED
6817  * - \ref SCIP_STAGE_SOLVING
6818  */
6820  SCIP* scip, /**< SCIP data structure */
6821  SCIP_VAR** vars, /**< binary variables in the clique from which at most one can be set to 1 */
6822  SCIP_Bool* values, /**< values of the variables in the clique; NULL to use TRUE for all vars */
6823  int nvars, /**< number of variables in the clique */
6824  SCIP_Bool isequation, /**< is the clique an equation or an inequality? */
6825  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
6826  int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
6827  )
6828 {
6829  SCIP_CALL( SCIPcheckStage(scip, "SCIPaddClique", FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
6830 
6831  *infeasible = FALSE;
6832  if( nbdchgs != NULL )
6833  *nbdchgs = 0;
6834 
6835  if( nvars > 1 )
6836  {
6837  /* add the clique to the clique table */
6838  SCIP_CALL( SCIPcliquetableAdd(scip->cliquetable, scip->mem->probmem, scip->set, scip->stat, scip->transprob,
6839  scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, vars, values, nvars, isequation,
6840  infeasible, nbdchgs) );
6841  }
6842 
6843  return SCIP_OKAY;
6844 }
6845 
6846 /** relabels the given labels in-place in an increasing fashion: the first seen label is 0, the next label 1, etc...
6847  *
6848  * @note every label equal to -1 is treated as a previously unseen, unique label and gets a new ordered label.
6849  */
6850 static
6852  SCIP*const scip, /**< SCIP data structure */
6853  int* labels, /**< current labels that will be overwritten */
6854  int const nlabels, /**< number of variables in the clique */
6855  int* nclasses /**< pointer to store the total number of distinct labels */
6856  )
6857 {
6858  SCIP_HASHMAP* classidx2newlabel;
6859 
6860  int classidx;
6861  int i;
6862 
6863  SCIP_CALL( SCIPhashmapCreate(&classidx2newlabel, SCIPblkmem(scip), nlabels) );
6864 
6865  classidx = 0;
6866 
6867  /* loop over labels to create local class indices that obey the variable order */
6868  for( i = 0; i < nlabels; ++i )
6869  {
6870  int currentlabel = labels[i];
6871  int localclassidx;
6872 
6873  /* labels equal to -1 are stored as singleton classes */
6874  if( currentlabel == -1 )
6875  {
6876  ++classidx;
6877  localclassidx = classidx;
6878  }
6879  else
6880  {
6881  assert(currentlabel >= 0);
6882  /* look up the class index image in the hash map; if it is not stored yet, new class index is created and stored */
6883  if( !SCIPhashmapExists(classidx2newlabel, (void*)(size_t)currentlabel) )
6884  {
6885  ++classidx;
6886  localclassidx = classidx;
6887  SCIP_CALL( SCIPhashmapInsert(classidx2newlabel, (void*)(size_t)currentlabel, (void *)(size_t)classidx) );
6888  }
6889  else
6890  {
6891  localclassidx = (int)(size_t)SCIPhashmapGetImage(classidx2newlabel, (void*)(size_t)currentlabel);
6892  }
6893  }
6894  assert(localclassidx - 1 >= 0);
6895  assert(localclassidx - 1 <= i);
6896 
6897  /* indices start with zero, but we have an offset of 1 because we cannot store 0 in a hashmap */
6898  labels[i] = localclassidx - 1;
6899  }
6900 
6901  assert(classidx > 0);
6902  assert(classidx <= nlabels);
6903  *nclasses = classidx;
6904 
6905  SCIPhashmapFree(&classidx2newlabel);
6906 
6907  return SCIP_OKAY;
6908 }
6909 
6910 /** sort the variables w.r.t. the given labels; thereby ensure the current order of the variables with the same label. */
6911 static
6913  SCIP* scip, /**< SCIP data structure */
6914  SCIP_VAR** vars, /**< variable array */
6915  int* classlabels, /**< array that contains a class label for every variable */
6916  SCIP_VAR** sortedvars, /**< array to store variables after stable sorting */
6917  int* sortedindices, /**< array to store indices of sorted variables in the original vars array */
6918  int* classesstartposs, /**< starting position array for each label class (must have size nclasses + 1) */
6919  int nvars, /**< size of the vars arrays */
6920  int nclasses /**< number of label classes */
6921  )
6922 {
6923  SCIP_VAR*** varpointers;
6924  int** indexpointers;
6925  int* classcount;
6926 
6927  int nextpos;
6928  int c;
6929  int v;
6930 
6931  assert(scip != NULL);
6932  assert(vars != NULL);
6933  assert(sortedindices != NULL);
6934  assert(classesstartposs != NULL);
6935 
6936  assert(nvars == 0 || vars != NULL);
6937 
6938  if( nvars == 0 )
6939  return SCIP_OKAY;
6940 
6941  assert(classlabels != NULL);
6942  assert(nclasses > 0);
6943 
6944  /* we first count all class cardinalities and allocate temporary memory for a bucket sort */
6945  SCIP_CALL( SCIPallocBufferArray(scip, &classcount, nclasses) );
6946  BMSclearMemoryArray(classcount, nclasses);
6947 
6948  /* first we count for each class the number of elements */
6949  for( v = nvars - 1; v >= 0; --v )
6950  {
6951  assert(0 <= classlabels[v] && classlabels[v] < nclasses);
6952  ++(classcount[classlabels[v]]);
6953  }
6954 
6955 #ifndef NDEBUG
6956  BMSclearMemoryArray(sortedvars, nvars);
6957  BMSclearMemoryArray(sortedindices, nvars);
6958 #endif
6959  SCIP_CALL( SCIPallocBufferArray(scip, &varpointers, nclasses) );
6960  SCIP_CALL( SCIPallocBufferArray(scip, &indexpointers, nclasses) );
6961 
6962  nextpos = 0;
6963  /* now we initialize all start pointers for each class, so they will be ordered */
6964  for( c = 0; c < nclasses; ++c )
6965  {
6966  /* to reach the goal that all variables of each class will be standing next to each other we will initialize the
6967  * starting pointers for each class by adding the cardinality of each class to the last class starting pointer
6968  * e.g. class1 has 4 elements and class2 has 3 elements then the starting pointer for class1 will be the pointer
6969  * to sortedvars[0], the starting pointer to class2 will be the pointer to sortedvars[4] and to class3 it will be
6970  * the pointer to sortedvars[7]
6971  */
6972  varpointers[c] = (SCIP_VAR**) (sortedvars + nextpos);
6973  indexpointers[c] = (int*) (sortedindices + nextpos);
6974  classesstartposs[c] = nextpos;
6975  assert(classcount[c] > 0);
6976  nextpos += classcount[c];
6977  assert(nextpos > 0);
6978  }
6979  assert(nextpos == nvars);
6980  classesstartposs[c] = nextpos;
6981 
6982  /* now we copy all variables to the right order */
6983  for( v = 0; v < nvars; ++v )
6984  {
6985  /* copy variable itself to the right position */
6986  *(varpointers[classlabels[v]]) = vars[v]; /*lint !e613*/
6987  ++(varpointers[classlabels[v]]);
6988 
6989  /* copy index */
6990  *(indexpointers[classlabels[v]]) = v;
6991  ++(indexpointers[classlabels[v]]);
6992  }
6993 
6994 /* in debug mode, we ensure the correctness of the mapping */
6995 #ifndef NDEBUG
6996  for( v = 0; v < nvars; ++v )
6997  {
6998  assert(sortedvars[v] != NULL);
6999  assert(sortedindices[v] >= 0);
7000 
7001  /* assert that the sorted indices map back to the correct variable in the original order */
7002  assert(vars[sortedindices[v]] == sortedvars[v]);
7003  }
7004 #endif
7005 
7006  /* free temporary memory */
7007  SCIPfreeBufferArray(scip, &indexpointers);
7008  SCIPfreeBufferArray(scip, &varpointers);
7009  SCIPfreeBufferArray(scip, &classcount);
7010 
7011  return SCIP_OKAY;
7012 }
7013 
7014 
7015 /* calculate clique partition for a maximal amount of comparisons on variables due to expensive algorithm
7016  * @todo: check for a good value, maybe it's better to check parts of variables
7017  */
7018 #define MAXNCLIQUEVARSCOMP 1000000
7019 
7020 /** calculates a partition of the given set of binary variables into cliques;
7021  * afterwards the output array contains one value for each variable, such that two variables got the same value iff they
7022  * were assigned to the same clique;
7023  * the first variable is always assigned to clique 0, and a variable can only be assigned to clique i if at least one of
7024  * the preceding variables was assigned to clique i-1;
7025  * for each clique at most 1 variables can be set to TRUE in a feasible solution;
7026  *
7027  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7028  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7029  *
7030  * @pre This method can be called if @p scip is in one of the following stages:
7031  * - \ref SCIP_STAGE_INITPRESOLVE
7032  * - \ref SCIP_STAGE_PRESOLVING
7033  * - \ref SCIP_STAGE_EXITPRESOLVE
7034  * - \ref SCIP_STAGE_PRESOLVED
7035  * - \ref SCIP_STAGE_SOLVING
7036  */
7037 static
7039  SCIP*const scip, /**< SCIP data structure */
7040  SCIP_VAR**const vars, /**< binary variables in the clique from which at most one can be set to 1 */
7041  SCIP_Bool*const values, /**< clique value (TRUE or FALSE) for each variable in the clique */
7042  int const nvars, /**< number of variables in the array */
7043  int*const cliquepartition, /**< array of length nvars to store the clique partition */
7044  int*const ncliques /**< pointer to store the number of cliques actually contained in the partition */
7045  )
7046 {
7047  SCIP_VAR** cliquevars;
7048  SCIP_Bool* cliquevalues;
7049  int i;
7050  int maxncliquevarscomp;
7051  int ncliquevars;
7052 
7053  /* allocate temporary memory for storing the variables of the current clique */
7054  SCIP_CALL( SCIPsetAllocBufferArray(scip->set, &cliquevars, nvars) );
7055  SCIP_CALL( SCIPsetAllocBufferArray(scip->set, &cliquevalues, nvars) );
7056 
7057  /* initialize the cliquepartition array with -1 */
7058  for( i = nvars - 1; i >= 0; --i )
7059  cliquepartition[i] = -1;
7060 
7061  maxncliquevarscomp = (int) MIN(nvars * (SCIP_Longint)nvars, MAXNCLIQUEVARSCOMP);
7062  /* calculate the clique partition */
7063  *ncliques = 0;
7064  for( i = 0; i < nvars; ++i )
7065  {
7066  if( cliquepartition[i] == -1 )
7067  {
7068  int j;
7069 
7070  /* variable starts a new clique */
7071  cliquepartition[i] = *ncliques;
7072  cliquevars[0] = vars[i];
7073  cliquevalues[0] = values[i];
7074  ncliquevars = 1;
7075 
7076  /* if variable is not active (multi-aggregated or fixed), it cannot be in any clique */
7077  if( SCIPvarIsActive(vars[i]) && SCIPvarGetNCliques(vars[i], values[i]) > 0 )
7078  {
7079  /* greedily fill up the clique */
7080  for( j = i+1; j < nvars; ++j )
7081  {
7082  /* if variable is not active (multi-aggregated or fixed), it cannot be in any clique */
7083  if( cliquepartition[j] == -1 && SCIPvarIsActive(vars[j]) )
7084  {
7085  int k;
7086 
7087  /* check if every variable in the current clique can be extended by tmpvars[j] */
7088  for( k = ncliquevars - 1; k >= 0; --k )
7089  {
7090  if( !SCIPvarsHaveCommonClique(vars[j], values[j], cliquevars[k], cliquevalues[k], FALSE) )
7091  break;
7092  }
7093 
7094  if( k == -1 )
7095  {
7096  /* put the variable into the same clique */
7097  cliquepartition[j] = cliquepartition[i];
7098  cliquevars[ncliquevars] = vars[j];
7099  cliquevalues[ncliquevars] = values[j];
7100  ++ncliquevars;
7101  }
7102  }
7103  }
7104  }
7105 
7106  /* this clique is finished */
7107  ++(*ncliques);
7108  }
7109  assert(cliquepartition[i] >= 0 && cliquepartition[i] < i+1);
7110 
7111  /* break if we reached the maximal number of comparisons */
7112  if( i * nvars > maxncliquevarscomp )
7113  break;
7114  }
7115  /* if we had to many variables fill up the cliquepartition and put each variable in a separate clique */
7116  for( ; i < nvars; ++i )
7117  {
7118  if( cliquepartition[i] == -1 )
7119  {
7120  cliquepartition[i] = *ncliques;
7121  ++(*ncliques);
7122  }
7123  }
7124 
7125  SCIPsetFreeBufferArray(scip->set, &cliquevalues);
7126  SCIPsetFreeBufferArray(scip->set, &cliquevars);
7127 
7128  return SCIP_OKAY;
7129 }
7130 
7131 /** calculates a partition of the given set of binary variables into cliques; takes into account independent clique components
7132  *
7133  * The algorithm performs the following steps:
7134  * - recomputes connected components of the clique table, if necessary
7135  * - computes a clique partition for every connected component greedily.
7136  * - relabels the resulting clique partition such that it satisfies the description below
7137  *
7138  * afterwards the output array contains one value for each variable, such that two variables got the same value iff they
7139  * were assigned to the same clique;
7140  * the first variable is always assigned to clique 0, and a variable can only be assigned to clique i if at least one of
7141  * the preceding variables was assigned to clique i-1;
7142  * for each clique at most 1 variables can be set to TRUE in a feasible solution;
7143  *
7144  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7145  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7146  *
7147  * @pre This method can be called if @p scip is in one of the following stages:
7148  * - \ref SCIP_STAGE_INITPRESOLVE
7149  * - \ref SCIP_STAGE_PRESOLVING
7150  * - \ref SCIP_STAGE_EXITPRESOLVE
7151  * - \ref SCIP_STAGE_PRESOLVED
7152  * - \ref SCIP_STAGE_SOLVING
7153  */
7155  SCIP*const scip, /**< SCIP data structure */
7156  SCIP_VAR**const vars, /**< binary variables in the clique from which at most one can be set to 1 */
7157  int const nvars, /**< number of variables in the clique */
7158  int*const cliquepartition, /**< array of length nvars to store the clique partition */
7159  int*const ncliques /**< pointer to store the number of cliques actually contained in the partition */
7160  )
7161 {
7162  SCIP_VAR** tmpvars;
7163 
7164  SCIP_VAR** sortedtmpvars;
7165  SCIP_Bool* tmpvalues;
7166  SCIP_Bool* sortedtmpvalues;
7167  int* componentlabels;
7168  int* sortedindices;
7169  int* componentstartposs;
7170  int i;
7171  int c;
7172 
7173  int ncomponents;
7174 
7175  assert(scip != NULL);
7176  assert(nvars == 0 || vars != NULL);
7177  assert(nvars == 0 || cliquepartition != NULL);
7178  assert(ncliques != NULL);
7179 
7180  SCIP_CALL( SCIPcheckStage(scip, "SCIPcalcCliquePartition", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
7181 
7182  if( nvars == 0 )
7183  {
7184  *ncliques = 0;
7185  return SCIP_OKAY;
7186  }
7187 
7188  /* early abort if no cliques are present */
7189  if( SCIPgetNCliques(scip) == 0 )
7190  {
7191  for( i = 0; i < nvars; ++i )
7192  cliquepartition[i] = i;
7193 
7194  *ncliques = nvars;
7195 
7196  return SCIP_OKAY;
7197  }
7198 
7199  SCIP_CALL( SCIPsetAllocBufferArray(scip->set, &tmpvalues, nvars) );
7200  SCIP_CALL( SCIPsetDuplicateBufferArray(scip->set, &tmpvars, vars, nvars) );
7201  SCIP_CALL( SCIPsetAllocBufferArray(scip->set, &componentlabels, nvars) );
7202  SCIP_CALL( SCIPsetAllocBufferArray(scip->set, &sortedindices, nvars) );
7203 
7204  /* initialize the tmpvalues array */
7205  for( i = nvars - 1; i >= 0; --i )
7206  {
7207  tmpvalues[i] = TRUE;
7208  cliquepartition[i] = -1;
7209  }
7210 
7211  /* get corresponding active problem variables */
7212  SCIP_CALL( SCIPvarsGetProbvarBinary(&tmpvars, &tmpvalues, nvars) );
7213 
7214  ncomponents = -1;
7215 
7216  /* update clique components if necessary */
7218  {
7219  SCIP_VAR** allvars;
7220  int nallbinvars;
7221  int nallintvars;
7222  int nallimplvars;
7223 
7224  SCIP_CALL( SCIPgetVarsData(scip, &allvars, NULL, &nallbinvars, &nallintvars, &nallimplvars, NULL) );
7225 
7226  SCIP_CALL( SCIPcliquetableComputeCliqueComponents(scip->cliquetable, scip->set, SCIPblkmem(scip), allvars, nallbinvars, nallintvars, nallimplvars) );
7227  }
7228 
7230 
7231  /* store the global clique component labels */
7232  for( i = 0; i < nvars; ++i )
7233  {
7234  if( SCIPvarIsActive(tmpvars[i]) )
7235  componentlabels[i] = SCIPcliquetableGetVarComponentIdx(scip->cliquetable, tmpvars[i]);
7236  else
7237  componentlabels[i] = -1;
7238  }
7239 
7240  /* relabel component labels order consistent as prerequisite for a stable sort */
7241  SCIP_CALL( relabelOrderConsistent(scip, componentlabels, nvars, &ncomponents) );
7242  assert(ncomponents >= 1);
7243  assert(ncomponents <= nvars);
7244 
7245  /* allocate storage array for the starting positions of the components */
7246  SCIP_CALL( SCIPsetAllocBufferArray(scip->set, &componentstartposs, ncomponents + 1) );
7247 
7248  /* stable sort the variables w.r.t. the component labels so that we can restrict the quadratic algorithm to the components */
7249  if( ncomponents > 1 )
7250  {
7251  SCIP_CALL( SCIPsetAllocBufferArray(scip->set, &sortedtmpvars, nvars) );
7252  SCIP_CALL( SCIPsetAllocBufferArray(scip->set, &sortedtmpvalues, nvars) );
7253  SCIP_CALL( labelSortStable(scip, tmpvars, componentlabels, sortedtmpvars, sortedindices, componentstartposs, nvars, ncomponents) );
7254 
7255  /* reassign the tmpvalues with respect to the sorting */
7256  for( i = 0; i < nvars; ++i )
7257  {
7258  assert(tmpvars[sortedindices[i]] == sortedtmpvars[i]);
7259  sortedtmpvalues[i] = tmpvalues[sortedindices[i]];
7260  }
7261  }
7262  else
7263  {
7264  /* if we have only one large connected component, skip the stable sorting and prepare the data differently */
7265  sortedtmpvars = tmpvars;
7266  sortedtmpvalues = tmpvalues;
7267  componentstartposs[0] = 0;
7268  componentstartposs[1] = nvars;
7269 
7270  /* sorted indices are the identity */
7271  for( i = 0; i < nvars; ++i )
7272  sortedindices[i] = i;
7273  }
7274 
7275  *ncliques = 0;
7276  /* calculate a greedy clique partition for each connected component */
7277  for( c = 0; c < ncomponents; ++c )
7278  {
7279  int* localcliquepartition;
7280  int nlocalcliques;
7281  int ncomponentvars;
7282  int l;
7283 
7284  /* extract the number of variables in this connected component */
7285  ncomponentvars = componentstartposs[c + 1] - componentstartposs[c];
7286  nlocalcliques = 0;
7287 
7288  /* allocate necessary memory to hold the intermediate component clique partition */
7289  SCIP_CALL( SCIPsetAllocBufferArray(scip->set, &localcliquepartition, ncomponentvars) );
7290 
7291  /* call greedy clique algorithm for all component variables */
7292  SCIP_CALL( calcCliquePartitionGreedy(scip, &(sortedtmpvars[componentstartposs[c]]), &(sortedtmpvalues[componentstartposs[c]]),
7293  ncomponentvars, localcliquepartition, &nlocalcliques) );
7294 
7295  assert(nlocalcliques >= 1);
7296  assert(nlocalcliques <= ncomponentvars);
7297 
7298  /* store the obtained clique partition with an offset of ncliques for the original variables */
7299  for( l = componentstartposs[c]; l < componentstartposs[c + 1]; ++l )
7300  {
7301  int origvaridx = sortedindices[l];
7302  assert(cliquepartition[origvaridx] == -1);
7303  assert(localcliquepartition[l - componentstartposs[c]] <= l - componentstartposs[c]);
7304  cliquepartition[origvaridx] = localcliquepartition[l - componentstartposs[c]] + (*ncliques);
7305  }
7306  *ncliques += nlocalcliques;
7307 
7308  /* free the local clique partition */
7309  SCIPsetFreeBufferArray(scip->set, &localcliquepartition);
7310  }
7311 
7312  /* except in the two trivial cases, we have to ensure the order consistency of the partition indices */
7313  if( ncomponents > 1 && ncomponents < nvars )
7314  {
7315  int partitionsize;
7316  SCIP_CALL( relabelOrderConsistent(scip, cliquepartition, nvars, &partitionsize) );
7317 
7318  assert(partitionsize == *ncliques);
7319  }
7320 
7321  if( ncomponents > 1 )
7322  {
7323  SCIPsetFreeBufferArray(scip->set, &sortedtmpvalues);
7324  SCIPsetFreeBufferArray(scip->set, &sortedtmpvars);
7325  }
7326 
7327  /* use the greedy algorithm as a whole to verify the result on small number of variables */
7328 #ifdef SCIP_DISABLED_CODE
7329  {
7330  int* debugcliquepartition;
7331  int ndebugcliques;
7332 
7333  SCIP_CALL( SCIPsetAllocBufferArray(scip->set, &debugcliquepartition, nvars) );
7334 
7335  /* call greedy clique algorithm for all component variables */
7336  SCIP_CALL( calcCliquePartitionGreedy(scip, tmpvars, tmpvalues, nvars, debugcliquepartition, &ndebugcliques) );
7337 
7338  /* loop and compare the traditional greedy clique with */
7339  for( i = 0; i < nvars; ++i )
7340  assert(i * nvars > MAXNCLIQUEVARSCOMP || cliquepartition[i] == debugcliquepartition[i]);
7341 
7342  SCIPsetFreeBufferArray(scip->set, &debugcliquepartition);
7343  }
7344 #endif
7345 
7346  /* free temporary memory */
7347  SCIPsetFreeBufferArray(scip->set, &componentstartposs);
7348  SCIPsetFreeBufferArray(scip->set, &sortedindices);
7349  SCIPsetFreeBufferArray(scip->set, &componentlabels);
7350  SCIPsetFreeBufferArray(scip->set, &tmpvars);
7351  SCIPsetFreeBufferArray(scip->set, &tmpvalues);
7352 
7353  return SCIP_OKAY;
7354 }
7355 
7356 /** calculates a partition of the given set of binary variables into negated cliques;
7357  * afterwards the output array contains one value for each variable, such that two variables got the same value iff they
7358  * were assigned to the same negated clique;
7359  * the first variable is always assigned to clique 0 and a variable can only be assigned to clique i if at least one of
7360  * the preceding variables was assigned to clique i-1;
7361  * for each clique with n_c variables at least n_c-1 variables can be set to TRUE in a feasible solution;
7362  *
7363  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7364  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7365  *
7366  * @pre This method can be called if @p scip is in one of the following stages:
7367  * - \ref SCIP_STAGE_INITPRESOLVE
7368  * - \ref SCIP_STAGE_PRESOLVING
7369  * - \ref SCIP_STAGE_EXITPRESOLVE
7370  * - \ref SCIP_STAGE_PRESOLVED
7371  * - \ref SCIP_STAGE_SOLVING
7372  */
7374  SCIP*const scip, /**< SCIP data structure */
7375  SCIP_VAR**const vars, /**< binary variables in the clique from which at most one can be set to 1 */
7376  int const nvars, /**< number of variables in the clique */
7377  int*const cliquepartition, /**< array of length nvars to store the clique partition */
7378  int*const ncliques /**< pointer to store the number of cliques actually contained in the partition */
7379  )
7380 {
7381  SCIP_VAR** negvars;
7382  int v;
7383 
7384  assert(scip != NULL);
7385  assert(cliquepartition != NULL || nvars == 0);
7386  assert(ncliques != NULL);
7387 
7388  if( nvars == 0 )
7389  {
7390  *ncliques = 0;
7391  return SCIP_OKAY;
7392  }
7393  assert(vars != NULL);
7394 
7395  /* allocate temporary memory */
7396  SCIP_CALL( SCIPsetAllocBufferArray(scip->set, &negvars, nvars) );
7397 
7398  /* get all negated variables */
7399  for( v = nvars - 1; v >= 0; --v )
7400  {
7401  SCIP_CALL( SCIPgetNegatedVar(scip, vars[v], &(negvars[v])) );
7402  }
7403 
7404  /* calculate cliques on negated variables, which are "negated" cliques on normal variables array */
7405  SCIP_CALL( SCIPcalcCliquePartition( scip, negvars, nvars, cliquepartition, ncliques) );
7406 
7407  /* free temporary memory */
7408  SCIPsetFreeBufferArray(scip->set, &negvars);
7409 
7410  return SCIP_OKAY;
7411 }
7412 
7413 
7414 /** force SCIP to clean up all cliques; cliques do not get automatically cleaned up after presolving. Use
7415  * this method to prevent inactive variables in cliques when retrieved via SCIPgetCliques()
7416  *
7417  * @return SCIP_OKAY if everything worked, otherwise a suitable error code is passed
7418  *
7419  * @pre This method can be called if @p scip is in one of the following stages:
7420  * - \ref SCIP_STAGE_TRANSFORMED
7421  * - \ref SCIP_STAGE_INITPRESOLVE
7422  * - \ref SCIP_STAGE_PRESOLVING
7423  * - \ref SCIP_STAGE_EXITPRESOLVE
7424  * - \ref SCIP_STAGE_PRESOLVED
7425  * - \ref SCIP_STAGE_INITSOLVE
7426  * - \ref SCIP_STAGE_SOLVING
7427  * - \ref SCIP_STAGE_SOLVED
7428  * - \ref SCIP_STAGE_EXITSOLVE
7429  */
7431  SCIP* scip, /**< SCIP data structure */
7432  SCIP_Bool* infeasible /**< pointer to store if cleanup detected infeasibility */
7433  )
7434 {
7435  int nlocalbdchgs;
7436  SCIP_Bool globalinfeasibility;
7437 
7438  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPcleanupCliques", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
7439 
7440  globalinfeasibility = FALSE;
7441  nlocalbdchgs = 0;
7442  SCIP_CALL( SCIPcliquetableCleanup(scip->cliquetable, scip->mem->probmem, scip->set, scip->stat, scip->transprob,
7443  scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, &nlocalbdchgs,
7444  &globalinfeasibility) );
7445 
7446  if( infeasible != NULL )
7447  *infeasible = globalinfeasibility;
7448 
7449  if( globalinfeasibility )
7451 
7452  return SCIP_OKAY;
7453 }
7454 
7455 /** gets the number of cliques in the clique table
7456  *
7457  * @return number of cliques in the clique table
7458  *
7459  * @note cliques do not get automatically cleaned up after presolving. Use SCIPcleanupCliques()
7460  * to prevent inactive variables in cliques when retrieved via SCIPgetCliques(). This might reduce the number of cliques
7461  *
7462  * @pre This method can be called if @p scip is in one of the following stages:
7463  * - \ref SCIP_STAGE_TRANSFORMED
7464  * - \ref SCIP_STAGE_INITPRESOLVE
7465  * - \ref SCIP_STAGE_PRESOLVING
7466  * - \ref SCIP_STAGE_EXITPRESOLVE
7467  * - \ref SCIP_STAGE_PRESOLVED
7468  * - \ref SCIP_STAGE_INITSOLVE
7469  * - \ref SCIP_STAGE_SOLVING
7470  * - \ref SCIP_STAGE_SOLVED
7471  * - \ref SCIP_STAGE_EXITSOLVE
7472  */
7474  SCIP* scip /**< SCIP data structure */
7475  )
7476 {
7477  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNCliques", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
7478 
7480 }
7481 
7482 /** gets the number of cliques created so far by the cliquetable
7483  *
7484  * @return number of cliques created so far by the cliquetable
7485  *
7486  * @note cliques do not get automatically cleaned up after presolving. Use SCIPcleanupCliques()
7487  * to prevent inactive variables in cliques when retrieved via SCIPgetCliques(). This might reduce the number of cliques
7488  *
7489  * @pre This method can be called if @p scip is in one of the following stages:
7490  * - \ref SCIP_STAGE_TRANSFORMED
7491  * - \ref SCIP_STAGE_INITPRESOLVE
7492  * - \ref SCIP_STAGE_PRESOLVING
7493  * - \ref SCIP_STAGE_EXITPRESOLVE
7494  * - \ref SCIP_STAGE_PRESOLVED
7495  * - \ref SCIP_STAGE_INITSOLVE
7496  * - \ref SCIP_STAGE_SOLVING
7497  * - \ref SCIP_STAGE_SOLVED
7498  * - \ref SCIP_STAGE_EXITSOLVE
7499  */
7501  SCIP* scip /**< SCIP data structure */
7502  )
7503 {
7504  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNCliquesCreated", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
7505 
7507 }
7508 
7509 /** gets the array of cliques in the clique table
7510  *
7511  * @return array of cliques in the clique table
7512  *
7513  * @note cliques do not get automatically cleaned up after presolving. Use SCIPcleanupCliques()
7514  * to prevent inactive variables in cliques when retrieved via SCIPgetCliques(). This might reduce the number of cliques
7515  *
7516  * @pre This method can be called if @p scip is in one of the following stages:
7517  * - \ref SCIP_STAGE_TRANSFORMED
7518  * - \ref SCIP_STAGE_INITPRESOLVE
7519  * - \ref SCIP_STAGE_PRESOLVING
7520  * - \ref SCIP_STAGE_EXITPRESOLVE
7521  * - \ref SCIP_STAGE_PRESOLVED
7522  * - \ref SCIP_STAGE_INITSOLVE
7523  * - \ref SCIP_STAGE_SOLVING
7524  * - \ref SCIP_STAGE_SOLVED
7525  * - \ref SCIP_STAGE_EXITSOLVE
7526  */
7528  SCIP* scip /**< SCIP data structure */
7529  )
7530 {
7531  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetCliques", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
7532 
7533  return SCIPcliquetableGetCliques(scip->cliquetable);
7534 }
7535 
7536 /** returns whether there is a clique that contains both given variable/value pairs;
7537  * the variables must be active binary variables;
7538  * if regardimplics is FALSE, only the cliques in the clique table are looked at;
7539  * if regardimplics is TRUE, both the cliques and the implications of the implication graph are regarded
7540  *
7541  * @return TRUE, if there is a clique that contains both variable/clique pairs; FALSE, otherwise
7542  *
7543  * @pre This method can be called if @p scip is in one of the following stages:
7544  * - \ref SCIP_STAGE_TRANSFORMED
7545  * - \ref SCIP_STAGE_INITPRESOLVE
7546  * - \ref SCIP_STAGE_PRESOLVING
7547  * - \ref SCIP_STAGE_EXITPRESOLVE
7548  * - \ref SCIP_STAGE_PRESOLVED
7549  * - \ref SCIP_STAGE_INITSOLVE
7550  * - \ref SCIP_STAGE_SOLVING
7551  * - \ref SCIP_STAGE_SOLVED
7552  * - \ref SCIP_STAGE_EXITSOLVE
7553  *
7554  * @note a variable with it's negated variable are NOT! in a clique
7555  * @note a variable with itself are in a clique
7556  */
7558  SCIP* scip, /**< SCIP data structure */
7559  SCIP_VAR* var1, /**< first variable */
7560  SCIP_Bool value1, /**< value of first variable */
7561  SCIP_VAR* var2, /**< second variable */
7562  SCIP_Bool value2, /**< value of second variable */
7563  SCIP_Bool regardimplics /**< should the implication graph also be searched for a clique? */
7564  )
7565 {
7566  assert(scip != NULL);
7567  assert(var1 != NULL);
7568  assert(var2 != NULL);
7569  assert(SCIPvarIsActive(var1));
7570  assert(SCIPvarIsActive(var2));
7571  assert(SCIPvarIsBinary(var1));
7572  assert(SCIPvarIsBinary(var2));
7573 
7574  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPhaveVarsCommonClique", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
7575 
7576  /* if both variables together have more cliques then actual cliques exist, then they have a common clique (in debug
7577  * mode we check this for correctness), otherwise we need to call the pairwise comparison method for these variables
7578  */
7579 #ifndef NDEBUG
7580  assert((SCIPvarGetNCliques(var1, value1) + SCIPvarGetNCliques(var2, value2) > SCIPcliquetableGetNCliques(scip->cliquetable)) ? SCIPvarsHaveCommonClique(var1, value1, var2, value2, FALSE) : TRUE);
7581 #endif
7582 
7583  return (SCIPvarGetNCliques(var1, value1) + SCIPvarGetNCliques(var2, value2) > SCIPcliquetableGetNCliques(scip->cliquetable)
7584  || SCIPvarsHaveCommonClique(var1, value1, var2, value2, regardimplics));
7585 }
7586 
7587 /** writes the clique graph to a gml file
7588  *
7589  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7590  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7591  *
7592  * @pre This method can be called if @p scip is in one of the following stages:
7593  * - \ref SCIP_STAGE_TRANSFORMED
7594  * - \ref SCIP_STAGE_INITPRESOLVE
7595  * - \ref SCIP_STAGE_PRESOLVING
7596  * - \ref SCIP_STAGE_EXITPRESOLVE
7597  * - \ref SCIP_STAGE_PRESOLVED
7598  * - \ref SCIP_STAGE_INITSOLVE
7599  * - \ref SCIP_STAGE_SOLVING
7600  * - \ref SCIP_STAGE_SOLVED
7601  * - \ref SCIP_STAGE_EXITSOLVE
7602  *
7603  * @note there can be duplicated arcs in the output file
7604  *
7605  * If @p writenodeweights is true, only nodes corresponding to variables that have a fractional value and only edges
7606  * between such nodes are written.
7607  */
7609  SCIP* scip, /**< SCIP data structure */
7610  const char* fname, /**< name of file */
7611  SCIP_Bool writenodeweights /**< should we write weights of nodes? */
7612  )
7613 {
7614  FILE* gmlfile;
7615  SCIP_HASHMAP* nodehashmap;
7616  SCIP_CLIQUE** cliques;
7617  SCIP_VAR** clqvars;
7618  SCIP_VAR** allvars;
7619  SCIP_Bool* clqvalues;
7620  char nodename[SCIP_MAXSTRLEN];
7621  int nallvars;
7622  int nbinvars;
7623  int nintvars;
7624  int nimplvars;
7625  int ncliques;
7626  int c;
7627  int v1;
7628  int v2;
7629  int id1;
7630  int id2;
7631 
7632  assert(scip != NULL);
7633  assert(fname != NULL);
7634 
7635  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPwriteCliqueGraph", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
7636 
7637  /* get all active variables */
7638  SCIP_CALL( SCIPgetVarsData(scip, &allvars, &nallvars, &nbinvars, &nintvars, &nimplvars, NULL) );
7639 
7640  /* no possible variables for cliques exist */
7641  if( nbinvars + nimplvars == 0 )
7642  return SCIP_OKAY;
7643 
7644  ncliques = SCIPgetNCliques(scip);
7645 
7646  /* no cliques and do not wont to check for binary implications */
7647  if( ncliques == 0 )
7648  return SCIP_OKAY;
7649 
7650  /* open gml file */
7651  gmlfile = fopen(fname, "w");
7652 
7653  if( gmlfile == NULL )
7654  {
7655  SCIPerrorMessage("cannot open graph file <%s>\n", fname);
7656  SCIPABORT();
7657  return SCIP_INVALIDDATA; /*lint !e527*/
7658  }
7659 
7660  /* create the hash map */
7661  SCIP_CALL_FINALLY( SCIPhashmapCreate(&nodehashmap, SCIPblkmem(scip), nbinvars+nimplvars), fclose(gmlfile) );
7662 
7663  /* write starting of gml file */
7664  SCIPgmlWriteOpening(gmlfile, TRUE);
7665 
7666  cliques = SCIPgetCliques(scip);
7667 
7668  /* write nodes and arcs for all cliques */
7669  for( c = ncliques - 1; c >= 0; --c )
7670  {
7671  clqvalues = SCIPcliqueGetValues(cliques[c]);
7672  clqvars = SCIPcliqueGetVars(cliques[c]);
7673 
7674  for( v1 = SCIPcliqueGetNVars(cliques[c]) - 1; v1 >= 0; --v1 )
7675  {
7676  id1 = clqvalues[v1] ? SCIPvarGetProbindex(clqvars[v1]) : (nallvars + SCIPvarGetProbindex(clqvars[v1]));
7677 
7678  /* if corresponding node was not added yet, add it */
7679  if( !SCIPhashmapExists(nodehashmap, (void*)(size_t)id1) )
7680  {
7681  assert(id1 >= 0);
7682  SCIP_CALL_FINALLY( SCIPhashmapInsert(nodehashmap, (void*)(size_t)id1, (void*)(size_t) 1), fclose(gmlfile) );
7683 
7684  (void) SCIPsnprintf(nodename, SCIP_MAXSTRLEN, "%s%s", (id1 >= nallvars ? "~" : ""), SCIPvarGetName(clqvars[v1]));
7685 
7686  /* write new gml node for new variable */
7687  if ( writenodeweights )
7688  {
7689  if ( ! SCIPisFeasIntegral(scip, SCIPgetSolVal(scip, NULL, clqvars[v1])) )
7690  SCIPgmlWriteNodeWeight(gmlfile, (unsigned int)id1, nodename, NULL, NULL, NULL, SCIPgetSolVal(scip, NULL, clqvars[v1]));
7691  }
7692  else
7693  {
7694  SCIPgmlWriteNode(gmlfile, (unsigned int)id1, nodename, NULL, NULL, NULL);
7695  }
7696  }
7697 
7698  for( v2 = SCIPcliqueGetNVars(cliques[c]) - 1; v2 >= 0; --v2 )
7699  {
7700  if( v1 == v2 )
7701  continue;
7702 
7703  id2 = clqvalues[v2] ? SCIPvarGetProbindex(clqvars[v2]) : (nallvars + SCIPvarGetProbindex(clqvars[v2]));
7704 
7705  /* if corresponding node was not added yet, add it */
7706  if( !SCIPhashmapExists(nodehashmap, (void*)(size_t)id2) )
7707  {
7708  assert(id2 >= 0);
7709  SCIP_CALL_FINALLY( SCIPhashmapInsert(nodehashmap, (void*)(size_t)id2, (void*)(size_t) 1), fclose(gmlfile) );
7710 
7711  (void) SCIPsnprintf(nodename, SCIP_MAXSTRLEN, "%s%s", (id2 >= nallvars ? "~" : ""), SCIPvarGetName(clqvars[v2]));
7712 
7713  /* write new gml node for new variable */
7714  if ( writenodeweights )
7715  {
7716  if ( ! SCIPisFeasIntegral(scip, SCIPgetSolVal(scip, NULL, clqvars[v2])) )
7717  SCIPgmlWriteNodeWeight(gmlfile, (unsigned int)id2, nodename, NULL, NULL, NULL, SCIPgetSolVal(scip, NULL, clqvars[v2]));
7718  }
7719  else
7720  {
7721  SCIPgmlWriteNode(gmlfile, (unsigned int)id2, nodename, NULL, NULL, NULL);
7722  }
7723  }
7724 
7725  /* write gml arc between resultant and operand */
7726  if ( ! writenodeweights || ! SCIPisFeasIntegral(scip, SCIPgetSolVal(scip, NULL, clqvars[v2])) )
7727  SCIPgmlWriteArc(gmlfile, (unsigned int)id1, (unsigned int)id2, NULL, NULL);
7728  }
7729  }
7730  }
7731 
7732  /* free the hash map */
7733  SCIPhashmapFree(&nodehashmap);
7734 
7735  SCIPgmlWriteClosing(gmlfile);
7736  fclose(gmlfile);
7737 
7738  return SCIP_OKAY;
7739 }
7740 
7741 /** Removes (irrelevant) variable from all its global structures, i.e. cliques, implications and variable bounds.
7742  * This is an advanced method which should be used with care.
7743  *
7744  * @return SCIP_OKAY if everything worked, otherwise a suitable error code is passed
7745  *
7746  * @pre This method can be called if @p scip is in one of the following stages:
7747  * - \ref SCIP_STAGE_TRANSFORMED
7748  * - \ref SCIP_STAGE_INITPRESOLVE
7749  * - \ref SCIP_STAGE_PRESOLVING
7750  * - \ref SCIP_STAGE_EXITPRESOLVE
7751  * - \ref SCIP_STAGE_PRESOLVED
7752  * - \ref SCIP_STAGE_INITSOLVE
7753  * - \ref SCIP_STAGE_SOLVING
7754  * - \ref SCIP_STAGE_SOLVED
7755  * - \ref SCIP_STAGE_EXITSOLVE
7756  */
7758  SCIP* scip, /**< SCIP data structure */
7759  SCIP_VAR* var /**< variable to remove from global structures */
7760  )
7761 {
7762  assert(scip != NULL);
7763 
7764  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPremoveVarFromGlobalStructures", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
7765 
7766  /* mark the variable as deletable from global structures - This is necessary for the delayed clean up of cliques */
7768 
7769  /* remove variable from all its cliques, implications, and variable bounds */
7771 
7772  return SCIP_OKAY;
7773 }
7774 
7775 /** sets the branch factor of the variable; this value can be used in the branching methods to scale the score
7776  * values of the variables; higher factor leads to a higher probability that this variable is chosen for branching
7777  *
7778  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7779  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7780  *
7781  * @pre This method can be called if @p scip is in one of the following stages:
7782  * - \ref SCIP_STAGE_PROBLEM
7783  * - \ref SCIP_STAGE_TRANSFORMING
7784  * - \ref SCIP_STAGE_TRANSFORMED
7785  * - \ref SCIP_STAGE_INITPRESOLVE
7786  * - \ref SCIP_STAGE_PRESOLVING
7787  * - \ref SCIP_STAGE_EXITPRESOLVE
7788  * - \ref SCIP_STAGE_PRESOLVED
7789  * - \ref SCIP_STAGE_SOLVING
7790  */
7792  SCIP* scip, /**< SCIP data structure */
7793  SCIP_VAR* var, /**< problem variable */
7794  SCIP_Real branchfactor /**< factor to weigh variable's branching score with */
7795  )
7796 {
7797  SCIP_CALL( SCIPcheckStage(scip, "SCIPchgVarBranchFactor", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
7798 
7799  SCIP_CALL( SCIPvarChgBranchFactor(var, scip->set, branchfactor) );
7800 
7801  return SCIP_OKAY;
7802 }
7803 
7804 /** scales the branch factor of the variable with the given value
7805  *
7806  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7807  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7808  *
7809  * @pre This method can be called if @p scip is in one of the following stages:
7810  * - \ref SCIP_STAGE_PROBLEM
7811  * - \ref SCIP_STAGE_TRANSFORMING
7812  * - \ref SCIP_STAGE_TRANSFORMED
7813  * - \ref SCIP_STAGE_INITPRESOLVE
7814  * - \ref SCIP_STAGE_PRESOLVING
7815  * - \ref SCIP_STAGE_EXITPRESOLVE
7816  * - \ref SCIP_STAGE_PRESOLVED
7817  * - \ref SCIP_STAGE_SOLVING
7818  */
7820  SCIP* scip, /**< SCIP data structure */
7821  SCIP_VAR* var, /**< problem variable */
7822  SCIP_Real scale /**< factor to scale variable's branching factor with */
7823  )
7824 {
7825  SCIP_CALL( SCIPcheckStage(scip, "SCIPscaleVarBranchFactor", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
7826 
7827  SCIP_CALL( SCIPvarChgBranchFactor(var, scip->set, scale * SCIPvarGetBranchFactor(var)) );
7828 
7829  return SCIP_OKAY;
7830 }
7831 
7832 /** adds the given value to the branch factor of the variable
7833  *
7834  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7835  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7836  *
7837  * @pre This method can be called if @p scip is in one of the following stages:
7838  * - \ref SCIP_STAGE_PROBLEM
7839  * - \ref SCIP_STAGE_TRANSFORMING
7840  * - \ref SCIP_STAGE_TRANSFORMED
7841  * - \ref SCIP_STAGE_INITPRESOLVE
7842  * - \ref SCIP_STAGE_PRESOLVING
7843  * - \ref SCIP_STAGE_EXITPRESOLVE
7844  * - \ref SCIP_STAGE_PRESOLVED
7845  * - \ref SCIP_STAGE_SOLVING
7846  */
7848  SCIP* scip, /**< SCIP data structure */
7849  SCIP_VAR* var, /**< problem variable */
7850  SCIP_Real addfactor /**< value to add to the branch factor of the variable */
7851  )
7852 {
7853  SCIP_CALL( SCIPcheckStage(scip, "SCIPaddVarBranchFactor", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
7854 
7855  SCIP_CALL( SCIPvarChgBranchFactor(var, scip->set, addfactor + SCIPvarGetBranchFactor(var)) );
7856 
7857  return SCIP_OKAY;
7858 }
7859 
7860 /** sets the branch priority of the variable; variables with higher branch priority are always preferred to variables
7861  * with lower priority in selection of branching variable
7862  *
7863  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7864  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7865  *
7866  * @pre This method can be called if @p scip is in one of the following stages:
7867  * - \ref SCIP_STAGE_PROBLEM
7868  * - \ref SCIP_STAGE_TRANSFORMING
7869  * - \ref SCIP_STAGE_TRANSFORMED
7870  * - \ref SCIP_STAGE_INITPRESOLVE
7871  * - \ref SCIP_STAGE_PRESOLVING
7872  * - \ref SCIP_STAGE_EXITPRESOLVE
7873  * - \ref SCIP_STAGE_PRESOLVED
7874  * - \ref SCIP_STAGE_SOLVING
7875  *
7876  * @note the default branching priority is 0
7877  */
7879  SCIP* scip, /**< SCIP data structure */
7880  SCIP_VAR* var, /**< problem variable */
7881  int branchpriority /**< branch priority of the variable */
7882  )
7883 {
7884  SCIP_CALL( SCIPcheckStage(scip, "SCIPchgVarBranchPriority", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
7885 
7886  assert( var->scip == scip );
7887 
7888  if( SCIPisTransformed(scip) )
7889  {
7890  assert(scip->branchcand != NULL);
7891 
7892  /* inform the pseudo branch candidates that the branch priority changes and change the branch priority */
7893  SCIP_CALL( SCIPbranchcandUpdateVarBranchPriority(scip->branchcand, scip->set, var, branchpriority) );
7894  }
7895  else
7896  {
7897  /* change the branching priority of the variable */
7898  SCIP_CALL( SCIPvarChgBranchPriority(var, branchpriority) );
7899  }
7900 
7901  return SCIP_OKAY;
7902 }
7903 
7904 /** changes the branch priority of the variable to the given value, if it is larger than the current priority
7905  *
7906  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7907  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7908  *
7909  * @pre This method can be called if @p scip is in one of the following stages:
7910  * - \ref SCIP_STAGE_PROBLEM
7911  * - \ref SCIP_STAGE_TRANSFORMING
7912  * - \ref SCIP_STAGE_TRANSFORMED
7913  * - \ref SCIP_STAGE_INITPRESOLVE
7914  * - \ref SCIP_STAGE_PRESOLVING
7915  * - \ref SCIP_STAGE_EXITPRESOLVE
7916  * - \ref SCIP_STAGE_PRESOLVED
7917  * - \ref SCIP_STAGE_SOLVING
7918  */
7920  SCIP* scip, /**< SCIP data structure */
7921  SCIP_VAR* var, /**< problem variable */
7922  int branchpriority /**< new branch priority of the variable, if it is larger than current priority */
7923  )
7924 {
7925  SCIP_CALL( SCIPcheckStage(scip, "SCIPupdateVarBranchPriority", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
7926 
7927  assert( var->scip == scip );
7928 
7929  if( branchpriority > SCIPvarGetBranchPriority(var) )
7930  {
7931  SCIP_CALL( SCIPvarChgBranchPriority(var, branchpriority) );
7932  }
7933 
7934  return SCIP_OKAY;
7935 }
7936 
7937 /** adds the given value to the branch priority of the variable
7938  *
7939  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7940  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7941  *
7942  * @pre This method can be called if @p scip is in one of the following stages:
7943  * - \ref SCIP_STAGE_PROBLEM
7944  * - \ref SCIP_STAGE_TRANSFORMING
7945  * - \ref SCIP_STAGE_TRANSFORMED
7946  * - \ref SCIP_STAGE_INITPRESOLVE
7947  * - \ref SCIP_STAGE_PRESOLVING
7948  * - \ref SCIP_STAGE_EXITPRESOLVE
7949  * - \ref SCIP_STAGE_PRESOLVED
7950  * - \ref SCIP_STAGE_SOLVING
7951  */
7953  SCIP* scip, /**< SCIP data structure */
7954  SCIP_VAR* var, /**< problem variable */
7955  int addpriority /**< value to add to the branch priority of the variable */
7956  )
7957 {
7958  SCIP_CALL( SCIPcheckStage(scip, "SCIPaddVarBranchPriority", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
7959 
7960  assert( var->scip == scip );
7961 
7962  SCIP_CALL( SCIPvarChgBranchPriority(var, addpriority + SCIPvarGetBranchPriority(var)) );
7963 
7964  return SCIP_OKAY;
7965 }
7966 
7967 /** sets the branch direction of the variable (-1: prefer downwards branch, 0: automatic selection, +1: prefer upwards
7968  * branch)
7969  *
7970  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7971  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7972  *
7973  * @pre This method can be called if @p scip is in one of the following stages:
7974  * - \ref SCIP_STAGE_PROBLEM
7975  * - \ref SCIP_STAGE_TRANSFORMING
7976  * - \ref SCIP_STAGE_TRANSFORMED
7977  * - \ref SCIP_STAGE_INITPRESOLVE
7978  * - \ref SCIP_STAGE_PRESOLVING
7979  * - \ref SCIP_STAGE_EXITPRESOLVE
7980  * - \ref SCIP_STAGE_PRESOLVED
7981  * - \ref SCIP_STAGE_SOLVING
7982  */
7984  SCIP* scip, /**< SCIP data structure */
7985  SCIP_VAR* var, /**< problem variable */
7986  SCIP_BRANCHDIR branchdirection /**< preferred branch direction of the variable (downwards, upwards, auto) */
7987  )
7988 {
7989  SCIP_CALL( SCIPcheckStage(scip, "SCIPchgVarBranchDirection", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
7990 
7991  assert( var->scip == scip );
7992 
7993  SCIP_CALL( SCIPvarChgBranchDirection(var, branchdirection) );
7994 
7995  return SCIP_OKAY;
7996 }
7997 
7998 /** tightens the variable bounds due a new variable type */
7999 static
8001  SCIP* scip, /**< SCIP data structure */
8002  SCIP_VAR* var, /**< variable to change the bound for */
8003  SCIP_VARTYPE vartype, /**< new type of variable */
8004  SCIP_Bool* infeasible /**< pointer to store whether an infeasibility was detected (, due to
8005  * integrality condition of the new variable type) */
8006  )
8007 {
8008  assert(scip != NULL);
8010  assert(scip->set->stage == SCIP_STAGE_PROBLEM || SCIPvarIsTransformed(var));
8011  assert(var->scip == scip);
8012 
8013  *infeasible = FALSE;
8014 
8015  /* adjusts bounds if the variable type changed form continuous to non-continuous (integral) */
8017  {
8018  SCIP_Bool tightened;
8019 
8020  /* we adjust variable bounds to integers first, since otherwise a later bound tightening with a fractional old
8021  * bound may give an assert because SCIP expects non-continuous variables to have non-fractional bounds
8022  *
8023  * we adjust bounds with a fractionality within [eps,feastol] only if the resulting bound change is a bound
8024  * tightening, because relaxing bounds may not be allowed
8025  */
8026  if( !SCIPisFeasIntegral(scip, SCIPvarGetLbGlobal(var)) ||
8028  )
8029  {
8030  SCIP_CALL( SCIPtightenVarLbGlobal(scip, var, SCIPfeasCeil(scip, SCIPvarGetLbGlobal(var)), TRUE, infeasible, &tightened) );
8031  if( *infeasible )
8032  return SCIP_OKAY;
8033 
8034  /* the only reason for not applying a forced boundchange is when the new bound is reduced because the variables upper bound is below the new bound
8035  * in a concrete case, lb == ub == 100.99999001; even though within feastol of 101, the lower bound cannot be tighented to 101 due to the upper bound
8036  */
8037  assert(tightened || SCIPisFeasLE(scip, SCIPvarGetUbGlobal(var), SCIPfeasCeil(scip, SCIPvarGetLbGlobal(var))));
8038  }
8039  if( !SCIPisFeasIntegral(scip, SCIPvarGetUbGlobal(var)) ||
8041  )
8042  {
8043  SCIP_CALL( SCIPtightenVarUbGlobal(scip, var, SCIPfeasFloor(scip, SCIPvarGetUbGlobal(var)), TRUE, infeasible, &tightened) );
8044  if( *infeasible )
8045  return SCIP_OKAY;
8046 
8047  assert(tightened || SCIPisFeasGE(scip, SCIPvarGetLbGlobal(var), SCIPfeasFloor(scip, SCIPvarGetUbGlobal(var))));
8048  }
8049  }
8050 
8051  return SCIP_OKAY;
8052 }
8053 
8054 /** changes type of variable in the problem;
8055  *
8056  * @warning This type change might change the variable array returned from SCIPgetVars() and SCIPgetVarsData();
8057  *
8058  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8059  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8060  *
8061  * @pre This method can be called if @p scip is in one of the following stages:
8062  * - \ref SCIP_STAGE_PROBLEM
8063  * - \ref SCIP_STAGE_TRANSFORMING
8064  * - \ref SCIP_STAGE_PRESOLVING
8065  *
8066  * @note If SCIP is already beyond the SCIP_STAGE_PROBLEM and a original variable is passed, the variable type of the
8067  * corresponding transformed variable is changed; the type of the original variable does not change
8068  *
8069  * @note If the type changes from a continuous variable to a non-continuous variable the bounds of the variable get
8070  * adjusted w.r.t. to integrality information
8071  */
8073  SCIP* scip, /**< SCIP data structure */
8074  SCIP_VAR* var, /**< variable to change the bound for */
8075  SCIP_VARTYPE vartype, /**< new type of variable */
8076  SCIP_Bool* infeasible /**< pointer to store whether an infeasibility was detected (, due to
8077  * integrality condition of the new variable type) */
8078  )
8079 {
8080  SCIP_CALL( SCIPcheckStage(scip, "SCIPchgVarType", FALSE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
8081 
8082  assert(var != NULL);
8083  assert(var->scip == scip);
8084 
8085  if( SCIPvarIsNegated(var) )
8086  {
8087  SCIPdebugMsg(scip, "upgrading type of negated variable <%s> from %d to %d\n", SCIPvarGetName(var), SCIPvarGetType(var), vartype);
8088  var = SCIPvarGetNegationVar(var);
8089  }
8090 #ifndef NDEBUG
8091  else
8092  {
8093  if( SCIPgetStage(scip) > SCIP_STAGE_PROBLEM )
8094  {
8095  SCIPdebugMsg(scip, "upgrading type of variable <%s> from %d to %d\n", SCIPvarGetName(var), SCIPvarGetType(var), vartype);
8096  }
8097  }
8098 #endif
8099 
8100  /* change variable type */
8101  switch( scip->set->stage )
8102  {
8103  case SCIP_STAGE_PROBLEM:
8104  assert(!SCIPvarIsTransformed(var));
8105 
8106  /* first adjust the variable due to new integrality information */
8107  SCIP_CALL( tightenBounds(scip, var, vartype, infeasible) );
8108 
8109  /* second change variable type */
8110  if( SCIPvarGetProbindex(var) >= 0 )
8111  {
8112  SCIP_CALL( SCIPprobChgVarType(scip->origprob, scip->mem->probmem, scip->set, scip->branchcand, scip->cliquetable, var, vartype) );
8113  }
8114  else
8115  {
8116  SCIP_CALL( SCIPvarChgType(var, vartype) );
8117  }
8118  break;
8119 
8120  case SCIP_STAGE_PRESOLVING:
8121  if( !SCIPvarIsTransformed(var) )
8122  {
8123  SCIP_VAR* transvar;
8124 
8125  SCIP_CALL( SCIPgetTransformedVar(scip, var, &transvar) );
8126  assert(transvar != NULL);
8127 
8128  /* recall method with transformed variable */
8129  SCIP_CALL( SCIPchgVarType(scip, transvar, vartype, infeasible) );
8130  return SCIP_OKAY;
8131  }
8132 
8133  /* first adjust the variable due to new integrality information */
8134  SCIP_CALL( tightenBounds(scip, var, vartype, infeasible) );
8135 
8136  /* second change variable type */
8137  if( SCIPvarGetProbindex(var) >= 0 )
8138  {
8139  SCIP_CALL( SCIPprobChgVarType(scip->transprob, scip->mem->probmem, scip->set, scip->branchcand, scip->cliquetable, var, vartype) );
8140  }
8141  else
8142  {
8143  SCIP_CALL( SCIPvarChgType(var, vartype) );
8144  }
8145  break;
8146 
8147  default:
8148  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
8149  return SCIP_INVALIDCALL;
8150  } /*lint !e788*/
8151 
8152  return SCIP_OKAY;
8153 }
8154 
8155 /** in problem creation and solving stage, both bounds of the variable are set to the given value;
8156  * in presolving stage, the variable is converted into a fixed variable, and bounds are changed respectively;
8157  * conversion into a fixed variable changes the vars array returned from SCIPgetVars() and SCIPgetVarsData(),
8158  * and also renders arrays returned from the SCIPvarGetImpl...() methods invalid
8159  *
8160  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8161  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8162  *
8163  * @pre This method can be called if @p scip is in one of the following stages:
8164  * - \ref SCIP_STAGE_PROBLEM
8165  * - \ref SCIP_STAGE_PRESOLVING
8166  * - \ref SCIP_STAGE_SOLVING
8167  */
8169  SCIP* scip, /**< SCIP data structure */
8170  SCIP_VAR* var, /**< variable to fix */
8171  SCIP_Real fixedval, /**< value to fix variable to */
8172  SCIP_Bool* infeasible, /**< pointer to store whether the fixing is infeasible */
8173  SCIP_Bool* fixed /**< pointer to store whether the fixing was performed (variable was unfixed) */
8174  )
8175 {
8176  assert(var != NULL);
8177  assert(infeasible != NULL);
8178  assert(fixed != NULL);
8179 
8180  SCIP_CALL( SCIPcheckStage(scip, "SCIPfixVar", FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
8181 
8182  *infeasible = FALSE;
8183  *fixed = FALSE;
8184 
8185  /* in the problem creation stage, modify the bounds as requested, independently from the current bounds */
8186  if( scip->set->stage != SCIP_STAGE_PROBLEM )
8187  {
8188  if( (SCIPvarGetType(var) != SCIP_VARTYPE_CONTINUOUS && !SCIPsetIsFeasIntegral(scip->set, fixedval))
8189  || SCIPsetIsFeasLT(scip->set, fixedval, SCIPvarGetLbLocal(var))
8190  || SCIPsetIsFeasGT(scip->set, fixedval, SCIPvarGetUbLocal(var)) )
8191  {
8192  *infeasible = TRUE;
8193  return SCIP_OKAY;
8194  }
8195  else if( SCIPvarGetStatus(var) == SCIP_VARSTATUS_FIXED )
8196  {
8197  *infeasible = !SCIPsetIsFeasEQ(scip->set, fixedval, SCIPvarGetLbLocal(var));
8198  return SCIP_OKAY;
8199  }
8200  }
8201  else
8202  assert(SCIPvarGetStatus(var) == SCIP_VARSTATUS_ORIGINAL);
8203 
8204  switch( scip->set->stage )
8205  {
8206  case SCIP_STAGE_PROBLEM:
8207  /* in the problem creation stage, modify the bounds as requested, independently from the current bounds;
8208  * we have to make sure, that the order of the bound changes does not intermediately produce an invalid
8209  * interval lb > ub
8210  */
8211  if( fixedval <= SCIPvarGetLbLocal(var) )
8212  {
8213  SCIP_CALL( SCIPchgVarLb(scip, var, fixedval) );
8214  SCIP_CALL( SCIPchgVarUb(scip, var, fixedval) );
8215  *fixed = TRUE;
8216  }
8217  else
8218  {
8219  SCIP_CALL( SCIPchgVarUb(scip, var, fixedval) );
8220  SCIP_CALL( SCIPchgVarLb(scip, var, fixedval) );
8221  *fixed = TRUE;
8222  }
8223  return SCIP_OKAY;
8224 
8225  case SCIP_STAGE_PRESOLVING:
8226  if( SCIPtreeGetCurrentDepth(scip->tree) == 0 )
8227  {
8228  SCIP_CALL( SCIPvarFix(var, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob,
8229  scip->primal, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable,
8230  fixedval, infeasible, fixed) );
8231  return SCIP_OKAY;
8232  }
8233  /*lint -fallthrough*/
8234  case SCIP_STAGE_SOLVING:
8235  if( SCIPsetIsFeasGT(scip->set, fixedval, SCIPvarGetLbLocal(var)) )
8236  {
8237  SCIP_CALL( SCIPchgVarLb(scip, var, fixedval) );
8238  *fixed = TRUE;
8239  }
8240  if( SCIPsetIsFeasLT(scip->set, fixedval, SCIPvarGetUbLocal(var)) )
8241  {
8242  SCIP_CALL( SCIPchgVarUb(scip, var, fixedval) );
8243  *fixed = TRUE;
8244  }
8245  return SCIP_OKAY;
8246 
8247  default:
8248  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
8249  return SCIP_INVALIDCALL;
8250  } /*lint !e788*/
8251 }
8252 
8253 /** From a given equality a*x + b*y == c, aggregates one of the variables and removes it from the set of
8254  * active problem variables. This changes the vars array returned from SCIPgetVars() and SCIPgetVarsData(),
8255  * and also renders the arrays returned from the SCIPvarGetImpl...() methods for the two variables invalid.
8256  * In the first step, the equality is transformed into an equality with active problem variables
8257  * a'*x' + b'*y' == c'. If x' == y', this leads to the detection of redundancy if a' == -b' and c' == 0,
8258  * of infeasibility, if a' == -b' and c' != 0, or to a variable fixing x' == c'/(a'+b') (and possible
8259  * infeasibility) otherwise.
8260  * In the second step, the variable to be aggregated is chosen among x' and y', prefering a less strict variable
8261  * type as aggregation variable (i.e. continuous variables are preferred over implicit integers, implicit integers
8262  * over integers, and integers over binaries). If none of the variables is continuous, it is tried to find an integer
8263  * aggregation (i.e. integral coefficients a'' and b'', such that a''*x' + b''*y' == c''). This can lead to
8264  * the detection of infeasibility (e.g. if c'' is fractional), or to a rejection of the aggregation (denoted by
8265  * aggregated == FALSE), if the resulting integer coefficients are too large and thus numerically instable.
8266  *
8267  * The output flags have the following meaning:
8268  * - infeasible: the problem is infeasible
8269  * - redundant: the equality can be deleted from the constraint set
8270  * - aggregated: the aggregation was successfully performed (the variables were not aggregated before)
8271  *
8272  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8273  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8274  *
8275  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_PRESOLVING
8276  */
8278  SCIP* scip, /**< SCIP data structure */
8279  SCIP_VAR* varx, /**< variable x in equality a*x + b*y == c */
8280  SCIP_VAR* vary, /**< variable y in equality a*x + b*y == c */
8281  SCIP_Real scalarx, /**< multiplier a in equality a*x + b*y == c */
8282  SCIP_Real scalary, /**< multiplier b in equality a*x + b*y == c */
8283  SCIP_Real rhs, /**< right hand side c in equality a*x + b*y == c */
8284  SCIP_Bool* infeasible, /**< pointer to store whether the aggregation is infeasible */
8285  SCIP_Bool* redundant, /**< pointer to store whether the equality is (now) redundant */
8286  SCIP_Bool* aggregated /**< pointer to store whether the aggregation was successful */
8287  )
8288 {
8289  SCIP_Real constantx;
8290  SCIP_Real constanty;
8291 
8292  assert(infeasible != NULL);
8293  assert(redundant != NULL);
8294  assert(aggregated != NULL);
8295 
8296  SCIP_CALL( SCIPcheckStage(scip, "SCIPaggregateVars", FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
8297 
8298  *infeasible = FALSE;
8299  *redundant = FALSE;
8300  *aggregated = FALSE;
8301 
8302  if( SCIPtreeProbing(scip->tree) )
8303  {
8304  SCIPerrorMessage("cannot aggregate variables during probing\n");
8305  return SCIP_INVALIDCALL;
8306  }
8307  assert(SCIPtreeGetCurrentDepth(scip->tree) == 0);
8308 
8309  /* do not perform aggregation if it is globally deactivated */
8310  if( scip->set->presol_donotaggr )
8311  return SCIP_OKAY;
8312 
8313  /* get the corresponding equality in active problem variable space:
8314  * transform both expressions "a*x + 0" and "b*y + 0" into problem variable space
8315  */
8316  constantx = 0.0;
8317  constanty = 0.0;
8318  SCIP_CALL( SCIPvarGetProbvarSum(&varx, scip->set, &scalarx, &constantx) );
8319  SCIP_CALL( SCIPvarGetProbvarSum(&vary, scip->set, &scalary, &constanty) );
8320 
8321  /* we cannot aggregate multi-aggregated variables */
8323  return SCIP_OKAY;
8324 
8325  /* move the constant to the right hand side to acquire the form "a'*x' + b'*y' == c'" */
8326  rhs -= (constantx + constanty);
8327 
8328  /* if a scalar is zero, treat the variable as fixed-to-zero variable */
8329  if( SCIPsetIsZero(scip->set, scalarx) )
8330  varx = NULL;
8331  if( SCIPsetIsZero(scip->set, scalary) )
8332  vary = NULL;
8333 
8334  /* capture the special cases that less than two variables are left, due to resolutions to a fixed variable or
8335  * to the same active variable
8336  */
8337  if( varx == NULL && vary == NULL )
8338  {
8339  /* both variables were resolved to fixed variables */
8340  *infeasible = !SCIPsetIsZero(scip->set, rhs);
8341  *redundant = TRUE;
8342  }
8343  else if( varx == NULL )
8344  {
8345  assert(SCIPsetIsZero(scip->set, scalarx));
8346  assert(!SCIPsetIsZero(scip->set, scalary));
8347 
8348  /* variable x was resolved to fixed variable: variable y can be fixed to c'/b' */
8349  SCIP_CALL( SCIPvarFix(vary, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob,
8350  scip->primal, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable,
8351  rhs/scalary, infeasible, aggregated) );
8352  *redundant = TRUE;
8353  }
8354  else if( vary == NULL )
8355  {
8356  assert(SCIPsetIsZero(scip->set, scalary));
8357  assert(!SCIPsetIsZero(scip->set, scalarx));
8358 
8359  /* variable y was resolved to fixed variable: variable x can be fixed to c'/a' */
8360  SCIP_CALL( SCIPvarFix(varx, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob,
8361  scip->primal, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable,
8362  rhs/scalarx, infeasible, aggregated) );
8363  *redundant = TRUE;
8364  }
8365  else if( varx == vary )
8366  {
8367  /* both variables were resolved to the same active problem variable: this variable can be fixed */
8368  scalarx += scalary;
8369  if( SCIPsetIsZero(scip->set, scalarx) )
8370  {
8371  /* left hand side of equality is zero: equality is potentially infeasible */
8372  *infeasible = !SCIPsetIsZero(scip->set, rhs);
8373  }
8374  else
8375  {
8376  /* sum of scalars is not zero: fix variable x' == y' to c'/(a'+b') */
8377  SCIP_CALL( SCIPvarFix(varx, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob,
8378  scip->primal, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable,
8379  rhs/scalarx, infeasible, aggregated) );
8380  }
8381  *redundant = TRUE;
8382  }
8383  else
8384  {
8385  /* both variables are different active problem variables, and both scalars are non-zero: try to aggregate them */
8386  SCIP_CALL( SCIPvarTryAggregateVars(scip->set, scip->mem->probmem, scip->stat, scip->transprob, scip->origprob,
8387  scip->primal, scip->tree, scip->reopt, scip->lp, scip->cliquetable, scip->branchcand, scip->eventfilter,
8388  scip->eventqueue, varx, vary, scalarx, scalary, rhs, infeasible, aggregated) );
8389  *redundant = *aggregated;
8390  }
8391 
8392  return SCIP_OKAY;
8393 }
8394 
8395 /** converts variable into multi-aggregated variable; this changes the variable array returned from
8396  * SCIPgetVars() and SCIPgetVarsData();
8397  *
8398  * @warning The integrality condition is not checked anymore on the multi-aggregated variable. You must not
8399  * multi-aggregate an integer variable without being sure, that integrality on the aggregation variables
8400  * implies integrality on the aggregated variable.
8401  *
8402  * The output flags have the following meaning:
8403  * - infeasible: the problem is infeasible
8404  * - aggregated: the aggregation was successfully performed (the variables were not aggregated before)
8405  *
8406  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8407  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8408  *
8409  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_PRESOLVING
8410  */
8412  SCIP* scip, /**< SCIP data structure */
8413  SCIP_VAR* var, /**< variable x to aggregate */
8414  int naggvars, /**< number n of variables in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
8415  SCIP_VAR** aggvars, /**< variables y_i in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
8416  SCIP_Real* scalars, /**< multipliers a_i in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
8417  SCIP_Real constant, /**< constant shift c in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
8418  SCIP_Bool* infeasible, /**< pointer to store whether the aggregation is infeasible */
8419  SCIP_Bool* aggregated /**< pointer to store whether the aggregation was successful */
8420  )
8421 {
8422  SCIP_CALL( SCIPcheckStage(scip, "SCIPmultiaggregateVar", FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
8423 
8424  assert(var->scip == scip);
8425 
8426  if( SCIPtreeProbing(scip->tree) )
8427  {
8428  SCIPerrorMessage("cannot multi-aggregate variables during probing\n");
8429  return SCIP_INVALIDCALL;
8430  }
8431  assert(SCIPtreeGetCurrentDepth(scip->tree) == 0);
8432 
8433  SCIP_CALL( SCIPvarMultiaggregate(var, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob,
8434  scip->primal, scip->tree, scip->reopt, scip->lp, scip->cliquetable, scip->branchcand, scip->eventfilter,
8435  scip->eventqueue, naggvars, aggvars, scalars, constant, infeasible, aggregated) );
8436 
8437  return SCIP_OKAY;
8438 }
8439 
8440 /** returns whether aggregation of variables is not allowed */
8442  SCIP* scip /**< SCIP data structure */
8443  )
8444 {
8445  assert(scip != NULL);
8446 
8447  return scip->set->presol_donotaggr;
8448 }
8449 
8450 /** returns whether multi-aggregation is disabled */
8452  SCIP* scip /**< SCIP data structure */
8453  )
8454 {
8455  assert(scip != NULL);
8456 
8457  return scip->set->presol_donotmultaggr;
8458 }
8459 
8460 /** returns whether variable is not allowed to be multi-aggregated */
8462  SCIP* scip, /**< SCIP data structure */
8463  SCIP_VAR* var /**< variable x to aggregate */
8464  )
8465 {
8466  assert(scip != NULL);
8467  assert(var != NULL);
8468  assert(var->scip == scip);
8469 
8470  return scip->set->presol_donotmultaggr || SCIPvarDoNotMultaggr(var);
8471 }
8472 
8473 /** returns whether dual reductions are allowed during propagation and presolving
8474  *
8475  * @note A reduction is called dual, if it may discard feasible solutions, but leaves at least one optimal solution
8476  * intact. Often such reductions are based on analyzing the objective function, reduced costs, and/or dual LPs.
8477  */
8479  SCIP* scip /**< SCIP data structure */
8480  )
8481 {
8482  assert(scip != NULL);
8483 
8484  return !scip->set->reopt_enable && scip->set->misc_allowdualreds;
8485 }
8486 
8487 /** returns whether propagation w.r.t. current objective is allowed */
8489  SCIP* scip /**< SCIP data structure */
8490  )
8491 {
8492  assert(scip != NULL);
8493 
8494  return !scip->set->reopt_enable && scip->set->misc_allowobjprop;
8495 }
8496 
8497 /** marks the variable that it must not be multi-aggregated
8498  *
8499  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8500  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8501  *
8502  * @pre This method can be called if @p scip is in one of the following stages:
8503  * - \ref SCIP_STAGE_INIT
8504  * - \ref SCIP_STAGE_PROBLEM
8505  * - \ref SCIP_STAGE_TRANSFORMING
8506  * - \ref SCIP_STAGE_TRANSFORMED
8507  * - \ref SCIP_STAGE_INITPRESOLVE
8508  * - \ref SCIP_STAGE_PRESOLVING
8509  * - \ref SCIP_STAGE_EXITPRESOLVE
8510  *
8511  * @note There exists no "unmark" method since it has to be ensured that if a plugin requires that a variable is not
8512  * multi-aggregated that this is will be the case.
8513  */
8515  SCIP* scip, /**< SCIP data structure */
8516  SCIP_VAR* var /**< variable to delete */
8517  )
8518 {
8519  assert(scip != NULL);
8520  assert(var != NULL);
8521  assert(var->scip == scip);
8522 
8523  SCIP_CALL( SCIPcheckStage(scip, "SCIPmarkDoNotMultaggrVar", TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE) );
8524 
8526 
8527  return SCIP_OKAY;
8528 }
8529 
8530 /** enables the collection of statistics for a variable
8531  *
8532  * @pre This method can be called if @p scip is in one of the following stages:
8533  * - \ref SCIP_STAGE_PROBLEM
8534  * - \ref SCIP_STAGE_INITPRESOLVE
8535  * - \ref SCIP_STAGE_PRESOLVING
8536  * - \ref SCIP_STAGE_EXITPRESOLVE
8537  * - \ref SCIP_STAGE_SOLVING
8538  * - \ref SCIP_STAGE_SOLVED
8539  */
8541  SCIP* scip /**< SCIP data structure */
8542  )
8543 {
8544  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPenableVarHistory", FALSE, TRUE, FALSE, FALSE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
8545 
8547 }
8548 
8549 /** disables the collection of any statistic for a variable
8550  *
8551  * @pre This method can be called if @p scip is in one of the following stages:
8552  * - \ref SCIP_STAGE_PROBLEM
8553  * - \ref SCIP_STAGE_INITPRESOLVE
8554  * - \ref SCIP_STAGE_PRESOLVING
8555  * - \ref SCIP_STAGE_EXITPRESOLVE
8556  * - \ref SCIP_STAGE_SOLVING
8557  * - \ref SCIP_STAGE_SOLVED
8558  */
8560  SCIP* scip /**< SCIP data structure */
8561  )
8562 {
8563  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPdisableVarHistory", FALSE, TRUE, FALSE, FALSE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
8564 
8566 }
8567 
8568 /** updates the pseudo costs of the given variable and the global pseudo costs after a change of "solvaldelta" in the
8569  * variable's solution value and resulting change of "objdelta" in the in the LP's objective value;
8570  * the update is ignored, if the objective value difference is infinite
8571  *
8572  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8573  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8574  *
8575  * @pre This method can be called if @p scip is in one of the following stages:
8576  * - \ref SCIP_STAGE_SOLVING
8577  * - \ref SCIP_STAGE_SOLVED
8578  */
8580  SCIP* scip, /**< SCIP data structure */
8581  SCIP_VAR* var, /**< problem variable */
8582  SCIP_Real solvaldelta, /**< difference of variable's new LP value - old LP value */
8583  SCIP_Real objdelta, /**< difference of new LP's objective value - old LP's objective value */
8584  SCIP_Real weight /**< weight in (0,1] of this update in pseudo cost sum */
8585  )
8586 {
8587  SCIP_CALL( SCIPcheckStage(scip, "SCIPupdateVarPseudocost", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
8588 
8589  if( !SCIPsetIsInfinity(scip->set, 2*objdelta) ) /* differences infinity - eps should also be treated as infinity */
8590  {
8591  if( scip->set->branch_divingpscost || (!scip->lp->diving && !SCIPtreeProbing(scip->tree)) )
8592  {
8593  SCIP_CALL( SCIPvarUpdatePseudocost(var, scip->set, scip->stat, solvaldelta, objdelta, weight) );
8594  }
8595  }
8596 
8597  return SCIP_OKAY;
8598 }
8599 
8600 /** gets the variable's pseudo cost value for the given change of the variable's LP value
8601  *
8602  * @return the variable's pseudo cost value for the given change of the variable's LP value
8603  *
8604  * @pre This method can be called if @p scip is in one of the following stages:
8605  * - \ref SCIP_STAGE_INITPRESOLVE
8606  * - \ref SCIP_STAGE_PRESOLVING
8607  * - \ref SCIP_STAGE_EXITPRESOLVE
8608  * - \ref SCIP_STAGE_PRESOLVED
8609  * - \ref SCIP_STAGE_INITSOLVE
8610  * - \ref SCIP_STAGE_SOLVING
8611  * - \ref SCIP_STAGE_SOLVED
8612  */
8614  SCIP* scip, /**< SCIP data structure */
8615  SCIP_VAR* var, /**< problem variable */
8616  SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
8617  )
8618 {
8619  assert( var->scip == scip );
8620 
8621  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarPseudocostVal", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
8622 
8623  return SCIPvarGetPseudocost(var, scip->stat, solvaldelta);
8624 }
8625 
8626 /** gets the variable's pseudo cost value for the given change of the variable's LP value,
8627  * only using the pseudo cost information of the current run
8628  *
8629  * @return the variable's pseudo cost value for the given change of the variable's LP value,
8630  * only using the pseudo cost information of the current run
8631  *
8632  * @pre This method can be called if @p scip is in one of the following stages:
8633  * - \ref SCIP_STAGE_INITPRESOLVE
8634  * - \ref SCIP_STAGE_PRESOLVING
8635  * - \ref SCIP_STAGE_EXITPRESOLVE
8636  * - \ref SCIP_STAGE_PRESOLVED
8637  * - \ref SCIP_STAGE_INITSOLVE
8638  * - \ref SCIP_STAGE_SOLVING
8639  * - \ref SCIP_STAGE_SOLVED
8640  */
8642  SCIP* scip, /**< SCIP data structure */
8643  SCIP_VAR* var, /**< problem variable */
8644  SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
8645  )
8646 {
8647  assert( var->scip == scip );
8648 
8649  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarPseudocostValCurrentRun", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
8650 
8651  return SCIPvarGetPseudocostCurrentRun(var, scip->stat, solvaldelta);
8652 }
8653 
8654 /** gets the variable's pseudo cost value for the given direction
8655  *
8656  * @return the variable's pseudo cost value for the given direction
8657  *
8658  * @pre This method can be called if @p scip is in one of the following stages:
8659  * - \ref SCIP_STAGE_INITPRESOLVE
8660  * - \ref SCIP_STAGE_PRESOLVING
8661  * - \ref SCIP_STAGE_EXITPRESOLVE
8662  * - \ref SCIP_STAGE_PRESOLVED
8663  * - \ref SCIP_STAGE_INITSOLVE
8664  * - \ref SCIP_STAGE_SOLVING
8665  * - \ref SCIP_STAGE_SOLVED
8666  */
8668  SCIP* scip, /**< SCIP data structure */
8669  SCIP_VAR* var, /**< problem variable */
8670  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
8671  )
8672 {
8673  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarPseudocost", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
8674  assert(dir == SCIP_BRANCHDIR_DOWNWARDS || dir == SCIP_BRANCHDIR_UPWARDS);
8675  assert(var->scip == scip);
8676 
8677  return SCIPvarGetPseudocost(var, scip->stat, dir == SCIP_BRANCHDIR_DOWNWARDS ? -1.0 : 1.0);
8678 }
8679 
8680 /** gets the variable's pseudo cost value for the given direction,
8681  * only using the pseudo cost information of the current run
8682  *
8683  * @return the variable's pseudo cost value for the given direction,
8684  * only using the pseudo cost information of the current run
8685  *
8686  * @pre This method can be called if @p scip is in one of the following stages:
8687  * - \ref SCIP_STAGE_INITPRESOLVE
8688  * - \ref SCIP_STAGE_PRESOLVING
8689  * - \ref SCIP_STAGE_EXITPRESOLVE
8690  * - \ref SCIP_STAGE_PRESOLVED
8691  * - \ref SCIP_STAGE_INITSOLVE
8692  * - \ref SCIP_STAGE_SOLVING
8693  * - \ref SCIP_STAGE_SOLVED
8694  */
8696  SCIP* scip, /**< SCIP data structure */
8697  SCIP_VAR* var, /**< problem variable */
8698  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
8699  )
8700 {
8701  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarPseudocostCurrentRun", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
8702  assert(dir == SCIP_BRANCHDIR_DOWNWARDS || dir == SCIP_BRANCHDIR_UPWARDS);
8703  assert(var->scip == scip);
8704 
8705  return SCIPvarGetPseudocostCurrentRun(var, scip->stat, dir == SCIP_BRANCHDIR_DOWNWARDS ? -1.0 : 1.0);
8706 }
8707 
8708 /** gets the variable's (possible fractional) number of pseudo cost updates for the given direction
8709  *
8710  * @return the variable's (possible fractional) number of pseudo cost updates for the given direction
8711  *
8712  * @pre This method can be called if @p scip is in one of the following stages:
8713  * - \ref SCIP_STAGE_INITPRESOLVE
8714  * - \ref SCIP_STAGE_PRESOLVING
8715  * - \ref SCIP_STAGE_EXITPRESOLVE
8716  * - \ref SCIP_STAGE_PRESOLVED
8717  * - \ref SCIP_STAGE_INITSOLVE
8718  * - \ref SCIP_STAGE_SOLVING
8719  * - \ref SCIP_STAGE_SOLVED
8720  */
8722  SCIP* scip, /**< SCIP data structure */
8723  SCIP_VAR* var, /**< problem variable */
8724  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
8725  )
8726 {
8727  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarPseudocostCount", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
8728  assert(dir == SCIP_BRANCHDIR_DOWNWARDS || dir == SCIP_BRANCHDIR_UPWARDS);
8729  assert(var->scip == scip);
8730 
8731  return SCIPvarGetPseudocostCount(var, dir);
8732 }
8733 
8734 /** gets the variable's (possible fractional) number of pseudo cost updates for the given direction,
8735  * only using the pseudo cost information of the current run
8736  *
8737  * @return the variable's (possible fractional) number of pseudo cost updates for the given direction,
8738  * only using the pseudo cost information of the current run
8739  *
8740  * @pre This method can be called if @p scip is in one of the following stages:
8741  * - \ref SCIP_STAGE_INITPRESOLVE
8742  * - \ref SCIP_STAGE_PRESOLVING
8743  * - \ref SCIP_STAGE_EXITPRESOLVE
8744  * - \ref SCIP_STAGE_PRESOLVED
8745  * - \ref SCIP_STAGE_INITSOLVE
8746  * - \ref SCIP_STAGE_SOLVING
8747  * - \ref SCIP_STAGE_SOLVED
8748  */
8750  SCIP* scip, /**< SCIP data structure */
8751  SCIP_VAR* var, /**< problem variable */
8752  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
8753  )
8754 {
8755  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarPseudocostCountCurrentRun", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
8756  assert(dir == SCIP_BRANCHDIR_DOWNWARDS || dir == SCIP_BRANCHDIR_UPWARDS);
8757  assert(var->scip == scip);
8758 
8759  return SCIPvarGetPseudocostCountCurrentRun(var, dir);
8760 }
8761 
8762 /** get pseudo cost variance of the variable, either for entire solve or only for current branch and bound run
8763  *
8764  * @return returns the (corrected) variance of pseudo code information collected so far.
8765  *
8766  * @pre This method can be called if @p scip is in one of the following stages:
8767  * - \ref SCIP_STAGE_INITPRESOLVE
8768  * - \ref SCIP_STAGE_PRESOLVING
8769  * - \ref SCIP_STAGE_EXITPRESOLVE
8770  * - \ref SCIP_STAGE_PRESOLVED
8771  * - \ref SCIP_STAGE_INITSOLVE
8772  * - \ref SCIP_STAGE_SOLVING
8773  * - \ref SCIP_STAGE_SOLVED
8774  */
8776  SCIP* scip, /**< SCIP data structure */
8777  SCIP_VAR* var, /**< problem variable */
8778  SCIP_BRANCHDIR dir, /**< branching direction (downwards, or upwards) */
8779  SCIP_Bool onlycurrentrun /**< only for pseudo costs of current branch and bound run */
8780  )
8781 {
8782  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarPseudocostVariance", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
8783  assert(dir == SCIP_BRANCHDIR_DOWNWARDS || dir == SCIP_BRANCHDIR_UPWARDS);
8784  assert(var->scip == scip);
8785 
8786  return SCIPvarGetPseudocostVariance(var, dir, onlycurrentrun);
8787 }
8788 
8789 /** calculates a confidence bound for this variable under the assumption of normally distributed pseudo costs
8790  *
8791  * The confidence bound \f$ \theta \geq 0\f$ denotes the interval borders \f$ [X - \theta, \ X + \theta]\f$, which contains
8792  * the true pseudo costs of the variable, i.e., the expected value of the normal distribution, with a probability
8793  * of 2 * clevel - 1.
8794  *
8795  * @return value of confidence bound for this variable
8796  */
8798  SCIP* scip, /**< SCIP data structure */
8799  SCIP_VAR* var, /**< variable in question */
8800  SCIP_BRANCHDIR dir, /**< the branching direction for the confidence bound */
8801  SCIP_Bool onlycurrentrun, /**< should only the current run be taken into account */
8802  SCIP_CONFIDENCELEVEL clevel /**< confidence level for the interval */
8803  )
8804 {
8805  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPcalculatePscostConfidenceBound", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
8806 
8807  return SCIPvarCalcPscostConfidenceBound(var, scip->set, dir, onlycurrentrun, clevel);
8808 }
8809 
8810 /** check if variable pseudo-costs have a significant difference in location. The significance depends on
8811  * the choice of \p clevel and on the kind of tested hypothesis. The one-sided hypothesis, which
8812  * should be rejected, is that fracy * mu_y >= fracx * mu_x, where mu_y and mu_x denote the
8813  * unknown location means of the underlying pseudo-cost distributions of x and y.
8814  *
8815  * This method is applied best if variable x has a better pseudo-cost score than y. The method hypothesizes that y were actually
8816  * better than x (despite the current information), meaning that y can be expected to yield branching
8817  * decisions as least as good as x in the long run. If the method returns TRUE, the current history information is
8818  * sufficient to safely rely on the alternative hypothesis that x yields indeed a better branching score (on average)
8819  * than y.
8820  *
8821  * @note The order of x and y matters for the one-sided hypothesis
8822  *
8823  * @note set \p onesided to FALSE if you are not sure which variable is better. The hypothesis tested then reads
8824  * fracy * mu_y == fracx * mu_x vs the alternative hypothesis fracy * mu_y != fracx * mu_x.
8825  *
8826  * @return TRUE if the hypothesis can be safely rejected at the given confidence level
8827  */
8829  SCIP* scip, /**< SCIP data structure */
8830  SCIP_VAR* varx, /**< variable x */
8831  SCIP_Real fracx, /**< the fractionality of variable x */
8832  SCIP_VAR* vary, /**< variable y */
8833  SCIP_Real fracy, /**< the fractionality of variable y */
8834  SCIP_BRANCHDIR dir, /**< branching direction */
8835  SCIP_CONFIDENCELEVEL clevel, /**< confidence level for rejecting hypothesis */
8836  SCIP_Bool onesided /**< should a one-sided hypothesis y >= x be tested? */
8837  )
8838 {
8839  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPsignificantVarPscostDifference", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
8840 
8841  return SCIPvarSignificantPscostDifference(scip->set, scip->stat, varx, fracx, vary, fracy, dir, clevel, onesided);
8842 }
8843 
8844 /** tests at a given confidence level whether the variable pseudo-costs only have a small probability to
8845  * exceed a \p threshold. This is useful to determine if past observations provide enough evidence
8846  * to skip an expensive strong-branching step if there is already a candidate that has been proven to yield an improvement
8847  * of at least \p threshold.
8848  *
8849  * @note use \p clevel to adjust the level of confidence. For SCIP_CONFIDENCELEVEL_MIN, the method returns TRUE if
8850  * the estimated probability to exceed \p threshold is less than 25 %.
8851  *
8852  * @see SCIP_Confidencelevel for a list of available levels. The used probability limits refer to the one-sided levels
8853  * of confidence.
8854  *
8855  * @return TRUE if the variable pseudo-cost probabilistic model is likely to be smaller than \p threshold
8856  * at the given confidence level \p clevel.
8857  */
8859  SCIP* scip, /**< SCIP data structure */
8860  SCIP_VAR* var, /**< variable x */
8861  SCIP_Real frac, /**< the fractionality of variable x */
8862  SCIP_Real threshold, /**< the threshold to test against */
8863  SCIP_BRANCHDIR dir, /**< branching direction */
8864  SCIP_CONFIDENCELEVEL clevel /**< confidence level for rejecting hypothesis */
8865  )
8866 {
8867  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPpscostThresholdProbabilityTest", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
8868 
8869  return SCIPvarPscostThresholdProbabilityTest(scip->set, scip->stat, var, frac, threshold, dir, clevel);
8870 }
8871 
8872 /** check if the current pseudo cost relative error in a direction violates the given threshold. The Relative
8873  * Error is calculated at a specific confidence level
8874  *
8875  * @return TRUE if relative error in variable pseudo costs is smaller than \p threshold
8876  */
8878  SCIP* scip, /**< SCIP data structure */
8879  SCIP_VAR* var, /**< variable in question */
8880  SCIP_Real threshold, /**< threshold for relative errors to be considered reliable (enough) */
8881  SCIP_CONFIDENCELEVEL clevel /**< a given confidence level */
8882  )
8883 {
8884  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPisVarPscostRelerrorReliable", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
8885 
8886  return SCIPvarIsPscostRelerrorReliable(var, scip->set, scip->stat, threshold, clevel);
8887 }
8888 
8889 /** gets the variable's pseudo cost score value for the given LP solution value
8890  *
8891  * @return the variable's pseudo cost score value for the given LP solution value
8892  *
8893  * @pre This method can be called if @p scip is in one of the following stages:
8894  * - \ref SCIP_STAGE_INITPRESOLVE
8895  * - \ref SCIP_STAGE_PRESOLVING
8896  * - \ref SCIP_STAGE_EXITPRESOLVE
8897  * - \ref SCIP_STAGE_PRESOLVED
8898  * - \ref SCIP_STAGE_INITSOLVE
8899  * - \ref SCIP_STAGE_SOLVING
8900  * - \ref SCIP_STAGE_SOLVED
8901  */
8903  SCIP* scip, /**< SCIP data structure */
8904  SCIP_VAR* var, /**< problem variable */
8905  SCIP_Real solval /**< variable's LP solution value */
8906  )
8907 {
8908  SCIP_Real downsol;
8909  SCIP_Real upsol;
8910  SCIP_Real pscostdown;
8911  SCIP_Real pscostup;
8912 
8913  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarPseudocostScore", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
8914 
8915  assert( var->scip == scip );
8916 
8917  downsol = SCIPsetFeasCeil(scip->set, solval-1.0);
8918  upsol = SCIPsetFeasFloor(scip->set, solval+1.0);
8919  pscostdown = SCIPvarGetPseudocost(var, scip->stat, downsol-solval);
8920  pscostup = SCIPvarGetPseudocost(var, scip->stat, upsol-solval);
8921 
8922  return SCIPbranchGetScore(scip->set, var, pscostdown, pscostup);
8923 }
8924 
8925 /** gets the variable's pseudo cost score value for the given LP solution value,
8926  * only using the pseudo cost information of the current run
8927  *
8928  * @return the variable's pseudo cost score value for the given LP solution value,
8929  * only using the pseudo cost information of the current run
8930  *
8931  * @pre This method can be called if @p scip is in one of the following stages:
8932  * - \ref SCIP_STAGE_INITPRESOLVE
8933  * - \ref SCIP_STAGE_PRESOLVING
8934  * - \ref SCIP_STAGE_EXITPRESOLVE
8935  * - \ref SCIP_STAGE_PRESOLVED
8936  * - \ref SCIP_STAGE_INITSOLVE
8937  * - \ref SCIP_STAGE_SOLVING
8938  * - \ref SCIP_STAGE_SOLVED
8939  */
8941  SCIP* scip, /**< SCIP data structure */
8942  SCIP_VAR* var, /**< problem variable */
8943  SCIP_Real solval /**< variable's LP solution value */
8944  )
8945 {
8946  SCIP_Real downsol;
8947  SCIP_Real upsol;
8948  SCIP_Real pscostdown;
8949  SCIP_Real pscostup;
8950 
8951  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarPseudocostScoreCurrentRun", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
8952 
8953  assert( var->scip == scip );
8954 
8955  downsol = SCIPsetFeasCeil(scip->set, solval-1.0);
8956  upsol = SCIPsetFeasFloor(scip->set, solval+1.0);
8957  pscostdown = SCIPvarGetPseudocostCurrentRun(var, scip->stat, downsol-solval);
8958  pscostup = SCIPvarGetPseudocostCurrentRun(var, scip->stat, upsol-solval);
8959 
8960  return SCIPbranchGetScore(scip->set, var, pscostdown, pscostup);
8961 }
8962 
8963 /** returns the variable's VSIDS value
8964  *
8965  * @return the variable's VSIDS value
8966  *
8967  * @pre This method can be called if @p scip is in one of the following stages:
8968  * - \ref SCIP_STAGE_INITPRESOLVE
8969  * - \ref SCIP_STAGE_PRESOLVING
8970  * - \ref SCIP_STAGE_EXITPRESOLVE
8971  * - \ref SCIP_STAGE_PRESOLVED
8972  * - \ref SCIP_STAGE_INITSOLVE
8973  * - \ref SCIP_STAGE_SOLVING
8974  * - \ref SCIP_STAGE_SOLVED
8975  */
8977  SCIP* scip, /**< SCIP data structure */
8978  SCIP_VAR* var, /**< problem variable */
8979  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
8980  )
8981 {
8982  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarVSIDS", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
8983 
8984  assert( var->scip == scip );
8985 
8986  if( dir != SCIP_BRANCHDIR_DOWNWARDS && dir != SCIP_BRANCHDIR_UPWARDS )
8987  {
8988  SCIPerrorMessage("invalid branching direction %d when asking for VSIDS value\n", dir);
8989  return SCIP_INVALID;
8990  }
8991 
8992  return SCIPvarGetVSIDS(var, scip->stat, dir);
8993 }
8994 
8995 /** returns the variable's VSIDS value only using conflicts of the current run
8996  *
8997  * @return the variable's VSIDS value only using conflicts of the current run
8998  *
8999  * @pre This method can be called if @p scip is in one of the following stages:
9000  * - \ref SCIP_STAGE_INITPRESOLVE
9001  * - \ref SCIP_STAGE_PRESOLVING
9002  * - \ref SCIP_STAGE_EXITPRESOLVE
9003  * - \ref SCIP_STAGE_PRESOLVED
9004  * - \ref SCIP_STAGE_INITSOLVE
9005  * - \ref SCIP_STAGE_SOLVING
9006  * - \ref SCIP_STAGE_SOLVED
9007  */
9009  SCIP* scip, /**< SCIP data structure */
9010  SCIP_VAR* var, /**< problem variable */
9011  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
9012  )
9013 {
9014  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarVSIDSCurrentRun", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
9015 
9016  assert( var->scip == scip );
9017 
9018  if( dir != SCIP_BRANCHDIR_DOWNWARDS && dir != SCIP_BRANCHDIR_UPWARDS )
9019  {
9020  SCIPerrorMessage("invalid branching direction %d when asking for VSIDS value\n", dir);
9021  return SCIP_INVALID;
9022  }
9023 
9024  return SCIPvarGetVSIDSCurrentRun(var, scip->stat, dir);
9025 }
9026 
9027 /** returns the variable's conflict score value
9028  *
9029  * @return the variable's conflict score value
9030  *
9031  * @pre This method can be called if @p scip is in one of the following stages:
9032  * - \ref SCIP_STAGE_INITPRESOLVE
9033  * - \ref SCIP_STAGE_PRESOLVING
9034  * - \ref SCIP_STAGE_EXITPRESOLVE
9035  * - \ref SCIP_STAGE_PRESOLVED
9036  * - \ref SCIP_STAGE_INITSOLVE
9037  * - \ref SCIP_STAGE_SOLVING
9038  * - \ref SCIP_STAGE_SOLVED
9039  */
9041  SCIP* scip, /**< SCIP data structure */
9042  SCIP_VAR* var /**< problem variable */
9043  )
9044 {
9045  SCIP_Real downscore;
9046  SCIP_Real upscore;
9047 
9048  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarConflictScore", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
9049 
9050  assert( var->scip == scip );
9051 
9052  downscore = SCIPvarGetVSIDS(var, scip->stat, SCIP_BRANCHDIR_DOWNWARDS);
9053  upscore = SCIPvarGetVSIDS(var, scip->stat, SCIP_BRANCHDIR_UPWARDS);
9054 
9055  return SCIPbranchGetScore(scip->set, var, downscore, upscore);
9056 }
9057 
9058 /** returns the variable's conflict score value only using conflicts of the current run
9059  *
9060  * @return the variable's conflict score value only using conflicts of the current run
9061  *
9062  * @pre This method can be called if @p scip is in one of the following stages:
9063  * - \ref SCIP_STAGE_INITPRESOLVE
9064  * - \ref SCIP_STAGE_PRESOLVING
9065  * - \ref SCIP_STAGE_EXITPRESOLVE
9066  * - \ref SCIP_STAGE_PRESOLVED
9067  * - \ref SCIP_STAGE_INITSOLVE
9068  * - \ref SCIP_STAGE_SOLVING
9069  * - \ref SCIP_STAGE_SOLVED
9070  */
9072  SCIP* scip, /**< SCIP data structure */
9073  SCIP_VAR* var /**< problem variable */
9074  )
9075 {
9076  SCIP_Real downscore;
9077  SCIP_Real upscore;
9078 
9079  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarConflictScoreCurrentRun", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
9080 
9081  assert( var->scip == scip );
9082 
9083  downscore = SCIPvarGetVSIDSCurrentRun(var, scip->stat, SCIP_BRANCHDIR_DOWNWARDS);
9084  upscore = SCIPvarGetVSIDSCurrentRun(var, scip->stat, SCIP_BRANCHDIR_UPWARDS);
9085 
9086  return SCIPbranchGetScore(scip->set, var, downscore, upscore);
9087 }
9088 
9089 /** returns the variable's conflict length score
9090  *
9091  * @return the variable's conflict length score
9092  *
9093  * @pre This method can be called if @p scip is in one of the following stages:
9094  * - \ref SCIP_STAGE_INITPRESOLVE
9095  * - \ref SCIP_STAGE_PRESOLVING
9096  * - \ref SCIP_STAGE_EXITPRESOLVE
9097  * - \ref SCIP_STAGE_PRESOLVED
9098  * - \ref SCIP_STAGE_INITSOLVE
9099  * - \ref SCIP_STAGE_SOLVING
9100  * - \ref SCIP_STAGE_SOLVED
9101  */
9103  SCIP* scip, /**< SCIP data structure */
9104  SCIP_VAR* var /**< problem variable */
9105  )
9106 {
9107  SCIP_Real downscore;
9108  SCIP_Real upscore;
9109 
9110  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarConflictlengthScore", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
9111 
9112  assert( var->scip == scip );
9113 
9116 
9117  return SCIPbranchGetScore(scip->set, var, downscore, upscore);
9118 }
9119 
9120 /** returns the variable's conflict length score only using conflicts of the current run
9121  *
9122  * @return the variable's conflict length score only using conflicts of the current run
9123  *
9124  * @pre This method can be called if @p scip is in one of the following stages:
9125  * - \ref SCIP_STAGE_INITPRESOLVE
9126  * - \ref SCIP_STAGE_PRESOLVING
9127  * - \ref SCIP_STAGE_EXITPRESOLVE
9128  * - \ref SCIP_STAGE_PRESOLVED
9129  * - \ref SCIP_STAGE_INITSOLVE
9130  * - \ref SCIP_STAGE_SOLVING
9131  * - \ref SCIP_STAGE_SOLVED
9132  */
9134  SCIP* scip, /**< SCIP data structure */
9135  SCIP_VAR* var /**< problem variable */
9136  )
9137 {
9138  SCIP_Real downscore;
9139  SCIP_Real upscore;
9140 
9141  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarConflictlengthScoreCurrentRun", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
9142 
9143  assert( var->scip == scip );
9144 
9147 
9148  return SCIPbranchGetScore(scip->set, var, downscore, upscore);
9149 }
9150 
9151 /** returns the variable's average conflict length
9152  *
9153  * @return the variable's average conflict length
9154  *
9155  * @pre This method can be called if @p scip is in one of the following stages:
9156  * - \ref SCIP_STAGE_INITPRESOLVE
9157  * - \ref SCIP_STAGE_PRESOLVING
9158  * - \ref SCIP_STAGE_EXITPRESOLVE
9159  * - \ref SCIP_STAGE_PRESOLVED
9160  * - \ref SCIP_STAGE_INITSOLVE
9161  * - \ref SCIP_STAGE_SOLVING
9162  * - \ref SCIP_STAGE_SOLVED
9163  */
9165  SCIP* scip, /**< SCIP data structure */
9166  SCIP_VAR* var, /**< problem variable */
9167  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
9168  )
9169 {
9170  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarAvgConflictlength", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
9171 
9172  assert( var->scip == scip );
9173 
9174  return SCIPvarGetAvgConflictlength(var, dir);
9175 }
9176 
9177 /** returns the variable's average conflict length only using conflicts of the current run
9178  *
9179  * @return the variable's average conflict length only using conflicts of the current run
9180  *
9181  * @pre This method can be called if @p scip is in one of the following stages:
9182  * - \ref SCIP_STAGE_INITPRESOLVE
9183  * - \ref SCIP_STAGE_PRESOLVING
9184  * - \ref SCIP_STAGE_EXITPRESOLVE
9185  * - \ref SCIP_STAGE_PRESOLVED
9186  * - \ref SCIP_STAGE_INITSOLVE
9187  * - \ref SCIP_STAGE_SOLVING
9188  * - \ref SCIP_STAGE_SOLVED
9189  */
9191  SCIP* scip, /**< SCIP data structure */
9192  SCIP_VAR* var, /**< problem variable */
9193  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
9194  )
9195 {
9196  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarAvgConflictlengthCurrentRun", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
9197 
9198  assert( var->scip == scip );
9199 
9200  return SCIPvarGetAvgConflictlengthCurrentRun(var, dir);
9201 }
9202 
9203 /** returns the average number of inferences found after branching on the variable in given direction;
9204  * if branching on the variable in the given direction was yet evaluated, the average number of inferences
9205  * over all variables for branching in the given direction is returned
9206  *
9207  * @return the average number of inferences found after branching on the variable in given direction
9208  *
9209  * @pre This method can be called if @p scip is in one of the following stages:
9210  * - \ref SCIP_STAGE_INITPRESOLVE
9211  * - \ref SCIP_STAGE_PRESOLVING
9212  * - \ref SCIP_STAGE_EXITPRESOLVE
9213  * - \ref SCIP_STAGE_PRESOLVED
9214  * - \ref SCIP_STAGE_INITSOLVE
9215  * - \ref SCIP_STAGE_SOLVING
9216  * - \ref SCIP_STAGE_SOLVED
9217  */
9219  SCIP* scip, /**< SCIP data structure */
9220  SCIP_VAR* var, /**< problem variable */
9221  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
9222  )
9223 {
9224  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarAvgInferences", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
9225 
9226  assert( var->scip == scip );
9227 
9228  return SCIPvarGetAvgInferences(var, scip->stat, dir);
9229 }
9230 
9231 /** returns the average number of inferences found after branching on the variable in given direction in the current run;
9232  * if branching on the variable in the given direction was yet evaluated, the average number of inferences
9233  * over all variables for branching in the given direction is returned
9234  *
9235  * @return the average number of inferences found after branching on the variable in given direction in the current run
9236  *
9237  * @pre This method can be called if @p scip is in one of the following stages:
9238  * - \ref SCIP_STAGE_INITPRESOLVE
9239  * - \ref SCIP_STAGE_PRESOLVING
9240  * - \ref SCIP_STAGE_EXITPRESOLVE
9241  * - \ref SCIP_STAGE_PRESOLVED
9242  * - \ref SCIP_STAGE_INITSOLVE
9243  * - \ref SCIP_STAGE_SOLVING
9244  * - \ref SCIP_STAGE_SOLVED
9245  */
9247  SCIP* scip, /**< SCIP data structure */
9248  SCIP_VAR* var, /**< problem variable */
9249  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
9250  )
9251 {
9252  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarAvgInferencesCurrentRun", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
9253 
9254  assert( var->scip == scip );
9255 
9256  return SCIPvarGetAvgInferencesCurrentRun(var, scip->stat, dir);
9257 }
9258 
9259 /** returns the variable's average inference score value
9260  *
9261  * @return the variable's average inference score value
9262  *
9263  * @pre This method can be called if @p scip is in one of the following stages:
9264  * - \ref SCIP_STAGE_INITPRESOLVE
9265  * - \ref SCIP_STAGE_PRESOLVING
9266  * - \ref SCIP_STAGE_EXITPRESOLVE
9267  * - \ref SCIP_STAGE_PRESOLVED
9268  * - \ref SCIP_STAGE_INITSOLVE
9269  * - \ref SCIP_STAGE_SOLVING
9270  * - \ref SCIP_STAGE_SOLVED
9271  */
9273  SCIP* scip, /**< SCIP data structure */
9274  SCIP_VAR* var /**< problem variable */
9275  )
9276 {
9277  SCIP_Real inferdown;
9278  SCIP_Real inferup;
9279 
9280  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarAvgInferenceScore", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
9281 
9282  assert( var->scip == scip );
9283 
9284  inferdown = SCIPvarGetAvgInferences(var, scip->stat, SCIP_BRANCHDIR_DOWNWARDS);
9285  inferup = SCIPvarGetAvgInferences(var, scip->stat, SCIP_BRANCHDIR_UPWARDS);
9286 
9287  return SCIPbranchGetScore(scip->set, var, inferdown, inferup);
9288 }
9289 
9290 /** returns the variable's average inference score value only using inferences of the current run
9291  *
9292  * @return the variable's average inference score value only using inferences of the current run
9293  *
9294  * @pre This method can be called if @p scip is in one of the following stages:
9295  * - \ref SCIP_STAGE_INITPRESOLVE
9296  * - \ref SCIP_STAGE_PRESOLVING
9297  * - \ref SCIP_STAGE_EXITPRESOLVE
9298  * - \ref SCIP_STAGE_PRESOLVED
9299  * - \ref SCIP_STAGE_INITSOLVE
9300  * - \ref SCIP_STAGE_SOLVING
9301  * - \ref SCIP_STAGE_SOLVED
9302  */
9304  SCIP* scip, /**< SCIP data structure */
9305  SCIP_VAR* var /**< problem variable */
9306  )
9307 {
9308  SCIP_Real inferdown;
9309  SCIP_Real inferup;
9310 
9311  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarAvgInferenceScoreCurrentRun", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
9312 
9313  assert( var->scip == scip );
9314 
9317 
9318  return SCIPbranchGetScore(scip->set, var, inferdown, inferup);
9319 }
9320 
9321 /** initializes the upwards and downwards pseudocosts, conflict scores, conflict lengths, inference scores, cutoff scores
9322  * of a variable to the given values
9323  *
9324  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9325  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9326  *
9327  * @pre This method can be called if @p scip is in one of the following stages:
9328  * - \ref SCIP_STAGE_TRANSFORMED
9329  * - \ref SCIP_STAGE_INITPRESOLVE
9330  * - \ref SCIP_STAGE_PRESOLVING
9331  * - \ref SCIP_STAGE_EXITPRESOLVE
9332  * - \ref SCIP_STAGE_PRESOLVED
9333  * - \ref SCIP_STAGE_INITSOLVE
9334  * - \ref SCIP_STAGE_SOLVING
9335  */
9337  SCIP* scip, /**< SCIP data structure */
9338  SCIP_VAR* var, /**< variable which should be initialized */
9339  SCIP_Real downpscost, /**< value to which pseudocosts for downwards branching should be initialized */
9340  SCIP_Real uppscost, /**< value to which pseudocosts for upwards branching should be initialized */
9341  SCIP_Real downvsids, /**< value to which VSIDS score for downwards branching should be initialized */
9342  SCIP_Real upvsids, /**< value to which VSIDS score for upwards branching should be initialized */
9343  SCIP_Real downconflen, /**< value to which conflict length score for downwards branching should be initialized */
9344  SCIP_Real upconflen, /**< value to which conflict length score for upwards branching should be initialized */
9345  SCIP_Real downinfer, /**< value to which inference counter for downwards branching should be initialized */
9346  SCIP_Real upinfer, /**< value to which inference counter for upwards branching should be initialized */
9347  SCIP_Real downcutoff, /**< value to which cutoff counter for downwards branching should be initialized */
9348  SCIP_Real upcutoff /**< value to which cutoff counter for upwards branching should be initialized */
9349  )
9350 {
9351  SCIP_CALL( SCIPcheckStage(scip, "SCIPinitVarBranchStats", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE) );
9352 
9353  assert(downpscost >= 0.0 && uppscost >= 0.0);
9354  assert(downvsids >= 0.0 && upvsids >= 0.0);
9355  assert(downconflen >= 0.0 && upconflen >= 0.0);
9356  assert(downinfer >= 0.0 && upinfer >= 0.0);
9357  assert(downcutoff >= 0.0 && upcutoff >= 0.0);
9358 
9359  if( !SCIPisFeasZero(scip, downpscost) || !SCIPisFeasZero(scip, downvsids)
9360  || !SCIPisFeasZero(scip, downinfer) || !SCIPisFeasZero(scip, downcutoff) )
9361  {
9363  SCIP_CALL( SCIPvarUpdatePseudocost(var, scip->set, scip->stat, -1.0, downpscost, 1.0) );
9365  SCIP_CALL( SCIPvarIncVSIDS(var, NULL, scip->set, scip->stat, SCIP_BRANCHDIR_DOWNWARDS, SCIP_UNKNOWN, downvsids) );
9367  }
9368 
9369  if( !SCIPisFeasZero(scip, downconflen) )
9370  {
9372  }
9373 
9374  if( !SCIPisFeasZero(scip, uppscost) || !SCIPisFeasZero(scip, upvsids)
9375  || !SCIPisFeasZero(scip, upinfer) || !SCIPisFeasZero(scip, upcutoff) )
9376  {
9378  SCIP_CALL( SCIPvarUpdatePseudocost(var, scip->set, scip->stat, 1.0, uppscost, 1.0) );
9380  SCIP_CALL( SCIPvarIncVSIDS(var, NULL, scip->set, scip->stat, SCIP_BRANCHDIR_UPWARDS, SCIP_UNKNOWN, upvsids) );
9382  }
9383 
9384  if( !SCIPisFeasZero(scip, upconflen) )
9385  {
9387  }
9388 
9389  return SCIP_OKAY;
9390 }
9391 
9392 /** initializes the upwards and downwards conflict scores, conflict lengths, inference scores, cutoff scores of a
9393  * variable w.r.t. a value by the given values (SCIP_VALUEHISTORY)
9394  *
9395  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9396  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9397  *
9398  * @pre This method can be called if @p scip is in one of the following stages:
9399  * - \ref SCIP_STAGE_TRANSFORMED
9400  * - \ref SCIP_STAGE_INITPRESOLVE
9401  * - \ref SCIP_STAGE_PRESOLVING
9402  * - \ref SCIP_STAGE_EXITPRESOLVE
9403  * - \ref SCIP_STAGE_PRESOLVED
9404  * - \ref SCIP_STAGE_INITSOLVE
9405  * - \ref SCIP_STAGE_SOLVING
9406  */
9408  SCIP* scip, /**< SCIP data structure */
9409  SCIP_VAR* var, /**< variable which should be initialized */
9410  SCIP_Real value, /**< domain value, or SCIP_UNKNOWN */
9411  SCIP_Real downvsids, /**< value to which VSIDS score for downwards branching should be initialized */
9412  SCIP_Real upvsids, /**< value to which VSIDS score for upwards branching should be initialized */
9413  SCIP_Real downconflen, /**< value to which conflict length score for downwards branching should be initialized */
9414  SCIP_Real upconflen, /**< value to which conflict length score for upwards branching should be initialized */
9415  SCIP_Real downinfer, /**< value to which inference counter for downwards branching should be initialized */
9416  SCIP_Real upinfer, /**< value to which inference counter for upwards branching should be initialized */
9417  SCIP_Real downcutoff, /**< value to which cutoff counter for downwards branching should be initialized */
9418  SCIP_Real upcutoff /**< value to which cutoff counter for upwards branching should be initialized */
9419  )
9420 {
9421  SCIP_CALL( SCIPcheckStage(scip, "SCIPinitVarValueBranchStats", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE) );
9422 
9423  assert(downvsids >= 0.0 && upvsids >= 0.0);
9424  assert(downconflen >= 0.0 && upconflen >= 0.0);
9425  assert(downinfer >= 0.0 && upinfer >= 0.0);
9426  assert(downcutoff >= 0.0 && upcutoff >= 0.0);
9427 
9428  if( !SCIPisFeasZero(scip, downvsids) || !SCIPisFeasZero(scip, downinfer) || !SCIPisFeasZero(scip, downcutoff) )
9429  {
9430  SCIP_CALL( SCIPvarIncNBranchings(var, SCIPblkmem(scip), scip->set, scip->stat, SCIP_BRANCHDIR_DOWNWARDS, value, 1) );
9431  SCIP_CALL( SCIPvarIncInferenceSum(var, SCIPblkmem(scip), scip->set, scip->stat, SCIP_BRANCHDIR_DOWNWARDS, value, downinfer) );
9432  SCIP_CALL( SCIPvarIncVSIDS(var, SCIPblkmem(scip), scip->set, scip->stat, SCIP_BRANCHDIR_DOWNWARDS, value, downvsids) );
9433  SCIP_CALL( SCIPvarIncCutoffSum(var, SCIPblkmem(scip), scip->set, scip->stat, SCIP_BRANCHDIR_DOWNWARDS, value, downcutoff) );
9434  }
9435 
9436  if( !SCIPisFeasZero(scip, downconflen) )
9437  {
9438  SCIP_CALL( SCIPvarIncNActiveConflicts(var, SCIPblkmem(scip), scip->set, scip->stat, SCIP_BRANCHDIR_DOWNWARDS, value, downconflen) );
9439  }
9440 
9441  if( !SCIPisFeasZero(scip, upvsids) || !SCIPisFeasZero(scip, upinfer) || !SCIPisFeasZero(scip, upcutoff) )
9442  {
9443  SCIP_CALL( SCIPvarIncNBranchings(var, SCIPblkmem(scip), scip->set, scip->stat, SCIP_BRANCHDIR_UPWARDS, value, 1) );
9444  SCIP_CALL( SCIPvarIncInferenceSum(var, SCIPblkmem(scip), scip->set, scip->stat, SCIP_BRANCHDIR_UPWARDS, value, upinfer) );
9445  SCIP_CALL( SCIPvarIncVSIDS(var, SCIPblkmem(scip), scip->set, scip->stat, SCIP_BRANCHDIR_UPWARDS, value, upvsids) );
9446  SCIP_CALL( SCIPvarIncCutoffSum(var, SCIPblkmem(scip), scip->set, scip->stat, SCIP_BRANCHDIR_UPWARDS, value, upcutoff) );
9447  }
9448 
9449  if( !SCIPisFeasZero(scip, upconflen) )
9450  {
9451  SCIP_CALL( SCIPvarIncNActiveConflicts(var, SCIPblkmem(scip), scip->set, scip->stat, SCIP_BRANCHDIR_UPWARDS, value, upconflen) );
9452  }
9453 
9454  return SCIP_OKAY;
9455 }
9456 
9457 /** returns the average number of cutoffs found after branching on the variable in given direction;
9458  * if branching on the variable in the given direction was yet evaluated, the average number of cutoffs
9459  * over all variables for branching in the given direction is returned
9460  *
9461  * @return the average number of cutoffs found after branching on the variable in given direction
9462  *
9463  * @pre This method can be called if @p scip is in one of the following stages:
9464  * - \ref SCIP_STAGE_INITPRESOLVE
9465  * - \ref SCIP_STAGE_PRESOLVING
9466  * - \ref SCIP_STAGE_EXITPRESOLVE
9467  * - \ref SCIP_STAGE_PRESOLVED
9468  * - \ref SCIP_STAGE_INITSOLVE
9469  * - \ref SCIP_STAGE_SOLVING
9470  * - \ref SCIP_STAGE_SOLVED
9471  */
9473  SCIP* scip, /**< SCIP data structure */
9474  SCIP_VAR* var, /**< problem variable */
9475  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
9476  )
9477 {
9478  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarAvgCutoffs", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
9479 
9480  assert( var->scip == scip );
9481 
9482  return SCIPvarGetAvgCutoffs(var, scip->stat, dir);
9483 }
9484 
9485 /** returns the average number of cutoffs found after branching on the variable in given direction in the current run;
9486  * if branching on the variable in the given direction was yet evaluated, the average number of cutoffs
9487  * over all variables for branching in the given direction is returned
9488  *
9489  * @return the average number of cutoffs found after branching on the variable in given direction in the current run
9490  *
9491  * @pre This method can be called if @p scip is in one of the following stages:
9492  * - \ref SCIP_STAGE_INITPRESOLVE
9493  * - \ref SCIP_STAGE_PRESOLVING
9494  * - \ref SCIP_STAGE_EXITPRESOLVE
9495  * - \ref SCIP_STAGE_PRESOLVED
9496  * - \ref SCIP_STAGE_INITSOLVE
9497  * - \ref SCIP_STAGE_SOLVING
9498  * - \ref SCIP_STAGE_SOLVED
9499  */
9501  SCIP* scip, /**< SCIP data structure */
9502  SCIP_VAR* var, /**< problem variable */
9503  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
9504  )
9505 {
9506  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarAvgCutoffsCurrentRun", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
9507 
9508  assert( var->scip == scip );
9509 
9510  return SCIPvarGetAvgCutoffsCurrentRun(var, scip->stat, dir);
9511 }
9512 
9513 /** returns the variable's average cutoff score value
9514  *
9515  * @return the variable's average cutoff score value
9516  *
9517  * @pre This method can be called if @p scip is in one of the following stages:
9518  * - \ref SCIP_STAGE_INITPRESOLVE
9519  * - \ref SCIP_STAGE_PRESOLVING
9520  * - \ref SCIP_STAGE_EXITPRESOLVE
9521  * - \ref SCIP_STAGE_PRESOLVED
9522  * - \ref SCIP_STAGE_INITSOLVE
9523  * - \ref SCIP_STAGE_SOLVING
9524  * - \ref SCIP_STAGE_SOLVED
9525  */
9527  SCIP* scip, /**< SCIP data structure */
9528  SCIP_VAR* var /**< problem variable */
9529  )
9530 {
9531  SCIP_Real cutoffdown;
9532  SCIP_Real cutoffup;
9533 
9534  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarAvgCutoffScore", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
9535 
9536  assert( var->scip == scip );
9537 
9538  cutoffdown = SCIPvarGetAvgCutoffs(var, scip->stat, SCIP_BRANCHDIR_DOWNWARDS);
9539  cutoffup = SCIPvarGetAvgCutoffs(var, scip->stat, SCIP_BRANCHDIR_UPWARDS);
9540 
9541  return SCIPbranchGetScore(scip->set, var, cutoffdown, cutoffup);
9542 }
9543 
9544 /** returns the variable's average cutoff score value, only using cutoffs of the current run
9545  *
9546  * @return the variable's average cutoff score value, only using cutoffs of the current run
9547  *
9548  * @pre This method can be called if @p scip is in one of the following stages:
9549  * - \ref SCIP_STAGE_INITPRESOLVE
9550  * - \ref SCIP_STAGE_PRESOLVING
9551  * - \ref SCIP_STAGE_EXITPRESOLVE
9552  * - \ref SCIP_STAGE_PRESOLVED
9553  * - \ref SCIP_STAGE_INITSOLVE
9554  * - \ref SCIP_STAGE_SOLVING
9555  * - \ref SCIP_STAGE_SOLVED
9556  */
9558  SCIP* scip, /**< SCIP data structure */
9559  SCIP_VAR* var /**< problem variable */
9560  )
9561 {
9562  SCIP_Real cutoffdown;
9563  SCIP_Real cutoffup;
9564 
9565  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarAvgCutoffScoreCurrentRun", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
9566 
9567  assert( var->scip == scip );
9568 
9571 
9572  return SCIPbranchGetScore(scip->set, var, cutoffdown, cutoffup);
9573 }
9574 
9575 /** returns the variable's average inference/cutoff score value, weighting the cutoffs of the variable with the given
9576  * factor
9577  *
9578  * @return the variable's average inference/cutoff score value
9579  *
9580  * @pre This method can be called if @p scip is in one of the following stages:
9581  * - \ref SCIP_STAGE_INITPRESOLVE
9582  * - \ref SCIP_STAGE_PRESOLVING
9583  * - \ref SCIP_STAGE_EXITPRESOLVE
9584  * - \ref SCIP_STAGE_PRESOLVED
9585  * - \ref SCIP_STAGE_INITSOLVE
9586  * - \ref SCIP_STAGE_SOLVING
9587  * - \ref SCIP_STAGE_SOLVED
9588  */
9590  SCIP* scip, /**< SCIP data structure */
9591  SCIP_VAR* var, /**< problem variable */
9592  SCIP_Real cutoffweight /**< factor to weigh average number of cutoffs in branching score */
9593  )
9594 {
9595  SCIP_Real avginferdown;
9596  SCIP_Real avginferup;
9597  SCIP_Real avginfer;
9598  SCIP_Real inferdown;
9599  SCIP_Real inferup;
9600  SCIP_Real cutoffdown;
9601  SCIP_Real cutoffup;
9602 
9603  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarAvgInferenceCutoffScore", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
9604 
9605  assert( var->scip == scip );
9606 
9609  avginfer = (avginferdown + avginferup)/2.0;
9610  inferdown = SCIPvarGetAvgInferences(var, scip->stat, SCIP_BRANCHDIR_DOWNWARDS);
9611  inferup = SCIPvarGetAvgInferences(var, scip->stat, SCIP_BRANCHDIR_UPWARDS);
9612  cutoffdown = SCIPvarGetAvgCutoffs(var, scip->stat, SCIP_BRANCHDIR_DOWNWARDS);
9613  cutoffup = SCIPvarGetAvgCutoffs(var, scip->stat, SCIP_BRANCHDIR_UPWARDS);
9614 
9615  return SCIPbranchGetScore(scip->set, var,
9616  inferdown + cutoffweight * avginfer * cutoffdown, inferup + cutoffweight * avginfer * cutoffup);
9617 }
9618 
9619 /** returns the variable's average inference/cutoff score value, weighting the cutoffs of the variable with the given
9620  * factor, only using inferences and cutoffs of the current run
9621  *
9622  * @return the variable's average inference/cutoff score value, only using inferences and cutoffs of the current run
9623  *
9624  * @pre This method can be called if @p scip is in one of the following stages:
9625  * - \ref SCIP_STAGE_INITPRESOLVE
9626  * - \ref SCIP_STAGE_PRESOLVING
9627  * - \ref SCIP_STAGE_EXITPRESOLVE
9628  * - \ref SCIP_STAGE_PRESOLVED
9629  * - \ref SCIP_STAGE_INITSOLVE
9630  * - \ref SCIP_STAGE_SOLVING
9631  * - \ref SCIP_STAGE_SOLVED
9632  */
9634  SCIP* scip, /**< SCIP data structure */
9635  SCIP_VAR* var, /**< problem variable */
9636  SCIP_Real cutoffweight /**< factor to weigh average number of cutoffs in branching score */
9637  )
9638 {
9639  SCIP_Real avginferdown;
9640  SCIP_Real avginferup;
9641  SCIP_Real avginfer;
9642  SCIP_Real inferdown;
9643  SCIP_Real inferup;
9644  SCIP_Real cutoffdown;
9645  SCIP_Real cutoffup;
9646 
9647  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarAvgInferenceCutoffScoreCurrentRun", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
9648 
9649  assert( var->scip == scip );
9650 
9653  avginfer = (avginferdown + avginferup)/2.0;
9658 
9659  return SCIPbranchGetScore(scip->set, var,
9660  inferdown + cutoffweight * avginfer * cutoffdown, inferup + cutoffweight * avginfer * cutoffup);
9661 }
9662 
9663 /** outputs variable information to file stream via the message system
9664  *
9665  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9666  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9667  *
9668  * @pre This method can be called if @p scip is in one of the following stages:
9669  * - \ref SCIP_STAGE_PROBLEM
9670  * - \ref SCIP_STAGE_TRANSFORMING
9671  * - \ref SCIP_STAGE_TRANSFORMED
9672  * - \ref SCIP_STAGE_INITPRESOLVE
9673  * - \ref SCIP_STAGE_PRESOLVING
9674  * - \ref SCIP_STAGE_EXITPRESOLVE
9675  * - \ref SCIP_STAGE_PRESOLVED
9676  * - \ref SCIP_STAGE_INITSOLVE
9677  * - \ref SCIP_STAGE_SOLVING
9678  * - \ref SCIP_STAGE_SOLVED
9679  * - \ref SCIP_STAGE_EXITSOLVE
9680  * - \ref SCIP_STAGE_FREETRANS
9681  *
9682  * @note If the message handler is set to a NULL pointer nothing will be printed
9683  */
9685  SCIP* scip, /**< SCIP data structure */
9686  SCIP_VAR* var, /**< problem variable */
9687  FILE* file /**< output file (or NULL for standard output) */
9688  )
9689 {
9690  SCIP_CALL( SCIPcheckStage(scip, "SCIPprintVar", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
9691 
9692  SCIP_CALL( SCIPvarPrint(var, scip->set, scip->messagehdlr, file) );
9693 
9694  return SCIP_OKAY;
9695 }
SCIP_STAT * stat
Definition: struct_scip.h:69
enum SCIP_BoundType SCIP_BOUNDTYPE
Definition: type_lp.h:50
SCIP_Bool SCIPisFeasZero(SCIP *scip, SCIP_Real val)
SCIP_Real sbup
Definition: struct_lp.h:145
void SCIPcolGetStrongbranchLast(SCIP_COL *col, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Real *solval, SCIP_Real *lpobjval)
Definition: lp.c:4630
SCIP_Real SCIPvarGetAvgConflictlengthCurrentRun(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: var.c:14877
SCIP_RETCODE SCIPflattenVarAggregationGraph(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:1696
SCIP_Bool SCIPsolveIsStopped(SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool checknodelimits)
Definition: solve.c:91
SCIP_Longint nsbdivinglps
Definition: struct_stat.h:192
SCIP_RETCODE SCIPchgVarLbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_var.c:4879
SCIP_Bool SCIPsetIsInfinity(SCIP_SET *set, SCIP_Real val)
Definition: set.c:5953
SCIP_RETCODE SCIPtreeEndProbing(SCIP_TREE *tree, SCIP_REOPT *reopt, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_LP *lp, SCIP_RELAXATION *relaxation, SCIP_PRIMAL *primal, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_CLIQUETABLE *cliquetable)
Definition: tree.c:6777
#define NULL
Definition: def.h:239
void SCIPvarGetClosestVlb(SCIP_VAR *var, SCIP_SOL *sol, SCIP_SET *set, SCIP_STAT *stat, SCIP_Real *closestvlb, int *closestvlbidx)
Definition: var.c:13597
SCIP_Real SCIPgetVarAvgInferences(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:9218
SCIP_RETCODE SCIPvarIncInferenceSum(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_BRANCHDIR dir, SCIP_Real value, SCIP_Real weight)
Definition: var.c:15004
SCIP_Bool SCIPvarsHaveCommonClique(SCIP_VAR *var1, SCIP_Bool value1, SCIP_VAR *var2, SCIP_Bool value2, SCIP_Bool regardimplics)
Definition: var.c:10958
SCIP_Real SCIPgetVarAvgCutoffs(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:9472
SCIP_VAR ** SCIPcliqueGetVars(SCIP_CLIQUE *clique)
Definition: implics.c:3343
SCIP_Bool SCIPsetIsLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:6011
int SCIPcliquetableGetVarComponentIdx(SCIP_CLIQUETABLE *cliquetable, SCIP_VAR *var)
Definition: implics.c:2322
void SCIPstatEnableVarHistory(SCIP_STAT *stat)
Definition: stat.c:163
internal methods for storing primal CIP solutions
SCIP_RETCODE SCIPvarIncVSIDS(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_BRANCHDIR dir, SCIP_Real value, SCIP_Real weight)
Definition: var.c:14524
SCIP_RETCODE SCIPtightenVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:5120
SCIP_RETCODE SCIPvarAddVub(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_CLIQUETABLE *cliquetable, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_VAR *vubvar, SCIP_Real vubcoef, SCIP_Real vubconstant, SCIP_Bool transitive, SCIP_Bool *infeasible, int *nbdchgs)
Definition: var.c:10075
void SCIPvarUpdateBestRootSol(SCIP_VAR *var, SCIP_SET *set, SCIP_Real rootsol, SCIP_Real rootredcost, SCIP_Real rootlpobjval)
Definition: var.c:12757
SCIP_Real SCIPgetVarUbAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: scip_var.c:2130
SCIP_STATUS status
Definition: struct_stat.h:170
SCIP_Bool SCIPisFeasEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPlpDiving(SCIP_LP *lp)
Definition: lp.c:17377
SCIP_RETCODE SCIPvarAddObj(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_EVENTQUEUE *eventqueue, SCIP_Real addobj)
Definition: var.c:6045
SCIP_NODE * SCIPgetCurrentNode(SCIP *scip)
Definition: scip_tree.c:158
SCIP_STAGE SCIPgetStage(SCIP *scip)
Definition: scip_general.c:412
SCIP_Bool SCIPlpiIsInfinity(SCIP_LPI *lpi, SCIP_Real val)
public methods for branch and bound tree
SCIP_Real SCIPrelaxationGetSolObj(SCIP_RELAXATION *relaxation)
Definition: relax.c:716
SCIP_RETCODE SCIPgetBinvarRepresentative(SCIP *scip, SCIP_VAR *var, SCIP_VAR **repvar, SCIP_Bool *negated)
Definition: scip_var.c:1600
SCIP_RETCODE SCIPbacktrackProbing(SCIP *scip, int probingdepth)
Definition: scip_probing.c:280
internal methods for branch and bound tree
SCIP_Real SCIPgetVarAvgInferenceCutoffScore(SCIP *scip, SCIP_VAR *var, SCIP_Real cutoffweight)
Definition: scip_var.c:9589
SCIP_CONFLICT * conflict
Definition: struct_scip.h:85
SCIP_RETCODE SCIPaddVarObj(SCIP *scip, SCIP_VAR *var, SCIP_Real addobj)
Definition: scip_var.c:4499
SCIP_Real SCIPvarGetAvgCutoffsCurrentRun(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
Definition: var.c:15783
SCIP_Real SCIPvarGetBranchFactor(SCIP_VAR *var)
Definition: var.c:17503
SCIP_Real SCIPgetVarLbAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: scip_var.c:1994
void SCIPlpEndStrongbranchProbing(SCIP_LP *lp)
Definition: lp.c:15968
SCIP_Bool misc_allowdualreds
Definition: struct_set.h:375
public methods for memory management
SCIP_Real SCIPgetVarAvgInferencesCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:9246
SCIP_RETCODE SCIPmarkRelaxSolValid(SCIP *scip, SCIP_Bool includeslp)
Definition: scip_var.c:2549
int SCIPgetProbingDepth(SCIP *scip)
Definition: scip_probing.c:253
SCIP_Real SCIPgetCutoffbound(SCIP *scip)
SCIP_Real SCIPgetVarConflictlengthScoreCurrentRun(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:9133
SCIP_Bool SCIPsetIsFeasEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:6351
#define SCIPsetDuplicateBufferArray(set, ptr, source, num)
Definition: set.h:1906
#define SCIP_DECL_VARTRANS(x)
Definition: type_var.h:138
SCIP_RETCODE SCIPvarChgLbGlobal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Real newbound)
Definition: var.c:6889
SCIP_Bool SCIPvarDoNotMultaggr(SCIP_VAR *var)
Definition: var.c:5661
SCIP_RETCODE SCIPvarCreateTransformed(SCIP_VAR **var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype, SCIP_Bool initial, SCIP_Bool removable, SCIP_DECL_VARDELORIG((*vardelorig)), SCIP_DECL_VARTRANS((*vartrans)), SCIP_DECL_VARDELTRANS((*vardeltrans)), SCIP_DECL_VARCOPY((*varcopy)), SCIP_VARDATA *vardata)
Definition: var.c:2044
public methods for implications, variable bounds, and cliques
SCIP_Real SCIPvarGetPseudocostCountCurrentRun(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: var.c:14091
methods for implications, variable bounds, and cliques
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
Definition: var.c:17343
SCIP_RETCODE SCIPvarGetProbvarBinary(SCIP_VAR **var, SCIP_Bool *negated)
Definition: var.c:11789
SCIP_Bool SCIPvarIsPscostRelerrorReliable(SCIP_VAR *var, SCIP_SET *set, SCIP_STAT *stat, SCIP_Real threshold, SCIP_CONFIDENCELEVEL clevel)
Definition: var.c:14257
#define SCIP_MAXSTRLEN
Definition: def.h:260
SCIP_Bool conf_usesb
Definition: struct_set.h:209
SCIP_Real SCIPgetVarPseudocostVal(SCIP *scip, SCIP_VAR *var, SCIP_Real solvaldelta)
Definition: scip_var.c:8613
void SCIPgmlWriteArc(FILE *file, unsigned int source, unsigned int target, const char *label, const char *color)
Definition: misc.c:627
internal methods for clocks and timing issues
#define SCIP_VARTYPE_INTEGER_CHAR
Definition: def.h:122
SCIP_RETCODE SCIPvarChgLbOriginal(SCIP_VAR *var, SCIP_SET *set, SCIP_Real newbound)
Definition: var.c:6271
SCIP_Longint SCIPcolGetStrongbranchNode(SCIP_COL *col)
Definition: lp.c:16760
int SCIPcalcMemGrowSize(SCIP *scip, int num)
Definition: scip_mem.c:210
SCIP_Real SCIPgetVarRedcost(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:1866
int SCIPtreeGetProbingDepth(SCIP_TREE *tree)
Definition: tree.c:8332
SCIP_RETCODE SCIPgetNegatedVars(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **negvars)
Definition: scip_var.c:1563
SCIP_Bool presol_donotaggr
Definition: struct_set.h:426
SCIP_RETCODE SCIPnodeAddBoundinfer(SCIP_NODE *node, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_VAR *var, SCIP_Real newbound, SCIP_BOUNDTYPE boundtype, SCIP_CONS *infercons, SCIP_PROP *inferprop, int inferinfo, SCIP_Bool probingchange)
Definition: tree.c:1769
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
Definition: var.c:17399
SCIP_RETCODE SCIPvarChgLbLazy(SCIP_VAR *var, SCIP_SET *set, SCIP_Real lazylb)
Definition: var.c:7173
#define SCIP_CALL_FINALLY(x, y)
Definition: def.h:393
SCIP_RETCODE SCIPgetVarStrongbranchLast(SCIP *scip, SCIP_VAR *var, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Real *solval, SCIP_Real *lpobjval)
Definition: scip_var.c:3951
SCIP_Real SCIPgetColRedcost(SCIP *scip, SCIP_COL *col)
Definition: scip_lp.c:1133
SCIP_RETCODE SCIPprobChgVarType(SCIP_PROB *prob, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_BRANCHCAND *branchcand, SCIP_CLIQUETABLE *cliquetable, SCIP_VAR *var, SCIP_VARTYPE vartype)
Definition: prob.c:1130
SCIP_Real constant
Definition: struct_var.h:184
SCIP_Bool SCIPisGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_EVENTQUEUE * eventqueue
Definition: struct_scip.h:78
SCIP_Longint nsbtimesiterlimhit
Definition: struct_stat.h:112
SCIP_RETCODE SCIPinferVarLbProp(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_PROP *inferprop, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:5808
SCIP_Real SCIPvarGetMultaggrLbGlobal(SCIP_VAR *var, SCIP_SET *set)
Definition: var.c:8268
SCIP_RETCODE SCIPchgVarLbNode(SCIP *scip, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_var.c:4783
SCIP_PRIMAL * primal
Definition: struct_scip.h:83
void SCIPstatDisableVarHistory(SCIP_STAT *stat)
Definition: stat.c:153
SCIP_Bool SCIPpscostThresholdProbabilityTest(SCIP *scip, SCIP_VAR *var, SCIP_Real frac, SCIP_Real threshold, SCIP_BRANCHDIR dir, SCIP_CONFIDENCELEVEL clevel)
Definition: scip_var.c:8858
SCIP_RETCODE SCIPvarChgUbOriginal(SCIP_VAR *var, SCIP_SET *set, SCIP_Real newbound)
Definition: var.c:6330
void SCIPgmlWriteNode(FILE *file, unsigned int id, const char *label, const char *nodetype, const char *fillcolor, const char *bordercolor)
Definition: misc.c:485
SCIP_RETCODE SCIPgetTransformedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **transvar)
Definition: scip_var.c:1442
SCIP_RETCODE SCIPparseVarName(SCIP *scip, const char *str, SCIP_VAR **var, char **endptr)
Definition: scip_var.c:523
SCIP_RETCODE SCIPvarParseOriginal(SCIP_VAR **var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, const char *str, SCIP_Bool initial, SCIP_Bool removable, SCIP_DECL_VARCOPY((*varcopy)), SCIP_DECL_VARDELORIG((*vardelorig)), SCIP_DECL_VARTRANS((*vartrans)), SCIP_DECL_VARDELTRANS((*vardeltrans)), SCIP_VARDATA *vardata, char **endptr, SCIP_Bool *success)
Definition: var.c:2413
SCIP_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)
Definition: scip_var.c:1251
interface methods for specific LP solvers
SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)
Definition: var.c:16909
SCIP_RETCODE SCIPgetLPI(SCIP *scip, SCIP_LPI **lpi)
Definition: scip_lp.c:964
SCIP_Real SCIPvarGetSol(SCIP_VAR *var, SCIP_Bool getlpval)
Definition: var.c:12734
SCIP_RETCODE SCIPchgVarUbLazy(SCIP *scip, SCIP_VAR *var, SCIP_Real lazyub)
Definition: scip_var.c:5086
void SCIPgmlWriteClosing(FILE *file)
Definition: misc.c:687
SCIP_Real SCIPbranchGetScore(SCIP_SET *set, SCIP_VAR *var, SCIP_Real downgain, SCIP_Real upgain)
Definition: branch.c:2189
SCIP_RETCODE SCIPvarMarkDoNotMultaggr(SCIP_VAR *var)
Definition: var.c:5884
SCIP_Real SCIPgetVarPseudocostCountCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:8749
SCIP_BOUNDTYPE SCIPboundchgGetBoundtype(SCIP_BOUNDCHG *boundchg)
Definition: var.c:16656
SCIP_Real SCIPgetVarPseudocostScoreCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_Real solval)
Definition: scip_var.c:8940
SCIP_Bool SCIPisFeasGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_BRANCHCAND * branchcand
Definition: struct_scip.h:79
SCIP_RETCODE SCIPgetVarsData(SCIP *scip, SCIP_VAR ***vars, int *nvars, int *nbinvars, int *nintvars, int *nimplvars, int *ncontvars)
Definition: scip_prob.c:1918
#define NLOCKTYPES
Definition: type_var.h:81
void SCIPclockStop(SCIP_CLOCK *clck, SCIP_SET *set)
Definition: clock.c:350
#define FALSE
Definition: def.h:65
SCIP_Bool SCIPconsIsLockedTypeNeg(SCIP_CONS *cons, SCIP_LOCKTYPE locktype)
Definition: cons.c:8457
SCIP_Real SCIPadjustedVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real ub)
Definition: scip_var.c:4582
SCIP_RETCODE SCIPhashmapCreate(SCIP_HASHMAP **hashmap, BMS_BLKMEM *blkmem, int mapsize)
Definition: misc.c:2793
SCIP_Bool SCIPsetIsFeasIntegral(SCIP_SET *set, SCIP_Real val)
Definition: set.c:6494
SCIP_Real SCIPgetVarVSIDS(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:8976
struct SCIP_VarData SCIP_VARDATA
Definition: type_var.h:107
SCIP_RETCODE SCIPinferBinvarProp(SCIP *scip, SCIP_VAR *var, SCIP_Bool fixedval, SCIP_PROP *inferprop, int inferinfo, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:6031
void SCIPclockStart(SCIP_CLOCK *clck, SCIP_SET *set)
Definition: clock.c:280
SCIP_Real SCIPgetVarMultaggrUbLocal(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:6502
SCIP_RETCODE SCIPvarTransform(SCIP_VAR *origvar, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_OBJSENSE objsense, SCIP_VAR **transvar)
Definition: var.c:3340
SCIP_Real SCIPinfinity(SCIP *scip)
SCIP_Real SCIPgetVarPseudocostValCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_Real solvaldelta)
Definition: scip_var.c:8641
SCIP_Real constant
Definition: struct_var.h:194
int SCIPsnprintf(char *t, int len, const char *s,...)
Definition: misc.c:10017
SCIP_Bool SCIPsetIsZero(SCIP_SET *set, SCIP_Real val)
Definition: set.c:6065
SCIP_STAGE stage
Definition: struct_set.h:63
#define TRUE
Definition: def.h:64
SCIP_Real SCIPvarGetAvgConflictlength(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: var.c:14833
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:53
SCIP_RETCODE SCIPaddVarLocks(SCIP *scip, SCIP_VAR *var, int nlocksdown, int nlocksup)
Definition: scip_var.c:4257
SCIP_Longint SCIPgetVarStrongbranchNode(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:4100
void SCIPlpStartStrongbranchProbing(SCIP_LP *lp)
Definition: lp.c:15955
enum SCIP_Varstatus SCIP_VARSTATUS
Definition: type_var.h:48
#define SCIPsetAllocBufferArray(set, ptr, num)
Definition: set.h:1904
int SCIPtreeGetCurrentDepth(SCIP_TREE *tree)
Definition: tree.c:8304
SCIP_RETCODE SCIPvarCreateOriginal(SCIP_VAR **var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype, SCIP_Bool initial, SCIP_Bool removable, SCIP_DECL_VARDELORIG((*vardelorig)), SCIP_DECL_VARTRANS((*vartrans)), SCIP_DECL_VARDELTRANS((*vardeltrans)), SCIP_DECL_VARCOPY((*varcopy)), SCIP_VARDATA *vardata)
Definition: var.c:2001
SCIP_Bool branch_checksbsol
Definition: struct_set.h:180
int SCIPvarGetProbindex(SCIP_VAR *var)
Definition: var.c:17036
SCIP_Bool branch_divingpscost
Definition: struct_set.h:177
SCIP_RETCODE SCIPvarAddImplic(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_CLIQUETABLE *cliquetable, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_BOUNDTYPE impltype, SCIP_Real implbound, SCIP_Bool transitive, SCIP_Bool *infeasible, int *nbdchgs)
Definition: var.c:10430
#define SCIP_DECL_VARCOPY(x)
Definition: type_var.h:181
unsigned int sbdownvalid
Definition: struct_lp.h:179
internal methods for branching rules and branching candidate storage
SCIP_RETCODE SCIPcliquetableCleanup(SCIP_CLIQUETABLE *cliquetable, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, int *nchgbds, SCIP_Bool *infeasible)
Definition: implics.c:2883
static SCIP_RETCODE calcCliquePartitionGreedy(SCIP *const scip, SCIP_VAR **const vars, SCIP_Bool *const values, int const nvars, int *const cliquepartition, int *const ncliques)
Definition: scip_var.c:7038
SCIP_RETCODE SCIPcreateVarBasic(SCIP *scip, SCIP_VAR **var, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype)
Definition: scip_var.c:184
SCIP_Real SCIPgetVarAvgCutoffsCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:9500
SCIP_Bool presol_donotmultaggr
Definition: struct_set.h:425
SCIP_Real SCIPgetVarVSIDSCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:9008
SCIP_RETCODE SCIPvarChgUbGlobal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Real newbound)
Definition: var.c:7032
SCIP_Real SCIPgetVarAvgCutoffScoreCurrentRun(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:9557
public methods for problem variables
SCIP_Bool SCIPisVarPscostRelerrorReliable(SCIP *scip, SCIP_VAR *var, SCIP_Real threshold, SCIP_CONFIDENCELEVEL clevel)
Definition: scip_var.c:8877
SCIP_RETCODE SCIPclearRelaxSolVals(SCIP *scip)
Definition: scip_var.c:2366
SCIP_RETCODE SCIPtightenVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:5236
SCIP_Real SCIPgetRelaxSolObj(SCIP *scip)
Definition: scip_var.c:2622
SCIP_Bool SCIPgetVarWasFixedAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: scip_var.c:2284
SCIP_Real SCIPvarGetAvgInferences(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
Definition: var.c:15538
SCIP_Bool diving
Definition: struct_lp.h:365
SCIP_Real SCIPgetVarPseudocost(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:8667
SCIP_RETCODE SCIPchgVarLbProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_probing.c:356
SCIP_RETCODE SCIPvarsGetActiveVars(SCIP_SET *set, SCIP_VAR **vars, int *nvars, int varssize, int *requiredsize)
Definition: var.c:11486
SCIP_RETCODE SCIPchgVarUbNode(SCIP *scip, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_var.c:4827
SCIP_RETCODE SCIPwriteVarsPolynomial(SCIP *scip, FILE *file, SCIP_VAR ***monomialvars, SCIP_Real **monomialexps, SCIP_Real *monomialcoefs, int *monomialnvars, int nmonomials, SCIP_Bool type)
Definition: scip_var.c:394
void SCIPrelaxationSetSolValid(SCIP_RELAXATION *relaxation, SCIP_Bool isvalid, SCIP_Bool includeslp)
Definition: relax.c:672
#define SCIPduplicateBufferArray(scip, ptr, source, num)
Definition: scip_mem.h:138
SCIP_Real SCIPgetVarMultaggrUbGlobal(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:6472
static SCIP_RETCODE labelSortStable(SCIP *scip, SCIP_VAR **vars, int *classlabels, SCIP_VAR **sortedvars, int *sortedindices, int *classesstartposs, int nvars, int nclasses)
Definition: scip_var.c:6912
SCIP_PROB * transprob
Definition: struct_scip.h:87
SCIP_Bool SCIPrelaxationIsSolValid(SCIP_RELAXATION *relaxation)
Definition: relax.c:685
SCIP_RETCODE SCIPchgVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_var.c:4613
void * SCIPhashmapGetImage(SCIP_HASHMAP *hashmap, void *origin)
Definition: misc.c:2931
SCIP_Real constant
Definition: struct_var.h:177
SCIP_Bool conf_enable
Definition: struct_set.h:200
SCIP_RETCODE SCIPaddVarVlb(SCIP *scip, SCIP_VAR *var, SCIP_VAR *vlbvar, SCIP_Real vlbcoef, SCIP_Real vlbconstant, SCIP_Bool *infeasible, int *nbdchgs)
Definition: scip_var.c:6572
#define SCIP_LONGINT_MAX
Definition: def.h:136
SCIP_RETCODE SCIPcreateLPSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
Definition: scip_sol.c:419
SCIP_RETCODE SCIPmarkRelaxSolInvalid(SCIP *scip)
Definition: scip_var.c:2572
#define SCIPfreeBufferArray(scip, ptr)
Definition: scip_mem.h:142
SCIP_RETCODE SCIPvarUpdatePseudocost(SCIP_VAR *var, SCIP_SET *set, SCIP_STAT *stat, SCIP_Real solvaldelta, SCIP_Real objdelta, SCIP_Real weight)
Definition: var.c:13852
#define SCIPsetFreeBufferArray(set, ptr)
Definition: set.h:1911
SCIP_Real SCIPadjustedVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real lb)
Definition: scip_var.c:4550
enum SCIP_LPSolStat SCIP_LPSOLSTAT
Definition: type_lp.h:42
void SCIPvarAdjustLb(SCIP_VAR *var, SCIP_SET *set, SCIP_Real *lb)
Definition: var.c:6221
SCIP_Bool SCIPisTransformed(SCIP *scip)
Definition: scip_general.c:611
SCIP_RETCODE SCIPaddVarVub(SCIP *scip, SCIP_VAR *var, SCIP_VAR *vubvar, SCIP_Real vubcoef, SCIP_Real vubconstant, SCIP_Bool *infeasible, int *nbdchgs)
Definition: scip_var.c:6631
public methods for SCIP variables
SCIP_RETCODE SCIPvarChgBranchDirection(SCIP_VAR *var, SCIP_BRANCHDIR branchdirection)
Definition: var.c:11299
SCIP_VAR * SCIPvarGetNegationVar(SCIP_VAR *var)
Definition: var.c:17169
SCIP_Bool branch_forceall
Definition: struct_set.h:178
void SCIPwarningMessage(SCIP *scip, const char *formatstr,...)
Definition: scip_message.c:203
SCIP_RETCODE SCIPvarRemoveCliquesImplicsVbs(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_CLIQUETABLE *cliquetable, SCIP_SET *set, SCIP_Bool irrelevantvar, SCIP_Bool onlyredundant, SCIP_Bool removefromvar)
Definition: var.c:1535
SCIP_RETCODE SCIPchgVarUbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_var.c:4966
#define SCIPdebugMsg
Definition: scip_message.h:88
SCIP_RETCODE SCIPgetTransformedVars(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **transvars)
Definition: scip_var.c:1483
SCIP_Longint SCIPcolGetStrongbranchLPAge(SCIP_COL *col, SCIP_STAT *stat)
Definition: lp.c:4662
internal methods for LP management
int SCIPvarGetNCliques(SCIP_VAR *var, SCIP_Bool varfixing)
Definition: var.c:17695
SCIP_PROB * origprob
Definition: struct_scip.h:70
void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)
Definition: scip_message.c:279
SCIP_RETCODE SCIPparseVarsLinearsum(SCIP *scip, const char *str, SCIP_VAR **vars, SCIP_Real *vals, int *nvars, int varssize, int *requiredsize, char **endptr, SCIP_Bool *success)
Definition: scip_var.c:699
SCIP_RETCODE SCIPgetVarClosestVlb(SCIP *scip, SCIP_VAR *var, SCIP_SOL *sol, SCIP_Real *closestvlb, int *closestvlbidx)
Definition: scip_var.c:6520
SCIP_VAR ** vars
Definition: struct_var.h:186
SCIP_Real SCIPcomputeVarUbGlobal(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:6395
internal methods for branching and inference history
SCIP_Real SCIPfeasCeil(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPcomputeVarLbLocal(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:6416
SCIP_Bool SCIPisStrongbranchDownFirst(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:2645
SCIP_RETCODE SCIPtransformVars(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **transvars)
Definition: scip_var.c:1392
public methods for numerical tolerances
SCIP_Bool reopt_enable
Definition: struct_set.h:468
SCIP_Real SCIPgetVarPseudocostScore(SCIP *scip, SCIP_VAR *var, SCIP_Real solval)
Definition: scip_var.c:8902
SCIP_RETCODE SCIPscaleVarBranchFactor(SCIP *scip, SCIP_VAR *var, SCIP_Real scale)
Definition: scip_var.c:7819
SCIP_Real SCIPfeasFloor(SCIP *scip, SCIP_Real val)
SCIP_VAR * var
Definition: struct_var.h:178
#define SCIP_DECL_VARDELTRANS(x)
Definition: type_var.h:151
SCIP_Bool SCIPsetIsGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:6047
public methods for querying solving statistics
SCIP_HISTORY * glbhistorycrun
Definition: struct_stat.h:166
int SCIPcliquetableGetNCliquesCreated(SCIP_CLIQUETABLE *cliquetable)
Definition: implics.c:3479
SCIP_RETCODE SCIPtryStrongbranchLPSol(SCIP *scip, SCIP_Bool *foundsol, SCIP_Bool *cutoff)
Definition: scip_var.c:4020
SCIP_Bool SCIPhashmapExists(SCIP_HASHMAP *hashmap, void *origin)
Definition: misc.c:3025
SCIP_RETCODE SCIPaddVarLocksType(SCIP *scip, SCIP_VAR *var, SCIP_LOCKTYPE locktype, int nlocksdown, int nlocksup)
Definition: scip_var.c:4199
SCIP_Real SCIPvarGetVSIDSCurrentRun(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
Definition: var.c:15399
SCIP_RETCODE SCIPupdateVarPseudocost(SCIP *scip, SCIP_VAR *var, SCIP_Real solvaldelta, SCIP_Real objdelta, SCIP_Real weight)
Definition: scip_var.c:8579
public methods for the branch-and-bound tree
SCIP_Real SCIPgetVarBdAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: scip_var.c:2266
enum SCIP_BranchDir SCIP_BRANCHDIR
Definition: type_history.h:39
SCIP_Bool SCIPisLPRelax(SCIP *scip)
Definition: scip_lp.c:283
SCIP_VAR * SCIPfindVar(SCIP *scip, const char *name)
Definition: scip_prob.c:2737
SCIP_RETCODE SCIPchgVarType(SCIP *scip, SCIP_VAR *var, SCIP_VARTYPE vartype, SCIP_Bool *infeasible)
Definition: scip_var.c:8072
SCIP_RETCODE SCIPaddClique(SCIP *scip, SCIP_VAR **vars, SCIP_Bool *values, int nvars, SCIP_Bool isequation, SCIP_Bool *infeasible, int *nbdchgs)
Definition: scip_var.c:6819
union SCIP_Var::@13 data
SCIP_RETCODE SCIPvarChgLbLocal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_Real newbound)
Definition: var.c:7674
SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)
Definition: var.c:17353
int SCIPcliquetableGetNCliques(SCIP_CLIQUETABLE *cliquetable)
Definition: implics.c:3469
SCIP_CLOCK * strongpropclock
Definition: struct_stat.h:163
SCIP_RETCODE SCIPvarChgType(SCIP_VAR *var, SCIP_VARTYPE vartype)
Definition: var.c:5919
SCIP_RETCODE SCIPmultiaggregateVar(SCIP *scip, SCIP_VAR *var, int naggvars, SCIP_VAR **aggvars, SCIP_Real *scalars, SCIP_Real constant, SCIP_Bool *infeasible, SCIP_Bool *aggregated)
Definition: scip_var.c:8411
SCIP_MEM * mem
Definition: struct_scip.h:61
public methods for managing constraints
SCIP_Real SCIPvarGetImplRedcost(SCIP_VAR *var, SCIP_SET *set, SCIP_Bool varfixing, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_LP *lp)
Definition: var.c:12944
SCIP_Bool SCIPtreeProbing(SCIP_TREE *tree)
Definition: tree.c:8186
SCIP_RETCODE SCIPparseVarsList(SCIP *scip, const char *str, SCIP_VAR **vars, int *nvars, int varssize, int *requiredsize, char **endptr, char delimiter, SCIP_Bool *success)
Definition: scip_var.c:600
SCIP_Real lb
Definition: struct_lp.h:129
enum SCIP_Confidencelevel SCIP_CONFIDENCELEVEL
Definition: type_misc.h:44
SCIP_RETCODE SCIPvarChgBranchPriority(SCIP_VAR *var, int branchpriority)
Definition: var.c:11169
SCIP_Real SCIPvarGetPseudocost(SCIP_VAR *var, SCIP_STAT *stat, SCIP_Real solvaldelta)
Definition: var.c:13950
SCIP_RETCODE SCIPprobRemoveVarName(SCIP_PROB *prob, SCIP_VAR *var)
Definition: prob.c:904
SCIP_AGGREGATE aggregate
Definition: struct_var.h:225
SCIP_Real SCIPsolGetObj(SCIP_SOL *sol, SCIP_SET *set, SCIP_PROB *transprob, SCIP_PROB *origprob)
Definition: sol.c:1498
SCIP_Real sbdown
Definition: struct_lp.h:144
SCIP_RETCODE SCIPvarChgUbLazy(SCIP_VAR *var, SCIP_SET *set, SCIP_Real lazyub)
Definition: var.c:7196
SCIP_Real SCIPgetVarPseudocostVariance(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun)
Definition: scip_var.c:8775
enum SCIP_LockType SCIP_LOCKTYPE
Definition: type_var.h:87
SCIP_RETCODE SCIPgetBinvarRepresentatives(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **repvars, SCIP_Bool *negated)
Definition: scip_var.c:1647
internal methods for storing and manipulating the main problem
#define SCIPerrorMessage
Definition: pub_message.h:45
SCIP_Bool SCIPboundchgIsRedundant(SCIP_BOUNDCHG *boundchg)
Definition: var.c:16666
SCIP_EVENTFILTER * eventfilter
Definition: struct_scip.h:77
SCIP_Bool SCIPlpIsDualReliable(SCIP_LP *lp)
Definition: lp.c:17357
SCIP_Bool SCIPvarPscostThresholdProbabilityTest(SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR *var, SCIP_Real frac, SCIP_Real threshold, SCIP_BRANCHDIR dir, SCIP_CONFIDENCELEVEL clevel)
Definition: var.c:14400
SCIP_RETCODE SCIPchgVarLbLazy(SCIP *scip, SCIP_VAR *var, SCIP_Real lazylb)
Definition: scip_var.c:5053
SCIP_Longint lpcount
Definition: struct_stat.h:174
SCIP_Bool SCIPisLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Longint nbestsolsfound
Definition: struct_primal.h:42
SCIP_Bool SCIPdoNotMultaggrVar(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:8461
SCIP_RETCODE SCIPpropagateProbing(SCIP *scip, int maxproprounds, SCIP_Bool *cutoff, SCIP_Longint *ndomredsfound)
Definition: scip_probing.c:630
SCIP_RETCODE SCIPvarChgObj(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_PROB *prob, SCIP_PRIMAL *primal, SCIP_LP *lp, SCIP_EVENTQUEUE *eventqueue, SCIP_Real newobj)
Definition: var.c:5970
SCIP_Bool SCIPrelaxationIsSolZero(SCIP_RELAXATION *relaxation)
Definition: relax.c:662
SCIP_RETCODE SCIPgetSolVals(SCIP *scip, SCIP_SOL *sol, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
Definition: scip_sol.c:1447
SCIP_RETCODE SCIPinferVarFixCons(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:5347
SCIP_RETCODE SCIPinitVarBranchStats(SCIP *scip, SCIP_VAR *var, SCIP_Real downpscost, SCIP_Real uppscost, SCIP_Real downvsids, SCIP_Real upvsids, SCIP_Real downconflen, SCIP_Real upconflen, SCIP_Real downinfer, SCIP_Real upinfer, SCIP_Real downcutoff, SCIP_Real upcutoff)
Definition: scip_var.c:9336
SCIP_RETCODE SCIPvarRelease(SCIP_VAR **var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
Definition: var.c:2774
SCIP_RETCODE SCIPgetProbvarSum(SCIP *scip, SCIP_VAR **var, SCIP_Real *scalar, SCIP_Real *constant)
Definition: scip_var.c:1796
SCIP_RETCODE SCIPaddVarImplication(SCIP *scip, SCIP_VAR *var, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_BOUNDTYPE impltype, SCIP_Real implbound, SCIP_Bool *infeasible, int *nbdchgs)
Definition: scip_var.c:6691
SCIP_RETCODE SCIPcheckStage(SCIP *scip, const char *method, SCIP_Bool init, SCIP_Bool problem, SCIP_Bool transforming, SCIP_Bool transformed, SCIP_Bool initpresolve, SCIP_Bool presolving, SCIP_Bool exitpresolve, SCIP_Bool presolved, SCIP_Bool initsolve, SCIP_Bool solving, SCIP_Bool solved, SCIP_Bool exitsolve, SCIP_Bool freetrans, SCIP_Bool freescip)
Definition: debug.c:1933
SCIP_Bool misc_allowobjprop
Definition: struct_set.h:376
#define SCIPfreeBufferArrayNull(scip, ptr)
Definition: scip_mem.h:143
unsigned int sbupvalid
Definition: struct_lp.h:181
BMS_BLKMEM * SCIPblkmem(SCIP *scip)
Definition: scip_mem.c:128
SCIP_Real SCIPvarGetPseudocostCurrentRun(SCIP_VAR *var, SCIP_STAT *stat, SCIP_Real solvaldelta)
Definition: var.c:13999
void SCIPstrCopySection(const char *str, char startchar, char endchar, char *token, int size, char **endptr)
Definition: misc.c:10148
SCIP_RETCODE SCIPunlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)
Definition: scip_var.c:4375
SCIP_RETCODE SCIPvarAddLocks(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LOCKTYPE locktype, int addnlocksdown, int addnlocksup)
Definition: var.c:3056
SCIP_LPSOLSTAT lastsblpsolstats[2]
Definition: struct_stat.h:172
SCIP_CONFLICTSTORE * conflictstore
Definition: struct_scip.h:93
SCIP_RETCODE SCIPvarGetTransformed(SCIP_VAR *origvar, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR **transvar)
Definition: var.c:3426
SCIP_RETCODE SCIPchgVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_var.c:4703
SCIP_Real SCIPcalculatePscostConfidenceBound(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun, SCIP_CONFIDENCELEVEL clevel)
Definition: scip_var.c:8797
SCIP_OBJSENSE objsense
Definition: struct_prob.h:77
SCIP_RETCODE SCIPmarkDoNotMultaggrVar(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:8514
char branch_firstsbchild
Definition: struct_set.h:170
const char * SCIPvarGetName(SCIP_VAR *var)
Definition: var.c:16729
SCIP_VAR * transvar
Definition: struct_var.h:170
SCIP_REOPT * reopt
Definition: struct_scip.h:74
void SCIPhashmapFree(SCIP_HASHMAP **hashmap)
Definition: misc.c:2826
SCIP_Real SCIPsetFeasCeil(SCIP_SET *set, SCIP_Real val)
Definition: set.c:6529
SCIP_RETCODE SCIPtightenVarLbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:6139
SCIP_DOMCHG * SCIPnodeGetDomchg(SCIP_NODE *node)
Definition: tree.c:7439
SCIP_Real cutoffbound
Definition: struct_lp.h:274
SCIP_Longint nsbdivinglpiterations
Definition: struct_stat.h:67
SCIP_RETCODE SCIPgetVarStrongbranchInt(SCIP *scip, SCIP_VAR *var, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Bool *downinf, SCIP_Bool *upinf, SCIP_Bool *downconflict, SCIP_Bool *upconflict, SCIP_Bool *lperror)
Definition: scip_var.c:3627
void SCIPvarGetClosestVub(SCIP_VAR *var, SCIP_SOL *sol, SCIP_SET *set, SCIP_STAT *stat, SCIP_Real *closestvub, int *closestvubidx)
Definition: var.c:13672
SCIP_NEGATE negate
Definition: struct_var.h:227
SCIP_RETCODE SCIPvarFlattenAggregationGraph(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set)
Definition: var.c:4291
SCIP_Real SCIPgetVarConflictlengthScore(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:9102
SCIP_RETCODE SCIPvarSetRelaxSol(SCIP_VAR *var, SCIP_SET *set, SCIP_RELAXATION *relaxation, SCIP_Real solval, SCIP_Bool updateobj)
Definition: var.c:13337
data structures for branch and bound tree
SCIP_HISTORY * glbhistory
Definition: struct_stat.h:165
SCIP_Real SCIPboundchgGetNewbound(SCIP_BOUNDCHG *boundchg)
Definition: var.c:16626
#define REALABS(x)
Definition: def.h:174
SCIP_Real SCIPvarGetLPSol(SCIP_VAR *var)
Definition: var.c:17717
SCIP_Real SCIPgetVarAvgInferenceScoreCurrentRun(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:9303
SCIP_RETCODE SCIPvarFix(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Real fixedval, SCIP_Bool *infeasible, SCIP_Bool *fixed)
Definition: var.c:3627
SCIP_RETCODE SCIPvarAddVlb(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_CLIQUETABLE *cliquetable, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_VAR *vlbvar, SCIP_Real vlbcoef, SCIP_Real vlbconstant, SCIP_Bool transitive, SCIP_Bool *infeasible, int *nbdchgs)
Definition: var.c:9703
internal methods for global SCIP settings
SCIP_Real SCIPvarCalcPscostConfidenceBound(SCIP_VAR *var, SCIP_SET *set, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun, SCIP_CONFIDENCELEVEL clevel)
Definition: var.c:14219
#define SCIP_CALL(x)
Definition: def.h:351
SCIP_RETCODE SCIPprobAddVarName(SCIP_PROB *prob, SCIP_VAR *var)
Definition: prob.c:888
SCIP main data structure.
SCIP_Bool SCIPsignificantVarPscostDifference(SCIP *scip, SCIP_VAR *varx, SCIP_Real fracx, SCIP_VAR *vary, SCIP_Real fracy, SCIP_BRANCHDIR dir, SCIP_CONFIDENCELEVEL clevel, SCIP_Bool onesided)
Definition: scip_var.c:8828
SCIP_RETCODE SCIPsolveProbingLP(SCIP *scip, int itlim, SCIP_Bool *lperror, SCIP_Bool *cutoff)
Definition: scip_probing.c:866
SCIP_Real SCIPcomputeVarUbLocal(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:6437
SCIP_Longint nsbbestsolsfound
Definition: struct_stat.h:99
SCIP_RETCODE SCIPinferVarUbProp(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_PROP *inferprop, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:5922
SCIP_RETCODE SCIPvarIncNBranchings(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_BRANCHDIR dir, SCIP_Real value, int depth)
Definition: var.c:14920
SCIP_RETCODE SCIPgetProbvarLinearSum(SCIP *scip, SCIP_VAR **vars, SCIP_Real *scalars, int *nvars, int varssize, SCIP_Real *constant, int *requiredsize, SCIP_Bool mergemultiples)
Definition: scip_var.c:1740
SCIP_Real SCIPgetVarAvgConflictlength(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:9164
SCIP_RETCODE SCIPremoveVarFromGlobalStructures(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:7757
SCIP_RETCODE SCIPgetVarClosestVub(SCIP *scip, SCIP_VAR *var, SCIP_SOL *sol, SCIP_Real *closestvub, int *closestvubidx)
Definition: scip_var.c:6543
SCIP_Longint SCIPgetVarStrongbranchLPAge(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:4134
SCIP_Bool SCIPisFeasLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsLbBetter(SCIP_SET *set, SCIP_Real newlb, SCIP_Real oldlb, SCIP_Real oldub)
Definition: set.c:6776
SCIP_Real SCIPvarGetPseudocostCount(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: var.c:14046
#define SCIPstatAdd(stat, set, field, val)
Definition: stat.h:271
internal methods for relaxators
SCIP_Bool SCIPsetIsEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:5975
SCIP_RETCODE SCIPvarChgUbLocal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_Real newbound)
Definition: var.c:7800
SCIP_Real SCIPlpGetObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
Definition: lp.c:12907
SCIP_RETCODE SCIPvarPrint(SCIP_VAR *var, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, FILE *file)
Definition: var.c:2895
SCIP_Real SCIPgetVarPseudocostCount(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:8721
SCIP_RETCODE SCIPlpStartStrongbranch(SCIP_LP *lp)
Definition: lp.c:4117
SCIP_Real SCIPgetVarPseudocostCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:8695
SCIP_CLIQUETABLE * cliquetable
Definition: struct_scip.h:86
SCIP_Bool SCIPlpiWasSolved(SCIP_LPI *lpi)
SCIP_RETCODE SCIPchgVarObj(SCIP *scip, SCIP_VAR *var, SCIP_Real newobj)
Definition: scip_var.c:4450
internal methods for problem variables
SCIP_RETCODE SCIPvarChgBranchFactor(SCIP_VAR *var, SCIP_SET *set, SCIP_Real branchfactor)
Definition: var.c:11043
SCIP_RETCODE SCIPvarTryAggregateVars(SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_CLIQUETABLE *cliquetable, SCIP_BRANCHCAND *branchcand, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_VAR *varx, SCIP_VAR *vary, SCIP_Real scalarx, SCIP_Real scalary, SCIP_Real rhs, SCIP_Bool *infeasible, SCIP_Bool *aggregated)
Definition: var.c:5095
#define SCIPallocBufferArray(scip, ptr, num)
Definition: scip_mem.h:130
#define SCIP_UNKNOWN
Definition: def.h:171
SCIP_RETCODE SCIPstartStrongbranch(SCIP *scip, SCIP_Bool enablepropagation)
Definition: scip_var.c:2676
SCIP_RETCODE SCIPlpiGetObjval(SCIP_LPI *lpi, SCIP_Real *objval)
public data structures and miscellaneous methods
unsigned int vartype
Definition: struct_var.h:273
SCIP_Bool SCIPcliquetableNeedsComponentUpdate(SCIP_CLIQUETABLE *cliquetable)
Definition: implics.c:3517
SCIP_RETCODE SCIPvarIncCutoffSum(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_BRANCHDIR dir, SCIP_Real value, SCIP_Real weight)
Definition: var.c:15088
#define SCIP_Bool
Definition: def.h:62
SCIP_RETCODE SCIPinferVarFixProp(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval, SCIP_PROP *inferprop, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:5739
SCIP_LPSOLSTAT SCIPgetLPSolstat(SCIP *scip)
Definition: scip_lp.c:226
void SCIPvarCapture(SCIP_VAR *var)
Definition: var.c:2762
SCIP_CLOCK * sbsoltime
Definition: struct_stat.h:159
SCIP_Real ub
Definition: struct_var.h:162
int SCIPgetNCliquesCreated(SCIP *scip)
Definition: scip_var.c:7500
SCIP_Bool SCIPlpiIsDualFeasible(SCIP_LPI *lpi)
SCIP_RETCODE SCIPtreeStartProbing(SCIP_TREE *tree, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_LP *lp, SCIP_RELAXATION *relaxation, SCIP_PROB *transprob, SCIP_Bool strongbranching)
Definition: tree.c:6344
SCIP_RETCODE SCIProundSol(SCIP *scip, SCIP_SOL *sol, SCIP_Bool *success)
Definition: scip_sol.c:2521
#define MAXNCLIQUEVARSCOMP
Definition: scip_var.c:7018
static SCIP_RETCODE analyzeStrongbranch(SCIP *scip, SCIP_VAR *var, SCIP_Bool *downinf, SCIP_Bool *upinf, SCIP_Bool *downconflict, SCIP_Bool *upconflict)
Definition: scip_var.c:2829
int SCIPvarGetBranchPriority(SCIP_VAR *var)
Definition: var.c:17515
SCIP_MULTAGGR multaggr
Definition: struct_var.h:226
SCIP_RETCODE SCIPgetVarStrongbranchWithPropagation(SCIP *scip, SCIP_VAR *var, SCIP_Real solval, SCIP_Real lpobjval, int itlim, int maxproprounds, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Longint *ndomredsdown, SCIP_Longint *ndomredsup, SCIP_Bool *downinf, SCIP_Bool *upinf, SCIP_Bool *downconflict, SCIP_Bool *upconflict, SCIP_Bool *lperror, SCIP_Real *newlbs, SCIP_Real *newubs)
Definition: scip_var.c:3317
SCIP_Bool branch_roundsbsol
Definition: struct_set.h:181
int SCIPvarGetNLocksUp(SCIP_VAR *var)
Definition: var.c:3308
SCIP_RETCODE SCIPconflictAnalyzeStrongbranch(SCIP_CONFLICT *conflict, SCIP_CONFLICTSTORE *conflictstore, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_COL *col, SCIP_Bool *downconflict, SCIP_Bool *upconflict)
Definition: conflict.c:8364
SCIP_RETCODE SCIPcliquetableComputeCliqueComponents(SCIP_CLIQUETABLE *cliquetable, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_VAR **vars, int nbinvars, int nintvars, int nimplvars)
Definition: implics.c:3094
SCIP_Bool SCIPstrToRealValue(const char *str, SCIP_Real *value, char **endptr)
Definition: misc.c:10118
SCIP_RETCODE SCIPtrySolFree(SCIP *scip, SCIP_SOL **sol, SCIP_Bool printreason, SCIP_Bool completely, SCIP_Bool checkbounds, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool *stored)
Definition: scip_sol.c:3291
SCIP_RETCODE SCIPsetRelaxSolVals(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Bool includeslp)
Definition: scip_var.c:2443
SCIP_RETCODE SCIPcalcCliquePartition(SCIP *const scip, SCIP_VAR **const vars, int const nvars, int *const cliquepartition, int *const ncliques)
Definition: scip_var.c:7154
SCIP_VAR * SCIPboundchgGetVar(SCIP_BOUNDCHG *boundchg)
Definition: var.c:16636
#define MIN(x, y)
Definition: def.h:209
methods for debugging
SCIP_Bool * SCIPcliqueGetValues(SCIP_CLIQUE *clique)
Definition: implics.c:3355
SCIP_BOUNDCHG * SCIPdomchgGetBoundchg(SCIP_DOMCHG *domchg, int pos)
Definition: var.c:16684
public methods for LP management
void SCIPcolSetStrongbranchData(SCIP_COL *col, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_Real lpobjval, SCIP_Real primsol, SCIP_Real sbdown, SCIP_Real sbup, SCIP_Bool sbdownvalid, SCIP_Bool sbupvalid, SCIP_Longint iter, int itlim)
Definition: lp.c:4147
datastructures for block memory pools and memory buffers
SCIP_RETCODE SCIPwriteCliqueGraph(SCIP *scip, const char *fname, SCIP_Bool writenodeweights)
Definition: scip_var.c:7608
SCIP_RETCODE SCIPsetRelaxSolValsSol(SCIP *scip, SCIP_SOL *sol, SCIP_Bool includeslp)
Definition: scip_var.c:2483
SCIP_Real SCIPvarGetMultaggrUbGlobal(SCIP_VAR *var, SCIP_SET *set)
Definition: var.c:8334
SCIP_RETCODE SCIPfreeSol(SCIP *scip, SCIP_SOL **sol)
Definition: scip_sol.c:1034
SCIP_Bool SCIPprobAllColsInLP(SCIP_PROB *prob, SCIP_SET *set, SCIP_LP *lp)
Definition: prob.c:2267
void SCIPenableVarHistory(SCIP *scip)
Definition: scip_var.c:8540
SCIP_Real SCIPcomputeVarLbGlobal(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:6374
SCIP_Real SCIPgetVarAvgInferenceCutoffScoreCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_Real cutoffweight)
Definition: scip_var.c:9633
SCIP_Real SCIPbdchginfoGetNewbound(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:17935
SCIP_RETCODE SCIPgetVarsStrongbranchesInt(SCIP *scip, SCIP_VAR **vars, int nvars, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Bool *downinf, SCIP_Bool *upinf, SCIP_Bool *downconflict, SCIP_Bool *upconflict, SCIP_Bool *lperror)
Definition: scip_var.c:3825
SCIP_RETCODE SCIPcreateVar(SCIP *scip, SCIP_VAR **var, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype, SCIP_Bool initial, SCIP_Bool removable, SCIP_DECL_VARDELORIG((*vardelorig)), SCIP_DECL_VARTRANS((*vartrans)), SCIP_DECL_VARDELTRANS((*vardeltrans)), SCIP_DECL_VARCOPY((*varcopy)), SCIP_VARDATA *vardata)
Definition: scip_var.c:104
SCIP_Real SCIPvarGetAvgInferencesCurrentRun(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
Definition: var.c:15595
SCIP_Bool SCIPtreeHasCurrentNodeLP(SCIP_TREE *tree)
Definition: tree.c:8321
SCIP_RETCODE SCIPfixVar(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval, SCIP_Bool *infeasible, SCIP_Bool *fixed)
Definition: scip_var.c:8168
#define BMScopyMemoryArray(ptr, source, num)
Definition: memory.h:116
SCIP_RETCODE SCIPchgVarBranchPriority(SCIP *scip, SCIP_VAR *var, int branchpriority)
Definition: scip_var.c:7878
SCIP_RETCODE SCIPlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)
Definition: scip_var.c:4290
int SCIPconflictGetNConflicts(SCIP_CONFLICT *conflict)
Definition: conflict.c:3538
SCIP_COL * SCIPvarGetCol(SCIP_VAR *var)
Definition: var.c:17057
void SCIPgmlWriteNodeWeight(FILE *file, unsigned int id, const char *label, const char *nodetype, const char *fillcolor, const char *bordercolor, SCIP_Real weight)
Definition: misc.c:533
SCIP_Real SCIPvarGetRelaxSol(SCIP_VAR *var, SCIP_SET *set)
Definition: var.c:13398
datastructures for problem statistics
int nconflicthdlrs
Definition: struct_set.h:104
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
SCIP_Real ub
Definition: struct_lp.h:130
SCIP_Bool SCIPsetIsFeasLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:6373
SCIP_RETCODE SCIPcliquetableAdd(SCIP_CLIQUETABLE *cliquetable, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_VAR **vars, SCIP_Bool *values, int nvars, SCIP_Bool isequation, SCIP_Bool *infeasible, int *nbdchgs)
Definition: implics.c:2350
SCIP_RETCODE SCIPinferVarLbCons(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:5416
SCIP_RETCODE SCIPvarIncNActiveConflicts(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_BRANCHDIR dir, SCIP_Real value, SCIP_Real length)
Definition: var.c:14660
void SCIPrelaxationSetSolObj(SCIP_RELAXATION *relaxation, SCIP_Real obj)
Definition: relax.c:705
#define SCIP_MAXTREEDEPTH
Definition: def.h:287
SCIP * scip
Definition: struct_var.h:201
SCIP_BDCHGINFO * SCIPvarGetLbchgInfo(SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: var.c:15881
SCIP_Bool SCIPinProbing(SCIP *scip)
Definition: scip_probing.c:152
public methods for the LP relaxation, rows and columns
SCIP_BDCHGINFO * SCIPvarGetUbchgInfo(SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: var.c:15937
int SCIPgetNVars(SCIP *scip)
Definition: scip_prob.c:2044
SCIP_Real SCIPgetVarMultaggrLbLocal(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:6487
SCIP_RETCODE SCIPcolGetStrongbranches(SCIP_COL **cols, int ncols, SCIP_Bool integral, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_LP *lp, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Bool *lperror)
Definition: lp.c:4394
SCIP_RETCODE SCIPwriteVarsLinearsum(SCIP *scip, FILE *file, SCIP_VAR **vars, SCIP_Real *vals, int nvars, SCIP_Bool type)
Definition: scip_var.c:333
#define SCIP_DECL_VARDELORIG(x)
Definition: type_var.h:118
SCIP_Real SCIPlpGetLooseObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
Definition: lp.c:12946
datastructures for storing and manipulating the main problem
SCIP_Bool SCIPinDive(SCIP *scip)
Definition: scip_lp.c:2657
void SCIPrelaxationSetSolZero(SCIP_RELAXATION *relaxation, SCIP_Bool iszero)
Definition: relax.c:651
SCIP_Real SCIPsetFeasFloor(SCIP_SET *set, SCIP_Real val)
Definition: set.c:6518
#define SCIP_LONGINT_FORMAT
Definition: def.h:142
SCIP_CLIQUE ** SCIPgetCliques(SCIP *scip)
Definition: scip_var.c:7527
SCIP_Real SCIPgetVarAvgConflictlengthCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:9190
SCIP_RETCODE SCIPaddVarBranchFactor(SCIP *scip, SCIP_VAR *var, SCIP_Real addfactor)
Definition: scip_var.c:7847
SCIP_LPSOLSTAT SCIPgetLastStrongbranchLPSolStat(SCIP *scip, SCIP_BRANCHDIR branchdir)
Definition: scip_var.c:3929
SCIP_Bool misc_exactsolve
Definition: struct_set.h:361
SCIP_RETCODE SCIPwriteVarsList(SCIP *scip, FILE *file, SCIP_VAR **vars, int nvars, SCIP_Bool type, char delimiter)
Definition: scip_var.c:282
#define SCIP_VARTYPE_IMPLINT_CHAR
Definition: def.h:123
SCIP_RETCODE SCIPsetVarStrongbranchData(SCIP *scip, SCIP_VAR *var, SCIP_Real lpobjval, SCIP_Real primsol, SCIP_Real down, SCIP_Real up, SCIP_Bool downvalid, SCIP_Bool upvalid, SCIP_Longint iter, int itlim)
Definition: scip_var.c:3985
general public methods
#define MAX(x, y)
Definition: def.h:208
int SCIPvarGetNLocksDown(SCIP_VAR *var)
Definition: var.c:3295
SCIP_Real SCIPgetLPObjval(SCIP *scip)
Definition: scip_lp.c:305
BMS_BLKMEM * probmem
Definition: struct_mem.h:40
SCIP_RETCODE SCIPsetRelaxSolVal(SCIP *scip, SCIP_VAR *var, SCIP_Real val)
Definition: scip_var.c:2412
SCIP_Bool SCIPisGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisIntegral(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPgetVarImplRedcost(SCIP *scip, SCIP_VAR *var, SCIP_Bool varfixing)
Definition: scip_var.c:1911
public methods for solutions
internal methods for conflict analysis
void SCIPfreeParseVarsPolynomialData(SCIP *scip, SCIP_VAR ****monomialvars, SCIP_Real ***monomialexps, SCIP_Real **monomialcoefs, int **monomialnvars, int nmonomials)
Definition: scip_var.c:1161
static const SCIP_Real scalars[]
Definition: lp.c:5650
SCIP_RETCODE SCIPvarMultiaggregate(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_CLIQUETABLE *cliquetable, SCIP_BRANCHCAND *branchcand, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, int naggvars, SCIP_VAR **aggvars, SCIP_Real *scalars, SCIP_Real constant, SCIP_Bool *infeasible, SCIP_Bool *aggregated)
Definition: var.c:5261
SCIP_RETCODE SCIPinferVarUbCons(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:5529
SCIP_RETCODE SCIPgetVarsStrongbranchesFrac(SCIP *scip, SCIP_VAR **vars, int nvars, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Bool *downinf, SCIP_Bool *upinf, SCIP_Bool *downconflict, SCIP_Bool *upconflict, SCIP_Bool *lperror)
Definition: scip_var.c:3714
internal methods for main solving loop and node processing
SCIP_RETCODE SCIPgetVarSols(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
Definition: scip_var.c:2329
int SCIPdomchgGetNBoundchgs(SCIP_DOMCHG *domchg)
Definition: var.c:16676
SCIP_RETCODE SCIPnodeAddBoundchg(SCIP_NODE *node, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_VAR *var, SCIP_Real newbound, SCIP_BOUNDTYPE boundtype, SCIP_Bool probingchange)
Definition: tree.c:2021
#define SCIP_VARTYPE_CONTINUOUS_CHAR
Definition: def.h:124
public methods for the probing mode
SCIP_RETCODE SCIPvarGetActiveRepresentatives(SCIP_SET *set, SCIP_VAR **vars, SCIP_Real *scalars, int *nvars, int varssize, SCIP_Real *constant, int *requiredsize, SCIP_Bool mergemultiples)
Definition: var.c:3796
SCIP_NODE * SCIPtreeGetCurrentNode(SCIP_TREE *tree)
Definition: tree.c:8287
SCIP_RETCODE SCIPendStrongbranch(SCIP *scip)
Definition: scip_var.c:2734
SCIP_Bool SCIPisRelaxSolValid(SCIP *scip)
Definition: scip_var.c:2529
SCIP_Bool SCIPvarSignificantPscostDifference(SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR *varx, SCIP_Real fracx, SCIP_VAR *vary, SCIP_Real fracy, SCIP_BRANCHDIR dir, SCIP_CONFIDENCELEVEL clevel, SCIP_Bool onesided)
Definition: var.c:14334
SCIP_Bool SCIPallowDualReds(SCIP *scip)
Definition: scip_var.c:8478
SCIP_SET * set
Definition: struct_scip.h:62
public methods for message output
int SCIPgetNCliques(SCIP *scip)
Definition: scip_var.c:7473
data structures for LP management
SCIP_RETCODE SCIPaddVarBranchPriority(SCIP *scip, SCIP_VAR *var, int addpriority)
Definition: scip_var.c:7952
SCIP_Real * scalars
Definition: struct_var.h:185
datastructures for problem variables
SCIP_VAR ** SCIPgetVars(SCIP *scip)
Definition: scip_prob.c:1999
int SCIPcolGetNStrongbranchs(SCIP_COL *col)
Definition: lp.c:16770
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
Definition: var.c:16848
struct SCIP_LPi SCIP_LPI
Definition: type_lpi.h:96
SCIP_RETCODE SCIPcalcNegatedCliquePartition(SCIP *const scip, SCIP_VAR **const vars, int const nvars, int *const cliquepartition, int *const ncliques)
Definition: scip_var.c:7373
SCIP_MESSAGEHDLR * messagehdlr
Definition: struct_scip.h:65
SCIP_RETCODE SCIPaggregateVars(SCIP *scip, SCIP_VAR *varx, SCIP_VAR *vary, SCIP_Real scalarx, SCIP_Real scalary, SCIP_Real rhs, SCIP_Bool *infeasible, SCIP_Bool *redundant, SCIP_Bool *aggregated)
Definition: scip_var.c:8277
SCIP_RETCODE SCIPcolGetStrongbranch(SCIP_COL *col, SCIP_Bool integral, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_LP *lp, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Bool *lperror)
Definition: lp.c:4236
SCIP_NODETYPE SCIPnodeGetType(SCIP_NODE *node)
Definition: tree.c:7334
SCIP_RETCODE SCIPcaptureVar(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:1217
#define SCIP_Real
Definition: def.h:150
internal methods for problem statistics
SCIP_RETCODE SCIPvarsGetProbvarBinary(SCIP_VAR ***vars, SCIP_Bool **negatedarr, int nvars)
Definition: var.c:11757
SCIP_RETCODE SCIPchgVarBranchDirection(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR branchdirection)
Definition: scip_var.c:7983
SCIP_Bool SCIPhaveVarsCommonClique(SCIP *scip, SCIP_VAR *var1, SCIP_Bool value1, SCIP_VAR *var2, SCIP_Bool value2, SCIP_Bool regardimplics)
Definition: scip_var.c:7557
datastructures for collecting primal CIP solutions and primal informations
public methods for message handling
SCIP_Bool SCIPdoNotAggr(SCIP *scip)
Definition: scip_var.c:8441
SCIP_RETCODE SCIPtransformVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **transvar)
Definition: scip_var.c:1352
SCIP_Real SCIPvarGetVSIDS(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
Definition: var.c:17808
#define SCIP_INVALID
Definition: def.h:170
SCIP_RETCODE SCIPvarParseTransformed(SCIP_VAR **var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, const char *str, SCIP_Bool initial, SCIP_Bool removable, SCIP_DECL_VARCOPY((*varcopy)), SCIP_DECL_VARDELORIG((*vardelorig)), SCIP_DECL_VARTRANS((*vartrans)), SCIP_DECL_VARDELTRANS((*vardeltrans)), SCIP_VARDATA *vardata, char **endptr, SCIP_Bool *success)
Definition: var.c:2477
SCIP_Real primsol
Definition: struct_lp.h:139
#define SCIP_Longint
Definition: def.h:135
SCIP_Bool SCIPallColsInLP(SCIP *scip)
Definition: scip_lp.c:652
SCIP_Real SCIPvarGetAvgCutoffs(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
Definition: var.c:15736
SCIP_Real lb
Definition: struct_var.h:161
SCIP_Bool SCIPsetIsFeasGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:6417
SCIP_Longint nsbsolsfound
Definition: struct_stat.h:95
SCIP_TREE * tree
Definition: struct_scip.h:84
SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)
Definition: var.c:16894
#define SCIP_VARTYPE_BINARY_CHAR
Definition: def.h:121
SCIP_Real SCIPvarGetMultaggrUbLocal(SCIP_VAR *var, SCIP_SET *set)
Definition: var.c:8202
SCIP_RETCODE SCIPvarChgName(SCIP_VAR *var, BMS_BLKMEM *blkmem, const char *name)
Definition: var.c:2801
SCIP_RELAXATION * relaxation
Definition: struct_scip.h:82
static SCIP_RETCODE performStrongbranchWithPropagation(SCIP *scip, SCIP_VAR *var, SCIP_Bool down, SCIP_Bool firstchild, SCIP_Bool propagate, SCIP_Real newbound, int itlim, int maxproprounds, SCIP_Real *value, SCIP_Bool *valid, SCIP_Longint *ndomreductions, SCIP_Bool *conflict, SCIP_Bool *lperror, SCIP_VAR **vars, int nvars, SCIP_Real *newlbs, SCIP_Real *newubs, SCIP_Bool *foundsol, SCIP_Bool *cutoff)
Definition: scip_var.c:2992
SCIP_RETCODE SCIPparseVarsPolynomial(SCIP *scip, const char *str, SCIP_VAR ****monomialvars, SCIP_Real ***monomialexps, SCIP_Real **monomialcoefs, int **monomialnvars, int *nmonomials, char **endptr, SCIP_Bool *success)
Definition: scip_var.c:809
SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPdoNotMultaggr(SCIP *scip)
Definition: scip_var.c:8451
SCIP_DOM glbdom
Definition: struct_var.h:219
SCIP_Real SCIPgetVarConflictScoreCurrentRun(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:9071
SCIP_Real SCIPhistoryGetAvgInferences(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
Definition: history.c:641
SCIP_Bool SCIPisLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
enum SCIP_Vartype SCIP_VARTYPE
Definition: type_var.h:60
SCIP_Bool SCIPconsIsLockedTypePos(SCIP_CONS *cons, SCIP_LOCKTYPE locktype)
Definition: cons.c:8445
SCIP_Real SCIPgetVarSol(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:2309
SCIP_VAR * negatedvar
Definition: struct_var.h:236
SCIP_Real SCIPgetColFarkasCoef(SCIP *scip, SCIP_COL *col)
Definition: scip_lp.c:1159
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
Definition: var.c:17409
SCIP_Real SCIPgetVarMultaggrLbGlobal(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:6457
SCIP_RETCODE SCIPnewProbingNode(SCIP *scip)
Definition: scip_probing.c:220
int SCIPcliqueGetNVars(SCIP_CLIQUE *clique)
Definition: implics.c:3333
void SCIPgmlWriteOpening(FILE *file, SCIP_Bool directed)
Definition: misc.c:671
void SCIPvarAdjustUb(SCIP_VAR *var, SCIP_SET *set, SCIP_Real *ub)
Definition: var.c:6238
SCIP_Bool SCIPisFeasIntegral(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPsetIsUbBetter(SCIP_SET *set, SCIP_Real newub, SCIP_Real oldlb, SCIP_Real oldub)
Definition: set.c:6801
SCIP_Bool SCIPvarIsTransformed(SCIP_VAR *var)
Definition: var.c:16871
SCIP_RETCODE SCIPtightenVarUbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:6259
static SCIP_RETCODE tightenBounds(SCIP *scip, SCIP_VAR *var, SCIP_VARTYPE vartype, SCIP_Bool *infeasible)
Definition: scip_var.c:8000
SCIP_RETCODE SCIPinitVarValueBranchStats(SCIP *scip, SCIP_VAR *var, SCIP_Real value, SCIP_Real downvsids, SCIP_Real upvsids, SCIP_Real downconflen, SCIP_Real upconflen, SCIP_Real downinfer, SCIP_Real upinfer, SCIP_Real downcutoff, SCIP_Real upcutoff)
Definition: scip_var.c:9407
SCIP_RETCODE SCIPhashmapInsert(SCIP_HASHMAP *hashmap, void *origin, void *image)
Definition: misc.c:2874
#define BMSclearMemoryArray(ptr, num)
Definition: memory.h:112
SCIP_RETCODE SCIPgetVarStrongbranchFrac(SCIP *scip, SCIP_VAR *var, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Bool *downinf, SCIP_Bool *upinf, SCIP_Bool *downconflict, SCIP_Bool *upconflict, SCIP_Bool *lperror)
Definition: scip_var.c:2909
SCIP_RETCODE SCIPupdateVarBranchPriority(SCIP *scip, SCIP_VAR *var, int branchpriority)
Definition: scip_var.c:7919
void SCIPcolInvalidateStrongbranchData(SCIP_COL *col, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp)
Definition: lp.c:4201
SCIP_RETCODE SCIPvarGetProbvarSum(SCIP_VAR **var, SCIP_SET *set, SCIP_Real *scalar, SCIP_Real *constant)
Definition: var.c:12126
SCIP_NODE * root
Definition: struct_tree.h:178
#define SCIP_CALL_ABORT(x)
Definition: def.h:330
SCIP_Real SCIPvarGetPseudoSol(SCIP_VAR *var)
Definition: var.c:17795
SCIP_RETCODE SCIPcleanupCliques(SCIP *scip, SCIP_Bool *infeasible)
Definition: scip_var.c:7430
SCIP_Real SCIPgetVarFarkasCoef(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:1956
SCIP_ORIGINAL original
Definition: struct_var.h:223
SCIP_LP * lp
Definition: struct_scip.h:80
#define SCIPABORT()
Definition: def.h:323
SCIP_RETCODE SCIPwriteVarName(SCIP *scip, FILE *file, SCIP_VAR *var, SCIP_Bool type)
Definition: scip_var.c:220
public methods for global and local (sub)problems
int SCIPgetVarNStrongbranchs(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:4166
SCIP_RETCODE SCIPgetActiveVars(SCIP *scip, SCIP_VAR **vars, int *nvars, int varssize, int *requiredsize)
Definition: scip_var.c:1832
SCIP_Bool SCIPvarIsIntegral(SCIP_VAR *var)
Definition: var.c:16920
SCIP_RETCODE SCIPchgVarUbProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_probing.c:400
SCIP_Real SCIPvarGetMultaggrLbLocal(SCIP_VAR *var, SCIP_SET *set)
Definition: var.c:8136
void SCIPdisableVarHistory(SCIP *scip)
Definition: scip_var.c:8559
SCIP_Real SCIPgetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var)
Definition: scip_sol.c:1410
SCIP_Real SCIPgetVarAvgInferenceScore(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:9272
datastructures for global SCIP settings
SCIP_RETCODE SCIPlpEndStrongbranch(SCIP_LP *lp)
Definition: lp.c:4132
SCIP_RETCODE SCIPinferBinvarCons(SCIP *scip, SCIP_VAR *var, SCIP_Bool fixedval, SCIP_CONS *infercons, int inferinfo, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:5636
SCIP_RETCODE SCIPparseVar(SCIP *scip, SCIP_VAR **var, const char *str, SCIP_Bool initial, SCIP_Bool removable, SCIP_DECL_VARCOPY((*varcopy)), SCIP_DECL_VARDELORIG((*vardelorig)), SCIP_DECL_VARTRANS((*vartrans)), SCIP_DECL_VARDELTRANS((*vardeltrans)), SCIP_VARDATA *vardata, char **endptr, SCIP_Bool *success)
Definition: scip_var.c:464
SCIP_Bool SCIPcolIsInLP(SCIP_COL *col)
Definition: lp.c:16702
SCIP_RETCODE SCIPvarNegate(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR **negvar)
Definition: var.c:5696
SCIP_CLIQUE ** SCIPcliquetableGetCliques(SCIP_CLIQUETABLE *cliquetable)
Definition: implics.c:3489
SCIP_RETCODE SCIPchgVarBranchFactor(SCIP *scip, SCIP_VAR *var, SCIP_Real branchfactor)
Definition: scip_var.c:7791
SCIP_RETCODE SCIPprintVar(SCIP *scip, SCIP_VAR *var, FILE *file)
Definition: scip_var.c:9684
static SCIP_RETCODE relabelOrderConsistent(SCIP *const scip, int *labels, int const nlabels, int *nclasses)
Definition: scip_var.c:6851
SCIP_Bool SCIPallowObjProp(SCIP *scip)
Definition: scip_var.c:8488
SCIP_RETCODE SCIPgetNegatedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **negvar)
Definition: scip_var.c:1530
SCIP_Real SCIPgetVarConflictScore(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:9040
SCIP_RETCODE SCIPbranchcandUpdateVarBranchPriority(SCIP_BRANCHCAND *branchcand, SCIP_SET *set, SCIP_VAR *var, int branchpriority)
Definition: branch.c:1175
SCIP_Real SCIPvarGetPseudocostVariance(SCIP_VAR *var, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun)
Definition: var.c:14165
SCIP_Bool SCIPvarIsActive(SCIP_VAR *var)
Definition: var.c:17016
SCIP_Bool SCIPvarIsNegated(SCIP_VAR *var)
Definition: var.c:16884
SCIP_Real SCIPgetRelaxSolVal(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:2593
SCIP_Real scalar
Definition: struct_var.h:176
#define SCIPreallocBufferArray(scip, ptr, num)
Definition: scip_mem.h:134
void SCIPvarMarkDeleteGlobalStructures(SCIP_VAR *var)
Definition: var.c:16986
SCIP_RETCODE SCIPchgVarName(SCIP *scip, SCIP_VAR *var, const char *name)
Definition: scip_var.c:1302
memory allocation routines
SCIP_Real SCIPgetVarAvgCutoffScore(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:9526