Scippy

SCIP

Solving Constraint Integer Programs

pub_var.h
Go to the documentation of this file.
1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2 /* */
3 /* This file is part of the program and library */
4 /* SCIP --- Solving Constraint Integer Programs */
5 /* */
6 /* Copyright (C) 2002-2014 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 email to scip@zib.de. */
13 /* */
14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15 
16 /**@file pub_var.h
17  * @ingroup PUBLICMETHODS
18  * @brief public methods for problem variables
19  * @author Tobias Achterberg
20  */
21 
22 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
23 
24 #ifndef __SCIP_PUB_VAR_H__
25 #define __SCIP_PUB_VAR_H__
26 
27 
28 #include "scip/def.h"
29 #include "scip/type_retcode.h"
30 #include "scip/type_misc.h"
31 #include "scip/type_history.h"
32 #include "scip/type_var.h"
33 #include "scip/type_implics.h"
34 #include "scip/type_cons.h"
35 
36 #ifdef NDEBUG
37 #include "scip/struct_var.h"
38 #include "scip/implics.h"
39 #include "scip/history.h"
40 #endif
41 
42 #ifdef __cplusplus
43 extern "C" {
44 #endif
45 
46 /*
47  * methods for variables
48  */
49 
50 /** gets number of locks for rounding down */
51 extern
53  SCIP_VAR* var /**< problem variable */
54  );
55 
56 /** gets number of locks for rounding up */
57 extern
59  SCIP_VAR* var /**< problem variable */
60  );
61 
62 /** is it possible, to round variable down and stay feasible? */
63 extern
65  SCIP_VAR* var /**< problem variable */
66  );
67 
68 /** is it possible, to round variable up and stay feasible? */
69 extern
71  SCIP_VAR* var /**< problem variable */
72  );
73 
74 /** compares the index of two variables, only active or negated variables are allowed, if a variable
75  * is negated then the index of the corresponding active variable is taken, returns -1 if first is
76  * smaller than, and +1 if first is greater than second variable index; returns 0 if both indices
77  * are equal, which means both variables are equal
78  */
79 extern
81  SCIP_VAR* var1, /**< first problem variable */
82  SCIP_VAR* var2 /**< second problem variable */
83  );
84 
85 /** comparison method for sorting active and negated variables by non-decreasing index, active and negated
86  * variables are handled as the same variables
87  */
88 extern
89 SCIP_DECL_SORTPTRCOMP(SCIPvarCompActiveAndNegated);
90 
91 /** compares the index of two variables, returns -1 if first is smaller than, and +1 if first is greater than second
92  * variable index; returns 0 if both indices are equal, which means both variables are equal
93  */
94 extern
95 int SCIPvarCompare(
96  SCIP_VAR* var1, /**< first problem variable */
97  SCIP_VAR* var2 /**< second problem variable */
98  );
99 
100 /** comparison method for sorting variables by non-decreasing index */
101 extern
102 SCIP_DECL_SORTPTRCOMP(SCIPvarComp);
103 
104 /** comparison method for sorting variables by non-decreasing objective coefficient */
105 extern
106 SCIP_DECL_SORTPTRCOMP(SCIPvarCompObj);
107 
108 /** hash key retrieval function for variables */
109 extern
110 SCIP_DECL_HASHGETKEY(SCIPvarGetHashkey);
111 
112 /** returns TRUE iff the indices of both variables are equal */
113 extern
114 SCIP_DECL_HASHKEYEQ(SCIPvarIsHashkeyEq);
115 
116 /** returns the hash value of the key */
117 extern
118 SCIP_DECL_HASHKEYVAL(SCIPvarGetHashkeyVal);
119 
120 
121 /** gets corresponding active, fixed, or multi-aggregated problem variables of given variables,
122  * @note the content of the given array will/might change
123  */
124 extern
125 void SCIPvarsGetProbvar(
126  SCIP_VAR** vars, /**< array of problem variables */
127  int nvars /**< number of variables */
128  );
129 
130 /** gets corresponding active, fixed, or multi-aggregated problem variable of a variable */
131 extern
133  SCIP_VAR* var /**< problem variable */
134  );
135 
136 /** gets corresponding active, fixed, or multi-aggregated problem variables of binary variables and
137  * updates the given negation status of each variable
138  */
139 extern
141  SCIP_VAR*** vars, /**< pointer to binary problem variables */
142  SCIP_Bool** negatedarr, /**< pointer to corresponding array to update the negation status */
143  int nvars /**< number of variables and values in vars and negated array */
144  );
145 
146 /** gets corresponding active, fixed, or multi-aggregated problem variable of a binary variable and
147  * updates the given negation status
148  */
149 extern
151  SCIP_VAR** var, /**< pointer to binary problem variable */
152  SCIP_Bool* negated /**< pointer to update the negation status */
153  );
154 
155 /** transforms given variable, boundtype and bound to the corresponding active, fixed, or multi-aggregated variable
156  * values
157  */
158 extern
160  SCIP_VAR** var, /**< pointer to problem variable */
161  SCIP_Real* bound, /**< pointer to bound value to transform */
162  SCIP_BOUNDTYPE* boundtype /**< pointer to type of bound: lower or upper bound */
163  );
164 
165 /** transforms given variable and domain hole to the corresponding active, fixed, or multi-aggregated variable
166  * values
167  */
168 extern
170  SCIP_VAR** var, /**< pointer to problem variable */
171  SCIP_Real* left, /**< pointer to left bound of open interval in hole to transform */
172  SCIP_Real* right /**< pointer to right bound of open interval in hole to transform */
173  );
174 
175 /** retransforms given variable, scalar and constant to the corresponding original variable, scalar
176  * and constant, if possible; if the retransformation is impossible, NULL is returned as variable
177  */
178 extern
180  SCIP_VAR** var, /**< pointer to problem variable x in sum a*x + c */
181  SCIP_Real* scalar, /**< pointer to scalar a in sum a*x + c */
182  SCIP_Real* constant /**< pointer to constant c in sum a*x + c */
183  );
184 
185 /** returns whether the given variable is the direct counterpart of an original problem variable */
186 extern
188  SCIP_VAR* var /**< problem variable */
189  );
190 
191 /** returns the number of times, a bound of the variable was changed in given direction due to branching */
192 extern
194  SCIP_VAR* var, /**< problem variable */
195  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
196  );
197 
198 /** returns the number of times, a bound of the variable was changed in given direction due to branching
199  * in the current run
200  */
201 extern
203  SCIP_VAR* var, /**< problem variable */
204  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
205  );
206 
207 /** returns the number of inferences branching on this variable in given direction triggered */
208 extern
210  SCIP_VAR* var, /**< problem variable */
211  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
212  );
213 
214 /** returns the number of inferences branching on this variable in given direction triggered
215  * in the current run
216  */
217 extern
219  SCIP_VAR* var, /**< problem variable */
220  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
221  );
222 
223 /** returns the number of cutoffs branching on this variable in given direction produced */
224 extern
226  SCIP_VAR* var, /**< problem variable */
227  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
228  );
229 
230 /** returns the number of cutoffs branching on this variable in given direction produced in the current run */
231 extern
233  SCIP_VAR* var, /**< problem variable */
234  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
235  );
236 
237 /** returns the average depth of bound changes in given direction due to branching on the variable */
238 extern
240  SCIP_VAR* var, /**< problem variable */
241  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
242  );
243 
244 /** returns the average depth of bound changes in given direction due to branching on the variable
245  * in the current run
246  */
247 extern
249  SCIP_VAR* var, /**< problem variable */
250  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
251  );
252 
253 /** returns whether there is an implication x == varfixing -> y <= b or y >= b in the implication graph;
254  * implications that are represented as cliques in the clique table are not regarded (use SCIPvarsHaveCommonClique());
255  * both variables must be active, variable x must be binary
256  */
257 extern
259  SCIP_VAR* var, /**< problem variable x */
260  SCIP_Bool varfixing, /**< FALSE if y should be searched in implications for x == 0, TRUE for x == 1 */
261  SCIP_VAR* implvar, /**< variable y to search for */
262  SCIP_BOUNDTYPE impltype /**< type of implication y <=/>= b to search for */
263  );
264 
265 /** returns whether there is an implication x == varfixing -> y == implvarfixing in the implication graph;
266  * implications that are represented as cliques in the clique table are not regarded (use SCIPvarsHaveCommonClique());
267  * both variables must be active binary variables
268  */
269 extern
271  SCIP_VAR* var, /**< problem variable x */
272  SCIP_Bool varfixing, /**< FALSE if y should be searched in implications for x == 0, TRUE for x == 1 */
273  SCIP_VAR* implvar, /**< variable y to search for */
274  SCIP_Bool implvarfixing /**< value of the implied variable to search for */
275  );
276 
277 /** returns whether there is a clique that contains both given variable/value pairs;
278  * the variables must be active binary variables;
279  * if regardimplics is FALSE, only the cliques in the clique table are looked at;
280  * if regardimplics is TRUE, both the cliques and the implications of the implication graph are regarded
281  */
282 extern
284  SCIP_VAR* var1, /**< first variable */
285  SCIP_Bool value1, /**< value of first variable */
286  SCIP_VAR* var2, /**< second variable */
287  SCIP_Bool value2, /**< value of second variable */
288  SCIP_Bool regardimplics /**< should the implication graph also be searched for a clique? */
289  );
290 
291 /** gets corresponding objective value of active, fixed, or multi-aggregated problem variable of given variable
292  * e.g. obj(x) = 1 this method returns for ~x the value -1
293  */
294 extern
296  SCIP_VAR* var, /**< problem variable */
297  SCIP_Real* aggrobj /**< pointer to store the aggregated objective value */
298  );
299 
300 /** sets the initial flag of a variable; only possible for original or loose variables */
301 extern
303  SCIP_VAR* var, /**< problem variable */
304  SCIP_Bool initial /**< initial flag */
305  );
306 
307 /** sets the removable flag of a variable; only possible for original or loose variables */
308 extern
310  SCIP_VAR* var, /**< problem variable */
311  SCIP_Bool removable /**< removable flag */
312  );
313 
314 /** returns the name of the variable
315  *
316  * @note to change the name of a variable, use SCIPchgVarName() from scip.h
317  */
318 extern
319 const char* SCIPvarGetName(
320  SCIP_VAR* var /**< problem variable */
321  );
322 
323 /** gets number of times, the variable is currently captured */
324 extern
325 int SCIPvarGetNUses(
326  SCIP_VAR* var /**< problem variable */
327  );
328 
329 /** returns the user data of the variable */
330 extern
332  SCIP_VAR* var /**< problem variable */
333  );
334 
335 /** sets the user data for the variable */
336 extern
337 void SCIPvarSetData(
338  SCIP_VAR* var, /**< problem variable */
339  SCIP_VARDATA* vardata /**< user variable data */
340  );
341 
342 /** sets method to free user data for the original variable */
343 extern
345  SCIP_VAR* var, /**< problem variable */
346  SCIP_DECL_VARDELORIG ((*vardelorig)) /**< frees user data of original variable */
347  );
348 
349 /** sets method to transform user data of the variable */
350 extern
352  SCIP_VAR* var, /**< problem variable */
353  SCIP_DECL_VARTRANS ((*vartrans)) /**< creates transformed user data by transforming original user data */
354  );
355 
356 /** sets method to free transformed user data for the variable */
357 extern
359  SCIP_VAR* var, /**< problem variable */
360  SCIP_DECL_VARDELTRANS ((*vardeltrans)) /**< frees user data of transformed variable */
361  );
362 
363 /** sets method to copy this variable into sub-SCIPs */
364 extern
365 void SCIPvarSetCopyData(
366  SCIP_VAR* var, /**< problem variable */
367  SCIP_DECL_VARCOPY ((*varcopy)) /**< copy method of the variable */
368  );
369 
370 /** gets status of variable */
371 extern
373  SCIP_VAR* var /**< problem variable */
374  );
375 
376 /** returns whether the variable belongs to the original problem */
377 extern
379  SCIP_VAR* var /**< problem variable */
380  );
381 
382 /** returns whether the variable belongs to the transformed problem */
383 extern
385  SCIP_VAR* var /**< problem variable */
386  );
387 
388 /** returns whether the variable was created by negation of a different variable */
389 extern
391  SCIP_VAR* var /**< problem variable */
392  );
393 
394 /** gets type of variable */
395 extern
397  SCIP_VAR* var /**< problem variable */
398  );
399 
400 /** returns TRUE if the variable is of binary type; this is the case if:
401  * (1) variable type is binary
402  * (2) variable type is integer or implicit integer and
403  * (i) the lazy lower bound or the global lower bound is greater or equal to zero
404  * (ii) the lazy upper bound or the global upper bound is less tor equal to one
405  */
406 extern
408  SCIP_VAR* var /**< problem variable */
409  );
410 
411 /** returns whether variable is of integral type (binary, integer, or implicit integer) */
412 extern
414  SCIP_VAR* var /**< problem variable */
415  );
416 
417 /** returns whether variable's column should be present in the initial root LP */
418 extern
420  SCIP_VAR* var /**< problem variable */
421  );
422 
423 /** returns whether variable's column is removable from the LP (due to aging or cleanup) */
424 extern
426  SCIP_VAR* var /**< problem variable */
427  );
428 
429 /** returns whether the variable was deleted from the problem */
430 extern
432  SCIP_VAR* var /**< problem variable */
433  );
434 
435 /** marks the variable to be deletable, i.e., it may be deleted completely from the problem;
436  * method can only be called before the variable is added to the problem by SCIPaddVar() or SCIPaddPricedVar()
437  */
438 extern
440  SCIP_VAR* var
441  );
442 
443 /** marks the variable to be not deletable from the problem */
444 extern
446  SCIP_VAR* var
447  );
448 
449 /** returns whether variable is allowed to be deleted completely from the problem */
450 extern
452  SCIP_VAR* var
453  );
454 
455 /** returns whether variable is an active (neither fixed nor aggregated) variable */
456 extern
458  SCIP_VAR* var /**< problem variable */
459  );
460 
461 /** gets unique index of variable */
462 extern
463 int SCIPvarGetIndex(
464  SCIP_VAR* var /**< problem variable */
465  );
466 
467 /** gets position of variable in problem, or -1 if variable is not active */
468 extern
470  SCIP_VAR* var /**< problem variable */
471  );
472 
473 /** gets transformed variable of ORIGINAL variable */
474 extern
476  SCIP_VAR* var /**< problem variable */
477  );
478 
479 /** gets column of COLUMN variable */
480 extern
482  SCIP_VAR* var /**< problem variable */
483  );
484 
485 /** returns whether the variable is a COLUMN variable that is member of the current LP */
486 extern
488  SCIP_VAR* var /**< problem variable */
489  );
490 
491 /** gets aggregation variable y of an aggregated variable x = a*y + c */
492 extern
494  SCIP_VAR* var /**< problem variable */
495  );
496 
497 /** gets aggregation scalar a of an aggregated variable x = a*y + c */
498 extern
500  SCIP_VAR* var /**< problem variable */
501  );
502 
503 /** gets aggregation constant c of an aggregated variable x = a*y + c */
504 extern
506  SCIP_VAR* var /**< problem variable */
507  );
508 
509 /** gets number n of aggregation variables of a multi aggregated variable x = a0*y0 + ... + a(n-1)*y(n-1) + c */
510 extern
512  SCIP_VAR* var /**< problem variable */
513  );
514 
515 /** gets vector of aggregation variables y of a multi aggregated variable x = a0*y0 + ... + a(n-1)*y(n-1) + c */
516 extern
518  SCIP_VAR* var /**< problem variable */
519  );
520 
521 /** gets vector of aggregation scalars a of a multi aggregated variable x = a0*y0 + ... + a(n-1)*y(n-1) + c */
522 extern
524  SCIP_VAR* var /**< problem variable */
525  );
526 
527 /** gets aggregation constant c of a multi aggregated variable x = a0*y0 + ... + a(n-1)*y(n-1) + c */
528 extern
530  SCIP_VAR* var /**< problem variable */
531  );
532 
533 /** gets the negation of the given variable; may return NULL, if no negation is existing yet */
534 extern
536  SCIP_VAR* var /**< negated problem variable */
537  );
538 
539 /** gets the negation variable x of a negated variable x' = offset - x */
540 extern
542  SCIP_VAR* var /**< negated problem variable */
543  );
544 
545 /** gets the negation offset of a negated variable x' = offset - x */
546 extern
548  SCIP_VAR* var /**< negated problem variable */
549  );
550 
551 /** gets objective function value of variable */
552 extern
554  SCIP_VAR* var /**< problem variable */
555  );
556 
557 /** gets original lower bound of original problem variable (i.e. the bound set in problem creation) */
558 extern
560  SCIP_VAR* var /**< original problem variable */
561  );
562 
563 /** gets original upper bound of original problem variable (i.e. the bound set in problem creation) */
564 extern
566  SCIP_VAR* var /**< original problem variable */
567  );
568 
569 /** gets the original hole list of an original variable */
570 extern
572  SCIP_VAR* var /**< problem variable */
573  );
574 
575 /** gets global lower bound of variable */
576 extern
578  SCIP_VAR* var /**< problem variable */
579  );
580 
581 /** gets global upper bound of variable */
582 extern
584  SCIP_VAR* var /**< problem variable */
585  );
586 
587 /** gets the global hole list of an active variable */
588 extern
590  SCIP_VAR* var /**< problem variable */
591  );
592 
593 /** gets best global bound of variable with respect to the objective function */
594 extern
596  SCIP_VAR* var /**< problem variable */
597  );
598 
599 /** gets worst global bound of variable with respect to the objective function */
600 extern
602  SCIP_VAR* var /**< problem variable */
603  );
604 
605 /** gets current lower bound of variable */
606 extern
608  SCIP_VAR* var /**< problem variable */
609  );
610 
611 /** gets current upper bound of variable */
612 extern
614  SCIP_VAR* var /**< problem variable */
615  );
616 
617 /** gets the current hole list of an active variable */
618 extern
620  SCIP_VAR* var /**< problem variable */
621  );
622 
623 /** gets best local bound of variable with respect to the objective function */
624 extern
626  SCIP_VAR* var /**< problem variable */
627  );
628 
629 /** gets worst local bound of variable with respect to the objective function */
630 extern
632  SCIP_VAR* var /**< problem variable */
633  );
634 
635 /** gets type (lower or upper) of best bound of variable with respect to the objective function */
636 extern
638  SCIP_VAR* var /**< problem variable */
639  );
640 
641 /** gets type (lower or upper) of worst bound of variable with respect to the objective function */
642 extern
644  SCIP_VAR* var /**< problem variable */
645  );
646 
647 /** gets lazy lower bound of variable */
648 extern
650  SCIP_VAR* var /**< problem variable */
651  );
652 
653 /** gets lazy upper bound of variable */
654 extern
656  SCIP_VAR* var /**< problem variable */
657  );
658 
659 /** gets the branch factor of the variable; this value can be used in the branching methods to scale the score
660  * values of the variables; higher factor leads to a higher probability that this variable is chosen for branching
661  */
662 extern
664  SCIP_VAR* var /**< problem variable */
665  );
666 
667 /** gets the branch priority of the variable; variables with higher priority should always be preferred to variables
668  * with lower priority
669  */
670 extern
672  SCIP_VAR* var /**< problem variable */
673  );
674 
675 /** gets the preferred branch direction of the variable (downwards, upwards, or auto) */
676 extern
678  SCIP_VAR* var /**< problem variable */
679  );
680 
681 /** gets number of variable lower bounds x >= b_i*z_i + d_i of given variable x */
682 extern
683 int SCIPvarGetNVlbs(
684  SCIP_VAR* var /**< problem variable */
685  );
686 
687 /** gets array with bounding variables z_i in variable lower bounds x >= b_i*z_i + d_i of given variable x;
688  * the variable bounds are sorted by increasing variable index of the bounding variable z_i (see SCIPvarGetIndex())
689  */
690 extern
692  SCIP_VAR* var /**< problem variable */
693  );
694 
695 /** gets array with bounding coefficients b_i in variable lower bounds x >= b_i*z_i + d_i of given variable x */
696 extern
698  SCIP_VAR* var /**< problem variable */
699  );
700 
701 /** gets array with bounding constants d_i in variable lower bounds x >= b_i*z_i + d_i of given variable x */
702 extern
704  SCIP_VAR* var /**< problem variable */
705  );
706 
707 /** gets number of variable upper bounds x <= b_i*z_i + d_i of given variable x */
708 extern
709 int SCIPvarGetNVubs(
710  SCIP_VAR* var /**< problem variable */
711  );
712 
713 /** gets array with bounding variables z_i in variable upper bounds x <= b_i*z_i + d_i of given variable x;
714  * the variable bounds are sorted by increasing variable index of the bounding variable z_i (see SCIPvarGetIndex())
715  */
716 extern
718  SCIP_VAR* var /**< problem variable */
719  );
720 
721 /** gets array with bounding coefficients b_i in variable upper bounds x <= b_i*z_i + d_i of given variable x */
722 extern
724  SCIP_VAR* var /**< problem variable */
725  );
726 
727 /** gets array with bounding constants d_i in variable upper bounds x <= b_i*z_i + d_i of given variable x */
728 extern
730  SCIP_VAR* var /**< problem variable */
731  );
732 
733 /** gets number of implications y <= b or y >= b for x == 0 or x == 1 of given active problem variable x,
734  * there are no implications for nonbinary variable x
735  */
736 extern
737 int SCIPvarGetNImpls(
738  SCIP_VAR* var, /**< active problem variable */
739  SCIP_Bool varfixing /**< FALSE for implications for x == 0, TRUE for x == 1 */
740  );
741 
742 /** gets number of implications y <= 0 or y >= 1 for x == 0 or x == 1 of given active problem variable x with binary y,
743  * there are no implications for nonbinary variable x
744  */
745 extern
747  SCIP_VAR* var, /**< active problem variable */
748  SCIP_Bool varfixing /**< FALSE for implications for x == 0, TRUE for x == 1 */
749  );
750 
751 /** gets array with implication variables y of implications y <= b or y >= b for x == 0 or x == 1 of given active
752  * problem variable x, there are no implications for nonbinary variable x;
753  * the implications are sorted such that implications with binary implied variables precede the ones with non-binary
754  * implied variables, and as a second criteria, the implied variables are sorted by increasing variable index
755  * (see SCIPvarGetIndex())
756  */
757 extern
759  SCIP_VAR* var, /**< active problem variable */
760  SCIP_Bool varfixing /**< FALSE for implications for x == 0, TRUE for x == 1 */
761  );
762 
763 /** gets array with implication types of implications y <= b or y >= b for x == 0 or x == 1 of given active problem
764  * variable x (SCIP_BOUNDTYPE_UPPER if y <= b, SCIP_BOUNDTYPE_LOWER if y >= b),
765  * there are no implications for nonbinary variable x
766  */
767 extern
769  SCIP_VAR* var, /**< active problem variable */
770  SCIP_Bool varfixing /**< FALSE for implications for x == 0, TRUE for x == 1 */
771  );
772 
773 /** gets array with implication bounds b of implications y <= b or y >= b for x == 0 or x == 1 of given active problem
774  * variable x, there are no implications for nonbinary variable x
775  */
776 extern
778  SCIP_VAR* var, /**< active problem variable */
779  SCIP_Bool varfixing /**< FALSE for implications for x == 0, TRUE for x == 1 */
780  );
781 
782 /** Gets array with unique ids of implications y <= b or y >= b for x == 0 or x == 1 of given active problem variable x,
783  * there are no implications for nonbinary variable x.
784  * If an implication is a shortcut, i.e., it was added as part of the transitive closure of another implication,
785  * its id is negative, otherwise it is nonnegative.
786  */
787 extern
788 int* SCIPvarGetImplIds(
789  SCIP_VAR* var, /**< active problem variable */
790  SCIP_Bool varfixing /**< FALSE for implications for x == 0, TRUE for x == 1 */
791  );
792 
793 /** gets number of cliques, the active variable is contained in */
794 extern
796  SCIP_VAR* var, /**< active problem variable */
797  SCIP_Bool varfixing /**< FALSE for cliques containing x == 0, TRUE for x == 1 */
798  );
799 
800 /** gets array of cliques, the active variable is contained in */
801 extern
803  SCIP_VAR* var, /**< active problem variable */
804  SCIP_Bool varfixing /**< FALSE for cliques containing x == 0, TRUE for x == 1 */
805  );
806 
807 /** gets primal LP solution value of variable */
808 extern
810  SCIP_VAR* var /**< problem variable */
811  );
812 
813 /** gets primal NLP solution value of variable */
814 extern
816  SCIP_VAR* var /**< problem variable */
817  );
818 
819 /** return lower bound change info at requested position */
820 extern
822  SCIP_VAR* var, /**< problem variable */
823  int pos /**< requested position */
824  );
825 
826 /** gets the number of lower bound change info array */
827 extern
829  SCIP_VAR* var /**< problem variable */
830  );
831 
832 /** return upper bound change info at requested position */
833 extern
835  SCIP_VAR* var, /**< problem variable */
836  int pos /**< requested position */
837  );
838 
839 /** gets the number upper bound change info array */
840 extern
842  SCIP_VAR* var /**< problem variable */
843  );
844 
845 /** returns the value based history for the variable */
846 extern
848  SCIP_VAR* var /**< problem variable */
849  );
850 
851 #ifdef NDEBUG
852 
853 /* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
854  * speed up the algorithms.
855  */
856 
857 #define SCIPvarGetName(var) (var)->name
858 #define SCIPvarGetNUses(var) (var)->nuses
859 #define SCIPvarGetData(var) (var)->vardata
860 #define SCIPvarSetData(var,vdata) (var)->vardata = (vdata)
861 #define SCIPvarSetDelorigData(var,func) (var)->vardelorig = (func)
862 #define SCIPvarSetTransData(var,func) (var)->vartrans = (func)
863 #define SCIPvarSetDeltransData(var,func) (var)->vardeltrans = (func)
864 #define SCIPvarGetStatus(var) (SCIP_VARSTATUS)((var)->varstatus)
865 #define SCIPvarIsOriginal(var) ((var)->varstatus == SCIP_VARSTATUS_ORIGINAL \
866  || ((var)->varstatus == SCIP_VARSTATUS_NEGATED && (var)->negatedvar->varstatus == SCIP_VARSTATUS_ORIGINAL))
867 #define SCIPvarIsTransformed(var) ((var)->varstatus != SCIP_VARSTATUS_ORIGINAL \
868  && ((var)->varstatus != SCIP_VARSTATUS_NEGATED || (var)->negatedvar->varstatus != SCIP_VARSTATUS_ORIGINAL))
869 #define SCIPvarIsNegated(var) ((var)->varstatus == SCIP_VARSTATUS_NEGATED)
870 #define SCIPvarGetType(var) ((SCIP_VARTYPE)((var)->vartype))
871 #define SCIPvarIsBinary(var) ((var)->vartype == SCIP_VARTYPE_BINARY || \
872  ((var)->vartype != SCIP_VARTYPE_CONTINUOUS && MAX((var)->glbdom.lb, (var)->lazylb) >= 0.0 && MIN((var)->glbdom.ub, (var)->lazyub) <= 1.0))
873 #define SCIPvarIsIntegral(var) ((var)->vartype != SCIP_VARTYPE_CONTINUOUS)
874 #define SCIPvarIsInitial(var) (var)->initial
875 #define SCIPvarIsRemovable(var) (var)->removable
876 #define SCIPvarIsDeleted(var) (var)->deleted
877 #define SCIPvarMarkDeletable(var) (var)->deletable = TRUE
878 #define SCIPvarMarkNotDeletable(var) (var)->deletable = FALSE
879 #define SCIPvarIsDeletable(var) (var)->deletable
880 #define SCIPvarIsActive(var) ((var)->probindex >= 0)
881 #define SCIPvarGetIndex(var) (var)->index
882 #define SCIPvarGetProbindex(var) (var)->probindex
883 #define SCIPvarGetTransVar(var) (var)->data.original.transvar
884 #define SCIPvarGetCol(var) (var)->data.col
885 #define SCIPvarIsInLP(var) ((var)->varstatus == SCIP_VARSTATUS_COLUMN && SCIPcolIsInLP((var)->data.col))
886 /* use different name for var - otherwise we have clash with the var at the end */
887 #define SCIPvarGetAggrVar(war) (war)->data.aggregate.var
888 #define SCIPvarGetAggrScalar(var) (var)->data.aggregate.scalar
889 #define SCIPvarGetAggrConstant(var) (var)->data.aggregate.constant
890 #define SCIPvarGetMultaggrNVars(var) (var)->data.multaggr.nvars
891 #define SCIPvarGetMultaggrVars(var) (var)->data.multaggr.vars
892 #define SCIPvarGetMultaggrScalars(var) (var)->data.multaggr.scalars
893 #define SCIPvarGetMultaggrConstant(var) (var)->data.multaggr.constant
894 #define SCIPvarGetNegatedVar(var) (var)->negatedvar
895 #define SCIPvarGetNegationVar(var) (var)->negatedvar
896 #define SCIPvarGetNegationConstant(var) (var)->data.negate.constant
897 #define SCIPvarGetObj(var) (var)->obj
898 #define SCIPvarGetLbOriginal(var) ((var)->varstatus == SCIP_VARSTATUS_ORIGINAL \
899  ? (var)->data.original.origdom.lb \
900  : (var)->data.negate.constant - (var)->negatedvar->data.original.origdom.ub)
901 #define SCIPvarGetUbOriginal(var) ((var)->varstatus == SCIP_VARSTATUS_ORIGINAL \
902  ? (var)->data.original.origdom.ub \
903  : (var)->data.negate.constant - (var)->negatedvar->data.original.origdom.lb)
904 #define SCIPvarGetHolelistOriginal(var) ((var)->varstatus == SCIP_VARSTATUS_ORIGINAL \
905  ? (var)->data.original.origdom.holelist \
906  : NULL)
907 #define SCIPvarGetLbGlobal(var) (var)->glbdom.lb
908 #define SCIPvarGetUbGlobal(var) (var)->glbdom.ub
909 #define SCIPvarGetHolelistGlobal(var) (var)->glbdom.holelist
910 #define SCIPvarGetBestBoundGlobal(var) ((var)->obj >= 0.0 ? (var)->glbdom.lb : (var)->glbdom.ub)
911 #define SCIPvarGetWorstBoundGlobal(var) ((var)->obj >= 0.0 ? (var)->glbdom.ub : (var)->glbdom.lb)
912 #define SCIPvarGetLbLocal(var) (var)->locdom.lb
913 #define SCIPvarGetUbLocal(var) (var)->locdom.ub
914 #define SCIPvarGetHolelistLocal(var) (var)->locdom.holelist
915 #define SCIPvarGetBestBoundLocal(var) ((var)->obj >= 0.0 ? (var)->locdom.lb : (var)->locdom.ub)
916 #define SCIPvarGetWorstBoundLocal(var) ((var)->obj >= 0.0 ? (var)->locdom.ub : (var)->locdom.lb)
917 #define SCIPvarGetBestBoundType(var) ((var)->obj >= 0.0 ? SCIP_BOUNDTYPE_LOWER : SCIP_BOUNDTYPE_UPPER)
918 #define SCIPvarGetWorstBoundType(var) ((var)->obj >= 0.0 ? SCIP_BOUNDTYPE_UPPER : SCIP_BOUNDTYPE_LOWER)
919 #define SCIPvarGetLbLazy(var) (var)->lazylb
920 #define SCIPvarGetUbLazy(var) (var)->lazyub
921 #define SCIPvarGetBranchFactor(var) (var)->branchfactor
922 #define SCIPvarGetBranchPriority(var) (var)->branchpriority
923 #define SCIPvarGetBranchDirection(var) (var)->branchdirection
924 #define SCIPvarGetNVlbs(var) (SCIPvboundsGetNVbds((var)->vlbs))
925 #define SCIPvarGetVlbVars(var) (SCIPvboundsGetVars((var)->vlbs))
926 #define SCIPvarGetVlbCoefs(var) (SCIPvboundsGetCoefs((var)->vlbs))
927 #define SCIPvarGetVlbConstants(var) (SCIPvboundsGetConstants((var)->vlbs))
928 #define SCIPvarGetNVubs(var) (SCIPvboundsGetNVbds((var)->vubs))
929 #define SCIPvarGetVubVars(var) (SCIPvboundsGetVars((var)->vubs))
930 #define SCIPvarGetVubCoefs(var) (SCIPvboundsGetCoefs((var)->vubs))
931 #define SCIPvarGetVubConstants(var) (SCIPvboundsGetConstants((var)->vubs))
932 #define SCIPvarGetNImpls(var, fix) (SCIPimplicsGetNImpls((var)->implics, fix))
933 #define SCIPvarGetNBinImpls(var, fix) (SCIPimplicsGetNBinImpls((var)->implics, fix))
934 #define SCIPvarGetImplVars(var, fix) (SCIPimplicsGetVars((var)->implics, fix))
935 #define SCIPvarGetImplTypes(var, fix) (SCIPimplicsGetTypes((var)->implics, fix))
936 #define SCIPvarGetImplBounds(var, fix) (SCIPimplicsGetBounds((var)->implics, fix))
937 #define SCIPvarGetImplIds(var, fix) (SCIPimplicsGetIds((var)->implics, fix))
938 #define SCIPvarGetNCliques(var, fix) (SCIPcliquelistGetNCliques((var)->cliquelist, fix))
939 #define SCIPvarGetCliques(var, fix) (SCIPcliquelistGetCliques((var)->cliquelist, fix))
940 #define SCIPvarGetLPSol(var) ((var)->varstatus == SCIP_VARSTATUS_COLUMN ? SCIPcolGetPrimsol((var)->data.col) : SCIPvarGetLPSol_rec(var))
941 #define SCIPvarGetNLPSol(var) (((var)->varstatus == SCIP_VARSTATUS_COLUMN || ((var)->varstatus == SCIP_VARSTATUS_LOOSE)) ? (var)->nlpsol : SCIPvarGetNLPSol_rec(var))
942 #define SCIPvarGetBdchgInfoLb(var, pos) (&((var)->lbchginfos[pos]))
943 #define SCIPvarGetNBdchgInfosLb(var) ((var)->nlbchginfos)
944 #define SCIPvarGetBdchgInfoUb(var, pos) (&((var)->ubchginfos[pos]))
945 #define SCIPvarGetNBdchgInfosUb(var) ((var)->nubchginfos)
946 #define SCIPvarGetValuehistory(var) (var)->valuehistory
947 
948 #endif
949 
950 /** gets primal LP solution value of variable */
951 extern
953  SCIP_VAR* var /**< problem variable */
954  );
955 
956 /** gets primal NLP solution value of variable */
957 extern
959  SCIP_VAR* var /**< problem variable */
960  );
961 
962 /** gets pseudo solution value of variable at current node */
963 extern
965  SCIP_VAR* var /**< problem variable */
966  );
967 
968 /** gets current LP or pseudo solution value of variable */
969 extern
971  SCIP_VAR* var, /**< problem variable */
972  SCIP_Bool getlpval /**< should the LP solution value be returned? */
973  );
974 
975 /** returns the solution of the variable in the last root node's relaxation, if the root relaxation is not yet
976  * completely solved, zero is returned
977  */
978 extern
980  SCIP_VAR* var /**< problem variable */
981  );
982 
983 /** returns the best solution (w.r.t. root reduced cost propagation) of the variable in the root node's relaxation, if
984  * the root relaxation is not yet completely solved, zero is returned
985  */
986 extern
988  SCIP_VAR* var /**< problem variable */
989  );
990 
991 /** returns the best reduced costs (w.r.t. root reduced cost propagation) of the variable in the root node's relaxation,
992  * if the root relaxation is not yet completely solved, or the variable was no column of the root LP, SCIP_INVALID is
993  * returned
994  */
995 extern
997  SCIP_VAR* var /**< problem variable */
998  );
999 
1000 /** returns the best objective value (w.r.t. root reduced cost propagation) of the root LP which belongs the root
1001  * reduced cost which is accessible via SCIPvarGetRootRedcost() or the variable was no column of the root LP,
1002  * SCIP_INVALID is returned
1003  */
1004 extern
1006  SCIP_VAR* var /**< problem variable */
1007  );
1008 
1009 /** set the given solution as the best root solution w.r.t. root reduced cost propagation in the variables */
1010 extern
1012  SCIP_VAR* var, /**< problem variable */
1013  SCIP_Real rootsol, /**< root solution value */
1014  SCIP_Real rootredcost, /**< root reduced cost */
1015  SCIP_Real rootlpobjval /**< objective value of the root LP */
1016  );
1017 
1018 /** returns a weighted average solution value of the variable in all feasible primal solutions found so far */
1019 extern
1021  SCIP_VAR* var /**< problem variable */
1022  );
1023 
1024 /** returns the bound change information for the last lower bound change on given active problem variable before or
1025  * after the bound change with the given index was applied;
1026  * returns NULL, if no change to the lower bound was applied up to this point of time
1027  */
1028 extern
1030  SCIP_VAR* var, /**< active problem variable */
1031  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
1032  SCIP_Bool after /**< should the bound change with given index be included? */
1033  );
1034 
1035 /** returns the bound change information for the last upper bound change on given active problem variable before or
1036  * after the bound change with the given index was applied;
1037  * returns NULL, if no change to the upper bound was applied up to this point of time
1038  */
1039 extern
1041  SCIP_VAR* var, /**< active problem variable */
1042  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
1043  SCIP_Bool after /**< should the bound change with given index be included? */
1044  );
1045 
1046 /** returns the bound change information for the last lower or upper bound change on given active problem variable
1047  * before or after the bound change with the given index was applied;
1048  * returns NULL, if no change to the lower/upper bound was applied up to this point of time
1049  */
1050 extern
1052  SCIP_VAR* var, /**< active problem variable */
1053  SCIP_BOUNDTYPE boundtype, /**< type of bound: lower or upper bound */
1054  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
1055  SCIP_Bool after /**< should the bound change with given index be included? */
1056  );
1057 
1058 /** returns lower bound of variable directly before or after the bound change given by the bound change index
1059  * was applied
1060  */
1061 extern
1063  SCIP_VAR* var, /**< problem variable */
1064  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
1065  SCIP_Bool after /**< should the bound change with given index be included? */
1066  );
1067 
1068 /** returns upper bound of variable directly before or after the bound change given by the bound change index
1069  * was applied
1070  */
1071 extern
1073  SCIP_VAR* var, /**< problem variable */
1074  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
1075  SCIP_Bool after /**< should the bound change with given index be included? */
1076  );
1077 
1078 /** returns lower or upper bound of variable directly before or after the bound change given by the bound change index
1079  * was applied
1080  */
1081 extern
1083  SCIP_VAR* var, /**< problem variable */
1084  SCIP_BOUNDTYPE boundtype, /**< type of bound: lower or upper bound */
1085  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
1086  SCIP_Bool after /**< should the bound change with given index be included? */
1087  );
1088 
1089 /** returns whether the binary variable was fixed at the time given by the bound change index */
1090 extern
1092  SCIP_VAR* var, /**< problem variable */
1093  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
1094  SCIP_Bool after /**< should the bound change with given index be included? */
1095  );
1096 
1097 /** returns the last bound change index, at which the bounds of the given variable were tightened */
1098 extern
1100  SCIP_VAR* var /**< problem variable */
1101  );
1102 
1103 /** returns the last depth level, at which the bounds of the given variable were tightened;
1104  * returns -2, if the variable's bounds are still the global bounds
1105  * returns -1, if the variable was fixed in presolving
1106  */
1107 extern
1109  SCIP_VAR* var /**< problem variable */
1110  );
1111 
1112 /** returns whether the first binary variable was fixed earlier than the second one;
1113  * returns FALSE, if the first variable is not fixed, and returns TRUE, if the first variable is fixed, but the
1114  * second one is not fixed
1115  */
1116 extern
1118  SCIP_VAR* var1, /**< first binary variable */
1119  SCIP_VAR* var2 /**< second binary variable */
1120  );
1121 
1122 /** returns whether first bound change index belongs to an earlier applied bound change than second one;
1123  * if a bound change index is NULL, the bound change index represents the current time, i.e. the time after the
1124  * last bound change was applied to the current node
1125  */
1126 extern
1128  SCIP_BDCHGIDX* bdchgidx1, /**< first bound change index, or NULL */
1129  SCIP_BDCHGIDX* bdchgidx2 /**< second bound change index, or NULL */
1130  );
1131 
1132 /** returns whether first bound change index belongs to an earlier applied bound change than second one */
1133 extern
1135  SCIP_BDCHGIDX* bdchgidx1, /**< first bound change index */
1136  SCIP_BDCHGIDX* bdchgidx2 /**< second bound change index */
1137  );
1138 
1139 /** returns old bound that was overwritten for given bound change information */
1140 extern
1142  SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1143  );
1144 
1145 /** returns new bound installed for given bound change information */
1146 extern
1148  SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1149  );
1150 
1151 /** returns variable that belongs to the given bound change information */
1152 extern
1154  SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1155  );
1156 
1157 /** returns whether the bound change information belongs to a branching decision or a deduction */
1158 extern
1160  SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1161  );
1162 
1163 /** returns whether the bound change information belongs to a lower or upper bound change */
1164 extern
1166  SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1167  );
1168 
1169 /** returns depth level of given bound change information */
1170 extern
1172  SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1173  );
1174 
1175 /** returns bound change position in its depth level of given bound change information */
1176 extern
1178  SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1179  );
1180 
1181 /** returns bound change index of given bound change information */
1182 extern
1184  SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1185  );
1186 
1187 /** returns inference variable of given bound change information */
1188 extern
1190  SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1191  );
1192 
1193 /** returns inference constraint of given bound change information */
1194 extern
1196  SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1197  );
1198 
1199 /** returns inference propagator of given bound change information, or NULL if no propagator was responsible */
1200 extern
1202  SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1203  );
1204 
1205 /** returns inference user information of given bound change information */
1206 extern
1208  SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1209  );
1210 
1211 /** returns inference bound of inference variable of given bound change information */
1212 extern
1214  SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1215  );
1216 
1217 /** returns whether the bound change information belongs to a redundant bound change */
1218 extern
1220  SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1221  );
1222 
1223 /** returns whether the bound change has an inference reason (constraint or propagator), that can be resolved */
1224 extern
1226  SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1227  );
1228 
1229 /** for two bound change informations belonging to the same variable and bound, returns whether the first bound change
1230  * has a tighter new bound as the second bound change
1231  */
1232 extern
1234  SCIP_BDCHGINFO* bdchginfo1, /**< first bound change information */
1235  SCIP_BDCHGINFO* bdchginfo2 /**< second bound change information */
1236  );
1237 
1238 /** returns the new value of the bound in the bound change data */
1239 extern
1241  SCIP_BOUNDCHG* boundchg /**< bound change data */
1242  );
1243 
1244 /** returns the variable of the bound change in the bound change data */
1245 extern
1247  SCIP_BOUNDCHG* boundchg /**< bound change data */
1248  );
1249 
1250 /** returns the bound change type of the bound change in the bound change data */
1251 extern
1253  SCIP_BOUNDCHG* boundchg /**< bound change data */
1254  );
1255 
1256 /** returns the bound type of the bound change in the bound change data */
1257 extern
1259  SCIP_BOUNDCHG* boundchg /**< bound change data */
1260  );
1261 
1262 /** returns whether the bound change is redundant due to a more global bound that is at least as strong */
1263 extern
1265  SCIP_BOUNDCHG* boundchg /**< bound change data */
1266  );
1267 
1268 /** returns the number of bound changes in the domain change data */
1269 extern
1271  SCIP_DOMCHG* domchg /**< domain change data */
1272  );
1273 
1274 /** returns a particular bound change in the domain change data */
1275 extern
1277  SCIP_DOMCHG* domchg, /**< domain change data */
1278  int pos /**< position of the bound change in the domain change data */
1279  );
1280 
1281 /** returns left bound of open interval in hole */
1282 extern
1284  SCIP_HOLELIST* holelist /**< hole list pointer to hole of interest */
1285  );
1286 
1287 /** returns right bound of open interval in hole */
1288 extern
1290  SCIP_HOLELIST* holelist /**< hole list pointer to hole of interest */
1291  );
1292 
1293 /** returns next hole in list or NULL */
1294 extern
1296  SCIP_HOLELIST* holelist /**< hole list pointer to hole of interest */
1297  );
1298 
1299 #ifdef NDEBUG
1300 
1301 /* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
1302  * speed up the algorithms.
1303  */
1304 
1305 #define SCIPbdchgidxIsEarlierNonNull(idx1,idx2) \
1306  ((idx1)->depth < (idx2)->depth || ((idx1)->depth == (idx2)->depth && (idx1)->pos < (idx2)->pos))
1307 #define SCIPbdchgidxIsEarlier(idx1,idx2) \
1308  ((idx1) != NULL && ((idx2) == NULL || SCIPbdchgidxIsEarlierNonNull(idx1, idx2)))
1309 #define SCIPbdchginfoGetOldbound(bdchginfo) (bdchginfo)->oldbound
1310 #define SCIPbdchginfoGetNewbound(bdchginfo) (bdchginfo)->newbound
1311 #define SCIPbdchginfoGetVar(bdchginfo) (bdchginfo)->var
1312 #define SCIPbdchginfoGetChgtype(bdchginfo) (SCIP_BOUNDCHGTYPE)((bdchginfo)->boundchgtype)
1313 #define SCIPbdchginfoGetBoundtype(bdchginfo) (SCIP_BOUNDTYPE)((bdchginfo)->boundtype)
1314 #define SCIPbdchginfoGetDepth(bdchginfo) (bdchginfo)->bdchgidx.depth
1315 #define SCIPbdchginfoGetPos(bdchginfo) (bdchginfo)->bdchgidx.pos
1316 #define SCIPbdchginfoGetIdx(bdchginfo) (&(bdchginfo)->bdchgidx)
1317 #define SCIPbdchginfoGetInferVar(bdchginfo) (bdchginfo)->inferencedata.var
1318 #define SCIPbdchginfoGetInferCons(bdchginfo) (bdchginfo)->inferencedata.reason.cons
1319 #define SCIPbdchginfoGetInferProp(bdchginfo) (bdchginfo)->inferencedata.reason.prop
1320 #define SCIPbdchginfoGetInferInfo(bdchginfo) (bdchginfo)->inferencedata.info
1321 #define SCIPbdchginfoGetInferBoundtype(bdchginfo) (SCIP_BOUNDTYPE)((bdchginfo)->inferboundtype)
1322 #define SCIPbdchginfoIsRedundant(bdchginfo) (bdchginfo)->redundant
1323 #define SCIPbdchginfoHasInferenceReason(bdchginfo) \
1324  (((bdchginfo)->boundchgtype == SCIP_BOUNDCHGTYPE_CONSINFER) \
1325  || ((bdchginfo)->boundchgtype == SCIP_BOUNDCHGTYPE_PROPINFER && (bdchginfo)->inferencedata.reason.prop != NULL))
1326 #define SCIPbdchginfoIsTighter(bdchginfo1,bdchginfo2) ((bdchginfo1)->boundtype == SCIP_BOUNDTYPE_LOWER \
1327  ? (bdchginfo1)->newbound > bdchginfo2->newbound : (bdchginfo1)->newbound < bdchginfo2->newbound)
1328 #define SCIPboundchgGetNewbound(boundchg) ((boundchg)->newbound)
1329 #define SCIPboundchgGetVar(boundchg) ((boundchg)->var)
1330 #define SCIPboundchgGetBoundchgtype(boundchg) ((SCIP_BOUNDCHGTYPE)((boundchg)->boundchgtype))
1331 #define SCIPboundchgGetBoundtype(boundchg) ((SCIP_BOUNDTYPE)((boundchg)->boundtype))
1332 #define SCIPboundchgIsRedundant(boundchg) ((boundchg)->redundant)
1333 #define SCIPdomchgGetNBoundchgs(domchg) ((domchg) != NULL ? (domchg)->domchgbound.nboundchgs : 0)
1334 #define SCIPdomchgGetBoundchg(domchg, pos) (&(domchg)->domchgbound.boundchgs[pos])
1335 #define SCIPholelistGetLeft(holelist) ((holelist)->hole.left)
1336 #define SCIPholelistGetRight(holelist) ((holelist)->hole.right)
1337 #define SCIPholelistGetNext(holelist) ((holelist)->next)
1338 
1339 #endif
1340 
1341 #ifdef __cplusplus
1342 }
1343 #endif
1344 
1345 #endif
1346