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-2017 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 PUBLICCOREAPI
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 /**@addtogroup PublicVariableMethods
51  *
52  * @{
53  */
54 
55 /** gets number of locks for rounding down */
56 extern
58  SCIP_VAR* var /**< problem variable */
59  );
60 
61 /** gets number of locks for rounding up */
62 extern
64  SCIP_VAR* var /**< problem variable */
65  );
66 
67 /** is it possible, to round variable down and stay feasible? */
68 extern
70  SCIP_VAR* var /**< problem variable */
71  );
72 
73 /** is it possible, to round variable up and stay feasible? */
74 extern
76  SCIP_VAR* var /**< problem variable */
77  );
78 
79 /** compares the index of two variables, only active or negated variables are allowed, if a variable
80  * is negated then the index of the corresponding active variable is taken, returns -1 if first is
81  * smaller than, and +1 if first is greater than second variable index; returns 0 if both indices
82  * are equal, which means both variables are equal
83  */
84 extern
86  SCIP_VAR* var1, /**< first problem variable */
87  SCIP_VAR* var2 /**< second problem variable */
88  );
89 
90 /** comparison method for sorting active and negated variables by non-decreasing index, active and negated
91  * variables are handled as the same variables
92  */
93 extern
94 SCIP_DECL_SORTPTRCOMP(SCIPvarCompActiveAndNegated);
95 
96 /** compares the index of two variables, returns -1 if first is smaller than, and +1 if first is greater than second
97  * variable index; returns 0 if both indices are equal, which means both variables are equal
98  */
99 extern
100 int SCIPvarCompare(
101  SCIP_VAR* var1, /**< first problem variable */
102  SCIP_VAR* var2 /**< second problem variable */
103  );
104 
105 /** comparison method for sorting variables by non-decreasing index */
106 extern
107 SCIP_DECL_SORTPTRCOMP(SCIPvarComp);
108 
109 /** comparison method for sorting variables by non-decreasing objective coefficient */
110 extern
111 SCIP_DECL_SORTPTRCOMP(SCIPvarCompObj);
112 
113 /** hash key retrieval function for variables */
114 extern
115 SCIP_DECL_HASHGETKEY(SCIPvarGetHashkey);
116 
117 /** returns TRUE iff the indices of both variables are equal */
118 extern
119 SCIP_DECL_HASHKEYEQ(SCIPvarIsHashkeyEq);
120 
121 /** returns the hash value of the key */
122 extern
123 SCIP_DECL_HASHKEYVAL(SCIPvarGetHashkeyVal);
124 
125 
126 /** gets corresponding active, fixed, or multi-aggregated problem variables of given variables,
127  * @note the content of the given array will/might change
128  */
129 extern
130 void SCIPvarsGetProbvar(
131  SCIP_VAR** vars, /**< array of problem variables */
132  int nvars /**< number of variables */
133  );
134 
135 /** gets corresponding active, fixed, or multi-aggregated problem variable of a variable */
136 extern
138  SCIP_VAR* var /**< problem variable */
139  );
140 
141 /** gets corresponding active, fixed, or multi-aggregated problem variables of binary variables and
142  * updates the given negation status of each variable
143  */
144 extern
146  SCIP_VAR*** vars, /**< pointer to binary problem variables */
147  SCIP_Bool** negatedarr, /**< pointer to corresponding array to update the negation status */
148  int nvars /**< number of variables and values in vars and negated array */
149  );
150 
151 /** gets corresponding active, fixed, or multi-aggregated problem variable of a binary variable and
152  * updates the given negation status
153  */
154 extern
156  SCIP_VAR** var, /**< pointer to binary problem variable */
157  SCIP_Bool* negated /**< pointer to update the negation status */
158  );
159 
160 /** transforms given variable, boundtype and bound to the corresponding active, fixed, or multi-aggregated variable
161  * values
162  */
163 extern
165  SCIP_VAR** var, /**< pointer to problem variable */
166  SCIP_Real* bound, /**< pointer to bound value to transform */
167  SCIP_BOUNDTYPE* boundtype /**< pointer to type of bound: lower or upper bound */
168  );
169 
170 /** transforms given variable and domain hole to the corresponding active, fixed, or multi-aggregated variable
171  * values
172  */
173 extern
175  SCIP_VAR** var, /**< pointer to problem variable */
176  SCIP_Real* left, /**< pointer to left bound of open interval in hole to transform */
177  SCIP_Real* right /**< pointer to right bound of open interval in hole to transform */
178  );
179 
180 /** retransforms given variable, scalar and constant to the corresponding original variable, scalar
181  * and constant, if possible; if the retransformation is impossible, NULL is returned as variable
182  */
183 extern
185  SCIP_VAR** var, /**< pointer to problem variable x in sum a*x + c */
186  SCIP_Real* scalar, /**< pointer to scalar a in sum a*x + c */
187  SCIP_Real* constant /**< pointer to constant c in sum a*x + c */
188  );
189 
190 /** returns whether the given variable is the direct counterpart of an original problem variable */
191 extern
193  SCIP_VAR* var /**< problem variable */
194  );
195 
196 /** returns the number of times, a bound of the variable was changed in given direction due to branching */
197 extern
199  SCIP_VAR* var, /**< problem variable */
200  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
201  );
202 
203 /** returns the number of times, a bound of the variable was changed in given direction due to branching
204  * in the current run
205  */
206 extern
208  SCIP_VAR* var, /**< problem variable */
209  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
210  );
211 
212 /** returns the number of inferences branching on this variable in given direction triggered */
213 extern
215  SCIP_VAR* var, /**< problem variable */
216  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
217  );
218 
219 /** returns the number of inferences branching on this variable in given direction triggered
220  * in the current run
221  */
222 extern
224  SCIP_VAR* var, /**< problem variable */
225  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
226  );
227 
228 /** returns the number of cutoffs branching on this variable in given direction produced */
229 extern
231  SCIP_VAR* var, /**< problem variable */
232  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
233  );
234 
235 /** returns the number of cutoffs branching on this variable in given direction produced in the current run */
236 extern
238  SCIP_VAR* var, /**< problem variable */
239  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
240  );
241 
242 /** returns the average depth of bound changes in given direction due to branching on the variable */
243 extern
245  SCIP_VAR* var, /**< problem variable */
246  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
247  );
248 
249 /** returns the average depth of bound changes in given direction due to branching on the variable
250  * in the current run
251  */
252 extern
254  SCIP_VAR* var, /**< problem variable */
255  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
256  );
257 
258 /** returns whether there is an implication x == varfixing -> y <= b or y >= b in the implication graph;
259  * implications that are represented as cliques in the clique table are not regarded (use SCIPvarsHaveCommonClique());
260  * both variables must be active, variable x must be binary
261  */
262 extern
264  SCIP_VAR* var, /**< problem variable x */
265  SCIP_Bool varfixing, /**< FALSE if y should be searched in implications for x == 0, TRUE for x == 1 */
266  SCIP_VAR* implvar, /**< variable y to search for */
267  SCIP_BOUNDTYPE impltype /**< type of implication y <=/>= b to search for */
268  );
269 
270 /** returns whether there is an implication x == varfixing -> y == implvarfixing in the implication graph;
271  * implications that are represented as cliques in the clique table are not regarded (use SCIPvarsHaveCommonClique());
272  * both variables must be active binary variables
273  */
274 extern
276  SCIP_VAR* var, /**< problem variable x */
277  SCIP_Bool varfixing, /**< FALSE if y should be searched in implications for x == 0, TRUE for x == 1 */
278  SCIP_VAR* implvar, /**< variable y to search for */
279  SCIP_Bool implvarfixing /**< value of the implied variable to search for */
280  );
281 
282 /** returns whether there is a clique that contains both given variable/value pairs;
283  * the variables must be active binary variables;
284  * if regardimplics is FALSE, only the cliques in the clique table are looked at;
285  * if regardimplics is TRUE, both the cliques and the implications of the implication graph are regarded
286  */
287 extern
289  SCIP_VAR* var1, /**< first variable */
290  SCIP_Bool value1, /**< value of first variable */
291  SCIP_VAR* var2, /**< second variable */
292  SCIP_Bool value2, /**< value of second variable */
293  SCIP_Bool regardimplics /**< should the implication graph also be searched for a clique? */
294  );
295 
296 /** gets corresponding objective value of active, fixed, or multi-aggregated problem variable of given variable
297  * e.g. obj(x) = 1 this method returns for ~x the value -1
298  */
299 extern
301  SCIP_VAR* var, /**< problem variable */
302  SCIP_Real* aggrobj /**< pointer to store the aggregated objective value */
303  );
304 
305 /** sets the initial flag of a variable; only possible for original or loose variables */
306 extern
308  SCIP_VAR* var, /**< problem variable */
309  SCIP_Bool initial /**< initial flag */
310  );
311 
312 /** sets the removable flag of a variable; only possible for original or loose variables */
313 extern
315  SCIP_VAR* var, /**< problem variable */
316  SCIP_Bool removable /**< removable flag */
317  );
318 
319 /** returns the name of the variable
320  *
321  * @note to change the name of a variable, use SCIPchgVarName() from scip.h
322  */
323 extern
324 const char* SCIPvarGetName(
325  SCIP_VAR* var /**< problem variable */
326  );
327 
328 /** gets number of times, the variable is currently captured */
329 extern
330 int SCIPvarGetNUses(
331  SCIP_VAR* var /**< problem variable */
332  );
333 
334 /** returns the user data of the variable */
335 extern
337  SCIP_VAR* var /**< problem variable */
338  );
339 
340 /** sets the user data for the variable */
341 extern
342 void SCIPvarSetData(
343  SCIP_VAR* var, /**< problem variable */
344  SCIP_VARDATA* vardata /**< user variable data */
345  );
346 
347 /** sets method to free user data for the original variable */
348 extern
350  SCIP_VAR* var, /**< problem variable */
351  SCIP_DECL_VARDELORIG ((*vardelorig)) /**< frees user data of original variable */
352  );
353 
354 /** sets method to transform user data of the variable */
355 extern
357  SCIP_VAR* var, /**< problem variable */
358  SCIP_DECL_VARTRANS ((*vartrans)) /**< creates transformed user data by transforming original user data */
359  );
360 
361 /** sets method to free transformed user data for the variable */
362 extern
364  SCIP_VAR* var, /**< problem variable */
365  SCIP_DECL_VARDELTRANS ((*vardeltrans)) /**< frees user data of transformed variable */
366  );
367 
368 /** sets method to copy this variable into sub-SCIPs */
369 extern
370 void SCIPvarSetCopyData(
371  SCIP_VAR* var, /**< problem variable */
372  SCIP_DECL_VARCOPY ((*varcopy)) /**< copy method of the variable */
373  );
374 
375 /** gets status of variable */
376 extern
378  SCIP_VAR* var /**< problem variable */
379  );
380 
381 /** returns whether the variable belongs to the original problem */
382 extern
384  SCIP_VAR* var /**< problem variable */
385  );
386 
387 /** returns whether the variable belongs to the transformed problem */
388 extern
390  SCIP_VAR* var /**< problem variable */
391  );
392 
393 /** returns whether the variable was created by negation of a different variable */
394 extern
396  SCIP_VAR* var /**< problem variable */
397  );
398 
399 /** gets type of variable */
400 extern
402  SCIP_VAR* var /**< problem variable */
403  );
404 
405 /** returns TRUE if the variable is of binary type; this is the case if:
406  * (1) variable type is binary
407  * (2) variable type is integer or implicit integer and
408  * (i) the lazy lower bound or the global lower bound is greater than or equal to zero
409  * (ii) the lazy upper bound or the global upper bound is less than or equal to one
410  */
411 extern
413  SCIP_VAR* var /**< problem variable */
414  );
415 
416 /** returns whether variable is of integral type (binary, integer, or implicit integer) */
417 extern
419  SCIP_VAR* var /**< problem variable */
420  );
421 
422 /** returns whether variable's column should be present in the initial root LP */
423 extern
425  SCIP_VAR* var /**< problem variable */
426  );
427 
428 /** returns whether variable's column is removable from the LP (due to aging or cleanup) */
429 extern
431  SCIP_VAR* var /**< problem variable */
432  );
433 
434 /** returns whether the variable was deleted from the problem */
435 extern
437  SCIP_VAR* var /**< problem variable */
438  );
439 
440 /** marks the variable to be deletable, i.e., it may be deleted completely from the problem;
441  * method can only be called before the variable is added to the problem by SCIPaddVar() or SCIPaddPricedVar()
442  */
443 extern
445  SCIP_VAR* var /**< problem variable */
446  );
447 
448 /** marks the variable to be not deletable from the problem */
449 extern
451  SCIP_VAR* var
452  );
453 
454 /** returns whether variable is allowed to be deleted completely from the problem */
455 extern
457  SCIP_VAR* var
458  );
459 
460 /** marks variable to be deleted from global structures (cliques etc.) when cleaning up
461  *
462  * @note: this is not equivalent to marking the variable itself for deletion, this is done by using SCIPvarMarkDeletable()
463  */
464 extern
466  SCIP_VAR* var /**< problem variable */
467  );
468 
469 /** returns whether variable is an active (neither fixed nor aggregated) variable */
470 extern
472  SCIP_VAR* var /**< problem variable */
473  );
474 
475 /** gets unique index of variable */
476 extern
477 int SCIPvarGetIndex(
478  SCIP_VAR* var /**< problem variable */
479  );
480 
481 /** gets position of variable in problem, or -1 if variable is not active */
482 extern
484  SCIP_VAR* var /**< problem variable */
485  );
486 
487 /** gets transformed variable of ORIGINAL variable */
488 extern
490  SCIP_VAR* var /**< problem variable */
491  );
492 
493 /** gets column of COLUMN variable */
494 extern
496  SCIP_VAR* var /**< problem variable */
497  );
498 
499 /** returns whether the variable is a COLUMN variable that is member of the current LP */
500 extern
502  SCIP_VAR* var /**< problem variable */
503  );
504 
505 /** gets aggregation variable y of an aggregated variable x = a*y + c */
506 extern
508  SCIP_VAR* var /**< problem variable */
509  );
510 
511 /** gets aggregation scalar a of an aggregated variable x = a*y + c */
512 extern
514  SCIP_VAR* var /**< problem variable */
515  );
516 
517 /** gets aggregation constant c of an aggregated variable x = a*y + c */
518 extern
520  SCIP_VAR* var /**< problem variable */
521  );
522 
523 /** gets number n of aggregation variables of a multi aggregated variable x = a0*y0 + ... + a(n-1)*y(n-1) + c */
524 extern
526  SCIP_VAR* var /**< problem variable */
527  );
528 
529 /** gets vector of aggregation variables y of a multi aggregated variable x = a0*y0 + ... + a(n-1)*y(n-1) + c */
530 extern
532  SCIP_VAR* var /**< problem variable */
533  );
534 
535 /** gets vector of aggregation scalars a of a multi aggregated variable x = a0*y0 + ... + a(n-1)*y(n-1) + c */
536 extern
538  SCIP_VAR* var /**< problem variable */
539  );
540 
541 /** gets aggregation constant c of a multi aggregated variable x = a0*y0 + ... + a(n-1)*y(n-1) + c */
542 extern
544  SCIP_VAR* var /**< problem variable */
545  );
546 
547 /** gets the negation of the given variable; may return NULL, if no negation is existing yet */
548 extern
550  SCIP_VAR* var /**< negated problem variable */
551  );
552 
553 /** gets the negation variable x of a negated variable x' = offset - x */
554 extern
556  SCIP_VAR* var /**< negated problem variable */
557  );
558 
559 /** gets the negation offset of a negated variable x' = offset - x */
560 extern
562  SCIP_VAR* var /**< negated problem variable */
563  );
564 
565 /** gets objective function value of variable */
566 extern
568  SCIP_VAR* var /**< problem variable */
569  );
570 
571 /** gets the unchanged objective function value of variable (ignoring temproray changes performed in probing mode) */
572 extern
574  SCIP_VAR* var /**< problem variable */
575  );
576 
577 /** gets original lower bound of original problem variable (i.e. the bound set in problem creation) */
578 extern
580  SCIP_VAR* var /**< original problem variable */
581  );
582 
583 /** gets original upper bound of original problem variable (i.e. the bound set in problem creation) */
584 extern
586  SCIP_VAR* var /**< original problem variable */
587  );
588 
589 /** gets the original hole list of an original variable */
590 extern
592  SCIP_VAR* var /**< problem variable */
593  );
594 
595 /** gets global lower bound of variable */
596 extern
598  SCIP_VAR* var /**< problem variable */
599  );
600 
601 /** gets global upper bound of variable */
602 extern
604  SCIP_VAR* var /**< problem variable */
605  );
606 
607 /** gets the global hole list of an active variable */
608 extern
610  SCIP_VAR* var /**< problem variable */
611  );
612 
613 /** gets best global bound of variable with respect to the objective function */
614 extern
616  SCIP_VAR* var /**< problem variable */
617  );
618 
619 /** gets worst global bound of variable with respect to the objective function */
620 extern
622  SCIP_VAR* var /**< problem variable */
623  );
624 
625 /** gets current lower bound of variable */
626 extern
628  SCIP_VAR* var /**< problem variable */
629  );
630 
631 /** gets current upper bound of variable */
632 extern
634  SCIP_VAR* var /**< problem variable */
635  );
636 
637 /** gets the current hole list of an active variable */
638 extern
640  SCIP_VAR* var /**< problem variable */
641  );
642 
643 /** gets best local bound of variable with respect to the objective function */
644 extern
646  SCIP_VAR* var /**< problem variable */
647  );
648 
649 /** gets worst local bound of variable with respect to the objective function */
650 extern
652  SCIP_VAR* var /**< problem variable */
653  );
654 
655 /** gets type (lower or upper) of best bound of variable with respect to the objective function */
656 extern
658  SCIP_VAR* var /**< problem variable */
659  );
660 
661 /** gets type (lower or upper) of worst bound of variable with respect to the objective function */
662 extern
664  SCIP_VAR* var /**< problem variable */
665  );
666 
667 /** gets lazy lower bound of variable */
668 extern
670  SCIP_VAR* var /**< problem variable */
671  );
672 
673 /** gets lazy upper bound of variable */
674 extern
676  SCIP_VAR* var /**< problem variable */
677  );
678 
679 /** gets the branch factor of the variable; this value can be used in the branching methods to scale the score
680  * values of the variables; higher factor leads to a higher probability that this variable is chosen for branching
681  */
682 extern
684  SCIP_VAR* var /**< problem variable */
685  );
686 
687 /** gets the branch priority of the variable; variables with higher priority should always be preferred to variables
688  * with lower priority
689  */
690 extern
692  SCIP_VAR* var /**< problem variable */
693  );
694 
695 /** gets the preferred branch direction of the variable (downwards, upwards, or auto) */
696 extern
698  SCIP_VAR* var /**< problem variable */
699  );
700 
701 /** gets number of variable lower bounds x >= b_i*z_i + d_i of given variable x */
702 extern
703 int SCIPvarGetNVlbs(
704  SCIP_VAR* var /**< problem variable */
705  );
706 
707 /** gets array with bounding variables z_i in variable lower bounds x >= b_i*z_i + d_i of given variable x;
708  * the variable bounds are sorted by increasing variable index of the bounding variable z_i (see SCIPvarGetIndex())
709  */
710 extern
712  SCIP_VAR* var /**< problem variable */
713  );
714 
715 /** gets array with bounding coefficients b_i in variable lower bounds x >= b_i*z_i + d_i of given variable x */
716 extern
718  SCIP_VAR* var /**< problem variable */
719  );
720 
721 /** gets array with bounding constants d_i in variable lower bounds x >= b_i*z_i + d_i of given variable x */
722 extern
724  SCIP_VAR* var /**< problem variable */
725  );
726 
727 /** gets number of variable upper bounds x <= b_i*z_i + d_i of given variable x */
728 extern
729 int SCIPvarGetNVubs(
730  SCIP_VAR* var /**< problem variable */
731  );
732 
733 /** gets array with bounding variables z_i in variable upper bounds x <= b_i*z_i + d_i of given variable x;
734  * the variable bounds are sorted by increasing variable index of the bounding variable z_i (see SCIPvarGetIndex())
735  */
736 extern
738  SCIP_VAR* var /**< problem variable */
739  );
740 
741 /** gets array with bounding coefficients b_i in variable upper bounds x <= b_i*z_i + d_i of given variable x */
742 extern
744  SCIP_VAR* var /**< problem variable */
745  );
746 
747 /** gets array with bounding constants d_i in variable upper bounds x <= b_i*z_i + d_i of given variable x */
748 extern
750  SCIP_VAR* var /**< problem variable */
751  );
752 
753 /** gets number of implications y <= b or y >= b for x == 0 or x == 1 of given active problem variable x,
754  * there are no implications for nonbinary variable x
755  */
756 extern
757 int SCIPvarGetNImpls(
758  SCIP_VAR* var, /**< active problem variable */
759  SCIP_Bool varfixing /**< FALSE for implications for x == 0, TRUE for x == 1 */
760  );
761 
762 /** gets array with implication variables y of implications y <= b or y >= b for x == 0 or x == 1 of given active
763  * problem variable x, there are no implications for nonbinary variable x;
764  * the implications are sorted such that implications with binary implied variables precede the ones with non-binary
765  * implied variables, and as a second criteria, the implied variables are sorted by increasing variable index
766  * (see SCIPvarGetIndex())
767  */
768 extern
770  SCIP_VAR* var, /**< active problem variable */
771  SCIP_Bool varfixing /**< FALSE for implications for x == 0, TRUE for x == 1 */
772  );
773 
774 /** gets array with implication types of implications y <= b or y >= b for x == 0 or x == 1 of given active problem
775  * variable x (SCIP_BOUNDTYPE_UPPER if y <= b, SCIP_BOUNDTYPE_LOWER if y >= b),
776  * there are no implications for nonbinary variable x
777  */
778 extern
780  SCIP_VAR* var, /**< active problem variable */
781  SCIP_Bool varfixing /**< FALSE for implications for x == 0, TRUE for x == 1 */
782  );
783 
784 /** gets array with implication bounds b of implications y <= b or y >= b for x == 0 or x == 1 of given active problem
785  * variable x, there are no implications for nonbinary variable x
786  */
787 extern
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 array with unique ids of implications y <= b or y >= b for x == 0 or x == 1 of given active problem variable x,
794  * there are no implications for nonbinary variable x.
795  * If an implication is a shortcut, i.e., it was added as part of the transitive closure of another implication,
796  * its id is negative, otherwise it is nonnegative.
797  */
798 extern
799 int* SCIPvarGetImplIds(
800  SCIP_VAR* var, /**< active problem variable */
801  SCIP_Bool varfixing /**< FALSE for implications for x == 0, TRUE for x == 1 */
802  );
803 
804 /** gets number of cliques, the active variable is contained in */
805 extern
807  SCIP_VAR* var, /**< active problem variable */
808  SCIP_Bool varfixing /**< FALSE for cliques containing x == 0, TRUE for x == 1 */
809  );
810 
811 /** gets array of cliques, the active variable is contained in */
812 extern
814  SCIP_VAR* var, /**< active problem variable */
815  SCIP_Bool varfixing /**< FALSE for cliques containing x == 0, TRUE for x == 1 */
816  );
817 
818 /** gets primal LP solution value of variable */
819 extern
821  SCIP_VAR* var /**< problem variable */
822  );
823 
824 /** gets primal NLP solution value of variable */
825 extern
827  SCIP_VAR* var /**< problem variable */
828  );
829 
830 /** return lower bound change info at requested position */
831 extern
833  SCIP_VAR* var, /**< problem variable */
834  int pos /**< requested position */
835  );
836 
837 /** gets the number of lower bound change info array */
838 extern
840  SCIP_VAR* var /**< problem variable */
841  );
842 
843 /** return upper bound change info at requested position */
844 extern
846  SCIP_VAR* var, /**< problem variable */
847  int pos /**< requested position */
848  );
849 
850 /** gets the number upper bound change info array */
851 extern
853  SCIP_VAR* var /**< problem variable */
854  );
855 
856 /** returns the value based history for the variable */
857 extern
859  SCIP_VAR* var /**< problem variable */
860  );
861 
862 #ifdef NDEBUG
863 
864 /* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
865  * speed up the algorithms.
866  */
867 
868 #define SCIPvarGetName(var) (var)->name
869 #define SCIPvarGetNUses(var) (var)->nuses
870 #define SCIPvarGetData(var) (var)->vardata
871 #define SCIPvarSetData(var,vdata) (var)->vardata = (vdata)
872 #define SCIPvarSetDelorigData(var,func) (var)->vardelorig = (func)
873 #define SCIPvarSetTransData(var,func) (var)->vartrans = (func)
874 #define SCIPvarSetDeltransData(var,func) (var)->vardeltrans = (func)
875 #define SCIPvarGetStatus(var) (SCIP_VARSTATUS)((var)->varstatus)
876 #define SCIPvarIsOriginal(var) ((var)->varstatus == SCIP_VARSTATUS_ORIGINAL \
877  || ((var)->varstatus == SCIP_VARSTATUS_NEGATED && (var)->negatedvar->varstatus == SCIP_VARSTATUS_ORIGINAL))
878 #define SCIPvarIsTransformed(var) ((var)->varstatus != SCIP_VARSTATUS_ORIGINAL \
879  && ((var)->varstatus != SCIP_VARSTATUS_NEGATED || (var)->negatedvar->varstatus != SCIP_VARSTATUS_ORIGINAL))
880 #define SCIPvarIsNegated(var) ((var)->varstatus == SCIP_VARSTATUS_NEGATED)
881 #define SCIPvarGetType(var) ((SCIP_VARTYPE)((var)->vartype))
882 #define SCIPvarIsBinary(var) ((var)->vartype == SCIP_VARTYPE_BINARY || \
883  ((var)->vartype != SCIP_VARTYPE_CONTINUOUS && MAX((var)->glbdom.lb, (var)->lazylb) >= 0.0 && MIN((var)->glbdom.ub, (var)->lazyub) <= 1.0))
884 #define SCIPvarIsIntegral(var) ((var)->vartype != SCIP_VARTYPE_CONTINUOUS)
885 #define SCIPvarIsInitial(var) (var)->initial
886 #define SCIPvarIsRemovable(var) (var)->removable
887 #define SCIPvarIsDeleted(var) (var)->deleted
888 #define SCIPvarMarkDeletable(var) (var)->deletable = TRUE
889 #define SCIPvarMarkNotDeletable(var) (var)->deletable = FALSE
890 #define SCIPvarIsDeletable(var) (var)->deletable
891 #define SCIPvarIsActive(var) ((var)->probindex >= 0)
892 #define SCIPvarGetIndex(var) (var)->index
893 #define SCIPvarGetProbindex(var) (var)->probindex
894 #define SCIPvarGetTransVar(var) (var)->data.original.transvar
895 #define SCIPvarGetCol(var) (var)->data.col
896 #define SCIPvarIsInLP(var) ((var)->varstatus == SCIP_VARSTATUS_COLUMN && SCIPcolIsInLP((var)->data.col))
897 /* use different name for var - otherwise we have clash with the var at the end */
898 #define SCIPvarGetAggrVar(war) (war)->data.aggregate.var
899 #define SCIPvarGetAggrScalar(var) (var)->data.aggregate.scalar
900 #define SCIPvarGetAggrConstant(var) (var)->data.aggregate.constant
901 #define SCIPvarGetMultaggrNVars(var) (var)->data.multaggr.nvars
902 #define SCIPvarGetMultaggrVars(var) (var)->data.multaggr.vars
903 #define SCIPvarGetMultaggrScalars(var) (var)->data.multaggr.scalars
904 #define SCIPvarGetMultaggrConstant(var) (var)->data.multaggr.constant
905 #define SCIPvarGetNegatedVar(var) (var)->negatedvar
906 #define SCIPvarGetNegationVar(var) (var)->negatedvar
907 #define SCIPvarGetNegationConstant(var) (var)->data.negate.constant
908 #define SCIPvarGetObj(var) (var)->obj
909 #define SCIPvarGetLbOriginal(var) ((var)->varstatus == SCIP_VARSTATUS_ORIGINAL \
910  ? (var)->data.original.origdom.lb \
911  : (var)->data.negate.constant - (var)->negatedvar->data.original.origdom.ub)
912 #define SCIPvarGetUbOriginal(var) ((var)->varstatus == SCIP_VARSTATUS_ORIGINAL \
913  ? (var)->data.original.origdom.ub \
914  : (var)->data.negate.constant - (var)->negatedvar->data.original.origdom.lb)
915 #define SCIPvarGetHolelistOriginal(var) ((var)->varstatus == SCIP_VARSTATUS_ORIGINAL \
916  ? (var)->data.original.origdom.holelist \
917  : NULL)
918 #define SCIPvarGetLbGlobal(var) (var)->glbdom.lb
919 #define SCIPvarGetUbGlobal(var) (var)->glbdom.ub
920 #define SCIPvarGetHolelistGlobal(var) (var)->glbdom.holelist
921 #define SCIPvarGetBestBoundGlobal(var) ((var)->obj >= 0.0 ? (var)->glbdom.lb : (var)->glbdom.ub)
922 #define SCIPvarGetWorstBoundGlobal(var) ((var)->obj >= 0.0 ? (var)->glbdom.ub : (var)->glbdom.lb)
923 #define SCIPvarGetLbLocal(var) (var)->locdom.lb
924 #define SCIPvarGetUbLocal(var) (var)->locdom.ub
925 #define SCIPvarGetHolelistLocal(var) (var)->locdom.holelist
926 #define SCIPvarGetBestBoundLocal(var) ((var)->obj >= 0.0 ? (var)->locdom.lb : (var)->locdom.ub)
927 #define SCIPvarGetWorstBoundLocal(var) ((var)->obj >= 0.0 ? (var)->locdom.ub : (var)->locdom.lb)
928 #define SCIPvarGetBestBoundType(var) ((var)->obj >= 0.0 ? SCIP_BOUNDTYPE_LOWER : SCIP_BOUNDTYPE_UPPER)
929 #define SCIPvarGetWorstBoundType(var) ((var)->obj >= 0.0 ? SCIP_BOUNDTYPE_UPPER : SCIP_BOUNDTYPE_LOWER)
930 #define SCIPvarGetLbLazy(var) (var)->lazylb
931 #define SCIPvarGetUbLazy(var) (var)->lazyub
932 #define SCIPvarGetBranchFactor(var) (var)->branchfactor
933 #define SCIPvarGetBranchPriority(var) (var)->branchpriority
934 #define SCIPvarGetBranchDirection(var) (var)->branchdirection
935 #define SCIPvarGetNVlbs(var) (SCIPvboundsGetNVbds((var)->vlbs))
936 #define SCIPvarGetVlbVars(var) (SCIPvboundsGetVars((var)->vlbs))
937 #define SCIPvarGetVlbCoefs(var) (SCIPvboundsGetCoefs((var)->vlbs))
938 #define SCIPvarGetVlbConstants(var) (SCIPvboundsGetConstants((var)->vlbs))
939 #define SCIPvarGetNVubs(var) (SCIPvboundsGetNVbds((var)->vubs))
940 #define SCIPvarGetVubVars(var) (SCIPvboundsGetVars((var)->vubs))
941 #define SCIPvarGetVubCoefs(var) (SCIPvboundsGetCoefs((var)->vubs))
942 #define SCIPvarGetVubConstants(var) (SCIPvboundsGetConstants((var)->vubs))
943 #define SCIPvarGetNImpls(var, fix) (SCIPimplicsGetNImpls((var)->implics, fix))
944 #define SCIPvarGetImplVars(var, fix) (SCIPimplicsGetVars((var)->implics, fix))
945 #define SCIPvarGetImplTypes(var, fix) (SCIPimplicsGetTypes((var)->implics, fix))
946 #define SCIPvarGetImplBounds(var, fix) (SCIPimplicsGetBounds((var)->implics, fix))
947 #define SCIPvarGetImplIds(var, fix) (SCIPimplicsGetIds((var)->implics, fix))
948 #define SCIPvarGetNCliques(var, fix) (SCIPcliquelistGetNCliques((var)->cliquelist, fix))
949 #define SCIPvarGetCliques(var, fix) (SCIPcliquelistGetCliques((var)->cliquelist, fix))
950 #define SCIPvarGetLPSol(var) ((var)->varstatus == SCIP_VARSTATUS_COLUMN ? SCIPcolGetPrimsol((var)->data.col) : SCIPvarGetLPSol_rec(var))
951 #define SCIPvarGetNLPSol(var) (((var)->varstatus == SCIP_VARSTATUS_COLUMN || ((var)->varstatus == SCIP_VARSTATUS_LOOSE)) ? (var)->nlpsol : SCIPvarGetNLPSol_rec(var))
952 #define SCIPvarGetBdchgInfoLb(var, pos) (&((var)->lbchginfos[pos]))
953 #define SCIPvarGetNBdchgInfosLb(var) ((var)->nlbchginfos)
954 #define SCIPvarGetBdchgInfoUb(var, pos) (&((var)->ubchginfos[pos]))
955 #define SCIPvarGetNBdchgInfosUb(var) ((var)->nubchginfos)
956 #define SCIPvarGetValuehistory(var) (var)->valuehistory
957 #define SCIPvarGetCliqueComponentIdx(var) ((var)->clqcomponentidx)
958 
959 #endif
960 
961 /** gets primal LP solution value of variable */
962 extern
964  SCIP_VAR* var /**< problem variable */
965  );
966 
967 /** gets primal NLP solution value of variable */
968 extern
970  SCIP_VAR* var /**< problem variable */
971  );
972 
973 /** gets pseudo solution value of variable at current node */
974 extern
976  SCIP_VAR* var /**< problem variable */
977  );
978 
979 /** gets current LP or pseudo solution value of variable */
980 extern
982  SCIP_VAR* var, /**< problem variable */
983  SCIP_Bool getlpval /**< should the LP solution value be returned? */
984  );
985 
986 /** returns the solution of the variable in the last root node's relaxation, if the root relaxation is not yet
987  * completely solved, zero is returned
988  */
989 extern
991  SCIP_VAR* var /**< problem variable */
992  );
993 
994 /** returns the best solution (w.r.t. root reduced cost propagation) of the variable in the root node's relaxation, if
995  * the root relaxation is not yet completely solved, zero is returned
996  */
997 extern
999  SCIP_VAR* var /**< problem variable */
1000  );
1001 
1002 /** returns the best reduced costs (w.r.t. root reduced cost propagation) of the variable in the root node's relaxation,
1003  * if the root relaxation is not yet completely solved, or the variable was no column of the root LP, SCIP_INVALID is
1004  * returned
1005  */
1006 extern
1008  SCIP_VAR* var /**< problem variable */
1009  );
1010 
1011 /** returns the best objective value (w.r.t. root reduced cost propagation) of the root LP which belongs the root
1012  * reduced cost which is accessible via SCIPvarGetRootRedcost() or the variable was no column of the root LP,
1013  * SCIP_INVALID is returned
1014  */
1015 extern
1017  SCIP_VAR* var /**< problem variable */
1018  );
1019 
1020 /** set the given solution as the best root solution w.r.t. root reduced cost propagation in the variables */
1021 extern
1023  SCIP_VAR* var, /**< problem variable */
1024  SCIP_Real rootsol, /**< root solution value */
1025  SCIP_Real rootredcost, /**< root reduced cost */
1026  SCIP_Real rootlpobjval /**< objective value of the root LP */
1027  );
1028 
1029 /** returns a weighted average solution value of the variable in all feasible primal solutions found so far */
1030 extern
1032  SCIP_VAR* var /**< problem variable */
1033  );
1034 
1035 /** returns the bound change information for the last lower 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 lower 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 upper bound change on given active problem variable before or
1047  * after the bound change with the given index was applied;
1048  * returns NULL, if no change to the upper bound was applied up to this point of time
1049  */
1050 extern
1052  SCIP_VAR* var, /**< active problem variable */
1053  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
1054  SCIP_Bool after /**< should the bound change with given index be included? */
1055  );
1056 
1057 /** returns the bound change information for the last lower or upper bound change on given active problem variable
1058  * before or after the bound change with the given index was applied;
1059  * returns NULL, if no change to the lower/upper bound was applied up to this point of time
1060  */
1061 extern
1063  SCIP_VAR* var, /**< active problem variable */
1064  SCIP_BOUNDTYPE boundtype, /**< type of bound: lower or upper bound */
1065  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
1066  SCIP_Bool after /**< should the bound change with given index be included? */
1067  );
1068 
1069 /** returns lower bound of variable directly before or after the bound change given by the bound change index
1070  * was applied
1071  *
1072  * @deprecated Please use SCIPgetVarLbAtIndex()
1073  */
1074 extern
1076  SCIP_VAR* var, /**< problem variable */
1077  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
1078  SCIP_Bool after /**< should the bound change with given index be included? */
1079  );
1080 
1081 /** returns upper bound of variable directly before or after the bound change given by the bound change index
1082  * was applied
1083  *
1084  * @deprecated Please use SCIPgetVarUbAtIndex()
1085  */
1086 extern
1088  SCIP_VAR* var, /**< problem variable */
1089  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
1090  SCIP_Bool after /**< should the bound change with given index be included? */
1091  );
1092 
1093 /** returns lower or upper bound of variable directly before or after the bound change given by the bound change index
1094  * was applied
1095  *
1096  * @deprecated Please use SCIPgetVarBdAtIndex()
1097  */
1098 extern
1100  SCIP_VAR* var, /**< problem variable */
1101  SCIP_BOUNDTYPE boundtype, /**< type of bound: lower or upper bound */
1102  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
1103  SCIP_Bool after /**< should the bound change with given index be included? */
1104  );
1105 
1106 /** returns whether the binary variable was fixed at the time given by the bound change index
1107  *
1108  * @deprecated Please use SCIPgetVarWasFixedAtIndex()
1109  */
1110 extern
1112  SCIP_VAR* var, /**< problem variable */
1113  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
1114  SCIP_Bool after /**< should the bound change with given index be included? */
1115  );
1116 
1117 /** returns the last bound change index, at which the bounds of the given variable were tightened */
1118 extern
1120  SCIP_VAR* var /**< problem variable */
1121  );
1122 
1123 /** returns the last depth level, at which the bounds of the given variable were tightened;
1124  * returns -2, if the variable's bounds are still the global bounds
1125  * returns -1, if the variable was fixed in presolving
1126  */
1127 extern
1129  SCIP_VAR* var /**< problem variable */
1130  );
1131 
1132 /** returns whether the first binary variable was fixed earlier than the second one;
1133  * returns FALSE, if the first variable is not fixed, and returns TRUE, if the first variable is fixed, but the
1134  * second one is not fixed
1135  */
1136 extern
1138  SCIP_VAR* var1, /**< first binary variable */
1139  SCIP_VAR* var2 /**< second binary variable */
1140  );
1141 
1142 /**
1143  * @name Public SCIP_BDCHGIDX Methods
1144  *
1145  * @{
1146  */
1147 
1148 /** returns whether first bound change index belongs to an earlier applied bound change than second one;
1149  * if a bound change index is NULL, the bound change index represents the current time, i.e. the time after the
1150  * last bound change was applied to the current node
1151  */
1152 extern
1154  SCIP_BDCHGIDX* bdchgidx1, /**< first bound change index, or NULL */
1155  SCIP_BDCHGIDX* bdchgidx2 /**< second bound change index, or NULL */
1156  );
1157 
1158 /** returns whether first bound change index belongs to an earlier applied bound change than second one */
1159 extern
1161  SCIP_BDCHGIDX* bdchgidx1, /**< first bound change index */
1162  SCIP_BDCHGIDX* bdchgidx2 /**< second bound change index */
1163  );
1164 
1165 /**@} */
1166 
1167 /**
1168  * @name Public SCIP_BDCHGINFO Methods
1169  *
1170  * @{
1171  */
1172 
1173 /** returns old bound that was overwritten for given bound change information */
1174 extern
1176  SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1177  );
1178 
1179 /** returns new bound installed for given bound change information */
1180 extern
1182  SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1183  );
1184 
1185 /** returns variable that belongs to the given bound change information */
1186 extern
1188  SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1189  );
1190 
1191 /** returns whether the bound change information belongs to a branching decision or a deduction */
1192 extern
1194  SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1195  );
1196 
1197 /** returns whether the bound change information belongs to a lower or upper bound change */
1198 extern
1200  SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1201  );
1202 
1203 /** returns depth level of given bound change information */
1204 extern
1206  SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1207  );
1208 
1209 /** returns bound change position in its depth level of given bound change information */
1210 extern
1212  SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1213  );
1214 
1215 /** returns bound change index of given bound change information */
1216 extern
1218  SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1219  );
1220 
1221 /** returns inference variable of given bound change information */
1222 extern
1224  SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1225  );
1226 
1227 /** returns inference constraint of given bound change information */
1228 extern
1230  SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1231  );
1232 
1233 /** returns inference propagator of given bound change information, or NULL if no propagator was responsible */
1234 extern
1236  SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1237  );
1238 
1239 /** returns inference user information of given bound change information */
1240 extern
1242  SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1243  );
1244 
1245 /** returns inference bound of inference variable of given bound change information */
1246 extern
1248  SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1249  );
1250 
1251 /** returns whether the bound change information belongs to a redundant bound change */
1252 extern
1254  SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1255  );
1256 
1257 /** returns whether the bound change has an inference reason (constraint or propagator), that can be resolved */
1258 extern
1260  SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1261  );
1262 
1263 /** for two bound change informations belonging to the same variable and bound, returns whether the first bound change
1264  * has a tighter new bound as the second bound change
1265  */
1266 extern
1268  SCIP_BDCHGINFO* bdchginfo1, /**< first bound change information */
1269  SCIP_BDCHGINFO* bdchginfo2 /**< second bound change information */
1270  );
1271 
1272 /**@} */
1273 
1274 /**
1275  * @name Public SCIP_BOUNDCHG Methods
1276  *
1277  * @{
1278  */
1279 
1280 /** returns the new value of the bound in the bound change data */
1281 extern
1283  SCIP_BOUNDCHG* boundchg /**< bound change data */
1284  );
1285 
1286 /** returns the variable of the bound change in the bound change data */
1287 extern
1289  SCIP_BOUNDCHG* boundchg /**< bound change data */
1290  );
1291 
1292 /** returns the bound change type of the bound change in the bound change data */
1293 extern
1295  SCIP_BOUNDCHG* boundchg /**< bound change data */
1296  );
1297 
1298 /** returns the bound type of the bound change in the bound change data */
1299 extern
1301  SCIP_BOUNDCHG* boundchg /**< bound change data */
1302  );
1303 
1304 /** returns whether the bound change is redundant due to a more global bound that is at least as strong */
1305 extern
1307  SCIP_BOUNDCHG* boundchg /**< bound change data */
1308  );
1309 
1310 /** @} */
1311 
1312 /**
1313  * @name Public SCIP_DOMCHG Methods
1314  *
1315  * @{
1316  */
1317 
1318 /** returns the number of bound changes in the domain change data */
1319 extern
1321  SCIP_DOMCHG* domchg /**< domain change data */
1322  );
1323 
1324 /** returns a particular bound change in the domain change data */
1325 extern
1327  SCIP_DOMCHG* domchg, /**< domain change data */
1328  int pos /**< position of the bound change in the domain change data */
1329  );
1330 
1331 /**@} */
1332 
1333 /**
1334  * @name Public SCIP_HOLELIST Methods
1335  *
1336  * @{
1337  */
1338 
1339 /** returns left bound of open interval in hole */
1340 extern
1342  SCIP_HOLELIST* holelist /**< hole list pointer to hole of interest */
1343  );
1344 
1345 /** returns right bound of open interval in hole */
1346 extern
1348  SCIP_HOLELIST* holelist /**< hole list pointer to hole of interest */
1349  );
1350 
1351 /** returns next hole in list or NULL */
1352 extern
1354  SCIP_HOLELIST* holelist /**< hole list pointer to hole of interest */
1355  );
1356 
1357 /**@} */
1358 
1359 #ifdef NDEBUG
1360 
1361 /* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
1362  * speed up the algorithms.
1363  */
1364 
1365 #define SCIPbdchgidxIsEarlierNonNull(idx1,idx2) \
1366  ((idx1)->depth < (idx2)->depth || ((idx1)->depth == (idx2)->depth && (idx1)->pos < (idx2)->pos))
1367 #define SCIPbdchgidxIsEarlier(idx1,idx2) \
1368  ((idx1) != NULL && ((idx2) == NULL || SCIPbdchgidxIsEarlierNonNull(idx1, idx2)))
1369 #define SCIPbdchginfoGetOldbound(bdchginfo) (bdchginfo)->oldbound
1370 #define SCIPbdchginfoGetNewbound(bdchginfo) (bdchginfo)->newbound
1371 #define SCIPbdchginfoGetVar(bdchginfo) (bdchginfo)->var
1372 #define SCIPbdchginfoGetChgtype(bdchginfo) (SCIP_BOUNDCHGTYPE)((bdchginfo)->boundchgtype)
1373 #define SCIPbdchginfoGetBoundtype(bdchginfo) (SCIP_BOUNDTYPE)((bdchginfo)->boundtype)
1374 #define SCIPbdchginfoGetDepth(bdchginfo) (bdchginfo)->bdchgidx.depth
1375 #define SCIPbdchginfoGetPos(bdchginfo) (bdchginfo)->bdchgidx.pos
1376 #define SCIPbdchginfoGetIdx(bdchginfo) (&(bdchginfo)->bdchgidx)
1377 #define SCIPbdchginfoGetInferVar(bdchginfo) (bdchginfo)->inferencedata.var
1378 #define SCIPbdchginfoGetInferCons(bdchginfo) (bdchginfo)->inferencedata.reason.cons
1379 #define SCIPbdchginfoGetInferProp(bdchginfo) (bdchginfo)->inferencedata.reason.prop
1380 #define SCIPbdchginfoGetInferInfo(bdchginfo) (bdchginfo)->inferencedata.info
1381 #define SCIPbdchginfoGetInferBoundtype(bdchginfo) (SCIP_BOUNDTYPE)((bdchginfo)->inferboundtype)
1382 #define SCIPbdchginfoIsRedundant(bdchginfo) (bdchginfo)->redundant
1383 #define SCIPbdchginfoHasInferenceReason(bdchginfo) \
1384  (((bdchginfo)->boundchgtype == SCIP_BOUNDCHGTYPE_CONSINFER) \
1385  || ((bdchginfo)->boundchgtype == SCIP_BOUNDCHGTYPE_PROPINFER && (bdchginfo)->inferencedata.reason.prop != NULL))
1386 #define SCIPbdchginfoIsTighter(bdchginfo1,bdchginfo2) ((bdchginfo1)->boundtype == SCIP_BOUNDTYPE_LOWER \
1387  ? (bdchginfo1)->newbound > bdchginfo2->newbound : (bdchginfo1)->newbound < bdchginfo2->newbound)
1388 #define SCIPboundchgGetNewbound(boundchg) ((boundchg)->newbound)
1389 #define SCIPboundchgGetVar(boundchg) ((boundchg)->var)
1390 #define SCIPboundchgGetBoundchgtype(boundchg) ((SCIP_BOUNDCHGTYPE)((boundchg)->boundchgtype))
1391 #define SCIPboundchgGetBoundtype(boundchg) ((SCIP_BOUNDTYPE)((boundchg)->boundtype))
1392 #define SCIPboundchgIsRedundant(boundchg) ((boundchg)->redundant)
1393 #define SCIPdomchgGetNBoundchgs(domchg) ((domchg) != NULL ? (domchg)->domchgbound.nboundchgs : 0)
1394 #define SCIPdomchgGetBoundchg(domchg, pos) (&(domchg)->domchgbound.boundchgs[pos])
1395 #define SCIPholelistGetLeft(holelist) ((holelist)->hole.left)
1396 #define SCIPholelistGetRight(holelist) ((holelist)->hole.right)
1397 #define SCIPholelistGetNext(holelist) ((holelist)->next)
1398 
1399 #endif
1400 
1401 /**@} */
1402 
1403 #ifdef __cplusplus
1404 }
1405 #endif
1406 
1407 #endif
enum SCIP_BoundType SCIP_BOUNDTYPE
Definition: type_lp.h:50
SCIP_Real SCIPvarGetWorstBoundLocal(SCIP_VAR *var)
Definition: var.c:17375
SCIP_Real * SCIPvarGetVlbCoefs(SCIP_VAR *var)
Definition: var.c:17490
SCIP_BOUNDTYPE SCIPvarGetWorstBoundType(SCIP_VAR *var)
Definition: var.c:17401
SCIP_Bool SCIPvarsHaveCommonClique(SCIP_VAR *var1, SCIP_Bool value1, SCIP_VAR *var2, SCIP_Bool value2, SCIP_Bool regardimplics)
Definition: var.c:10889
SCIP_Real SCIPvarGetBdAtIndex(SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: var.c:16195
SCIP_PROP * SCIPbdchginfoGetInferProp(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:17962
void SCIPvarMarkNotDeletable(SCIP_VAR *var)
Definition: var.c:16906
SCIP_BDCHGINFO * SCIPvarGetBdchgInfoLb(SCIP_VAR *var, int pos)
Definition: var.c:17676
SCIP_Real * SCIPvarGetMultaggrScalars(SCIP_VAR *var)
Definition: var.c:17068
type definitions for miscellaneous datastructures
type definitions for implications, variable bounds, and cliques
SCIP_Real SCIPvarGetBranchFactor(SCIP_VAR *var)
Definition: var.c:17436
SCIP_Real SCIPbdchginfoGetOldbound(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:17858
SCIP_BRANCHDIR SCIPvarGetBranchDirection(SCIP_VAR *var)
Definition: var.c:17458
SCIP_Real SCIPvarGetUbLazy(SCIP_VAR *var)
Definition: var.c:17424
int SCIPvarGetNVlbs(SCIP_VAR *var)
Definition: var.c:17468
SCIP_VAR * SCIPbdchginfoGetVar(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:17878
SCIP_Real SCIPvarGetWorstBoundGlobal(SCIP_VAR *var)
Definition: var.c:17319
#define SCIP_DECL_VARTRANS(x)
Definition: type_var.h:129
methods for implications, variable bounds, and cliques
int SCIPvarGetLastBdchgDepth(SCIP_VAR *var)
Definition: var.c:16275
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
Definition: var.c:17276
SCIP_Real SCIPvarGetAvgBranchdepth(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: var.c:15193
SCIP_RETCODE SCIPvarGetProbvarBinary(SCIP_VAR **var, SCIP_Bool *negated)
Definition: var.c:11720
SCIP_Bool SCIPvarIsInitial(SCIP_VAR *var)
Definition: var.c:16863
SCIP_VAR ** SCIPvarGetMultaggrVars(SCIP_VAR *var)
Definition: var.c:17056
static long bound
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
Definition: var.c:17332
SCIP_CLIQUE ** SCIPvarGetCliques(SCIP_VAR *var, SCIP_Bool varfixing)
Definition: var.c:17639
SCIP_VALUEHISTORY * SCIPvarGetValuehistory(SCIP_VAR *var)
Definition: var.c:17718
void SCIPvarSetTransData(SCIP_VAR *var, SCIP_DECL_VARTRANS((*vartrans)))
Definition: var.c:16715
SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)
Definition: var.c:16842
SCIP_Real SCIPvarGetSol(SCIP_VAR *var, SCIP_Bool getlpval)
Definition: var.c:12665
SCIP_Bool SCIPbdchgidxIsEarlier(SCIP_BDCHGIDX *bdchgidx1, SCIP_BDCHGIDX *bdchgidx2)
Definition: var.c:17838
SCIP_Bool SCIPvarWasFixedAtIndex(SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: var.c:16215
SCIP_Real SCIPvarGetBestBoundLocal(SCIP_VAR *var)
Definition: var.c:17362
SCIP_Real SCIPvarGetRootSol(SCIP_VAR *var)
Definition: var.c:12758
SCIP_BOUNDTYPE SCIPboundchgGetBoundtype(SCIP_BOUNDCHG *boundchg)
Definition: var.c:16589
SCIP_HOLELIST * SCIPholelistGetNext(SCIP_HOLELIST *holelist)
Definition: var.c:16649
int SCIPvarGetNBdchgInfosLb(SCIP_VAR *var)
Definition: var.c:17688
struct SCIP_VarData SCIP_VARDATA
Definition: type_var.h:98
SCIP_Bool SCIPvarHasImplic(SCIP_VAR *var, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_BOUNDTYPE impltype)
Definition: var.c:10560
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:53
SCIP_Real SCIPvarGetNegationConstant(SCIP_VAR *var)
Definition: var.c:17113
int SCIPvarGetNVubs(SCIP_VAR *var)
Definition: var.c:17510
int SCIPbdchginfoGetInferInfo(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:17973
enum SCIP_Varstatus SCIP_VARSTATUS
Definition: type_var.h:48
int SCIPvarGetProbindex(SCIP_VAR *var)
Definition: var.c:16969
#define SCIP_DECL_VARCOPY(x)
Definition: type_var.h:172
SCIP_Real SCIPvarGetAggrScalar(SCIP_VAR *var)
Definition: var.c:17022
SCIP_Real SCIPvarGetInferenceSum(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: var.c:15383
void SCIPvarMarkDeletable(SCIP_VAR *var)
Definition: var.c:16895
type definitions for return codes for SCIP methods
SCIP_VAR ** SCIPvarGetVlbVars(SCIP_VAR *var)
Definition: var.c:17480
SCIP_Bool SCIPvarIsDeletable(SCIP_VAR *var)
Definition: var.c:16939
SCIP_Bool SCIPvarIsRemovable(SCIP_VAR *var)
Definition: var.c:16873
SCIP_Longint SCIPvarGetNBranchingsCurrentRun(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: var.c:15150
SCIP_VAR * SCIPvarGetNegationVar(SCIP_VAR *var)
Definition: var.c:17102
SCIP_BDCHGIDX * SCIPvarGetLastBdchgIndex(SCIP_VAR *var)
Definition: var.c:16238
int SCIPvarGetNCliques(SCIP_VAR *var, SCIP_Bool varfixing)
Definition: var.c:17628
SCIP_Real SCIPvarGetLPSol_rec(SCIP_VAR *var)
Definition: var.c:12479
internal methods for branching and inference history
SCIP_Real SCIPvarGetCutoffSumCurrentRun(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: var.c:15626
int * SCIPvarGetImplIds(SCIP_VAR *var, SCIP_Bool varfixing)
Definition: var.c:17616
SCIP_HOLELIST * SCIPvarGetHolelistOriginal(SCIP_VAR *var)
Definition: var.c:17262
SCIP_DECL_HASHKEYVAL(SCIPvarGetHashkeyVal)
Definition: var.c:11410
#define SCIP_DECL_VARDELTRANS(x)
Definition: type_var.h:142
SCIP_VAR * SCIPvarGetNegatedVar(SCIP_VAR *var)
Definition: var.c:17092
enum SCIP_BranchDir SCIP_BRANCHDIR
Definition: type_history.h:39
SCIP_Real SCIPvarGetNLPSol_rec(SCIP_VAR *var)
Definition: var.c:12551
int SCIPvarGetNBdchgInfosUb(SCIP_VAR *var)
Definition: var.c:17708
SCIP_Bool SCIPbdchginfoIsTighter(SCIP_BDCHGINFO *bdchginfo1, SCIP_BDCHGINFO *bdchginfo2)
Definition: var.c:18031
SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)
Definition: var.c:17286
SCIP_VAR * SCIPvarGetProbvar(SCIP_VAR *var)
Definition: var.c:11628
SCIP_Real SCIPvarGetBestRootLPObjval(SCIP_VAR *var)
Definition: var.c:13222
void SCIPvarSetDelorigData(SCIP_VAR *var, SCIP_DECL_VARDELORIG((*vardelorig)))
Definition: var.c:16703
void SCIPvarSetDeltransData(SCIP_VAR *var, SCIP_DECL_VARDELTRANS((*vardeltrans)))
Definition: var.c:16727
SCIP_Real SCIPvarGetBestBoundGlobal(SCIP_VAR *var)
Definition: var.c:17306
SCIP_Bool SCIPboundchgIsRedundant(SCIP_BOUNDCHG *boundchg)
Definition: var.c:16599
SCIP_Real SCIPvarGetLbOriginal(SCIP_VAR *var)
Definition: var.c:17222
SCIP_Bool SCIPbdchgidxIsEarlierNonNull(SCIP_BDCHGIDX *bdchgidx1, SCIP_BDCHGIDX *bdchgidx2)
Definition: var.c:17818
int SCIPvarCompareActiveAndNegated(SCIP_VAR *var1, SCIP_VAR *var2)
Definition: var.c:11315
SCIP_Real SCIPvarGetAvgBranchdepthCurrentRun(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: var.c:15238
SCIP_Real SCIPvarGetUbOriginal(SCIP_VAR *var)
Definition: var.c:17242
SCIP_Bool SCIPvarIsTransformedOrigvar(SCIP_VAR *var)
Definition: var.c:12271
SCIP_DECL_SORTPTRCOMP(SCIPvarCompActiveAndNegated)
Definition: var.c:11345
SCIP_Real SCIPvarGetUbAtIndex(SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: var.c:16071
SCIP_Bool SCIPvarHasBinaryImplic(SCIP_VAR *var, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_Bool implvarfixing)
Definition: var.c:10580
SCIP_Real * SCIPvarGetVubConstants(SCIP_VAR *var)
Definition: var.c:17542
SCIP_Real SCIPvarGetAggrConstant(SCIP_VAR *var)
Definition: var.c:17033
const char * SCIPvarGetName(SCIP_VAR *var)
Definition: var.c:16662
SCIP_DECL_HASHGETKEY(SCIPvarGetHashkey)
Definition: var.c:11396
SCIP_Real SCIPboundchgGetNewbound(SCIP_BOUNDCHG *boundchg)
Definition: var.c:16559
SCIP_Real SCIPvarGetLPSol(SCIP_VAR *var)
Definition: var.c:17650
SCIP_HOLELIST * SCIPvarGetHolelistGlobal(SCIP_VAR *var)
Definition: var.c:17296
SCIP_RETCODE SCIPvarGetAggregatedObj(SCIP_VAR *var, SCIP_Real *aggrobj)
Definition: var.c:17146
SCIP_Bool SCIPbdchginfoHasInferenceReason(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:18017
SCIP_Real SCIPvarGetLbLazy(SCIP_VAR *var)
Definition: var.c:17414
SCIP_Real * SCIPvarGetVlbConstants(SCIP_VAR *var)
Definition: var.c:17500
SCIP_Real SCIPvarGetMultaggrConstant(SCIP_VAR *var)
Definition: var.c:17080
type definitions for problem variables
SCIP_Real SCIPvarGetCutoffSum(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: var.c:15583
SCIP_Real * SCIPvarGetVubCoefs(SCIP_VAR *var)
Definition: var.c:17532
SCIP_Bool SCIPbdchginfoIsRedundant(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:18006
SCIP_BDCHGIDX * SCIPbdchginfoGetIdx(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:17928
void SCIPvarSetBestRootSol(SCIP_VAR *var, SCIP_Real rootsol, SCIP_Real rootredcost, SCIP_Real rootlpobjval)
Definition: var.c:13253
SCIP_Bool SCIPvarIsOriginal(SCIP_VAR *var)
Definition: var.c:16791
SCIP_BOUNDTYPE * SCIPvarGetImplTypes(SCIP_VAR *var, SCIP_Bool varfixing)
Definition: var.c:17586
SCIP_Real SCIPholelistGetRight(SCIP_HOLELIST *holelist)
Definition: var.c:16639
#define SCIP_Bool
Definition: def.h:61
SCIP_BOUNDCHGTYPE SCIPboundchgGetBoundchgtype(SCIP_BOUNDCHG *boundchg)
Definition: var.c:16579
int SCIPbdchginfoGetPos(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:17918
SCIP_Bool SCIPvarWasFixedEarlier(SCIP_VAR *var1, SCIP_VAR *var2)
Definition: var.c:16363
SCIP_Real SCIPvarGetInferenceSumCurrentRun(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: var.c:15428
SCIP_Bool SCIPvarIsInLP(SCIP_VAR *var)
Definition: var.c:17001
SCIP_Real SCIPvarGetNLPSol(SCIP_VAR *var)
Definition: var.c:17663
int SCIPvarGetBranchPriority(SCIP_VAR *var)
Definition: var.c:17448
SCIP_Real SCIPvarGetLbAtIndex(SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: var.c:15947
int SCIPvarGetNImpls(SCIP_VAR *var, SCIP_Bool varfixing)
Definition: var.c:17554
SCIP_VARDATA * SCIPvarGetData(SCIP_VAR *var)
Definition: var.c:16682
int SCIPvarGetNLocksUp(SCIP_VAR *var)
Definition: var.c:3217
SCIP_VAR * SCIPboundchgGetVar(SCIP_BOUNDCHG *boundchg)
Definition: var.c:16569
int SCIPvarCompare(SCIP_VAR *var1, SCIP_VAR *var2)
Definition: var.c:11353
SCIP_BOUNDCHG * SCIPdomchgGetBoundchg(SCIP_DOMCHG *domchg, int pos)
Definition: var.c:16617
SCIP_Real SCIPvarGetUnchangedObj(SCIP_VAR *var)
Definition: var.c:17134
SCIP_Real SCIPvarGetObj(SCIP_VAR *var)
Definition: var.c:17124
SCIP_Real SCIPbdchginfoGetNewbound(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:17868
SCIP_Real SCIPvarGetBestRootRedcost(SCIP_VAR *var)
Definition: var.c:13188
SCIP_VAR * SCIPvarGetAggrVar(SCIP_VAR *var)
Definition: var.c:17011
SCIP_COL * SCIPvarGetCol(SCIP_VAR *var)
Definition: var.c:16990
int SCIPvarGetMultaggrNVars(SCIP_VAR *var)
Definition: var.c:17044
SCIP_Real * SCIPvarGetImplBounds(SCIP_VAR *var, SCIP_Bool varfixing)
Definition: var.c:17600
SCIP_RETCODE SCIPvarGetOrigvarSum(SCIP_VAR **var, SCIP_Real *scalar, SCIP_Real *constant)
Definition: var.c:12184
SCIP_BDCHGINFO * SCIPvarGetLbchgInfo(SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: var.c:15814
SCIP_BOUNDTYPE SCIPbdchginfoGetInferBoundtype(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:17985
SCIP_BDCHGINFO * SCIPvarGetUbchgInfo(SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: var.c:15870
SCIP_RETCODE SCIPvarGetProbvarBound(SCIP_VAR **var, SCIP_Real *bound, SCIP_BOUNDTYPE *boundtype)
Definition: var.c:11879
SCIP_BDCHGINFO * SCIPvarGetBdchgInfoUb(SCIP_VAR *var, int pos)
Definition: var.c:17696
SCIP_BDCHGINFO * SCIPvarGetBdchgInfo(SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: var.c:15926
#define SCIP_DECL_VARDELORIG(x)
Definition: type_var.h:109
SCIP_VAR ** SCIPvarGetImplVars(SCIP_VAR *var, SCIP_Bool varfixing)
Definition: var.c:17571
int SCIPvarGetNLocksDown(SCIP_VAR *var)
Definition: var.c:3162
int SCIPdomchgGetNBoundchgs(SCIP_DOMCHG *domchg)
Definition: var.c:16609
int SCIPbdchginfoGetDepth(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:17908
SCIP_DECL_HASHKEYEQ(SCIPvarIsHashkeyEq)
Definition: var.c:11402
SCIP_Real SCIPvarGetBestRootSol(SCIP_VAR *var)
Definition: var.c:13122
void SCIPvarSetCopyData(SCIP_VAR *var, SCIP_DECL_VARCOPY((*varcopy)))
Definition: var.c:16738
SCIP_Real SCIPholelistGetLeft(SCIP_HOLELIST *holelist)
Definition: var.c:16629
datastructures for problem variables
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
Definition: var.c:16781
#define SCIP_Real
Definition: def.h:149
type definitions for branching and inference history
SCIP_Longint SCIPvarGetNBranchings(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: var.c:15105
SCIP_RETCODE SCIPvarsGetProbvarBinary(SCIP_VAR ***vars, SCIP_Bool **negatedarr, int nvars)
Definition: var.c:11688
SCIP_VAR * SCIPbdchginfoGetInferVar(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:17938
SCIP_RETCODE SCIPvarSetInitial(SCIP_VAR *var, SCIP_Bool initial)
Definition: var.c:16749
SCIP_RETCODE SCIPvarGetProbvarHole(SCIP_VAR **var, SCIP_Real *left, SCIP_Real *right)
Definition: var.c:11972
int SCIPvarGetNUses(SCIP_VAR *var)
Definition: var.c:16672
void SCIPvarsGetProbvar(SCIP_VAR **vars, int nvars)
Definition: var.c:11608
SCIP_VAR ** SCIPvarGetVubVars(SCIP_VAR *var)
Definition: var.c:17522
#define SCIP_Longint
Definition: def.h:134
SCIP_BOUNDTYPE SCIPvarGetBestBoundType(SCIP_VAR *var)
Definition: var.c:17388
SCIP_CONS * SCIPbdchginfoGetInferCons(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:17950
SCIP_Real SCIPvarGetAvgSol(SCIP_VAR *var)
Definition: var.c:13468
int SCIPvarGetIndex(SCIP_VAR *var)
Definition: var.c:16959
SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)
Definition: var.c:16827
enum SCIP_Vartype SCIP_VARTYPE
Definition: type_var.h:60
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
Definition: var.c:17342
SCIP_Bool SCIPvarIsTransformed(SCIP_VAR *var)
Definition: var.c:16804
SCIP_HOLELIST * SCIPvarGetHolelistLocal(SCIP_VAR *var)
Definition: var.c:17352
SCIP_BOUNDTYPE SCIPbdchginfoGetBoundtype(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:17898
common defines and data types used in all packages of SCIP
SCIP_RETCODE SCIPvarSetRemovable(SCIP_VAR *var, SCIP_Bool removable)
Definition: var.c:16765
SCIP_Real SCIPvarGetPseudoSol(SCIP_VAR *var)
Definition: var.c:17728
enum SCIP_BoundchgType SCIP_BOUNDCHGTYPE
Definition: type_var.h:78
SCIP_VAR * SCIPvarGetTransVar(SCIP_VAR *var)
Definition: var.c:16979
SCIP_Bool SCIPvarIsIntegral(SCIP_VAR *var)
Definition: var.c:16853
SCIP_Bool SCIPvarIsDeleted(SCIP_VAR *var)
Definition: var.c:16883
void SCIPvarSetData(SCIP_VAR *var, SCIP_VARDATA *vardata)
Definition: var.c:16692
SCIP_Bool SCIPvarMayRoundUp(SCIP_VAR *var)
Definition: var.c:3280
SCIP_Bool SCIPvarMayRoundDown(SCIP_VAR *var)
Definition: var.c:3272
type definitions for constraints and constraint handlers
SCIP_Bool SCIPvarIsActive(SCIP_VAR *var)
Definition: var.c:16949
SCIP_Bool SCIPvarIsNegated(SCIP_VAR *var)
Definition: var.c:16817
void SCIPvarMarkDeleteGlobalStructures(SCIP_VAR *var)
Definition: var.c:16919
SCIP_BOUNDCHGTYPE SCIPbdchginfoGetChgtype(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:17888