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-2018 Konrad-Zuse-Zentrum */
7 /* fuer Informationstechnik Berlin */
8 /* */
9 /* SCIP is distributed under the terms of the ZIB Academic License. */
10 /* */
11 /* You should have received a copy of the ZIB Academic License */
12 /* along with SCIP; see the file COPYING. If not visit scip.zib.de. */
13 /* */
14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15 
16 /**@file 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_cons.h"
30 #include "scip/type_history.h"
31 #include "scip/type_implics.h"
32 #include "scip/type_lp.h"
33 #include "scip/type_misc.h"
34 #include "scip/type_prop.h"
35 #include "scip/type_result.h"
36 #include "scip/type_retcode.h"
37 #include "scip/type_scip.h"
38 #include "scip/type_var.h"
39 
40 #ifdef NDEBUG
41 #include "scip/struct_var.h"
42 #include "scip/implics.h"
43 #include "scip/history.h"
44 #include "scip/pub_lp.h"
45 #endif
46 
47 #ifdef __cplusplus
48 extern "C" {
49 #endif
50 
51 /*
52  * methods for variables
53  */
54 
55 /**@addtogroup PublicVariableMethods
56  *
57  * @{
58  */
59 
60 /** gets number of locks for rounding down
61  *
62  * @note This method will always return variable locks of type model
63  *
64  * @note It is recommented to use SCIPvarGetNLocksDownType()
65  */
66 extern
68  SCIP_VAR* var /**< problem variable */
69  );
70 
71 /** gets number of locks for rounding up
72  *
73  * @note This method will always return variable locks of type model
74  *
75  * @note It is recommented to use SCIPvarGetNLocksUpType()
76  */
77 extern
79  SCIP_VAR* var /**< problem variable */
80  );
81 
82 /** gets number of locks for rounding up of a special type */
83 extern
85  SCIP_VAR* var, /**< problem variable */
86  SCIP_LOCKTYPE locktype /**< type of variable locks */
87  );
88 
89 /** gets number of locks for rounding down of a special type */
90 extern
92  SCIP_VAR* var, /**< problem variable */
93  SCIP_LOCKTYPE locktype /**< type of variable locks */
94  );
95 
96 /** is it possible, to round variable down and stay feasible?
97  *
98  * @note This method will always check w.r.t variable locks of type model
99  */
100 extern
102  SCIP_VAR* var /**< problem variable */
103  );
104 
105 /** is it possible, to round variable up and stay feasible?
106  *
107  * @note This method will always check w.r.t. variable locks of type model
108  */
109 extern
111  SCIP_VAR* var /**< problem variable */
112  );
113 
114 /** compares the index of two variables, only active or negated variables are allowed, if a variable
115  * is negated then the index of the corresponding active variable is taken, returns -1 if first is
116  * smaller than, and +1 if first is greater than second variable index; returns 0 if both indices
117  * are equal, which means both variables are equal
118  */
119 extern
121  SCIP_VAR* var1, /**< first problem variable */
122  SCIP_VAR* var2 /**< second problem variable */
123  );
124 
125 /** comparison method for sorting active and negated variables by non-decreasing index, active and negated
126  * variables are handled as the same variables
127  */
128 extern
129 SCIP_DECL_SORTPTRCOMP(SCIPvarCompActiveAndNegated);
130 
131 /** compares the index of two variables, returns -1 if first is smaller than, and +1 if first is greater than second
132  * variable index; returns 0 if both indices are equal, which means both variables are equal
133  */
134 extern
135 int SCIPvarCompare(
136  SCIP_VAR* var1, /**< first problem variable */
137  SCIP_VAR* var2 /**< second problem variable */
138  );
139 
140 /** comparison method for sorting variables by non-decreasing index */
141 extern
142 SCIP_DECL_SORTPTRCOMP(SCIPvarComp);
143 
144 /** comparison method for sorting variables by non-decreasing objective coefficient */
145 extern
146 SCIP_DECL_SORTPTRCOMP(SCIPvarCompObj);
147 
148 /** hash key retrieval function for variables */
149 extern
150 SCIP_DECL_HASHGETKEY(SCIPvarGetHashkey);
151 
152 /** returns TRUE iff the indices of both variables are equal */
153 extern
154 SCIP_DECL_HASHKEYEQ(SCIPvarIsHashkeyEq);
155 
156 /** returns the hash value of the key */
157 extern
158 SCIP_DECL_HASHKEYVAL(SCIPvarGetHashkeyVal);
159 
160 
161 /** gets corresponding active, fixed, or multi-aggregated problem variables of given variables,
162  * @note the content of the given array will/might change
163  */
164 extern
165 void SCIPvarsGetProbvar(
166  SCIP_VAR** vars, /**< array of problem variables */
167  int nvars /**< number of variables */
168  );
169 
170 /** gets corresponding active, fixed, or multi-aggregated problem variable of a variable */
171 extern
173  SCIP_VAR* var /**< problem variable */
174  );
175 
176 /** gets corresponding active, fixed, or multi-aggregated problem variables of binary variables and
177  * updates the given negation status of each variable
178  */
179 extern
181  SCIP_VAR*** vars, /**< pointer to binary problem variables */
182  SCIP_Bool** negatedarr, /**< pointer to corresponding array to update the negation status */
183  int nvars /**< number of variables and values in vars and negated array */
184  );
185 
186 /** gets corresponding active, fixed, or multi-aggregated problem variable of a binary variable and
187  * updates the given negation status
188  */
189 extern
191  SCIP_VAR** var, /**< pointer to binary problem variable */
192  SCIP_Bool* negated /**< pointer to update the negation status */
193  );
194 
195 /** transforms given variable, boundtype and bound to the corresponding active, fixed, or multi-aggregated variable
196  * values
197  */
198 extern
200  SCIP_VAR** var, /**< pointer to problem variable */
201  SCIP_Real* bound, /**< pointer to bound value to transform */
202  SCIP_BOUNDTYPE* boundtype /**< pointer to type of bound: lower or upper bound */
203  );
204 
205 /** transforms given variable and domain hole to the corresponding active, fixed, or multi-aggregated variable
206  * values
207  */
208 extern
210  SCIP_VAR** var, /**< pointer to problem variable */
211  SCIP_Real* left, /**< pointer to left bound of open interval in hole to transform */
212  SCIP_Real* right /**< pointer to right bound of open interval in hole to transform */
213  );
214 
215 /** retransforms given variable, scalar and constant to the corresponding original variable, scalar
216  * and constant, if possible; if the retransformation is impossible, NULL is returned as variable
217  */
218 extern
220  SCIP_VAR** var, /**< pointer to problem variable x in sum a*x + c */
221  SCIP_Real* scalar, /**< pointer to scalar a in sum a*x + c */
222  SCIP_Real* constant /**< pointer to constant c in sum a*x + c */
223  );
224 
225 /** returns whether the given variable is the direct counterpart of an original problem variable */
226 extern
228  SCIP_VAR* var /**< problem variable */
229  );
230 
231 /** returns the number of times, a bound of the variable was changed in given direction due to branching */
232 extern
234  SCIP_VAR* var, /**< problem variable */
235  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
236  );
237 
238 /** returns the number of times, a bound of the variable was changed in given direction due to branching
239  * in the current run
240  */
241 extern
243  SCIP_VAR* var, /**< problem variable */
244  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
245  );
246 
247 /** returns the number of inferences branching on this variable in given direction triggered */
248 extern
250  SCIP_VAR* var, /**< problem variable */
251  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
252  );
253 
254 /** returns the number of inferences branching on this variable in given direction triggered
255  * in the current run
256  */
257 extern
259  SCIP_VAR* var, /**< problem variable */
260  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
261  );
262 
263 /** returns the number of cutoffs branching on this variable in given direction produced */
264 extern
266  SCIP_VAR* var, /**< problem variable */
267  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
268  );
269 
270 /** returns the number of cutoffs branching on this variable in given direction produced in the current run */
271 extern
273  SCIP_VAR* var, /**< problem variable */
274  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
275  );
276 
277 /** returns the average depth of bound changes in given direction due to branching on the variable */
278 extern
280  SCIP_VAR* var, /**< problem variable */
281  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
282  );
283 
284 /** returns the average depth of bound changes in given direction due to branching on the variable
285  * in the current run
286  */
287 extern
289  SCIP_VAR* var, /**< problem variable */
290  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
291  );
292 
293 /** returns whether there is an implication x == varfixing -> y <= b or y >= b in the implication graph;
294  * implications that are represented as cliques in the clique table are not regarded (use SCIPvarsHaveCommonClique());
295  * both variables must be active, variable x must be binary
296  */
297 extern
299  SCIP_VAR* var, /**< problem variable x */
300  SCIP_Bool varfixing, /**< FALSE if y should be searched in implications for x == 0, TRUE for x == 1 */
301  SCIP_VAR* implvar, /**< variable y to search for */
302  SCIP_BOUNDTYPE impltype /**< type of implication y <=/>= b to search for */
303  );
304 
305 /** returns whether there is an implication x == varfixing -> y == implvarfixing in the implication graph;
306  * implications that are represented as cliques in the clique table are not regarded (use SCIPvarsHaveCommonClique());
307  * both variables must be active binary variables
308  */
309 extern
311  SCIP_VAR* var, /**< problem variable x */
312  SCIP_Bool varfixing, /**< FALSE if y should be searched in implications for x == 0, TRUE for x == 1 */
313  SCIP_VAR* implvar, /**< variable y to search for */
314  SCIP_Bool implvarfixing /**< value of the implied variable to search for */
315  );
316 
317 /** returns whether there is a clique that contains both given variable/value pairs;
318  * the variables must be active binary variables;
319  * if regardimplics is FALSE, only the cliques in the clique table are looked at;
320  * if regardimplics is TRUE, both the cliques and the implications of the implication graph are regarded
321  */
322 extern
324  SCIP_VAR* var1, /**< first variable */
325  SCIP_Bool value1, /**< value of first variable */
326  SCIP_VAR* var2, /**< second variable */
327  SCIP_Bool value2, /**< value of second variable */
328  SCIP_Bool regardimplics /**< should the implication graph also be searched for a clique? */
329  );
330 
331 /** gets corresponding objective value of active, fixed, or multi-aggregated problem variable of given variable
332  * e.g. obj(x) = 1 this method returns for ~x the value -1
333  */
334 extern
336  SCIP_VAR* var, /**< problem variable */
337  SCIP_Real* aggrobj /**< pointer to store the aggregated objective value */
338  );
339 
340 /** sets the initial flag of a variable; only possible for original or loose variables */
341 extern
343  SCIP_VAR* var, /**< problem variable */
344  SCIP_Bool initial /**< initial flag */
345  );
346 
347 /** sets the removable flag of a variable; only possible for original or loose variables */
348 extern
350  SCIP_VAR* var, /**< problem variable */
351  SCIP_Bool removable /**< removable flag */
352  );
353 
354 /** returns the name of the variable
355  *
356  * @note to change the name of a variable, use SCIPchgVarName() from scip.h
357  */
358 extern
359 const char* SCIPvarGetName(
360  SCIP_VAR* var /**< problem variable */
361  );
362 
363 /** gets number of times, the variable is currently captured */
364 extern
365 int SCIPvarGetNUses(
366  SCIP_VAR* var /**< problem variable */
367  );
368 
369 /** returns the user data of the variable */
370 extern
372  SCIP_VAR* var /**< problem variable */
373  );
374 
375 /** sets the user data for the variable */
376 extern
377 void SCIPvarSetData(
378  SCIP_VAR* var, /**< problem variable */
379  SCIP_VARDATA* vardata /**< user variable data */
380  );
381 
382 /** sets method to free user data for the original variable */
383 extern
385  SCIP_VAR* var, /**< problem variable */
386  SCIP_DECL_VARDELORIG ((*vardelorig)) /**< frees user data of original variable */
387  );
388 
389 /** sets method to transform user data of the variable */
390 extern
392  SCIP_VAR* var, /**< problem variable */
393  SCIP_DECL_VARTRANS ((*vartrans)) /**< creates transformed user data by transforming original user data */
394  );
395 
396 /** sets method to free transformed user data for the variable */
397 extern
399  SCIP_VAR* var, /**< problem variable */
400  SCIP_DECL_VARDELTRANS ((*vardeltrans)) /**< frees user data of transformed variable */
401  );
402 
403 /** sets method to copy this variable into sub-SCIPs */
404 extern
405 void SCIPvarSetCopyData(
406  SCIP_VAR* var, /**< problem variable */
407  SCIP_DECL_VARCOPY ((*varcopy)) /**< copy method of the variable */
408  );
409 
410 /** gets status of variable */
411 extern
413  SCIP_VAR* var /**< problem variable */
414  );
415 
416 /** returns whether the variable belongs to the original problem */
417 extern
419  SCIP_VAR* var /**< problem variable */
420  );
421 
422 /** returns whether the variable belongs to the transformed problem */
423 extern
425  SCIP_VAR* var /**< problem variable */
426  );
427 
428 /** returns whether the variable was created by negation of a different variable */
429 extern
431  SCIP_VAR* var /**< problem variable */
432  );
433 
434 /** gets type of variable */
435 extern
437  SCIP_VAR* var /**< problem variable */
438  );
439 
440 /** returns TRUE if the variable is of binary type; this is the case if:
441  * (1) variable type is binary
442  * (2) variable type is integer or implicit integer and
443  * (i) the lazy lower bound or the global lower bound is greater than or equal to zero
444  * (ii) the lazy upper bound or the global upper bound is less than or equal to one
445  */
446 extern
448  SCIP_VAR* var /**< problem variable */
449  );
450 
451 /** returns whether variable is of integral type (binary, integer, or implicit integer) */
452 extern
454  SCIP_VAR* var /**< problem variable */
455  );
456 
457 /** returns whether variable's column should be present in the initial root LP */
458 extern
460  SCIP_VAR* var /**< problem variable */
461  );
462 
463 /** returns whether variable's column is removable from the LP (due to aging or cleanup) */
464 extern
466  SCIP_VAR* var /**< problem variable */
467  );
468 
469 /** returns whether the variable was deleted from the problem */
470 extern
472  SCIP_VAR* var /**< problem variable */
473  );
474 
475 /** marks the variable to be deletable, i.e., it may be deleted completely from the problem;
476  * method can only be called before the variable is added to the problem by SCIPaddVar() or SCIPaddPricedVar()
477  */
478 extern
480  SCIP_VAR* var /**< problem variable */
481  );
482 
483 /** marks the variable to be not deletable from the problem */
484 extern
486  SCIP_VAR* var
487  );
488 
489 /** returns whether variable is allowed to be deleted completely from the problem */
490 extern
492  SCIP_VAR* var
493  );
494 
495 /** marks variable to be deleted from global structures (cliques etc.) when cleaning up
496  *
497  * @note: this is not equivalent to marking the variable itself for deletion, this is done by using SCIPvarMarkDeletable()
498  */
499 extern
501  SCIP_VAR* var /**< problem variable */
502  );
503 
504 /** returns whether variable is an active (neither fixed nor aggregated) variable */
505 extern
507  SCIP_VAR* var /**< problem variable */
508  );
509 
510 /** gets unique index of variable */
511 extern
512 int SCIPvarGetIndex(
513  SCIP_VAR* var /**< problem variable */
514  );
515 
516 /** gets position of variable in problem, or -1 if variable is not active */
517 extern
519  SCIP_VAR* var /**< problem variable */
520  );
521 
522 /** gets transformed variable of ORIGINAL variable */
523 extern
525  SCIP_VAR* var /**< problem variable */
526  );
527 
528 /** gets column of COLUMN variable */
529 extern
531  SCIP_VAR* var /**< problem variable */
532  );
533 
534 /** returns whether the variable is a COLUMN variable that is member of the current LP */
535 extern
537  SCIP_VAR* var /**< problem variable */
538  );
539 
540 /** gets aggregation variable y of an aggregated variable x = a*y + c */
541 extern
543  SCIP_VAR* var /**< problem variable */
544  );
545 
546 /** gets aggregation scalar a of an aggregated variable x = a*y + c */
547 extern
549  SCIP_VAR* var /**< problem variable */
550  );
551 
552 /** gets aggregation constant c of an aggregated variable x = a*y + c */
553 extern
555  SCIP_VAR* var /**< problem variable */
556  );
557 
558 /** gets number n of aggregation variables of a multi aggregated variable x = a0*y0 + ... + a(n-1)*y(n-1) + c */
559 extern
561  SCIP_VAR* var /**< problem variable */
562  );
563 
564 /** gets vector of aggregation variables y of a multi aggregated variable x = a0*y0 + ... + a(n-1)*y(n-1) + c */
565 extern
567  SCIP_VAR* var /**< problem variable */
568  );
569 
570 /** gets vector of aggregation scalars a of a multi aggregated variable x = a0*y0 + ... + a(n-1)*y(n-1) + c */
571 extern
573  SCIP_VAR* var /**< problem variable */
574  );
575 
576 /** gets aggregation constant c of a multi aggregated variable x = a0*y0 + ... + a(n-1)*y(n-1) + c */
577 extern
579  SCIP_VAR* var /**< problem variable */
580  );
581 
582 /** gets the negation of the given variable; may return NULL, if no negation is existing yet */
583 extern
585  SCIP_VAR* var /**< negated problem variable */
586  );
587 
588 /** gets the negation variable x of a negated variable x' = offset - x */
589 extern
591  SCIP_VAR* var /**< negated problem variable */
592  );
593 
594 /** gets the negation offset of a negated variable x' = offset - x */
595 extern
597  SCIP_VAR* var /**< negated problem variable */
598  );
599 
600 /** gets objective function value of variable */
601 extern
603  SCIP_VAR* var /**< problem variable */
604  );
605 
606 /** gets the unchanged objective function value of variable (ignoring temproray changes performed in probing mode) */
607 extern
609  SCIP_VAR* var /**< problem variable */
610  );
611 
612 /** gets original lower bound of original problem variable (i.e. the bound set in problem creation) */
613 extern
615  SCIP_VAR* var /**< original problem variable */
616  );
617 
618 /** gets original upper bound of original problem variable (i.e. the bound set in problem creation) */
619 extern
621  SCIP_VAR* var /**< original problem variable */
622  );
623 
624 /** gets the original hole list of an original variable */
625 extern
627  SCIP_VAR* var /**< problem variable */
628  );
629 
630 /** gets global lower bound of variable */
631 extern
633  SCIP_VAR* var /**< problem variable */
634  );
635 
636 /** gets global upper bound of variable */
637 extern
639  SCIP_VAR* var /**< problem variable */
640  );
641 
642 /** gets the global hole list of an active variable */
643 extern
645  SCIP_VAR* var /**< problem variable */
646  );
647 
648 /** gets best global bound of variable with respect to the objective function */
649 extern
651  SCIP_VAR* var /**< problem variable */
652  );
653 
654 /** gets worst global bound of variable with respect to the objective function */
655 extern
657  SCIP_VAR* var /**< problem variable */
658  );
659 
660 /** gets current lower bound of variable */
661 extern
663  SCIP_VAR* var /**< problem variable */
664  );
665 
666 /** gets current upper bound of variable */
667 extern
669  SCIP_VAR* var /**< problem variable */
670  );
671 
672 /** gets the current hole list of an active variable */
673 extern
675  SCIP_VAR* var /**< problem variable */
676  );
677 
678 /** gets best local bound of variable with respect to the objective function */
679 extern
681  SCIP_VAR* var /**< problem variable */
682  );
683 
684 /** gets worst local bound of variable with respect to the objective function */
685 extern
687  SCIP_VAR* var /**< problem variable */
688  );
689 
690 /** gets type (lower or upper) of best bound of variable with respect to the objective function */
691 extern
693  SCIP_VAR* var /**< problem variable */
694  );
695 
696 /** gets type (lower or upper) of worst bound of variable with respect to the objective function */
697 extern
699  SCIP_VAR* var /**< problem variable */
700  );
701 
702 /** gets lazy lower bound of variable */
703 extern
705  SCIP_VAR* var /**< problem variable */
706  );
707 
708 /** gets lazy upper bound of variable */
709 extern
711  SCIP_VAR* var /**< problem variable */
712  );
713 
714 /** gets the branch factor of the variable; this value can be used in the branching methods to scale the score
715  * values of the variables; higher factor leads to a higher probability that this variable is chosen for branching
716  */
717 extern
719  SCIP_VAR* var /**< problem variable */
720  );
721 
722 /** gets the branch priority of the variable; variables with higher priority should always be preferred to variables
723  * with lower priority
724  */
725 extern
727  SCIP_VAR* var /**< problem variable */
728  );
729 
730 /** gets the preferred branch direction of the variable (downwards, upwards, or auto) */
731 extern
733  SCIP_VAR* var /**< problem variable */
734  );
735 
736 /** gets number of variable lower bounds x >= b_i*z_i + d_i of given variable x */
737 extern
738 int SCIPvarGetNVlbs(
739  SCIP_VAR* var /**< problem variable */
740  );
741 
742 /** gets array with bounding variables z_i in variable lower bounds x >= b_i*z_i + d_i of given variable x;
743  * the variable bounds are sorted by increasing variable index of the bounding variable z_i (see SCIPvarGetIndex())
744  */
745 extern
747  SCIP_VAR* var /**< problem variable */
748  );
749 
750 /** gets array with bounding coefficients b_i in variable lower bounds x >= b_i*z_i + d_i of given variable x */
751 extern
753  SCIP_VAR* var /**< problem variable */
754  );
755 
756 /** gets array with bounding constants d_i in variable lower bounds x >= b_i*z_i + d_i of given variable x */
757 extern
759  SCIP_VAR* var /**< problem variable */
760  );
761 
762 /** gets number of variable upper bounds x <= b_i*z_i + d_i of given variable x */
763 extern
764 int SCIPvarGetNVubs(
765  SCIP_VAR* var /**< problem variable */
766  );
767 
768 /** gets array with bounding variables z_i in variable upper bounds x <= b_i*z_i + d_i of given variable x;
769  * the variable bounds are sorted by increasing variable index of the bounding variable z_i (see SCIPvarGetIndex())
770  */
771 extern
773  SCIP_VAR* var /**< problem variable */
774  );
775 
776 /** gets array with bounding coefficients b_i in variable upper bounds x <= b_i*z_i + d_i of given variable x */
777 extern
779  SCIP_VAR* var /**< problem variable */
780  );
781 
782 /** gets array with bounding constants d_i in variable upper bounds x <= b_i*z_i + d_i of given variable x */
783 extern
785  SCIP_VAR* var /**< problem variable */
786  );
787 
788 /** gets number of implications y <= b or y >= b for x == 0 or x == 1 of given active problem variable x,
789  * there are no implications for nonbinary variable x
790  */
791 extern
792 int SCIPvarGetNImpls(
793  SCIP_VAR* var, /**< active problem variable */
794  SCIP_Bool varfixing /**< FALSE for implications for x == 0, TRUE for x == 1 */
795  );
796 
797 /** gets array with implication variables y of implications y <= b or y >= b for x == 0 or x == 1 of given active
798  * problem variable x, there are no implications for nonbinary variable x;
799  * the implications are sorted such that implications with binary implied variables precede the ones with non-binary
800  * implied variables, and as a second criteria, the implied variables are sorted by increasing variable index
801  * (see SCIPvarGetIndex())
802  */
803 extern
805  SCIP_VAR* var, /**< active problem variable */
806  SCIP_Bool varfixing /**< FALSE for implications for x == 0, TRUE for x == 1 */
807  );
808 
809 /** gets array with implication types of implications y <= b or y >= b for x == 0 or x == 1 of given active problem
810  * variable x (SCIP_BOUNDTYPE_UPPER if y <= b, SCIP_BOUNDTYPE_LOWER if y >= b),
811  * there are no implications for nonbinary variable x
812  */
813 extern
815  SCIP_VAR* var, /**< active problem variable */
816  SCIP_Bool varfixing /**< FALSE for implications for x == 0, TRUE for x == 1 */
817  );
818 
819 /** gets array with implication bounds b of implications y <= b or y >= b for x == 0 or x == 1 of given active problem
820  * variable x, there are no implications for nonbinary variable x
821  */
822 extern
824  SCIP_VAR* var, /**< active problem variable */
825  SCIP_Bool varfixing /**< FALSE for implications for x == 0, TRUE for x == 1 */
826  );
827 
828 /** Gets array with unique ids of implications y <= b or y >= b for x == 0 or x == 1 of given active problem variable x,
829  * there are no implications for nonbinary variable x.
830  * If an implication is a shortcut, i.e., it was added as part of the transitive closure of another implication,
831  * its id is negative, otherwise it is nonnegative.
832  */
833 extern
834 int* SCIPvarGetImplIds(
835  SCIP_VAR* var, /**< active problem variable */
836  SCIP_Bool varfixing /**< FALSE for implications for x == 0, TRUE for x == 1 */
837  );
838 
839 /** gets number of cliques, the active variable is contained in */
840 extern
842  SCIP_VAR* var, /**< active problem variable */
843  SCIP_Bool varfixing /**< FALSE for cliques containing x == 0, TRUE for x == 1 */
844  );
845 
846 /** gets array of cliques, the active variable is contained in */
847 extern
849  SCIP_VAR* var, /**< active problem variable */
850  SCIP_Bool varfixing /**< FALSE for cliques containing x == 0, TRUE for x == 1 */
851  );
852 
853 /** gets primal LP solution value of variable */
854 extern
856  SCIP_VAR* var /**< problem variable */
857  );
858 
859 /** gets primal NLP solution value of variable */
860 extern
862  SCIP_VAR* var /**< problem variable */
863  );
864 
865 /** return lower bound change info at requested position */
866 extern
868  SCIP_VAR* var, /**< problem variable */
869  int pos /**< requested position */
870  );
871 
872 /** gets the number of lower bound change info array */
873 extern
875  SCIP_VAR* var /**< problem variable */
876  );
877 
878 /** return upper bound change info at requested position */
879 extern
881  SCIP_VAR* var, /**< problem variable */
882  int pos /**< requested position */
883  );
884 
885 /** gets the number upper bound change info array */
886 extern
888  SCIP_VAR* var /**< problem variable */
889  );
890 
891 /** returns the value based history for the variable */
892 extern
894  SCIP_VAR* var /**< problem variable */
895  );
896 
897 #ifdef NDEBUG
898 
899 /* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
900  * speed up the algorithms.
901  */
902 
903 #define SCIPvarGetName(var) (var)->name
904 #define SCIPvarGetNUses(var) (var)->nuses
905 #define SCIPvarGetData(var) (var)->vardata
906 #define SCIPvarSetData(var,vdata) (var)->vardata = (vdata)
907 #define SCIPvarSetDelorigData(var,func) (var)->vardelorig = (func)
908 #define SCIPvarSetTransData(var,func) (var)->vartrans = (func)
909 #define SCIPvarSetDeltransData(var,func) (var)->vardeltrans = (func)
910 #define SCIPvarGetStatus(var) (SCIP_VARSTATUS)((var)->varstatus)
911 #define SCIPvarIsOriginal(var) ((var)->varstatus == SCIP_VARSTATUS_ORIGINAL \
912  || ((var)->varstatus == SCIP_VARSTATUS_NEGATED && (var)->negatedvar->varstatus == SCIP_VARSTATUS_ORIGINAL))
913 #define SCIPvarIsTransformed(var) ((var)->varstatus != SCIP_VARSTATUS_ORIGINAL \
914  && ((var)->varstatus != SCIP_VARSTATUS_NEGATED || (var)->negatedvar->varstatus != SCIP_VARSTATUS_ORIGINAL))
915 #define SCIPvarIsNegated(var) ((var)->varstatus == SCIP_VARSTATUS_NEGATED)
916 #define SCIPvarGetType(var) ((SCIP_VARTYPE)((var)->vartype))
917 #define SCIPvarIsBinary(var) ((var)->vartype == SCIP_VARTYPE_BINARY || \
918  ((var)->vartype != SCIP_VARTYPE_CONTINUOUS && MAX((var)->glbdom.lb, (var)->lazylb) >= 0.0 && MIN((var)->glbdom.ub, (var)->lazyub) <= 1.0))
919 #define SCIPvarIsIntegral(var) ((var)->vartype != SCIP_VARTYPE_CONTINUOUS)
920 #define SCIPvarIsInitial(var) (var)->initial
921 #define SCIPvarIsRemovable(var) (var)->removable
922 #define SCIPvarIsDeleted(var) (var)->deleted
923 #define SCIPvarMarkDeletable(var) (var)->deletable = TRUE
924 #define SCIPvarMarkNotDeletable(var) (var)->deletable = FALSE
925 #define SCIPvarIsDeletable(var) (var)->deletable
926 #define SCIPvarIsActive(var) ((var)->probindex >= 0)
927 #define SCIPvarGetIndex(var) (var)->index
928 #define SCIPvarGetProbindex(var) (var)->probindex
929 #define SCIPvarGetTransVar(var) (var)->data.original.transvar
930 #define SCIPvarGetCol(var) (var)->data.col
931 #define SCIPvarIsInLP(var) ((var)->varstatus == SCIP_VARSTATUS_COLUMN && SCIPcolIsInLP((var)->data.col))
932 /* use different name for var - otherwise we have clash with the var at the end */
933 #define SCIPvarGetAggrVar(war) (war)->data.aggregate.var
934 #define SCIPvarGetAggrScalar(var) (var)->data.aggregate.scalar
935 #define SCIPvarGetAggrConstant(var) (var)->data.aggregate.constant
936 #define SCIPvarGetMultaggrNVars(var) (var)->data.multaggr.nvars
937 #define SCIPvarGetMultaggrVars(var) (var)->data.multaggr.vars
938 #define SCIPvarGetMultaggrScalars(var) (var)->data.multaggr.scalars
939 #define SCIPvarGetMultaggrConstant(var) (var)->data.multaggr.constant
940 #define SCIPvarGetNegatedVar(var) (var)->negatedvar
941 #define SCIPvarGetNegationVar(var) (var)->negatedvar
942 #define SCIPvarGetNegationConstant(var) (var)->data.negate.constant
943 #define SCIPvarGetObj(var) (var)->obj
944 #define SCIPvarGetLbOriginal(var) ((var)->varstatus == SCIP_VARSTATUS_ORIGINAL \
945  ? (var)->data.original.origdom.lb \
946  : (var)->data.negate.constant - (var)->negatedvar->data.original.origdom.ub)
947 #define SCIPvarGetUbOriginal(var) ((var)->varstatus == SCIP_VARSTATUS_ORIGINAL \
948  ? (var)->data.original.origdom.ub \
949  : (var)->data.negate.constant - (var)->negatedvar->data.original.origdom.lb)
950 #define SCIPvarGetHolelistOriginal(var) ((var)->varstatus == SCIP_VARSTATUS_ORIGINAL \
951  ? (var)->data.original.origdom.holelist \
952  : NULL)
953 #define SCIPvarGetLbGlobal(var) (var)->glbdom.lb
954 #define SCIPvarGetUbGlobal(var) (var)->glbdom.ub
955 #define SCIPvarGetHolelistGlobal(var) (var)->glbdom.holelist
956 #define SCIPvarGetBestBoundGlobal(var) ((var)->obj >= 0.0 ? (var)->glbdom.lb : (var)->glbdom.ub)
957 #define SCIPvarGetWorstBoundGlobal(var) ((var)->obj >= 0.0 ? (var)->glbdom.ub : (var)->glbdom.lb)
958 #define SCIPvarGetLbLocal(var) (var)->locdom.lb
959 #define SCIPvarGetUbLocal(var) (var)->locdom.ub
960 #define SCIPvarGetHolelistLocal(var) (var)->locdom.holelist
961 #define SCIPvarGetBestBoundLocal(var) ((var)->obj >= 0.0 ? (var)->locdom.lb : (var)->locdom.ub)
962 #define SCIPvarGetWorstBoundLocal(var) ((var)->obj >= 0.0 ? (var)->locdom.ub : (var)->locdom.lb)
963 #define SCIPvarGetBestBoundType(var) ((var)->obj >= 0.0 ? SCIP_BOUNDTYPE_LOWER : SCIP_BOUNDTYPE_UPPER)
964 #define SCIPvarGetWorstBoundType(var) ((var)->obj >= 0.0 ? SCIP_BOUNDTYPE_UPPER : SCIP_BOUNDTYPE_LOWER)
965 #define SCIPvarGetLbLazy(var) (var)->lazylb
966 #define SCIPvarGetUbLazy(var) (var)->lazyub
967 #define SCIPvarGetBranchFactor(var) (var)->branchfactor
968 #define SCIPvarGetBranchPriority(var) (var)->branchpriority
969 #define SCIPvarGetBranchDirection(var) (var)->branchdirection
970 #define SCIPvarGetNVlbs(var) (SCIPvboundsGetNVbds((var)->vlbs))
971 #define SCIPvarGetVlbVars(var) (SCIPvboundsGetVars((var)->vlbs))
972 #define SCIPvarGetVlbCoefs(var) (SCIPvboundsGetCoefs((var)->vlbs))
973 #define SCIPvarGetVlbConstants(var) (SCIPvboundsGetConstants((var)->vlbs))
974 #define SCIPvarGetNVubs(var) (SCIPvboundsGetNVbds((var)->vubs))
975 #define SCIPvarGetVubVars(var) (SCIPvboundsGetVars((var)->vubs))
976 #define SCIPvarGetVubCoefs(var) (SCIPvboundsGetCoefs((var)->vubs))
977 #define SCIPvarGetVubConstants(var) (SCIPvboundsGetConstants((var)->vubs))
978 #define SCIPvarGetNImpls(var, fix) (SCIPimplicsGetNImpls((var)->implics, fix))
979 #define SCIPvarGetImplVars(var, fix) (SCIPimplicsGetVars((var)->implics, fix))
980 #define SCIPvarGetImplTypes(var, fix) (SCIPimplicsGetTypes((var)->implics, fix))
981 #define SCIPvarGetImplBounds(var, fix) (SCIPimplicsGetBounds((var)->implics, fix))
982 #define SCIPvarGetImplIds(var, fix) (SCIPimplicsGetIds((var)->implics, fix))
983 #define SCIPvarGetNCliques(var, fix) (SCIPcliquelistGetNCliques((var)->cliquelist, fix))
984 #define SCIPvarGetCliques(var, fix) (SCIPcliquelistGetCliques((var)->cliquelist, fix))
985 #define SCIPvarGetLPSol(var) ((var)->varstatus == SCIP_VARSTATUS_COLUMN ? SCIPcolGetPrimsol((var)->data.col) : SCIPvarGetLPSol_rec(var))
986 #define SCIPvarGetNLPSol(var) (((var)->varstatus == SCIP_VARSTATUS_COLUMN || ((var)->varstatus == SCIP_VARSTATUS_LOOSE)) ? (var)->nlpsol : SCIPvarGetNLPSol_rec(var))
987 #define SCIPvarGetBdchgInfoLb(var, pos) (&((var)->lbchginfos[pos]))
988 #define SCIPvarGetNBdchgInfosLb(var) ((var)->nlbchginfos)
989 #define SCIPvarGetBdchgInfoUb(var, pos) (&((var)->ubchginfos[pos]))
990 #define SCIPvarGetNBdchgInfosUb(var) ((var)->nubchginfos)
991 #define SCIPvarGetValuehistory(var) (var)->valuehistory
992 #define SCIPvarGetCliqueComponentIdx(var) ((var)->clqcomponentidx)
993 
994 #endif
995 
996 /** gets primal LP solution value of variable */
997 extern
999  SCIP_VAR* var /**< problem variable */
1000  );
1001 
1002 /** gets primal NLP solution value of variable */
1003 extern
1005  SCIP_VAR* var /**< problem variable */
1006  );
1007 
1008 /** gets pseudo solution value of variable at current node */
1009 extern
1011  SCIP_VAR* var /**< problem variable */
1012  );
1013 
1014 /** gets current LP or pseudo solution value of variable */
1015 extern
1017  SCIP_VAR* var, /**< problem variable */
1018  SCIP_Bool getlpval /**< should the LP solution value be returned? */
1019  );
1020 
1021 /** returns the solution of the variable in the last root node's relaxation, if the root relaxation is not yet
1022  * completely solved, zero is returned
1023  */
1024 extern
1026  SCIP_VAR* var /**< problem variable */
1027  );
1028 
1029 /** returns the best solution (w.r.t. root reduced cost propagation) of the variable in the root node's relaxation, if
1030  * the root relaxation is not yet completely solved, zero is returned
1031  */
1032 extern
1034  SCIP_VAR* var /**< problem variable */
1035  );
1036 
1037 /** returns the best reduced costs (w.r.t. root reduced cost propagation) of the variable in the root node's relaxation,
1038  * if the root relaxation is not yet completely solved, or the variable was no column of the root LP, SCIP_INVALID is
1039  * returned
1040  */
1041 extern
1043  SCIP_VAR* var /**< problem variable */
1044  );
1045 
1046 /** returns the best objective value (w.r.t. root reduced cost propagation) of the root LP which belongs the root
1047  * reduced cost which is accessible via SCIPvarGetRootRedcost() or the variable was no column of the root LP,
1048  * SCIP_INVALID is returned
1049  */
1050 extern
1052  SCIP_VAR* var /**< problem variable */
1053  );
1054 
1055 /** set the given solution as the best root solution w.r.t. root reduced cost propagation in the variables */
1056 extern
1058  SCIP_VAR* var, /**< problem variable */
1059  SCIP_Real rootsol, /**< root solution value */
1060  SCIP_Real rootredcost, /**< root reduced cost */
1061  SCIP_Real rootlpobjval /**< objective value of the root LP */
1062  );
1063 
1064 /** returns a weighted average solution value of the variable in all feasible primal solutions found so far */
1065 extern
1067  SCIP_VAR* var /**< problem variable */
1068  );
1069 
1070 /** returns the bound change information for the last lower bound change on given active problem variable before or
1071  * after the bound change with the given index was applied;
1072  * returns NULL, if no change to the lower bound was applied up to this point of time
1073  */
1074 extern
1076  SCIP_VAR* var, /**< active 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 the bound change information for the last upper bound change on given active problem variable before or
1082  * after the bound change with the given index was applied;
1083  * returns NULL, if no change to the upper bound was applied up to this point of time
1084  */
1085 extern
1087  SCIP_VAR* var, /**< active problem variable */
1088  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
1089  SCIP_Bool after /**< should the bound change with given index be included? */
1090  );
1091 
1092 /** returns the bound change information for the last lower or upper bound change on given active problem variable
1093  * before or after the bound change with the given index was applied;
1094  * returns NULL, if no change to the lower/upper bound was applied up to this point of time
1095  */
1096 extern
1098  SCIP_VAR* var, /**< active problem variable */
1099  SCIP_BOUNDTYPE boundtype, /**< type of bound: lower or upper bound */
1100  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
1101  SCIP_Bool after /**< should the bound change with given index be included? */
1102  );
1103 
1104 /** returns lower bound of variable directly before or after the bound change given by the bound change index
1105  * was applied
1106  *
1107  * @deprecated Please use SCIPgetVarLbAtIndex()
1108  */
1109 extern
1111  SCIP_VAR* var, /**< problem variable */
1112  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
1113  SCIP_Bool after /**< should the bound change with given index be included? */
1114  );
1115 
1116 /** returns upper bound of variable directly before or after the bound change given by the bound change index
1117  * was applied
1118  *
1119  * @deprecated Please use SCIPgetVarUbAtIndex()
1120  */
1121 extern
1123  SCIP_VAR* var, /**< problem variable */
1124  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
1125  SCIP_Bool after /**< should the bound change with given index be included? */
1126  );
1127 
1128 /** returns lower or upper bound of variable directly before or after the bound change given by the bound change index
1129  * was applied
1130  *
1131  * @deprecated Please use SCIPgetVarBdAtIndex()
1132  */
1133 extern
1135  SCIP_VAR* var, /**< problem variable */
1136  SCIP_BOUNDTYPE boundtype, /**< type of bound: lower or upper bound */
1137  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
1138  SCIP_Bool after /**< should the bound change with given index be included? */
1139  );
1140 
1141 /** returns whether the binary variable was fixed at the time given by the bound change index
1142  *
1143  * @deprecated Please use SCIPgetVarWasFixedAtIndex()
1144  */
1145 extern
1147  SCIP_VAR* var, /**< problem variable */
1148  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
1149  SCIP_Bool after /**< should the bound change with given index be included? */
1150  );
1151 
1152 /** returns the last bound change index, at which the bounds of the given variable were tightened */
1153 extern
1155  SCIP_VAR* var /**< problem variable */
1156  );
1157 
1158 /** returns the last depth level, at which the bounds of the given variable were tightened;
1159  * returns -2, if the variable's bounds are still the global bounds
1160  * returns -1, if the variable was fixed in presolving
1161  */
1162 extern
1164  SCIP_VAR* var /**< problem variable */
1165  );
1166 
1167 /** returns whether the first binary variable was fixed earlier than the second one;
1168  * returns FALSE, if the first variable is not fixed, and returns TRUE, if the first variable is fixed, but the
1169  * second one is not fixed
1170  */
1171 extern
1173  SCIP_VAR* var1, /**< first binary variable */
1174  SCIP_VAR* var2 /**< second binary variable */
1175  );
1176 
1177 /**
1178  * @name Public SCIP_BDCHGIDX Methods
1179  *
1180  * @{
1181  */
1182 
1183 /** returns whether first bound change index belongs to an earlier applied bound change than second one;
1184  * if a bound change index is NULL, the bound change index represents the current time, i.e. the time after the
1185  * last bound change was applied to the current node
1186  */
1187 extern
1189  SCIP_BDCHGIDX* bdchgidx1, /**< first bound change index, or NULL */
1190  SCIP_BDCHGIDX* bdchgidx2 /**< second bound change index, or NULL */
1191  );
1192 
1193 /** returns whether first bound change index belongs to an earlier applied bound change than second one */
1194 extern
1196  SCIP_BDCHGIDX* bdchgidx1, /**< first bound change index */
1197  SCIP_BDCHGIDX* bdchgidx2 /**< second bound change index */
1198  );
1199 
1200 /**@} */
1201 
1202 /**
1203  * @name Public SCIP_BDCHGINFO Methods
1204  *
1205  * @{
1206  */
1207 
1208 /** returns old bound that was overwritten for given bound change information */
1209 extern
1211  SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1212  );
1213 
1214 /** returns new bound installed for given bound change information */
1215 extern
1217  SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1218  );
1219 
1220 /** returns variable that belongs to the given bound change information */
1221 extern
1223  SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1224  );
1225 
1226 /** returns whether the bound change information belongs to a branching decision or a deduction */
1227 extern
1229  SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1230  );
1231 
1232 /** returns whether the bound change information belongs to a lower or upper bound change */
1233 extern
1235  SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1236  );
1237 
1238 /** returns depth level of given bound change information */
1239 extern
1241  SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1242  );
1243 
1244 /** returns bound change position in its depth level of given bound change information */
1245 extern
1247  SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1248  );
1249 
1250 /** returns bound change index of given bound change information */
1251 extern
1253  SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1254  );
1255 
1256 /** returns inference variable of given bound change information */
1257 extern
1259  SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1260  );
1261 
1262 /** returns inference constraint of given bound change information */
1263 extern
1265  SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1266  );
1267 
1268 /** returns inference propagator of given bound change information, or NULL if no propagator was responsible */
1269 extern
1271  SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1272  );
1273 
1274 /** returns inference user information of given bound change information */
1275 extern
1277  SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1278  );
1279 
1280 /** returns inference bound of inference variable of given bound change information */
1281 extern
1283  SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1284  );
1285 
1286 /** returns whether the bound change information belongs to a redundant bound change */
1287 extern
1289  SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1290  );
1291 
1292 /** returns whether the bound change has an inference reason (constraint or propagator), that can be resolved */
1293 extern
1295  SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1296  );
1297 
1298 /** for two bound change informations belonging to the same variable and bound, returns whether the first bound change
1299  * has a tighter new bound as the second bound change
1300  */
1301 extern
1303  SCIP_BDCHGINFO* bdchginfo1, /**< first bound change information */
1304  SCIP_BDCHGINFO* bdchginfo2 /**< second bound change information */
1305  );
1306 
1307 /**@} */
1308 
1309 /**
1310  * @name Public SCIP_BOUNDCHG Methods
1311  *
1312  * @{
1313  */
1314 
1315 /** returns the new value of the bound in the bound change data */
1316 extern
1318  SCIP_BOUNDCHG* boundchg /**< bound change data */
1319  );
1320 
1321 /** returns the variable of the bound change in the bound change data */
1322 extern
1324  SCIP_BOUNDCHG* boundchg /**< bound change data */
1325  );
1326 
1327 /** returns the bound change type of the bound change in the bound change data */
1328 extern
1330  SCIP_BOUNDCHG* boundchg /**< bound change data */
1331  );
1332 
1333 /** returns the bound type of the bound change in the bound change data */
1334 extern
1336  SCIP_BOUNDCHG* boundchg /**< bound change data */
1337  );
1338 
1339 /** returns whether the bound change is redundant due to a more global bound that is at least as strong */
1340 extern
1342  SCIP_BOUNDCHG* boundchg /**< bound change data */
1343  );
1344 
1345 /** @} */
1346 
1347 /**
1348  * @name Public SCIP_DOMCHG Methods
1349  *
1350  * @{
1351  */
1352 
1353 /** returns the number of bound changes in the domain change data */
1354 extern
1356  SCIP_DOMCHG* domchg /**< domain change data */
1357  );
1358 
1359 /** returns a particular bound change in the domain change data */
1360 extern
1362  SCIP_DOMCHG* domchg, /**< domain change data */
1363  int pos /**< position of the bound change in the domain change data */
1364  );
1365 
1366 /**@} */
1367 
1368 /**
1369  * @name Public SCIP_HOLELIST Methods
1370  *
1371  * @{
1372  */
1373 
1374 /** returns left bound of open interval in hole */
1375 extern
1377  SCIP_HOLELIST* holelist /**< hole list pointer to hole of interest */
1378  );
1379 
1380 /** returns right bound of open interval in hole */
1381 extern
1383  SCIP_HOLELIST* holelist /**< hole list pointer to hole of interest */
1384  );
1385 
1386 /** returns next hole in list or NULL */
1387 extern
1389  SCIP_HOLELIST* holelist /**< hole list pointer to hole of interest */
1390  );
1391 
1392 /**@} */
1393 
1394 #ifdef NDEBUG
1395 
1396 /* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
1397  * speed up the algorithms.
1398  */
1399 
1400 #define SCIPbdchgidxIsEarlierNonNull(idx1,idx2) \
1401  ((idx1)->depth < (idx2)->depth || ((idx1)->depth == (idx2)->depth && (idx1)->pos < (idx2)->pos))
1402 #define SCIPbdchgidxIsEarlier(idx1,idx2) \
1403  ((idx1) != NULL && ((idx2) == NULL || SCIPbdchgidxIsEarlierNonNull(idx1, idx2)))
1404 #define SCIPbdchginfoGetOldbound(bdchginfo) (bdchginfo)->oldbound
1405 #define SCIPbdchginfoGetNewbound(bdchginfo) (bdchginfo)->newbound
1406 #define SCIPbdchginfoGetVar(bdchginfo) (bdchginfo)->var
1407 #define SCIPbdchginfoGetChgtype(bdchginfo) (SCIP_BOUNDCHGTYPE)((bdchginfo)->boundchgtype)
1408 #define SCIPbdchginfoGetBoundtype(bdchginfo) (SCIP_BOUNDTYPE)((bdchginfo)->boundtype)
1409 #define SCIPbdchginfoGetDepth(bdchginfo) (bdchginfo)->bdchgidx.depth
1410 #define SCIPbdchginfoGetPos(bdchginfo) (bdchginfo)->bdchgidx.pos
1411 #define SCIPbdchginfoGetIdx(bdchginfo) (&(bdchginfo)->bdchgidx)
1412 #define SCIPbdchginfoGetInferVar(bdchginfo) (bdchginfo)->inferencedata.var
1413 #define SCIPbdchginfoGetInferCons(bdchginfo) (bdchginfo)->inferencedata.reason.cons
1414 #define SCIPbdchginfoGetInferProp(bdchginfo) (bdchginfo)->inferencedata.reason.prop
1415 #define SCIPbdchginfoGetInferInfo(bdchginfo) (bdchginfo)->inferencedata.info
1416 #define SCIPbdchginfoGetInferBoundtype(bdchginfo) (SCIP_BOUNDTYPE)((bdchginfo)->inferboundtype)
1417 #define SCIPbdchginfoIsRedundant(bdchginfo) (bdchginfo)->redundant
1418 #define SCIPbdchginfoHasInferenceReason(bdchginfo) \
1419  (((bdchginfo)->boundchgtype == SCIP_BOUNDCHGTYPE_CONSINFER) \
1420  || ((bdchginfo)->boundchgtype == SCIP_BOUNDCHGTYPE_PROPINFER && (bdchginfo)->inferencedata.reason.prop != NULL))
1421 #define SCIPbdchginfoIsTighter(bdchginfo1,bdchginfo2) ((bdchginfo1)->boundtype == SCIP_BOUNDTYPE_LOWER \
1422  ? (bdchginfo1)->newbound > bdchginfo2->newbound : (bdchginfo1)->newbound < bdchginfo2->newbound)
1423 #define SCIPboundchgGetNewbound(boundchg) ((boundchg)->newbound)
1424 #define SCIPboundchgGetVar(boundchg) ((boundchg)->var)
1425 #define SCIPboundchgGetBoundchgtype(boundchg) ((SCIP_BOUNDCHGTYPE)((boundchg)->boundchgtype))
1426 #define SCIPboundchgGetBoundtype(boundchg) ((SCIP_BOUNDTYPE)((boundchg)->boundtype))
1427 #define SCIPboundchgIsRedundant(boundchg) ((boundchg)->redundant)
1428 #define SCIPdomchgGetNBoundchgs(domchg) ((domchg) != NULL ? (domchg)->domchgbound.nboundchgs : 0)
1429 #define SCIPdomchgGetBoundchg(domchg, pos) (&(domchg)->domchgbound.boundchgs[pos])
1430 #define SCIPholelistGetLeft(holelist) ((holelist)->hole.left)
1431 #define SCIPholelistGetRight(holelist) ((holelist)->hole.right)
1432 #define SCIPholelistGetNext(holelist) ((holelist)->next)
1433 
1434 #endif
1435 
1436 /**@} */
1437 
1438 #ifdef __cplusplus
1439 }
1440 #endif
1441 
1442 #endif
enum SCIP_BoundType SCIP_BOUNDTYPE
Definition: type_lp.h:50
SCIP_Real SCIPvarGetWorstBoundLocal(SCIP_VAR *var)
Definition: var.c:17442
SCIP_Real * SCIPvarGetVlbCoefs(SCIP_VAR *var)
Definition: var.c:17557
SCIP_BOUNDTYPE SCIPvarGetWorstBoundType(SCIP_VAR *var)
Definition: var.c:17468
SCIP_Bool SCIPvarsHaveCommonClique(SCIP_VAR *var1, SCIP_Bool value1, SCIP_VAR *var2, SCIP_Bool value2, SCIP_Bool regardimplics)
Definition: var.c:10958
SCIP_Real SCIPvarGetBdAtIndex(SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: var.c:16262
SCIP_PROP * SCIPbdchginfoGetInferProp(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:18029
void SCIPvarMarkNotDeletable(SCIP_VAR *var)
Definition: var.c:16973
int SCIPvarGetNLocksDownType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)
Definition: var.c:3176
SCIP_BDCHGINFO * SCIPvarGetBdchgInfoLb(SCIP_VAR *var, int pos)
Definition: var.c:17743
SCIP_Real * SCIPvarGetMultaggrScalars(SCIP_VAR *var)
Definition: var.c:17135
type definitions for miscellaneous datastructures
type definitions for implications, variable bounds, and cliques
SCIP_Real SCIPvarGetBranchFactor(SCIP_VAR *var)
Definition: var.c:17503
SCIP_Real SCIPbdchginfoGetOldbound(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:17925
SCIP_BRANCHDIR SCIPvarGetBranchDirection(SCIP_VAR *var)
Definition: var.c:17525
SCIP_Real SCIPvarGetUbLazy(SCIP_VAR *var)
Definition: var.c:17491
int SCIPvarGetNVlbs(SCIP_VAR *var)
Definition: var.c:17535
SCIP_VAR * SCIPbdchginfoGetVar(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:17945
SCIP_Real SCIPvarGetWorstBoundGlobal(SCIP_VAR *var)
Definition: var.c:17386
#define SCIP_DECL_VARTRANS(x)
Definition: type_var.h:138
methods for implications, variable bounds, and cliques
int SCIPvarGetLastBdchgDepth(SCIP_VAR *var)
Definition: var.c:16342
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
Definition: var.c:17343
SCIP_Real SCIPvarGetAvgBranchdepth(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: var.c:15260
SCIP_RETCODE SCIPvarGetProbvarBinary(SCIP_VAR **var, SCIP_Bool *negated)
Definition: var.c:11789
int SCIPvarGetNLocksUpType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)
Definition: var.c:3233
SCIP_Bool SCIPvarIsInitial(SCIP_VAR *var)
Definition: var.c:16930
SCIP_VAR ** SCIPvarGetMultaggrVars(SCIP_VAR *var)
Definition: var.c:17123
static long bound
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
Definition: var.c:17399
SCIP_CLIQUE ** SCIPvarGetCliques(SCIP_VAR *var, SCIP_Bool varfixing)
Definition: var.c:17706
SCIP_VALUEHISTORY * SCIPvarGetValuehistory(SCIP_VAR *var)
Definition: var.c:17785
void SCIPvarSetTransData(SCIP_VAR *var, SCIP_DECL_VARTRANS((*vartrans)))
Definition: var.c:16782
SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)
Definition: var.c:16909
SCIP_Real SCIPvarGetSol(SCIP_VAR *var, SCIP_Bool getlpval)
Definition: var.c:12734
SCIP_Bool SCIPbdchgidxIsEarlier(SCIP_BDCHGIDX *bdchgidx1, SCIP_BDCHGIDX *bdchgidx2)
Definition: var.c:17905
SCIP_Bool SCIPvarWasFixedAtIndex(SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: var.c:16282
SCIP_Real SCIPvarGetBestBoundLocal(SCIP_VAR *var)
Definition: var.c:17429
SCIP_Real SCIPvarGetRootSol(SCIP_VAR *var)
Definition: var.c:12827
SCIP_BOUNDTYPE SCIPboundchgGetBoundtype(SCIP_BOUNDCHG *boundchg)
Definition: var.c:16656
SCIP_HOLELIST * SCIPholelistGetNext(SCIP_HOLELIST *holelist)
Definition: var.c:16716
int SCIPvarGetNBdchgInfosLb(SCIP_VAR *var)
Definition: var.c:17755
struct SCIP_VarData SCIP_VARDATA
Definition: type_var.h:107
SCIP_Bool SCIPvarHasImplic(SCIP_VAR *var, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_BOUNDTYPE impltype)
Definition: var.c:10629
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:53
SCIP_Real SCIPvarGetNegationConstant(SCIP_VAR *var)
Definition: var.c:17180
int SCIPvarGetNVubs(SCIP_VAR *var)
Definition: var.c:17577
int SCIPbdchginfoGetInferInfo(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:18040
enum SCIP_Varstatus SCIP_VARSTATUS
Definition: type_var.h:48
int SCIPvarGetProbindex(SCIP_VAR *var)
Definition: var.c:17036
#define SCIP_DECL_VARCOPY(x)
Definition: type_var.h:181
SCIP_Real SCIPvarGetAggrScalar(SCIP_VAR *var)
Definition: var.c:17089
SCIP_Real SCIPvarGetInferenceSum(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: var.c:15450
void SCIPvarMarkDeletable(SCIP_VAR *var)
Definition: var.c:16962
type definitions for return codes for SCIP methods
SCIP_VAR ** SCIPvarGetVlbVars(SCIP_VAR *var)
Definition: var.c:17547
SCIP_Bool SCIPvarIsDeletable(SCIP_VAR *var)
Definition: var.c:17006
SCIP_Bool SCIPvarIsRemovable(SCIP_VAR *var)
Definition: var.c:16940
SCIP_Longint SCIPvarGetNBranchingsCurrentRun(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: var.c:15217
SCIP_VAR * SCIPvarGetNegationVar(SCIP_VAR *var)
Definition: var.c:17169
SCIP_BDCHGIDX * SCIPvarGetLastBdchgIndex(SCIP_VAR *var)
Definition: var.c:16305
int SCIPvarGetNCliques(SCIP_VAR *var, SCIP_Bool varfixing)
Definition: var.c:17695
SCIP_Real SCIPvarGetLPSol_rec(SCIP_VAR *var)
Definition: var.c:12548
internal methods for branching and inference history
SCIP_Real SCIPvarGetCutoffSumCurrentRun(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: var.c:15693
int * SCIPvarGetImplIds(SCIP_VAR *var, SCIP_Bool varfixing)
Definition: var.c:17683
SCIP_HOLELIST * SCIPvarGetHolelistOriginal(SCIP_VAR *var)
Definition: var.c:17329
SCIP_DECL_HASHKEYVAL(SCIPvarGetHashkeyVal)
Definition: var.c:11479
#define SCIP_DECL_VARDELTRANS(x)
Definition: type_var.h:151
type definitions for LP management
SCIP_VAR * SCIPvarGetNegatedVar(SCIP_VAR *var)
Definition: var.c:17159
enum SCIP_BranchDir SCIP_BRANCHDIR
Definition: type_history.h:39
SCIP_Real SCIPvarGetNLPSol_rec(SCIP_VAR *var)
Definition: var.c:12620
int SCIPvarGetNBdchgInfosUb(SCIP_VAR *var)
Definition: var.c:17775
SCIP_Bool SCIPbdchginfoIsTighter(SCIP_BDCHGINFO *bdchginfo1, SCIP_BDCHGINFO *bdchginfo2)
Definition: var.c:18098
SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)
Definition: var.c:17353
SCIP_VAR * SCIPvarGetProbvar(SCIP_VAR *var)
Definition: var.c:11697
SCIP_Real SCIPvarGetBestRootLPObjval(SCIP_VAR *var)
Definition: var.c:13291
void SCIPvarSetDelorigData(SCIP_VAR *var, SCIP_DECL_VARDELORIG((*vardelorig)))
Definition: var.c:16770
void SCIPvarSetDeltransData(SCIP_VAR *var, SCIP_DECL_VARDELTRANS((*vardeltrans)))
Definition: var.c:16794
SCIP_Real SCIPvarGetBestBoundGlobal(SCIP_VAR *var)
Definition: var.c:17373
enum SCIP_LockType SCIP_LOCKTYPE
Definition: type_var.h:87
SCIP_Bool SCIPboundchgIsRedundant(SCIP_BOUNDCHG *boundchg)
Definition: var.c:16666
SCIP_Real SCIPvarGetLbOriginal(SCIP_VAR *var)
Definition: var.c:17289
SCIP_Bool SCIPbdchgidxIsEarlierNonNull(SCIP_BDCHGIDX *bdchgidx1, SCIP_BDCHGIDX *bdchgidx2)
Definition: var.c:17885
int SCIPvarCompareActiveAndNegated(SCIP_VAR *var1, SCIP_VAR *var2)
Definition: var.c:11384
SCIP_Real SCIPvarGetAvgBranchdepthCurrentRun(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: var.c:15305
SCIP_Real SCIPvarGetUbOriginal(SCIP_VAR *var)
Definition: var.c:17309
SCIP_Bool SCIPvarIsTransformedOrigvar(SCIP_VAR *var)
Definition: var.c:12340
type definitions for SCIP&#39;s main datastructure
SCIP_DECL_SORTPTRCOMP(SCIPvarCompActiveAndNegated)
Definition: var.c:11414
SCIP_Real SCIPvarGetUbAtIndex(SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: var.c:16138
SCIP_Bool SCIPvarHasBinaryImplic(SCIP_VAR *var, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_Bool implvarfixing)
Definition: var.c:10649
SCIP_Real * SCIPvarGetVubConstants(SCIP_VAR *var)
Definition: var.c:17609
SCIP_Real SCIPvarGetAggrConstant(SCIP_VAR *var)
Definition: var.c:17100
const char * SCIPvarGetName(SCIP_VAR *var)
Definition: var.c:16729
SCIP_DECL_HASHGETKEY(SCIPvarGetHashkey)
Definition: var.c:11465
SCIP_Real SCIPboundchgGetNewbound(SCIP_BOUNDCHG *boundchg)
Definition: var.c:16626
SCIP_Real SCIPvarGetLPSol(SCIP_VAR *var)
Definition: var.c:17717
SCIP_HOLELIST * SCIPvarGetHolelistGlobal(SCIP_VAR *var)
Definition: var.c:17363
SCIP_RETCODE SCIPvarGetAggregatedObj(SCIP_VAR *var, SCIP_Real *aggrobj)
Definition: var.c:17213
SCIP_Bool SCIPbdchginfoHasInferenceReason(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:18084
SCIP_Real SCIPvarGetLbLazy(SCIP_VAR *var)
Definition: var.c:17481
SCIP_Real * SCIPvarGetVlbConstants(SCIP_VAR *var)
Definition: var.c:17567
SCIP_Real SCIPvarGetMultaggrConstant(SCIP_VAR *var)
Definition: var.c:17147
type definitions for problem variables
SCIP_Real SCIPvarGetCutoffSum(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: var.c:15650
SCIP_Real * SCIPvarGetVubCoefs(SCIP_VAR *var)
Definition: var.c:17599
SCIP_Bool SCIPbdchginfoIsRedundant(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:18073
SCIP_BDCHGIDX * SCIPbdchginfoGetIdx(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:17995
void SCIPvarSetBestRootSol(SCIP_VAR *var, SCIP_Real rootsol, SCIP_Real rootredcost, SCIP_Real rootlpobjval)
Definition: var.c:13322
SCIP_Bool SCIPvarIsOriginal(SCIP_VAR *var)
Definition: var.c:16858
SCIP_BOUNDTYPE * SCIPvarGetImplTypes(SCIP_VAR *var, SCIP_Bool varfixing)
Definition: var.c:17653
SCIP_Real SCIPholelistGetRight(SCIP_HOLELIST *holelist)
Definition: var.c:16706
#define SCIP_Bool
Definition: def.h:62
SCIP_BOUNDCHGTYPE SCIPboundchgGetBoundchgtype(SCIP_BOUNDCHG *boundchg)
Definition: var.c:16646
int SCIPbdchginfoGetPos(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:17985
SCIP_Bool SCIPvarWasFixedEarlier(SCIP_VAR *var1, SCIP_VAR *var2)
Definition: var.c:16430
SCIP_Real SCIPvarGetInferenceSumCurrentRun(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: var.c:15495
SCIP_Bool SCIPvarIsInLP(SCIP_VAR *var)
Definition: var.c:17068
SCIP_Real SCIPvarGetNLPSol(SCIP_VAR *var)
Definition: var.c:17730
int SCIPvarGetBranchPriority(SCIP_VAR *var)
Definition: var.c:17515
SCIP_Real SCIPvarGetLbAtIndex(SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: var.c:16014
int SCIPvarGetNImpls(SCIP_VAR *var, SCIP_Bool varfixing)
Definition: var.c:17621
SCIP_VARDATA * SCIPvarGetData(SCIP_VAR *var)
Definition: var.c:16749
int SCIPvarGetNLocksUp(SCIP_VAR *var)
Definition: var.c:3308
SCIP_VAR * SCIPboundchgGetVar(SCIP_BOUNDCHG *boundchg)
Definition: var.c:16636
int SCIPvarCompare(SCIP_VAR *var1, SCIP_VAR *var2)
Definition: var.c:11422
SCIP_BOUNDCHG * SCIPdomchgGetBoundchg(SCIP_DOMCHG *domchg, int pos)
Definition: var.c:16684
SCIP_Real SCIPvarGetUnchangedObj(SCIP_VAR *var)
Definition: var.c:17201
public methods for LP management
SCIP_Real SCIPvarGetObj(SCIP_VAR *var)
Definition: var.c:17191
SCIP_Real SCIPbdchginfoGetNewbound(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:17935
SCIP_Real SCIPvarGetBestRootRedcost(SCIP_VAR *var)
Definition: var.c:13257
SCIP_VAR * SCIPvarGetAggrVar(SCIP_VAR *var)
Definition: var.c:17078
SCIP_COL * SCIPvarGetCol(SCIP_VAR *var)
Definition: var.c:17057
int SCIPvarGetMultaggrNVars(SCIP_VAR *var)
Definition: var.c:17111
SCIP_Real * SCIPvarGetImplBounds(SCIP_VAR *var, SCIP_Bool varfixing)
Definition: var.c:17667
SCIP_RETCODE SCIPvarGetOrigvarSum(SCIP_VAR **var, SCIP_Real *scalar, SCIP_Real *constant)
Definition: var.c:12253
SCIP_BDCHGINFO * SCIPvarGetLbchgInfo(SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: var.c:15881
SCIP_BOUNDTYPE SCIPbdchginfoGetInferBoundtype(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:18052
SCIP_BDCHGINFO * SCIPvarGetUbchgInfo(SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: var.c:15937
SCIP_RETCODE SCIPvarGetProbvarBound(SCIP_VAR **var, SCIP_Real *bound, SCIP_BOUNDTYPE *boundtype)
Definition: var.c:11948
SCIP_BDCHGINFO * SCIPvarGetBdchgInfoUb(SCIP_VAR *var, int pos)
Definition: var.c:17763
SCIP_BDCHGINFO * SCIPvarGetBdchgInfo(SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: var.c:15993
#define SCIP_DECL_VARDELORIG(x)
Definition: type_var.h:118
type definitions for propagators
SCIP_VAR ** SCIPvarGetImplVars(SCIP_VAR *var, SCIP_Bool varfixing)
Definition: var.c:17638
int SCIPvarGetNLocksDown(SCIP_VAR *var)
Definition: var.c:3295
int SCIPdomchgGetNBoundchgs(SCIP_DOMCHG *domchg)
Definition: var.c:16676
int SCIPbdchginfoGetDepth(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:17975
SCIP_DECL_HASHKEYEQ(SCIPvarIsHashkeyEq)
Definition: var.c:11471
SCIP_Real SCIPvarGetBestRootSol(SCIP_VAR *var)
Definition: var.c:13191
void SCIPvarSetCopyData(SCIP_VAR *var, SCIP_DECL_VARCOPY((*varcopy)))
Definition: var.c:16805
SCIP_Real SCIPholelistGetLeft(SCIP_HOLELIST *holelist)
Definition: var.c:16696
datastructures for problem variables
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
Definition: var.c:16848
#define SCIP_Real
Definition: def.h:150
result codes for SCIP callback methods
type definitions for branching and inference history
SCIP_Longint SCIPvarGetNBranchings(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: var.c:15172
SCIP_RETCODE SCIPvarsGetProbvarBinary(SCIP_VAR ***vars, SCIP_Bool **negatedarr, int nvars)
Definition: var.c:11757
SCIP_VAR * SCIPbdchginfoGetInferVar(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:18005
SCIP_RETCODE SCIPvarSetInitial(SCIP_VAR *var, SCIP_Bool initial)
Definition: var.c:16816
SCIP_RETCODE SCIPvarGetProbvarHole(SCIP_VAR **var, SCIP_Real *left, SCIP_Real *right)
Definition: var.c:12041
int SCIPvarGetNUses(SCIP_VAR *var)
Definition: var.c:16739
void SCIPvarsGetProbvar(SCIP_VAR **vars, int nvars)
Definition: var.c:11677
SCIP_VAR ** SCIPvarGetVubVars(SCIP_VAR *var)
Definition: var.c:17589
#define SCIP_Longint
Definition: def.h:135
SCIP_BOUNDTYPE SCIPvarGetBestBoundType(SCIP_VAR *var)
Definition: var.c:17455
SCIP_CONS * SCIPbdchginfoGetInferCons(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:18017
SCIP_Real SCIPvarGetAvgSol(SCIP_VAR *var)
Definition: var.c:13537
int SCIPvarGetIndex(SCIP_VAR *var)
Definition: var.c:17026
SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)
Definition: var.c:16894
enum SCIP_Vartype SCIP_VARTYPE
Definition: type_var.h:60
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
Definition: var.c:17409
SCIP_Bool SCIPvarIsTransformed(SCIP_VAR *var)
Definition: var.c:16871
SCIP_HOLELIST * SCIPvarGetHolelistLocal(SCIP_VAR *var)
Definition: var.c:17419
SCIP_BOUNDTYPE SCIPbdchginfoGetBoundtype(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:17965
common defines and data types used in all packages of SCIP
SCIP_RETCODE SCIPvarSetRemovable(SCIP_VAR *var, SCIP_Bool removable)
Definition: var.c:16832
SCIP_Real SCIPvarGetPseudoSol(SCIP_VAR *var)
Definition: var.c:17795
enum SCIP_BoundchgType SCIP_BOUNDCHGTYPE
Definition: type_var.h:78
SCIP_VAR * SCIPvarGetTransVar(SCIP_VAR *var)
Definition: var.c:17046
SCIP_Bool SCIPvarIsIntegral(SCIP_VAR *var)
Definition: var.c:16920
SCIP_Bool SCIPvarIsDeleted(SCIP_VAR *var)
Definition: var.c:16950
void SCIPvarSetData(SCIP_VAR *var, SCIP_VARDATA *vardata)
Definition: var.c:16759
SCIP_Bool SCIPvarMayRoundUp(SCIP_VAR *var)
Definition: var.c:3330
SCIP_Bool SCIPvarMayRoundDown(SCIP_VAR *var)
Definition: var.c:3319
type definitions for constraints and constraint handlers
SCIP_Bool SCIPvarIsActive(SCIP_VAR *var)
Definition: var.c:17016
SCIP_Bool SCIPvarIsNegated(SCIP_VAR *var)
Definition: var.c:16884
void SCIPvarMarkDeleteGlobalStructures(SCIP_VAR *var)
Definition: var.c:16986
SCIP_BOUNDCHGTYPE SCIPbdchginfoGetChgtype(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:17955