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-2024 Zuse Institute Berlin (ZIB) */
7/* */
8/* Licensed under the Apache License, Version 2.0 (the "License"); */
9/* you may not use this file except in compliance with the License. */
10/* You may obtain a copy of the License at */
11/* */
12/* http://www.apache.org/licenses/LICENSE-2.0 */
13/* */
14/* Unless required by applicable law or agreed to in writing, software */
15/* distributed under the License is distributed on an "AS IS" BASIS, */
16/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */
17/* See the License for the specific language governing permissions and */
18/* limitations under the License. */
19/* */
20/* You should have received a copy of the Apache-2.0 license */
21/* along with SCIP; see the file LICENSE. If not visit scipopt.org. */
22/* */
23/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
24
25/**@file pub_var.h
26 * @ingroup PUBLICCOREAPI
27 * @brief public methods for problem variables
28 * @author Tobias Achterberg
29 */
30
31/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
32
33#ifndef __SCIP_PUB_VAR_H__
34#define __SCIP_PUB_VAR_H__
35
36
37#include "scip/def.h"
38#include "scip/type_cons.h"
39#include "scip/type_history.h"
40#include "scip/type_implics.h"
41#include "scip/type_lp.h"
42#include "scip/type_misc.h"
43#include "scip/type_prop.h"
44#include "scip/type_result.h"
45#include "scip/type_retcode.h"
46#include "scip/type_scip.h"
47#include "scip/type_var.h"
48
49#ifdef NDEBUG
50#include "scip/struct_var.h"
51#include "scip/implics.h"
52#include "scip/history.h"
53#include "scip/pub_lp.h"
54#endif
55
56#ifdef __cplusplus
57extern "C" {
58#endif
59
60/*
61 * methods for variables
62 */
63
64/**@addtogroup PublicVariableMethods
65 *
66 * @{
67 */
68
69/** gets number of locks for rounding down
70 *
71 * @note This method will always return variable locks of type model
72 *
73 * @note It is recommented to use SCIPvarGetNLocksDownType()
74 */
75SCIP_EXPORT
77 SCIP_VAR* var /**< problem variable */
78 );
79
80/** gets number of locks for rounding up
81 *
82 * @note This method will always return variable locks of type model
83 *
84 * @note It is recommented to use SCIPvarGetNLocksUpType()
85 */
86SCIP_EXPORT
88 SCIP_VAR* var /**< problem variable */
89 );
90
91/** gets number of locks for rounding up of a special type */
92SCIP_EXPORT
94 SCIP_VAR* var, /**< problem variable */
95 SCIP_LOCKTYPE locktype /**< type of variable locks */
96 );
97
98/** gets number of locks for rounding down of a special type */
99SCIP_EXPORT
101 SCIP_VAR* var, /**< problem variable */
102 SCIP_LOCKTYPE locktype /**< type of variable locks */
103 );
104
105/** is it possible, to round variable down and stay feasible?
106 *
107 * @note This method will always check w.r.t variable locks of type model
108 */
109SCIP_EXPORT
111 SCIP_VAR* var /**< problem variable */
112 );
113
114/** is it possible, to round variable up and stay feasible?
115 *
116 * @note This method will always check w.r.t. variable locks of type model
117 */
118SCIP_EXPORT
120 SCIP_VAR* var /**< problem variable */
121 );
122
123/** compares the index of two variables, only active or negated variables are allowed, if a variable
124 * is negated then the index of the corresponding active variable is taken, returns -1 if first is
125 * smaller than, and +1 if first is greater than second variable index; returns 0 if both indices
126 * are equal, which means both variables are equal
127 */
128SCIP_EXPORT
130 SCIP_VAR* var1, /**< first problem variable */
131 SCIP_VAR* var2 /**< second problem variable */
132 );
133
134/** comparison method for sorting active and negated variables by non-decreasing index, active and negated
135 * variables are handled as the same variables
136 */
137SCIP_EXPORT
138SCIP_DECL_SORTPTRCOMP(SCIPvarCompActiveAndNegated);
139
140/** compares the index of two variables, returns -1 if first is smaller than, and +1 if first is greater than second
141 * variable index; returns 0 if both indices are equal, which means both variables are equal
142 */
143SCIP_EXPORT
145 SCIP_VAR* var1, /**< first problem variable */
146 SCIP_VAR* var2 /**< second problem variable */
147 );
148
149/** comparison method for sorting variables by non-decreasing index */
150SCIP_EXPORT
151SCIP_DECL_SORTPTRCOMP(SCIPvarComp);
152
153/** comparison method for sorting variables by non-decreasing objective coefficient */
154SCIP_EXPORT
155SCIP_DECL_SORTPTRCOMP(SCIPvarCompObj);
156
157/** hash key retrieval function for variables */
158SCIP_EXPORT
159SCIP_DECL_HASHGETKEY(SCIPvarGetHashkey);
160
161/** returns TRUE iff the indices of both variables are equal */
162SCIP_EXPORT
163SCIP_DECL_HASHKEYEQ(SCIPvarIsHashkeyEq);
164
165/** returns the hash value of the key */
166SCIP_EXPORT
167SCIP_DECL_HASHKEYVAL(SCIPvarGetHashkeyVal);
168
169
170/** gets corresponding active, fixed, or multi-aggregated problem variables of given variables,
171 * @note the content of the given array will/might change
172 */
173SCIP_EXPORT
175 SCIP_VAR** vars, /**< array of problem variables */
176 int nvars /**< number of variables */
177 );
178
179/** gets corresponding active, fixed, or multi-aggregated problem variable of a variable */
180SCIP_EXPORT
182 SCIP_VAR* var /**< problem variable */
183 );
184
185/** gets corresponding active, fixed, or multi-aggregated problem variables of binary variables and
186 * updates the given negation status of each variable
187 */
188SCIP_EXPORT
190 SCIP_VAR*** vars, /**< pointer to binary problem variables */
191 SCIP_Bool** negatedarr, /**< pointer to corresponding array to update the negation status */
192 int nvars /**< number of variables and values in vars and negated array */
193 );
194
195/** gets corresponding active, fixed, or multi-aggregated problem variable of a binary variable and
196 * updates the given negation status
197 */
198SCIP_EXPORT
200 SCIP_VAR** var, /**< pointer to binary problem variable */
201 SCIP_Bool* negated /**< pointer to update the negation status */
202 );
203
204/** transforms given variable, boundtype and bound to the corresponding active, fixed, or multi-aggregated variable
205 * values
206 */
207SCIP_EXPORT
209 SCIP_VAR** var, /**< pointer to problem variable */
210 SCIP_Real* bound, /**< pointer to bound value to transform */
211 SCIP_BOUNDTYPE* boundtype /**< pointer to type of bound: lower or upper bound */
212 );
213
214/** transforms given variable and domain hole to the corresponding active, fixed, or multi-aggregated variable
215 * values
216 */
217SCIP_EXPORT
219 SCIP_VAR** var, /**< pointer to problem variable */
220 SCIP_Real* left, /**< pointer to left bound of open interval in hole to transform */
221 SCIP_Real* right /**< pointer to right bound of open interval in hole to transform */
222 );
223
224/** retransforms given variable, scalar and constant to the corresponding original variable, scalar
225 * and constant, if possible; if the retransformation is impossible, NULL is returned as variable
226 */
227SCIP_EXPORT
229 SCIP_VAR** var, /**< pointer to problem variable x in sum a*x + c */
230 SCIP_Real* scalar, /**< pointer to scalar a in sum a*x + c */
231 SCIP_Real* constant /**< pointer to constant c in sum a*x + c */
232 );
233
234/** returns whether the given variable is the direct counterpart of an original problem variable */
235SCIP_EXPORT
237 SCIP_VAR* var /**< problem variable */
238 );
239
240/** returns the number of times, a bound of the variable was changed in given direction due to branching */
241SCIP_EXPORT
243 SCIP_VAR* var, /**< problem variable */
244 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
245 );
246
247/** returns the number of times, a bound of the variable was changed in given direction due to branching
248 * in the current run
249 */
250SCIP_EXPORT
252 SCIP_VAR* var, /**< problem variable */
253 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
254 );
255
256/** returns the number of inferences branching on this variable in given direction triggered */
257SCIP_EXPORT
259 SCIP_VAR* var, /**< problem variable */
260 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
261 );
262
263/** returns the number of inferences branching on this variable in given direction triggered
264 * in the current run
265 */
266SCIP_EXPORT
268 SCIP_VAR* var, /**< problem variable */
269 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
270 );
271
272/** returns the number of cutoffs branching on this variable in given direction produced */
273SCIP_EXPORT
275 SCIP_VAR* var, /**< problem variable */
276 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
277 );
278
279/** returns the number of cutoffs branching on this variable in given direction produced in the current run */
280SCIP_EXPORT
282 SCIP_VAR* var, /**< problem variable */
283 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
284 );
285
286/** returns the average depth of bound changes in given direction due to branching on the variable */
287SCIP_EXPORT
289 SCIP_VAR* var, /**< problem variable */
290 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
291 );
292
293/** returns the average depth of bound changes in given direction due to branching on the variable
294 * in the current run
295 */
296SCIP_EXPORT
298 SCIP_VAR* var, /**< problem variable */
299 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
300 );
301
302/** returns whether there is an implication x == varfixing -> y <= b or y >= b in the implication graph;
303 * implications that are represented as cliques in the clique table are not regarded (use SCIPvarsHaveCommonClique());
304 * both variables must be active, variable x must be binary
305 */
306SCIP_EXPORT
308 SCIP_VAR* var, /**< problem variable x */
309 SCIP_Bool varfixing, /**< FALSE if y should be searched in implications for x == 0, TRUE for x == 1 */
310 SCIP_VAR* implvar, /**< variable y to search for */
311 SCIP_BOUNDTYPE impltype /**< type of implication y <=/>= b to search for */
312 );
313
314/** returns whether there is an implication x == varfixing -> y == implvarfixing in the implication graph;
315 * implications that are represented as cliques in the clique table are not regarded (use SCIPvarsHaveCommonClique());
316 * both variables must be active binary variables
317 */
318SCIP_EXPORT
320 SCIP_VAR* var, /**< problem variable x */
321 SCIP_Bool varfixing, /**< FALSE if y should be searched in implications for x == 0, TRUE for x == 1 */
322 SCIP_VAR* implvar, /**< variable y to search for */
323 SCIP_Bool implvarfixing /**< value of the implied variable to search for */
324 );
325
326/** gets the values of b in implications x == varfixing -> y <= b or y >= b in the implication graph;
327 * the values are set to SCIP_INVALID if there is no implied bound
328 */
329SCIP_EXPORT
331 SCIP_VAR* var, /**< problem variable x */
332 SCIP_Bool varfixing, /**< FALSE if y should be searched in implications for x == 0, TRUE for x == 1 */
333 SCIP_VAR* implvar, /**< variable y to search for */
334 SCIP_Real* lb, /**< buffer to store the value of the implied lower bound */
335 SCIP_Real* ub /**< buffer to store the value of the implied upper bound */
336 );
337
338/** returns whether there is a clique that contains both given variable/value pairs;
339 * the variables must be active binary variables;
340 * if regardimplics is FALSE, only the cliques in the clique table are looked at;
341 * if regardimplics is TRUE, both the cliques and the implications of the implication graph are regarded
342 */
343SCIP_EXPORT
345 SCIP_VAR* var1, /**< first variable */
346 SCIP_Bool value1, /**< value of first variable */
347 SCIP_VAR* var2, /**< second variable */
348 SCIP_Bool value2, /**< value of second variable */
349 SCIP_Bool regardimplics /**< should the implication graph also be searched for a clique? */
350 );
351
352/** gets corresponding objective value of active, fixed, or multi-aggregated problem variable of given variable
353 * e.g. obj(x) = 1 this method returns for ~x the value -1
354 */
355SCIP_EXPORT
357 SCIP_VAR* var, /**< problem variable */
358 SCIP_Real* aggrobj /**< pointer to store the aggregated objective value */
359 );
360
361/** sets the initial flag of a variable; only possible for original or loose variables */
362SCIP_EXPORT
364 SCIP_VAR* var, /**< problem variable */
365 SCIP_Bool initial /**< initial flag */
366 );
367
368/** sets the removable flag of a variable; only possible for original or loose variables */
369SCIP_EXPORT
371 SCIP_VAR* var, /**< problem variable */
372 SCIP_Bool removable /**< removable flag */
373 );
374
375/** returns the name of the variable
376 *
377 * @note to change the name of a variable, use SCIPchgVarName() from scip.h
378 */
379SCIP_EXPORT
380const char* SCIPvarGetName(
381 SCIP_VAR* var /**< problem variable */
382 );
383
384/** gets number of times, the variable is currently captured */
385SCIP_EXPORT
387 SCIP_VAR* var /**< problem variable */
388 );
389
390/** returns the user data of the variable */
391SCIP_EXPORT
393 SCIP_VAR* var /**< problem variable */
394 );
395
396/** sets the user data for the variable */
397SCIP_EXPORT
398void SCIPvarSetData(
399 SCIP_VAR* var, /**< problem variable */
400 SCIP_VARDATA* vardata /**< user variable data */
401 );
402
403/** sets method to free user data for the original variable */
404SCIP_EXPORT
406 SCIP_VAR* var, /**< problem variable */
407 SCIP_DECL_VARDELORIG ((*vardelorig)) /**< frees user data of original variable */
408 );
409
410/** sets method to transform user data of the variable */
411SCIP_EXPORT
413 SCIP_VAR* var, /**< problem variable */
414 SCIP_DECL_VARTRANS ((*vartrans)) /**< creates transformed user data by transforming original user data */
415 );
416
417/** sets method to free transformed user data for the variable */
418SCIP_EXPORT
420 SCIP_VAR* var, /**< problem variable */
421 SCIP_DECL_VARDELTRANS ((*vardeltrans)) /**< frees user data of transformed variable */
422 );
423
424/** sets method to copy this variable into sub-SCIPs */
425SCIP_EXPORT
427 SCIP_VAR* var, /**< problem variable */
428 SCIP_DECL_VARCOPY ((*varcopy)) /**< copy method of the variable */
429 );
430
431/** gets status of variable */
432SCIP_EXPORT
434 SCIP_VAR* var /**< problem variable */
435 );
436
437/** returns whether the variable belongs to the original problem */
438SCIP_EXPORT
440 SCIP_VAR* var /**< problem variable */
441 );
442
443/** returns whether the variable belongs to the transformed problem */
444SCIP_EXPORT
446 SCIP_VAR* var /**< problem variable */
447 );
448
449/** returns whether the variable was created by negation of a different variable */
450SCIP_EXPORT
452 SCIP_VAR* var /**< problem variable */
453 );
454
455/** gets type of variable */
456SCIP_EXPORT
458 SCIP_VAR* var /**< problem variable */
459 );
460
461/** returns TRUE if the variable is of binary type; this is the case if:
462 * (1) variable type is binary
463 * (2) variable type is integer or implicit integer and
464 * (i) the global lower bound is greater than or equal to zero
465 * (ii) the global upper bound is less than or equal to one
466 */
467SCIP_EXPORT
469 SCIP_VAR* var /**< problem variable */
470 );
471
472/** returns whether variable is of integral type (binary, integer, or implicit integer) */
473SCIP_EXPORT
475 SCIP_VAR* var /**< problem variable */
476 );
477
478/** returns whether variable's column should be present in the initial root LP */
479SCIP_EXPORT
481 SCIP_VAR* var /**< problem variable */
482 );
483
484/** returns whether variable's column is removable from the LP (due to aging or cleanup) */
485SCIP_EXPORT
487 SCIP_VAR* var /**< problem variable */
488 );
489
490/** returns whether the variable was deleted from the problem */
491SCIP_EXPORT
493 SCIP_VAR* var /**< problem variable */
494 );
495
496/** marks the variable to be deletable, i.e., it may be deleted completely from the problem;
497 * method can only be called before the variable is added to the problem by SCIPaddVar() or SCIPaddPricedVar()
498 */
499SCIP_EXPORT
501 SCIP_VAR* var /**< problem variable */
502 );
503
504/** marks the variable to be not deletable from the problem */
505SCIP_EXPORT
507 SCIP_VAR* var
508 );
509
510/** returns whether variable is allowed to be deleted completely from the problem */
511SCIP_EXPORT
513 SCIP_VAR* var
514 );
515
516/** marks variable to be deleted from global structures (cliques etc.) when cleaning up
517 *
518 * @note: this is not equivalent to marking the variable itself for deletion, this is done by using SCIPvarMarkDeletable()
519 */
520SCIP_EXPORT
522 SCIP_VAR* var /**< problem variable */
523 );
524
525/** returns whether variable is an active (neither fixed nor aggregated) variable */
526SCIP_EXPORT
528 SCIP_VAR* var /**< problem variable */
529 );
530
531/** gets unique index of variable */
532SCIP_EXPORT
534 SCIP_VAR* var /**< problem variable */
535 );
536
537/** gets position of variable in problem, or -1 if variable is not active */
538SCIP_EXPORT
540 SCIP_VAR* var /**< problem variable */
541 );
542
543/** gets transformed variable of ORIGINAL variable */
544SCIP_EXPORT
546 SCIP_VAR* var /**< problem variable */
547 );
548
549/** gets column of COLUMN variable */
550SCIP_EXPORT
552 SCIP_VAR* var /**< problem variable */
553 );
554
555/** returns whether the variable is a COLUMN variable that is member of the current LP */
556SCIP_EXPORT
558 SCIP_VAR* var /**< problem variable */
559 );
560
561/** gets aggregation variable y of an aggregated variable x = a*y + c */
562SCIP_EXPORT
564 SCIP_VAR* var /**< problem variable */
565 );
566
567/** gets aggregation scalar a of an aggregated variable x = a*y + c */
568SCIP_EXPORT
570 SCIP_VAR* var /**< problem variable */
571 );
572
573/** gets aggregation constant c of an aggregated variable x = a*y + c */
574SCIP_EXPORT
576 SCIP_VAR* var /**< problem variable */
577 );
578
579/** gets number n of aggregation variables of a multi aggregated variable x = a0*y0 + ... + a(n-1)*y(n-1) + c */
580SCIP_EXPORT
582 SCIP_VAR* var /**< problem variable */
583 );
584
585/** gets vector of aggregation variables y of a multi aggregated variable x = a0*y0 + ... + a(n-1)*y(n-1) + c */
586SCIP_EXPORT
588 SCIP_VAR* var /**< problem variable */
589 );
590
591/** gets vector of aggregation scalars a of a multi aggregated variable x = a0*y0 + ... + a(n-1)*y(n-1) + c */
592SCIP_EXPORT
594 SCIP_VAR* var /**< problem variable */
595 );
596
597/** gets aggregation constant c of a multi aggregated variable x = a0*y0 + ... + a(n-1)*y(n-1) + c */
598SCIP_EXPORT
600 SCIP_VAR* var /**< problem variable */
601 );
602
603/** gets the negation of the given variable; may return NULL, if no negation is existing yet */
604SCIP_EXPORT
606 SCIP_VAR* var /**< negated problem variable */
607 );
608
609/** gets the negation variable x of a negated variable x' = offset - x */
610SCIP_EXPORT
612 SCIP_VAR* var /**< negated problem variable */
613 );
614
615/** gets the negation offset of a negated variable x' = offset - x */
616SCIP_EXPORT
618 SCIP_VAR* var /**< negated problem variable */
619 );
620
621/** gets objective function value of variable */
622SCIP_EXPORT
624 SCIP_VAR* var /**< problem variable */
625 );
626
627/** gets the unchanged objective function value of variable (ignoring temproray changes performed in probing mode) */
628SCIP_EXPORT
630 SCIP_VAR* var /**< problem variable */
631 );
632
633/** gets original lower bound of original problem variable (i.e. the bound set in problem creation) */
634SCIP_EXPORT
636 SCIP_VAR* var /**< original problem variable */
637 );
638
639/** gets original upper bound of original problem variable (i.e. the bound set in problem creation) */
640SCIP_EXPORT
642 SCIP_VAR* var /**< original problem variable */
643 );
644
645/** gets the original hole list of an original variable */
646SCIP_EXPORT
648 SCIP_VAR* var /**< problem variable */
649 );
650
651/** gets global lower bound of variable */
652SCIP_EXPORT
654 SCIP_VAR* var /**< problem variable */
655 );
656
657/** gets global upper bound of variable */
658SCIP_EXPORT
660 SCIP_VAR* var /**< problem variable */
661 );
662
663/** gets the global hole list of an active variable */
664SCIP_EXPORT
666 SCIP_VAR* var /**< problem variable */
667 );
668
669/** gets best global bound of variable with respect to the objective function */
670SCIP_EXPORT
672 SCIP_VAR* var /**< problem variable */
673 );
674
675/** gets worst global bound of variable with respect to the objective function */
676SCIP_EXPORT
678 SCIP_VAR* var /**< problem variable */
679 );
680
681/** gets current lower bound of variable */
682SCIP_EXPORT
684 SCIP_VAR* var /**< problem variable */
685 );
686
687/** gets current upper bound of variable */
688SCIP_EXPORT
690 SCIP_VAR* var /**< problem variable */
691 );
692
693/** gets the current hole list of an active variable */
694SCIP_EXPORT
696 SCIP_VAR* var /**< problem variable */
697 );
698
699/** gets best local bound of variable with respect to the objective function */
700SCIP_EXPORT
702 SCIP_VAR* var /**< problem variable */
703 );
704
705/** gets worst local bound of variable with respect to the objective function */
706SCIP_EXPORT
708 SCIP_VAR* var /**< problem variable */
709 );
710
711/** gets type (lower or upper) of best bound of variable with respect to the objective function */
712SCIP_EXPORT
714 SCIP_VAR* var /**< problem variable */
715 );
716
717/** gets type (lower or upper) of worst bound of variable with respect to the objective function */
718SCIP_EXPORT
720 SCIP_VAR* var /**< problem variable */
721 );
722
723/** gets lazy lower bound of variable */
724SCIP_EXPORT
726 SCIP_VAR* var /**< problem variable */
727 );
728
729/** gets lazy upper bound of variable */
730SCIP_EXPORT
732 SCIP_VAR* var /**< problem variable */
733 );
734
735/** gets the branch factor of the variable; this value can be used in the branching methods to scale the score
736 * values of the variables; higher factor leads to a higher probability that this variable is chosen for branching
737 */
738SCIP_EXPORT
740 SCIP_VAR* var /**< problem variable */
741 );
742
743/** gets the branch priority of the variable; variables with higher priority should always be preferred to variables
744 * with lower priority
745 */
746SCIP_EXPORT
748 SCIP_VAR* var /**< problem variable */
749 );
750
751/** gets the preferred branch direction of the variable (downwards, upwards, or auto) */
752SCIP_EXPORT
754 SCIP_VAR* var /**< problem variable */
755 );
756
757/** gets number of variable lower bounds x >= b_i*z_i + d_i of given variable x */
758SCIP_EXPORT
760 SCIP_VAR* var /**< problem variable */
761 );
762
763/** gets array with bounding variables z_i in variable lower bounds x >= b_i*z_i + d_i of given variable x;
764 * the variable bounds are sorted by increasing variable index of the bounding variable z_i (see SCIPvarGetIndex())
765 */
766SCIP_EXPORT
768 SCIP_VAR* var /**< problem variable */
769 );
770
771/** gets array with bounding coefficients b_i in variable lower bounds x >= b_i*z_i + d_i of given variable x */
772SCIP_EXPORT
774 SCIP_VAR* var /**< problem variable */
775 );
776
777/** gets array with bounding constants d_i in variable lower bounds x >= b_i*z_i + d_i of given variable x */
778SCIP_EXPORT
780 SCIP_VAR* var /**< problem variable */
781 );
782
783/** gets number of variable upper bounds x <= b_i*z_i + d_i of given variable x */
784SCIP_EXPORT
786 SCIP_VAR* var /**< problem variable */
787 );
788
789/** gets array with bounding variables z_i in variable upper bounds x <= b_i*z_i + d_i of given variable x;
790 * the variable bounds are sorted by increasing variable index of the bounding variable z_i (see SCIPvarGetIndex())
791 */
792SCIP_EXPORT
794 SCIP_VAR* var /**< problem variable */
795 );
796
797/** gets array with bounding coefficients b_i in variable upper bounds x <= b_i*z_i + d_i of given variable x */
798SCIP_EXPORT
800 SCIP_VAR* var /**< problem variable */
801 );
802
803/** gets array with bounding constants d_i in variable upper bounds x <= b_i*z_i + d_i of given variable x */
804SCIP_EXPORT
806 SCIP_VAR* var /**< problem variable */
807 );
808
809/** gets number of implications y <= b or y >= b for x == 0 or x == 1 of given active problem variable x,
810 * there are no implications for nonbinary variable x
811 */
812SCIP_EXPORT
814 SCIP_VAR* var, /**< active problem variable */
815 SCIP_Bool varfixing /**< FALSE for implications for x == 0, TRUE for x == 1 */
816 );
817
818/** gets array with implication variables y of implications y <= b or y >= b for x == 0 or x == 1 of given active
819 * problem variable x, there are no implications for nonbinary variable x;
820 * the implications are sorted such that implications with binary implied variables precede the ones with non-binary
821 * implied variables, and as a second criteria, the implied variables are sorted by increasing variable index
822 * (see SCIPvarGetIndex())
823 */
824SCIP_EXPORT
826 SCIP_VAR* var, /**< active problem variable */
827 SCIP_Bool varfixing /**< FALSE for implications for x == 0, TRUE for x == 1 */
828 );
829
830/** gets array with implication types of implications y <= b or y >= b for x == 0 or x == 1 of given active problem
831 * variable x (SCIP_BOUNDTYPE_UPPER if y <= b, SCIP_BOUNDTYPE_LOWER if y >= b),
832 * there are no implications for nonbinary variable x
833 */
834SCIP_EXPORT
836 SCIP_VAR* var, /**< active problem variable */
837 SCIP_Bool varfixing /**< FALSE for implications for x == 0, TRUE for x == 1 */
838 );
839
840/** gets array with implication bounds b of implications y <= b or y >= b for x == 0 or x == 1 of given active problem
841 * variable x, there are no implications for nonbinary variable x
842 */
843SCIP_EXPORT
845 SCIP_VAR* var, /**< active problem variable */
846 SCIP_Bool varfixing /**< FALSE for implications for x == 0, TRUE for x == 1 */
847 );
848
849/** Gets array with unique ids of implications y <= b or y >= b for x == 0 or x == 1 of given active problem variable x,
850 * there are no implications for nonbinary variable x.
851 * If an implication is a shortcut, i.e., it was added as part of the transitive closure of another implication,
852 * its id is negative, otherwise it is nonnegative.
853 */
854SCIP_EXPORT
856 SCIP_VAR* var, /**< active problem variable */
857 SCIP_Bool varfixing /**< FALSE for implications for x == 0, TRUE for x == 1 */
858 );
859
860/** gets number of cliques, the active variable is contained in */
861SCIP_EXPORT
863 SCIP_VAR* var, /**< active problem variable */
864 SCIP_Bool varfixing /**< FALSE for cliques containing x == 0, TRUE for x == 1 */
865 );
866
867/** gets array of cliques, the active variable is contained in */
868SCIP_EXPORT
870 SCIP_VAR* var, /**< active problem variable */
871 SCIP_Bool varfixing /**< FALSE for cliques containing x == 0, TRUE for x == 1 */
872 );
873
874/** gets primal LP solution value of variable */
875SCIP_EXPORT
877 SCIP_VAR* var /**< problem variable */
878 );
879
880/** gets primal NLP solution value of variable */
881SCIP_EXPORT
883 SCIP_VAR* var /**< problem variable */
884 );
885
886/** return lower bound change info at requested position */
887SCIP_EXPORT
889 SCIP_VAR* var, /**< problem variable */
890 int pos /**< requested position */
891 );
892
893/** gets the number of lower bound change info array */
894SCIP_EXPORT
896 SCIP_VAR* var /**< problem variable */
897 );
898
899/** return upper bound change info at requested position */
900SCIP_EXPORT
902 SCIP_VAR* var, /**< problem variable */
903 int pos /**< requested position */
904 );
905
906/** gets the number upper bound change info array */
907SCIP_EXPORT
909 SCIP_VAR* var /**< problem variable */
910 );
911
912/** returns the value based history for the variable */
913SCIP_EXPORT
915 SCIP_VAR* var /**< problem variable */
916 );
917
918/** returns whether a variable has been introduced to define a relaxation
919 *
920 * These variables are only valid for the current SCIP solve round,
921 * they are not contained in any (checked) constraints, but may be used
922 * in cutting planes, for example.
923 * Relaxation-only variables are not copied by SCIPcopyVars and cuts
924 * that contain these variables are not added as linear constraints when
925 * restarting or transferring information from a copied SCIP to a SCIP.
926 * Also conflicts with relaxation-only variables are not generated at
927 * the moment.
928 * Relaxation-only variables do not appear in the objective.
929 */
930SCIP_EXPORT
932 SCIP_VAR* var /**< problem variable */
933 );
934
935/** marks that this variable has only been introduced to define a relaxation
936 *
937 * The variable must not have a coefficient in the objective and must be deletable.
938 * If it is not marked deletable, it will be marked as deletable, which is only possible
939 * before the variable is added to a problem.
940 *
941 * @see SCIPvarIsRelaxationOnly
942 * @see SCIPvarMarkDeletable
943 */
944SCIP_EXPORT
946 SCIP_VAR* var /**< problem variable */
947 );
948
949#ifdef NDEBUG
950
951/* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
952 * speed up the algorithms.
953 */
954
955#define SCIPvarGetName(var) (var)->name
956#define SCIPvarGetNUses(var) (var)->nuses
957#define SCIPvarGetData(var) (var)->vardata
958#define SCIPvarSetData(var,vdata) (var)->vardata = (vdata)
959#define SCIPvarSetDelorigData(var,func) (var)->vardelorig = (func)
960#define SCIPvarSetTransData(var,func) (var)->vartrans = (func)
961#define SCIPvarSetDeltransData(var,func) (var)->vardeltrans = (func)
962#define SCIPvarGetStatus(var) (SCIP_VARSTATUS)((var)->varstatus)
963#define SCIPvarIsOriginal(var) ((var)->varstatus == SCIP_VARSTATUS_ORIGINAL \
964 || ((var)->varstatus == SCIP_VARSTATUS_NEGATED && (var)->negatedvar->varstatus == SCIP_VARSTATUS_ORIGINAL))
965#define SCIPvarIsTransformed(var) ((var)->varstatus != SCIP_VARSTATUS_ORIGINAL \
966 && ((var)->varstatus != SCIP_VARSTATUS_NEGATED || (var)->negatedvar->varstatus != SCIP_VARSTATUS_ORIGINAL))
967#define SCIPvarIsNegated(var) ((var)->varstatus == SCIP_VARSTATUS_NEGATED)
968#define SCIPvarGetType(var) ((SCIP_VARTYPE)((var)->vartype))
969#define SCIPvarIsBinary(var) ((var)->vartype == SCIP_VARTYPE_BINARY || \
970 ((var)->vartype != SCIP_VARTYPE_CONTINUOUS && (var)->glbdom.lb >= 0.0 && (var)->glbdom.ub <= 1.0))
971#define SCIPvarIsIntegral(var) ((var)->vartype != SCIP_VARTYPE_CONTINUOUS)
972#define SCIPvarIsInitial(var) (var)->initial
973#define SCIPvarIsRemovable(var) (var)->removable
974#define SCIPvarIsDeleted(var) (var)->deleted
975#define SCIPvarMarkDeletable(var) (var)->deletable = TRUE
976#define SCIPvarMarkNotDeletable(var) (var)->deletable = FALSE
977#define SCIPvarIsDeletable(var) (var)->deletable
978#define SCIPvarIsActive(var) ((var)->probindex >= 0)
979#define SCIPvarGetIndex(var) (var)->index
980#define SCIPvarGetProbindex(var) (var)->probindex
981#define SCIPvarGetTransVar(var) (var)->data.original.transvar
982#define SCIPvarGetCol(var) (var)->data.col
983#define SCIPvarIsInLP(var) ((var)->varstatus == SCIP_VARSTATUS_COLUMN && SCIPcolIsInLP((var)->data.col))
984/* use different name for var - otherwise we have clash with the var at the end */
985#define SCIPvarGetAggrVar(war) (war)->data.aggregate.var
986#define SCIPvarGetAggrScalar(var) (var)->data.aggregate.scalar
987#define SCIPvarGetAggrConstant(var) (var)->data.aggregate.constant
988#define SCIPvarGetMultaggrNVars(var) (var)->data.multaggr.nvars
989#define SCIPvarGetMultaggrVars(var) (var)->data.multaggr.vars
990#define SCIPvarGetMultaggrScalars(var) (var)->data.multaggr.scalars
991#define SCIPvarGetMultaggrConstant(var) (var)->data.multaggr.constant
992#define SCIPvarGetNegatedVar(var) (var)->negatedvar
993#define SCIPvarGetNegationVar(var) (var)->negatedvar
994#define SCIPvarGetNegationConstant(var) (var)->data.negate.constant
995#define SCIPvarGetObj(var) (var)->obj
996#define SCIPvarGetLbOriginal(var) ((var)->varstatus == SCIP_VARSTATUS_ORIGINAL \
997 ? (var)->data.original.origdom.lb \
998 : (var)->data.negate.constant - (var)->negatedvar->data.original.origdom.ub)
999#define SCIPvarGetUbOriginal(var) ((var)->varstatus == SCIP_VARSTATUS_ORIGINAL \
1000 ? (var)->data.original.origdom.ub \
1001 : (var)->data.negate.constant - (var)->negatedvar->data.original.origdom.lb)
1002#define SCIPvarGetHolelistOriginal(var) ((var)->varstatus == SCIP_VARSTATUS_ORIGINAL \
1003 ? (var)->data.original.origdom.holelist \
1004 : NULL)
1005#define SCIPvarGetLbGlobal(var) (var)->glbdom.lb
1006#define SCIPvarGetUbGlobal(var) (var)->glbdom.ub
1007#define SCIPvarGetHolelistGlobal(var) (var)->glbdom.holelist
1008#define SCIPvarGetBestBoundGlobal(var) ((var)->obj >= 0.0 ? (var)->glbdom.lb : (var)->glbdom.ub)
1009#define SCIPvarGetWorstBoundGlobal(var) ((var)->obj >= 0.0 ? (var)->glbdom.ub : (var)->glbdom.lb)
1010#define SCIPvarGetLbLocal(var) (var)->locdom.lb
1011#define SCIPvarGetUbLocal(var) (var)->locdom.ub
1012#define SCIPvarGetHolelistLocal(var) (var)->locdom.holelist
1013#define SCIPvarGetBestBoundLocal(var) ((var)->obj >= 0.0 ? (var)->locdom.lb : (var)->locdom.ub)
1014#define SCIPvarGetWorstBoundLocal(var) ((var)->obj >= 0.0 ? (var)->locdom.ub : (var)->locdom.lb)
1015#define SCIPvarGetBestBoundType(var) ((var)->obj >= 0.0 ? SCIP_BOUNDTYPE_LOWER : SCIP_BOUNDTYPE_UPPER)
1016#define SCIPvarGetWorstBoundType(var) ((var)->obj >= 0.0 ? SCIP_BOUNDTYPE_UPPER : SCIP_BOUNDTYPE_LOWER)
1017#define SCIPvarGetLbLazy(var) (var)->lazylb
1018#define SCIPvarGetUbLazy(var) (var)->lazyub
1019#define SCIPvarGetBranchFactor(var) (var)->branchfactor
1020#define SCIPvarGetBranchPriority(var) (var)->branchpriority
1021#define SCIPvarGetBranchDirection(var) (var)->branchdirection
1022#define SCIPvarGetNVlbs(var) (SCIPvboundsGetNVbds((var)->vlbs))
1023#define SCIPvarGetVlbVars(var) (SCIPvboundsGetVars((var)->vlbs))
1024#define SCIPvarGetVlbCoefs(var) (SCIPvboundsGetCoefs((var)->vlbs))
1025#define SCIPvarGetVlbConstants(var) (SCIPvboundsGetConstants((var)->vlbs))
1026#define SCIPvarGetNVubs(var) (SCIPvboundsGetNVbds((var)->vubs))
1027#define SCIPvarGetVubVars(var) (SCIPvboundsGetVars((var)->vubs))
1028#define SCIPvarGetVubCoefs(var) (SCIPvboundsGetCoefs((var)->vubs))
1029#define SCIPvarGetVubConstants(var) (SCIPvboundsGetConstants((var)->vubs))
1030#define SCIPvarGetNImpls(var, fix) (SCIPimplicsGetNImpls((var)->implics, fix))
1031#define SCIPvarGetImplVars(var, fix) (SCIPimplicsGetVars((var)->implics, fix))
1032#define SCIPvarGetImplTypes(var, fix) (SCIPimplicsGetTypes((var)->implics, fix))
1033#define SCIPvarGetImplBounds(var, fix) (SCIPimplicsGetBounds((var)->implics, fix))
1034#define SCIPvarGetImplIds(var, fix) (SCIPimplicsGetIds((var)->implics, fix))
1035#define SCIPvarGetNCliques(var, fix) (SCIPcliquelistGetNCliques((var)->cliquelist, fix))
1036#define SCIPvarGetCliques(var, fix) (SCIPcliquelistGetCliques((var)->cliquelist, fix))
1037#define SCIPvarGetLPSol(var) ((var)->varstatus == SCIP_VARSTATUS_COLUMN ? SCIPcolGetPrimsol((var)->data.col) : SCIPvarGetLPSol_rec(var))
1038#define SCIPvarGetNLPSol(var) (((var)->varstatus == SCIP_VARSTATUS_COLUMN || ((var)->varstatus == SCIP_VARSTATUS_LOOSE)) ? (var)->nlpsol : SCIPvarGetNLPSol_rec(var))
1039#define SCIPvarGetBdchgInfoLb(var, pos) (&((var)->lbchginfos[pos]))
1040#define SCIPvarGetNBdchgInfosLb(var) ((var)->nlbchginfos)
1041#define SCIPvarGetBdchgInfoUb(var, pos) (&((var)->ubchginfos[pos]))
1042#define SCIPvarGetNBdchgInfosUb(var) ((var)->nubchginfos)
1043#define SCIPvarGetValuehistory(var) (var)->valuehistory
1044#define SCIPvarGetCliqueComponentIdx(var) ((var)->clqcomponentidx)
1045#define SCIPvarIsRelaxationOnly(var)((var)->relaxationonly)
1046#define SCIPvarMarkRelaxationOnly(var)((var)->relaxationonly = TRUE)
1047
1048#endif
1049
1050/** gets primal LP solution value of variable */
1051SCIP_EXPORT
1053 SCIP_VAR* var /**< problem variable */
1054 );
1055
1056/** gets primal NLP solution value of variable */
1057SCIP_EXPORT
1059 SCIP_VAR* var /**< problem variable */
1060 );
1061
1062/** gets pseudo solution value of variable at current node */
1063SCIP_EXPORT
1065 SCIP_VAR* var /**< problem variable */
1066 );
1067
1068/** gets current LP or pseudo solution value of variable */
1069SCIP_EXPORT
1071 SCIP_VAR* var, /**< problem variable */
1072 SCIP_Bool getlpval /**< should the LP solution value be returned? */
1073 );
1074
1075/** returns the solution of the variable in the last root node's relaxation, if the root relaxation is not yet
1076 * completely solved, zero is returned
1077 */
1078SCIP_EXPORT
1080 SCIP_VAR* var /**< problem variable */
1081 );
1082
1083/** returns the best solution (w.r.t. root reduced cost propagation) of the variable in the root node's relaxation, if
1084 * the root relaxation is not yet completely solved, zero is returned
1085 */
1086SCIP_EXPORT
1088 SCIP_VAR* var /**< problem variable */
1089 );
1090
1091/** returns the best reduced costs (w.r.t. root reduced cost propagation) of the variable in the root node's relaxation,
1092 * if the root relaxation is not yet completely solved, or the variable was no column of the root LP, SCIP_INVALID is
1093 * returned
1094 */
1095SCIP_EXPORT
1097 SCIP_VAR* var /**< problem variable */
1098 );
1099
1100/** returns the best objective value (w.r.t. root reduced cost propagation) of the root LP which belongs the root
1101 * reduced cost which is accessible via SCIPvarGetRootRedcost() or the variable was no column of the root LP,
1102 * SCIP_INVALID is returned
1103 */
1104SCIP_EXPORT
1106 SCIP_VAR* var /**< problem variable */
1107 );
1108
1109/** set the given solution as the best root solution w.r.t. root reduced cost propagation in the variables */
1110SCIP_EXPORT
1112 SCIP_VAR* var, /**< problem variable */
1113 SCIP_Real rootsol, /**< root solution value */
1114 SCIP_Real rootredcost, /**< root reduced cost */
1115 SCIP_Real rootlpobjval /**< objective value of the root LP */
1116 );
1117
1118/** returns a weighted average solution value of the variable in all feasible primal solutions found so far */
1119SCIP_EXPORT
1121 SCIP_VAR* var /**< problem variable */
1122 );
1123
1124/** returns the bound change information for the last lower bound change on given active problem variable before or
1125 * after the bound change with the given index was applied;
1126 * returns NULL, if no change to the lower bound was applied up to this point of time
1127 */
1128SCIP_EXPORT
1130 SCIP_VAR* var, /**< active problem variable */
1131 SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
1132 SCIP_Bool after /**< should the bound change with given index be included? */
1133 );
1134
1135/** returns the bound change information for the last upper bound change on given active problem variable before or
1136 * after the bound change with the given index was applied;
1137 * returns NULL, if no change to the upper bound was applied up to this point of time
1138 */
1139SCIP_EXPORT
1141 SCIP_VAR* var, /**< active problem variable */
1142 SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
1143 SCIP_Bool after /**< should the bound change with given index be included? */
1144 );
1145
1146/** returns the bound change information for the last lower or upper bound change on given active problem variable
1147 * before or after the bound change with the given index was applied;
1148 * returns NULL, if no change to the lower/upper bound was applied up to this point of time
1149 */
1150SCIP_EXPORT
1152 SCIP_VAR* var, /**< active problem variable */
1153 SCIP_BOUNDTYPE boundtype, /**< type of bound: lower or upper bound */
1154 SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
1155 SCIP_Bool after /**< should the bound change with given index be included? */
1156 );
1157
1158/** returns lower bound of variable directly before or after the bound change given by the bound change index
1159 * was applied
1160 *
1161 * @deprecated Please use SCIPgetVarLbAtIndex()
1162 */
1163SCIP_EXPORT
1165 SCIP_VAR* var, /**< problem variable */
1166 SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
1167 SCIP_Bool after /**< should the bound change with given index be included? */
1168 );
1169
1170/** returns upper bound of variable directly before or after the bound change given by the bound change index
1171 * was applied
1172 *
1173 * @deprecated Please use SCIPgetVarUbAtIndex()
1174 */
1175SCIP_EXPORT
1177 SCIP_VAR* var, /**< problem variable */
1178 SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
1179 SCIP_Bool after /**< should the bound change with given index be included? */
1180 );
1181
1182/** returns lower or upper bound of variable directly before or after the bound change given by the bound change index
1183 * was applied
1184 *
1185 * @deprecated Please use SCIPgetVarBdAtIndex()
1186 */
1187SCIP_EXPORT
1189 SCIP_VAR* var, /**< problem variable */
1190 SCIP_BOUNDTYPE boundtype, /**< type of bound: lower or upper bound */
1191 SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
1192 SCIP_Bool after /**< should the bound change with given index be included? */
1193 );
1194
1195/** returns whether the binary variable was fixed at the time given by the bound change index
1196 *
1197 * @deprecated Please use SCIPgetVarWasFixedAtIndex()
1198 */
1199SCIP_EXPORT
1201 SCIP_VAR* var, /**< problem variable */
1202 SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
1203 SCIP_Bool after /**< should the bound change with given index be included? */
1204 );
1205
1206/** returns the last bound change index, at which the bounds of the given variable were tightened */
1207SCIP_EXPORT
1209 SCIP_VAR* var /**< problem variable */
1210 );
1211
1212/** returns the last depth level, at which the bounds of the given variable were tightened;
1213 * returns -2, if the variable's bounds are still the global bounds
1214 * returns -1, if the variable was fixed in presolving
1215 */
1216SCIP_EXPORT
1218 SCIP_VAR* var /**< problem variable */
1219 );
1220
1221/** returns whether the first binary variable was fixed earlier than the second one;
1222 * returns FALSE, if the first variable is not fixed, and returns TRUE, if the first variable is fixed, but the
1223 * second one is not fixed
1224 */
1225SCIP_EXPORT
1227 SCIP_VAR* var1, /**< first binary variable */
1228 SCIP_VAR* var2 /**< second binary variable */
1229 );
1230
1231/**
1232 * @name Public SCIP_BDCHGIDX Methods
1233 *
1234 * @{
1235 */
1236
1237/** returns whether first bound change index belongs to an earlier applied bound change than second one;
1238 * if a bound change index is NULL, the bound change index represents the current time, i.e. the time after the
1239 * last bound change was applied to the current node
1240 */
1241SCIP_EXPORT
1243 SCIP_BDCHGIDX* bdchgidx1, /**< first bound change index, or NULL */
1244 SCIP_BDCHGIDX* bdchgidx2 /**< second bound change index, or NULL */
1245 );
1246
1247/** returns whether first bound change index belongs to an earlier applied bound change than second one */
1248SCIP_EXPORT
1250 SCIP_BDCHGIDX* bdchgidx1, /**< first bound change index */
1251 SCIP_BDCHGIDX* bdchgidx2 /**< second bound change index */
1252 );
1253
1254/**@} */
1255
1256/**
1257 * @name Public SCIP_BDCHGINFO Methods
1258 *
1259 * @{
1260 */
1261
1262/** returns old bound that was overwritten for given bound change information */
1263SCIP_EXPORT
1265 SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1266 );
1267
1268/** returns new bound installed for given bound change information */
1269SCIP_EXPORT
1271 SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1272 );
1273
1274/** returns variable that belongs to the given bound change information */
1275SCIP_EXPORT
1277 SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1278 );
1279
1280/** returns whether the bound change information belongs to a branching decision or a deduction */
1281SCIP_EXPORT
1283 SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1284 );
1285
1286/** returns whether the bound change information belongs to a lower or upper bound change */
1287SCIP_EXPORT
1289 SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1290 );
1291
1292/** returns depth level of given bound change information */
1293SCIP_EXPORT
1295 SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1296 );
1297
1298/** returns bound change position in its depth level of given bound change information */
1299SCIP_EXPORT
1301 SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1302 );
1303
1304/** returns bound change index of given bound change information */
1305SCIP_EXPORT
1307 SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1308 );
1309
1310/** returns inference variable of given bound change information */
1311SCIP_EXPORT
1313 SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1314 );
1315
1316/** returns inference constraint of given bound change information */
1317SCIP_EXPORT
1319 SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1320 );
1321
1322/** returns inference propagator of given bound change information, or NULL if no propagator was responsible */
1323SCIP_EXPORT
1325 SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1326 );
1327
1328/** returns inference user information of given bound change information */
1329SCIP_EXPORT
1331 SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1332 );
1333
1334/** returns inference bound of inference variable of given bound change information */
1335SCIP_EXPORT
1337 SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1338 );
1339
1340/** returns whether the bound change information belongs to a redundant bound change */
1341SCIP_EXPORT
1343 SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1344 );
1345
1346/** returns whether the bound change has an inference reason (constraint or propagator), that can be resolved */
1347SCIP_EXPORT
1349 SCIP_BDCHGINFO* bdchginfo /**< bound change information */
1350 );
1351
1352/** for two bound change informations belonging to the same variable and bound, returns whether the first bound change
1353 * has a tighter new bound as the second bound change
1354 */
1355SCIP_EXPORT
1357 SCIP_BDCHGINFO* bdchginfo1, /**< first bound change information */
1358 SCIP_BDCHGINFO* bdchginfo2 /**< second bound change information */
1359 );
1360
1361/**@} */
1362
1363/**
1364 * @name Public SCIP_BOUNDCHG Methods
1365 *
1366 * @{
1367 */
1368
1369/** returns the new value of the bound in the bound change data */
1370SCIP_EXPORT
1372 SCIP_BOUNDCHG* boundchg /**< bound change data */
1373 );
1374
1375/** returns the variable of the bound change in the bound change data */
1376SCIP_EXPORT
1378 SCIP_BOUNDCHG* boundchg /**< bound change data */
1379 );
1380
1381/** returns the bound change type of the bound change in the bound change data */
1382SCIP_EXPORT
1384 SCIP_BOUNDCHG* boundchg /**< bound change data */
1385 );
1386
1387/** returns the bound type of the bound change in the bound change data */
1388SCIP_EXPORT
1390 SCIP_BOUNDCHG* boundchg /**< bound change data */
1391 );
1392
1393/** returns whether the bound change is redundant due to a more global bound that is at least as strong */
1394SCIP_EXPORT
1396 SCIP_BOUNDCHG* boundchg /**< bound change data */
1397 );
1398
1399/** @} */
1400
1401/**
1402 * @name Public SCIP_DOMCHG Methods
1403 *
1404 * @{
1405 */
1406
1407/** returns the number of bound changes in the domain change data */
1408SCIP_EXPORT
1410 SCIP_DOMCHG* domchg /**< domain change data */
1411 );
1412
1413/** returns a particular bound change in the domain change data */
1414SCIP_EXPORT
1416 SCIP_DOMCHG* domchg, /**< domain change data */
1417 int pos /**< position of the bound change in the domain change data */
1418 );
1419
1420/**@} */
1421
1422/**
1423 * @name Public SCIP_HOLELIST Methods
1424 *
1425 * @{
1426 */
1427
1428/** returns left bound of open interval in hole */
1429SCIP_EXPORT
1431 SCIP_HOLELIST* holelist /**< hole list pointer to hole of interest */
1432 );
1433
1434/** returns right bound of open interval in hole */
1435SCIP_EXPORT
1437 SCIP_HOLELIST* holelist /**< hole list pointer to hole of interest */
1438 );
1439
1440/** returns next hole in list or NULL */
1441SCIP_EXPORT
1443 SCIP_HOLELIST* holelist /**< hole list pointer to hole of interest */
1444 );
1445
1446/**@} */
1447
1448#ifdef NDEBUG
1449
1450/* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
1451 * speed up the algorithms.
1452 */
1453
1454#define SCIPbdchgidxIsEarlierNonNull(idx1,idx2) \
1455 ((idx1)->depth < (idx2)->depth || ((idx1)->depth == (idx2)->depth && (idx1)->pos < (idx2)->pos))
1456#define SCIPbdchgidxIsEarlier(idx1,idx2) \
1457 ((idx1) != NULL && ((idx2) == NULL || SCIPbdchgidxIsEarlierNonNull(idx1, idx2)))
1458#define SCIPbdchginfoGetOldbound(bdchginfo) (bdchginfo)->oldbound
1459#define SCIPbdchginfoGetNewbound(bdchginfo) (bdchginfo)->newbound
1460#define SCIPbdchginfoGetVar(bdchginfo) (bdchginfo)->var
1461#define SCIPbdchginfoGetChgtype(bdchginfo) (SCIP_BOUNDCHGTYPE)((bdchginfo)->boundchgtype)
1462#define SCIPbdchginfoGetBoundtype(bdchginfo) (SCIP_BOUNDTYPE)((bdchginfo)->boundtype)
1463#define SCIPbdchginfoGetDepth(bdchginfo) (bdchginfo)->bdchgidx.depth
1464#define SCIPbdchginfoGetPos(bdchginfo) (bdchginfo)->bdchgidx.pos
1465#define SCIPbdchginfoGetIdx(bdchginfo) (&(bdchginfo)->bdchgidx)
1466#define SCIPbdchginfoGetInferVar(bdchginfo) (bdchginfo)->inferencedata.var
1467#define SCIPbdchginfoGetInferCons(bdchginfo) (bdchginfo)->inferencedata.reason.cons
1468#define SCIPbdchginfoGetInferProp(bdchginfo) (bdchginfo)->inferencedata.reason.prop
1469#define SCIPbdchginfoGetInferInfo(bdchginfo) (bdchginfo)->inferencedata.info
1470#define SCIPbdchginfoGetInferBoundtype(bdchginfo) (SCIP_BOUNDTYPE)((bdchginfo)->inferboundtype)
1471#define SCIPbdchginfoIsRedundant(bdchginfo) (bdchginfo)->redundant
1472#define SCIPbdchginfoHasInferenceReason(bdchginfo) \
1473 (((bdchginfo)->boundchgtype == SCIP_BOUNDCHGTYPE_CONSINFER) \
1474 || ((bdchginfo)->boundchgtype == SCIP_BOUNDCHGTYPE_PROPINFER && (bdchginfo)->inferencedata.reason.prop != NULL))
1475#define SCIPbdchginfoIsTighter(bdchginfo1,bdchginfo2) ((bdchginfo1)->boundtype == SCIP_BOUNDTYPE_LOWER \
1476 ? (bdchginfo1)->newbound > bdchginfo2->newbound : (bdchginfo1)->newbound < bdchginfo2->newbound)
1477#define SCIPboundchgGetNewbound(boundchg) ((boundchg)->newbound)
1478#define SCIPboundchgGetVar(boundchg) ((boundchg)->var)
1479#define SCIPboundchgGetBoundchgtype(boundchg) ((SCIP_BOUNDCHGTYPE)((boundchg)->boundchgtype))
1480#define SCIPboundchgGetBoundtype(boundchg) ((SCIP_BOUNDTYPE)((boundchg)->boundtype))
1481#define SCIPboundchgIsRedundant(boundchg) ((boundchg)->redundant)
1482#define SCIPdomchgGetNBoundchgs(domchg) ((domchg) != NULL ? (domchg)->domchgbound.nboundchgs : 0)
1483#define SCIPdomchgGetBoundchg(domchg, pos) (&(domchg)->domchgbound.boundchgs[pos])
1484#define SCIPholelistGetLeft(holelist) ((holelist)->hole.left)
1485#define SCIPholelistGetRight(holelist) ((holelist)->hole.right)
1486#define SCIPholelistGetNext(holelist) ((holelist)->next)
1487
1488#endif
1489
1490/**@} */
1491
1492#ifdef __cplusplus
1493}
1494#endif
1495
1496#endif
static long bound
common defines and data types used in all packages of SCIP
#define SCIP_Longint
Definition: def.h:158
#define SCIP_Bool
Definition: def.h:91
#define SCIP_Real
Definition: def.h:173
SCIP_Bool SCIPvarIsInitial(SCIP_VAR *var)
Definition: var.c:17620
SCIP_Real SCIPvarGetLPSol_rec(SCIP_VAR *var)
Definition: var.c:13069
int SCIPvarCompareActiveAndNegated(SCIP_VAR *var1, SCIP_VAR *var2)
Definition: var.c:11904
void SCIPvarSetDelorigData(SCIP_VAR *var, SCIP_DECL_VARDELORIG((*vardelorig)))
Definition: var.c:17460
SCIP_RETCODE SCIPvarGetOrigvarSum(SCIP_VAR **var, SCIP_Real *scalar, SCIP_Real *constant)
Definition: var.c:12774
SCIP_HOLELIST * SCIPvarGetHolelistLocal(SCIP_VAR *var)
Definition: var.c:18154
int SCIPvarGetNVlbs(SCIP_VAR *var)
Definition: var.c:18270
SCIP_RETCODE SCIPvarGetProbvarBound(SCIP_VAR **var, SCIP_Real *bound, SCIP_BOUNDTYPE *boundtype)
Definition: var.c:12469
SCIP_Bool SCIPvarIsDeleted(SCIP_VAR *var)
Definition: var.c:17640
SCIP_Real SCIPvarGetNegationConstant(SCIP_VAR *var)
Definition: var.c:17915
SCIP_COL * SCIPvarGetCol(SCIP_VAR *var)
Definition: var.c:17789
SCIP_Bool SCIPbdchginfoIsRedundant(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:18808
SCIP_Bool SCIPvarWasFixedAtIndex(SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: var.c:16970
SCIP_Real SCIPvarGetAvgBranchdepthCurrentRun(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: var.c:15832
SCIP_Bool SCIPvarMayRoundUp(SCIP_VAR *var)
Definition: var.c:3451
SCIP_Real SCIPvarGetMultaggrConstant(SCIP_VAR *var)
Definition: var.c:17882
SCIP_BOUNDTYPE SCIPvarGetBestBoundType(SCIP_VAR *var)
Definition: var.c:18190
void SCIPvarsGetProbvar(SCIP_VAR **vars, int nvars)
Definition: var.c:12198
SCIP_Real SCIPvarGetSol(SCIP_VAR *var, SCIP_Bool getlpval)
Definition: var.c:13257
SCIP_VAR * SCIPvarGetNegatedVar(SCIP_VAR *var)
Definition: var.c:17894
SCIP_Real * SCIPvarGetVlbCoefs(SCIP_VAR *var)
Definition: var.c:18292
SCIP_Bool SCIPvarIsActive(SCIP_VAR *var)
Definition: var.c:17748
SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)
Definition: var.c:17599
SCIP_BOUNDTYPE SCIPboundchgGetBoundtype(SCIP_BOUNDCHG *boundchg)
Definition: var.c:17346
SCIP_Real SCIPholelistGetRight(SCIP_HOLELIST *holelist)
Definition: var.c:17396
void SCIPvarSetTransData(SCIP_VAR *var, SCIP_DECL_VARTRANS((*vartrans)))
Definition: var.c:17472
SCIP_Real SCIPvarGetAvgBranchdepth(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: var.c:15787
SCIP_Real SCIPvarGetBestBoundGlobal(SCIP_VAR *var)
Definition: var.c:18108
SCIP_Bool SCIPbdchgidxIsEarlier(SCIP_BDCHGIDX *bdchgidx1, SCIP_BDCHGIDX *bdchgidx2)
Definition: var.c:18640
SCIP_Bool SCIPvarWasFixedEarlier(SCIP_VAR *var1, SCIP_VAR *var2)
Definition: var.c:17118
SCIP_BDCHGIDX * SCIPbdchginfoGetIdx(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:18730
SCIP_VAR * SCIPboundchgGetVar(SCIP_BOUNDCHG *boundchg)
Definition: var.c:17326
SCIP_Bool SCIPvarHasImplic(SCIP_VAR *var, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_BOUNDTYPE impltype)
Definition: var.c:11111
SCIP_BOUNDCHG * SCIPdomchgGetBoundchg(SCIP_DOMCHG *domchg, int pos)
Definition: var.c:17374
int SCIPvarGetNImpls(SCIP_VAR *var, SCIP_Bool varfixing)
Definition: var.c:18356
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
Definition: var.c:17538
int SCIPvarGetNLocksUpType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)
Definition: var.c:3353
SCIP_BOUNDCHGTYPE SCIPboundchgGetBoundchgtype(SCIP_BOUNDCHG *boundchg)
Definition: var.c:17336
SCIP_Real SCIPvarGetInferenceSum(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: var.c:15979
SCIP_Real SCIPvarGetAggrConstant(SCIP_VAR *var)
Definition: var.c:17834
SCIP_RETCODE SCIPvarGetAggregatedObj(SCIP_VAR *var, SCIP_Real *aggrobj)
Definition: var.c:17948
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
Definition: var.c:18144
int SCIPvarGetNLocksDown(SCIP_VAR *var)
Definition: var.c:3416
SCIP_Real SCIPvarGetBestRootSol(SCIP_VAR *var)
Definition: var.c:13715
void SCIPvarSetDeltransData(SCIP_VAR *var, SCIP_DECL_VARDELTRANS((*vardeltrans)))
Definition: var.c:17484
SCIP_HOLELIST * SCIPholelistGetNext(SCIP_HOLELIST *holelist)
Definition: var.c:17406
SCIP_Real SCIPvarGetLbOriginal(SCIP_VAR *var)
Definition: var.c:18024
SCIP_BDCHGINFO * SCIPvarGetLbchgInfo(SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: var.c:16577
SCIP_DECL_HASHGETKEY(SCIPvarGetHashkey)
Definition: var.c:11985
SCIP_Bool SCIPvarIsTransformed(SCIP_VAR *var)
Definition: var.c:17561
void SCIPvarMarkDeletable(SCIP_VAR *var)
Definition: var.c:17652
void SCIPvarGetImplicVarBounds(SCIP_VAR *var, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_Real *lb, SCIP_Real *ub)
Definition: var.c:11146
SCIP_PROP * SCIPbdchginfoGetInferProp(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:18764
SCIP_Real SCIPboundchgGetNewbound(SCIP_BOUNDCHG *boundchg)
Definition: var.c:17316
SCIP_Bool SCIPvarMayRoundDown(SCIP_VAR *var)
Definition: var.c:3440
SCIP_Real SCIPvarGetObj(SCIP_VAR *var)
Definition: var.c:17926
SCIP_Real SCIPvarGetAggrScalar(SCIP_VAR *var)
Definition: var.c:17822
SCIP_DECL_SORTPTRCOMP(SCIPvarCompActiveAndNegated)
Definition: var.c:11934
SCIP_VAR * SCIPvarGetProbvar(SCIP_VAR *var)
Definition: var.c:12218
void SCIPvarMarkRelaxationOnly(SCIP_VAR *var)
Definition: var.c:17724
SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)
Definition: var.c:17584
SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)
Definition: var.c:18088
SCIP_RETCODE SCIPvarSetInitial(SCIP_VAR *var, SCIP_Bool initial)
Definition: var.c:17506
SCIP_VAR ** SCIPvarGetImplVars(SCIP_VAR *var, SCIP_Bool varfixing)
Definition: var.c:18373
void SCIPvarSetBestRootSol(SCIP_VAR *var, SCIP_Real rootsol, SCIP_Real rootredcost, SCIP_Real rootlpobjval)
Definition: var.c:13847
int SCIPbdchginfoGetDepth(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:18710
int SCIPbdchginfoGetInferInfo(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:18775
int SCIPvarGetIndex(SCIP_VAR *var)
Definition: var.c:17758
SCIP_CONS * SCIPbdchginfoGetInferCons(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:18752
SCIP_Real SCIPvarGetNLPSol_rec(SCIP_VAR *var)
Definition: var.c:13142
SCIP_BDCHGIDX * SCIPvarGetLastBdchgIndex(SCIP_VAR *var)
Definition: var.c:16993
int SCIPbdchginfoGetPos(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:18720
SCIP_Real SCIPvarGetWorstBoundLocal(SCIP_VAR *var)
Definition: var.c:18177
int SCIPvarGetNUses(SCIP_VAR *var)
Definition: var.c:17429
int SCIPdomchgGetNBoundchgs(SCIP_DOMCHG *domchg)
Definition: var.c:17366
int SCIPvarGetProbindex(SCIP_VAR *var)
Definition: var.c:17768
const char * SCIPvarGetName(SCIP_VAR *var)
Definition: var.c:17419
SCIP_Real SCIPvarGetUbOriginal(SCIP_VAR *var)
Definition: var.c:18044
SCIP_Real SCIPvarGetWorstBoundGlobal(SCIP_VAR *var)
Definition: var.c:18121
SCIP_VAR * SCIPbdchginfoGetVar(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:18680
SCIP_Bool SCIPvarHasBinaryImplic(SCIP_VAR *var, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_Bool implvarfixing)
Definition: var.c:11131
void SCIPvarMarkDeleteGlobalStructures(SCIP_VAR *var)
Definition: var.c:17676
SCIP_Real * SCIPvarGetVlbConstants(SCIP_VAR *var)
Definition: var.c:18302
SCIP_Real SCIPvarGetRootSol(SCIP_VAR *var)
Definition: var.c:13350
int * SCIPvarGetImplIds(SCIP_VAR *var, SCIP_Bool varfixing)
Definition: var.c:18418
SCIP_Real SCIPvarGetBestBoundLocal(SCIP_VAR *var)
Definition: var.c:18164
int SCIPvarGetNVubs(SCIP_VAR *var)
Definition: var.c:18312
SCIP_Real SCIPvarGetBranchFactor(SCIP_VAR *var)
Definition: var.c:18238
SCIP_Real SCIPvarGetAvgSol(SCIP_VAR *var)
Definition: var.c:14062
SCIP_Bool SCIPvarIsDeletable(SCIP_VAR *var)
Definition: var.c:17738
SCIP_Real SCIPbdchginfoGetOldbound(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:18660
SCIP_Bool SCIPvarIsIntegral(SCIP_VAR *var)
Definition: var.c:17610
SCIP_Bool SCIPvarIsTransformedOrigvar(SCIP_VAR *var)
Definition: var.c:12861
SCIP_Real SCIPvarGetUbLazy(SCIP_VAR *var)
Definition: var.c:18226
SCIP_Real SCIPvarGetPseudoSol(SCIP_VAR *var)
Definition: var.c:18530
SCIP_BRANCHDIR SCIPvarGetBranchDirection(SCIP_VAR *var)
Definition: var.c:18260
SCIP_BOUNDTYPE SCIPbdchginfoGetInferBoundtype(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:18787
void SCIPvarSetData(SCIP_VAR *var, SCIP_VARDATA *vardata)
Definition: var.c:17449
SCIP_Real * SCIPvarGetImplBounds(SCIP_VAR *var, SCIP_Bool varfixing)
Definition: var.c:18402
SCIP_Real SCIPvarGetLPSol(SCIP_VAR *var)
Definition: var.c:18452
SCIP_BDCHGINFO * SCIPvarGetBdchgInfo(SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: var.c:16689
SCIP_VARDATA * SCIPvarGetData(SCIP_VAR *var)
Definition: var.c:17439
SCIP_VAR ** SCIPvarGetMultaggrVars(SCIP_VAR *var)
Definition: var.c:17858
SCIP_Bool SCIPbdchginfoIsTighter(SCIP_BDCHGINFO *bdchginfo1, SCIP_BDCHGINFO *bdchginfo2)
Definition: var.c:18833
int SCIPvarGetMultaggrNVars(SCIP_VAR *var)
Definition: var.c:17846
SCIP_RETCODE SCIPvarSetRemovable(SCIP_VAR *var, SCIP_Bool removable)
Definition: var.c:17522
SCIP_HOLELIST * SCIPvarGetHolelistOriginal(SCIP_VAR *var)
Definition: var.c:18064
SCIP_Bool SCIPvarIsRemovable(SCIP_VAR *var)
Definition: var.c:17630
int SCIPvarGetNCliques(SCIP_VAR *var, SCIP_Bool varfixing)
Definition: var.c:18430
SCIP_BOUNDCHGTYPE SCIPbdchginfoGetChgtype(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:18690
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
Definition: var.c:18134
SCIP_Bool SCIPvarIsNegated(SCIP_VAR *var)
Definition: var.c:17574
SCIP_DECL_HASHKEYEQ(SCIPvarIsHashkeyEq)
Definition: var.c:11991
SCIP_VAR * SCIPbdchginfoGetInferVar(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:18740
SCIP_Bool SCIPbdchginfoHasInferenceReason(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:18819
SCIP_Bool SCIPboundchgIsRedundant(SCIP_BOUNDCHG *boundchg)
Definition: var.c:17356
SCIP_Longint SCIPvarGetNBranchings(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: var.c:15699
SCIP_Bool SCIPvarIsRelaxationOnly(SCIP_VAR *var)
Definition: var.c:17706
SCIP_VAR * SCIPvarGetNegationVar(SCIP_VAR *var)
Definition: var.c:17904
SCIP_RETCODE SCIPvarGetProbvarHole(SCIP_VAR **var, SCIP_Real *left, SCIP_Real *right)
Definition: var.c:12562
SCIP_VAR ** SCIPvarGetVlbVars(SCIP_VAR *var)
Definition: var.c:18282
SCIP_BDCHGINFO * SCIPvarGetUbchgInfo(SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: var.c:16633
SCIP_Real SCIPholelistGetLeft(SCIP_HOLELIST *holelist)
Definition: var.c:17386
int SCIPvarGetBranchPriority(SCIP_VAR *var)
Definition: var.c:18250
SCIP_Bool SCIPvarIsOriginal(SCIP_VAR *var)
Definition: var.c:17548
SCIP_CLIQUE ** SCIPvarGetCliques(SCIP_VAR *var, SCIP_Bool varfixing)
Definition: var.c:18441
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
Definition: var.c:18078
void SCIPvarMarkNotDeletable(SCIP_VAR *var)
Definition: var.c:17663
SCIP_Real SCIPvarGetBestRootRedcost(SCIP_VAR *var)
Definition: var.c:13782
SCIP_BDCHGINFO * SCIPvarGetBdchgInfoLb(SCIP_VAR *var, int pos)
Definition: var.c:18478
SCIP_DECL_HASHKEYVAL(SCIPvarGetHashkeyVal)
Definition: var.c:11999
int SCIPvarCompare(SCIP_VAR *var1, SCIP_VAR *var2)
Definition: var.c:11942
SCIP_Real SCIPvarGetCutoffSumCurrentRun(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: var.c:16222
SCIP_Real SCIPvarGetBestRootLPObjval(SCIP_VAR *var)
Definition: var.c:13816
SCIP_Real SCIPvarGetLbAtIndex(SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: var.c:16710
SCIP_RETCODE SCIPvarGetProbvarBinary(SCIP_VAR **var, SCIP_Bool *negated)
Definition: var.c:12310
SCIP_Longint SCIPvarGetNBranchingsCurrentRun(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: var.c:15744
SCIP_Real * SCIPvarGetVubConstants(SCIP_VAR *var)
Definition: var.c:18344
int SCIPvarGetNLocksUp(SCIP_VAR *var)
Definition: var.c:3429
SCIP_VAR * SCIPvarGetTransVar(SCIP_VAR *var)
Definition: var.c:17778
SCIP_Real SCIPvarGetNLPSol(SCIP_VAR *var)
Definition: var.c:18465
SCIP_VAR ** SCIPvarGetVubVars(SCIP_VAR *var)
Definition: var.c:18324
int SCIPvarGetNBdchgInfosUb(SCIP_VAR *var)
Definition: var.c:18510
SCIP_BOUNDTYPE SCIPbdchginfoGetBoundtype(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:18700
SCIP_VALUEHISTORY * SCIPvarGetValuehistory(SCIP_VAR *var)
Definition: var.c:18520
SCIP_BOUNDTYPE SCIPvarGetWorstBoundType(SCIP_VAR *var)
Definition: var.c:18203
SCIP_Real SCIPvarGetInferenceSumCurrentRun(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: var.c:16024
SCIP_Bool SCIPvarsHaveCommonClique(SCIP_VAR *var1, SCIP_Bool value1, SCIP_VAR *var2, SCIP_Bool value2, SCIP_Bool regardimplics)
Definition: var.c:11475
SCIP_Bool SCIPbdchgidxIsEarlierNonNull(SCIP_BDCHGIDX *bdchgidx1, SCIP_BDCHGIDX *bdchgidx2)
Definition: var.c:18620
SCIP_Real * SCIPvarGetVubCoefs(SCIP_VAR *var)
Definition: var.c:18334
SCIP_HOLELIST * SCIPvarGetHolelistGlobal(SCIP_VAR *var)
Definition: var.c:18098
SCIP_Real SCIPvarGetBdAtIndex(SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: var.c:16950
SCIP_Real SCIPbdchginfoGetNewbound(SCIP_BDCHGINFO *bdchginfo)
Definition: var.c:18670
int SCIPvarGetNLocksDownType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)
Definition: var.c:3295
SCIP_Real SCIPvarGetUbAtIndex(SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: var.c:16829
SCIP_BDCHGINFO * SCIPvarGetBdchgInfoUb(SCIP_VAR *var, int pos)
Definition: var.c:18498
int SCIPvarGetNBdchgInfosLb(SCIP_VAR *var)
Definition: var.c:18490
SCIP_BOUNDTYPE * SCIPvarGetImplTypes(SCIP_VAR *var, SCIP_Bool varfixing)
Definition: var.c:18388
int SCIPvarGetLastBdchgDepth(SCIP_VAR *var)
Definition: var.c:17030
void SCIPvarSetCopyData(SCIP_VAR *var, SCIP_DECL_VARCOPY((*varcopy)))
Definition: var.c:17495
SCIP_RETCODE SCIPvarsGetProbvarBinary(SCIP_VAR ***vars, SCIP_Bool **negatedarr, int nvars)
Definition: var.c:12278
SCIP_Real SCIPvarGetUnchangedObj(SCIP_VAR *var)
Definition: var.c:17936
SCIP_Real * SCIPvarGetMultaggrScalars(SCIP_VAR *var)
Definition: var.c:17870
SCIP_Real SCIPvarGetCutoffSum(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: var.c:16179
SCIP_Real SCIPvarGetLbLazy(SCIP_VAR *var)
Definition: var.c:18216
SCIP_Bool SCIPvarIsInLP(SCIP_VAR *var)
Definition: var.c:17800
SCIP_VAR * SCIPvarGetAggrVar(SCIP_VAR *var)
Definition: var.c:17810
internal methods for branching and inference history
methods for implications, variable bounds, and cliques
public methods for LP management
datastructures for problem variables
type definitions for constraints and constraint handlers
type definitions for branching and inference history
enum SCIP_BranchDir SCIP_BRANCHDIR
Definition: type_history.h:48
type definitions for implications, variable bounds, and cliques
type definitions for LP management
enum SCIP_BoundType SCIP_BOUNDTYPE
Definition: type_lp.h:59
type definitions for miscellaneous datastructures
type definitions for propagators
result codes for SCIP callback methods
type definitions for return codes for SCIP methods
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:63
type definitions for SCIP's main datastructure
type definitions for problem variables
struct SCIP_VarData SCIP_VARDATA
Definition: type_var.h:120
enum SCIP_BoundchgType SCIP_BOUNDCHGTYPE
Definition: type_var.h:91
#define SCIP_DECL_VARDELORIG(x)
Definition: type_var.h:131
#define SCIP_DECL_VARTRANS(x)
Definition: type_var.h:151
#define SCIP_DECL_VARCOPY(x)
Definition: type_var.h:194
#define SCIP_DECL_VARDELTRANS(x)
Definition: type_var.h:164
enum SCIP_LockType SCIP_LOCKTYPE
Definition: type_var.h:100
enum SCIP_Vartype SCIP_VARTYPE
Definition: type_var.h:73
enum SCIP_Varstatus SCIP_VARSTATUS
Definition: type_var.h:57