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