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-2019 Konrad-Zuse-Zentrum */
7 /* fuer Informationstechnik Berlin */
8 /* */
9 /* SCIP is distributed under the terms of the ZIB Academic License. */
10 /* */
11 /* You should have received a copy of the ZIB Academic License */
12 /* along with SCIP; see the file COPYING. If not visit scip.zib.de. */
13 /* */
14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15 
16 /**@file scip_var.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, &(*monomialexps)[i]);
1190  SCIPfreeBufferArrayNull(scip, &(*monomialvars)[i]);
1191  }
1192 
1193  SCIPfreeBufferArray(scip, monomialcoefs);
1194  SCIPfreeBufferArray(scip, monomialnvars);
1195  SCIPfreeBufferArray(scip, monomialexps);
1196  SCIPfreeBufferArray(scip, monomialvars);
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  *cutoff = FALSE;
3103 
3104  if( conflict != NULL )
3105  *conflict = FALSE;
3106 
3107  return SCIP_OKAY;
3108  }
3109 
3110  /* propagate domains at the probing node */
3111  if( propagate )
3112  {
3113  /* start time measuring */
3114  SCIPclockStart(scip->stat->strongpropclock, scip->set);
3115 
3116  ndomreds = 0;
3117  SCIP_CALL( SCIPpropagateProbing(scip, maxproprounds, cutoff, &ndomreds) );
3118 
3119  /* store number of domain reductions in strong branching */
3120  if( down )
3121  SCIPstatAdd(scip->stat, scip->set, nsbdowndomchgs, ndomreds);
3122  else
3123  SCIPstatAdd(scip->stat, scip->set, nsbupdomchgs, ndomreds);
3124 
3125  if( ndomreductions != NULL )
3126  *ndomreductions = ndomreds;
3127 
3128  /* stop time measuring */
3129  SCIPclockStop(scip->stat->strongpropclock, scip->set);
3130 
3131  if( *cutoff )
3132  {
3133  *value = SCIPinfinity(scip);
3134 
3135  if( valid != NULL )
3136  *valid = TRUE;
3137 
3138  SCIPdebugMsg(scip, "%s branch of var <%s> detected infeasible during propagation\n",
3139  down ? "down" : "up", SCIPvarGetName(var));
3140  }
3141  }
3142 
3143  /* if propagation did not already detect infeasibility, solve the probing LP */
3144  if( !(*cutoff) )
3145  {
3146  SCIP_CALL( SCIPsolveProbingLP(scip, itlim, lperror, cutoff) );
3147  assert(SCIPisLPRelax(scip));
3148 
3149  if( *cutoff )
3150  {
3151  assert(!(*lperror));
3152 
3153  *value = SCIPinfinity(scip);
3154 
3155  if( valid != NULL )
3156  *valid = TRUE;
3157 
3158  SCIPdebugMsg(scip, "%s branch of var <%s> detected infeasible in LP solving: status=%d\n",
3159  down ? "down" : "up", SCIPvarGetName(var), SCIPgetLPSolstat(scip));
3160  }
3161  else if( !(*lperror) )
3162  {
3163  /* save the lp solution status */
3164  scip->stat->lastsblpsolstats[down ? 0 : 1] = SCIPgetLPSolstat(scip);
3165 
3166  switch( SCIPgetLPSolstat(scip) )
3167  {
3169  {
3170  *value = SCIPgetLPObjval(scip);
3171  assert(SCIPisLT(scip, *value, SCIPgetCutoffbound(scip)));
3172 
3173  SCIPdebugMsg(scip, "probing LP solved to optimality, objective value: %16.9g\n", *value);
3174 
3175  if( valid != NULL )
3176  *valid = TRUE;
3177 
3178  /* check the strong branching LP solution for feasibility */
3179  SCIP_CALL( SCIPtryStrongbranchLPSol(scip, foundsol, cutoff) );
3180  break;
3181  }
3183  ++scip->stat->nsbtimesiterlimhit;
3184  /*lint -fallthrough*/
3186  {
3187  /* use LP value as estimate */
3188  SCIP_LPI* lpi;
3189  SCIP_Real objval;
3190  SCIP_Real looseobjval;
3191 
3192  SCIPdebugMsg(scip, "probing LP hit %s limit\n", SCIPgetLPSolstat(scip) == SCIP_LPSOLSTAT_ITERLIMIT ? "iteration" : "time");
3193 
3194  /* we access the LPI directly, because when a time limit was hit, we cannot access objective value and dual
3195  * feasibility using the SCIPlp... methods; we should try to avoid direct calls to the LPI, but this is rather
3196  * uncritical here, because we are immediately after the SCIPsolveProbingLP() call, because we access the LPI
3197  * read-only, and we check SCIPlpiWasSolved() first
3198  */
3199  SCIP_CALL( SCIPgetLPI(scip, &lpi) );
3200 
3201  if( SCIPlpiWasSolved(lpi) )
3202  {
3203  SCIP_CALL( SCIPlpiGetObjval(lpi, &objval) );
3204  looseobjval = SCIPlpGetLooseObjval(scip->lp, scip->set, scip->transprob);
3205 
3206  /* the infinity value in the LPI should not be smaller than SCIP's infinity value */
3207  assert(!SCIPlpiIsInfinity(lpi, objval) || SCIPisInfinity(scip, objval));
3208 
3209  /* we use SCIP's infinity value here because a value larger than this is counted as infeasible by SCIP */
3210  if( SCIPisInfinity(scip, objval) )
3211  *value = SCIPinfinity(scip);
3212  else if( SCIPisInfinity(scip, -looseobjval) )
3213  *value = -SCIPinfinity(scip);
3214  else
3215  *value = objval + looseobjval;
3216 
3217  if( SCIPlpiIsDualFeasible(lpi) )
3218  {
3219  if( valid != NULL )
3220  *valid = TRUE;
3221 
3222  if( SCIPisGE(scip, *value, SCIPgetCutoffbound(scip)) )
3223  *cutoff = TRUE;
3224  }
3225  }
3226  break;
3227  }
3228  case SCIP_LPSOLSTAT_ERROR:
3230  *lperror = TRUE;
3231  break;
3232  case SCIP_LPSOLSTAT_NOTSOLVED: /* should only be the case for *cutoff = TRUE or *lperror = TRUE */
3233  case SCIP_LPSOLSTAT_OBJLIMIT: /* in this case, *cutoff should be TRUE and we should not get here */
3234  case SCIP_LPSOLSTAT_INFEASIBLE: /* in this case, *cutoff should be TRUE and we should not get here */
3235  default:
3236  SCIPerrorMessage("invalid LP solution status <%d>\n", SCIPgetLPSolstat(scip));
3237  return SCIP_INVALIDDATA;
3238  } /*lint !e788*/
3239  }
3240 
3241  /* If columns are missing in the LP, the cutoff flag may be wrong. Therefore, we need to set it and the valid pointer
3242  * to false here.
3243  */
3244  if( (*cutoff) && !SCIPallColsInLP(scip) )
3245  {
3246  *cutoff = FALSE;
3247  }
3248 
3249 #ifndef NDEBUG
3250  if( *lperror )
3251  {
3252  SCIPdebugMsg(scip, "error during strong branching probing LP solving: status=%d\n", SCIPgetLPSolstat(scip));
3253  }
3254 #endif
3255  }
3256 
3257  /* if the subproblem was feasible, we store the local bounds of the variables after propagation and (possibly)
3258  * conflict analysis
3259  * @todo do this after propagation? should be able to get valid bounds more often, but they might be weaker
3260  */
3261  if( !(*cutoff) && newlbs != NULL)
3262  {
3263  int v;
3264 
3265  assert(newubs != NULL);
3266 
3267  /* initialize the newlbs and newubs to the current local bounds */
3268  if( firstchild )
3269  {
3270  for( v = 0; v < nvars; ++v )
3271  {
3272  newlbs[v] = SCIPvarGetLbLocal(vars[v]);
3273  newubs[v] = SCIPvarGetUbLocal(vars[v]);
3274  }
3275  }
3276  /* update newlbs and newubs: take the weaker of the already stored bounds and the current local bounds */
3277  else
3278  {
3279  for( v = 0; v < nvars; ++v )
3280  {
3281  SCIP_Real lb = SCIPvarGetLbLocal(vars[v]);
3282  SCIP_Real ub = SCIPvarGetUbLocal(vars[v]);
3283 
3284  newlbs[v] = MIN(newlbs[v], lb);
3285  newubs[v] = MAX(newubs[v], ub);
3286  }
3287  }
3288  }
3289 
3290  /* revert all changes at the probing node */
3291  SCIP_CALL( SCIPbacktrackProbing(scip, 0) );
3292 
3293  return SCIP_OKAY;
3294 }
3295 
3296 /** gets strong branching information with previous domain propagation on column variable
3297  *
3298  * Before calling this method, the strong branching mode must have been activated by calling SCIPstartStrongbranch();
3299  * after strong branching was done for all candidate variables, the strong branching mode must be ended by
3300  * SCIPendStrongbranch(). Since this method applies domain propagation before strongbranching, propagation has to be be
3301  * enabled in the SCIPstartStrongbranch() call.
3302  *
3303  * Before solving the strong branching LP, domain propagation can be performed. The number of propagation rounds
3304  * can be specified by the parameter @p maxproprounds.
3305  *
3306  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3307  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3308  *
3309  * @pre This method can be called if @p scip is in one of the following stages:
3310  * - \ref SCIP_STAGE_PRESOLVED
3311  * - \ref SCIP_STAGE_SOLVING
3312  *
3313  * @warning When using this method, LP banching candidates and solution values must be copied beforehand, because
3314  * they are updated w.r.t. the strong branching LP solution.
3315  */
3317  SCIP* scip, /**< SCIP data structure */
3318  SCIP_VAR* var, /**< variable to get strong branching values for */
3319  SCIP_Real solval, /**< value of the variable in the current LP solution */
3320  SCIP_Real lpobjval, /**< LP objective value of the current LP solution */
3321  int itlim, /**< iteration limit for strong branchings */
3322  int maxproprounds, /**< maximum number of propagation rounds (-1: no limit, -2: parameter
3323  * settings) */
3324  SCIP_Real* down, /**< stores dual bound after branching column down */
3325  SCIP_Real* up, /**< stores dual bound after branching column up */
3326  SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL;
3327  * otherwise, it can only be used as an estimate value */
3328  SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound, or NULL;
3329  * otherwise, it can only be used as an estimate value */
3330  SCIP_Longint* ndomredsdown, /**< pointer to store the number of domain reductions down, or NULL */
3331  SCIP_Longint* ndomredsup, /**< pointer to store the number of domain reductions up, or NULL */
3332  SCIP_Bool* downinf, /**< pointer to store whether the downwards branch is infeasible, or NULL */
3333  SCIP_Bool* upinf, /**< pointer to store whether the upwards branch is infeasible, or NULL */
3334  SCIP_Bool* downconflict, /**< pointer to store whether a conflict constraint was created for an
3335  * infeasible downwards branch, or NULL */
3336  SCIP_Bool* upconflict, /**< pointer to store whether a conflict constraint was created for an
3337  * infeasible upwards branch, or NULL */
3338  SCIP_Bool* lperror, /**< pointer to store whether an unresolved LP error occurred or the
3339  * solving process should be stopped (e.g., due to a time limit) */
3340  SCIP_Real* newlbs, /**< array to store valid lower bounds for all active variables, or NULL */
3341  SCIP_Real* newubs /**< array to store valid upper bounds for all active variables, or NULL */
3342  )
3343 {
3344  SCIP_COL* col;
3345  SCIP_VAR** vars;
3346  SCIP_Longint oldniters;
3347  SCIP_Real newub;
3348  SCIP_Real newlb;
3349  SCIP_Bool propagate;
3350  SCIP_Bool cutoff;
3351  SCIP_Bool downchild;
3352  SCIP_Bool firstchild;
3353  SCIP_Bool foundsol;
3354  SCIP_Bool downvalidlocal;
3355  SCIP_Bool upvalidlocal;
3356  SCIP_Bool allcolsinlp;
3357  SCIP_Bool enabledconflict;
3358  int oldnconflicts;
3359  int nvars;
3360 
3361  assert(scip != NULL);
3362  assert(var != NULL);
3363  assert(SCIPvarIsIntegral(var));
3364  assert(down != NULL);
3365  assert(up != NULL);
3366  assert(lperror != NULL);
3367  assert((newlbs != NULL) == (newubs != NULL));
3368  assert(SCIPinProbing(scip));
3369  assert(var->scip == scip);
3370 
3371  SCIP_CALL( SCIPcheckStage(scip, "SCIPgetVarStrongbranchWithPropagation", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
3372 
3373  /* check whether propagation should be performed */
3374  propagate = (maxproprounds != 0 && maxproprounds != -3);
3375 
3376  /* Check, if all existing columns are in LP.
3377  * If this is not the case, we may still return that the up and down dual bounds are valid, because the branching
3378  * rule should not apply them otherwise.
3379  * However, we must not set the downinf or upinf pointers to TRUE based on the dual bound, because we cannot
3380  * guarantee that this node can be cut off.
3381  */
3382  allcolsinlp = SCIPallColsInLP(scip);
3383 
3384  /* if maxproprounds is -2, change it to 0, which for the following calls means using the parameter settings */
3385  if( maxproprounds == -2 )
3386  maxproprounds = 0;
3387 
3388  *down = lpobjval;
3389  *up = lpobjval;
3390  if( downvalid != NULL )
3391  *downvalid = FALSE;
3392  if( upvalid != NULL )
3393  *upvalid = FALSE;
3394  if( downinf != NULL )
3395  *downinf = FALSE;
3396  if( upinf != NULL )
3397  *upinf = FALSE;
3398  if( downconflict != NULL )
3399  *downconflict = FALSE;
3400  if( upconflict != NULL )
3401  *upconflict = FALSE;
3402  if( ndomredsdown != NULL )
3403  *ndomredsdown = 0;
3404  if( ndomredsup != NULL )
3405  *ndomredsup = 0;
3406 
3407  *lperror = FALSE;
3408 
3409  vars = SCIPgetVars(scip);
3410  nvars = SCIPgetNVars(scip);
3411 
3413 
3414  /* check if the solving process should be aborted */
3415  if( SCIPsolveIsStopped(scip->set, scip->stat, FALSE) )
3416  {
3417  /* mark this as if the LP failed */
3418  *lperror = TRUE;
3419  return SCIP_OKAY;
3420  }
3421 
3423  {
3424  SCIPerrorMessage("cannot get strong branching information on non-COLUMN variable <%s>\n", SCIPvarGetName(var));
3425  return SCIP_INVALIDDATA;
3426  }
3427 
3428  col = SCIPvarGetCol(var);
3429  assert(col != NULL);
3430 
3431  if( !SCIPcolIsInLP(col) )
3432  {
3433  SCIPerrorMessage("cannot get strong branching information on variable <%s> not in current LP\n", SCIPvarGetName(var));
3434  return SCIP_INVALIDDATA;
3435  }
3436 
3437  newlb = SCIPfeasFloor(scip, solval + 1.0);
3438  newub = SCIPfeasCeil(scip, solval - 1.0);
3439 
3440  SCIPdebugMsg(scip, "strong branching on var <%s>: solval=%g, lb=%g, ub=%g\n", SCIPvarGetName(var), solval,
3442 
3443  /* the up branch is infeasible due to the branching bound change; since this means that solval is not within the
3444  * bounds, this should only happen if previous strong branching calls on other variables detected bound changes which
3445  * are valid for and were already applied at the probing root
3446  */
3447  if( newlb > SCIPvarGetUbLocal(var) + 0.5 )
3448  {
3449  *up = SCIPinfinity(scip);
3450 
3451  if( upinf != NULL )
3452  *upinf = TRUE;
3453 
3454  if( upvalid != NULL )
3455  *upvalid = TRUE;
3456 
3457  /* bound changes are applied in SCIPendStrongbranch(), which can be seen as a conflict constraint */
3458  if( upconflict != NULL )
3459  *upconflict = TRUE;
3460 
3461  SCIPcolSetStrongbranchData(col, scip->set, scip->stat, scip->lp, lpobjval, solval,
3462  *down, *up, FALSE, TRUE, 0LL, INT_MAX);
3463 
3464  /* we do not regard the down branch; its valid pointer stays set to FALSE */
3465  return SCIP_OKAY;
3466  }
3467 
3468  /* the down branch is infeasible due to the branching bound change; since this means that solval is not within the
3469  * bounds, this should only happen if previous strong branching calls on other variables detected bound changes which
3470  * are valid for and were already applied at the probing root
3471  */
3472  if( newub < SCIPvarGetLbLocal(var) - 0.5 )
3473  {
3474  *down = SCIPinfinity(scip);
3475 
3476  if( downinf != NULL )
3477  *downinf = TRUE;
3478 
3479  if( downvalid != NULL )
3480  *downvalid = TRUE;
3481 
3482  /* bound changes are applied in SCIPendStrongbranch(), which can be seen as a conflict constraint */
3483  if( downconflict != NULL )
3484  *downconflict = TRUE;
3485 
3486  SCIPcolSetStrongbranchData(col, scip->set, scip->stat, scip->lp, lpobjval, solval,
3487  *down, *up, TRUE, FALSE, 0LL, INT_MAX);
3488 
3489  /* we do not regard the up branch; its valid pointer stays set to FALSE */
3490  return SCIP_OKAY;
3491  }
3492 
3493  /* We now do strong branching by creating the two potential child nodes as probing nodes and solving them one after
3494  * the other. We will stop when the first child is detected infeasible, saving the effort we would need for the
3495  * second child. Since empirically, the up child tends to be infeasible more often, we do strongbranching first on
3496  * the up branch.
3497  */
3498  oldniters = scip->stat->nsbdivinglpiterations;
3499  firstchild = TRUE;
3500  cutoff = FALSE;
3501 
3502  /* switch conflict analysis according to usesb parameter */
3503  enabledconflict = scip->set->conf_enable;
3504  scip->set->conf_enable = (scip->set->conf_enable && scip->set->conf_usesb);
3505 
3506  /* @todo: decide the branch to look at first based on the cutoffs in previous calls? */
3507  downchild = SCIPisStrongbranchDownFirst(scip, var);
3508 
3509  downvalidlocal = FALSE;
3510  upvalidlocal = FALSE;
3511 
3512  do
3513  {
3514  oldnconflicts = SCIPconflictGetNConflicts(scip->conflict);
3515 
3516  if( downchild )
3517  {
3518  SCIP_CALL( performStrongbranchWithPropagation(scip, var, downchild, firstchild, propagate, newub, itlim, maxproprounds,
3519  down, &downvalidlocal, ndomredsdown, downconflict, lperror, vars, nvars, newlbs, newubs, &foundsol, &cutoff) );
3520 
3521  /* check whether a new solutions rendered the previous child infeasible */
3522  if( foundsol && !firstchild && allcolsinlp )
3523  {
3524  if( SCIPisGE(scip, *up, SCIPgetCutoffbound(scip)) )
3525  {
3526  if( upinf != NULL )
3527  *upinf = TRUE;
3528  }
3529  }
3530 
3531  /* check for infeasibility */
3532  if( cutoff )
3533  {
3534  if( downinf != NULL )
3535  *downinf = TRUE;
3536 
3537  if( downconflict != NULL &&
3538  (SCIPvarGetLbLocal(var) > newub + 0.5 || SCIPconflictGetNConflicts(scip->conflict) > oldnconflicts) )
3539  {
3540  *downconflict = TRUE;
3541  }
3542 
3543  if( !scip->set->branch_forceall )
3544  {
3545  /* if this is the first call, we do not regard the up branch, its valid pointer is initially set to FALSE */
3546  break;
3547  }
3548  }
3549  }
3550  else
3551  {
3552  SCIP_CALL( performStrongbranchWithPropagation(scip, var, downchild, firstchild, propagate, newlb, itlim, maxproprounds,
3553  up, &upvalidlocal, ndomredsup, upconflict, lperror, vars, nvars, newlbs, newubs, &foundsol, &cutoff) );
3554 
3555  /* check whether a new solutions rendered the previous child infeasible */
3556  if( foundsol && !firstchild && allcolsinlp )
3557  {
3558  if( SCIPisGE(scip, *down, SCIPgetCutoffbound(scip)) )
3559  {
3560  if( downinf != NULL )
3561  *downinf = TRUE;
3562  }
3563  }
3564 
3565  /* check for infeasibility */
3566  if( cutoff )
3567  {
3568  if( upinf != NULL )
3569  *upinf = TRUE;
3570 
3571  assert(upinf == NULL || (*upinf) == TRUE);
3572 
3573  if( upconflict != NULL &&
3574  (SCIPvarGetUbLocal(var) < newlb - 0.5 || SCIPconflictGetNConflicts(scip->conflict) > oldnconflicts) )
3575  {
3576  *upconflict = TRUE;
3577  }
3578 
3579  if( !scip->set->branch_forceall )
3580  {
3581  /* if this is the first call, we do not regard the down branch, its valid pointer is initially set to FALSE */
3582  break;
3583  }
3584  }
3585  }
3586 
3587  downchild = !downchild;
3588  firstchild = !firstchild;
3589  }
3590  while( !firstchild );
3591 
3592  /* set strong branching information in column */
3593  if( *lperror )
3594  {
3595  SCIPcolInvalidateStrongbranchData(col, scip->set, scip->stat, scip->lp);
3596  }
3597  else
3598  {
3599  SCIPcolSetStrongbranchData(col, scip->set, scip->stat, scip->lp, lpobjval, solval,
3600  *down, *up, downvalidlocal, upvalidlocal, scip->stat->nsbdivinglpiterations - oldniters, itlim);
3601  }
3602 
3603  if( downvalid != NULL )
3604  *downvalid = downvalidlocal;
3605  if( upvalid != NULL )
3606  *upvalid = upvalidlocal;
3607 
3608  scip->set->conf_enable = enabledconflict;
3609 
3610  return SCIP_OKAY;
3611 }
3612 
3613 /** gets strong branching information on column variable x with integral LP solution value (val); that is, the down branch
3614  * is (val -1.0) and the up brach ins (val +1.0)
3615  *
3616  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3617  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3618  *
3619  * @pre This method can be called if @p scip is in one of the following stages:
3620  * - \ref SCIP_STAGE_PRESOLVED
3621  * - \ref SCIP_STAGE_SOLVING
3622  *
3623  * @note If the integral LP solution value is the lower or upper bound of the variable, the corresponding branch will be
3624  * marked as infeasible. That is, the valid pointer and the infeasible pointer are set to TRUE.
3625  */
3627  SCIP* scip, /**< SCIP data structure */
3628  SCIP_VAR* var, /**< variable to get strong branching values for */
3629  int itlim, /**< iteration limit for strong branchings */
3630  SCIP_Real* down, /**< stores dual bound after branching column down */
3631  SCIP_Real* up, /**< stores dual bound after branching column up */
3632  SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL;
3633  * otherwise, it can only be used as an estimate value */
3634  SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound, or NULL;
3635  * otherwise, it can only be used as an estimate value */
3636  SCIP_Bool* downinf, /**< pointer to store whether the downwards branch is infeasible, or NULL */
3637  SCIP_Bool* upinf, /**< pointer to store whether the upwards branch is infeasible, or NULL */
3638  SCIP_Bool* downconflict, /**< pointer to store whether a conflict constraint was created for an
3639  * infeasible downwards branch, or NULL */
3640  SCIP_Bool* upconflict, /**< pointer to store whether a conflict constraint was created for an
3641  * infeasible upwards branch, or NULL */
3642  SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred or the
3643  * solving process should be stopped (e.g., due to a time limit) */
3644  )
3645 {
3646  SCIP_COL* col;
3647 
3648  SCIP_CALL( SCIPcheckStage(scip, "SCIPgetVarStrongbranchInt", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
3649 
3650  assert(lperror != NULL);
3651  assert(var->scip == scip);
3652 
3653  if( downvalid != NULL )
3654  *downvalid = FALSE;
3655  if( upvalid != NULL )
3656  *upvalid = FALSE;
3657  if( downinf != NULL )
3658  *downinf = FALSE;
3659  if( upinf != NULL )
3660  *upinf = FALSE;
3661  if( downconflict != NULL )
3662  *downconflict = FALSE;
3663  if( upconflict != NULL )
3664  *upconflict = FALSE;
3665 
3667  {
3668  SCIPerrorMessage("cannot get strong branching information on non-COLUMN variable <%s>\n", SCIPvarGetName(var));
3669  return SCIP_INVALIDDATA;
3670  }
3671 
3672  col = SCIPvarGetCol(var);
3673  assert(col != NULL);
3674 
3675  if( !SCIPcolIsInLP(col) )
3676  {
3677  SCIPerrorMessage("cannot get strong branching information on variable <%s> not in current LP\n", SCIPvarGetName(var));
3678  return SCIP_INVALIDDATA;
3679  }
3680 
3681  /* check if the solving process should be aborted */
3682  if( SCIPsolveIsStopped(scip->set, scip->stat, FALSE) )
3683  {
3684  /* mark this as if the LP failed */
3685  *lperror = TRUE;
3686  return SCIP_OKAY;
3687  }
3688 
3689  /* call strong branching for column */
3690  SCIP_CALL( SCIPcolGetStrongbranch(col, TRUE, scip->set, scip->stat, scip->transprob, scip->lp, itlim,
3691  down, up, downvalid, upvalid, lperror) );
3692 
3693  /* check, if the branchings are infeasible; in exact solving mode, we cannot trust the strong branching enough to
3694  * declare the sub nodes infeasible
3695  */
3696  if( !(*lperror) && SCIPprobAllColsInLP(scip->transprob, scip->set, scip->lp) && !scip->set->misc_exactsolve )
3697  {
3698  SCIP_CALL( analyzeStrongbranch(scip, var, downinf, upinf, downconflict, upconflict) );
3699  }
3700 
3701  return SCIP_OKAY;
3702 }
3703 
3704 /** gets strong branching information on column variables with fractional values
3705  *
3706  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3707  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3708  *
3709  * @pre This method can be called if @p scip is in one of the following stages:
3710  * - \ref SCIP_STAGE_PRESOLVED
3711  * - \ref SCIP_STAGE_SOLVING
3712  */
3714  SCIP* scip, /**< SCIP data structure */
3715  SCIP_VAR** vars, /**< variables to get strong branching values for */
3716  int nvars, /**< number of variables */
3717  int itlim, /**< iteration limit for strong branchings */
3718  SCIP_Real* down, /**< stores dual bounds after branching variables down */
3719  SCIP_Real* up, /**< stores dual bounds after branching variables up */
3720  SCIP_Bool* downvalid, /**< stores whether the returned down values are valid dual bounds, or NULL;
3721  * otherwise, they can only be used as an estimate value */
3722  SCIP_Bool* upvalid, /**< stores whether the returned up values are valid dual bounds, or NULL;
3723  * otherwise, they can only be used as an estimate value */
3724  SCIP_Bool* downinf, /**< array to store whether the downward branches are infeasible, or NULL */
3725  SCIP_Bool* upinf, /**< array to store whether the upward branches are infeasible, or NULL */
3726  SCIP_Bool* downconflict, /**< array to store whether conflict constraints were created for
3727  * infeasible downward branches, or NULL */
3728  SCIP_Bool* upconflict, /**< array to store whether conflict constraints were created for
3729  * infeasible upward branches, or NULL */
3730  SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred or the
3731  * solving process should be stopped (e.g., due to a time limit) */
3732  )
3733 {
3734  SCIP_COL** cols;
3735  int j;
3736 
3737  SCIP_CALL( SCIPcheckStage(scip, "SCIPgetVarsStrongbranchesFrac", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
3738 
3739  assert( lperror != NULL );
3740  assert( vars != NULL );
3741 
3742  /* set up data */
3743  cols = NULL;
3744  SCIP_CALL( SCIPallocBufferArray(scip, &cols, nvars) );
3745  assert(cols != NULL);
3746  for( j = 0; j < nvars; ++j )
3747  {
3748  SCIP_VAR* var;
3749  SCIP_COL* col;
3750 
3751  if( downvalid != NULL )
3752  downvalid[j] = FALSE;
3753  if( upvalid != NULL )
3754  upvalid[j] = FALSE;
3755  if( downinf != NULL )
3756  downinf[j] = FALSE;
3757  if( upinf != NULL )
3758  upinf[j] = FALSE;
3759  if( downconflict != NULL )
3760  downconflict[j] = FALSE;
3761  if( upconflict != NULL )
3762  upconflict[j] = FALSE;
3763 
3764  var = vars[j];
3765  assert( var != NULL );
3767  {
3768  SCIPerrorMessage("cannot get strong branching information on non-COLUMN variable <%s>\n", SCIPvarGetName(var));
3769  SCIPfreeBufferArray(scip, &cols);
3770  return SCIP_INVALIDDATA;
3771  }
3772 
3773  col = SCIPvarGetCol(var);
3774  assert(col != NULL);
3775  cols[j] = col;
3776 
3777  if( !SCIPcolIsInLP(col) )
3778  {
3779  SCIPerrorMessage("cannot get strong branching information on variable <%s> not in current LP\n", SCIPvarGetName(var));
3780  SCIPfreeBufferArray(scip, &cols);
3781  return SCIP_INVALIDDATA;
3782  }
3783  }
3784 
3785  /* check if the solving process should be aborted */
3786  if( SCIPsolveIsStopped(scip->set, scip->stat, FALSE) )
3787  {
3788  /* mark this as if the LP failed */
3789  *lperror = TRUE;
3790  }
3791  else
3792  {
3793  /* call strong branching for columns with fractional value */
3794  SCIP_CALL( SCIPcolGetStrongbranches(cols, nvars, FALSE, scip->set, scip->stat, scip->transprob, scip->lp, itlim,
3795  down, up, downvalid, upvalid, lperror) );
3796 
3797  /* check, if the branchings are infeasible; in exact solving mode, we cannot trust the strong branching enough to
3798  * declare the sub nodes infeasible
3799  */
3800  if( !(*lperror) && SCIPprobAllColsInLP(scip->transprob, scip->set, scip->lp) && !scip->set->misc_exactsolve )
3801  {
3802  for( j = 0; j < nvars; ++j )
3803  {
3804  SCIP_CALL( analyzeStrongbranch(scip, vars[j], (downinf != NULL) ? (&(downinf[j])) : NULL,
3805  (upinf != NULL) ? (&(upinf[j])) : NULL, (downconflict != NULL) ? (&(downconflict[j])) : NULL,
3806  (upconflict != NULL) ? (&(upconflict[j])) : NULL) );
3807  }
3808  }
3809  }
3810  SCIPfreeBufferArray(scip, &cols);
3811 
3812  return SCIP_OKAY;
3813 }
3814 
3815 /** gets strong branching information on column variables with integral values
3816  *
3817  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3818  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3819  *
3820  * @pre This method can be called if @p scip is in one of the following stages:
3821  * - \ref SCIP_STAGE_PRESOLVED
3822  * - \ref SCIP_STAGE_SOLVING
3823  */
3825  SCIP* scip, /**< SCIP data structure */
3826  SCIP_VAR** vars, /**< variables to get strong branching values for */
3827  int nvars, /**< number of variables */
3828  int itlim, /**< iteration limit for strong branchings */
3829  SCIP_Real* down, /**< stores dual bounds after branching variables down */
3830  SCIP_Real* up, /**< stores dual bounds after branching variables up */
3831  SCIP_Bool* downvalid, /**< stores whether the returned down values are valid dual bounds, or NULL;
3832  * otherwise, they can only be used as an estimate value */
3833  SCIP_Bool* upvalid, /**< stores whether the returned up values are valid dual bounds, or NULL;
3834  * otherwise, they can only be used as an estimate value */
3835  SCIP_Bool* downinf, /**< array to store whether the downward branches are infeasible, or NULL */
3836  SCIP_Bool* upinf, /**< array to store whether the upward branches are infeasible, or NULL */
3837  SCIP_Bool* downconflict, /**< array to store whether conflict constraints were created for
3838  * infeasible downward branches, or NULL */
3839  SCIP_Bool* upconflict, /**< array to store whether conflict constraints were created for
3840  * infeasible upward branches, or NULL */
3841  SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred or the
3842  * solving process should be stopped (e.g., due to a time limit) */
3843  )
3844 {
3845  SCIP_COL** cols;
3846  int j;
3847 
3848  assert(lperror != NULL);
3849 
3850  SCIP_CALL( SCIPcheckStage(scip, "SCIPgetVarsStrongbranchesInt", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
3851 
3852  assert( vars != NULL );
3853 
3854  /* set up data */
3855  cols = NULL;
3856  SCIP_CALL( SCIPallocBufferArray(scip, &cols, nvars) );
3857  assert(cols != NULL);
3858  for( j = 0; j < nvars; ++j )
3859  {
3860  SCIP_VAR* var;
3861  SCIP_COL* col;
3862 
3863  if( downvalid != NULL )
3864  downvalid[j] = FALSE;
3865  if( upvalid != NULL )
3866  upvalid[j] = FALSE;
3867  if( downinf != NULL )
3868  downinf[j] = FALSE;
3869  if( upinf != NULL )
3870  upinf[j] = FALSE;
3871  if( downconflict != NULL )
3872  downconflict[j] = FALSE;
3873  if( upconflict != NULL )
3874  upconflict[j] = FALSE;
3875 
3876  var = vars[j];
3877  assert( var != NULL );
3879  {
3880  SCIPerrorMessage("cannot get strong branching information on non-COLUMN variable <%s>\n", SCIPvarGetName(var));
3881  SCIPfreeBufferArray(scip, &cols);
3882  return SCIP_INVALIDDATA;
3883  }
3884 
3885  col = SCIPvarGetCol(var);
3886  assert(col != NULL);
3887  cols[j] = col;
3888 
3889  if( !SCIPcolIsInLP(col) )
3890  {
3891  SCIPerrorMessage("cannot get strong branching information on variable <%s> not in current LP\n", SCIPvarGetName(var));
3892  SCIPfreeBufferArray(scip, &cols);
3893  return SCIP_INVALIDDATA;
3894  }
3895  }
3896 
3897  /* check if the solving process should be aborted */
3898  if( SCIPsolveIsStopped(scip->set, scip->stat, FALSE) )
3899  {
3900  /* mark this as if the LP failed */
3901  *lperror = TRUE;
3902  }
3903  else
3904  {
3905  /* call strong branching for columns */
3906  SCIP_CALL( SCIPcolGetStrongbranches(cols, nvars, TRUE, scip->set, scip->stat, scip->transprob, scip->lp, itlim,
3907  down, up, downvalid, upvalid, lperror) );
3908 
3909  /* check, if the branchings are infeasible; in exact solving mode, we cannot trust the strong branching enough to
3910  * declare the sub nodes infeasible
3911  */
3912  if( !(*lperror) && SCIPprobAllColsInLP(scip->transprob, scip->set, scip->lp) && !scip->set->misc_exactsolve )
3913  {
3914  for( j = 0; j < nvars; ++j )
3915  {
3916  SCIP_CALL( analyzeStrongbranch(scip, vars[j], (downinf != NULL) ? (&(downinf[j])) : NULL,
3917  (upinf != NULL) ? (&(upinf[j])) : NULL, (downconflict != NULL) ? (&(downconflict[j])) : NULL,
3918  (upconflict != NULL) ? (&(upconflict[j])) : NULL) );
3919  }
3920  }
3921  }
3922  SCIPfreeBufferArray(scip, &cols);
3923 
3924  return SCIP_OKAY;
3925 }
3926 
3927 /** get LP solution status of last strong branching call (currently only works for strong branching with propagation) */
3929  SCIP* scip, /**< SCIP data structure */
3930  SCIP_BRANCHDIR branchdir /**< branching direction for which LP solution status is requested */
3931  )
3932 {
3933  assert(NULL != scip);
3934  assert(branchdir == SCIP_BRANCHDIR_DOWNWARDS || branchdir == SCIP_BRANCHDIR_UPWARDS);
3935 
3936  return scip->stat->lastsblpsolstats[branchdir == SCIP_BRANCHDIR_DOWNWARDS ? 0 : 1];
3937 }
3938 
3939 /** gets strong branching information on COLUMN variable of the last SCIPgetVarStrongbranch() call;
3940  * returns values of SCIP_INVALID, if strong branching was not yet called on the given variable;
3941  * keep in mind, that the returned old values may have nothing to do with the current LP solution
3942  *
3943  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3944  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3945  *
3946  * @pre This method can be called if @p scip is in one of the following stages:
3947  * - \ref SCIP_STAGE_SOLVING
3948  * - \ref SCIP_STAGE_SOLVED
3949  */
3951  SCIP* scip, /**< SCIP data structure */
3952  SCIP_VAR* var, /**< variable to get last strong branching values for */
3953  SCIP_Real* down, /**< stores dual bound after branching column down */
3954  SCIP_Real* up, /**< stores dual bound after branching column up */
3955  SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL;
3956  * otherwise, it can only be used as an estimate value */
3957  SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound, or NULL;
3958  * otherwise, it can only be used as an estimate value */
3959  SCIP_Real* solval, /**< stores LP solution value of variable at the last strong branching call, or NULL */
3960  SCIP_Real* lpobjval /**< stores LP objective value at last strong branching call, or NULL */
3961  )
3962 {
3963  SCIP_CALL( SCIPcheckStage(scip, "SCIPgetVarStrongbranchLast", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
3964 
3966  {
3967  SCIPerrorMessage("cannot get strong branching information on non-COLUMN variable\n");
3968  return SCIP_INVALIDDATA;
3969  }
3970 
3971  SCIPcolGetStrongbranchLast(SCIPvarGetCol(var), down, up, downvalid, upvalid, solval, lpobjval);
3972 
3973  return SCIP_OKAY;
3974 }
3975 
3976 /** sets strong branching information for a column variable
3977  *
3978  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3979  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3980  *
3981  * @pre This method can be called if @p scip is in one of the following stages:
3982  * - \ref SCIP_STAGE_SOLVING
3983  */
3985  SCIP* scip, /**< SCIP data structure */
3986  SCIP_VAR* var, /**< variable to set last strong branching values for */
3987  SCIP_Real lpobjval, /**< objective value of the current LP */
3988  SCIP_Real primsol, /**< primal solution value of the column in the current LP */
3989  SCIP_Real down, /**< dual bound after branching column down */
3990  SCIP_Real up, /**< dual bound after branching column up */
3991  SCIP_Bool downvalid, /**< is the returned down value a valid dual bound? */
3992  SCIP_Bool upvalid, /**< is the returned up value a valid dual bound? */
3993  SCIP_Longint iter, /**< total number of strong branching iterations */
3994  int itlim /**< iteration limit applied to the strong branching call */
3995  )
3996 {
3997  SCIP_CALL( SCIPcheckStage(scip, "SCIPsetVarStrongbranchData", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
3998 
4000  {
4001  SCIPerrorMessage("cannot set strong branching information on non-COLUMN variable\n");
4002  return SCIP_INVALIDDATA;
4003  }
4004 
4005  SCIPcolSetStrongbranchData(SCIPvarGetCol(var), scip->set, scip->stat, scip->lp, lpobjval, primsol,
4006  down, up, downvalid, upvalid, iter, itlim);
4007 
4008  return SCIP_OKAY;
4009 }
4010 
4011 /** rounds the current solution and tries it afterwards; if feasible, adds it to storage
4012  *
4013  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4014  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4015  *
4016  * @pre This method can be called if @p scip is in one of the following stages:
4017  * - \ref SCIP_STAGE_SOLVING
4018  */
4020  SCIP* scip, /**< SCIP data structure */
4021  SCIP_Bool* foundsol, /**< stores whether solution was feasible and good enough to keep */
4022  SCIP_Bool* cutoff /**< stores whether solution was cutoff due to exceeding the cutoffbound */
4023  )
4024 {
4025  assert(scip != NULL);
4026  assert(foundsol != NULL);
4027  assert(cutoff != NULL);
4028 
4029  SCIP_CALL( SCIPcheckStage(scip, "SCIPtryStrongbranchLPSol", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
4030 
4031  if( scip->set->branch_checksbsol )
4032  {
4033  SCIP_SOL* sol;
4034  SCIP_Bool rounded = TRUE;
4035  SCIP_Real value = SCIPgetLPObjval(scip);
4036  SCIP_Longint oldnbestsolsfound = scip->primal->nbestsolsfound;
4037 
4038  /* start clock for strong branching solutions */
4039  SCIPclockStart(scip->stat->sbsoltime, scip->set);
4040 
4041  SCIP_CALL( SCIPcreateLPSol(scip, &sol, NULL) );
4042 
4043  /* try to round the strong branching solution */
4044  if( scip->set->branch_roundsbsol )
4045  {
4046  SCIP_CALL( SCIProundSol(scip, sol, &rounded) );
4047  }
4048 
4049  /* check the solution for feasibility if rounding worked well (or was not tried) */
4050  if( rounded )
4051  {
4052  SCIP_CALL( SCIPtrySolFree(scip, &sol, FALSE, FALSE, FALSE, TRUE, FALSE, foundsol) );
4053  }
4054  else
4055  {
4056  SCIP_CALL( SCIPfreeSol(scip, &sol) );
4057  }
4058 
4059  if( *foundsol )
4060  {
4061  SCIPdebugMsg(scip, "found new solution in strong branching\n");
4062 
4063  scip->stat->nsbsolsfound++;
4064 
4065  if( scip->primal->nbestsolsfound != oldnbestsolsfound )
4066  {
4067  scip->stat->nsbbestsolsfound++;
4068  }
4069 
4070  if( SCIPisGE(scip, value, SCIPgetCutoffbound(scip)) )
4071  *cutoff = TRUE;
4072  }
4073 
4074  /* stop clock for strong branching solutions */
4075  SCIPclockStop(scip->stat->sbsoltime, scip->set);
4076  }
4077  return SCIP_OKAY;
4078 }
4079 
4080 
4081 /** gets node number of the last node in current branch and bound run, where strong branching was used on the
4082  * given variable, or -1 if strong branching was never applied to the variable in current run
4083  *
4084  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4085  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4086  *
4087  * @pre This method can be called if @p scip is in one of the following stages:
4088  * - \ref SCIP_STAGE_TRANSFORMING
4089  * - \ref SCIP_STAGE_TRANSFORMED
4090  * - \ref SCIP_STAGE_INITPRESOLVE
4091  * - \ref SCIP_STAGE_PRESOLVING
4092  * - \ref SCIP_STAGE_EXITPRESOLVE
4093  * - \ref SCIP_STAGE_PRESOLVED
4094  * - \ref SCIP_STAGE_INITSOLVE
4095  * - \ref SCIP_STAGE_SOLVING
4096  * - \ref SCIP_STAGE_SOLVED
4097  * - \ref SCIP_STAGE_EXITSOLVE
4098  */
4100  SCIP* scip, /**< SCIP data structure */
4101  SCIP_VAR* var /**< variable to get last strong branching node for */
4102  )
4103 {
4104  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarStrongbranchNode", FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
4105 
4106  assert( var->scip == scip );
4107 
4109  return -1;
4110 
4112 }
4113 
4114 /** if strong branching was already applied on the variable at the current node, returns the number of LPs solved after
4115  * the LP where the strong branching on this variable was applied;
4116  * if strong branching was not yet applied on the variable at the current node, returns INT_MAX
4117  *
4118  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4119  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4120  *
4121  * @pre This method can be called if @p scip is in one of the following stages:
4122  * - \ref SCIP_STAGE_TRANSFORMING
4123  * - \ref SCIP_STAGE_TRANSFORMED
4124  * - \ref SCIP_STAGE_INITPRESOLVE
4125  * - \ref SCIP_STAGE_PRESOLVING
4126  * - \ref SCIP_STAGE_EXITPRESOLVE
4127  * - \ref SCIP_STAGE_PRESOLVED
4128  * - \ref SCIP_STAGE_INITSOLVE
4129  * - \ref SCIP_STAGE_SOLVING
4130  * - \ref SCIP_STAGE_SOLVED
4131  * - \ref SCIP_STAGE_EXITSOLVE
4132  */
4134  SCIP* scip, /**< SCIP data structure */
4135  SCIP_VAR* var /**< variable to get strong branching LP age for */
4136  )
4137 {
4138  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarStrongbranchLPAge", FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
4139 
4140  assert( var->scip == scip );
4141 
4143  return SCIP_LONGINT_MAX;
4144 
4145  return SCIPcolGetStrongbranchLPAge(SCIPvarGetCol(var), scip->stat);
4146 }
4147 
4148 /** gets number of times, strong branching was applied in current run on the given variable
4149  *
4150  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4151  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4152  *
4153  * @pre This method can be called if @p scip is in one of the following stages:
4154  * - \ref SCIP_STAGE_TRANSFORMING
4155  * - \ref SCIP_STAGE_TRANSFORMED
4156  * - \ref SCIP_STAGE_INITPRESOLVE
4157  * - \ref SCIP_STAGE_PRESOLVING
4158  * - \ref SCIP_STAGE_EXITPRESOLVE
4159  * - \ref SCIP_STAGE_PRESOLVED
4160  * - \ref SCIP_STAGE_INITSOLVE
4161  * - \ref SCIP_STAGE_SOLVING
4162  * - \ref SCIP_STAGE_SOLVED
4163  * - \ref SCIP_STAGE_EXITSOLVE
4164  */
4166  SCIP* scip, /**< SCIP data structure */
4167  SCIP_VAR* var /**< variable to get last strong branching node for */
4168  )
4169 {
4170  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarNStrongbranchs", FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
4171 
4172  assert( var->scip == scip );
4173 
4175  return 0;
4176 
4178 }
4179 
4180 /** adds given values to lock numbers of type @p locktype of variable for rounding
4181  *
4182  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4183  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4184  *
4185  * @pre This method can be called if @p scip is in one of the following stages:
4186  * - \ref SCIP_STAGE_PROBLEM
4187  * - \ref SCIP_STAGE_TRANSFORMING
4188  * - \ref SCIP_STAGE_TRANSFORMED
4189  * - \ref SCIP_STAGE_INITPRESOLVE
4190  * - \ref SCIP_STAGE_PRESOLVING
4191  * - \ref SCIP_STAGE_EXITPRESOLVE
4192  * - \ref SCIP_STAGE_PRESOLVED
4193  * - \ref SCIP_STAGE_INITSOLVE
4194  * - \ref SCIP_STAGE_SOLVING
4195  * - \ref SCIP_STAGE_EXITSOLVE
4196  * - \ref SCIP_STAGE_FREETRANS
4197  */
4199  SCIP* scip, /**< SCIP data structure */
4200  SCIP_VAR* var, /**< problem variable */
4201  SCIP_LOCKTYPE locktype, /**< type of the variable locks */
4202  int nlocksdown, /**< modification in number of rounding down locks */
4203  int nlocksup /**< modification in number of rounding up locks */
4204  )
4205 {
4206  SCIP_CALL( SCIPcheckStage(scip, "SCIPaddVarLocksType", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE) );
4207 
4208  assert( var->scip == scip );
4209 
4210  switch( scip->set->stage )
4211  {
4212  case SCIP_STAGE_PROBLEM:
4213  assert(!SCIPvarIsTransformed(var));
4214  /*lint -fallthrough*/
4218  case SCIP_STAGE_PRESOLVING:
4220  case SCIP_STAGE_PRESOLVED:
4221  case SCIP_STAGE_INITSOLVE:
4222  case SCIP_STAGE_SOLVING:
4223  case SCIP_STAGE_EXITSOLVE:
4224  case SCIP_STAGE_FREETRANS:
4225  SCIP_CALL( SCIPvarAddLocks(var, scip->mem->probmem, scip->set, scip->eventqueue, locktype, nlocksdown, nlocksup) );
4226  return SCIP_OKAY;
4227 
4228  default:
4229  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
4230  return SCIP_INVALIDCALL;
4231  } /*lint !e788*/
4232 }
4233 
4234 /** adds given values to lock numbers of variable for rounding
4235  *
4236  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4237  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4238  *
4239  * @pre This method can be called if @p scip is in one of the following stages:
4240  * - \ref SCIP_STAGE_PROBLEM
4241  * - \ref SCIP_STAGE_TRANSFORMING
4242  * - \ref SCIP_STAGE_TRANSFORMED
4243  * - \ref SCIP_STAGE_INITPRESOLVE
4244  * - \ref SCIP_STAGE_PRESOLVING
4245  * - \ref SCIP_STAGE_EXITPRESOLVE
4246  * - \ref SCIP_STAGE_PRESOLVED
4247  * - \ref SCIP_STAGE_INITSOLVE
4248  * - \ref SCIP_STAGE_SOLVING
4249  * - \ref SCIP_STAGE_EXITSOLVE
4250  * - \ref SCIP_STAGE_FREETRANS
4251  *
4252  * @note This method will always add variable locks of type model
4253  *
4254  * @note It is recommented to use SCIPaddVarLocksType()
4255  */
4257  SCIP* scip, /**< SCIP data structure */
4258  SCIP_VAR* var, /**< problem variable */
4259  int nlocksdown, /**< modification in number of rounding down locks */
4260  int nlocksup /**< modification in number of rounding up locks */
4261  )
4262 {
4263  SCIP_CALL( SCIPcheckStage(scip, "SCIPaddVarLocks", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE) );
4264 
4265  SCIP_CALL( SCIPaddVarLocksType(scip, var, SCIP_LOCKTYPE_MODEL, nlocksdown, nlocksup) );
4266 
4267  return SCIP_OKAY;
4268 }
4269 
4270 /** add locks of variable with respect to the lock status of the constraint and its negation;
4271  * this method should be called whenever the lock status of a variable in a constraint changes, for example if
4272  * the coefficient of the variable changed its sign or if the left or right hand sides of the constraint were
4273  * added or removed
4274  *
4275  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4276  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4277  *
4278  * @pre This method can be called if @p scip is in one of the following stages:
4279  * - \ref SCIP_STAGE_PROBLEM
4280  * - \ref SCIP_STAGE_TRANSFORMING
4281  * - \ref SCIP_STAGE_INITPRESOLVE
4282  * - \ref SCIP_STAGE_PRESOLVING
4283  * - \ref SCIP_STAGE_EXITPRESOLVE
4284  * - \ref SCIP_STAGE_INITSOLVE
4285  * - \ref SCIP_STAGE_SOLVING
4286  * - \ref SCIP_STAGE_EXITSOLVE
4287  * - \ref SCIP_STAGE_FREETRANS
4288  */
4290  SCIP* scip, /**< SCIP data structure */
4291  SCIP_VAR* var, /**< problem variable */
4292  SCIP_CONS* cons, /**< constraint */
4293  SCIP_Bool lockdown, /**< should the rounding be locked in downwards direction? */
4294  SCIP_Bool lockup /**< should the rounding be locked in upwards direction? */
4295  )
4296 {
4297  int nlocksdown[NLOCKTYPES];
4298  int nlocksup[NLOCKTYPES];
4299  int i;
4300 
4301  SCIP_CALL( SCIPcheckStage(scip, "SCIPlockVarCons", FALSE, TRUE, TRUE, FALSE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE) );
4302 
4303  assert( var->scip == scip );
4304 
4305  for( i = 0; i < NLOCKTYPES; i++ )
4306  {
4307  nlocksdown[i] = 0;
4308  nlocksup[i] = 0;
4309 
4310  if( SCIPconsIsLockedTypePos(cons, (SCIP_LOCKTYPE) i) )
4311  {
4312  if( lockdown )
4313  ++nlocksdown[i];
4314  if( lockup )
4315  ++nlocksup[i];
4316  }
4317  if( SCIPconsIsLockedTypeNeg(cons, (SCIP_LOCKTYPE) i) )
4318  {
4319  if( lockdown )
4320  ++nlocksup[i];
4321  if( lockup )
4322  ++nlocksdown[i];
4323  }
4324  }
4325 
4326  switch( scip->set->stage )
4327  {
4328  case SCIP_STAGE_PROBLEM:
4329  assert(!SCIPvarIsTransformed(var));
4330  /*lint -fallthrough*/
4334  case SCIP_STAGE_PRESOLVING:
4336  case SCIP_STAGE_INITSOLVE:
4337  case SCIP_STAGE_SOLVING:
4338  case SCIP_STAGE_EXITSOLVE:
4339  case SCIP_STAGE_FREETRANS:
4340  for( i = 0; i < NLOCKTYPES; i++ )
4341  {
4342  if( nlocksdown[i] == 0 && nlocksup[i] == 0 )
4343  continue;
4344 
4345  SCIP_CALL( SCIPvarAddLocks(var, scip->mem->probmem, scip->set, scip->eventqueue, (SCIP_LOCKTYPE) i, nlocksdown[i], nlocksup[i]) );
4346  }
4347  return SCIP_OKAY;
4348 
4349  default:
4350  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
4351  return SCIP_INVALIDCALL;
4352  } /*lint !e788*/
4353 }
4354 
4355 /** remove locks of type @p locktype of variable with respect to the lock status of the constraint and its negation;
4356  * this method should be called whenever the lock status of a variable in a constraint changes, for example if
4357  * the coefficient of the variable changed its sign or if the left or right hand sides of the constraint were
4358  * added or removed
4359  *
4360  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4361  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4362  *
4363  * @pre This method can be called if @p scip is in one of the following stages:
4364  * - \ref SCIP_STAGE_PROBLEM
4365  * - \ref SCIP_STAGE_TRANSFORMING
4366  * - \ref SCIP_STAGE_INITPRESOLVE
4367  * - \ref SCIP_STAGE_PRESOLVING
4368  * - \ref SCIP_STAGE_EXITPRESOLVE
4369  * - \ref SCIP_STAGE_INITSOLVE
4370  * - \ref SCIP_STAGE_SOLVING
4371  * - \ref SCIP_STAGE_EXITSOLVE
4372  * - \ref SCIP_STAGE_FREETRANS
4373  */
4375  SCIP* scip, /**< SCIP data structure */
4376  SCIP_VAR* var, /**< problem variable */
4377  SCIP_CONS* cons, /**< constraint */
4378  SCIP_Bool lockdown, /**< should the rounding be unlocked in downwards direction? */
4379  SCIP_Bool lockup /**< should the rounding be unlocked in upwards direction? */
4380  )
4381 {
4382  int nlocksdown[NLOCKTYPES];
4383  int nlocksup[NLOCKTYPES];
4384  int i;
4385 
4386  SCIP_CALL( SCIPcheckStage(scip, "SCIPunlockVarCons", FALSE, TRUE, TRUE, FALSE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE) );
4387 
4388  assert( var->scip == scip );
4389 
4390  for( i = 0; i < NLOCKTYPES; i++ )
4391  {
4392  nlocksdown[i] = 0;
4393  nlocksup[i] = 0;
4394 
4395  if( SCIPconsIsLockedTypePos(cons, (SCIP_LOCKTYPE) i) )
4396  {
4397  if( lockdown )
4398  ++nlocksdown[i];
4399  if( lockup )
4400  ++nlocksup[i];
4401  }
4402  if( SCIPconsIsLockedTypeNeg(cons, (SCIP_LOCKTYPE) i) )
4403  {
4404  if( lockdown )
4405  ++nlocksup[i];
4406  if( lockup )
4407  ++nlocksdown[i];
4408  }
4409  }
4410  switch( scip->set->stage )
4411  {
4412  case SCIP_STAGE_PROBLEM:
4413  assert(!SCIPvarIsTransformed(var));
4414  /*lint -fallthrough*/
4417  case SCIP_STAGE_PRESOLVING:
4419  case SCIP_STAGE_INITSOLVE:
4420  case SCIP_STAGE_SOLVING:
4421  case SCIP_STAGE_EXITSOLVE:
4422  case SCIP_STAGE_FREETRANS:
4423  for( i = 0; i < NLOCKTYPES; i++ )
4424  {
4425  if( nlocksdown[i] == 0 && nlocksup[i] == 0 )
4426  continue;
4427 
4428  SCIP_CALL( SCIPvarAddLocks(var, scip->mem->probmem, scip->set, scip->eventqueue, (SCIP_LOCKTYPE) i, -nlocksdown[i], -nlocksup[i]) );
4429  }
4430  return SCIP_OKAY;
4431 
4432  default:
4433  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
4434  return SCIP_INVALIDCALL;
4435  } /*lint !e788*/
4436 }
4437 
4438 /** changes variable's objective value
4439  *
4440  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4441  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4442  *
4443  * @pre This method can be called if @p scip is in one of the following stages:
4444  * - \ref SCIP_STAGE_PROBLEM
4445  * - \ref SCIP_STAGE_TRANSFORMING
4446  * - \ref SCIP_STAGE_PRESOLVING
4447  * - \ref SCIP_STAGE_PRESOLVED
4448  */
4450  SCIP* scip, /**< SCIP data structure */
4451  SCIP_VAR* var, /**< variable to change the objective value for */
4452  SCIP_Real newobj /**< new objective value */
4453  )
4454 {
4455  SCIP_CALL( SCIPcheckStage(scip, "SCIPchgVarObj", FALSE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
4456 
4457  assert( var->scip == scip );
4458 
4459  /* forbid infinite objective values */
4460  if( SCIPisInfinity(scip, REALABS(newobj)) )
4461  {
4462  SCIPerrorMessage("invalid objective value: objective value is infinite\n");
4463  return SCIP_INVALIDDATA;
4464  }
4465 
4466  switch( scip->set->stage )
4467  {
4468  case SCIP_STAGE_PROBLEM:
4469  assert(!SCIPvarIsTransformed(var));
4470  SCIP_CALL( SCIPvarChgObj(var, scip->mem->probmem, scip->set, scip->origprob, scip->primal, scip->lp, scip->eventqueue, newobj) );
4471  return SCIP_OKAY;
4472 
4475  case SCIP_STAGE_PRESOLVING:
4476  case SCIP_STAGE_PRESOLVED:
4477  SCIP_CALL( SCIPvarChgObj(var, scip->mem->probmem, scip->set, scip->transprob, scip->primal, scip->lp, scip->eventqueue, newobj) );
4478  return SCIP_OKAY;
4479 
4480  default:
4481  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
4482  return SCIP_INVALIDCALL;
4483  } /*lint !e788*/
4484 }
4485 
4486 /** adds value to variable's objective value
4487  *
4488  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4489  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4490  *
4491  * @pre This method can be called if @p scip is in one of the following stages:
4492  * - \ref SCIP_STAGE_PROBLEM
4493  * - \ref SCIP_STAGE_TRANSFORMING
4494  * - \ref SCIP_STAGE_PRESOLVING
4495  * - \ref SCIP_STAGE_EXITPRESOLVE
4496  * - \ref SCIP_STAGE_PRESOLVED
4497  */
4499  SCIP* scip, /**< SCIP data structure */
4500  SCIP_VAR* var, /**< variable to change the objective value for */
4501  SCIP_Real addobj /**< additional objective value */
4502  )
4503 {
4504  SCIP_CALL( SCIPcheckStage(scip, "SCIPaddVarObj", FALSE, TRUE, TRUE, FALSE, FALSE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
4505 
4506  assert( var->scip == scip );
4507 
4508  switch( scip->set->stage )
4509  {
4510  case SCIP_STAGE_PROBLEM:
4511  assert(!SCIPvarIsTransformed(var));
4512  SCIP_CALL( SCIPvarAddObj(var, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob, scip->primal,
4513  scip->tree, scip->reopt, scip->lp, scip->eventqueue, addobj) );
4514  return SCIP_OKAY;
4515 
4517  case SCIP_STAGE_PRESOLVING:
4519  case SCIP_STAGE_PRESOLVED:
4520  SCIP_CALL( SCIPvarAddObj(var, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob, scip->primal,
4521  scip->tree, scip->reopt, scip->lp, scip->eventqueue, addobj) );
4522  return SCIP_OKAY;
4523 
4524  default:
4525  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
4526  return SCIP_INVALIDCALL;
4527  } /*lint !e788*/
4528 }
4529 
4530 /** returns the adjusted (i.e. rounded, if the given variable is of integral type) lower bound value;
4531  * does not change the bounds of the variable
4532  *
4533  * @return adjusted lower bound for the given variable; the bound of the variable is not changed
4534  *
4535  * @pre This method can be called if @p scip is in one of the following stages:
4536  * - \ref SCIP_STAGE_PROBLEM
4537  * - \ref SCIP_STAGE_TRANSFORMING
4538  * - \ref SCIP_STAGE_TRANSFORMED
4539  * - \ref SCIP_STAGE_INITPRESOLVE
4540  * - \ref SCIP_STAGE_PRESOLVING
4541  * - \ref SCIP_STAGE_EXITPRESOLVE
4542  * - \ref SCIP_STAGE_PRESOLVED
4543  * - \ref SCIP_STAGE_INITSOLVE
4544  * - \ref SCIP_STAGE_SOLVING
4545  * - \ref SCIP_STAGE_SOLVED
4546  * - \ref SCIP_STAGE_EXITSOLVE
4547  * - \ref SCIP_STAGE_FREETRANS
4548  */
4550  SCIP* scip, /**< SCIP data structure */
4551  SCIP_VAR* var, /**< variable to adjust the bound for */
4552  SCIP_Real lb /**< lower bound value to adjust */
4553  )
4554 {
4555  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPadjustedVarLb", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
4556 
4557  SCIPvarAdjustLb(var, scip->set, &lb);
4558 
4559  return lb;
4560 }
4561 
4562 /** returns the adjusted (i.e. rounded, if the given variable is of integral type) upper bound value;
4563  * does not change the bounds of the variable
4564  *
4565  * @return adjusted upper bound for the given variable; the bound of the variable is not changed
4566  *
4567  * @pre This method can be called if @p scip is in one of the following stages:
4568  * - \ref SCIP_STAGE_PROBLEM
4569  * - \ref SCIP_STAGE_TRANSFORMING
4570  * - \ref SCIP_STAGE_TRANSFORMED
4571  * - \ref SCIP_STAGE_INITPRESOLVE
4572  * - \ref SCIP_STAGE_PRESOLVING
4573  * - \ref SCIP_STAGE_EXITPRESOLVE
4574  * - \ref SCIP_STAGE_PRESOLVED
4575  * - \ref SCIP_STAGE_INITSOLVE
4576  * - \ref SCIP_STAGE_SOLVING
4577  * - \ref SCIP_STAGE_SOLVED
4578  * - \ref SCIP_STAGE_EXITSOLVE
4579  * - \ref SCIP_STAGE_FREETRANS
4580  */
4582  SCIP* scip, /**< SCIP data structure */
4583  SCIP_VAR* var, /**< variable to adjust the bound for */
4584  SCIP_Real ub /**< upper bound value to adjust */
4585  )
4586 {
4587  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPadjustedVarUb", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
4588 
4589  SCIPvarAdjustUb(var, scip->set, &ub);
4590 
4591  return ub;
4592 }
4593 
4594 /** depending on SCIP's stage, changes lower bound of variable in the problem, in preprocessing, or in current node;
4595  * if possible, adjusts bound to integral value; doesn't store any inference information in the bound change, such
4596  * that in conflict analysis, this change is treated like a branching decision
4597  *
4598  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
4599  * SCIPgetVars()) gets resorted.
4600  *
4601  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4602  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4603  *
4604  * @pre This method can be called if @p scip is in one of the following stages:
4605  * - \ref SCIP_STAGE_PROBLEM
4606  * - \ref SCIP_STAGE_TRANSFORMING
4607  * - \ref SCIP_STAGE_PRESOLVING
4608  * - \ref SCIP_STAGE_SOLVING
4609  *
4610  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
4611  */
4613  SCIP* scip, /**< SCIP data structure */
4614  SCIP_VAR* var, /**< variable to change the bound for */
4615  SCIP_Real newbound /**< new value for bound */
4616  )
4617 {
4618  SCIP_CALL( SCIPcheckStage(scip, "SCIPchgVarLb", FALSE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
4619 
4620  SCIPvarAdjustLb(var, scip->set, &newbound);
4621 
4622  /* ignore tightenings of lower bounds to +infinity during solving process */
4623  if( SCIPisInfinity(scip, newbound) && SCIPgetStage(scip) == SCIP_STAGE_SOLVING )
4624  {
4625 #ifndef NDEBUG
4626  SCIPwarningMessage(scip, "ignore lower bound tightening for %s from %e to +infinity\n", SCIPvarGetName(var),
4627  SCIPvarGetLbLocal(var));
4628 #endif
4629  return SCIP_OKAY;
4630  }
4631 
4632  switch( scip->set->stage )
4633  {
4634  case SCIP_STAGE_PROBLEM:
4635  assert(!SCIPvarIsTransformed(var));
4636  SCIP_CALL( SCIPvarChgLbGlobal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
4637  scip->branchcand, scip->eventqueue, scip->cliquetable, newbound) );
4638  SCIP_CALL( SCIPvarChgLbLocal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
4639  scip->branchcand, scip->eventqueue, newbound) );
4640  SCIP_CALL( SCIPvarChgLbOriginal(var, scip->set, newbound) );
4641  break;
4642 
4644  case SCIP_STAGE_PRESOLVED:
4645  SCIP_CALL( SCIPvarChgLbGlobal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
4646  scip->branchcand, scip->eventqueue, scip->cliquetable, newbound) );
4647  break;
4648 
4649  case SCIP_STAGE_PRESOLVING:
4650  if( !SCIPinProbing(scip) )
4651  {
4652  assert(SCIPtreeGetCurrentDepth(scip->tree) == 0);
4653  assert(scip->tree->root == SCIPtreeGetCurrentNode(scip->tree));
4654 
4655  SCIP_CALL( SCIPnodeAddBoundchg(scip->tree->root, scip->mem->probmem, scip->set, scip->stat, scip->transprob,
4656  scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable,
4657  var, newbound, SCIP_BOUNDTYPE_LOWER, FALSE) );
4658 
4660  {
4661  SCIP_Bool infeasible;
4662 
4663  SCIP_CALL( SCIPchgVarType(scip, var, SCIP_VARTYPE_BINARY, &infeasible) );
4664  assert(!infeasible);
4665  }
4666  break;
4667  }
4668  /*lint -fallthrough*/
4669  case SCIP_STAGE_SOLVING:
4671  scip->transprob, scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue,
4672  scip->cliquetable, var, newbound,
4674  break;
4675 
4676  default:
4677  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
4678  return SCIP_INVALIDCALL;
4679  } /*lint !e788*/
4680 
4681  return SCIP_OKAY;
4682 }
4683 
4684 /** depending on SCIP's stage, changes upper bound of variable in the problem, in preprocessing, or in current node;
4685  * if possible, adjusts bound to integral value; doesn't store any inference information in the bound change, such
4686  * that in conflict analysis, this change is treated like a branching decision
4687  *
4688  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
4689  * SCIPgetVars()) gets resorted.
4690  *
4691  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4692  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4693  *
4694  * @pre This method can be called if @p scip is in one of the following stages:
4695  * - \ref SCIP_STAGE_PROBLEM
4696  * - \ref SCIP_STAGE_TRANSFORMING
4697  * - \ref SCIP_STAGE_PRESOLVING
4698  * - \ref SCIP_STAGE_SOLVING
4699  *
4700  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
4701  */
4703  SCIP* scip, /**< SCIP data structure */
4704  SCIP_VAR* var, /**< variable to change the bound for */
4705  SCIP_Real newbound /**< new value for bound */
4706  )
4707 {
4708  SCIP_CALL( SCIPcheckStage(scip, "SCIPchgVarUb", FALSE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
4709 
4710  SCIPvarAdjustUb(var, scip->set, &newbound);
4711 
4712  /* ignore tightenings of upper bounds to -infinity during solving process */
4713  if( SCIPisInfinity(scip, -newbound) && SCIPgetStage(scip) == SCIP_STAGE_SOLVING )
4714  {
4715 #ifndef NDEBUG
4716  SCIPwarningMessage(scip, "ignore upper bound tightening for %s from %e to -infinity\n", SCIPvarGetName(var),
4717  SCIPvarGetUbLocal(var));
4718 #endif
4719  return SCIP_OKAY;
4720  }
4721 
4722  switch( scip->set->stage )
4723  {
4724  case SCIP_STAGE_PROBLEM:
4725  assert(!SCIPvarIsTransformed(var));
4726  SCIP_CALL( SCIPvarChgUbGlobal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
4727  scip->branchcand, scip->eventqueue, scip->cliquetable, newbound) );
4728  SCIP_CALL( SCIPvarChgUbLocal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
4729  scip->branchcand, scip->eventqueue, newbound) );
4730  SCIP_CALL( SCIPvarChgUbOriginal(var, scip->set, newbound) );
4731  break;
4732 
4734  case SCIP_STAGE_PRESOLVED:
4735  SCIP_CALL( SCIPvarChgUbGlobal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
4736  scip->branchcand, scip->eventqueue, scip->cliquetable, newbound) );
4737  break;
4738 
4739  case SCIP_STAGE_PRESOLVING:
4740  if( !SCIPinProbing(scip) )
4741  {
4742  assert(SCIPtreeGetCurrentDepth(scip->tree) == 0);
4743  assert(scip->tree->root == SCIPtreeGetCurrentNode(scip->tree));
4744 
4745  SCIP_CALL( SCIPnodeAddBoundchg(scip->tree->root, scip->mem->probmem, scip->set, scip->stat, scip->transprob,
4746  scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue,
4747  scip->cliquetable, var, newbound, SCIP_BOUNDTYPE_UPPER, FALSE) );
4748 
4750  {
4751  SCIP_Bool infeasible;
4752 
4753  SCIP_CALL( SCIPchgVarType(scip, var, SCIP_VARTYPE_BINARY, &infeasible) );
4754  assert(!infeasible);
4755  }
4756  break;
4757  }
4758  /*lint -fallthrough*/
4759  case SCIP_STAGE_SOLVING:
4761  scip->transprob, scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue,
4762  scip->cliquetable, var, newbound, SCIP_BOUNDTYPE_UPPER, FALSE) );
4763  break;
4764 
4765  default:
4766  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
4767  return SCIP_INVALIDCALL;
4768  } /*lint !e788*/
4769 
4770  return SCIP_OKAY;
4771 }
4772 
4773 /** changes lower bound of variable in the given node; if possible, adjust bound to integral value; doesn't store any
4774  * inference information in the bound change, such that in conflict analysis, this change is treated like a branching
4775  * decision
4776  *
4777  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4778  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4779  *
4780  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
4781  */
4783  SCIP* scip, /**< SCIP data structure */
4784  SCIP_NODE* node, /**< node to change bound at, or NULL for current node */
4785  SCIP_VAR* var, /**< variable to change the bound for */
4786  SCIP_Real newbound /**< new value for bound */
4787  )
4788 {
4789  SCIP_CALL( SCIPcheckStage(scip, "SCIPchgVarLbNode", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
4790 
4791  if( node == NULL )
4792  {
4793  SCIP_CALL( SCIPchgVarLb(scip, var, newbound) );
4794  }
4795  else
4796  {
4797  SCIPvarAdjustLb(var, scip->set, &newbound);
4798 
4799  /* ignore tightenings of lower bounds to +infinity during solving process */
4800  if( SCIPisInfinity(scip, newbound) && SCIPgetStage(scip) == SCIP_STAGE_SOLVING )
4801  {
4802 #ifndef NDEBUG
4803  SCIPwarningMessage(scip, "ignore lower bound tightening for %s from %e to +infinity\n", SCIPvarGetName(var),
4804  SCIPvarGetLbLocal(var));
4805 #endif
4806  return SCIP_OKAY;
4807  }
4808 
4809  SCIP_CALL( SCIPnodeAddBoundchg(node, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob,
4810  scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable, var, newbound,
4812  }
4813 
4814  return SCIP_OKAY;
4815 }
4816 
4817 /** changes upper bound of variable in the given node; if possible, adjust bound to integral value; doesn't store any
4818  * inference information in the bound change, such that in conflict analysis, this change is treated like a branching
4819  * decision
4820  *
4821  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4822  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4823  *
4824  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
4825  */
4827  SCIP* scip, /**< SCIP data structure */
4828  SCIP_NODE* node, /**< node to change bound at, or NULL for current node */
4829  SCIP_VAR* var, /**< variable to change the bound for */
4830  SCIP_Real newbound /**< new value for bound */
4831  )
4832 {
4833  SCIP_CALL( SCIPcheckStage(scip, "SCIPchgVarUbNode", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
4834 
4835  if( node == NULL )
4836  {
4837  SCIP_CALL( SCIPchgVarUb(scip, var, newbound) );
4838  }
4839  else
4840  {
4841  SCIPvarAdjustUb(var, scip->set, &newbound);
4842 
4843  /* ignore tightenings of upper bounds to -infinity during solving process */
4844  if( SCIPisInfinity(scip, -newbound) && SCIPgetStage(scip) == SCIP_STAGE_SOLVING )
4845  {
4846 #ifndef NDEBUG
4847  SCIPwarningMessage(scip, "ignore upper bound tightening for %s from %e to -infinity\n", SCIPvarGetName(var),
4848  SCIPvarGetUbLocal(var));
4849 #endif
4850  return SCIP_OKAY;
4851  }
4852 
4853  SCIP_CALL( SCIPnodeAddBoundchg(node, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob,
4854  scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable, var, newbound,
4856  }
4857 
4858  return SCIP_OKAY;
4859 }
4860 
4861 /** changes global lower bound of variable; if possible, adjust bound to integral value; also tightens the local bound,
4862  * if the global bound is better than the local bound
4863  *
4864  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
4865  * SCIPgetVars()) gets resorted.
4866  *
4867  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4868  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4869  *
4870  * @pre This method can be called if @p scip is in one of the following stages:
4871  * - \ref SCIP_STAGE_PROBLEM
4872  * - \ref SCIP_STAGE_TRANSFORMING
4873  * - \ref SCIP_STAGE_PRESOLVING
4874  * - \ref SCIP_STAGE_SOLVING
4875  *
4876  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
4877  */
4879  SCIP* scip, /**< SCIP data structure */
4880  SCIP_VAR* var, /**< variable to change the bound for */
4881  SCIP_Real newbound /**< new value for bound */
4882  )
4883 {
4884  SCIP_CALL( SCIPcheckStage(scip, "SCIPchgVarLbGlobal", FALSE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
4885 
4886  SCIPvarAdjustLb(var, scip->set, &newbound);
4887 
4888  /* ignore tightenings of lower bounds to +infinity during solving process */
4889  if( SCIPisInfinity(scip, newbound) && SCIPgetStage(scip) == SCIP_STAGE_SOLVING )
4890  {
4891 #ifndef NDEBUG
4892  SCIPwarningMessage(scip, "ignore lower bound tightening for %s from %e to +infinity\n", SCIPvarGetName(var),
4893  SCIPvarGetLbLocal(var));
4894 #endif
4895  return SCIP_OKAY;
4896  }
4897 
4898  switch( scip->set->stage )
4899  {
4900  case SCIP_STAGE_PROBLEM:
4901  assert(!SCIPvarIsTransformed(var));
4902  SCIP_CALL( SCIPvarChgLbGlobal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
4903  scip->branchcand, scip->eventqueue, scip->cliquetable, newbound) );
4904  SCIP_CALL( SCIPvarChgLbLocal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
4905  scip->branchcand, scip->eventqueue, newbound) );
4906  SCIP_CALL( SCIPvarChgLbOriginal(var, scip->set, newbound) );
4907  break;
4908 
4910  SCIP_CALL( SCIPvarChgLbGlobal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
4911  scip->branchcand, scip->eventqueue, scip->cliquetable, newbound) );
4912  break;
4913 
4914  case SCIP_STAGE_PRESOLVING:
4915  if( !SCIPinProbing(scip) )
4916  {
4917  assert(SCIPtreeGetCurrentDepth(scip->tree) == 0);
4918  assert(scip->tree->root == SCIPtreeGetCurrentNode(scip->tree));
4919 
4920  SCIP_CALL( SCIPnodeAddBoundchg(scip->tree->root, scip->mem->probmem, scip->set, scip->stat, scip->transprob,
4921  scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable, var, newbound,
4923 
4925  {
4926  SCIP_Bool infeasible;
4927 
4928  SCIP_CALL( SCIPchgVarType(scip, var, SCIP_VARTYPE_BINARY, &infeasible) );
4929  assert(!infeasible);
4930  }
4931  break;
4932  }
4933  /*lint -fallthrough*/
4934  case SCIP_STAGE_SOLVING:
4935  SCIP_CALL( SCIPnodeAddBoundchg(scip->tree->root, scip->mem->probmem, scip->set, scip->stat, scip->transprob,
4936  scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable, var, newbound,
4938  break;
4939 
4940  default:
4941  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
4942  return SCIP_INVALIDCALL;
4943  } /*lint !e788*/
4944 
4945  return SCIP_OKAY;
4946 }
4947 
4948 /** changes global upper bound of variable; if possible, adjust bound to integral value; also tightens the local bound,
4949  * if the global bound is better than the local bound
4950  *
4951  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
4952  * SCIPgetVars()) gets resorted.
4953  *
4954  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4955  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4956  *
4957  * @pre This method can be called if @p scip is in one of the following stages:
4958  * - \ref SCIP_STAGE_PROBLEM
4959  * - \ref SCIP_STAGE_TRANSFORMING
4960  * - \ref SCIP_STAGE_PRESOLVING
4961  * - \ref SCIP_STAGE_SOLVING
4962  *
4963  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
4964  */
4966  SCIP* scip, /**< SCIP data structure */
4967  SCIP_VAR* var, /**< variable to change the bound for */
4968  SCIP_Real newbound /**< new value for bound */
4969  )
4970 {
4971  SCIP_CALL( SCIPcheckStage(scip, "SCIPchgVarUbGlobal", FALSE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
4972 
4973  SCIPvarAdjustUb(var, scip->set, &newbound);
4974 
4975  /* ignore tightenings of upper bounds to -infinity during solving process */
4976  if( SCIPisInfinity(scip, -newbound) && SCIPgetStage(scip) == SCIP_STAGE_SOLVING )
4977  {
4978 #ifndef NDEBUG
4979  SCIPwarningMessage(scip, "ignore upper bound tightening for %s from %e to -infinity\n", SCIPvarGetName(var),
4980  SCIPvarGetUbLocal(var));
4981 #endif
4982  return SCIP_OKAY;
4983  }
4984 
4985  switch( scip->set->stage )
4986  {
4987  case SCIP_STAGE_PROBLEM:
4988  assert(!SCIPvarIsTransformed(var));
4989  SCIP_CALL( SCIPvarChgUbGlobal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
4990  scip->branchcand, scip->eventqueue, scip->cliquetable, newbound) );
4991  SCIP_CALL( SCIPvarChgUbLocal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
4992  scip->branchcand, scip->eventqueue, newbound) );
4993  SCIP_CALL( SCIPvarChgUbOriginal(var, scip->set, newbound) );
4994  break;
4995 
4997  SCIP_CALL( SCIPvarChgUbGlobal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
4998  scip->branchcand, scip->eventqueue, scip->cliquetable, newbound) );
4999  break;
5000 
5001  case SCIP_STAGE_PRESOLVING:
5002  if( !SCIPinProbing(scip) )
5003  {
5004  assert(SCIPtreeGetCurrentDepth(scip->tree) == 0);
5005  assert(scip->tree->root == SCIPtreeGetCurrentNode(scip->tree));
5006 
5007  SCIP_CALL( SCIPnodeAddBoundchg(scip->tree->root, scip->mem->probmem, scip->set, scip->stat, scip->transprob,
5008  scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable, var, newbound,
5010 
5012  {
5013  SCIP_Bool infeasible;
5014 
5015  SCIP_CALL( SCIPchgVarType(scip, var, SCIP_VARTYPE_BINARY, &infeasible) );
5016  assert(!infeasible);
5017  }
5018  break;
5019  }
5020  /*lint -fallthrough*/
5021  case SCIP_STAGE_SOLVING:
5022  SCIP_CALL( SCIPnodeAddBoundchg(scip->tree->root, scip->mem->probmem, scip->set, scip->stat, scip->transprob,
5023  scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable, var, newbound,
5025  break;
5026 
5027  default:
5028  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
5029  return SCIP_INVALIDCALL;
5030  } /*lint !e788*/
5031 
5032  return SCIP_OKAY;
5033 }
5034 
5035 /** changes lazy lower bound of the variable, this is only possible if the variable is not in the LP yet
5036  *
5037  * lazy bounds are bounds, that are enforced by constraints and the objective function; hence, these bounds do not need
5038  * to be put into the LP explicitly.
5039  *
5040  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5041  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5042  *
5043  * @pre This method can be called if @p scip is in one of the following stages:
5044  * - \ref SCIP_STAGE_PROBLEM
5045  * - \ref SCIP_STAGE_TRANSFORMING
5046  * - \ref SCIP_STAGE_TRANSFORMED
5047  * - \ref SCIP_STAGE_PRESOLVING
5048  * - \ref SCIP_STAGE_SOLVING
5049  *
5050  * @note lazy bounds are useful for branch-and-price since the corresponding variable bounds are not part of the LP
5051  */
5053  SCIP* scip, /**< SCIP data structure */
5054  SCIP_VAR* var, /**< problem variable */
5055  SCIP_Real lazylb /**< the lazy lower bound to be set */
5056  )
5057 {
5058  assert(scip != NULL);
5059  assert(var != NULL);
5060 
5061  SCIP_CALL( SCIPcheckStage(scip, "SCIPchgVarLbLazy", FALSE, TRUE, TRUE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
5062 
5063  SCIP_CALL( SCIPvarChgLbLazy(var, scip->set, lazylb) );
5064 
5065  return SCIP_OKAY;
5066 }
5067 
5068 /** changes lazy upper bound of the variable, this is only possible if the variable is not in the LP yet
5069  *
5070  * lazy bounds are bounds, that are enforced by constraints and the objective function; hence, these bounds do not need
5071  * to be put into the LP explicitly.
5072  *
5073  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5074  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5075  *
5076  * @pre This method can be called if @p scip is in one of the following stages:
5077  * - \ref SCIP_STAGE_PROBLEM
5078  * - \ref SCIP_STAGE_TRANSFORMING
5079  * - \ref SCIP_STAGE_TRANSFORMED
5080  * - \ref SCIP_STAGE_PRESOLVING
5081  * - \ref SCIP_STAGE_SOLVING
5082  *
5083  * @note lazy bounds are useful for branch-and-price since the corresponding variable bounds are not part of the LP
5084  */
5086  SCIP* scip, /**< SCIP data structure */
5087  SCIP_VAR* var, /**< problem variable */
5088  SCIP_Real lazyub /**< the lazy lower bound to be set */
5089  )
5090 {
5091  assert(scip != NULL);
5092  assert(var != NULL);
5093 
5094  SCIP_CALL( SCIPcheckStage(scip, "SCIPchgVarUbLazy", FALSE, TRUE, TRUE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
5095 
5096  SCIP_CALL( SCIPvarChgUbLazy(var, scip->set, lazyub) );
5097 
5098  return SCIP_OKAY;
5099 }
5100 
5101 /** changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter
5102  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
5103  * doesn't store any inference information in the bound change, such that in conflict analysis, this change
5104  * is treated like a branching decision
5105  *
5106  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
5107  * SCIPgetVars()) gets resorted.
5108  *
5109  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5110  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5111  *
5112  * @pre This method can be called if @p scip is in one of the following stages:
5113  * - \ref SCIP_STAGE_PROBLEM
5114  * - \ref SCIP_STAGE_PRESOLVING
5115  * - \ref SCIP_STAGE_SOLVING
5116  *
5117  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
5118  */
5120  SCIP* scip, /**< SCIP data structure */
5121  SCIP_VAR* var, /**< variable to change the bound for */
5122  SCIP_Real newbound, /**< new value for bound */
5123  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
5124  SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */
5125  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
5126  )
5127 {
5128  SCIP_Real lb;
5129  SCIP_Real ub;
5130 
5131  assert(infeasible != NULL);
5132  /** @todo if needed provide pending local/global bound changes that will be flushed after leaving diving mode (as in struct_tree.h) */
5133  assert(!SCIPinDive(scip));
5134 
5135  SCIP_CALL( SCIPcheckStage(scip, "SCIPtightenVarLb", FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
5136 
5137  *infeasible = FALSE;
5138  if( tightened != NULL )
5139  *tightened = FALSE;
5140 
5141  SCIPvarAdjustLb(var, scip->set, &newbound);
5142 
5143  /* ignore tightenings of lower bounds to +infinity during solving process */
5144  if( SCIPisInfinity(scip, newbound) && SCIPgetStage(scip) == SCIP_STAGE_SOLVING )
5145  {
5146 #ifndef NDEBUG
5147  SCIPwarningMessage(scip, "ignore lower bound tightening for %s from %e to +infinity\n", SCIPvarGetName(var),
5148  SCIPvarGetLbLocal(var));
5149 #endif
5150  return SCIP_OKAY;
5151  }
5152 
5153  /* get current bounds */
5154  lb = SCIPcomputeVarLbLocal(scip, var);
5155  ub = SCIPcomputeVarUbLocal(scip, var);
5156  assert(SCIPsetIsLE(scip->set, lb, ub));
5157 
5158  if( SCIPsetIsFeasGT(scip->set, newbound, ub) )
5159  {
5160  *infeasible = TRUE;
5161  return SCIP_OKAY;
5162  }
5163  newbound = MIN(newbound, ub);
5164 
5165  if( (force && SCIPsetIsLE(scip->set, newbound, lb)) || (!force && !SCIPsetIsLbBetter(scip->set, newbound, lb, ub)) )
5166  return SCIP_OKAY;
5167 
5168  switch( scip->set->stage )
5169  {
5170  case SCIP_STAGE_PROBLEM:
5171  assert(!SCIPvarIsTransformed(var));
5172  SCIP_CALL( SCIPvarChgLbGlobal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
5173  scip->branchcand, scip->eventqueue, scip->cliquetable, newbound) );
5174  SCIP_CALL( SCIPvarChgLbLocal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
5175  scip->branchcand, scip->eventqueue, newbound) );
5176  SCIP_CALL( SCIPvarChgLbOriginal(var, scip->set, newbound) );
5177  break;
5179  SCIP_CALL( SCIPvarChgLbGlobal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
5180  scip->branchcand, scip->eventqueue, scip->cliquetable, newbound) );
5181  break;
5182  case SCIP_STAGE_PRESOLVING:
5183  if( !SCIPinProbing(scip) )
5184  {
5185  assert(SCIPtreeGetCurrentDepth(scip->tree) == 0);
5186  assert(scip->tree->root == SCIPtreeGetCurrentNode(scip->tree));
5187 
5188  SCIP_CALL( SCIPnodeAddBoundchg(scip->tree->root, scip->mem->probmem, scip->set, scip->stat, scip->transprob,
5189  scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable, var, newbound,
5191 
5193  {
5194  SCIP_CALL( SCIPchgVarType(scip, var, SCIP_VARTYPE_BINARY, infeasible) );
5195  assert(!(*infeasible));
5196  }
5197  break;
5198  }
5199  /*lint -fallthrough*/
5200  case SCIP_STAGE_SOLVING:
5202  scip->transprob, scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable,
5203  var, newbound, SCIP_BOUNDTYPE_LOWER, FALSE) );
5204  break;
5205 
5206  default:
5207  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
5208  return SCIP_INVALIDCALL;
5209  } /*lint !e788*/
5210 
5211  if( tightened != NULL )
5212  *tightened = TRUE;
5213 
5214  return SCIP_OKAY;
5215 }
5216 
5217 /** changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter
5218  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
5219  * doesn't store any inference information in the bound change, such that in conflict analysis, this change
5220  * is treated like a branching decision
5221  *
5222  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
5223  * SCIPgetVars()) gets resorted.
5224  *
5225  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5226  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5227  *
5228  * @pre This method can be called if @p scip is in one of the following stages:
5229  * - \ref SCIP_STAGE_PROBLEM
5230  * - \ref SCIP_STAGE_PRESOLVING
5231  * - \ref SCIP_STAGE_SOLVING
5232  *
5233  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
5234  */
5236  SCIP* scip, /**< SCIP data structure */
5237  SCIP_VAR* var, /**< variable to change the bound for */
5238  SCIP_Real newbound, /**< new value for bound */
5239  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
5240  SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */
5241  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
5242  )
5243 {
5244  SCIP_Real lb;
5245  SCIP_Real ub;
5246 
5247  assert(infeasible != NULL);
5248  /** @todo if needed provide pending local/global bound changes that will be flushed after leaving diving mode (as in struct_tree.h) */
5249  assert(!SCIPinDive(scip));
5250 
5251  SCIP_CALL( SCIPcheckStage(scip, "SCIPtightenVarUb", FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
5252 
5253  *infeasible = FALSE;
5254  if( tightened != NULL )
5255  *tightened = FALSE;
5256 
5257  SCIPvarAdjustUb(var, scip->set, &newbound);
5258 
5259  /* ignore tightenings of upper bounds to -infinity during solving process */
5260  if( SCIPisInfinity(scip, -newbound) && SCIPgetStage(scip) == SCIP_STAGE_SOLVING )
5261  {
5262 #ifndef NDEBUG
5263  SCIPwarningMessage(scip, "ignore upper bound tightening for %s from %e to -infinity\n", SCIPvarGetName(var),
5264  SCIPvarGetUbLocal(var));
5265 #endif
5266  return SCIP_OKAY;
5267  }
5268 
5269  /* get current bounds */
5270  lb = SCIPcomputeVarLbLocal(scip, var);
5271  ub = SCIPcomputeVarUbLocal(scip, var);
5272  assert(SCIPsetIsLE(scip->set, lb, ub));
5273 
5274  if( SCIPsetIsFeasLT(scip->set, newbound, lb) )
5275  {
5276  *infeasible = TRUE;
5277  return SCIP_OKAY;
5278  }
5279  newbound = MAX(newbound, lb);
5280 
5281  if( (force && SCIPsetIsGE(scip->set, newbound, ub)) || (!force && !SCIPsetIsUbBetter(scip->set, newbound, lb, ub)) )
5282  return SCIP_OKAY;
5283 
5284  switch( scip->set->stage )
5285  {
5286  case SCIP_STAGE_PROBLEM:
5287  assert(!SCIPvarIsTransformed(var));
5288  SCIP_CALL( SCIPvarChgUbGlobal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
5289  scip->branchcand, scip->eventqueue, scip->cliquetable, newbound) );
5290  SCIP_CALL( SCIPvarChgUbLocal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
5291  scip->branchcand, scip->eventqueue, newbound) );
5292  SCIP_CALL( SCIPvarChgUbOriginal(var, scip->set, newbound) );
5293  break;
5295  SCIP_CALL( SCIPvarChgUbGlobal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
5296  scip->branchcand, scip->eventqueue, scip->cliquetable, newbound) );
5297  break;
5298  case SCIP_STAGE_PRESOLVING:
5299  if( !SCIPinProbing(scip) )
5300  {
5301  assert(SCIPtreeGetCurrentDepth(scip->tree) == 0);
5302  assert(scip->tree->root == SCIPtreeGetCurrentNode(scip->tree));
5303 
5304  SCIP_CALL( SCIPnodeAddBoundchg(scip->tree->root, scip->mem->probmem, scip->set, scip->stat, scip->transprob,
5305  scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable, var, newbound,
5307 
5309  {
5310  SCIP_CALL( SCIPchgVarType(scip, var, SCIP_VARTYPE_BINARY, infeasible) );
5311  assert(!(*infeasible));
5312  }
5313  break;
5314  }
5315  /*lint -fallthrough*/
5316  case SCIP_STAGE_SOLVING:
5318  scip->transprob, scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue,
5319  scip->cliquetable, var, newbound, SCIP_BOUNDTYPE_UPPER, FALSE) );
5320  break;
5321 
5322  default:
5323  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
5324  return SCIP_INVALIDCALL;
5325  } /*lint !e788*/
5326 
5327  if( tightened != NULL )
5328  *tightened = TRUE;
5329 
5330  return SCIP_OKAY;
5331 }
5332 
5333 /** fixes variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening
5334  * epsilon) than the current bound; if possible, adjusts bound to integral value; the given inference constraint is
5335  * stored, such that the conflict analysis is able to find out the reason for the deduction of the bound change
5336  *
5337  * @note In presolving stage when not in probing mode the variable will be fixed directly, otherwise this method
5338  * changes first the lowerbound by calling SCIPinferVarLbCons and second the upperbound by calling
5339  * SCIPinferVarUbCons
5340  *
5341  * @note If SCIP is in presolving stage, it can happen that the internal variable array (which get be accessed via
5342  * SCIPgetVars()) gets resorted.
5343  *
5344  * @note During presolving, an integer variable which bound changes to {0,1} is upgraded to a binary variable.
5345  */
5347  SCIP* scip, /**< SCIP data structure */
5348  SCIP_VAR* var, /**< variable to change the bound for */
5349  SCIP_Real fixedval, /**< new value for fixation */
5350  SCIP_CONS* infercons, /**< constraint that deduced the bound change */
5351  int inferinfo, /**< user information for inference to help resolving the conflict */
5352  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
5353  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
5354  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
5355  )
5356 {
5357  assert(scip != NULL);
5358  assert(var != NULL);
5359  assert(infeasible != NULL);
5360 
5361  SCIP_CALL( SCIPcheckStage(scip, "SCIPinferVarFixCons", FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
5362 
5363  if( tightened != NULL )
5364  *tightened = FALSE;
5365 
5366  /* in presolving case we take the shortcut to directly fix the variables */
5367  if( SCIPgetStage(scip) == SCIP_STAGE_PRESOLVING && SCIPtreeGetCurrentDepth(scip->tree) == 0 )
5368  {
5369  SCIP_Bool fixed;
5370 
5371  SCIP_CALL( SCIPvarFix(var, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob,
5372  scip->primal, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable,
5373  fixedval, infeasible, &fixed) );
5374 
5375  if( tightened != NULL )
5376  *tightened = fixed;
5377  }
5378  /* otherwise we use the lb and ub methods */
5379  else
5380  {
5381  SCIP_Bool lbtightened;
5382 
5383  SCIP_CALL( SCIPinferVarLbCons(scip, var, fixedval, infercons, inferinfo, force, infeasible, &lbtightened) );
5384 
5385  if( ! (*infeasible) )
5386  {
5387  SCIP_CALL( SCIPinferVarUbCons(scip, var, fixedval, infercons, inferinfo, force, infeasible, tightened) );
5388 
5389  if( tightened != NULL )
5390  *tightened |= lbtightened;
5391  }
5392  }
5393 
5394  return SCIP_OKAY;
5395 }
5396 
5397 /** changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter
5398  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
5399  * the given inference constraint is stored, such that the conflict analysis is able to find out the reason
5400  * for the deduction of the bound change
5401  *
5402  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
5403  * SCIPgetVars()) gets resorted.
5404  *
5405  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5406  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5407  *
5408  * @pre This method can be called if @p scip is in one of the following stages:
5409  * - \ref SCIP_STAGE_PROBLEM
5410  * - \ref SCIP_STAGE_PRESOLVING
5411  * - \ref SCIP_STAGE_SOLVING
5412  *
5413  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
5414  */
5416  SCIP* scip, /**< SCIP data structure */
5417  SCIP_VAR* var, /**< variable to change the bound for */
5418  SCIP_Real newbound, /**< new value for bound */
5419  SCIP_CONS* infercons, /**< constraint that deduced the bound change */
5420  int inferinfo, /**< user information for inference to help resolving the conflict */
5421  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
5422  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
5423  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
5424  )
5425 {
5426  SCIP_Real lb;
5427  SCIP_Real ub;
5428 
5429  assert(infeasible != NULL);
5430 
5431  SCIP_CALL( SCIPcheckStage(scip, "SCIPinferVarLbCons", FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
5432 
5433  *infeasible = FALSE;
5434  if( tightened != NULL )
5435  *tightened = FALSE;
5436 
5437  SCIPvarAdjustLb(var, scip->set, &newbound);
5438 
5439  /* ignore tightenings of lower bounds to +infinity during solving process */
5440  if( SCIPisInfinity(scip, newbound) && SCIPgetStage(scip) == SCIP_STAGE_SOLVING )
5441  {
5442 #ifndef NDEBUG
5443  SCIPwarningMessage(scip, "ignore lower bound tightening for %s from %e to +infinity\n", SCIPvarGetName(var),
5444  SCIPvarGetLbLocal(var));
5445 #endif
5446  return SCIP_OKAY;
5447  }
5448 
5449  /* get current bounds */
5450  lb = SCIPvarGetLbLocal(var);
5451  ub = SCIPvarGetUbLocal(var);
5452  assert(SCIPsetIsLE(scip->set, lb, ub));
5453 
5454  if( SCIPsetIsFeasGT(scip->set, newbound, ub) )
5455  {
5456  *infeasible = TRUE;
5457  return SCIP_OKAY;
5458  }
5459  newbound = MIN(newbound, ub);
5460 
5461  if( (force && SCIPsetIsLE(scip->set, newbound, lb)) || (!force && !SCIPsetIsLbBetter(scip->set, newbound, lb, ub)) )
5462  return SCIP_OKAY;
5463 
5464  switch( scip->set->stage )
5465  {
5466  case SCIP_STAGE_PROBLEM:
5467  assert(!SCIPvarIsTransformed(var));
5468  SCIP_CALL( SCIPvarChgLbGlobal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
5469  scip->branchcand, scip->eventqueue, scip->cliquetable, newbound) );
5470  SCIP_CALL( SCIPvarChgLbLocal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
5471  scip->branchcand, scip->eventqueue, newbound) );
5472  SCIP_CALL( SCIPvarChgLbOriginal(var, scip->set, newbound) );
5473  break;
5474 
5475  case SCIP_STAGE_PRESOLVING:
5476  if( !SCIPinProbing(scip) )
5477  {
5478  assert(SCIPtreeGetCurrentDepth(scip->tree) == 0);
5479  assert(scip->tree->root == SCIPtreeGetCurrentNode(scip->tree));
5480 
5481  SCIP_CALL( SCIPnodeAddBoundchg(scip->tree->root, scip->mem->probmem, scip->set, scip->stat, scip->transprob,
5482  scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable, var, newbound,
5484 
5486  {
5487  SCIP_CALL( SCIPchgVarType(scip, var, SCIP_VARTYPE_BINARY, infeasible) );
5488  assert(!(*infeasible));
5489  }
5490  break;
5491  }
5492  /*lint -fallthrough*/
5493  case SCIP_STAGE_SOLVING:
5495  scip->transprob, scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue,
5496  scip->cliquetable, var, newbound, SCIP_BOUNDTYPE_LOWER, infercons, NULL, inferinfo, FALSE) );
5497  break;
5498 
5499  default:
5500  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
5501  return SCIP_INVALIDCALL;
5502  } /*lint !e788*/
5503 
5504  if( tightened != NULL )
5505  *tightened = TRUE;
5506 
5507  return SCIP_OKAY;
5508 }
5509 
5510 /** changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter
5511  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
5512  * the given inference constraint is stored, such that the conflict analysis is able to find out the reason
5513  * for the deduction of the bound change
5514  *
5515  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
5516  * SCIPgetVars()) gets resorted.
5517  *
5518  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5519  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5520  *
5521  * @pre This method can be called if @p scip is in one of the following stages:
5522  * - \ref SCIP_STAGE_PROBLEM
5523  * - \ref SCIP_STAGE_PRESOLVING
5524  * - \ref SCIP_STAGE_SOLVING
5525  *
5526  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
5527  */
5529  SCIP* scip, /**< SCIP data structure */
5530  SCIP_VAR* var, /**< variable to change the bound for */
5531  SCIP_Real newbound, /**< new value for bound */
5532  SCIP_CONS* infercons, /**< constraint that deduced the bound change */
5533  int inferinfo, /**< user information for inference to help resolving the conflict */
5534  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
5535  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
5536  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
5537  )
5538 {
5539  SCIP_Real lb;
5540  SCIP_Real ub;
5541 
5542  assert(infeasible != NULL);
5543 
5544  SCIP_CALL( SCIPcheckStage(scip, "SCIPinferVarUbCons", FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
5545 
5546  *infeasible = FALSE;
5547  if( tightened != NULL )
5548  *tightened = FALSE;
5549 
5550  SCIPvarAdjustUb(var, scip->set, &newbound);
5551 
5552  /* ignore tightenings of upper bounds to -infinity during solving process */
5553  if( SCIPisInfinity(scip, -newbound) && SCIPgetStage(scip) == SCIP_STAGE_SOLVING )
5554  {
5555 #ifndef NDEBUG
5556  SCIPwarningMessage(scip, "ignore upper bound tightening for %s from %e to -infinity\n", SCIPvarGetName(var),
5557  SCIPvarGetUbLocal(var));
5558 #endif
5559  return SCIP_OKAY;
5560  }
5561 
5562  /* get current bounds */
5563  lb = SCIPvarGetLbLocal(var);
5564  ub = SCIPvarGetUbLocal(var);
5565  assert(SCIPsetIsLE(scip->set, lb, ub));
5566 
5567  if( SCIPsetIsFeasLT(scip->set, newbound, lb) )
5568  {
5569  *infeasible = TRUE;
5570  return SCIP_OKAY;
5571  }
5572  newbound = MAX(newbound, lb);
5573 
5574  if( (force && SCIPsetIsGE(scip->set, newbound, ub)) || (!force && !SCIPsetIsUbBetter(scip->set, newbound, lb, ub)) )
5575  return SCIP_OKAY;
5576 
5577  switch( scip->set->stage )
5578  {
5579  case SCIP_STAGE_PROBLEM:
5580  assert(!SCIPvarIsTransformed(var));
5581  SCIP_CALL( SCIPvarChgUbGlobal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
5582  scip->branchcand, scip->eventqueue, scip->cliquetable, newbound) );
5583  SCIP_CALL( SCIPvarChgUbLocal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
5584  scip->branchcand, scip->eventqueue, newbound) );
5585  SCIP_CALL( SCIPvarChgUbOriginal(var, scip->set, newbound) );
5586  break;
5587 
5588  case SCIP_STAGE_PRESOLVING:
5589  if( !SCIPinProbing(scip) )
5590  {
5591  assert(SCIPtreeGetCurrentDepth(scip->tree) == 0);
5592  assert(scip->tree->root == SCIPtreeGetCurrentNode(scip->tree));
5593 
5594  SCIP_CALL( SCIPnodeAddBoundchg(scip->tree->root, scip->mem->probmem, scip->set, scip->stat, scip->transprob,
5595  scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable, var, newbound,
5597 
5599  {
5600  SCIP_CALL( SCIPchgVarType(scip, var, SCIP_VARTYPE_BINARY, infeasible) );
5601  assert(!(*infeasible));
5602  }
5603  break;
5604  }
5605  /*lint -fallthrough*/
5606  case SCIP_STAGE_SOLVING:
5608  scip->transprob, scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue,
5609  scip->cliquetable, var, newbound, SCIP_BOUNDTYPE_UPPER, infercons, NULL, inferinfo, FALSE) );
5610  break;
5611 
5612  default:
5613  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
5614  return SCIP_INVALIDCALL;
5615  } /*lint !e788*/
5616 
5617  if( tightened != NULL )
5618  *tightened = TRUE;
5619 
5620  return SCIP_OKAY;
5621 }
5622 
5623 /** depending on SCIP's stage, fixes binary variable in the problem, in preprocessing, or in current node;
5624  * the given inference constraint is stored, such that the conflict analysis is able to find out the reason for the
5625  * deduction of the fixing
5626  *
5627  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5628  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5629  *
5630  * @pre This method can be called if @p scip is in one of the following stages:
5631  * - \ref SCIP_STAGE_PROBLEM
5632  * - \ref SCIP_STAGE_PRESOLVING
5633  * - \ref SCIP_STAGE_SOLVING
5634  */
5636  SCIP* scip, /**< SCIP data structure */
5637  SCIP_VAR* var, /**< binary variable to fix */
5638  SCIP_Bool fixedval, /**< value to fix binary variable to */
5639  SCIP_CONS* infercons, /**< constraint that deduced the fixing */
5640  int inferinfo, /**< user information for inference to help resolving the conflict */
5641  SCIP_Bool* infeasible, /**< pointer to store whether the fixing is infeasible */
5642  SCIP_Bool* tightened /**< pointer to store whether the fixing tightened the local bounds, or NULL */
5643  )
5644 {
5645  SCIP_Real lb;
5646  SCIP_Real ub;
5647 
5648  assert(SCIPvarIsBinary(var));
5649  assert(fixedval == TRUE || fixedval == FALSE);
5650  assert(infeasible != NULL);
5651 
5652  SCIP_CALL( SCIPcheckStage(scip, "SCIPinferBinvarCons", FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
5653 
5654  *infeasible = FALSE;
5655  if( tightened != NULL )
5656  *tightened = FALSE;
5657 
5658  /* get current bounds */
5659  lb = SCIPvarGetLbLocal(var);
5660  ub = SCIPvarGetUbLocal(var);
5661  assert(SCIPsetIsEQ(scip->set, lb, 0.0) || SCIPsetIsEQ(scip->set, lb, 1.0));
5662  assert(SCIPsetIsEQ(scip->set, ub, 0.0) || SCIPsetIsEQ(scip->set, ub, 1.0));
5663  assert(SCIPsetIsLE(scip->set, lb, ub));
5664 
5665  /* check, if variable is already fixed */
5666  if( (lb > 0.5) || (ub < 0.5) )
5667  {
5668  *infeasible = (fixedval == (lb < 0.5));
5669 
5670  return SCIP_OKAY;
5671  }
5672 
5673  /* apply the fixing */
5674  switch( scip->set->stage )
5675  {
5676  case SCIP_STAGE_PROBLEM:
5677  assert(!SCIPvarIsTransformed(var));
5678  if( fixedval == TRUE )
5679  {
5680  SCIP_CALL( SCIPchgVarLb(scip, var, 1.0) );
5681  }
5682  else
5683  {
5684  SCIP_CALL( SCIPchgVarUb(scip, var, 0.0) );
5685  }
5686  break;
5687 
5688  case SCIP_STAGE_PRESOLVING:
5689  if( SCIPtreeGetCurrentDepth(scip->tree) == 0 )
5690  {
5691  SCIP_Bool fixed;
5692 
5693  SCIP_CALL( SCIPvarFix(var, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob,
5694  scip->primal, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable,
5695  (SCIP_Real)fixedval, infeasible, &fixed) );
5696  break;
5697  }
5698  /*lint -fallthrough*/
5699  case SCIP_STAGE_SOLVING:
5700  if( fixedval == TRUE )
5701  {
5703  scip->transprob, scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue,
5704  scip->cliquetable, var, 1.0, SCIP_BOUNDTYPE_LOWER, infercons, NULL, inferinfo, FALSE) );
5705  }
5706  else
5707  {
5709  scip->transprob, scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue,
5710  scip->cliquetable, var, 0.0, SCIP_BOUNDTYPE_UPPER, infercons, NULL, inferinfo, FALSE) );
5711  }
5712  break;
5713 
5714  default:
5715  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
5716  return SCIP_INVALIDCALL;
5717  } /*lint !e788*/
5718 
5719  if( tightened != NULL )
5720  *tightened = TRUE;
5721 
5722  return SCIP_OKAY;
5723 }
5724 
5725 /** fixes variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening
5726  * epsilon) than the current bound; if possible, adjusts bound to integral value; the given inference constraint is
5727  * stored, such that the conflict analysis is able to find out the reason for the deduction of the bound change
5728  *
5729  * @note In presolving stage when not in probing mode the variable will be fixed directly, otherwise this method
5730  * changes first the lowerbound by calling SCIPinferVarLbProp and second the upperbound by calling
5731  * SCIPinferVarUbProp
5732  *
5733  * @note If SCIP is in presolving stage, it can happen that the internal variable array (which get be accessed via
5734  * SCIPgetVars()) gets resorted.
5735  *
5736  * @note During presolving, an integer variable which bound changes to {0,1} is upgraded to a binary variable.
5737  */
5739  SCIP* scip, /**< SCIP data structure */
5740  SCIP_VAR* var, /**< variable to change the bound for */
5741  SCIP_Real fixedval, /**< new value for fixation */
5742  SCIP_PROP* inferprop, /**< propagator that deduced the bound change */
5743  int inferinfo, /**< user information for inference to help resolving the conflict */
5744  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
5745  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
5746  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
5747  )
5748 {
5749  assert(scip != NULL);
5750  assert(var != NULL);
5751  assert(infeasible != NULL);
5752 
5753  SCIP_CALL( SCIPcheckStage(scip, "SCIPinferVarFixProp", FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
5754 
5755  if( tightened != NULL )
5756  *tightened = FALSE;
5757 
5758  /* in presolving case we take the shortcut to directly fix the variables */
5759  if( SCIPgetStage(scip) == SCIP_STAGE_PRESOLVING && SCIPtreeGetCurrentDepth(scip->tree) == 0 )
5760  {
5761  SCIP_Bool fixed;
5762 
5763  SCIP_CALL( SCIPvarFix(var, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob,
5764  scip->primal, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable,
5765  fixedval, infeasible, &fixed) );
5766 
5767  if( tightened != NULL )
5768  *tightened = fixed;
5769  }
5770  /* otherwise we use the lb and ub methods */
5771  else
5772  {
5773  SCIP_Bool lbtightened;
5774 
5775  SCIP_CALL( SCIPinferVarLbProp(scip, var, fixedval, inferprop, inferinfo, force, infeasible, &lbtightened) );
5776 
5777  if( ! (*infeasible) )
5778  {
5779  SCIP_CALL( SCIPinferVarUbProp(scip, var, fixedval, inferprop, inferinfo, force, infeasible, tightened) );
5780 
5781  if( tightened != NULL )
5782  *tightened |= lbtightened;
5783  }
5784  }
5785 
5786  return SCIP_OKAY;
5787 }
5788 
5789 /** changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter
5790  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
5791  * the given inference propagator is stored, such that the conflict analysis is able to find out the reason
5792  * for the deduction of the bound change
5793  *
5794  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
5795  * SCIPgetVars()) gets resorted.
5796  *
5797  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5798  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5799  *
5800  * @pre This method can be called if @p scip is in one of the following stages:
5801  * - \ref SCIP_STAGE_PROBLEM
5802  * - \ref SCIP_STAGE_PRESOLVING
5803  * - \ref SCIP_STAGE_SOLVING
5804  *
5805  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
5806  */
5808  SCIP* scip, /**< SCIP data structure */
5809  SCIP_VAR* var, /**< variable to change the bound for */
5810  SCIP_Real newbound, /**< new value for bound */
5811  SCIP_PROP* inferprop, /**< propagator that deduced the bound change */
5812  int inferinfo, /**< user information for inference to help resolving the conflict */
5813  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
5814  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
5815  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
5816  )
5817 {
5818  SCIP_Real lb;
5819  SCIP_Real ub;
5820 
5821  assert(infeasible != NULL);
5822 
5823  SCIP_CALL( SCIPcheckStage(scip, "SCIPinferVarLbProp", FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
5824 
5825  *infeasible = FALSE;
5826  if( tightened != NULL )
5827  *tightened = FALSE;
5828 
5829  SCIPvarAdjustLb(var, scip->set, &newbound);
5830 
5831  /* ignore tightenings of lower bounds to +infinity during solving process */
5832  if( SCIPisInfinity(scip, newbound) && SCIPgetStage(scip) == SCIP_STAGE_SOLVING )
5833  {
5834 #ifndef NDEBUG
5835  SCIPwarningMessage(scip, "ignore lower bound tightening for %s from %e to +infinity\n", SCIPvarGetName(var),
5836  SCIPvarGetLbLocal(var));
5837 #endif
5838  return SCIP_OKAY;
5839  }
5840 
5841  /* get current bounds */
5842  lb = SCIPvarGetLbLocal(var);
5843  ub = SCIPvarGetUbLocal(var);
5844  assert(SCIPsetIsLE(scip->set, lb, ub));
5845 
5846  if( SCIPsetIsFeasGT(scip->set, newbound, ub) )
5847  {
5848  *infeasible = TRUE;
5849  return SCIP_OKAY;
5850  }
5851  newbound = MIN(newbound, ub);
5852 
5853  if( (!force && !SCIPsetIsLbBetter(scip->set, newbound, lb, ub))
5854  || SCIPsetIsLE(scip->set, newbound, lb) )
5855  return SCIP_OKAY;
5856 
5857  switch( scip->set->stage )
5858  {
5859  case SCIP_STAGE_PROBLEM:
5860  assert(!SCIPvarIsTransformed(var));
5861  SCIP_CALL( SCIPvarChgLbGlobal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
5862  scip->branchcand, scip->eventqueue, scip->cliquetable, newbound) );
5863  SCIP_CALL( SCIPvarChgLbLocal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
5864  scip->branchcand, scip->eventqueue, newbound) );
5865  SCIP_CALL( SCIPvarChgLbOriginal(var, scip->set, newbound) );
5866  break;
5867 
5868  case SCIP_STAGE_PRESOLVING:
5869  if( !SCIPinProbing(scip) )
5870  {
5871  assert(SCIPtreeGetCurrentDepth(scip->tree) == 0);
5872  assert(scip->tree->root == SCIPtreeGetCurrentNode(scip->tree));
5873 
5874  SCIP_CALL( SCIPnodeAddBoundchg(scip->tree->root, scip->mem->probmem, scip->set, scip->stat, scip->transprob,
5875  scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable, var, newbound,
5877 
5879  {
5880  SCIP_CALL( SCIPchgVarType(scip, var, SCIP_VARTYPE_BINARY, infeasible) );
5881  assert(!(*infeasible));
5882  }
5883  break;
5884  }
5885  /*lint -fallthrough*/
5886  case SCIP_STAGE_SOLVING:
5888  scip->transprob, scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue,
5889  scip->cliquetable, var, newbound, SCIP_BOUNDTYPE_LOWER, NULL, inferprop, inferinfo, FALSE) );
5890  break;
5891 
5892  default:
5893  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
5894  return SCIP_INVALIDCALL;
5895  } /*lint !e788*/
5896 
5897  if( tightened != NULL )
5898  *tightened = TRUE;
5899 
5900  return SCIP_OKAY;
5901 }
5902 
5903 /** changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter
5904  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
5905  * the given inference propagator is stored, such that the conflict analysis is able to find out the reason
5906  * for the deduction of the bound change
5907  *
5908  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
5909  * SCIPgetVars()) gets resorted.
5910  *
5911  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5912  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5913  *
5914  * @pre This method can be called if @p scip is in one of the following stages:
5915  * - \ref SCIP_STAGE_PROBLEM
5916  * - \ref SCIP_STAGE_PRESOLVING
5917  * - \ref SCIP_STAGE_SOLVING
5918  *
5919  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
5920  */
5922  SCIP* scip, /**< SCIP data structure */
5923  SCIP_VAR* var, /**< variable to change the bound for */
5924  SCIP_Real newbound, /**< new value for bound */
5925  SCIP_PROP* inferprop, /**< propagator that deduced the bound change */
5926  int inferinfo, /**< user information for inference to help resolving the conflict */
5927  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
5928  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
5929  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
5930  )
5931 {
5932  SCIP_Real lb;
5933  SCIP_Real ub;
5934 
5935  assert(infeasible != NULL);
5936 
5937  SCIP_CALL( SCIPcheckStage(scip, "SCIPinferVarUbProp", FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
5938 
5939  *infeasible = FALSE;
5940  if( tightened != NULL )
5941  *tightened = FALSE;
5942 
5943  SCIPvarAdjustUb(var, scip->set, &newbound);
5944 
5945  /* ignore tightenings of upper bounds to -infinity during solving process */
5946  if( SCIPisInfinity(scip, -newbound) && SCIPgetStage(scip) == SCIP_STAGE_SOLVING )
5947  {
5948 #ifndef NDEBUG
5949  SCIPwarningMessage(scip, "ignore upper bound tightening for %s from %e to -infinity\n", SCIPvarGetName(var),
5950  SCIPvarGetUbLocal(var));
5951 #endif
5952  return SCIP_OKAY;
5953  }
5954 
5955  /* get current bounds */
5956  lb = SCIPvarGetLbLocal(var);
5957  ub = SCIPvarGetUbLocal(var);
5958  assert(SCIPsetIsLE(scip->set, lb, ub));
5959 
5960  if( SCIPsetIsFeasLT(scip->set, newbound, lb) )
5961  {
5962  *infeasible = TRUE;
5963  return SCIP_OKAY;
5964  }
5965  newbound = MAX(newbound, lb);
5966 
5967  if( (!force && !SCIPsetIsUbBetter(scip->set, newbound, lb, ub))
5968  || SCIPsetIsGE(scip->set, newbound, ub) )
5969  return SCIP_OKAY;
5970 
5971  switch( scip->set->stage )
5972  {
5973  case SCIP_STAGE_PROBLEM:
5974  assert(!SCIPvarIsTransformed(var));
5975  SCIP_CALL( SCIPvarChgUbGlobal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
5976  scip->branchcand, scip->eventqueue, scip->cliquetable, newbound) );
5977  SCIP_CALL( SCIPvarChgUbLocal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
5978  scip->branchcand, scip->eventqueue, newbound) );
5979  SCIP_CALL( SCIPvarChgUbOriginal(var, scip->set, newbound) );
5980  break;
5981 
5982  case SCIP_STAGE_PRESOLVING:
5983  if( !SCIPinProbing(scip) )
5984  {
5985  assert(SCIPtreeGetCurrentDepth(scip->tree) == 0);
5986  assert(scip->tree->root == SCIPtreeGetCurrentNode(scip->tree));
5987 
5988  SCIP_CALL( SCIPnodeAddBoundchg(scip->tree->root, scip->mem->probmem, scip->set, scip->stat, scip->transprob,
5989  scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable, var, newbound,
5991 
5993  {
5994  SCIP_CALL( SCIPchgVarType(scip, var, SCIP_VARTYPE_BINARY, infeasible) );
5995  assert(!(*infeasible));
5996  }
5997  break;
5998  }
5999  /*lint -fallthrough*/
6000  case SCIP_STAGE_SOLVING:
6002  scip->transprob, scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue,
6003  scip->cliquetable, var, newbound, SCIP_BOUNDTYPE_UPPER, NULL, inferprop, inferinfo, FALSE) );
6004  break;
6005 
6006  default:
6007  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
6008  return SCIP_INVALIDCALL;
6009  } /*lint !e788*/
6010 
6011  if( tightened != NULL )
6012  *tightened = TRUE;
6013 
6014  return SCIP_OKAY;
6015 }
6016 
6017 /** depending on SCIP's stage, fixes binary variable in the problem, in preprocessing, or in current node;
6018  * the given inference propagator is stored, such that the conflict analysis is able to find out the reason for the
6019  * deduction of the fixing
6020  *
6021  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6022  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6023  *
6024  * @pre This method can be called if @p scip is in one of the following stages:
6025  * - \ref SCIP_STAGE_PROBLEM
6026  * - \ref SCIP_STAGE_PRESOLVING
6027  * - \ref SCIP_STAGE_PRESOLVED
6028  * - \ref SCIP_STAGE_SOLVING
6029  */
6031  SCIP* scip, /**< SCIP data structure */
6032  SCIP_VAR* var, /**< binary variable to fix */
6033  SCIP_Bool fixedval, /**< value to fix binary variable to */
6034  SCIP_PROP* inferprop, /**< propagator that deduced the fixing */
6035  int inferinfo, /**< user information for inference to help resolving the conflict */
6036  SCIP_Bool* infeasible, /**< pointer to store whether the fixing is infeasible */
6037  SCIP_Bool* tightened /**< pointer to store whether the fixing tightened the local bounds, or NULL */
6038  )
6039 {
6040  SCIP_Real lb;
6041  SCIP_Real ub;
6042 
6043  assert(SCIPvarIsBinary(var));
6044  assert(fixedval == TRUE || fixedval == FALSE);
6045  assert(infeasible != NULL);
6046 
6047  SCIP_CALL( SCIPcheckStage(scip, "SCIPinferBinvarProp", FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
6048 
6049  *infeasible = FALSE;
6050  if( tightened != NULL )
6051  *tightened = FALSE;
6052 
6053  /* get current bounds */
6054  lb = SCIPvarGetLbLocal(var);
6055  ub = SCIPvarGetUbLocal(var);
6056  assert(SCIPsetIsEQ(scip->set, lb, 0.0) || SCIPsetIsEQ(scip->set, lb, 1.0));
6057  assert(SCIPsetIsEQ(scip->set, ub, 0.0) || SCIPsetIsEQ(scip->set, ub, 1.0));
6058  assert(SCIPsetIsLE(scip->set, lb, ub));
6059 
6060  /* check, if variable is already fixed */
6061  if( (lb > 0.5) || (ub < 0.5) )
6062  {
6063  *infeasible = (fixedval == (lb < 0.5));
6064 
6065  return SCIP_OKAY;
6066  }
6067 
6068  /* apply the fixing */
6069  switch( scip->set->stage )
6070  {
6071  case SCIP_STAGE_PROBLEM:
6072  assert(!SCIPvarIsTransformed(var));
6073  if( fixedval == TRUE )
6074  {
6075  SCIP_CALL( SCIPchgVarLb(scip, var, 1.0) );
6076  }
6077  else
6078  {
6079  SCIP_CALL( SCIPchgVarUb(scip, var, 0.0) );
6080  }
6081  break;
6082 
6083  case SCIP_STAGE_PRESOLVING:
6084  if( SCIPtreeGetCurrentDepth(scip->tree) == 0 )
6085  {
6086  SCIP_Bool fixed;
6087 
6088  SCIP_CALL( SCIPvarFix(var, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob,
6089  scip->primal, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable,
6090  (SCIP_Real)fixedval, infeasible, &fixed) );
6091  break;
6092  }
6093  /*lint -fallthrough*/
6094  case SCIP_STAGE_SOLVING:
6095  if( fixedval == TRUE )
6096  {
6098  scip->transprob, scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable, var, 1.0,
6099  SCIP_BOUNDTYPE_LOWER, NULL, inferprop, inferinfo, FALSE) );
6100  }
6101  else
6102  {
6104  scip->transprob, scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable, var, 0.0,
6105  SCIP_BOUNDTYPE_UPPER, NULL, inferprop, inferinfo, FALSE) );
6106  }
6107  break;
6108 
6109  default:
6110  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
6111  return SCIP_INVALIDCALL;
6112  } /*lint !e788*/
6113 
6114  if( tightened != NULL )
6115  *tightened = TRUE;
6116 
6117  return SCIP_OKAY;
6118 }
6119 
6120 /** changes global lower bound of variable in preprocessing or in the current node, if the new bound is tighter
6121  * (w.r.t. bound strengthening epsilon) than the current global bound; if possible, adjusts bound to integral value;
6122  * also tightens the local bound, if the global bound is better than the local bound
6123  *
6124  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
6125  * SCIPgetVars()) gets resorted.
6126  *
6127  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6128  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6129  *
6130  * @pre This method can be called if @p scip is in one of the following stages:
6131  * - \ref SCIP_STAGE_PROBLEM
6132  * - \ref SCIP_STAGE_TRANSFORMING
6133  * - \ref SCIP_STAGE_PRESOLVING
6134  * - \ref SCIP_STAGE_SOLVING
6135  *
6136  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
6137  */
6139  SCIP* scip, /**< SCIP data structure */
6140  SCIP_VAR* var, /**< variable to change the bound for */
6141  SCIP_Real newbound, /**< new value for bound */
6142  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
6143  SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */
6144  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
6145  )
6146 {
6147  SCIP_Real lb;
6148  SCIP_Real ub;
6149 
6150  assert(infeasible != NULL);
6151 
6152  SCIP_CALL( SCIPcheckStage(scip, "SCIPtightenVarLbGlobal", FALSE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
6153 
6154  *infeasible = FALSE;
6155  if( tightened != NULL )
6156  *tightened = FALSE;
6157 
6158  SCIPvarAdjustLb(var, scip->set, &newbound);
6159 
6160  /* ignore tightenings of lower bounds to +infinity during solving process */
6161  if( SCIPisInfinity(scip, newbound) && SCIPgetStage(scip) == SCIP_STAGE_SOLVING )
6162  {
6163 #ifndef NDEBUG
6164  SCIPwarningMessage(scip, "ignore lower bound tightening for %s from %e to +infinity\n", SCIPvarGetName(var),
6165  SCIPvarGetLbLocal(var));
6166 #endif
6167  return SCIP_OKAY;
6168  }
6169 
6170  /* get current bounds */
6171  lb = SCIPvarGetLbGlobal(var);
6172  ub = SCIPvarGetUbGlobal(var);
6173  assert(scip->set->stage == SCIP_STAGE_PROBLEM || SCIPsetIsLE(scip->set, lb, ub));
6174 
6175  if( SCIPsetIsFeasGT(scip->set, newbound, ub) )
6176  {
6177  *infeasible = TRUE;
6178  return SCIP_OKAY;
6179  }
6180  newbound = MIN(newbound, ub);
6181 
6182  /* bound changes of less than epsilon are ignored by SCIPvarChgLb or raise an assert in SCIPnodeAddBoundinfer,
6183  * so don't apply them even if force is set
6184  */
6185  if( SCIPsetIsEQ(scip->set, lb, newbound) || (!force && !SCIPsetIsLbBetter(scip->set, newbound, lb, ub)) )
6186  return SCIP_OKAY;
6187 
6188  switch( scip->set->stage )
6189  {
6190  case SCIP_STAGE_PROBLEM:
6191  assert(!SCIPvarIsTransformed(var));
6192  SCIP_CALL( SCIPvarChgLbGlobal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
6193  scip->branchcand, scip->eventqueue, scip->cliquetable, newbound) );
6194  SCIP_CALL( SCIPvarChgLbLocal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
6195  scip->branchcand, scip->eventqueue, newbound) );
6196  SCIP_CALL( SCIPvarChgLbOriginal(var, scip->set, newbound) );
6197  break;
6198 
6200  SCIP_CALL( SCIPvarChgLbGlobal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
6201  scip->branchcand, scip->eventqueue, scip->cliquetable, newbound) );
6202  break;
6203 
6204  case SCIP_STAGE_PRESOLVING:
6205  if( !SCIPinProbing(scip) )
6206  {
6207  assert(SCIPtreeGetCurrentDepth(scip->tree) == 0);
6208  assert(scip->tree->root == SCIPtreeGetCurrentNode(scip->tree));
6209 
6210  SCIP_CALL( SCIPnodeAddBoundchg(scip->tree->root, scip->mem->probmem, scip->set, scip->stat, scip->transprob,
6211  scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable, var, newbound,
6213 
6215  {
6216  SCIP_CALL( SCIPchgVarType(scip, var, SCIP_VARTYPE_BINARY, infeasible) );
6217  assert(!(*infeasible));
6218  }
6219  break;
6220  }
6221  /*lint -fallthrough*/
6222  case SCIP_STAGE_SOLVING:
6223  SCIP_CALL( SCIPnodeAddBoundchg(scip->tree->root, scip->mem->probmem, scip->set, scip->stat, scip->transprob,
6224  scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable, var, newbound,
6226  break;
6227 
6228  default:
6229  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
6230  return SCIP_INVALIDCALL;
6231  } /*lint !e788*/
6232 
6233  /* coverity: unreachable code */
6234  if( tightened != NULL )
6235  *tightened = TRUE;
6236 
6237  return SCIP_OKAY;
6238 }
6239 
6240 /** changes global upper bound of variable in preprocessing or in the current node, if the new bound is tighter
6241  * (w.r.t. bound strengthening epsilon) than the current global bound; if possible, adjusts bound to integral value;
6242  * also tightens the local bound, if the global bound is better than the local bound
6243  *
6244  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
6245  * SCIPgetVars()) gets resorted.
6246  *
6247  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6248  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6249  *
6250  * @pre This method can be called if @p scip is in one of the following stages:
6251  * - \ref SCIP_STAGE_PROBLEM
6252  * - \ref SCIP_STAGE_TRANSFORMING
6253  * - \ref SCIP_STAGE_PRESOLVING
6254  * - \ref SCIP_STAGE_SOLVING
6255  *
6256  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
6257  */
6259  SCIP* scip, /**< SCIP data structure */
6260  SCIP_VAR* var, /**< variable to change the bound for */
6261  SCIP_Real newbound, /**< new value for bound */
6262  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
6263  SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */
6264  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
6265  )
6266 {
6267  SCIP_Real lb;
6268  SCIP_Real ub;
6269 
6270  assert(infeasible != NULL);
6271 
6272  SCIP_CALL( SCIPcheckStage(scip, "SCIPtightenVarUbGlobal", FALSE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
6273 
6274  *infeasible = FALSE;
6275  if( tightened != NULL )
6276  *tightened = FALSE;
6277 
6278  SCIPvarAdjustUb(var, scip->set, &newbound);
6279 
6280  /* ignore tightenings of upper bounds to -infinity during solving process */
6281  if( SCIPisInfinity(scip, -newbound) && SCIPgetStage(scip) == SCIP_STAGE_SOLVING )
6282  {
6283 #ifndef NDEBUG
6284  SCIPwarningMessage(scip, "ignore upper bound tightening for %s from %e to -infinity\n", SCIPvarGetName(var),
6285  SCIPvarGetUbLocal(var));
6286 #endif
6287  return SCIP_OKAY;
6288  }
6289 
6290  /* get current bounds */
6291  lb = SCIPvarGetLbGlobal(var);
6292  ub = SCIPvarGetUbGlobal(var);
6293  assert(scip->set->stage == SCIP_STAGE_PROBLEM || SCIPsetIsLE(scip->set, lb, ub));
6294 
6295  if( SCIPsetIsFeasLT(scip->set, newbound, lb) )
6296  {
6297  *infeasible = TRUE;
6298  return SCIP_OKAY;
6299  }
6300  newbound = MAX(newbound, lb);
6301 
6302  /* bound changes of less than epsilon are ignored by SCIPvarChgUb or raise an assert in SCIPnodeAddBoundinfer,
6303  * so don't apply them even if force is set
6304  */
6305  if( SCIPsetIsEQ(scip->set, ub, newbound) || (!force && !SCIPsetIsUbBetter(scip->set, newbound, lb, ub)) )
6306  return SCIP_OKAY;
6307 
6308  switch( scip->set->stage )
6309  {
6310  case SCIP_STAGE_PROBLEM:
6311  assert(!SCIPvarIsTransformed(var));
6312  SCIP_CALL( SCIPvarChgUbGlobal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
6313  scip->branchcand, scip->eventqueue, scip->cliquetable, newbound) );
6314  SCIP_CALL( SCIPvarChgUbLocal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
6315  scip->branchcand, scip->eventqueue, newbound) );
6316  SCIP_CALL( SCIPvarChgUbOriginal(var, scip->set, newbound) );
6317  break;
6318 
6320  SCIP_CALL( SCIPvarChgUbGlobal(var, scip->mem->probmem, scip->set, scip->stat, scip->lp,
6321  scip->branchcand, scip->eventqueue, scip->cliquetable, newbound) );
6322  break;
6323 
6324  case SCIP_STAGE_PRESOLVING:
6325  if( !SCIPinProbing(scip) )
6326  {
6327  assert(SCIPtreeGetCurrentDepth(scip->tree) == 0);
6328  assert(scip->tree->root == SCIPtreeGetCurrentNode(scip->tree));
6329 
6330  SCIP_CALL( SCIPnodeAddBoundchg(scip->tree->root, scip->mem->probmem, scip->set, scip->stat, scip->transprob,
6331  scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable, var, newbound,
6333 
6335  {
6336  SCIP_CALL( SCIPchgVarType(scip, var, SCIP_VARTYPE_BINARY, infeasible) );
6337  assert(!(*infeasible));
6338  }
6339  break;
6340  }
6341  /*lint -fallthrough*/
6342  case SCIP_STAGE_SOLVING:
6343  SCIP_CALL( SCIPnodeAddBoundchg(scip->tree->root, scip->mem->probmem, scip->set, scip->stat, scip->transprob,
6344  scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable, var, newbound,
6346  break;
6347 
6348  default:
6349  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
6350  return SCIP_INVALIDCALL;
6351  } /*lint !e788*/
6352 
6353  /* coverity: unreachable code */
6354  if( tightened != NULL )
6355  *tightened = TRUE;
6356 
6357  return SCIP_OKAY;
6358 }
6359 
6360 /* some simple variable functions implemented as defines */
6361 #undef SCIPcomputeVarLbGlobal
6362 #undef SCIPcomputeVarUbGlobal
6363 #undef SCIPcomputeVarLbLocal
6364 #undef SCIPcomputeVarUbLocal
6365 
6366 /** for a multi-aggregated variable, returns the global lower bound computed by adding the global bounds from all aggregation variables
6367  *
6368  * 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
6369  * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetLbGlobal.
6370  *
6371  * @return the global lower bound computed by adding the global bounds from all aggregation variables
6372  */
6374  SCIP* scip, /**< SCIP data structure */
6375  SCIP_VAR* var /**< variable to compute the bound for */
6376  )
6377 {
6378  assert(scip != NULL);
6379  assert(var != NULL);
6380 
6382  return SCIPvarGetMultaggrLbGlobal(var, scip->set);
6383  else
6384  return SCIPvarGetLbGlobal(var);
6385 }
6386 
6387 /** for a multi-aggregated variable, returns the global upper bound computed by adding the global bounds from all aggregation variables
6388  *
6389  * 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
6390  * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetUbGlobal
6391  *
6392  * @return the global upper bound computed by adding the global bounds from all aggregation variables
6393  */
6395  SCIP* scip, /**< SCIP data structure */
6396  SCIP_VAR* var /**< variable to compute the bound for */
6397  )
6398 {
6399  assert(scip != NULL);
6400  assert(var != NULL);
6401 
6403  return SCIPvarGetMultaggrUbGlobal(var, scip->set);
6404  else
6405  return SCIPvarGetUbGlobal(var);
6406 }
6407 
6408 /** for a multi-aggregated variable, returns the local lower bound computed by adding the local bounds from all aggregation variables
6409  *
6410  * 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
6411  * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetLbLocal.
6412  *
6413  * @return the local lower bound computed by adding the global bounds from all aggregation variables
6414  */
6416  SCIP* scip, /**< SCIP data structure */
6417  SCIP_VAR* var /**< variable to compute the bound for */
6418  )
6419 {
6420  assert(scip != NULL);
6421  assert(var != NULL);
6422 
6424  return SCIPvarGetMultaggrLbLocal(var, scip->set);
6425  else
6426  return SCIPvarGetLbLocal(var);
6427 }
6428 
6429 /** for a multi-aggregated variable, returns the local upper bound computed by adding the local bounds from all aggregation variables
6430  *
6431  * 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
6432  * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetUbLocal.
6433  *
6434  * @return the local upper bound computed by adding the global bounds from all aggregation variables
6435  */
6437  SCIP* scip, /**< SCIP data structure */
6438  SCIP_VAR* var /**< variable to compute the bound for */
6439  )
6440 {
6441  assert(scip != NULL);
6442  assert(var != NULL);
6443 
6445  return SCIPvarGetMultaggrUbLocal(var, scip->set);
6446  else
6447  return SCIPvarGetUbLocal(var);
6448 }
6449 
6450 /** for a multi-aggregated variable, gives the global lower bound computed by adding the global bounds from all
6451  * aggregation variables, this global bound may be tighter than the one given by SCIPvarGetLbGlobal, since the latter is
6452  * not updated if bounds of aggregation variables are changing
6453  *
6454  * calling this function for a non-multi-aggregated variable is not allowed
6455  */
6457  SCIP* scip, /**< SCIP data structure */
6458  SCIP_VAR* var /**< variable to compute the bound for */
6459  )
6460 {
6461  assert(SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR);
6462  return SCIPvarGetMultaggrLbGlobal(var, scip->set);
6463 }
6464 
6465 /** for a multi-aggregated variable, gives the global upper bound computed by adding the global bounds from all
6466  * aggregation variables, this upper bound may be tighter than the one given by SCIPvarGetUbGlobal, since the latter is
6467  * not updated if bounds of aggregation variables are changing
6468  *
6469  * calling this function for a non-multi-aggregated variable is not allowed
6470  */
6472  SCIP* scip, /**< SCIP data structure */
6473  SCIP_VAR* var /**< variable to compute the bound for */
6474  )
6475 {
6476  assert(SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR);
6477  return SCIPvarGetMultaggrUbGlobal(var, scip->set);
6478 }
6479 
6480 /** for a multi-aggregated variable, gives the local lower bound computed by adding the local bounds from all
6481  * aggregation variables, this lower bound may be tighter than the one given by SCIPvarGetLbLocal, since the latter is
6482  * not updated if bounds of aggregation variables are changing
6483  *
6484  * calling this function for a non-multi-aggregated variable is not allowed
6485  */
6487  SCIP* scip, /**< SCIP data structure */
6488  SCIP_VAR* var /**< variable to compute the bound for */
6489  )
6490 {
6491  assert(SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR);
6492  return SCIPvarGetMultaggrLbLocal(var, scip->set);
6493 }
6494 
6495 /** for a multi-aggregated variable, gives the local upper bound computed by adding the local bounds from all
6496  * aggregation variables, this upper bound may be tighter than the one given by SCIPvarGetUbLocal, since the latter is
6497  * not updated if bounds of aggregation variables are changing
6498  *
6499  * calling this function for a non-multi-aggregated variable is not allowed
6500  */
6502  SCIP* scip, /**< SCIP data structure */
6503  SCIP_VAR* var /**< variable to compute the bound for */
6504  )
6505 {
6506  assert(SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR);
6507  return SCIPvarGetMultaggrUbLocal(var, scip->set);
6508 }
6509 
6510 /** returns solution value and index of variable lower bound that is closest to the variable's value in the given primal
6511  * solution or current LP solution if no primal solution is given; returns an index of -1 if no variable lower bound is
6512  * available
6513  *
6514  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6515  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6516  *
6517  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
6518  */
6520  SCIP* scip, /**< SCIP data structure */
6521  SCIP_VAR* var, /**< active problem variable */
6522  SCIP_SOL* sol, /**< primal solution, or NULL for LP solution */
6523  SCIP_Real* closestvlb, /**< pointer to store the value of the closest variable lower bound */
6524  int* closestvlbidx /**< pointer to store the index of the closest variable lower bound */
6525  )
6526 {
6527  SCIP_CALL( SCIPcheckStage(scip, "SCIPgetVarClosestVlb", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
6528 
6529  SCIPvarGetClosestVlb(var, sol, scip->set, scip->stat, closestvlb, closestvlbidx);
6530 
6531  return SCIP_OKAY;
6532 }
6533 
6534 /** returns solution value and index of variable upper bound that is closest to the variable's value in the given primal solution;
6535  * or current LP solution if no primal solution is given; returns an index of -1 if no variable upper bound is available
6536  *
6537  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6538  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6539  *
6540  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
6541  */
6543  SCIP* scip, /**< SCIP data structure */
6544  SCIP_VAR* var, /**< active problem variable */
6545  SCIP_SOL* sol, /**< primal solution, or NULL for LP solution */
6546  SCIP_Real* closestvub, /**< pointer to store the value of the closest variable lower bound */
6547  int* closestvubidx /**< pointer to store the index of the closest variable lower bound */
6548  )
6549 {
6550  SCIP_CALL( SCIPcheckStage(scip, "SCIPgetVarClosestVub", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
6551 
6552  SCIPvarGetClosestVub(var, sol, scip->set, scip->stat, closestvub, closestvubidx);
6553 
6554  return SCIP_OKAY;
6555 }
6556 
6557 /** informs variable x about a globally valid variable lower bound x >= b*z + d with integer variable z;
6558  * if z is binary, the corresponding valid implication for z is also added;
6559  * if z is non-continuous and 1/b not too small, the corresponding valid upper/lower bound
6560  * z <= (x-d)/b or z >= (x-d)/b (depending on the sign of of b) is added, too;
6561  * improves the global bounds of the variable and the vlb variable if possible
6562  *
6563  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6564  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6565  *
6566  * @pre This method can be called if @p scip is in one of the following stages:
6567  * - \ref SCIP_STAGE_PRESOLVING
6568  * - \ref SCIP_STAGE_PRESOLVED
6569  * - \ref SCIP_STAGE_SOLVING
6570  */
6572  SCIP* scip, /**< SCIP data structure */
6573  SCIP_VAR* var, /**< problem variable */
6574  SCIP_VAR* vlbvar, /**< variable z in x >= b*z + d */
6575  SCIP_Real vlbcoef, /**< coefficient b in x >= b*z + d */
6576  SCIP_Real vlbconstant, /**< constant d in x >= b*z + d */
6577  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
6578  int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
6579  )
6580 {
6581  int nlocalbdchgs;
6582 
6583  SCIP_CALL( SCIPcheckStage(scip, "SCIPaddVarVlb", FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
6584 
6585  SCIP_CALL( SCIPvarAddVlb(var, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob, scip->tree,
6586  scip->reopt, scip->lp, scip->cliquetable, scip->branchcand, scip->eventqueue, vlbvar, vlbcoef, vlbconstant,
6587  TRUE, infeasible, &nlocalbdchgs) );
6588 
6589  *nbdchgs = nlocalbdchgs;
6590 
6591  /* 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
6592  * detected infeasibility
6593  */
6594  if( !(*infeasible) && SCIPvarGetType(var) != SCIP_VARTYPE_CONTINUOUS && !SCIPisZero(scip, 1.0/vlbcoef) )
6595  {
6596  if( vlbcoef > 0.0 )
6597  {
6598  /* if b > 0, we have a variable upper bound: x >= b*z + d => z <= (x-d)/b */
6599  SCIP_CALL( SCIPvarAddVub(vlbvar, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob,
6600  scip->tree, scip->reopt, scip->lp, scip->cliquetable, scip->branchcand, scip->eventqueue, var, 1.0/vlbcoef,
6601  -vlbconstant/vlbcoef, TRUE, infeasible, &nlocalbdchgs) );
6602  }
6603  else
6604  {
6605  /* if b < 0, we have a variable lower bound: x >= b*z + d => z >= (x-d)/b */
6606  SCIP_CALL( SCIPvarAddVlb(vlbvar, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob,
6607  scip->tree, scip->reopt, scip->lp, scip->cliquetable, scip->branchcand, scip->eventqueue, var, 1.0/vlbcoef,
6608  -vlbconstant/vlbcoef, TRUE, infeasible, &nlocalbdchgs) );
6609  }
6610  *nbdchgs += nlocalbdchgs;
6611  }
6612 
6613  return SCIP_OKAY;
6614 }
6615 
6616 /** informs variable x about a globally valid variable upper bound x <= b*z + d with integer variable z;
6617  * if z is binary, the corresponding valid implication for z is also added;
6618  * if z is non-continuous and 1/b not too small, the corresponding valid lower/upper bound
6619  * z >= (x-d)/b or z <= (x-d)/b (depending on the sign of of b) is added, too;
6620  * improves the global bounds of the variable and the vlb variable if possible
6621  *
6622  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6623  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6624  *
6625  * @pre This method can be called if @p scip is in one of the following stages:
6626  * - \ref SCIP_STAGE_PRESOLVING
6627  * - \ref SCIP_STAGE_PRESOLVED
6628  * - \ref SCIP_STAGE_SOLVING
6629  */
6631  SCIP* scip, /**< SCIP data structure */
6632  SCIP_VAR* var, /**< problem variable */
6633  SCIP_VAR* vubvar, /**< variable z in x <= b*z + d */
6634  SCIP_Real vubcoef, /**< coefficient b in x <= b*z + d */
6635  SCIP_Real vubconstant, /**< constant d in x <= b*z + d */
6636  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
6637  int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
6638  )
6639 {
6640  int nlocalbdchgs;
6641 
6642  SCIP_CALL( SCIPcheckStage(scip, "SCIPaddVarVub", FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
6643 
6644  SCIP_CALL( SCIPvarAddVub(var, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob, scip->tree,
6645  scip->reopt, scip->lp, scip->cliquetable, scip->branchcand, scip->eventqueue, vubvar, vubcoef, vubconstant, TRUE,
6646  infeasible, &nlocalbdchgs) );
6647 
6648  *nbdchgs = nlocalbdchgs;
6649 
6650  /* 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
6651  * detected infeasibility
6652  */
6653  if( !(*infeasible) && SCIPvarGetType(var) != SCIP_VARTYPE_CONTINUOUS && !SCIPisZero(scip, 1.0/vubcoef) )
6654  {
6655  if( vubcoef > 0.0 )
6656  {
6657  /* if b < 0, we have a variable lower bound: x >= b*z + d => z >= (x-d)/b */
6658  SCIP_CALL( SCIPvarAddVlb(vubvar, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob,
6659  scip->tree, scip->reopt, scip->lp, scip->cliquetable, scip->branchcand, scip->eventqueue, var, 1.0/vubcoef,
6660  -vubconstant/vubcoef, TRUE, infeasible, &nlocalbdchgs) );
6661  }
6662  else
6663  {
6664  /* if b > 0, we have a variable upper bound: x >= b*z + d => z <= (x-d)/b */
6665  SCIP_CALL( SCIPvarAddVub(vubvar, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob,
6666  scip->tree, scip->reopt, scip->lp, scip->cliquetable, scip->branchcand, scip->eventqueue, var, 1.0/vubcoef,
6667  -vubconstant/vubcoef, TRUE, infeasible, &nlocalbdchgs) );
6668  }
6669  *nbdchgs += nlocalbdchgs;
6670  }
6671 
6672  return SCIP_OKAY;
6673 }
6674 
6675 /** informs binary variable x about a globally valid implication: x == 0 or x == 1 ==> y <= b or y >= b;
6676  * also adds the corresponding implication or variable bound to the implied variable;
6677  * if the implication is conflicting, the variable is fixed to the opposite value;
6678  * if the variable is already fixed to the given value, the implication is performed immediately;
6679  * if the implication is redundant with respect to the variables' global bounds, it is ignored
6680  *
6681  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6682  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6683  *
6684  * @pre This method can be called if @p scip is in one of the following stages:
6685  * - \ref SCIP_STAGE_TRANSFORMED
6686  * - \ref SCIP_STAGE_PRESOLVING
6687  * - \ref SCIP_STAGE_PRESOLVED
6688  * - \ref SCIP_STAGE_SOLVING
6689  */
6691  SCIP* scip, /**< SCIP data structure */
6692  SCIP_VAR* var, /**< problem variable */
6693  SCIP_Bool varfixing, /**< FALSE if y should be added in implications for x == 0, TRUE for x == 1 */
6694  SCIP_VAR* implvar, /**< variable y in implication y <= b or y >= b */
6695  SCIP_BOUNDTYPE impltype, /**< type of implication y <= b (SCIP_BOUNDTYPE_UPPER)
6696  * or y >= b (SCIP_BOUNDTYPE_LOWER) */
6697  SCIP_Real implbound, /**< bound b in implication y <= b or y >= b */
6698  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
6699  int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
6700  )
6701 {
6702  SCIP_VAR* implprobvar;
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  implprobvar = SCIPvarGetProbvar(implvar);
6715  /* transform implication containing two binary variables to clique; condition ensures that the active representative
6716  * of implvar is actually binary
6717  */
6718  if( SCIPvarIsBinary(implvar) && (SCIPvarIsActive(implvar) || (implprobvar != NULL && SCIPvarIsBinary(implprobvar))) )
6719  {
6720  assert(SCIPisFeasEQ(scip, implbound, 1.0) || SCIPisFeasZero(scip, implbound));
6721  assert((impltype == SCIP_BOUNDTYPE_UPPER) == SCIPisFeasZero(scip, implbound));
6722 
6723  /* only add clique if implication is not redundant with respect to global bounds of the implication variable */
6724  if( (impltype == SCIP_BOUNDTYPE_LOWER && SCIPvarGetLbGlobal(implvar) < 0.5) ||
6725  (impltype == SCIP_BOUNDTYPE_UPPER && SCIPvarGetUbGlobal(implvar) > 0.5)
6726  )
6727  {
6728  SCIP_VAR* vars[2];
6729  SCIP_Bool vals[2];
6730 
6731 
6732  vars[0] = var;
6733  vars[1] = implvar;
6734  vals[0] = varfixing;
6735  vals[1] = (impltype == SCIP_BOUNDTYPE_UPPER);
6736 
6737  SCIP_CALL( SCIPaddClique(scip, vars, vals, 2, FALSE, infeasible, nbdchgs) );
6738  }
6739 
6740  return SCIP_OKAY;
6741  }
6742 
6743  /* the implication graph can only handle 'real' binary (SCIP_VARTYPE_BINARY) variables, therefore we transform the
6744  * implication in variable bounds, (lowerbound of y will be abbreviated by lby, upperbound equivlaent) the follwing
6745  * four cases are:
6746  *
6747  * 1. (x >= 1 => y >= b) => y >= (b - lby) * x + lby
6748  * 2. (x >= 1 => y <= b) => y <= (b - uby) * x + uby
6749  * 3. (x <= 0 => y >= b) => y >= (lby - b) * x + b
6750  * 4. (x <= 0 => y <= b) => y <= (uby - b) * x + b
6751  */
6752  if( SCIPvarGetType(var) != SCIP_VARTYPE_BINARY )
6753  {
6754  SCIP_Real lby;
6755  SCIP_Real uby;
6756 
6757  lby = SCIPvarGetLbGlobal(implvar);
6758  uby = SCIPvarGetUbGlobal(implvar);
6759 
6760  if( varfixing == TRUE )
6761  {
6762  if( impltype == SCIP_BOUNDTYPE_LOWER )
6763  {
6764  /* we return if the lower bound is infinity */
6765  if( SCIPisInfinity(scip, -lby) )
6766  return SCIP_OKAY;
6767 
6768  SCIP_CALL( SCIPvarAddVlb(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 - lby, lby, TRUE, infeasible, nbdchgs) );
6771  }
6772  else
6773  {
6774  /* we return if the upper bound is infinity */
6775  if( SCIPisInfinity(scip, uby) )
6776  return SCIP_OKAY;
6777 
6778  SCIP_CALL( SCIPvarAddVub(implvar, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob,
6779  scip->tree, scip->reopt, scip->lp, scip->cliquetable, scip->branchcand, scip->eventqueue, var,
6780  implbound - uby, uby, TRUE, infeasible, nbdchgs) );
6781  }
6782  }
6783  else
6784  {
6785  if( impltype == SCIP_BOUNDTYPE_LOWER )
6786  {
6787  /* we return if the lower bound is infinity */
6788  if( SCIPisInfinity(scip, -lby) )
6789  return SCIP_OKAY;
6790 
6791  SCIP_CALL( SCIPvarAddVlb(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  lby - implbound, implbound, TRUE, infeasible, nbdchgs) );
6794  }
6795  else
6796  {
6797  /* we return if the upper bound is infinity */
6798  if( SCIPisInfinity(scip, uby) )
6799  return SCIP_OKAY;
6800 
6801  SCIP_CALL( SCIPvarAddVub(implvar, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob,
6802  scip->tree, scip->reopt, scip->lp, scip->cliquetable, scip->branchcand, scip->eventqueue, var,
6803  uby - implbound, implbound, TRUE, infeasible, nbdchgs) );
6804  }
6805  }
6806  }
6807  else
6808  {
6809  SCIP_CALL( SCIPvarAddImplic(var, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob,
6810  scip->tree, scip->reopt, scip->lp, scip->cliquetable, scip->branchcand, scip->eventqueue, varfixing, implvar, impltype,
6811  implbound, TRUE, infeasible, nbdchgs) );
6812  }
6813 
6814  return SCIP_OKAY;
6815 }
6816 
6817 /** adds a clique information to SCIP, stating that at most one of the given binary variables can be set to 1;
6818  * if a variable appears twice in the same clique, the corresponding implications are performed
6819  *
6820  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6821  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6822  *
6823  * @pre This method can be called if @p scip is in one of the following stages:
6824  * - \ref SCIP_STAGE_TRANSFORMED
6825  * - \ref SCIP_STAGE_PRESOLVING
6826  * - \ref SCIP_STAGE_PRESOLVED
6827  * - \ref SCIP_STAGE_SOLVING
6828  */
6830  SCIP* scip, /**< SCIP data structure */
6831  SCIP_VAR** vars, /**< binary variables in the clique from which at most one can be set to 1 */
6832  SCIP_Bool* values, /**< values of the variables in the clique; NULL to use TRUE for all vars */
6833  int nvars, /**< number of variables in the clique */
6834  SCIP_Bool isequation, /**< is the clique an equation or an inequality? */
6835  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
6836  int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
6837  )
6838 {
6839  SCIP_CALL( SCIPcheckStage(scip, "SCIPaddClique", FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
6840 
6841  *infeasible = FALSE;
6842  if( nbdchgs != NULL )
6843  *nbdchgs = 0;
6844 
6845  if( nvars > 1 )
6846  {
6847  /* add the clique to the clique table */
6848  SCIP_CALL( SCIPcliquetableAdd(scip->cliquetable, scip->mem->probmem, scip->set, scip->stat, scip->transprob,
6849  scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, vars, values, nvars, isequation,
6850  infeasible, nbdchgs) );
6851  }
6852 
6853  return SCIP_OKAY;
6854 }
6855 
6856 /** relabels the given labels in-place in an increasing fashion: the first seen label is 0, the next label 1, etc...
6857  *
6858  * @note every label equal to -1 is treated as a previously unseen, unique label and gets a new ordered label.
6859  */
6860 static
6862  SCIP*const scip, /**< SCIP data structure */
6863  int* labels, /**< current labels that will be overwritten */
6864  int const nlabels, /**< number of variables in the clique */
6865  int* nclasses /**< pointer to store the total number of distinct labels */
6866  )
6867 {
6868  SCIP_HASHMAP* classidx2newlabel;
6869 
6870  int classidx;
6871  int i;
6872 
6873  SCIP_CALL( SCIPhashmapCreate(&classidx2newlabel, SCIPblkmem(scip), nlabels) );
6874 
6875  classidx = 0;
6876 
6877  /* loop over labels to create local class indices that obey the variable order */
6878  for( i = 0; i < nlabels; ++i )
6879  {
6880  int currentlabel = labels[i];
6881  int localclassidx;
6882 
6883  /* labels equal to -1 are stored as singleton classes */
6884  if( currentlabel == -1 )
6885  {
6886  ++classidx;
6887  localclassidx = classidx;
6888  }
6889  else
6890  {
6891  assert(currentlabel >= 0);
6892  /* look up the class index image in the hash map; if it is not stored yet, new class index is created and stored */
6893  if( !SCIPhashmapExists(classidx2newlabel, (void*)(size_t)currentlabel) )
6894  {
6895  ++classidx;
6896  localclassidx = classidx;
6897  SCIP_CALL( SCIPhashmapInsertInt(classidx2newlabel, (void*)(size_t)currentlabel, classidx) ); /*lint !e571*/
6898  }
6899  else
6900  {
6901  localclassidx = SCIPhashmapGetImageInt(classidx2newlabel, (void*)(size_t)currentlabel); /*lint !e571*/
6902  }
6903  }
6904  assert(localclassidx - 1 >= 0);
6905  assert(localclassidx - 1 <= i);
6906 
6907  /* indices start with zero, but we have an offset of 1 because we cannot store 0 in a hashmap */
6908  labels[i] = localclassidx - 1;
6909  }
6910 
6911  assert(classidx > 0);
6912  assert(classidx <= nlabels);
6913  *nclasses = classidx;
6914 
6915  SCIPhashmapFree(&classidx2newlabel);
6916 
6917  return SCIP_OKAY;
6918 }
6919 
6920 /** sort the variables w.r.t. the given labels; thereby ensure the current order of the variables with the same label. */
6921 static
6923  SCIP* scip, /**< SCIP data structure */
6924  SCIP_VAR** vars, /**< variable array */
6925  int* classlabels, /**< array that contains a class label for every variable */
6926  SCIP_VAR** sortedvars, /**< array to store variables after stable sorting */
6927  int* sortedindices, /**< array to store indices of sorted variables in the original vars array */
6928  int* classesstartposs, /**< starting position array for each label class (must have size nclasses + 1) */
6929  int nvars, /**< size of the vars arrays */
6930  int nclasses /**< number of label classes */
6931  )
6932 {
6933  SCIP_VAR*** varpointers;
6934  int** indexpointers;
6935  int* classcount;
6936 
6937  int nextpos;
6938  int c;
6939  int v;
6940 
6941  assert(scip != NULL);
6942  assert(vars != NULL);
6943  assert(sortedindices != NULL);
6944  assert(classesstartposs != NULL);
6945 
6946  assert(nvars == 0 || vars != NULL);
6947 
6948  if( nvars == 0 )
6949  return SCIP_OKAY;
6950 
6951  assert(classlabels != NULL);
6952  assert(nclasses > 0);
6953 
6954  /* we first count all class cardinalities and allocate temporary memory for a bucket sort */
6955  SCIP_CALL( SCIPallocBufferArray(scip, &classcount, nclasses) );
6956  BMSclearMemoryArray(classcount, nclasses);
6957 
6958  /* first we count for each class the number of elements */
6959  for( v = nvars - 1; v >= 0; --v )
6960  {
6961  assert(0 <= classlabels[v] && classlabels[v] < nclasses);
6962  ++(classcount[classlabels[v]]);
6963  }
6964 
6965 #ifndef NDEBUG
6966  BMSclearMemoryArray(sortedvars, nvars);
6967  BMSclearMemoryArray(sortedindices, nvars);
6968 #endif
6969  SCIP_CALL( SCIPallocBufferArray(scip, &varpointers, nclasses) );
6970  SCIP_CALL( SCIPallocBufferArray(scip, &indexpointers, nclasses) );
6971 
6972  nextpos = 0;
6973  /* now we initialize all start pointers for each class, so they will be ordered */
6974  for( c = 0; c < nclasses; ++c )
6975  {
6976  /* to reach the goal that all variables of each class will be standing next to each other we will initialize the
6977  * starting pointers for each class by adding the cardinality of each class to the last class starting pointer
6978  * e.g. class1 has 4 elements and class2 has 3 elements then the starting pointer for class1 will be the pointer
6979  * to sortedvars[0], the starting pointer to class2 will be the pointer to sortedvars[4] and to class3 it will be
6980  * the pointer to sortedvars[7]
6981  */
6982  varpointers[c] = (SCIP_VAR**) (sortedvars + nextpos);
6983  indexpointers[c] = (int*) (sortedindices + nextpos);
6984  classesstartposs[c] = nextpos;
6985  assert(classcount[c] > 0);
6986  nextpos += classcount[c];
6987  assert(nextpos > 0);
6988  }
6989  assert(nextpos == nvars);
6990  classesstartposs[c] = nextpos;
6991 
6992  /* now we copy all variables to the right order */
6993  for( v = 0; v < nvars; ++v )
6994  {
6995  /* copy variable itself to the right position */
6996  *(varpointers[classlabels[v]]) = vars[v]; /*lint !e613*/
6997  ++(varpointers[classlabels[v]]);
6998 
6999  /* copy index */
7000  *(indexpointers[classlabels[v]]) = v;
7001  ++(indexpointers[classlabels[v]]);
7002  }
7003 
7004 /* in debug mode, we ensure the correctness of the mapping */
7005 #ifndef NDEBUG
7006  for( v = 0; v < nvars; ++v )
7007  {
7008  assert(sortedvars[v] != NULL);
7009  assert(sortedindices[v] >= 0);
7010 
7011  /* assert that the sorted indices map back to the correct variable in the original order */
7012  assert(vars[sortedindices[v]] == sortedvars[v]);
7013  }
7014 #endif
7015 
7016  /* free temporary memory */
7017  SCIPfreeBufferArray(scip, &indexpointers);
7018  SCIPfreeBufferArray(scip, &varpointers);
7019  SCIPfreeBufferArray(scip, &classcount);
7020 
7021  return SCIP_OKAY;
7022 }
7023 
7024 
7025 /* calculate clique partition for a maximal amount of comparisons on variables due to expensive algorithm
7026  * @todo: check for a good value, maybe it's better to check parts of variables
7027  */
7028 #define MAXNCLIQUEVARSCOMP 1000000
7029 
7030 /** calculates a partition of the given set of binary variables into cliques;
7031  * afterwards the output array contains one value for each variable, such that two variables got the same value iff they
7032  * were assigned to the same clique;
7033  * the first variable is always assigned to clique 0, and a variable can only be assigned to clique i if at least one of
7034  * the preceding variables was assigned to clique i-1;
7035  * for each clique at most 1 variables can be set to TRUE in a feasible solution;
7036  *
7037  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7038  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7039  *
7040  * @pre This method can be called if @p scip is in one of the following stages:
7041  * - \ref SCIP_STAGE_INITPRESOLVE
7042  * - \ref SCIP_STAGE_PRESOLVING
7043  * - \ref SCIP_STAGE_EXITPRESOLVE
7044  * - \ref SCIP_STAGE_PRESOLVED
7045  * - \ref SCIP_STAGE_SOLVING
7046  */
7047 static
7049  SCIP*const scip, /**< SCIP data structure */
7050  SCIP_VAR**const vars, /**< binary variables in the clique from which at most one can be set to 1 */
7051  SCIP_Bool*const values, /**< clique value (TRUE or FALSE) for each variable in the clique */
7052  int const nvars, /**< number of variables in the array */
7053  int*const cliquepartition, /**< array of length nvars to store the clique partition */
7054  int*const ncliques /**< pointer to store the number of cliques actually contained in the partition */
7055  )
7056 {
7057  SCIP_VAR** cliquevars;
7058  SCIP_Bool* cliquevalues;
7059  int i;
7060  int maxncliquevarscomp;
7061  int ncliquevars;
7062 
7063  /* allocate temporary memory for storing the variables of the current clique */
7064  SCIP_CALL( SCIPsetAllocBufferArray(scip->set, &cliquevars, nvars) );
7065  SCIP_CALL( SCIPsetAllocBufferArray(scip->set, &cliquevalues, nvars) );
7066 
7067  /* initialize the cliquepartition array with -1 */
7068  for( i = nvars - 1; i >= 0; --i )
7069  cliquepartition[i] = -1;
7070 
7071  maxncliquevarscomp = (int) MIN(nvars * (SCIP_Longint)nvars, MAXNCLIQUEVARSCOMP);
7072  /* calculate the clique partition */
7073  *ncliques = 0;
7074  for( i = 0; i < nvars; ++i )
7075  {
7076  if( cliquepartition[i] == -1 )
7077  {
7078  int j;
7079 
7080  /* variable starts a new clique */
7081  cliquepartition[i] = *ncliques;
7082  cliquevars[0] = vars[i];
7083  cliquevalues[0] = values[i];
7084  ncliquevars = 1;
7085 
7086  /* if variable is not active (multi-aggregated or fixed), it cannot be in any clique */
7087  if( SCIPvarIsActive(vars[i]) && SCIPvarGetNCliques(vars[i], values[i]) > 0 )
7088  {
7089  /* greedily fill up the clique */
7090  for( j = i+1; j < nvars; ++j )
7091  {
7092  /* if variable is not active (multi-aggregated or fixed), it cannot be in any clique */
7093  if( cliquepartition[j] == -1 && SCIPvarIsActive(vars[j]) )
7094  {
7095  int k;
7096 
7097  /* check if every variable in the current clique can be extended by tmpvars[j] */
7098  for( k = ncliquevars - 1; k >= 0; --k )
7099  {
7100  if( !SCIPvarsHaveCommonClique(vars[j], values[j], cliquevars[k], cliquevalues[k], FALSE) )
7101  break;
7102  }
7103 
7104  if( k == -1 )
7105  {
7106  /* put the variable into the same clique */
7107  cliquepartition[j] = cliquepartition[i];
7108  cliquevars[ncliquevars] = vars[j];
7109  cliquevalues[ncliquevars] = values[j];
7110  ++ncliquevars;
7111  }
7112  }
7113  }
7114  }
7115 
7116  /* this clique is finished */
7117  ++(*ncliques);
7118  }
7119  assert(cliquepartition[i] >= 0 && cliquepartition[i] < i+1);
7120 
7121  /* break if we reached the maximal number of comparisons */
7122  if( i * nvars > maxncliquevarscomp )
7123  break;
7124  }
7125  /* if we had to many variables fill up the cliquepartition and put each variable in a separate clique */
7126  for( ; i < nvars; ++i )
7127  {
7128  if( cliquepartition[i] == -1 )
7129  {
7130  cliquepartition[i] = *ncliques;
7131  ++(*ncliques);
7132  }
7133  }
7134 
7135  SCIPsetFreeBufferArray(scip->set, &cliquevalues);
7136  SCIPsetFreeBufferArray(scip->set, &cliquevars);
7137 
7138  return SCIP_OKAY;
7139 }
7140 
7141 /** calculates a partition of the given set of binary variables into cliques; takes into account independent clique components
7142  *
7143  * The algorithm performs the following steps:
7144  * - recomputes connected components of the clique table, if necessary
7145  * - computes a clique partition for every connected component greedily.
7146  * - relabels the resulting clique partition such that it satisfies the description below
7147  *
7148  * afterwards the output array contains one value for each variable, such that two variables got the same value iff they
7149  * were assigned to the same clique;
7150  * the first variable is always assigned to clique 0, and a variable can only be assigned to clique i if at least one of
7151  * the preceding variables was assigned to clique i-1;
7152  * for each clique at most 1 variables can be set to TRUE in a feasible solution;
7153  *
7154  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7155  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7156  *
7157  * @pre This method can be called if @p scip is in one of the following stages:
7158  * - \ref SCIP_STAGE_INITPRESOLVE
7159  * - \ref SCIP_STAGE_PRESOLVING
7160  * - \ref SCIP_STAGE_EXITPRESOLVE
7161  * - \ref SCIP_STAGE_PRESOLVED
7162  * - \ref SCIP_STAGE_SOLVING
7163  */
7165  SCIP*const scip, /**< SCIP data structure */
7166  SCIP_VAR**const vars, /**< binary variables in the clique from which at most one can be set to 1 */
7167  int const nvars, /**< number of variables in the clique */
7168  int*const cliquepartition, /**< array of length nvars to store the clique partition */
7169  int*const ncliques /**< pointer to store the number of cliques actually contained in the partition */
7170  )
7171 {
7172  SCIP_VAR** tmpvars;
7173 
7174  SCIP_VAR** sortedtmpvars;
7175  SCIP_Bool* tmpvalues;
7176  SCIP_Bool* sortedtmpvalues;
7177  int* componentlabels;
7178  int* sortedindices;
7179  int* componentstartposs;
7180  int i;
7181  int c;
7182 
7183  int ncomponents;
7184 
7185  assert(scip != NULL);
7186  assert(nvars == 0 || vars != NULL);
7187  assert(nvars == 0 || cliquepartition != NULL);
7188  assert(ncliques != NULL);
7189 
7190  SCIP_CALL( SCIPcheckStage(scip, "SCIPcalcCliquePartition", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
7191 
7192  if( nvars == 0 )
7193  {
7194  *ncliques = 0;
7195  return SCIP_OKAY;
7196  }
7197 
7198  /* early abort if no cliques are present */
7199  if( SCIPgetNCliques(scip) == 0 )
7200  {
7201  for( i = 0; i < nvars; ++i )
7202  cliquepartition[i] = i;
7203 
7204  *ncliques = nvars;
7205 
7206  return SCIP_OKAY;
7207  }
7208 
7209  SCIP_CALL( SCIPsetAllocBufferArray(scip->set, &tmpvalues, nvars) );
7210  SCIP_CALL( SCIPsetDuplicateBufferArray(scip->set, &tmpvars, vars, nvars) );
7211  SCIP_CALL( SCIPsetAllocBufferArray(scip->set, &componentlabels, nvars) );
7212  SCIP_CALL( SCIPsetAllocBufferArray(scip->set, &sortedindices, nvars) );
7213 
7214  /* initialize the tmpvalues array */
7215  for( i = nvars - 1; i >= 0; --i )
7216  {
7217  tmpvalues[i] = TRUE;
7218  cliquepartition[i] = -1;
7219  }
7220 
7221  /* get corresponding active problem variables */
7222  SCIP_CALL( SCIPvarsGetProbvarBinary(&tmpvars, &tmpvalues, nvars) );
7223 
7224  ncomponents = -1;
7225 
7226  /* update clique components if necessary */
7228  {
7229  SCIP_VAR** allvars;
7230  int nallbinvars;
7231  int nallintvars;
7232  int nallimplvars;
7233 
7234  SCIP_CALL( SCIPgetVarsData(scip, &allvars, NULL, &nallbinvars, &nallintvars, &nallimplvars, NULL) );
7235 
7236  SCIP_CALL( SCIPcliquetableComputeCliqueComponents(scip->cliquetable, scip->set, SCIPblkmem(scip), allvars, nallbinvars, nallintvars, nallimplvars) );
7237  }
7238 
7240 
7241  /* store the global clique component labels */
7242  for( i = 0; i < nvars; ++i )
7243  {
7244  if( SCIPvarIsActive(tmpvars[i]) )
7245  componentlabels[i] = SCIPcliquetableGetVarComponentIdx(scip->cliquetable, tmpvars[i]);
7246  else
7247  componentlabels[i] = -1;
7248  }
7249 
7250  /* relabel component labels order consistent as prerequisite for a stable sort */
7251  SCIP_CALL( relabelOrderConsistent(scip, componentlabels, nvars, &ncomponents) );
7252  assert(ncomponents >= 1);
7253  assert(ncomponents <= nvars);
7254 
7255  /* allocate storage array for the starting positions of the components */
7256  SCIP_CALL( SCIPsetAllocBufferArray(scip->set, &componentstartposs, ncomponents + 1) );
7257 
7258  /* stable sort the variables w.r.t. the component labels so that we can restrict the quadratic algorithm to the components */
7259  if( ncomponents > 1 )
7260  {
7261  SCIP_CALL( SCIPsetAllocBufferArray(scip->set, &sortedtmpvars, nvars) );
7262  SCIP_CALL( SCIPsetAllocBufferArray(scip->set, &sortedtmpvalues, nvars) );
7263  SCIP_CALL( labelSortStable(scip, tmpvars, componentlabels, sortedtmpvars, sortedindices, componentstartposs, nvars, ncomponents) );
7264 
7265  /* reassign the tmpvalues with respect to the sorting */
7266  for( i = 0; i < nvars; ++i )
7267  {
7268  assert(tmpvars[sortedindices[i]] == sortedtmpvars[i]);
7269  sortedtmpvalues[i] = tmpvalues[sortedindices[i]];
7270  }
7271  }
7272  else
7273  {
7274  /* if we have only one large connected component, skip the stable sorting and prepare the data differently */
7275  sortedtmpvars = tmpvars;
7276  sortedtmpvalues = tmpvalues;
7277  componentstartposs[0] = 0;
7278  componentstartposs[1] = nvars;
7279 
7280  /* sorted indices are the identity */
7281  for( i = 0; i < nvars; ++i )
7282  sortedindices[i] = i;
7283  }
7284 
7285  *ncliques = 0;
7286  /* calculate a greedy clique partition for each connected component */
7287  for( c = 0; c < ncomponents; ++c )
7288  {
7289  int* localcliquepartition;
7290  int nlocalcliques;
7291  int ncomponentvars;
7292  int l;
7293 
7294  /* extract the number of variables in this connected component */
7295  ncomponentvars = componentstartposs[c + 1] - componentstartposs[c];
7296  nlocalcliques = 0;
7297 
7298  /* allocate necessary memory to hold the intermediate component clique partition */
7299  SCIP_CALL( SCIPsetAllocBufferArray(scip->set, &localcliquepartition, ncomponentvars) );
7300 
7301  /* call greedy clique algorithm for all component variables */
7302  SCIP_CALL( calcCliquePartitionGreedy(scip, &(sortedtmpvars[componentstartposs[c]]), &(sortedtmpvalues[componentstartposs[c]]),
7303  ncomponentvars, localcliquepartition, &nlocalcliques) );
7304 
7305  assert(nlocalcliques >= 1);
7306  assert(nlocalcliques <= ncomponentvars);
7307 
7308  /* store the obtained clique partition with an offset of ncliques for the original variables */
7309  for( l = componentstartposs[c]; l < componentstartposs[c + 1]; ++l )
7310  {
7311  int origvaridx = sortedindices[l];
7312  assert(cliquepartition[origvaridx] == -1);
7313  assert(localcliquepartition[l - componentstartposs[c]] <= l - componentstartposs[c]);
7314  cliquepartition[origvaridx] = localcliquepartition[l - componentstartposs[c]] + (*ncliques);
7315  }
7316  *ncliques += nlocalcliques;
7317 
7318  /* free the local clique partition */
7319  SCIPsetFreeBufferArray(scip->set, &localcliquepartition);
7320  }
7321 
7322  /* except in the two trivial cases, we have to ensure the order consistency of the partition indices */
7323  if( ncomponents > 1 && ncomponents < nvars )
7324  {
7325  int partitionsize;
7326  SCIP_CALL( relabelOrderConsistent(scip, cliquepartition, nvars, &partitionsize) );
7327 
7328  assert(partitionsize == *ncliques);
7329  }
7330 
7331  if( ncomponents > 1 )
7332  {
7333  SCIPsetFreeBufferArray(scip->set, &sortedtmpvalues);
7334  SCIPsetFreeBufferArray(scip->set, &sortedtmpvars);
7335  }
7336 
7337  /* use the greedy algorithm as a whole to verify the result on small number of variables */
7338 #ifdef SCIP_DISABLED_CODE
7339  {
7340  int* debugcliquepartition;
7341  int ndebugcliques;
7342 
7343  SCIP_CALL( SCIPsetAllocBufferArray(scip->set, &debugcliquepartition, nvars) );
7344 
7345  /* call greedy clique algorithm for all component variables */
7346  SCIP_CALL( calcCliquePartitionGreedy(scip, tmpvars, tmpvalues, nvars, debugcliquepartition, &ndebugcliques) );
7347 
7348  /* loop and compare the traditional greedy clique with */
7349  for( i = 0; i < nvars; ++i )
7350  assert(i * nvars > MAXNCLIQUEVARSCOMP || cliquepartition[i] == debugcliquepartition[i]);
7351 
7352  SCIPsetFreeBufferArray(scip->set, &debugcliquepartition);
7353  }
7354 #endif
7355 
7356  /* free temporary memory */
7357  SCIPsetFreeBufferArray(scip->set, &componentstartposs);
7358  SCIPsetFreeBufferArray(scip->set, &sortedindices);
7359  SCIPsetFreeBufferArray(scip->set, &componentlabels);
7360  SCIPsetFreeBufferArray(scip->set, &tmpvars);
7361  SCIPsetFreeBufferArray(scip->set, &tmpvalues);
7362 
7363  return SCIP_OKAY;
7364 }
7365 
7366 /** calculates a partition of the given set of binary variables into negated cliques;
7367  * afterwards the output array contains one value for each variable, such that two variables got the same value iff they
7368  * were assigned to the same negated clique;
7369  * the first variable is always assigned to clique 0 and a variable can only be assigned to clique i if at least one of
7370  * the preceding variables was assigned to clique i-1;
7371  * for each clique with n_c variables at least n_c-1 variables can be set to TRUE in a feasible solution;
7372  *
7373  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7374  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7375  *
7376  * @pre This method can be called if @p scip is in one of the following stages:
7377  * - \ref SCIP_STAGE_INITPRESOLVE
7378  * - \ref SCIP_STAGE_PRESOLVING
7379  * - \ref SCIP_STAGE_EXITPRESOLVE
7380  * - \ref SCIP_STAGE_PRESOLVED
7381  * - \ref SCIP_STAGE_SOLVING
7382  */
7384  SCIP*const scip, /**< SCIP data structure */
7385  SCIP_VAR**const vars, /**< binary variables in the clique from which at most one can be set to 1 */
7386  int const nvars, /**< number of variables in the clique */
7387  int*const cliquepartition, /**< array of length nvars to store the clique partition */
7388  int*const ncliques /**< pointer to store the number of cliques actually contained in the partition */
7389  )
7390 {
7391  SCIP_VAR** negvars;
7392  int v;
7393 
7394  assert(scip != NULL);
7395  assert(cliquepartition != NULL || nvars == 0);
7396  assert(ncliques != NULL);
7397 
7398  if( nvars == 0 )
7399  {
7400  *ncliques = 0;
7401  return SCIP_OKAY;
7402  }
7403  assert(vars != NULL);
7404 
7405  /* allocate temporary memory */
7406  SCIP_CALL( SCIPsetAllocBufferArray(scip->set, &negvars, nvars) );
7407 
7408  /* get all negated variables */
7409  for( v = nvars - 1; v >= 0; --v )
7410  {
7411  SCIP_CALL( SCIPgetNegatedVar(scip, vars[v], &(negvars[v])) );
7412  }
7413 
7414  /* calculate cliques on negated variables, which are "negated" cliques on normal variables array */
7415  SCIP_CALL( SCIPcalcCliquePartition( scip, negvars, nvars, cliquepartition, ncliques) );
7416 
7417  /* free temporary memory */
7418  SCIPsetFreeBufferArray(scip->set, &negvars);
7419 
7420  return SCIP_OKAY;
7421 }
7422 
7423 
7424 /** force SCIP to clean up all cliques; cliques do not get automatically cleaned up after presolving. Use
7425  * this method to prevent inactive variables in cliques when retrieved via SCIPgetCliques()
7426  *
7427  * @return SCIP_OKAY if everything worked, otherwise a suitable error code is passed
7428  *
7429  * @pre This method can be called if @p scip is in one of the following stages:
7430  * - \ref SCIP_STAGE_TRANSFORMED
7431  * - \ref SCIP_STAGE_INITPRESOLVE
7432  * - \ref SCIP_STAGE_PRESOLVING
7433  * - \ref SCIP_STAGE_EXITPRESOLVE
7434  * - \ref SCIP_STAGE_PRESOLVED
7435  * - \ref SCIP_STAGE_INITSOLVE
7436  * - \ref SCIP_STAGE_SOLVING
7437  * - \ref SCIP_STAGE_SOLVED
7438  * - \ref SCIP_STAGE_EXITSOLVE
7439  */
7441  SCIP* scip, /**< SCIP data structure */
7442  SCIP_Bool* infeasible /**< pointer to store if cleanup detected infeasibility */
7443  )
7444 {
7445  int nlocalbdchgs;
7446  SCIP_Bool globalinfeasibility;
7447 
7448  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPcleanupCliques", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
7449 
7450  globalinfeasibility = FALSE;
7451  nlocalbdchgs = 0;
7452  SCIP_CALL( SCIPcliquetableCleanup(scip->cliquetable, scip->mem->probmem, scip->set, scip->stat, scip->transprob,
7453  scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, &nlocalbdchgs,
7454  &globalinfeasibility) );
7455 
7456  if( infeasible != NULL )
7457  *infeasible = globalinfeasibility;
7458 
7459  if( globalinfeasibility )
7461 
7462  return SCIP_OKAY;
7463 }
7464 
7465 /** gets the number of cliques in the clique table
7466  *
7467  * @return number of cliques in the clique table
7468  *
7469  * @note cliques do not get automatically cleaned up after presolving. Use SCIPcleanupCliques()
7470  * to prevent inactive variables in cliques when retrieved via SCIPgetCliques(). This might reduce the number of cliques
7471  *
7472  * @pre This method can be called if @p scip is in one of the following stages:
7473  * - \ref SCIP_STAGE_TRANSFORMED
7474  * - \ref SCIP_STAGE_INITPRESOLVE
7475  * - \ref SCIP_STAGE_PRESOLVING
7476  * - \ref SCIP_STAGE_EXITPRESOLVE
7477  * - \ref SCIP_STAGE_PRESOLVED
7478  * - \ref SCIP_STAGE_INITSOLVE
7479  * - \ref SCIP_STAGE_SOLVING
7480  * - \ref SCIP_STAGE_SOLVED
7481  * - \ref SCIP_STAGE_EXITSOLVE
7482  */
7484  SCIP* scip /**< SCIP data structure */
7485  )
7486 {
7487  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNCliques", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
7488 
7490 }
7491 
7492 /** gets the number of cliques created so far by the cliquetable
7493  *
7494  * @return number of cliques created so far by the cliquetable
7495  *
7496  * @note cliques do not get automatically cleaned up after presolving. Use SCIPcleanupCliques()
7497  * to prevent inactive variables in cliques when retrieved via SCIPgetCliques(). This might reduce the number of cliques
7498  *
7499  * @pre This method can be called if @p scip is in one of the following stages:
7500  * - \ref SCIP_STAGE_TRANSFORMED
7501  * - \ref SCIP_STAGE_INITPRESOLVE
7502  * - \ref SCIP_STAGE_PRESOLVING
7503  * - \ref SCIP_STAGE_EXITPRESOLVE
7504  * - \ref SCIP_STAGE_PRESOLVED
7505  * - \ref SCIP_STAGE_INITSOLVE
7506  * - \ref SCIP_STAGE_SOLVING
7507  * - \ref SCIP_STAGE_SOLVED
7508  * - \ref SCIP_STAGE_EXITSOLVE
7509  */
7511  SCIP* scip /**< SCIP data structure */
7512  )
7513 {
7514  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNCliquesCreated", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
7515 
7517 }
7518 
7519 /** gets the array of cliques in the clique table
7520  *
7521  * @return array of cliques in the clique table
7522  *
7523  * @note cliques do not get automatically cleaned up after presolving. Use SCIPcleanupCliques()
7524  * to prevent inactive variables in cliques when retrieved via SCIPgetCliques(). This might reduce the number of cliques
7525  *
7526  * @pre This method can be called if @p scip is in one of the following stages:
7527  * - \ref SCIP_STAGE_TRANSFORMED
7528  * - \ref SCIP_STAGE_INITPRESOLVE
7529  * - \ref SCIP_STAGE_PRESOLVING
7530  * - \ref SCIP_STAGE_EXITPRESOLVE
7531  * - \ref SCIP_STAGE_PRESOLVED
7532  * - \ref SCIP_STAGE_INITSOLVE
7533  * - \ref SCIP_STAGE_SOLVING
7534  * - \ref SCIP_STAGE_SOLVED
7535  * - \ref SCIP_STAGE_EXITSOLVE
7536  */
7538  SCIP* scip /**< SCIP data structure */
7539  )
7540 {
7541  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetCliques", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
7542 
7543  return SCIPcliquetableGetCliques(scip->cliquetable);
7544 }
7545 
7546 /** returns whether there is a clique that contains both given variable/value pairs;
7547  * the variables must be active binary variables;
7548  * if regardimplics is FALSE, only the cliques in the clique table are looked at;
7549  * if regardimplics is TRUE, both the cliques and the implications of the implication graph are regarded
7550  *
7551  * @return TRUE, if there is a clique that contains both variable/clique pairs; FALSE, otherwise
7552  *
7553  * @pre This method can be called if @p scip is in one of the following stages:
7554  * - \ref SCIP_STAGE_TRANSFORMED
7555  * - \ref SCIP_STAGE_INITPRESOLVE
7556  * - \ref SCIP_STAGE_PRESOLVING
7557  * - \ref SCIP_STAGE_EXITPRESOLVE
7558  * - \ref SCIP_STAGE_PRESOLVED
7559  * - \ref SCIP_STAGE_INITSOLVE
7560  * - \ref SCIP_STAGE_SOLVING
7561  * - \ref SCIP_STAGE_SOLVED
7562  * - \ref SCIP_STAGE_EXITSOLVE
7563  *
7564  * @note a variable with it's negated variable are NOT! in a clique
7565  * @note a variable with itself are in a clique
7566  */
7568  SCIP* scip, /**< SCIP data structure */
7569  SCIP_VAR* var1, /**< first variable */
7570  SCIP_Bool value1, /**< value of first variable */
7571  SCIP_VAR* var2, /**< second variable */
7572  SCIP_Bool value2, /**< value of second variable */
7573  SCIP_Bool regardimplics /**< should the implication graph also be searched for a clique? */
7574  )
7575 {
7576  assert(scip != NULL);
7577  assert(var1 != NULL);
7578  assert(var2 != NULL);
7579  assert(SCIPvarIsActive(var1));
7580  assert(SCIPvarIsActive(var2));
7581  assert(SCIPvarIsBinary(var1));
7582  assert(SCIPvarIsBinary(var2));
7583 
7584  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPhaveVarsCommonClique", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
7585 
7586  /* if both variables together have more cliques then actual cliques exist, then they have a common clique (in debug
7587  * mode we check this for correctness), otherwise we need to call the pairwise comparison method for these variables
7588  */
7589 #ifndef NDEBUG
7590  assert((SCIPvarGetNCliques(var1, value1) + SCIPvarGetNCliques(var2, value2) > SCIPcliquetableGetNCliques(scip->cliquetable)) ? SCIPvarsHaveCommonClique(var1, value1, var2, value2, FALSE) : TRUE);
7591 #endif
7592 
7593  return (SCIPvarGetNCliques(var1, value1) + SCIPvarGetNCliques(var2, value2) > SCIPcliquetableGetNCliques(scip->cliquetable)
7594  || SCIPvarsHaveCommonClique(var1, value1, var2, value2, regardimplics));
7595 }
7596 
7597 /** writes the clique graph to a gml file
7598  *
7599  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7600  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7601  *
7602  * @pre This method can be called if @p scip is in one of the following stages:
7603  * - \ref SCIP_STAGE_TRANSFORMED
7604  * - \ref SCIP_STAGE_INITPRESOLVE
7605  * - \ref SCIP_STAGE_PRESOLVING
7606  * - \ref SCIP_STAGE_EXITPRESOLVE
7607  * - \ref SCIP_STAGE_PRESOLVED
7608  * - \ref SCIP_STAGE_INITSOLVE
7609  * - \ref SCIP_STAGE_SOLVING
7610  * - \ref SCIP_STAGE_SOLVED
7611  * - \ref SCIP_STAGE_EXITSOLVE
7612  *
7613  * @note there can be duplicated arcs in the output file
7614  *
7615  * If @p writenodeweights is true, only nodes corresponding to variables that have a fractional value and only edges
7616  * between such nodes are written.
7617  */
7619  SCIP* scip, /**< SCIP data structure */
7620  const char* fname, /**< name of file */
7621  SCIP_Bool writenodeweights /**< should we write weights of nodes? */
7622  )
7623 {
7624  FILE* gmlfile;
7625  SCIP_HASHMAP* nodehashmap;
7626  SCIP_CLIQUE** cliques;
7627  SCIP_VAR** clqvars;
7628  SCIP_VAR** allvars;
7629  SCIP_Bool* clqvalues;
7630  char nodename[SCIP_MAXSTRLEN];
7631  int nallvars;
7632  int nbinvars;
7633  int nintvars;
7634  int nimplvars;
7635  int ncliques;
7636  int c;
7637  int v1;
7638  int v2;
7639  int id1;
7640  int id2;
7641 
7642  assert(scip != NULL);
7643  assert(fname != NULL);
7644 
7645  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPwriteCliqueGraph", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
7646 
7647  /* get all active variables */
7648  SCIP_CALL( SCIPgetVarsData(scip, &allvars, &nallvars, &nbinvars, &nintvars, &nimplvars, NULL) );
7649 
7650  /* no possible variables for cliques exist */
7651  if( nbinvars + nimplvars == 0 )
7652  return SCIP_OKAY;
7653 
7654  ncliques = SCIPgetNCliques(scip);
7655 
7656  /* no cliques and do not wont to check for binary implications */
7657  if( ncliques == 0 )
7658  return SCIP_OKAY;
7659 
7660  /* open gml file */
7661  gmlfile = fopen(fname, "w");
7662 
7663  if( gmlfile == NULL )
7664  {
7665  SCIPerrorMessage("cannot open graph file <%s>\n", fname);
7666  SCIPABORT();
7667  return SCIP_INVALIDDATA; /*lint !e527*/
7668  }
7669 
7670  /* create the hash map */
7671  SCIP_CALL_FINALLY( SCIPhashmapCreate(&nodehashmap, SCIPblkmem(scip), nbinvars+nimplvars), fclose(gmlfile) );
7672 
7673  /* write starting of gml file */
7674  SCIPgmlWriteOpening(gmlfile, TRUE);
7675 
7676  cliques = SCIPgetCliques(scip);
7677 
7678  /* write nodes and arcs for all cliques */
7679  for( c = ncliques - 1; c >= 0; --c )
7680  {
7681  clqvalues = SCIPcliqueGetValues(cliques[c]);
7682  clqvars = SCIPcliqueGetVars(cliques[c]);
7683 
7684  for( v1 = SCIPcliqueGetNVars(cliques[c]) - 1; v1 >= 0; --v1 )
7685  {
7686  id1 = clqvalues[v1] ? SCIPvarGetProbindex(clqvars[v1]) : (nallvars + SCIPvarGetProbindex(clqvars[v1]));
7687 
7688  /* if corresponding node was not added yet, add it */
7689  if( !SCIPhashmapExists(nodehashmap, (void*)(size_t)id1) )
7690  {
7691  assert(id1 >= 0);
7692  SCIP_CALL_FINALLY( SCIPhashmapInsertInt(nodehashmap, (void*)(size_t)id1, 1), fclose(gmlfile) ); /*lint !e571*/
7693 
7694  (void) SCIPsnprintf(nodename, SCIP_MAXSTRLEN, "%s%s", (id1 >= nallvars ? "~" : ""), SCIPvarGetName(clqvars[v1]));
7695 
7696  /* write new gml node for new variable */
7697  if ( writenodeweights )
7698  {
7699  if ( ! SCIPisFeasIntegral(scip, SCIPgetSolVal(scip, NULL, clqvars[v1])) )
7700  SCIPgmlWriteNodeWeight(gmlfile, (unsigned int)id1, nodename, NULL, NULL, NULL, SCIPgetSolVal(scip, NULL, clqvars[v1]));
7701  }
7702  else
7703  {
7704  SCIPgmlWriteNode(gmlfile, (unsigned int)id1, nodename, NULL, NULL, NULL);
7705  }
7706  }
7707 
7708  for( v2 = SCIPcliqueGetNVars(cliques[c]) - 1; v2 >= 0; --v2 )
7709  {
7710  if( v1 == v2 )
7711  continue;
7712 
7713  id2 = clqvalues[v2] ? SCIPvarGetProbindex(clqvars[v2]) : (nallvars + SCIPvarGetProbindex(clqvars[v2]));
7714 
7715  /* if corresponding node was not added yet, add it */
7716  if( !SCIPhashmapExists(nodehashmap, (void*)(size_t)id2) )
7717  {
7718  assert(id2 >= 0);
7719  SCIP_CALL_FINALLY( SCIPhashmapInsertInt(nodehashmap, (void*)(size_t)id2, 1), fclose(gmlfile) ); /*lint !e571*/
7720 
7721  (void) SCIPsnprintf(nodename, SCIP_MAXSTRLEN, "%s%s", (id2 >= nallvars ? "~" : ""), SCIPvarGetName(clqvars[v2]));
7722 
7723  /* write new gml node for new variable */
7724  if ( writenodeweights )
7725  {
7726  if ( ! SCIPisFeasIntegral(scip, SCIPgetSolVal(scip, NULL, clqvars[v2])) )
7727  SCIPgmlWriteNodeWeight(gmlfile, (unsigned int)id2, nodename, NULL, NULL, NULL, SCIPgetSolVal(scip, NULL, clqvars[v2]));
7728  }
7729  else
7730  {
7731  SCIPgmlWriteNode(gmlfile, (unsigned int)id2, nodename, NULL, NULL, NULL);
7732  }
7733  }
7734 
7735  /* write gml arc between resultant and operand */
7736  if ( ! writenodeweights || ! SCIPisFeasIntegral(scip, SCIPgetSolVal(scip, NULL, clqvars[v2])) )
7737  SCIPgmlWriteArc(gmlfile, (unsigned int)id1, (unsigned int)id2, NULL, NULL);
7738  }
7739  }
7740  }
7741 
7742  /* free the hash map */
7743  SCIPhashmapFree(&nodehashmap);
7744 
7745  SCIPgmlWriteClosing(gmlfile);
7746  fclose(gmlfile);
7747 
7748  return SCIP_OKAY;
7749 }
7750 
7751 /** Removes (irrelevant) variable from all its global structures, i.e. cliques, implications and variable bounds.
7752  * This is an advanced method which should be used with care.
7753  *
7754  * @return SCIP_OKAY if everything worked, otherwise a suitable error code is passed
7755  *
7756  * @pre This method can be called if @p scip is in one of the following stages:
7757  * - \ref SCIP_STAGE_TRANSFORMED
7758  * - \ref SCIP_STAGE_INITPRESOLVE
7759  * - \ref SCIP_STAGE_PRESOLVING
7760  * - \ref SCIP_STAGE_EXITPRESOLVE
7761  * - \ref SCIP_STAGE_PRESOLVED
7762  * - \ref SCIP_STAGE_INITSOLVE
7763  * - \ref SCIP_STAGE_SOLVING
7764  * - \ref SCIP_STAGE_SOLVED
7765  * - \ref SCIP_STAGE_EXITSOLVE
7766  */
7768  SCIP* scip, /**< SCIP data structure */
7769  SCIP_VAR* var /**< variable to remove from global structures */
7770  )
7771 {
7772  assert(scip != NULL);
7773 
7774  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPremoveVarFromGlobalStructures", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
7775 
7776  /* mark the variable as deletable from global structures - This is necessary for the delayed clean up of cliques */
7778 
7779  /* remove variable from all its cliques, implications, and variable bounds */
7781 
7782  return SCIP_OKAY;
7783 }
7784 
7785 /** sets the branch factor of the variable; this value can be used in the branching methods to scale the score
7786  * values of the variables; higher factor leads to a higher probability that this variable is chosen for branching
7787  *
7788  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7789  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7790  *
7791  * @pre This method can be called if @p scip is in one of the following stages:
7792  * - \ref SCIP_STAGE_PROBLEM
7793  * - \ref SCIP_STAGE_TRANSFORMING
7794  * - \ref SCIP_STAGE_TRANSFORMED
7795  * - \ref SCIP_STAGE_INITPRESOLVE
7796  * - \ref SCIP_STAGE_PRESOLVING
7797  * - \ref SCIP_STAGE_EXITPRESOLVE
7798  * - \ref SCIP_STAGE_PRESOLVED
7799  * - \ref SCIP_STAGE_SOLVING
7800  */
7802  SCIP* scip, /**< SCIP data structure */
7803  SCIP_VAR* var, /**< problem variable */
7804  SCIP_Real branchfactor /**< factor to weigh variable's branching score with */
7805  )
7806 {
7807  SCIP_CALL( SCIPcheckStage(scip, "SCIPchgVarBranchFactor", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
7808 
7809  SCIP_CALL( SCIPvarChgBranchFactor(var, scip->set, branchfactor) );
7810 
7811  return SCIP_OKAY;
7812 }
7813 
7814 /** scales the branch factor of the variable with the given value
7815  *
7816  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7817  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7818  *
7819  * @pre This method can be called if @p scip is in one of the following stages:
7820  * - \ref SCIP_STAGE_PROBLEM
7821  * - \ref SCIP_STAGE_TRANSFORMING
7822  * - \ref SCIP_STAGE_TRANSFORMED
7823  * - \ref SCIP_STAGE_INITPRESOLVE
7824  * - \ref SCIP_STAGE_PRESOLVING
7825  * - \ref SCIP_STAGE_EXITPRESOLVE
7826  * - \ref SCIP_STAGE_PRESOLVED
7827  * - \ref SCIP_STAGE_SOLVING
7828  */
7830  SCIP* scip, /**< SCIP data structure */
7831  SCIP_VAR* var, /**< problem variable */
7832  SCIP_Real scale /**< factor to scale variable's branching factor with */
7833  )
7834 {
7835  SCIP_CALL( SCIPcheckStage(scip, "SCIPscaleVarBranchFactor", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
7836 
7837  SCIP_CALL( SCIPvarChgBranchFactor(var, scip->set, scale * SCIPvarGetBranchFactor(var)) );
7838 
7839  return SCIP_OKAY;
7840 }
7841 
7842 /** adds the given value to the branch factor of the variable
7843  *
7844  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7845  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7846  *
7847  * @pre This method can be called if @p scip is in one of the following stages:
7848  * - \ref SCIP_STAGE_PROBLEM
7849  * - \ref SCIP_STAGE_TRANSFORMING
7850  * - \ref SCIP_STAGE_TRANSFORMED
7851  * - \ref SCIP_STAGE_INITPRESOLVE
7852  * - \ref SCIP_STAGE_PRESOLVING
7853  * - \ref SCIP_STAGE_EXITPRESOLVE
7854  * - \ref SCIP_STAGE_PRESOLVED
7855  * - \ref SCIP_STAGE_SOLVING
7856  */
7858  SCIP* scip, /**< SCIP data structure */
7859  SCIP_VAR* var, /**< problem variable */
7860  SCIP_Real addfactor /**< value to add to the branch factor of the variable */
7861  )
7862 {
7863  SCIP_CALL( SCIPcheckStage(scip, "SCIPaddVarBranchFactor", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
7864 
7865  SCIP_CALL( SCIPvarChgBranchFactor(var, scip->set, addfactor + SCIPvarGetBranchFactor(var)) );
7866 
7867  return SCIP_OKAY;
7868 }
7869 
7870 /** sets the branch priority of the variable; variables with higher branch priority are always preferred to variables
7871  * with lower priority in selection of branching variable
7872  *
7873  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7874  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7875  *
7876  * @pre This method can be called if @p scip is in one of the following stages:
7877  * - \ref SCIP_STAGE_PROBLEM
7878  * - \ref SCIP_STAGE_TRANSFORMING
7879  * - \ref SCIP_STAGE_TRANSFORMED
7880  * - \ref SCIP_STAGE_INITPRESOLVE
7881  * - \ref SCIP_STAGE_PRESOLVING
7882  * - \ref SCIP_STAGE_EXITPRESOLVE
7883  * - \ref SCIP_STAGE_PRESOLVED
7884  * - \ref SCIP_STAGE_SOLVING
7885  *
7886  * @note the default branching priority is 0
7887  */
7889  SCIP* scip, /**< SCIP data structure */
7890  SCIP_VAR* var, /**< problem variable */
7891  int branchpriority /**< branch priority of the variable */
7892  )
7893 {
7894  SCIP_CALL( SCIPcheckStage(scip, "SCIPchgVarBranchPriority", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
7895 
7896  assert( var->scip == scip );
7897 
7898  if( SCIPisTransformed(scip) )
7899  {
7900  assert(scip->branchcand != NULL);
7901 
7902  /* inform the pseudo branch candidates that the branch priority changes and change the branch priority */
7903  SCIP_CALL( SCIPbranchcandUpdateVarBranchPriority(scip->branchcand, scip->set, var, branchpriority) );
7904  }
7905  else
7906  {
7907  /* change the branching priority of the variable */
7908  SCIP_CALL( SCIPvarChgBranchPriority(var, branchpriority) );
7909  }
7910 
7911  return SCIP_OKAY;
7912 }
7913 
7914 /** changes the branch priority of the variable to the given value, if it is larger than the current priority
7915  *
7916  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7917  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7918  *
7919  * @pre This method can be called if @p scip is in one of the following stages:
7920  * - \ref SCIP_STAGE_PROBLEM
7921  * - \ref SCIP_STAGE_TRANSFORMING
7922  * - \ref SCIP_STAGE_TRANSFORMED
7923  * - \ref SCIP_STAGE_INITPRESOLVE
7924  * - \ref SCIP_STAGE_PRESOLVING
7925  * - \ref SCIP_STAGE_EXITPRESOLVE
7926  * - \ref SCIP_STAGE_PRESOLVED
7927  * - \ref SCIP_STAGE_SOLVING
7928  */
7930  SCIP* scip, /**< SCIP data structure */
7931  SCIP_VAR* var, /**< problem variable */
7932  int branchpriority /**< new branch priority of the variable, if it is larger than current priority */
7933  )
7934 {
7935  SCIP_CALL( SCIPcheckStage(scip, "SCIPupdateVarBranchPriority", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
7936 
7937  assert( var->scip == scip );
7938 
7939  if( branchpriority > SCIPvarGetBranchPriority(var) )
7940  {
7941  SCIP_CALL( SCIPvarChgBranchPriority(var, branchpriority) );
7942  }
7943 
7944  return SCIP_OKAY;
7945 }
7946 
7947 /** adds the given value to the branch priority of the variable
7948  *
7949  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7950  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7951  *
7952  * @pre This method can be called if @p scip is in one of the following stages:
7953  * - \ref SCIP_STAGE_PROBLEM
7954  * - \ref SCIP_STAGE_TRANSFORMING
7955  * - \ref SCIP_STAGE_TRANSFORMED
7956  * - \ref SCIP_STAGE_INITPRESOLVE
7957  * - \ref SCIP_STAGE_PRESOLVING
7958  * - \ref SCIP_STAGE_EXITPRESOLVE
7959  * - \ref SCIP_STAGE_PRESOLVED
7960  * - \ref SCIP_STAGE_SOLVING
7961  */
7963  SCIP* scip, /**< SCIP data structure */
7964  SCIP_VAR* var, /**< problem variable */
7965  int addpriority /**< value to add to the branch priority of the variable */
7966  )
7967 {
7968  SCIP_CALL( SCIPcheckStage(scip, "SCIPaddVarBranchPriority", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
7969 
7970  assert( var->scip == scip );
7971 
7972  SCIP_CALL( SCIPvarChgBranchPriority(var, addpriority + SCIPvarGetBranchPriority(var)) );
7973 
7974  return SCIP_OKAY;
7975 }
7976 
7977 /** sets the branch direction of the variable (-1: prefer downwards branch, 0: automatic selection, +1: prefer upwards
7978  * branch)
7979  *
7980  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7981  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7982  *
7983  * @pre This method can be called if @p scip is in one of the following stages:
7984  * - \ref SCIP_STAGE_PROBLEM
7985  * - \ref SCIP_STAGE_TRANSFORMING
7986  * - \ref SCIP_STAGE_TRANSFORMED
7987  * - \ref SCIP_STAGE_INITPRESOLVE
7988  * - \ref SCIP_STAGE_PRESOLVING
7989  * - \ref SCIP_STAGE_EXITPRESOLVE
7990  * - \ref SCIP_STAGE_PRESOLVED
7991  * - \ref SCIP_STAGE_SOLVING
7992  */
7994  SCIP* scip, /**< SCIP data structure */
7995  SCIP_VAR* var, /**< problem variable */
7996  SCIP_BRANCHDIR branchdirection /**< preferred branch direction of the variable (downwards, upwards, auto) */
7997  )
7998 {
7999  SCIP_CALL( SCIPcheckStage(scip, "SCIPchgVarBranchDirection", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
8000 
8001  assert( var->scip == scip );
8002 
8003  SCIP_CALL( SCIPvarChgBranchDirection(var, branchdirection) );
8004 
8005  return SCIP_OKAY;
8006 }
8007 
8008 /** tightens the variable bounds due a new variable type */
8009 static
8011  SCIP* scip, /**< SCIP data structure */
8012  SCIP_VAR* var, /**< variable to change the bound for */
8013  SCIP_VARTYPE vartype, /**< new type of variable */
8014  SCIP_Bool* infeasible /**< pointer to store whether an infeasibility was detected (, due to
8015  * integrality condition of the new variable type) */
8016  )
8017 {
8018  assert(scip != NULL);
8020  assert(scip->set->stage == SCIP_STAGE_PROBLEM || SCIPvarIsTransformed(var));
8021  assert(var->scip == scip);
8022 
8023  *infeasible = FALSE;
8024 
8025  /* adjusts bounds if the variable type changed form continuous to non-continuous (integral) */
8027  {
8028  SCIP_Bool tightened;
8029 
8030  /* we adjust variable bounds to integers first, since otherwise a later bound tightening with a fractional old
8031  * bound may give an assert because SCIP expects non-continuous variables to have non-fractional bounds
8032  *
8033  * we adjust bounds with a fractionality within [eps,feastol] only if the resulting bound change is a bound
8034  * tightening, because relaxing bounds may not be allowed
8035  */
8036  if( !SCIPisFeasIntegral(scip, SCIPvarGetLbGlobal(var)) ||
8038  )
8039  {
8040  SCIP_CALL( SCIPtightenVarLbGlobal(scip, var, SCIPfeasCeil(scip, SCIPvarGetLbGlobal(var)), TRUE, infeasible, &tightened) );
8041  if( *infeasible )
8042  return SCIP_OKAY;
8043 
8044  /* 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
8045  * 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
8046  */
8047  assert(tightened || SCIPisFeasLE(scip, SCIPvarGetUbGlobal(var), SCIPfeasCeil(scip, SCIPvarGetLbGlobal(var))));
8048  }
8049  if( !SCIPisFeasIntegral(scip, SCIPvarGetUbGlobal(var)) ||
8051  )
8052  {
8053  SCIP_CALL( SCIPtightenVarUbGlobal(scip, var, SCIPfeasFloor(scip, SCIPvarGetUbGlobal(var)), TRUE, infeasible, &tightened) );
8054  if( *infeasible )
8055  return SCIP_OKAY;
8056 
8057  assert(tightened || SCIPisFeasGE(scip, SCIPvarGetLbGlobal(var), SCIPfeasFloor(scip, SCIPvarGetUbGlobal(var))));
8058  }
8059  }
8060 
8061  return SCIP_OKAY;
8062 }
8063 
8064 /** changes type of variable in the problem;
8065  *
8066  * @warning This type change might change the variable array returned from SCIPgetVars() and SCIPgetVarsData();
8067  *
8068  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8069  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8070  *
8071  * @pre This method can be called if @p scip is in one of the following stages:
8072  * - \ref SCIP_STAGE_PROBLEM
8073  * - \ref SCIP_STAGE_TRANSFORMING
8074  * - \ref SCIP_STAGE_PRESOLVING
8075  *
8076  * @note If SCIP is already beyond the SCIP_STAGE_PROBLEM and a original variable is passed, the variable type of the
8077  * corresponding transformed variable is changed; the type of the original variable does not change
8078  *
8079  * @note If the type changes from a continuous variable to a non-continuous variable the bounds of the variable get
8080  * adjusted w.r.t. to integrality information
8081  */
8083  SCIP* scip, /**< SCIP data structure */
8084  SCIP_VAR* var, /**< variable to change the bound for */
8085  SCIP_VARTYPE vartype, /**< new type of variable */
8086  SCIP_Bool* infeasible /**< pointer to store whether an infeasibility was detected (, due to
8087  * integrality condition of the new variable type) */
8088  )
8089 {
8090  SCIP_CALL( SCIPcheckStage(scip, "SCIPchgVarType", FALSE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
8091 
8092  assert(var != NULL);
8093  assert(var->scip == scip);
8094 
8095  if( SCIPvarIsNegated(var) )
8096  {
8097  SCIPdebugMsg(scip, "upgrading type of negated variable <%s> from %d to %d\n", SCIPvarGetName(var), SCIPvarGetType(var), vartype);
8098  var = SCIPvarGetNegationVar(var);
8099  }
8100 #ifndef NDEBUG
8101  else
8102  {
8103  if( SCIPgetStage(scip) > SCIP_STAGE_PROBLEM )
8104  {
8105  SCIPdebugMsg(scip, "upgrading type of variable <%s> from %d to %d\n", SCIPvarGetName(var), SCIPvarGetType(var), vartype);
8106  }
8107  }
8108 #endif
8109 
8110  /* change variable type */
8111  switch( scip->set->stage )
8112  {
8113  case SCIP_STAGE_PROBLEM:
8114  assert(!SCIPvarIsTransformed(var));
8115 
8116  /* first adjust the variable due to new integrality information */
8117  SCIP_CALL( tightenBounds(scip, var, vartype, infeasible) );
8118 
8119  /* second change variable type */
8120  if( SCIPvarGetProbindex(var) >= 0 )
8121  {
8122  SCIP_CALL( SCIPprobChgVarType(scip->origprob, scip->mem->probmem, scip->set, scip->branchcand, scip->cliquetable, var, vartype) );
8123  }
8124  else
8125  {
8126  SCIP_CALL( SCIPvarChgType(var, vartype) );
8127  }
8128  break;
8129 
8130  case SCIP_STAGE_PRESOLVING:
8131  if( !SCIPvarIsTransformed(var) )
8132  {
8133  SCIP_VAR* transvar;
8134 
8135  SCIP_CALL( SCIPgetTransformedVar(scip, var, &transvar) );
8136  assert(transvar != NULL);
8137 
8138  /* recall method with transformed variable */
8139  SCIP_CALL( SCIPchgVarType(scip, transvar, vartype, infeasible) );
8140  return SCIP_OKAY;
8141  }
8142 
8143  /* first adjust the variable due to new integrality information */
8144  SCIP_CALL( tightenBounds(scip, var, vartype, infeasible) );
8145 
8146  /* second change variable type */
8147  if( SCIPvarGetProbindex(var) >= 0 )
8148  {
8149  SCIP_CALL( SCIPprobChgVarType(scip->transprob, scip->mem->probmem, scip->set, scip->branchcand, scip->cliquetable, var, vartype) );
8150  }
8151  else
8152  {
8153  SCIP_CALL( SCIPvarChgType(var, vartype) );
8154  }
8155  break;
8156 
8157  default:
8158  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
8159  return SCIP_INVALIDCALL;
8160  } /*lint !e788*/
8161 
8162  return SCIP_OKAY;
8163 }
8164 
8165 /** in problem creation and solving stage, both bounds of the variable are set to the given value;
8166  * in presolving stage, the variable is converted into a fixed variable, and bounds are changed respectively;
8167  * conversion into a fixed variable changes the vars array returned from SCIPgetVars() and SCIPgetVarsData(),
8168  * and also renders arrays returned from the SCIPvarGetImpl...() methods invalid
8169  *
8170  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8171  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8172  *
8173  * @pre This method can be called if @p scip is in one of the following stages:
8174  * - \ref SCIP_STAGE_PROBLEM
8175  * - \ref SCIP_STAGE_PRESOLVING
8176  * - \ref SCIP_STAGE_SOLVING
8177  */
8179  SCIP* scip, /**< SCIP data structure */
8180  SCIP_VAR* var, /**< variable to fix */
8181  SCIP_Real fixedval, /**< value to fix variable to */
8182  SCIP_Bool* infeasible, /**< pointer to store whether the fixing is infeasible */
8183  SCIP_Bool* fixed /**< pointer to store whether the fixing was performed (variable was unfixed) */
8184  )
8185 {
8186  assert(var != NULL);
8187  assert(infeasible != NULL);
8188  assert(fixed != NULL);
8189 
8190  SCIP_CALL( SCIPcheckStage(scip, "SCIPfixVar", FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
8191 
8192  *infeasible = FALSE;
8193  *fixed = FALSE;
8194 
8195  /* in the problem creation stage, modify the bounds as requested, independently from the current bounds */
8196  if( scip->set->stage != SCIP_STAGE_PROBLEM )
8197  {
8198  if( (SCIPvarGetType(var) != SCIP_VARTYPE_CONTINUOUS && !SCIPsetIsFeasIntegral(scip->set, fixedval))
8199  || SCIPsetIsFeasLT(scip->set, fixedval, SCIPvarGetLbLocal(var))
8200  || SCIPsetIsFeasGT(scip->set, fixedval, SCIPvarGetUbLocal(var)) )
8201  {
8202  *infeasible = TRUE;
8203  return SCIP_OKAY;
8204  }
8205  else if( SCIPvarGetStatus(var) == SCIP_VARSTATUS_FIXED )
8206  {
8207  *infeasible = !SCIPsetIsFeasEQ(scip->set, fixedval, SCIPvarGetLbLocal(var));
8208  return SCIP_OKAY;
8209  }
8210  }
8211  else
8212  assert(SCIPvarGetStatus(var) == SCIP_VARSTATUS_ORIGINAL);
8213 
8214  switch( scip->set->stage )
8215  {
8216  case SCIP_STAGE_PROBLEM:
8217  /* in the problem creation stage, modify the bounds as requested, independently from the current bounds;
8218  * we have to make sure, that the order of the bound changes does not intermediately produce an invalid
8219  * interval lb > ub
8220  */
8221  if( fixedval <= SCIPvarGetLbLocal(var) )
8222  {
8223  SCIP_CALL( SCIPchgVarLb(scip, var, fixedval) );
8224  SCIP_CALL( SCIPchgVarUb(scip, var, fixedval) );
8225  *fixed = TRUE;
8226  }
8227  else
8228  {
8229  SCIP_CALL( SCIPchgVarUb(scip, var, fixedval) );
8230  SCIP_CALL( SCIPchgVarLb(scip, var, fixedval) );
8231  *fixed = TRUE;
8232  }
8233  return SCIP_OKAY;
8234 
8235  case SCIP_STAGE_PRESOLVING:
8236  if( SCIPtreeGetCurrentDepth(scip->tree) == 0 )
8237  {
8238  SCIP_CALL( SCIPvarFix(var, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob,
8239  scip->primal, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable,
8240  fixedval, infeasible, fixed) );
8241  return SCIP_OKAY;
8242  }
8243  /*lint -fallthrough*/
8244  case SCIP_STAGE_SOLVING:
8245  if( SCIPsetIsFeasGT(scip->set, fixedval, SCIPvarGetLbLocal(var)) )
8246  {
8247  SCIP_CALL( SCIPchgVarLb(scip, var, fixedval) );
8248  *fixed = TRUE;
8249  }
8250  if( SCIPsetIsFeasLT(scip->set, fixedval, SCIPvarGetUbLocal(var)) )
8251  {
8252  SCIP_CALL( SCIPchgVarUb(scip, var, fixedval) );
8253  *fixed = TRUE;
8254  }
8255  return SCIP_OKAY;
8256 
8257  default:
8258  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
8259  return SCIP_INVALIDCALL;
8260  } /*lint !e788*/
8261 }
8262 
8263 /** From a given equality a*x + b*y == c, aggregates one of the variables and removes it from the set of
8264  * active problem variables. This changes the vars array returned from SCIPgetVars() and SCIPgetVarsData(),
8265  * and also renders the arrays returned from the SCIPvarGetImpl...() methods for the two variables invalid.
8266  * In the first step, the equality is transformed into an equality with active problem variables
8267  * a'*x' + b'*y' == c'. If x' == y', this leads to the detection of redundancy if a' == -b' and c' == 0,
8268  * of infeasibility, if a' == -b' and c' != 0, or to a variable fixing x' == c'/(a'+b') (and possible
8269  * infeasibility) otherwise.
8270  * In the second step, the variable to be aggregated is chosen among x' and y', prefering a less strict variable
8271  * type as aggregation variable (i.e. continuous variables are preferred over implicit integers, implicit integers
8272  * over integers, and integers over binaries). If none of the variables is continuous, it is tried to find an integer
8273  * aggregation (i.e. integral coefficients a'' and b'', such that a''*x' + b''*y' == c''). This can lead to
8274  * the detection of infeasibility (e.g. if c'' is fractional), or to a rejection of the aggregation (denoted by
8275  * aggregated == FALSE), if the resulting integer coefficients are too large and thus numerically instable.
8276  *
8277  * The output flags have the following meaning:
8278  * - infeasible: the problem is infeasible
8279  * - redundant: the equality can be deleted from the constraint set
8280  * - aggregated: the aggregation was successfully performed (the variables were not aggregated before)
8281  *
8282  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8283  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8284  *
8285  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_PRESOLVING
8286  */
8288  SCIP* scip, /**< SCIP data structure */
8289  SCIP_VAR* varx, /**< variable x in equality a*x + b*y == c */
8290  SCIP_VAR* vary, /**< variable y in equality a*x + b*y == c */
8291  SCIP_Real scalarx, /**< multiplier a in equality a*x + b*y == c */
8292  SCIP_Real scalary, /**< multiplier b in equality a*x + b*y == c */
8293  SCIP_Real rhs, /**< right hand side c in equality a*x + b*y == c */
8294  SCIP_Bool* infeasible, /**< pointer to store whether the aggregation is infeasible */
8295  SCIP_Bool* redundant, /**< pointer to store whether the equality is (now) redundant */
8296  SCIP_Bool* aggregated /**< pointer to store whether the aggregation was successful */
8297  )
8298 {
8299  SCIP_Real constantx;
8300  SCIP_Real constanty;
8301 
8302  assert(infeasible != NULL);
8303  assert(redundant != NULL);
8304  assert(aggregated != NULL);
8305 
8306  SCIP_CALL( SCIPcheckStage(scip, "SCIPaggregateVars", FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
8307 
8308  *infeasible = FALSE;
8309  *redundant = FALSE;
8310  *aggregated = FALSE;
8311 
8312  if( SCIPtreeProbing(scip->tree) )
8313  {
8314  SCIPerrorMessage("cannot aggregate variables during probing\n");
8315  return SCIP_INVALIDCALL;
8316  }
8317  assert(SCIPtreeGetCurrentDepth(scip->tree) == 0);
8318 
8319  /* do not perform aggregation if it is globally deactivated */
8320  if( scip->set->presol_donotaggr )
8321  return SCIP_OKAY;
8322 
8323  /* get the corresponding equality in active problem variable space:
8324  * transform both expressions "a*x + 0" and "b*y + 0" into problem variable space
8325  */
8326  constantx = 0.0;
8327  constanty = 0.0;
8328  SCIP_CALL( SCIPvarGetProbvarSum(&varx, scip->set, &scalarx, &constantx) );
8329  SCIP_CALL( SCIPvarGetProbvarSum(&vary, scip->set, &scalary, &constanty) );
8330 
8331  /* we cannot aggregate multi-aggregated variables */
8333  return SCIP_OKAY;
8334 
8335  /* move the constant to the right hand side to acquire the form "a'*x' + b'*y' == c'" */
8336  rhs -= (constantx + constanty);
8337 
8338  /* if a scalar is zero, treat the variable as fixed-to-zero variable */
8339  if( SCIPsetIsZero(scip->set, scalarx) )
8340  varx = NULL;
8341  if( SCIPsetIsZero(scip->set, scalary) )
8342  vary = NULL;
8343 
8344  /* capture the special cases that less than two variables are left, due to resolutions to a fixed variable or
8345  * to the same active variable
8346  */
8347  if( varx == NULL && vary == NULL )
8348  {
8349  /* both variables were resolved to fixed variables */
8350  *infeasible = !SCIPsetIsZero(scip->set, rhs);
8351  *redundant = TRUE;
8352  }
8353  else if( varx == NULL )
8354  {
8355  assert(SCIPsetIsZero(scip->set, scalarx));
8356  assert(!SCIPsetIsZero(scip->set, scalary));
8357 
8358  /* variable x was resolved to fixed variable: variable y can be fixed to c'/b' */
8359  SCIP_CALL( SCIPvarFix(vary, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob,
8360  scip->primal, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable,
8361  rhs/scalary, infeasible, aggregated) );
8362  *redundant = TRUE;
8363  }
8364  else if( vary == NULL )
8365  {
8366  assert(SCIPsetIsZero(scip->set, scalary));
8367  assert(!SCIPsetIsZero(scip->set, scalarx));
8368 
8369  /* variable y was resolved to fixed variable: variable x can be fixed to c'/a' */
8370  SCIP_CALL( SCIPvarFix(varx, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob,
8371  scip->primal, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable,
8372  rhs/scalarx, infeasible, aggregated) );
8373  *redundant = TRUE;
8374  }
8375  else if( varx == vary )
8376  {
8377  /* both variables were resolved to the same active problem variable: this variable can be fixed */
8378  scalarx += scalary;
8379  if( SCIPsetIsZero(scip->set, scalarx) )
8380  {
8381  /* left hand side of equality is zero: equality is potentially infeasible */
8382  *infeasible = !SCIPsetIsZero(scip->set, rhs);
8383  }
8384  else
8385  {
8386  /* sum of scalars is not zero: fix variable x' == y' to c'/(a'+b') */
8387  SCIP_CALL( SCIPvarFix(varx, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob,
8388  scip->primal, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable,
8389  rhs/scalarx, infeasible, aggregated) );
8390  }
8391  *redundant = TRUE;
8392  }
8393  else
8394  {
8395  /* both variables are different active problem variables, and both scalars are non-zero: try to aggregate them */
8396  SCIP_CALL( SCIPvarTryAggregateVars(scip->set, scip->mem->probmem, scip->stat, scip->transprob, scip->origprob,
8397  scip->primal, scip->tree, scip->reopt, scip->lp, scip->cliquetable, scip->branchcand, scip->eventfilter,
8398  scip->eventqueue, varx, vary, scalarx, scalary, rhs, infeasible, aggregated) );
8399  *redundant = *aggregated;
8400  }
8401 
8402  return SCIP_OKAY;
8403 }
8404 
8405 /** converts variable into multi-aggregated variable; this changes the variable array returned from
8406  * SCIPgetVars() and SCIPgetVarsData();
8407  *
8408  * @warning The integrality condition is not checked anymore on the multi-aggregated variable. You must not
8409  * multi-aggregate an integer variable without being sure, that integrality on the aggregation variables
8410  * implies integrality on the aggregated variable.
8411  *
8412  * The output flags have the following meaning:
8413  * - infeasible: the problem is infeasible
8414  * - aggregated: the aggregation was successfully performed (the variables were not aggregated before)
8415  *
8416  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8417  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8418  *
8419  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_PRESOLVING
8420  */
8422  SCIP* scip, /**< SCIP data structure */
8423  SCIP_VAR* var, /**< variable x to aggregate */
8424  int naggvars, /**< number n of variables in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
8425  SCIP_VAR** aggvars, /**< variables y_i in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
8426  SCIP_Real* scalars, /**< multipliers a_i in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
8427  SCIP_Real constant, /**< constant shift c in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
8428  SCIP_Bool* infeasible, /**< pointer to store whether the aggregation is infeasible */
8429  SCIP_Bool* aggregated /**< pointer to store whether the aggregation was successful */
8430  )
8431 {
8432  SCIP_CALL( SCIPcheckStage(scip, "SCIPmultiaggregateVar", FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
8433 
8434  assert(var->scip == scip);
8435 
8436  if( SCIPtreeProbing(scip->tree) )
8437  {
8438  SCIPerrorMessage("cannot multi-aggregate variables during probing\n");
8439  return SCIP_INVALIDCALL;
8440  }
8441  assert(SCIPtreeGetCurrentDepth(scip->tree) == 0);
8442 
8443  SCIP_CALL( SCIPvarMultiaggregate(var, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob,
8444  scip->primal, scip->tree, scip->reopt, scip->lp, scip->cliquetable, scip->branchcand, scip->eventfilter,
8445  scip->eventqueue, naggvars, aggvars, scalars, constant, infeasible, aggregated) );
8446 
8447  return SCIP_OKAY;
8448 }
8449 
8450 /** returns whether aggregation of variables is not allowed */
8452  SCIP* scip /**< SCIP data structure */
8453  )
8454 {
8455  assert(scip != NULL);
8456 
8457  return scip->set->presol_donotaggr;
8458 }
8459 
8460 /** returns whether multi-aggregation is disabled */
8462  SCIP* scip /**< SCIP data structure */
8463  )
8464 {
8465  assert(scip != NULL);
8466 
8467  return scip->set->presol_donotmultaggr;
8468 }
8469 
8470 /** returns whether variable is not allowed to be multi-aggregated */
8472  SCIP* scip, /**< SCIP data structure */
8473  SCIP_VAR* var /**< variable x to aggregate */
8474  )
8475 {
8476  assert(scip != NULL);
8477  assert(var != NULL);
8478  assert(var->scip == scip);
8479 
8480  return scip->set->presol_donotmultaggr || SCIPvarDoNotMultaggr(var);
8481 }
8482 
8483 /** returns whether dual reductions are allowed during propagation and presolving
8484  *
8485  * @note A reduction is called dual, if it may discard feasible solutions, but leaves at least one optimal solution
8486  * intact. Often such reductions are based on analyzing the objective function, reduced costs, and/or dual LPs.
8487  */
8489  SCIP* scip /**< SCIP data structure */
8490  )
8491 {
8492  assert(scip != NULL);
8493 
8494  return !scip->set->reopt_enable && scip->set->misc_allowdualreds;
8495 }
8496 
8497 /** returns whether propagation w.r.t. current objective is allowed */
8499  SCIP* scip /**< SCIP data structure */
8500  )
8501 {
8502  assert(scip != NULL);
8503 
8504  return !scip->set->reopt_enable && scip->set->misc_allowobjprop;
8505 }
8506 
8507 /** marks the variable that it must not be multi-aggregated
8508  *
8509  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8510  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8511  *
8512  * @pre This method can be called if @p scip is in one of the following stages:
8513  * - \ref SCIP_STAGE_INIT
8514  * - \ref SCIP_STAGE_PROBLEM
8515  * - \ref SCIP_STAGE_TRANSFORMING
8516  * - \ref SCIP_STAGE_TRANSFORMED
8517  * - \ref SCIP_STAGE_INITPRESOLVE
8518  * - \ref SCIP_STAGE_PRESOLVING
8519  * - \ref SCIP_STAGE_EXITPRESOLVE
8520  *
8521  * @note There exists no "unmark" method since it has to be ensured that if a plugin requires that a variable is not
8522  * multi-aggregated that this is will be the case.
8523  */
8525  SCIP* scip, /**< SCIP data structure */
8526  SCIP_VAR* var /**< variable to delete */
8527  )
8528 {
8529  assert(scip != NULL);
8530  assert(var != NULL);
8531  assert(var->scip == scip);
8532 
8533  SCIP_CALL( SCIPcheckStage(scip, "SCIPmarkDoNotMultaggrVar", TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE) );
8534 
8536 
8537  return SCIP_OKAY;
8538 }
8539 
8540 /** enables the collection of statistics for a variable
8541  *
8542  * @pre This method can be called if @p scip is in one of the following stages:
8543  * - \ref SCIP_STAGE_PROBLEM
8544  * - \ref SCIP_STAGE_INITPRESOLVE
8545  * - \ref SCIP_STAGE_PRESOLVING
8546  * - \ref SCIP_STAGE_EXITPRESOLVE
8547  * - \ref SCIP_STAGE_SOLVING
8548  * - \ref SCIP_STAGE_SOLVED
8549  */
8551  SCIP* scip /**< SCIP data structure */
8552  )
8553 {
8554  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPenableVarHistory", FALSE, TRUE, FALSE, FALSE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
8555 
8557 }
8558 
8559 /** disables the collection of any statistic for a variable
8560  *
8561  * @pre This method can be called if @p scip is in one of the following stages:
8562  * - \ref SCIP_STAGE_PROBLEM
8563  * - \ref SCIP_STAGE_INITPRESOLVE
8564  * - \ref SCIP_STAGE_PRESOLVING
8565  * - \ref SCIP_STAGE_EXITPRESOLVE
8566  * - \ref SCIP_STAGE_SOLVING
8567  * - \ref SCIP_STAGE_SOLVED
8568  */
8570  SCIP* scip /**< SCIP data structure */
8571  )
8572 {
8573  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPdisableVarHistory", FALSE, TRUE, FALSE, FALSE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
8574 
8576 }
8577 
8578 /** updates the pseudo costs of the given variable and the global pseudo costs after a change of "solvaldelta" in the
8579  * variable's solution value and resulting change of "objdelta" in the in the LP's objective value;
8580  * the update is ignored, if the objective value difference is infinite
8581  *
8582  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8583  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8584  *
8585  * @pre This method can be called if @p scip is in one of the following stages:
8586  * - \ref SCIP_STAGE_SOLVING
8587  * - \ref SCIP_STAGE_SOLVED
8588  */
8590  SCIP* scip, /**< SCIP data structure */
8591  SCIP_VAR* var, /**< problem variable */
8592  SCIP_Real solvaldelta, /**< difference of variable's new LP value - old LP value */
8593  SCIP_Real objdelta, /**< difference of new LP's objective value - old LP's objective value */
8594  SCIP_Real weight /**< weight in (0,1] of this update in pseudo cost sum */
8595  )
8596 {
8597  SCIP_CALL( SCIPcheckStage(scip, "SCIPupdateVarPseudocost", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
8598 
8599  if( !SCIPsetIsInfinity(scip->set, 2*objdelta) ) /* differences infinity - eps should also be treated as infinity */
8600  {
8601  if( scip->set->branch_divingpscost || (!scip->lp->diving && !SCIPtreeProbing(scip->tree)) )
8602  {
8603  SCIP_CALL( SCIPvarUpdatePseudocost(var, scip->set, scip->stat, solvaldelta, objdelta, weight) );
8604  }
8605  }
8606 
8607  return SCIP_OKAY;
8608 }
8609 
8610 /** gets the variable's pseudo cost value for the given change of the variable's LP value
8611  *
8612  * @return the variable's pseudo cost value for the given change of the variable's LP value
8613  *
8614  * @pre This method can be called if @p scip is in one of the following stages:
8615  * - \ref SCIP_STAGE_INITPRESOLVE
8616  * - \ref SCIP_STAGE_PRESOLVING
8617  * - \ref SCIP_STAGE_EXITPRESOLVE
8618  * - \ref SCIP_STAGE_PRESOLVED
8619  * - \ref SCIP_STAGE_INITSOLVE
8620  * - \ref SCIP_STAGE_SOLVING
8621  * - \ref SCIP_STAGE_SOLVED
8622  */
8624  SCIP* scip, /**< SCIP data structure */
8625  SCIP_VAR* var, /**< problem variable */
8626  SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
8627  )
8628 {
8629  assert( var->scip == scip );
8630 
8631  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarPseudocostVal", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
8632 
8633  return SCIPvarGetPseudocost(var, scip->stat, solvaldelta);
8634 }
8635 
8636 /** gets the variable's pseudo cost value for the given change of the variable's LP value,
8637  * only using the pseudo cost information of the current run
8638  *
8639  * @return the variable's pseudo cost value for the given change of the variable's LP value,
8640  * only using the pseudo cost information of the current run
8641  *
8642  * @pre This method can be called if @p scip is in one of the following stages:
8643  * - \ref SCIP_STAGE_INITPRESOLVE
8644  * - \ref SCIP_STAGE_PRESOLVING
8645  * - \ref SCIP_STAGE_EXITPRESOLVE
8646  * - \ref SCIP_STAGE_PRESOLVED
8647  * - \ref SCIP_STAGE_INITSOLVE
8648  * - \ref SCIP_STAGE_SOLVING
8649  * - \ref SCIP_STAGE_SOLVED
8650  */
8652  SCIP* scip, /**< SCIP data structure */
8653  SCIP_VAR* var, /**< problem variable */
8654  SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
8655  )
8656 {
8657  assert( var->scip == scip );
8658 
8659  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarPseudocostValCurrentRun", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
8660 
8661  return SCIPvarGetPseudocostCurrentRun(var, scip->stat, solvaldelta);
8662 }
8663 
8664 /** gets the variable's pseudo cost value for the given direction
8665  *
8666  * @return the variable's pseudo cost value for the given direction
8667  *
8668  * @pre This method can be called if @p scip is in one of the following stages:
8669  * - \ref SCIP_STAGE_INITPRESOLVE
8670  * - \ref SCIP_STAGE_PRESOLVING
8671  * - \ref SCIP_STAGE_EXITPRESOLVE
8672  * - \ref SCIP_STAGE_PRESOLVED
8673  * - \ref SCIP_STAGE_INITSOLVE
8674  * - \ref SCIP_STAGE_SOLVING
8675  * - \ref SCIP_STAGE_SOLVED
8676  */
8678  SCIP* scip, /**< SCIP data structure */
8679  SCIP_VAR* var, /**< problem variable */
8680  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
8681  )
8682 {
8683  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarPseudocost", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
8684  assert(dir == SCIP_BRANCHDIR_DOWNWARDS || dir == SCIP_BRANCHDIR_UPWARDS);
8685  assert(var->scip == scip);
8686 
8687  return SCIPvarGetPseudocost(var, scip->stat, dir == SCIP_BRANCHDIR_DOWNWARDS ? -1.0 : 1.0);
8688 }
8689 
8690 /** gets the variable's pseudo cost value for the given direction,
8691  * only using the pseudo cost information of the current run
8692  *
8693  * @return the variable's pseudo cost value for the given direction,
8694  * only using the pseudo cost information of the current run
8695  *
8696  * @pre This method can be called if @p scip is in one of the following stages:
8697  * - \ref SCIP_STAGE_INITPRESOLVE
8698  * - \ref SCIP_STAGE_PRESOLVING
8699  * - \ref SCIP_STAGE_EXITPRESOLVE
8700  * - \ref SCIP_STAGE_PRESOLVED
8701  * - \ref SCIP_STAGE_INITSOLVE
8702  * - \ref SCIP_STAGE_SOLVING
8703  * - \ref SCIP_STAGE_SOLVED
8704  */
8706  SCIP* scip, /**< SCIP data structure */
8707  SCIP_VAR* var, /**< problem variable */
8708  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
8709  )
8710 {
8711  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarPseudocostCurrentRun", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
8712  assert(dir == SCIP_BRANCHDIR_DOWNWARDS || dir == SCIP_BRANCHDIR_UPWARDS);
8713  assert(var->scip == scip);
8714 
8715  return SCIPvarGetPseudocostCurrentRun(var, scip->stat, dir == SCIP_BRANCHDIR_DOWNWARDS ? -1.0 : 1.0);
8716 }
8717 
8718 /** gets the variable's (possible fractional) number of pseudo cost updates for the given direction
8719  *
8720  * @return the variable's (possible fractional) number of pseudo cost updates for the given direction
8721  *
8722  * @pre This method can be called if @p scip is in one of the following stages:
8723  * - \ref SCIP_STAGE_INITPRESOLVE
8724  * - \ref SCIP_STAGE_PRESOLVING
8725  * - \ref SCIP_STAGE_EXITPRESOLVE
8726  * - \ref SCIP_STAGE_PRESOLVED
8727  * - \ref SCIP_STAGE_INITSOLVE
8728  * - \ref SCIP_STAGE_SOLVING
8729  * - \ref SCIP_STAGE_SOLVED
8730  */
8732  SCIP* scip, /**< SCIP data structure */
8733  SCIP_VAR* var, /**< problem variable */
8734  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
8735  )
8736 {
8737  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarPseudocostCount", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
8738  assert(dir == SCIP_BRANCHDIR_DOWNWARDS || dir == SCIP_BRANCHDIR_UPWARDS);
8739  assert(var->scip == scip);
8740 
8741  return SCIPvarGetPseudocostCount(var, dir);
8742 }
8743 
8744 /** gets the variable's (possible fractional) number of pseudo cost updates for the given direction,
8745  * only using the pseudo cost information of the current run
8746  *
8747  * @return the variable's (possible fractional) number of pseudo cost updates for the given direction,
8748  * only using the pseudo cost information of the current run
8749  *
8750  * @pre This method can be called if @p scip is in one of the following stages:
8751  * - \ref SCIP_STAGE_INITPRESOLVE
8752  * - \ref SCIP_STAGE_PRESOLVING
8753  * - \ref SCIP_STAGE_EXITPRESOLVE
8754  * - \ref SCIP_STAGE_PRESOLVED
8755  * - \ref SCIP_STAGE_INITSOLVE
8756  * - \ref SCIP_STAGE_SOLVING
8757  * - \ref SCIP_STAGE_SOLVED
8758  */
8760  SCIP* scip, /**< SCIP data structure */
8761  SCIP_VAR* var, /**< problem variable */
8762  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
8763  )
8764 {
8765  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarPseudocostCountCurrentRun", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
8766  assert(dir == SCIP_BRANCHDIR_DOWNWARDS || dir == SCIP_BRANCHDIR_UPWARDS);
8767  assert(var->scip == scip);
8768 
8769  return SCIPvarGetPseudocostCountCurrentRun(var, dir);
8770 }
8771 
8772 /** get pseudo cost variance of the variable, either for entire solve or only for current branch and bound run
8773  *
8774  * @return returns the (corrected) variance of pseudo code information collected so far.
8775  *
8776  * @pre This method can be called if @p scip is in one of the following stages:
8777  * - \ref SCIP_STAGE_INITPRESOLVE
8778  * - \ref SCIP_STAGE_PRESOLVING
8779  * - \ref SCIP_STAGE_EXITPRESOLVE
8780  * - \ref SCIP_STAGE_PRESOLVED
8781  * - \ref SCIP_STAGE_INITSOLVE
8782  * - \ref SCIP_STAGE_SOLVING
8783  * - \ref SCIP_STAGE_SOLVED
8784  */
8786  SCIP* scip, /**< SCIP data structure */
8787  SCIP_VAR* var, /**< problem variable */
8788  SCIP_BRANCHDIR dir, /**< branching direction (downwards, or upwards) */
8789  SCIP_Bool onlycurrentrun /**< only for pseudo costs of current branch and bound run */
8790  )
8791 {
8792  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarPseudocostVariance", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
8793  assert(dir == SCIP_BRANCHDIR_DOWNWARDS || dir == SCIP_BRANCHDIR_UPWARDS);
8794  assert(var->scip == scip);
8795 
8796  return SCIPvarGetPseudocostVariance(var, dir, onlycurrentrun);
8797 }
8798 
8799 /** calculates a confidence bound for this variable under the assumption of normally distributed pseudo costs
8800  *
8801  * The confidence bound \f$ \theta \geq 0\f$ denotes the interval borders \f$ [X - \theta, \ X + \theta]\f$, which contains
8802  * the true pseudo costs of the variable, i.e., the expected value of the normal distribution, with a probability
8803  * of 2 * clevel - 1.
8804  *
8805  * @return value of confidence bound for this variable
8806  */
8808  SCIP* scip, /**< SCIP data structure */
8809  SCIP_VAR* var, /**< variable in question */
8810  SCIP_BRANCHDIR dir, /**< the branching direction for the confidence bound */
8811  SCIP_Bool onlycurrentrun, /**< should only the current run be taken into account */
8812  SCIP_CONFIDENCELEVEL clevel /**< confidence level for the interval */
8813  )
8814 {
8815  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPcalculatePscostConfidenceBound", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
8816 
8817  return SCIPvarCalcPscostConfidenceBound(var, scip->set, dir, onlycurrentrun, clevel);
8818 }
8819 
8820 /** check if variable pseudo-costs have a significant difference in location. The significance depends on
8821  * the choice of \p clevel and on the kind of tested hypothesis. The one-sided hypothesis, which
8822  * should be rejected, is that fracy * mu_y >= fracx * mu_x, where mu_y and mu_x denote the
8823  * unknown location means of the underlying pseudo-cost distributions of x and y.
8824  *
8825  * This method is applied best if variable x has a better pseudo-cost score than y. The method hypothesizes that y were actually
8826  * better than x (despite the current information), meaning that y can be expected to yield branching
8827  * decisions as least as good as x in the long run. If the method returns TRUE, the current history information is
8828  * sufficient to safely rely on the alternative hypothesis that x yields indeed a better branching score (on average)
8829  * than y.
8830  *
8831  * @note The order of x and y matters for the one-sided hypothesis
8832  *
8833  * @note set \p onesided to FALSE if you are not sure which variable is better. The hypothesis tested then reads
8834  * fracy * mu_y == fracx * mu_x vs the alternative hypothesis fracy * mu_y != fracx * mu_x.
8835  *
8836  * @return TRUE if the hypothesis can be safely rejected at the given confidence level
8837  */
8839  SCIP* scip, /**< SCIP data structure */
8840  SCIP_VAR* varx, /**< variable x */
8841  SCIP_Real fracx, /**< the fractionality of variable x */
8842  SCIP_VAR* vary, /**< variable y */
8843  SCIP_Real fracy, /**< the fractionality of variable y */
8844  SCIP_BRANCHDIR dir, /**< branching direction */
8845  SCIP_CONFIDENCELEVEL clevel, /**< confidence level for rejecting hypothesis */
8846  SCIP_Bool onesided /**< should a one-sided hypothesis y >= x be tested? */
8847  )
8848 {
8849  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPsignificantVarPscostDifference", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
8850 
8851  return SCIPvarSignificantPscostDifference(scip->set, scip->stat, varx, fracx, vary, fracy, dir, clevel, onesided);
8852 }
8853 
8854 /** tests at a given confidence level whether the variable pseudo-costs only have a small probability to
8855  * exceed a \p threshold. This is useful to determine if past observations provide enough evidence
8856  * to skip an expensive strong-branching step if there is already a candidate that has been proven to yield an improvement
8857  * of at least \p threshold.
8858  *
8859  * @note use \p clevel to adjust the level of confidence. For SCIP_CONFIDENCELEVEL_MIN, the method returns TRUE if
8860  * the estimated probability to exceed \p threshold is less than 25 %.
8861  *
8862  * @see SCIP_Confidencelevel for a list of available levels. The used probability limits refer to the one-sided levels
8863  * of confidence.
8864  *
8865  * @return TRUE if the variable pseudo-cost probabilistic model is likely to be smaller than \p threshold
8866  * at the given confidence level \p clevel.
8867  */
8869  SCIP* scip, /**< SCIP data structure */
8870  SCIP_VAR* var, /**< variable x */
8871  SCIP_Real frac, /**< the fractionality of variable x */
8872  SCIP_Real threshold, /**< the threshold to test against */
8873  SCIP_BRANCHDIR dir, /**< branching direction */
8874  SCIP_CONFIDENCELEVEL clevel /**< confidence level for rejecting hypothesis */
8875  )
8876 {
8877  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPpscostThresholdProbabilityTest", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
8878 
8879  return SCIPvarPscostThresholdProbabilityTest(scip->set, scip->stat, var, frac, threshold, dir, clevel);
8880 }
8881 
8882 /** check if the current pseudo cost relative error in a direction violates the given threshold. The Relative
8883  * Error is calculated at a specific confidence level
8884  *
8885  * @return TRUE if relative error in variable pseudo costs is smaller than \p threshold
8886  */
8888  SCIP* scip, /**< SCIP data structure */
8889  SCIP_VAR* var, /**< variable in question */
8890  SCIP_Real threshold, /**< threshold for relative errors to be considered reliable (enough) */
8891  SCIP_CONFIDENCELEVEL clevel /**< a given confidence level */
8892  )
8893 {
8894  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPisVarPscostRelerrorReliable", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
8895 
8896  return SCIPvarIsPscostRelerrorReliable(var, scip->set, scip->stat, threshold, clevel);
8897 }
8898 
8899 /** gets the variable's pseudo cost score value for the given LP solution value
8900  *
8901  * @return the variable's pseudo cost score value for the given LP solution value
8902  *
8903  * @pre This method can be called if @p scip is in one of the following stages:
8904  * - \ref SCIP_STAGE_INITPRESOLVE
8905  * - \ref SCIP_STAGE_PRESOLVING
8906  * - \ref SCIP_STAGE_EXITPRESOLVE
8907  * - \ref SCIP_STAGE_PRESOLVED
8908  * - \ref SCIP_STAGE_INITSOLVE
8909  * - \ref SCIP_STAGE_SOLVING
8910  * - \ref SCIP_STAGE_SOLVED
8911  */
8913  SCIP* scip, /**< SCIP data structure */
8914  SCIP_VAR* var, /**< problem variable */
8915  SCIP_Real solval /**< variable's LP solution value */
8916  )
8917 {
8918  SCIP_Real downsol;
8919  SCIP_Real upsol;
8920  SCIP_Real pscostdown;
8921  SCIP_Real pscostup;
8922 
8923  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarPseudocostScore", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
8924 
8925  assert( var->scip == scip );
8926 
8927  downsol = SCIPsetFeasCeil(scip->set, solval-1.0);
8928  upsol = SCIPsetFeasFloor(scip->set, solval+1.0);
8929  pscostdown = SCIPvarGetPseudocost(var, scip->stat, downsol-solval);
8930  pscostup = SCIPvarGetPseudocost(var, scip->stat, upsol-solval);
8931 
8932  return SCIPbranchGetScore(scip->set, var, pscostdown, pscostup);
8933 }
8934 
8935 /** gets the variable's pseudo cost score value for the given LP solution value,
8936  * only using the pseudo cost information of the current run
8937  *
8938  * @return the variable's pseudo cost score value for the given LP solution value,
8939  * only using the pseudo cost information of the current run
8940  *
8941  * @pre This method can be called if @p scip is in one of the following stages:
8942  * - \ref SCIP_STAGE_INITPRESOLVE
8943  * - \ref SCIP_STAGE_PRESOLVING
8944  * - \ref SCIP_STAGE_EXITPRESOLVE
8945  * - \ref SCIP_STAGE_PRESOLVED
8946  * - \ref SCIP_STAGE_INITSOLVE
8947  * - \ref SCIP_STAGE_SOLVING
8948  * - \ref SCIP_STAGE_SOLVED
8949  */
8951  SCIP* scip, /**< SCIP data structure */
8952  SCIP_VAR* var, /**< problem variable */
8953  SCIP_Real solval /**< variable's LP solution value */
8954  )
8955 {
8956  SCIP_Real downsol;
8957  SCIP_Real upsol;
8958  SCIP_Real pscostdown;
8959  SCIP_Real pscostup;
8960 
8961  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarPseudocostScoreCurrentRun", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
8962 
8963  assert( var->scip == scip );
8964 
8965  downsol = SCIPsetFeasCeil(scip->set, solval-1.0);
8966  upsol = SCIPsetFeasFloor(scip->set, solval+1.0);
8967  pscostdown = SCIPvarGetPseudocostCurrentRun(var, scip->stat, downsol-solval);
8968  pscostup = SCIPvarGetPseudocostCurrentRun(var, scip->stat, upsol-solval);
8969 
8970  return SCIPbranchGetScore(scip->set, var, pscostdown, pscostup);
8971 }
8972 
8973 /** returns the variable's VSIDS value
8974  *
8975  * @return the variable's VSIDS value
8976  *
8977  * @pre This method can be called if @p scip is in one of the following stages:
8978  * - \ref SCIP_STAGE_INITPRESOLVE
8979  * - \ref SCIP_STAGE_PRESOLVING
8980  * - \ref SCIP_STAGE_EXITPRESOLVE
8981  * - \ref SCIP_STAGE_PRESOLVED
8982  * - \ref SCIP_STAGE_INITSOLVE
8983  * - \ref SCIP_STAGE_SOLVING
8984  * - \ref SCIP_STAGE_SOLVED
8985  */
8987  SCIP* scip, /**< SCIP data structure */
8988  SCIP_VAR* var, /**< problem variable */
8989  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
8990  )
8991 {
8992  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarVSIDS", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
8993 
8994  assert( var->scip == scip );
8995 
8996  if( dir != SCIP_BRANCHDIR_DOWNWARDS && dir != SCIP_BRANCHDIR_UPWARDS )
8997  {
8998  SCIPerrorMessage("invalid branching direction %d when asking for VSIDS value\n", dir);
8999  return SCIP_INVALID;
9000  }
9001 
9002  return SCIPvarGetVSIDS(var, scip->stat, dir);
9003 }
9004 
9005 /** returns the variable's VSIDS value only using conflicts of the current run
9006  *
9007  * @return the variable's VSIDS value only using conflicts of the current run
9008  *
9009  * @pre This method can be called if @p scip is in one of the following stages:
9010  * - \ref SCIP_STAGE_INITPRESOLVE
9011  * - \ref SCIP_STAGE_PRESOLVING
9012  * - \ref SCIP_STAGE_EXITPRESOLVE
9013  * - \ref SCIP_STAGE_PRESOLVED
9014  * - \ref SCIP_STAGE_INITSOLVE
9015  * - \ref SCIP_STAGE_SOLVING
9016  * - \ref SCIP_STAGE_SOLVED
9017  */
9019  SCIP* scip, /**< SCIP data structure */
9020  SCIP_VAR* var, /**< problem variable */
9021  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
9022  )
9023 {
9024  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarVSIDSCurrentRun", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
9025 
9026  assert( var->scip == scip );
9027 
9028  if( dir != SCIP_BRANCHDIR_DOWNWARDS && dir != SCIP_BRANCHDIR_UPWARDS )
9029  {
9030  SCIPerrorMessage("invalid branching direction %d when asking for VSIDS value\n", dir);
9031  return SCIP_INVALID;
9032  }
9033 
9034  return SCIPvarGetVSIDSCurrentRun(var, scip->stat, dir);
9035 }
9036 
9037 /** returns the variable's conflict score value
9038  *
9039  * @return the variable's conflict score value
9040  *
9041  * @pre This method can be called if @p scip is in one of the following stages:
9042  * - \ref SCIP_STAGE_INITPRESOLVE
9043  * - \ref SCIP_STAGE_PRESOLVING
9044  * - \ref SCIP_STAGE_EXITPRESOLVE
9045  * - \ref SCIP_STAGE_PRESOLVED
9046  * - \ref SCIP_STAGE_INITSOLVE
9047  * - \ref SCIP_STAGE_SOLVING
9048  * - \ref SCIP_STAGE_SOLVED
9049  */
9051  SCIP* scip, /**< SCIP data structure */
9052  SCIP_VAR* var /**< problem variable */
9053  )
9054 {
9055  SCIP_Real downscore;
9056  SCIP_Real upscore;
9057 
9058  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarConflictScore", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
9059 
9060  assert( var->scip == scip );
9061 
9062  downscore = SCIPvarGetVSIDS(var, scip->stat, SCIP_BRANCHDIR_DOWNWARDS);
9063  upscore = SCIPvarGetVSIDS(var, scip->stat, SCIP_BRANCHDIR_UPWARDS);
9064 
9065  return SCIPbranchGetScore(scip->set, var, downscore, upscore);
9066 }
9067 
9068 /** returns the variable's conflict score value only using conflicts of the current run
9069  *
9070  * @return the variable's conflict score value only using conflicts of the current run
9071  *
9072  * @pre This method can be called if @p scip is in one of the following stages:
9073  * - \ref SCIP_STAGE_INITPRESOLVE
9074  * - \ref SCIP_STAGE_PRESOLVING
9075  * - \ref SCIP_STAGE_EXITPRESOLVE
9076  * - \ref SCIP_STAGE_PRESOLVED
9077  * - \ref SCIP_STAGE_INITSOLVE
9078  * - \ref SCIP_STAGE_SOLVING
9079  * - \ref SCIP_STAGE_SOLVED
9080  */
9082  SCIP* scip, /**< SCIP data structure */
9083  SCIP_VAR* var /**< problem variable */
9084  )
9085 {
9086  SCIP_Real downscore;
9087  SCIP_Real upscore;
9088 
9089  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarConflictScoreCurrentRun", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
9090 
9091  assert( var->scip == scip );
9092 
9093  downscore = SCIPvarGetVSIDSCurrentRun(var, scip->stat, SCIP_BRANCHDIR_DOWNWARDS);
9094  upscore = SCIPvarGetVSIDSCurrentRun(var, scip->stat, SCIP_BRANCHDIR_UPWARDS);
9095 
9096  return SCIPbranchGetScore(scip->set, var, downscore, upscore);
9097 }
9098 
9099 /** returns the variable's conflict length score
9100  *
9101  * @return the variable's conflict length score
9102  *
9103  * @pre This method can be called if @p scip is in one of the following stages:
9104  * - \ref SCIP_STAGE_INITPRESOLVE
9105  * - \ref SCIP_STAGE_PRESOLVING
9106  * - \ref SCIP_STAGE_EXITPRESOLVE
9107  * - \ref SCIP_STAGE_PRESOLVED
9108  * - \ref SCIP_STAGE_INITSOLVE
9109  * - \ref SCIP_STAGE_SOLVING
9110  * - \ref SCIP_STAGE_SOLVED
9111  */
9113  SCIP* scip, /**< SCIP data structure */
9114  SCIP_VAR* var /**< problem variable */
9115  )
9116 {
9117  SCIP_Real downscore;
9118  SCIP_Real upscore;
9119 
9120  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarConflictlengthScore", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
9121 
9122  assert( var->scip == scip );
9123 
9126 
9127  return SCIPbranchGetScore(scip->set, var, downscore, upscore);
9128 }
9129 
9130 /** returns the variable's conflict length score only using conflicts of the current run
9131  *
9132  * @return the variable's conflict length score only using conflicts of the current run
9133  *
9134  * @pre This method can be called if @p scip is in one of the following stages:
9135  * - \ref SCIP_STAGE_INITPRESOLVE
9136  * - \ref SCIP_STAGE_PRESOLVING
9137  * - \ref SCIP_STAGE_EXITPRESOLVE
9138  * - \ref SCIP_STAGE_PRESOLVED
9139  * - \ref SCIP_STAGE_INITSOLVE
9140  * - \ref SCIP_STAGE_SOLVING
9141  * - \ref SCIP_STAGE_SOLVED
9142  */
9144  SCIP* scip, /**< SCIP data structure */
9145  SCIP_VAR* var /**< problem variable */
9146  )
9147 {
9148  SCIP_Real downscore;
9149  SCIP_Real upscore;
9150 
9151  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarConflictlengthScoreCurrentRun", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
9152 
9153  assert( var->scip == scip );
9154 
9157 
9158  return SCIPbranchGetScore(scip->set, var, downscore, upscore);
9159 }
9160 
9161 /** returns the variable's average conflict length
9162  *
9163  * @return the variable's average conflict length
9164  *
9165  * @pre This method can be called if @p scip is in one of the following stages:
9166  * - \ref SCIP_STAGE_INITPRESOLVE
9167  * - \ref SCIP_STAGE_PRESOLVING
9168  * - \ref SCIP_STAGE_EXITPRESOLVE
9169  * - \ref SCIP_STAGE_PRESOLVED
9170  * - \ref SCIP_STAGE_INITSOLVE
9171  * - \ref SCIP_STAGE_SOLVING
9172  * - \ref SCIP_STAGE_SOLVED
9173  */
9175  SCIP* scip, /**< SCIP data structure */
9176  SCIP_VAR* var, /**< problem variable */
9177  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
9178  )
9179 {
9180  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarAvgConflictlength", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
9181 
9182  assert( var->scip == scip );
9183 
9184  return SCIPvarGetAvgConflictlength(var, dir);
9185 }
9186 
9187 /** returns the variable's average conflict length only using conflicts of the current run
9188  *
9189  * @return the variable's average conflict length only using conflicts of the current run
9190  *
9191  * @pre This method can be called if @p scip is in one of the following stages:
9192  * - \ref SCIP_STAGE_INITPRESOLVE
9193  * - \ref SCIP_STAGE_PRESOLVING
9194  * - \ref SCIP_STAGE_EXITPRESOLVE
9195  * - \ref SCIP_STAGE_PRESOLVED
9196  * - \ref SCIP_STAGE_INITSOLVE
9197  * - \ref SCIP_STAGE_SOLVING
9198  * - \ref SCIP_STAGE_SOLVED
9199  */
9201  SCIP* scip, /**< SCIP data structure */
9202  SCIP_VAR* var, /**< problem variable */
9203  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
9204  )
9205 {
9206  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarAvgConflictlengthCurrentRun", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
9207 
9208  assert( var->scip == scip );
9209 
9210  return SCIPvarGetAvgConflictlengthCurrentRun(var, dir);
9211 }
9212 
9213 /** returns the average number of inferences found after branching on the variable in given direction;
9214  * if branching on the variable in the given direction was yet evaluated, the average number of inferences
9215  * over all variables for branching in the given direction is returned
9216  *
9217  * @return the average number of inferences found after branching on the variable in given direction
9218  *
9219  * @pre This method can be called if @p scip is in one of the following stages:
9220  * - \ref SCIP_STAGE_INITPRESOLVE
9221  * - \ref SCIP_STAGE_PRESOLVING
9222  * - \ref SCIP_STAGE_EXITPRESOLVE
9223  * - \ref SCIP_STAGE_PRESOLVED
9224  * - \ref SCIP_STAGE_INITSOLVE
9225  * - \ref SCIP_STAGE_SOLVING
9226  * - \ref SCIP_STAGE_SOLVED
9227  */
9229  SCIP* scip, /**< SCIP data structure */
9230  SCIP_VAR* var, /**< problem variable */
9231  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
9232  )
9233 {
9234  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarAvgInferences", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
9235 
9236  assert( var->scip == scip );
9237 
9238  return SCIPvarGetAvgInferences(var, scip->stat, dir);
9239 }
9240 
9241 /** returns the average number of inferences found after branching on the variable in given direction in the current run;
9242  * if branching on the variable in the given direction was yet evaluated, the average number of inferences
9243  * over all variables for branching in the given direction is returned
9244  *
9245  * @return the average number of inferences found after branching on the variable in given direction in the current run
9246  *
9247  * @pre This method can be called if @p scip is in one of the following stages:
9248  * - \ref SCIP_STAGE_INITPRESOLVE
9249  * - \ref SCIP_STAGE_PRESOLVING
9250  * - \ref SCIP_STAGE_EXITPRESOLVE
9251  * - \ref SCIP_STAGE_PRESOLVED
9252  * - \ref SCIP_STAGE_INITSOLVE
9253  * - \ref SCIP_STAGE_SOLVING
9254  * - \ref SCIP_STAGE_SOLVED
9255  */
9257  SCIP* scip, /**< SCIP data structure */
9258  SCIP_VAR* var, /**< problem variable */
9259  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
9260  )
9261 {
9262  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarAvgInferencesCurrentRun", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
9263 
9264  assert( var->scip == scip );
9265 
9266  return SCIPvarGetAvgInferencesCurrentRun(var, scip->stat, dir);
9267 }
9268 
9269 /** returns the variable's average inference score value
9270  *
9271  * @return the variable's average inference score value
9272  *
9273  * @pre This method can be called if @p scip is in one of the following stages:
9274  * - \ref SCIP_STAGE_INITPRESOLVE
9275  * - \ref SCIP_STAGE_PRESOLVING
9276  * - \ref SCIP_STAGE_EXITPRESOLVE
9277  * - \ref SCIP_STAGE_PRESOLVED
9278  * - \ref SCIP_STAGE_INITSOLVE
9279  * - \ref SCIP_STAGE_SOLVING
9280  * - \ref SCIP_STAGE_SOLVED
9281  */
9283  SCIP* scip, /**< SCIP data structure */
9284  SCIP_VAR* var /**< problem variable */
9285  )
9286 {
9287  SCIP_Real inferdown;
9288  SCIP_Real inferup;
9289 
9290  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarAvgInferenceScore", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
9291 
9292  assert( var->scip == scip );
9293 
9294  inferdown = SCIPvarGetAvgInferences(var, scip->stat, SCIP_BRANCHDIR_DOWNWARDS);
9295  inferup = SCIPvarGetAvgInferences(var, scip->stat, SCIP_BRANCHDIR_UPWARDS);
9296 
9297  return SCIPbranchGetScore(scip->set, var, inferdown, inferup);
9298 }
9299 
9300 /** returns the variable's average inference score value only using inferences of the current run
9301  *
9302  * @return the variable's average inference score value only using inferences of the current run
9303  *
9304  * @pre This method can be called if @p scip is in one of the following stages:
9305  * - \ref SCIP_STAGE_INITPRESOLVE
9306  * - \ref SCIP_STAGE_PRESOLVING
9307  * - \ref SCIP_STAGE_EXITPRESOLVE
9308  * - \ref SCIP_STAGE_PRESOLVED
9309  * - \ref SCIP_STAGE_INITSOLVE
9310  * - \ref SCIP_STAGE_SOLVING
9311  * - \ref SCIP_STAGE_SOLVED
9312  */
9314  SCIP* scip, /**< SCIP data structure */
9315  SCIP_VAR* var /**< problem variable */
9316  )
9317 {
9318  SCIP_Real inferdown;
9319  SCIP_Real inferup;
9320 
9321  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarAvgInferenceScoreCurrentRun", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
9322 
9323  assert( var->scip == scip );
9324 
9327 
9328  return SCIPbranchGetScore(scip->set, var, inferdown, inferup);
9329 }
9330 
9331 /** initializes the upwards and downwards pseudocosts, conflict scores, conflict lengths, inference scores, cutoff scores
9332  * of a variable to the given values
9333  *
9334  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9335  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9336  *
9337  * @pre This method can be called if @p scip is in one of the following stages:
9338  * - \ref SCIP_STAGE_TRANSFORMED
9339  * - \ref SCIP_STAGE_INITPRESOLVE
9340  * - \ref SCIP_STAGE_PRESOLVING
9341  * - \ref SCIP_STAGE_EXITPRESOLVE
9342  * - \ref SCIP_STAGE_PRESOLVED
9343  * - \ref SCIP_STAGE_INITSOLVE
9344  * - \ref SCIP_STAGE_SOLVING
9345  */
9347  SCIP* scip, /**< SCIP data structure */
9348  SCIP_VAR* var, /**< variable which should be initialized */
9349  SCIP_Real downpscost, /**< value to which pseudocosts for downwards branching should be initialized */
9350  SCIP_Real uppscost, /**< value to which pseudocosts for upwards branching should be initialized */
9351  SCIP_Real downvsids, /**< value to which VSIDS score for downwards branching should be initialized */
9352  SCIP_Real upvsids, /**< value to which VSIDS score for upwards branching should be initialized */
9353  SCIP_Real downconflen, /**< value to which conflict length score for downwards branching should be initialized */
9354  SCIP_Real upconflen, /**< value to which conflict length score for upwards branching should be initialized */
9355  SCIP_Real downinfer, /**< value to which inference counter for downwards branching should be initialized */
9356  SCIP_Real upinfer, /**< value to which inference counter for upwards branching should be initialized */
9357  SCIP_Real downcutoff, /**< value to which cutoff counter for downwards branching should be initialized */
9358  SCIP_Real upcutoff /**< value to which cutoff counter for upwards branching should be initialized */
9359  )
9360 {
9361  SCIP_CALL( SCIPcheckStage(scip, "SCIPinitVarBranchStats", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE) );
9362 
9363  assert(downpscost >= 0.0 && uppscost >= 0.0);
9364  assert(downvsids >= 0.0 && upvsids >= 0.0);
9365  assert(downconflen >= 0.0 && upconflen >= 0.0);
9366  assert(downinfer >= 0.0 && upinfer >= 0.0);
9367  assert(downcutoff >= 0.0 && upcutoff >= 0.0);
9368 
9369  if( !SCIPisFeasZero(scip, downpscost) || !SCIPisFeasZero(scip, downvsids)
9370  || !SCIPisFeasZero(scip, downinfer) || !SCIPisFeasZero(scip, downcutoff) )
9371  {
9373  SCIP_CALL( SCIPvarUpdatePseudocost(var, scip->set, scip->stat, -1.0, downpscost, 1.0) );
9375  SCIP_CALL( SCIPvarIncVSIDS(var, NULL, scip->set, scip->stat, SCIP_BRANCHDIR_DOWNWARDS, SCIP_UNKNOWN, downvsids) );
9377  }
9378 
9379  if( !SCIPisFeasZero(scip, downconflen) )
9380  {
9382  }
9383 
9384  if( !SCIPisFeasZero(scip, uppscost) || !SCIPisFeasZero(scip, upvsids)
9385  || !SCIPisFeasZero(scip, upinfer) || !SCIPisFeasZero(scip, upcutoff) )
9386  {
9388  SCIP_CALL( SCIPvarUpdatePseudocost(var, scip->set, scip->stat, 1.0, uppscost, 1.0) );
9390  SCIP_CALL( SCIPvarIncVSIDS(var, NULL, scip->set, scip->stat, SCIP_BRANCHDIR_UPWARDS, SCIP_UNKNOWN, upvsids) );
9392  }
9393 
9394  if( !SCIPisFeasZero(scip, upconflen) )
9395  {
9397  }
9398 
9399  return SCIP_OKAY;
9400 }
9401 
9402 /** initializes the upwards and downwards conflict scores, conflict lengths, inference scores, cutoff scores of a
9403  * variable w.r.t. a value by the given values (SCIP_VALUEHISTORY)
9404  *
9405  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9406  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9407  *
9408  * @pre This method can be called if @p scip is in one of the following stages:
9409  * - \ref SCIP_STAGE_TRANSFORMED
9410  * - \ref SCIP_STAGE_INITPRESOLVE
9411  * - \ref SCIP_STAGE_PRESOLVING
9412  * - \ref SCIP_STAGE_EXITPRESOLVE
9413  * - \ref SCIP_STAGE_PRESOLVED
9414  * - \ref SCIP_STAGE_INITSOLVE
9415  * - \ref SCIP_STAGE_SOLVING
9416  */
9418  SCIP* scip, /**< SCIP data structure */
9419  SCIP_VAR* var, /**< variable which should be initialized */
9420  SCIP_Real value, /**< domain value, or SCIP_UNKNOWN */
9421  SCIP_Real downvsids, /**< value to which VSIDS score for downwards branching should be initialized */
9422  SCIP_Real upvsids, /**< value to which VSIDS score for upwards branching should be initialized */
9423  SCIP_Real downconflen, /**< value to which conflict length score for downwards branching should be initialized */
9424  SCIP_Real upconflen, /**< value to which conflict length score for upwards branching should be initialized */
9425  SCIP_Real downinfer, /**< value to which inference counter for downwards branching should be initialized */
9426  SCIP_Real upinfer, /**< value to which inference counter for upwards branching should be initialized */
9427  SCIP_Real downcutoff, /**< value to which cutoff counter for downwards branching should be initialized */
9428  SCIP_Real upcutoff /**< value to which cutoff counter for upwards branching should be initialized */
9429  )
9430 {
9431  SCIP_CALL( SCIPcheckStage(scip, "SCIPinitVarValueBranchStats", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE) );
9432 
9433  assert(downvsids >= 0.0 && upvsids >= 0.0);
9434  assert(downconflen >= 0.0 && upconflen >= 0.0);
9435  assert(downinfer >= 0.0 && upinfer >= 0.0);
9436  assert(downcutoff >= 0.0 && upcutoff >= 0.0);
9437 
9438  if( !SCIPisFeasZero(scip, downvsids) || !SCIPisFeasZero(scip, downinfer) || !SCIPisFeasZero(scip, downcutoff) )
9439  {
9440  SCIP_CALL( SCIPvarIncNBranchings(var, SCIPblkmem(scip), scip->set, scip->stat, SCIP_BRANCHDIR_DOWNWARDS, value, 1) );
9441  SCIP_CALL( SCIPvarIncInferenceSum(var, SCIPblkmem(scip), scip->set, scip->stat, SCIP_BRANCHDIR_DOWNWARDS, value, downinfer) );
9442  SCIP_CALL( SCIPvarIncVSIDS(var, SCIPblkmem(scip), scip->set, scip->stat, SCIP_BRANCHDIR_DOWNWARDS, value, downvsids) );
9443  SCIP_CALL( SCIPvarIncCutoffSum(var, SCIPblkmem(scip), scip->set, scip->stat, SCIP_BRANCHDIR_DOWNWARDS, value, downcutoff) );
9444  }
9445 
9446  if( !SCIPisFeasZero(scip, downconflen) )
9447  {
9448  SCIP_CALL( SCIPvarIncNActiveConflicts(var, SCIPblkmem(scip), scip->set, scip->stat, SCIP_BRANCHDIR_DOWNWARDS, value, downconflen) );
9449  }
9450 
9451  if( !SCIPisFeasZero(scip, upvsids) || !SCIPisFeasZero(scip, upinfer) || !SCIPisFeasZero(scip, upcutoff) )
9452  {
9453  SCIP_CALL( SCIPvarIncNBranchings(var, SCIPblkmem(scip), scip->set, scip->stat, SCIP_BRANCHDIR_UPWARDS, value, 1) );
9454  SCIP_CALL( SCIPvarIncInferenceSum(var, SCIPblkmem(scip), scip->set, scip->stat, SCIP_BRANCHDIR_UPWARDS, value, upinfer) );
9455  SCIP_CALL( SCIPvarIncVSIDS(var, SCIPblkmem(scip), scip->set, scip->stat, SCIP_BRANCHDIR_UPWARDS, value, upvsids) );
9456  SCIP_CALL( SCIPvarIncCutoffSum(var, SCIPblkmem(scip), scip->set, scip->stat, SCIP_BRANCHDIR_UPWARDS, value, upcutoff) );
9457  }
9458 
9459  if( !SCIPisFeasZero(scip, upconflen) )
9460  {
9461  SCIP_CALL( SCIPvarIncNActiveConflicts(var, SCIPblkmem(scip), scip->set, scip->stat, SCIP_BRANCHDIR_UPWARDS, value, upconflen) );
9462  }
9463 
9464  return SCIP_OKAY;
9465 }
9466 
9467 /** returns the average number of cutoffs found after branching on the variable in given direction;
9468  * if branching on the variable in the given direction was yet evaluated, the average number of cutoffs
9469  * over all variables for branching in the given direction is returned
9470  *
9471  * @return the average number of cutoffs found after branching on the variable in given direction
9472  *
9473  * @pre This method can be called if @p scip is in one of the following stages:
9474  * - \ref SCIP_STAGE_INITPRESOLVE
9475  * - \ref SCIP_STAGE_PRESOLVING
9476  * - \ref SCIP_STAGE_EXITPRESOLVE
9477  * - \ref SCIP_STAGE_PRESOLVED
9478  * - \ref SCIP_STAGE_INITSOLVE
9479  * - \ref SCIP_STAGE_SOLVING
9480  * - \ref SCIP_STAGE_SOLVED
9481  */
9483  SCIP* scip, /**< SCIP data structure */
9484  SCIP_VAR* var, /**< problem variable */
9485  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
9486  )
9487 {
9488  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarAvgCutoffs", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
9489 
9490  assert( var->scip == scip );
9491 
9492  return SCIPvarGetAvgCutoffs(var, scip->stat, dir);
9493 }
9494 
9495 /** returns the average number of cutoffs found after branching on the variable in given direction in the current run;
9496  * if branching on the variable in the given direction was yet evaluated, the average number of cutoffs
9497  * over all variables for branching in the given direction is returned
9498  *
9499  * @return the average number of cutoffs found after branching on the variable in given direction in the current run
9500  *
9501  * @pre This method can be called if @p scip is in one of the following stages:
9502  * - \ref SCIP_STAGE_INITPRESOLVE
9503  * - \ref SCIP_STAGE_PRESOLVING
9504  * - \ref SCIP_STAGE_EXITPRESOLVE
9505  * - \ref SCIP_STAGE_PRESOLVED
9506  * - \ref SCIP_STAGE_INITSOLVE
9507  * - \ref SCIP_STAGE_SOLVING
9508  * - \ref SCIP_STAGE_SOLVED
9509  */
9511  SCIP* scip, /**< SCIP data structure */
9512  SCIP_VAR* var, /**< problem variable */
9513  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
9514  )
9515 {
9516  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarAvgCutoffsCurrentRun", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
9517 
9518  assert( var->scip == scip );
9519 
9520  return SCIPvarGetAvgCutoffsCurrentRun(var, scip->stat, dir);
9521 }
9522 
9523 /** returns the variable's average cutoff score value
9524  *
9525  * @return the variable's average cutoff score value
9526  *
9527  * @pre This method can be called if @p scip is in one of the following stages:
9528  * - \ref SCIP_STAGE_INITPRESOLVE
9529  * - \ref SCIP_STAGE_PRESOLVING
9530  * - \ref SCIP_STAGE_EXITPRESOLVE
9531  * - \ref SCIP_STAGE_PRESOLVED
9532  * - \ref SCIP_STAGE_INITSOLVE
9533  * - \ref SCIP_STAGE_SOLVING
9534  * - \ref SCIP_STAGE_SOLVED
9535  */
9537  SCIP* scip, /**< SCIP data structure */
9538  SCIP_VAR* var /**< problem variable */
9539  )
9540 {
9541  SCIP_Real cutoffdown;
9542  SCIP_Real cutoffup;
9543 
9544  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarAvgCutoffScore", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
9545 
9546  assert( var->scip == scip );
9547 
9548  cutoffdown = SCIPvarGetAvgCutoffs(var, scip->stat, SCIP_BRANCHDIR_DOWNWARDS);
9549  cutoffup = SCIPvarGetAvgCutoffs(var, scip->stat, SCIP_BRANCHDIR_UPWARDS);
9550 
9551  return SCIPbranchGetScore(scip->set, var, cutoffdown, cutoffup);
9552 }
9553 
9554 /** returns the variable's average cutoff score value, only using cutoffs of the current run
9555  *
9556  * @return the variable's average cutoff score value, only using cutoffs of the current run
9557  *
9558  * @pre This method can be called if @p scip is in one of the following stages:
9559  * - \ref SCIP_STAGE_INITPRESOLVE
9560  * - \ref SCIP_STAGE_PRESOLVING
9561  * - \ref SCIP_STAGE_EXITPRESOLVE
9562  * - \ref SCIP_STAGE_PRESOLVED
9563  * - \ref SCIP_STAGE_INITSOLVE
9564  * - \ref SCIP_STAGE_SOLVING
9565  * - \ref SCIP_STAGE_SOLVED
9566  */
9568  SCIP* scip, /**< SCIP data structure */
9569  SCIP_VAR* var /**< problem variable */
9570  )
9571 {
9572  SCIP_Real cutoffdown;
9573  SCIP_Real cutoffup;
9574 
9575  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarAvgCutoffScoreCurrentRun", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
9576 
9577  assert( var->scip == scip );
9578 
9581 
9582  return SCIPbranchGetScore(scip->set, var, cutoffdown, cutoffup);
9583 }
9584 
9585 /** returns the variable's average inference/cutoff score value, weighting the cutoffs of the variable with the given
9586  * factor
9587  *
9588  * @return the variable's average inference/cutoff score value
9589  *
9590  * @pre This method can be called if @p scip is in one of the following stages:
9591  * - \ref SCIP_STAGE_INITPRESOLVE
9592  * - \ref SCIP_STAGE_PRESOLVING
9593  * - \ref SCIP_STAGE_EXITPRESOLVE
9594  * - \ref SCIP_STAGE_PRESOLVED
9595  * - \ref SCIP_STAGE_INITSOLVE
9596  * - \ref SCIP_STAGE_SOLVING
9597  * - \ref SCIP_STAGE_SOLVED
9598  */
9600  SCIP* scip, /**< SCIP data structure */
9601  SCIP_VAR* var, /**< problem variable */
9602  SCIP_Real cutoffweight /**< factor to weigh average number of cutoffs in branching score */
9603  )
9604 {
9605  SCIP_Real avginferdown;
9606  SCIP_Real avginferup;
9607  SCIP_Real avginfer;
9608  SCIP_Real inferdown;
9609  SCIP_Real inferup;
9610  SCIP_Real cutoffdown;
9611  SCIP_Real cutoffup;
9612 
9613  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarAvgInferenceCutoffScore", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
9614 
9615  assert( var->scip == scip );
9616 
9619  avginfer = (avginferdown + avginferup)/2.0;
9620  inferdown = SCIPvarGetAvgInferences(var, scip->stat, SCIP_BRANCHDIR_DOWNWARDS);
9621  inferup = SCIPvarGetAvgInferences(var, scip->stat, SCIP_BRANCHDIR_UPWARDS);
9622  cutoffdown = SCIPvarGetAvgCutoffs(var, scip->stat, SCIP_BRANCHDIR_DOWNWARDS);
9623  cutoffup = SCIPvarGetAvgCutoffs(var, scip->stat, SCIP_BRANCHDIR_UPWARDS);
9624 
9625  return SCIPbranchGetScore(scip->set, var,
9626  inferdown + cutoffweight * avginfer * cutoffdown, inferup + cutoffweight * avginfer * cutoffup);
9627 }
9628 
9629 /** returns the variable's average inference/cutoff score value, weighting the cutoffs of the variable with the given
9630  * factor, only using inferences and cutoffs of the current run
9631  *
9632  * @return the variable's average inference/cutoff score value, only using inferences and cutoffs of the current run
9633  *
9634  * @pre This method can be called if @p scip is in one of the following stages:
9635  * - \ref SCIP_STAGE_INITPRESOLVE
9636  * - \ref SCIP_STAGE_PRESOLVING
9637  * - \ref SCIP_STAGE_EXITPRESOLVE
9638  * - \ref SCIP_STAGE_PRESOLVED
9639  * - \ref SCIP_STAGE_INITSOLVE
9640  * - \ref SCIP_STAGE_SOLVING
9641  * - \ref SCIP_STAGE_SOLVED
9642  */
9644  SCIP* scip, /**< SCIP data structure */
9645  SCIP_VAR* var, /**< problem variable */
9646  SCIP_Real cutoffweight /**< factor to weigh average number of cutoffs in branching score */
9647  )
9648 {
9649  SCIP_Real avginferdown;
9650  SCIP_Real avginferup;
9651  SCIP_Real avginfer;
9652  SCIP_Real inferdown;
9653  SCIP_Real inferup;
9654  SCIP_Real cutoffdown;
9655  SCIP_Real cutoffup;
9656 
9657  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarAvgInferenceCutoffScoreCurrentRun", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
9658 
9659  assert( var->scip == scip );
9660 
9663  avginfer = (avginferdown + avginferup)/2.0;
9668 
9669  return SCIPbranchGetScore(scip->set, var,
9670  inferdown + cutoffweight * avginfer * cutoffdown, inferup + cutoffweight * avginfer * cutoffup);
9671 }
9672 
9673 /** outputs variable information to file stream via the message system
9674  *
9675  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9676  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9677  *
9678  * @pre This method can be called if @p scip is in one of the following stages:
9679  * - \ref SCIP_STAGE_PROBLEM
9680  * - \ref SCIP_STAGE_TRANSFORMING
9681  * - \ref SCIP_STAGE_TRANSFORMED
9682  * - \ref SCIP_STAGE_INITPRESOLVE
9683  * - \ref SCIP_STAGE_PRESOLVING
9684  * - \ref SCIP_STAGE_EXITPRESOLVE
9685  * - \ref SCIP_STAGE_PRESOLVED
9686  * - \ref SCIP_STAGE_INITSOLVE
9687  * - \ref SCIP_STAGE_SOLVING
9688  * - \ref SCIP_STAGE_SOLVED
9689  * - \ref SCIP_STAGE_EXITSOLVE
9690  * - \ref SCIP_STAGE_FREETRANS
9691  *
9692  * @note If the message handler is set to a NULL pointer nothing will be printed
9693  */
9695  SCIP* scip, /**< SCIP data structure */
9696  SCIP_VAR* var, /**< problem variable */
9697  FILE* file /**< output file (or NULL for standard output) */
9698  )
9699 {
9700  SCIP_CALL( SCIPcheckStage(scip, "SCIPprintVar", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
9701 
9702  SCIP_CALL( SCIPvarPrint(var, scip->set, scip->messagehdlr, file) );
9703 
9704  return SCIP_OKAY;
9705 }
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:14884
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:4878
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:6780
#define NULL
Definition: def.h:246
void SCIPvarGetClosestVlb(SCIP_VAR *var, SCIP_SOL *sol, SCIP_SET *set, SCIP_STAT *stat, SCIP_Real *closestvlb, int *closestvlbidx)
Definition: var.c:13604
SCIP_Real SCIPgetVarAvgInferences(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:9228
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:15011
SCIP_Bool SCIPvarsHaveCommonClique(SCIP_VAR *var1, SCIP_Bool value1, SCIP_VAR *var2, SCIP_Bool value2, SCIP_Bool regardimplics)
Definition: var.c:10964
SCIP_Real SCIPgetVarAvgCutoffs(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:9482
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:14531
SCIP_RETCODE SCIPtightenVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:5119
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:10081
void SCIPvarUpdateBestRootSol(SCIP_VAR *var, SCIP_SET *set, SCIP_Real rootsol, SCIP_Real rootredcost, SCIP_Real rootlpobjval)
Definition: var.c:12764
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:17467
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:6051
SCIP_NODE * SCIPgetCurrentNode(SCIP *scip)
Definition: scip_tree.c:158
SCIP_STAGE SCIPgetStage(SCIP *scip)
Definition: scip_general.c:411
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:9599
SCIP_CONFLICT * conflict
Definition: struct_scip.h:85
SCIP_RETCODE SCIPaddVarObj(SCIP *scip, SCIP_VAR *var, SCIP_Real addobj)
Definition: scip_var.c:4498
SCIP_Real SCIPvarGetAvgCutoffsCurrentRun(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
Definition: var.c:15792
SCIP_Real SCIPvarGetBranchFactor(SCIP_VAR *var)
Definition: var.c:17504
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:16058
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:9256
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:9143
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:6895
SCIP_Bool SCIPvarDoNotMultaggr(SCIP_VAR *var)
Definition: var.c:5667
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:14098
methods for implications, variable bounds, and cliques
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
Definition: var.c:17344
SCIP_RETCODE SCIPvarGetProbvarBinary(SCIP_VAR **var, SCIP_Bool *negated)
Definition: var.c:11796
SCIP_Bool SCIPvarIsPscostRelerrorReliable(SCIP_VAR *var, SCIP_SET *set, SCIP_STAT *stat, SCIP_Real threshold, SCIP_CONFIDENCELEVEL clevel)
Definition: var.c:14264
#define SCIP_MAXSTRLEN
Definition: def.h:267
SCIP_Bool conf_usesb
Definition: struct_set.h:209
SCIP_Real SCIPgetVarPseudocostVal(SCIP *scip, SCIP_VAR *var, SCIP_Real solvaldelta)
Definition: scip_var.c:8623
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:129
SCIP_RETCODE SCIPvarChgLbOriginal(SCIP_VAR *var, SCIP_SET *set, SCIP_Real newbound)
Definition: var.c:6277
SCIP_Longint SCIPcolGetStrongbranchNode(SCIP_COL *col)
Definition: lp.c:16850
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:8335
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:17400
SCIP_RETCODE SCIPvarChgLbLazy(SCIP_VAR *var, SCIP_SET *set, SCIP_Real lazylb)
Definition: var.c:7179
#define SCIP_CALL_FINALLY(x, y)
Definition: def.h:400
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:3950
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:5807
SCIP_Real SCIPvarGetMultaggrLbGlobal(SCIP_VAR *var, SCIP_SET *set)
Definition: var.c:8274
SCIP_RETCODE SCIPchgVarLbNode(SCIP *scip, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_var.c:4782
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:8868
SCIP_RETCODE SCIPvarChgUbOriginal(SCIP_VAR *var, SCIP_SET *set, SCIP_Real newbound)
Definition: var.c:6336
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:16910
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:12741
SCIP_RETCODE SCIPchgVarUbLazy(SCIP *scip, SCIP_VAR *var, SCIP_Real lazyub)
Definition: scip_var.c:5085
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:5890
SCIP_Real SCIPgetVarPseudocostCountCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:8759
SCIP_BOUNDTYPE SCIPboundchgGetBoundtype(SCIP_BOUNDCHG *boundchg)
Definition: var.c:16657
SCIP_Real SCIPgetVarPseudocostScoreCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_Real solval)
Definition: scip_var.c:8950
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:72
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:4581
SCIP_RETCODE SCIPhashmapCreate(SCIP_HASHMAP **hashmap, BMS_BLKMEM *blkmem, int mapsize)
Definition: misc.c:2891
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:8986
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:6030
void SCIPclockStart(SCIP_CLOCK *clck, SCIP_SET *set)
Definition: clock.c:280
SCIP_Real SCIPgetVarMultaggrUbLocal(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:6501
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:8651
SCIP_Real constant
Definition: struct_var.h:194
int SCIPsnprintf(char *t, int len, const char *s,...)
Definition: misc.c:10253
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:71
SCIP_Real SCIPvarGetAvgConflictlength(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: var.c:14840
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:4256
SCIP_Longint SCIPgetVarStrongbranchNode(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:4099
SCIP_RETCODE SCIPhashmapInsertInt(SCIP_HASHMAP *hashmap, void *origin, int image)
Definition: misc.c:3009
void SCIPlpStartStrongbranchProbing(SCIP_LP *lp)
Definition: lp.c:16045
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:8307
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:17037
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:10436
#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:7048
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:9510
SCIP_Bool presol_donotmultaggr
Definition: struct_set.h:425
SCIP_Real SCIPgetVarVSIDSCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:9018
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:7038
SCIP_Real SCIPgetVarAvgCutoffScoreCurrentRun(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:9567
public methods for problem variables
SCIP_Bool SCIPisVarPscostRelerrorReliable(SCIP *scip, SCIP_VAR *var, SCIP_Real threshold, SCIP_CONFIDENCELEVEL clevel)
Definition: scip_var.c:8887
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:5235
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:15547
SCIP_Bool diving
Definition: struct_lp.h:365
SCIP_Real SCIPgetVarPseudocost(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:8677
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:11492
SCIP_RETCODE SCIPchgVarUbNode(SCIP *scip, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_var.c:4826
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:6471
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:6922
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:4612
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:6571
#define SCIP_LONGINT_MAX
Definition: def.h:143
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:13859
#define SCIPsetFreeBufferArray(set, ptr)
Definition: set.h:1911
SCIP_Real SCIPadjustedVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real lb)
Definition: scip_var.c:4549
enum SCIP_LPSolStat SCIP_LPSOLSTAT
Definition: type_lp.h:42
void SCIPvarAdjustLb(SCIP_VAR *var, SCIP_SET *set, SCIP_Real *lb)
Definition: var.c:6227
SCIP_Bool SCIPisTransformed(SCIP *scip)
Definition: scip_general.c:610
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:6630
public methods for SCIP variables
SCIP_RETCODE SCIPvarChgBranchDirection(SCIP_VAR *var, SCIP_BRANCHDIR branchdirection)
Definition: var.c:11305
SCIP_VAR * SCIPvarGetNegationVar(SCIP_VAR *var)
Definition: var.c:17170
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:4965
#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:17696
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:6519
SCIP_VAR ** vars
Definition: struct_var.h:186
SCIP_Real SCIPcomputeVarUbGlobal(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:6394
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:6415
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:8912
SCIP_RETCODE SCIPscaleVarBranchFactor(SCIP *scip, SCIP_VAR *var, SCIP_Real scale)
Definition: scip_var.c:7829
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:4019
SCIP_Bool SCIPhashmapExists(SCIP_HASHMAP *hashmap, void *origin)
Definition: misc.c:3240
SCIP_RETCODE SCIPaddVarLocksType(SCIP *scip, SCIP_VAR *var, SCIP_LOCKTYPE locktype, int nlocksdown, int nlocksup)
Definition: scip_var.c:4198
SCIP_Real SCIPvarGetVSIDSCurrentRun(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
Definition: var.c:15408
SCIP_RETCODE SCIPupdateVarPseudocost(SCIP *scip, SCIP_VAR *var, SCIP_Real solvaldelta, SCIP_Real objdelta, SCIP_Real weight)
Definition: scip_var.c:8589
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:8082
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:6829
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:7680
SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)
Definition: var.c:17354
SCIP_VAR * SCIPvarGetProbvar(SCIP_VAR *var)
Definition: var.c:11704
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:5925
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:8421
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:12951
SCIP_Bool SCIPtreeProbing(SCIP_TREE *tree)
Definition: tree.c:8189
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:11175
SCIP_Real SCIPvarGetPseudocost(SCIP_VAR *var, SCIP_STAT *stat, SCIP_Real solvaldelta)
Definition: var.c:13957
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:7202
SCIP_Real SCIPgetVarPseudocostVariance(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun)
Definition: scip_var.c:8785
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:16667
SCIP_EVENTFILTER * eventfilter
Definition: struct_scip.h:77
SCIP_Bool SCIPlpIsDualReliable(SCIP_LP *lp)
Definition: lp.c:17447
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:14407
SCIP_RETCODE SCIPchgVarLbLazy(SCIP *scip, SCIP_VAR *var, SCIP_Real lazylb)
Definition: scip_var.c:5052
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:8471
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:5976
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:5346
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:9346
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:6690
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:2010
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:14006
void SCIPstrCopySection(const char *str, char startchar, char endchar, char *token, int size, char **endptr)
Definition: misc.c:10384
SCIP_RETCODE SCIPunlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)
Definition: scip_var.c:4374
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:4702
SCIP_Real SCIPcalculatePscostConfidenceBound(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun, SCIP_CONFIDENCELEVEL clevel)
Definition: scip_var.c:8807
SCIP_OBJSENSE objsense
Definition: struct_prob.h:77
SCIP_RETCODE SCIPmarkDoNotMultaggrVar(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:8524
char branch_firstsbchild
Definition: struct_set.h:170
const char * SCIPvarGetName(SCIP_VAR *var)
Definition: var.c:16730
SCIP_VAR * transvar
Definition: struct_var.h:170
SCIP_REOPT * reopt
Definition: struct_scip.h:74
void SCIPhashmapFree(SCIP_HASHMAP **hashmap)
Definition: misc.c:2925
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:6138
SCIP_DOMCHG * SCIPnodeGetDomchg(SCIP_NODE *node)
Definition: tree.c:7442
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:3626
void SCIPvarGetClosestVub(SCIP_VAR *var, SCIP_SOL *sol, SCIP_SET *set, SCIP_STAT *stat, SCIP_Real *closestvub, int *closestvubidx)
Definition: var.c:13679
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:9112
SCIP_RETCODE SCIPvarSetRelaxSol(SCIP_VAR *var, SCIP_SET *set, SCIP_RELAXATION *relaxation, SCIP_Real solval, SCIP_Bool updateobj)
Definition: var.c:13344
data structures for branch and bound tree
SCIP_HISTORY * glbhistory
Definition: struct_stat.h:165
SCIP_Real SCIPboundchgGetNewbound(SCIP_BOUNDCHG *boundchg)
Definition: var.c:16627
#define REALABS(x)
Definition: def.h:181
SCIP_Real SCIPvarGetLPSol(SCIP_VAR *var)
Definition: var.c:17718
SCIP_Real SCIPgetVarAvgInferenceScoreCurrentRun(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:9313
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:9709
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:14226
#define SCIP_CALL(x)
Definition: def.h:358
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:8838
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:6436
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:5921
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:14927
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:9174
SCIP_RETCODE SCIPremoveVarFromGlobalStructures(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:7767
SCIP_RETCODE SCIPgetVarClosestVub(SCIP *scip, SCIP_VAR *var, SCIP_SOL *sol, SCIP_Real *closestvub, int *closestvubidx)
Definition: scip_var.c:6542
SCIP_Longint SCIPgetVarStrongbranchLPAge(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:4133
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:14053
#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:7806
SCIP_Real SCIPlpGetObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
Definition: lp.c:12911
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:8731
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:8705
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:4449
internal methods for problem variables
SCIP_RETCODE SCIPvarChgBranchFactor(SCIP_VAR *var, SCIP_SET *set, SCIP_Real branchfactor)
Definition: var.c:11049
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:5098
#define SCIPallocBufferArray(scip, ptr, num)
Definition: scip_mem.h:130
#define SCIP_UNKNOWN
Definition: def.h:178
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:15095
#define SCIP_Bool
Definition: def.h:69
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:5738
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:7510
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:6347
SCIP_RETCODE SCIProundSol(SCIP *scip, SCIP_SOL *sol, SCIP_Bool *success)
Definition: scip_sol.c:2504
#define MAXNCLIQUEVARSCOMP
Definition: scip_var.c:7028
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:17516
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:3316
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:10354
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:3276
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:7164
SCIP_VAR * SCIPboundchgGetVar(SCIP_BOUNDCHG *boundchg)
Definition: var.c:16637
#define MIN(x, y)
Definition: def.h:216
methods for debugging
SCIP_Bool * SCIPcliqueGetValues(SCIP_CLIQUE *clique)
Definition: implics.c:3355
SCIP_BOUNDCHG * SCIPdomchgGetBoundchg(SCIP_DOMCHG *domchg, int pos)
Definition: var.c:16685
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:7618
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:8340
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:8550
SCIP_Real SCIPcomputeVarLbGlobal(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:6373
SCIP_Real SCIPgetVarAvgInferenceCutoffScoreCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_Real cutoffweight)
Definition: scip_var.c:9643
SCIP_Real SCIPbdchginfoGetNewbound(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:17936
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:3824
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:15604
SCIP_Bool SCIPtreeHasCurrentNodeLP(SCIP_TREE *tree)
Definition: tree.c:8324
SCIP_RETCODE SCIPfixVar(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval, SCIP_Bool *infeasible, SCIP_Bool *fixed)
Definition: scip_var.c:8178
#define BMScopyMemoryArray(ptr, source, num)
Definition: memory.h:123
SCIP_RETCODE SCIPchgVarBranchPriority(SCIP *scip, SCIP_VAR *var, int branchpriority)
Definition: scip_var.c:7888
SCIP_RETCODE SCIPlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)
Definition: scip_var.c:4289
int SCIPconflictGetNConflicts(SCIP_CONFLICT *conflict)
Definition: conflict.c:3538
SCIP_COL * SCIPvarGetCol(SCIP_VAR *var)
Definition: var.c:17058
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:13405
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:5415
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:14667
void SCIPrelaxationSetSolObj(SCIP_RELAXATION *relaxation, SCIP_Real obj)
Definition: relax.c:705
#define SCIP_MAXTREEDEPTH
Definition: def.h:294
SCIP * scip
Definition: struct_var.h:201
SCIP_BDCHGINFO * SCIPvarGetLbchgInfo(SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: var.c:15890
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:15946
int SCIPgetNVars(SCIP *scip)
Definition: scip_prob.c:2044
SCIP_Real SCIPgetVarMultaggrLbLocal(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:6486
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:12950
datastructures for storing and manipulating the main problem
SCIP_Bool SCIPinDive(SCIP *scip)
Definition: scip_lp.c:2662
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:149
SCIP_CLIQUE ** SCIPgetCliques(SCIP *scip)
Definition: scip_var.c:7537
SCIP_Real SCIPgetVarAvgConflictlengthCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip_var.c:9200
SCIP_RETCODE SCIPaddVarBranchFactor(SCIP *scip, SCIP_VAR *var, SCIP_Real addfactor)
Definition: scip_var.c:7857
SCIP_LPSOLSTAT SCIPgetLastStrongbranchLPSolStat(SCIP *scip, SCIP_BRANCHDIR branchdir)
Definition: scip_var.c:3928
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:130
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:3984
general public methods
#define MAX(x, y)
Definition: def.h:215
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:5264
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:5528
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:3713
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:16677
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:131
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:8290
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:14341
SCIP_Bool SCIPallowDualReds(SCIP *scip)
Definition: scip_var.c:8488
SCIP_SET * set
Definition: struct_scip.h:62
public methods for message output
int SCIPgetNCliques(SCIP *scip)
Definition: scip_var.c:7483
data structures for LP management
SCIP_RETCODE SCIPaddVarBranchPriority(SCIP *scip, SCIP_VAR *var, int addpriority)
Definition: scip_var.c:7962
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:16860
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
Definition: var.c:16849
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:7383
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:8287
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:7337
SCIP_RETCODE SCIPcaptureVar(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:1217
#define SCIP_Real
Definition: def.h:157
internal methods for problem statistics
SCIP_RETCODE SCIPvarsGetProbvarBinary(SCIP_VAR ***vars, SCIP_Bool **negatedarr, int nvars)
Definition: var.c:11764
SCIP_RETCODE SCIPchgVarBranchDirection(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR branchdirection)
Definition: scip_var.c:7993
SCIP_Bool SCIPhaveVarsCommonClique(SCIP *scip, SCIP_VAR *var1, SCIP_Bool value1, SCIP_VAR *var2, SCIP_Bool value2, SCIP_Bool regardimplics)
Definition: scip_var.c:7567
datastructures for collecting primal CIP solutions and primal informations
public methods for message handling
SCIP_Bool SCIPdoNotAggr(SCIP *scip)
Definition: scip_var.c:8451
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:17809
#define SCIP_INVALID
Definition: def.h:177
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:142
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:15745
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:16895
#define SCIP_VARTYPE_BINARY_CHAR
Definition: def.h:128
SCIP_Real SCIPvarGetMultaggrUbLocal(SCIP_VAR *var, SCIP_SET *set)
Definition: var.c:8208
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:8461
SCIP_DOM glbdom
Definition: struct_var.h:219
SCIP_Real SCIPgetVarConflictScoreCurrentRun(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:9081
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:17410
SCIP_Real SCIPgetVarMultaggrLbGlobal(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:6456
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:6244
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:16872
SCIP_RETCODE SCIPtightenVarUbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:6258
static SCIP_RETCODE tightenBounds(SCIP *scip, SCIP_VAR *var, SCIP_VARTYPE vartype, SCIP_Bool *infeasible)
Definition: scip_var.c:8010
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:9417
#define BMSclearMemoryArray(ptr, num)
Definition: memory.h:119
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:7929
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:12133
SCIP_NODE * root
Definition: struct_tree.h:177
int SCIPhashmapGetImageInt(SCIP_HASHMAP *hashmap, void *origin)
Definition: misc.c:3098
#define SCIP_CALL_ABORT(x)
Definition: def.h:337
SCIP_Real SCIPvarGetPseudoSol(SCIP_VAR *var)
Definition: var.c:17796
SCIP_RETCODE SCIPcleanupCliques(SCIP *scip, SCIP_Bool *infeasible)
Definition: scip_var.c:7440
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:330
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:4165
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:16921
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:8142
void SCIPdisableVarHistory(SCIP *scip)
Definition: scip_var.c:8569
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:9282
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:5635
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:16792
SCIP_RETCODE SCIPvarNegate(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR **negvar)
Definition: var.c:5702
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:7801
SCIP_RETCODE SCIPprintVar(SCIP *scip, SCIP_VAR *var, FILE *file)
Definition: scip_var.c:9694
static SCIP_RETCODE relabelOrderConsistent(SCIP *const scip, int *labels, int const nlabels, int *nclasses)
Definition: scip_var.c:6861
SCIP_Bool SCIPallowObjProp(SCIP *scip)
Definition: scip_var.c:8498
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:9050
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:14172
SCIP_Bool SCIPvarIsActive(SCIP_VAR *var)
Definition: var.c:17017
SCIP_Bool SCIPvarIsNegated(SCIP_VAR *var)
Definition: var.c:16885
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:16987
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:9536