Scippy

SCIP

Solving Constraint Integer Programs

implics.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 email to scip@zib.de. */
13 /* */
14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15 
16 /**@file implics.h
17  * @ingroup INTERNALAPI
18  * @brief methods for implications, variable bounds, and cliques
19  * @author Tobias Achterberg
20  */
21 
22 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
23 
24 #ifndef __SCIP_IMPLICS_H__
25 #define __SCIP_IMPLICS_H__
26 
27 
28 #include "scip/def.h"
29 #include "blockmemshell/memory.h"
30 #include "scip/type_retcode.h"
31 #include "scip/type_set.h"
32 #include "scip/type_stat.h"
33 #include "scip/type_event.h"
34 #include "scip/type_lp.h"
35 #include "scip/type_var.h"
36 #include "scip/type_implics.h"
37 #include "scip/type_branch.h"
38 #include "scip/pub_implics.h"
39 
40 #ifdef NDEBUG
41 #include "scip/struct_implics.h"
42 #endif
43 
44 #ifdef __cplusplus
45 extern "C" {
46 #endif
47 
48 /*
49  * Methods for Variable Bounds
50  */
51 
52 /** frees a variable bounds data structure */
53 extern
54 void SCIPvboundsFree(
55  SCIP_VBOUNDS** vbounds, /**< pointer to store variable bounds data structure */
56  BMS_BLKMEM* blkmem /**< block memory */
57  );
58 
59 /** adds a variable bound to the variable bounds data structure */
60 extern
62  SCIP_VBOUNDS** vbounds, /**< pointer to variable bounds data structure */
63  BMS_BLKMEM* blkmem, /**< block memory */
64  SCIP_SET* set, /**< global SCIP settings */
65  SCIP_BOUNDTYPE vboundtype, /**< type of variable bound (LOWER or UPPER) */
66  SCIP_VAR* var, /**< variable z in x <= b*z + d or x >= b*z + d */
67  SCIP_Real coef, /**< coefficient b in x <= b*z + d or x >= b*z + d */
68  SCIP_Real constant, /**< constant d in x <= b*z + d or x >= b*z + d */
69  SCIP_Bool* added /**< pointer to store whether the variable bound was added */
70  );
71 
72 /** removes from variable x a variable bound x >=/<= b*z + d with binary or integer z */
73 extern
75  SCIP_VBOUNDS** vbounds, /**< pointer to variable bounds data structure */
76  BMS_BLKMEM* blkmem, /**< block memory */
77  SCIP_VAR* vbdvar, /**< variable z in x >=/<= b*z + d */
78  SCIP_Bool negativecoef /**< is coefficient b negative? */
79  );
80 
81 /** reduces the number of variable bounds stored in the given variable bounds data structure */
83  SCIP_VBOUNDS** vbounds, /**< pointer to variable bounds data structure */
84  BMS_BLKMEM* blkmem, /**< block memory */
85  int newnvbds /**< new number of variable bounds */
86  );
87 
88 
89 /** gets number of variable bounds contained in given variable bounds data structure */
90 extern
92  SCIP_VBOUNDS* vbounds /**< variable bounds data structure */
93  );
94 
95 /** gets array of variables contained in given variable bounds data structure */
96 extern
98  SCIP_VBOUNDS* vbounds /**< variable bounds data structure */
99  );
100 
101 /** gets array of coefficients contained in given variable bounds data structure */
102 extern
104  SCIP_VBOUNDS* vbounds /**< variable bounds data structure */
105  );
106 
107 /** gets array of constants contained in given variable bounds data structure */
108 extern
110  SCIP_VBOUNDS* vbounds /**< variable bounds data structure */
111  );
112 
113 #ifdef NDEBUG
114 
115 /* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
116  * speed up the algorithms.
117  */
118 
119 #define SCIPvboundsGetNVbds(vbounds) ((vbounds) != NULL ? (vbounds)->len : 0)
120 #define SCIPvboundsGetVars(vbounds) ((vbounds) != NULL ? (vbounds)->vars : NULL)
121 #define SCIPvboundsGetCoefs(vbounds) ((vbounds) != NULL ? (vbounds)->coefs : NULL)
122 #define SCIPvboundsGetConstants(vbounds) ((vbounds) != NULL ? (vbounds)->constants : NULL)
123 
124 #endif
125 
126 
127 
128 
129 /*
130  * Methods for Implications
131  */
132 
133 /** frees an implications data structure */
134 extern
135 void SCIPimplicsFree(
136  SCIP_IMPLICS** implics, /**< pointer of implications data structure to free */
137  BMS_BLKMEM* blkmem /**< block memory */
138  );
139 
140 /** adds an implication x == 0/1 -> y <= b or y >= b to the implications data structure;
141  * the implication must be non-redundant
142  */
143 extern
145  SCIP_IMPLICS** implics, /**< pointer to implications data structure */
146  BMS_BLKMEM* blkmem, /**< block memory */
147  SCIP_SET* set, /**< global SCIP settings */
148  SCIP_STAT* stat, /**< problem statistics */
149  SCIP_Bool varfixing, /**< FALSE if implication for x == 0 has to be added, TRUE for x == 1 */
150  SCIP_VAR* implvar, /**< variable y in implication y <= b or y >= b */
151  SCIP_BOUNDTYPE impltype, /**< type of implication y <= b (SCIP_BOUNDTYPE_UPPER) or y >= b (SCIP_BOUNDTYPE_LOWER) */
152  SCIP_Real implbound, /**< bound b in implication y <= b or y >= b */
153  SCIP_Bool isshortcut, /**< is the implication a shortcut, i.e., added as part of the transitive closure of another implication? */
154  SCIP_Bool* conflict, /**< pointer to store whether implication causes a conflict for variable x */
155  SCIP_Bool* added /**< pointer to store whether the implication was added */
156  );
157 
158 /** removes the implication x <= 0 or x >= 1 ==> y <= b or y >= b from the implications data structure */
159 extern
161  SCIP_IMPLICS** implics, /**< pointer to implications data structure */
162  BMS_BLKMEM* blkmem, /**< block memory */
163  SCIP_SET* set, /**< global SCIP settings */
164  SCIP_Bool varfixing, /**< FALSE if y should be removed from implications for x <= 0, TRUE for x >= 1 */
165  SCIP_VAR* implvar, /**< variable y in implication y <= b or y >= b */
166  SCIP_BOUNDTYPE impltype /**< type of implication y <= b (SCIP_BOUNDTYPE_UPPER) or y >= b (SCIP_BOUNDTYPE_LOWER) */
167  );
168 
169 /** returns which implications on given variable y are contained in implications for x == 0 or x == 1 */
170 extern
172  SCIP_IMPLICS* implics, /**< implications data structure */
173  SCIP_Bool varfixing, /**< FALSE if y should be searched in implications for x == 0, TRUE for x == 1 */
174  SCIP_VAR* implvar, /**< variable y to search for */
175  SCIP_Bool* haslowerimplic, /**< pointer to store whether there exists an implication y >= l */
176  SCIP_Bool* hasupperimplic /**< pointer to store whether there exists an implication y <= u */
177  );
178 
179 /** returns whether an implication y <= b or y >= b is contained in implications for x == 0 or x == 1 */
180 extern
182  SCIP_IMPLICS* implics, /**< implications data structure */
183  SCIP_Bool varfixing, /**< FALSE if y should be searched in implications for x == 0, TRUE for x == 1 */
184  SCIP_VAR* implvar, /**< variable y to search for */
185  SCIP_BOUNDTYPE impltype /**< type of implication y <=/>= b to search for */
186  );
187 
188 
189 /** gets number of implications for a given binary variable fixing */
190 extern
192  SCIP_IMPLICS* implics, /**< implication data */
193  SCIP_Bool varfixing /**< should the implications on var == FALSE or var == TRUE be returned? */
194  );
195 
196 /** gets array with implied variables for a given binary variable fixing */
197 extern
199  SCIP_IMPLICS* implics, /**< implication data */
200  SCIP_Bool varfixing /**< should the implications on var == FALSE or var == TRUE be returned? */
201  );
202 
203 /** gets array with implication types for a given binary variable fixing */
204 extern
206  SCIP_IMPLICS* implics, /**< implication data */
207  SCIP_Bool varfixing /**< should the implications on var == FALSE or var == TRUE be returned? */
208  );
209 
210 /** gets array with implication bounds for a given binary variable fixing */
211 extern
213  SCIP_IMPLICS* implics, /**< implication data */
214  SCIP_Bool varfixing /**< should the implications on var == FALSE or var == TRUE be returned? */
215  );
216 
217 /** Gets array with unique implication identifiers for a given binary variable fixing.
218  * If an implication is a shortcut, i.e., it was added as part of the transitive closure of another implication,
219  * its id is negative, otherwise it is nonnegative.
220  */
221 extern
222 int* SCIPimplicsGetIds(
223  SCIP_IMPLICS* implics, /**< implication data */
224  SCIP_Bool varfixing /**< should the implications on var == FALSE or var == TRUE be returned? */
225  );
226 
227 #ifdef NDEBUG
228 
229 /* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
230  * speed up the algorithms.
231  */
232 
233 #define SCIPimplicsGetNImpls(implics, varfixing) ((implics) != NULL ? (implics)->nimpls[varfixing] : 0)
234 #define SCIPimplicsGetNBinImpls(implics, varfixing) ((implics) != NULL ? (implics)->nbinimpls[varfixing] : 0)
235 #define SCIPimplicsGetVars(implics, varfixing) ((implics) != NULL ? (implics)->vars[varfixing] : NULL)
236 #define SCIPimplicsGetTypes(implics, varfixing) ((implics) != NULL ? (implics)->types[varfixing] : NULL)
237 #define SCIPimplicsGetBounds(implics, varfixing) ((implics) != NULL ? (implics)->bounds[varfixing] : NULL)
238 #define SCIPimplicsGetIds(implics, varfixing) ((implics) != NULL ? (implics)->ids[varfixing] : NULL)
239 
240 #endif
241 
242 
243 
244 
245 /*
246  * methods for cliques
247  */
248 
249 /** adds a single variable to the given clique */
250 extern
252  SCIP_CLIQUE* clique, /**< clique data structure */
253  BMS_BLKMEM* blkmem, /**< block memory */
254  SCIP_SET* set, /**< global SCIP settings */
255  SCIP_VAR* var, /**< variable to add to the clique */
256  SCIP_Bool value, /**< value of the variable in the clique */
257  SCIP_Bool* doubleentry, /**< pointer to store whether the variable and value occurs twice in the clique */
258  SCIP_Bool* oppositeentry /**< pointer to store whether the variable with opposite value is in the clique */
259  );
260 
261 /** removes a single variable from the given clique */
262 extern
263 void SCIPcliqueDelVar(
264  SCIP_CLIQUE* clique, /**< clique data structure */
265  SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
266  SCIP_VAR* var, /**< variable to remove from the clique */
267  SCIP_Bool value /**< value of the variable in the clique */
268  );
269 
270 /** frees a clique list data structure */
271 extern
272 void SCIPcliquelistFree(
273  SCIP_CLIQUELIST** cliquelist, /**< pointer to the clique list data structure */
274  BMS_BLKMEM* blkmem /**< block memory */
275  );
276 
277 /** adds a clique to the clique list */
278 extern
280  SCIP_CLIQUELIST** cliquelist, /**< pointer to the clique list data structure */
281  BMS_BLKMEM* blkmem, /**< block memory */
282  SCIP_SET* set, /**< global SCIP settings */
283  SCIP_Bool value, /**< value of the variable for which the clique list should be extended */
284  SCIP_CLIQUE* clique /**< clique that should be added to the clique list */
285  );
286 
287 /** removes a clique from the clique list */
288 extern
290  SCIP_CLIQUELIST** cliquelist, /**< pointer to the clique list data structure */
291  BMS_BLKMEM* blkmem, /**< block memory */
292  SCIP_Bool value, /**< value of the variable for which the clique list should be reduced */
293  SCIP_CLIQUE* clique /**< clique that should be deleted from the clique list */
294  );
295 
296 /** returns whether the given clique lists have a non-empty intersection, i.e. whether there is a clique that appears
297  * in both lists
298  */
299 extern
301  SCIP_CLIQUELIST* cliquelist1, /**< first clique list data structure */
302  SCIP_Bool value1, /**< value of first variable */
303  SCIP_CLIQUELIST* cliquelist2, /**< second clique list data structure */
304  SCIP_Bool value2 /**< value of second variable */
305  );
306 
307 /** removes all listed entries from the cliques */
308 extern
310  SCIP_CLIQUELIST* cliquelist, /**< clique list data structure */
311  SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
312  SCIP_VAR* var, /**< active problem variable the clique list belongs to */
313  SCIP_Bool irrelevantvar /**< has the variable become irrelevant, meaning that equality
314  * cliques need to be relaxed? */
315  );
316 
317 /** creates a clique table data structure */
318 extern
320  SCIP_CLIQUETABLE** cliquetable, /**< pointer to store clique table data structure */
321  SCIP_SET* set, /**< global SCIP settings */
322  BMS_BLKMEM* blkmem /**< block memory */
323  );
324 
325 /** frees a clique table data structure */
326 extern
328  SCIP_CLIQUETABLE** cliquetable, /**< pointer to store clique table data structure */
329  BMS_BLKMEM* blkmem /**< block memory */
330  );
331 
332 /** adds a clique to the clique table, using the given values for the given variables;
333  * performs implications if the clique contains the same variable twice
334  */
335 extern
337  SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
338  BMS_BLKMEM* blkmem, /**< block memory */
339  SCIP_SET* set, /**< global SCIP settings */
340  SCIP_STAT* stat, /**< problem statistics */
341  SCIP_PROB* transprob, /**< transformed problem */
342  SCIP_PROB* origprob, /**< original problem */
343  SCIP_TREE* tree, /**< branch and bound tree if in solving stage */
344  SCIP_REOPT* reopt, /**< reoptimization data structure */
345  SCIP_LP* lp, /**< current LP data */
346  SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */
347  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
348  SCIP_VAR** vars, /**< binary variables in the clique: at most one can be set to the given value */
349  SCIP_Bool* values, /**< values of the variables in the clique; NULL to use TRUE for all vars */
350  int nvars, /**< number of variables in the clique */
351  SCIP_Bool isequation, /**< is the clique an equation or an inequality? */
352  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
353  int* nbdchgs /**< pointer to count the number of performed bound changes, or NULL */
354  );
355 
356 /** removes all empty and single variable cliques from the clique table; removes double entries from the clique table
357  *
358  * @note cliques can be processed several times by this method
359  */
360 extern
362  SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
363  BMS_BLKMEM* blkmem, /**< block memory */
364  SCIP_SET* set, /**< global SCIP settings */
365  SCIP_STAT* stat, /**< problem statistics */
366  SCIP_PROB* transprob, /**< transformed problem */
367  SCIP_PROB* origprob, /**< original problem */
368  SCIP_TREE* tree, /**< branch and bound tree if in solving stage */
369  SCIP_REOPT* reopt, /**< reoptimization data structure */
370  SCIP_LP* lp, /**< current LP data */
371  SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */
372  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
373  int* nchgbds, /**< pointer to store number of fixed variables */
374  SCIP_Bool* infeasible /**< pointer to store whether an infeasibility was detected */
375  );
376 
377 /** computes connected components of the clique graph
378  *
379  * use depth-first search similarly to the components presolver/constraint handler, representing a clique as a
380  * path to reduce memory usage, but leaving the connected components the same
381  *
382  * an update becomes necessary if a clique gets added with variables from different components
383  */
384 extern
386  SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
387  SCIP_SET* set, /**< global SCIP settings */
388  BMS_BLKMEM* blkmem, /**< block memory */
389  SCIP_VAR** vars, /**< array of problem variables, sorted by variable type */
390  int nbinvars, /**< number of binary variables */
391  int nintvars, /**< number of integer variables */
392  int nimplvars /**< number of implicit integer variables */
393  );
394 
395 /** returns the index of the connected component of the clique graph that the variable belongs to, or -1 */
396 extern
398  SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
399  SCIP_VAR* var /**< problem variable */
400  );
401 
402 /** returns the number of cliques stored in the clique list */
403 extern
405  SCIP_CLIQUELIST* cliquelist, /**< clique list data structure */
406  SCIP_Bool value /**< value of the variable for which the cliques should be returned */
407  );
408 
409 /** returns the cliques stored in the clique list, or NULL if the clique list is empty */
410 extern
412  SCIP_CLIQUELIST* cliquelist, /**< clique list data structure */
413  SCIP_Bool value /**< value of the variable for which the cliques should be returned */
414  );
415 
416 /** checks whether variable is contained in all cliques of the cliquelist */
417 extern
419  SCIP_CLIQUELIST* cliquelist, /**< clique list data structure */
420  SCIP_VAR* var /**< variable, the clique list belongs to */
421  );
422 
423 /** gets the number of cliques stored in the clique table */
424 extern
426  SCIP_CLIQUETABLE* cliquetable /**< clique table data structure */
427  );
428 
429 /** gets the number of cliques created so far by the clique table */
430 extern
432  SCIP_CLIQUETABLE* cliquetable /**< clique table data structure */
433  );
434 
435 /** gets the array of cliques stored in the clique table */
436 extern
438  SCIP_CLIQUETABLE* cliquetable /**< clique table data structure */
439  );
440 
441 /** gets the number of entries in the whole clique table */
442 extern
444  SCIP_CLIQUETABLE* cliquetable /**< clique table data structure */
445  );
446 
447 /** returns the number of clique components, or -1 if update is necessary first */
448 extern
450  SCIP_CLIQUETABLE* cliquetable /**< clique table data structure */
451  );
452 
453 /** returns TRUE iff the connected clique components need an update (because new cliques were added) */
454 extern
456  SCIP_CLIQUETABLE* cliquetable /**< clique table data structure */
457  );
458 
459 #ifdef NDEBUG
460 
461 /* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
462  * speed up the algorithms.
463  */
464 
465 #define SCIPcliquelistGetNCliques(cliquelist, value) ((cliquelist) != NULL ? (cliquelist)->ncliques[value] : 0)
466 #define SCIPcliquelistGetCliques(cliquelist, value) ((cliquelist) != NULL ? (cliquelist)->cliques[value] : NULL)
467 #define SCIPcliquelistCheck(cliquelist, var) /**/
468 #define SCIPcliquetableGetNCliques(cliquetable) ((cliquetable)->ncliques)
469 #define SCIPcliquetableGetCliques(cliquetable) ((cliquetable)->cliques)
470 #define SCIPcliquetableGetNEntries(cliquetable) ((cliquetable)->nentries)
471 #define SCIPcliquetableGetNCliqueComponents(cliquetable) (cliquetable->compsfromscratch ? -1 : cliquetable->ncliquecomponents)
472 #define SCIPcliquetableNeedsComponentUpdate(cliquetable) (cliquetable->compsfromscratch || cliquetable->djset == NULL)
473 #endif
474 
475 #ifdef __cplusplus
476 }
477 #endif
478 
479 #endif
enum SCIP_BoundType SCIP_BOUNDTYPE
Definition: type_lp.h:50
int SCIPcliquetableGetNCliqueComponents(SCIP_CLIQUETABLE *cliquetable)
Definition: implics.c:3519
void SCIPvboundsShrink(SCIP_VBOUNDS **vbounds, BMS_BLKMEM *blkmem, int newnvbds)
Definition: implics.c:328
SCIP_Longint SCIPcliquetableGetNEntries(SCIP_CLIQUETABLE *cliquetable)
Definition: implics.c:3509
type definitions for implications, variable bounds, and cliques
SCIP_Bool SCIPcliquetableNeedsComponentUpdate(SCIP_CLIQUETABLE *cliquetable)
Definition: implics.c:3527
public methods for implications, variable bounds, and cliques
SCIP_RETCODE SCIPcliquetableCleanup(SCIP_CLIQUETABLE *cliquetable, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, int *nchgbds, SCIP_Bool *infeasible)
Definition: implics.c:2893
SCIP_RETCODE SCIPcliquelistAdd(SCIP_CLIQUELIST **cliquelist, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_Bool value, SCIP_CLIQUE *clique)
Definition: implics.c:1460
SCIP_Real * SCIPvboundsGetConstants(SCIP_VBOUNDS *vbounds)
Definition: implics.c:3287
SCIP_Real * SCIPvboundsGetCoefs(SCIP_VBOUNDS *vbounds)
Definition: implics.c:3279
SCIP_RETCODE SCIPcliqueAddVar(SCIP_CLIQUE *clique, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_VAR *var, SCIP_Bool value, SCIP_Bool *doubleentry, SCIP_Bool *oppositeentry)
Definition: implics.c:1129
int SCIPcliquetableGetNCliques(SCIP_CLIQUETABLE *cliquetable)
Definition: implics.c:3479
int SCIPimplicsGetNImpls(SCIP_IMPLICS *implics, SCIP_Bool varfixing)
Definition: implics.c:3295
int SCIPvboundsGetNVbds(SCIP_VBOUNDS *vbounds)
Definition: implics.c:3263
SCIP_Bool SCIPcliquelistsHaveCommonClique(SCIP_CLIQUELIST *cliquelist1, SCIP_Bool value1, SCIP_CLIQUELIST *cliquelist2, SCIP_Bool value2)
Definition: implics.c:1583
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:53
type definitions for global SCIP settings
type definitions for return codes for SCIP methods
SCIP_RETCODE SCIPcliquetableCreate(SCIP_CLIQUETABLE **cliquetable, SCIP_SET *set, BMS_BLKMEM *blkmem)
Definition: implics.c:1766
SCIP_RETCODE SCIPimplicsDel(SCIP_IMPLICS **implics, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_BOUNDTYPE impltype)
Definition: implics.c:831
type definitions for branching rules
type definitions for problem statistics
SCIP_Bool SCIPimplicsContainsImpl(SCIP_IMPLICS *implics, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_BOUNDTYPE impltype)
Definition: implics.c:911
SCIP_RETCODE SCIPcliquetableAdd(SCIP_CLIQUETABLE *cliquetable, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_VAR **vars, SCIP_Bool *values, int nvars, SCIP_Bool isequation, SCIP_Bool *infeasible, int *nbdchgs)
Definition: implics.c:2358
type definitions for LP management
void SCIPimplicsGetVarImplics(SCIP_IMPLICS *implics, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_Bool *haslowerimplic, SCIP_Bool *hasupperimplic)
Definition: implics.c:889
void SCIPcliquelistRemoveFromCliques(SCIP_CLIQUELIST *cliquelist, SCIP_CLIQUETABLE *cliquetable, SCIP_VAR *var, SCIP_Bool irrelevantvar)
Definition: implics.c:1661
SCIP_RETCODE SCIPimplicsAdd(SCIP_IMPLICS **implics, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_BOUNDTYPE impltype, SCIP_Real implbound, SCIP_Bool isshortcut, SCIP_Bool *conflict, SCIP_Bool *added)
Definition: implics.c:628
SCIP_VAR ** SCIPimplicsGetVars(SCIP_IMPLICS *implics, SCIP_Bool varfixing)
Definition: implics.c:3304
SCIP_CLIQUE ** SCIPcliquetableGetCliques(SCIP_CLIQUETABLE *cliquetable)
Definition: implics.c:3499
SCIP_CLIQUE ** SCIPcliquelistGetCliques(SCIP_CLIQUELIST *cliquelist, SCIP_Bool value)
Definition: implics.c:3428
SCIP_BOUNDTYPE * SCIPimplicsGetTypes(SCIP_IMPLICS *implics, SCIP_Bool varfixing)
Definition: implics.c:3313
type definitions for problem variables
void SCIPcliqueDelVar(SCIP_CLIQUE *clique, SCIP_CLIQUETABLE *cliquetable, SCIP_VAR *var, SCIP_Bool value)
Definition: implics.c:1263
type definitions for managing events
datastructures for implications, variable bounds, and cliques
int * SCIPimplicsGetIds(SCIP_IMPLICS *implics, SCIP_Bool varfixing)
Definition: implics.c:3334
void SCIPvboundsFree(SCIP_VBOUNDS **vbounds, BMS_BLKMEM *blkmem)
Definition: implics.c:68
#define SCIP_Bool
Definition: def.h:61
SCIP_RETCODE SCIPcliquetableFree(SCIP_CLIQUETABLE **cliquetable, BMS_BLKMEM *blkmem)
Definition: implics.c:1802
void SCIPcliquelistCheck(SCIP_CLIQUELIST *cliquelist, SCIP_VAR *var)
Definition: implics.c:3437
SCIP_RETCODE SCIPcliquetableComputeCliqueComponents(SCIP_CLIQUETABLE *cliquetable, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_VAR **vars, int nbinvars, int nintvars, int nimplvars)
Definition: implics.c:3104
void SCIPimplicsFree(SCIP_IMPLICS **implics, BMS_BLKMEM *blkmem)
Definition: implics.c:446
SCIP_RETCODE SCIPvboundsDel(SCIP_VBOUNDS **vbounds, BMS_BLKMEM *blkmem, SCIP_VAR *vbdvar, SCIP_Bool negativecoef)
Definition: implics.c:283
int SCIPcliquetableGetVarComponentIdx(SCIP_CLIQUETABLE *cliquetable, SCIP_VAR *var)
Definition: implics.c:2330
void SCIPcliquelistFree(SCIP_CLIQUELIST **cliquelist, BMS_BLKMEM *blkmem)
Definition: implics.c:1419
SCIP_VAR ** SCIPvboundsGetVars(SCIP_VBOUNDS *vbounds)
Definition: implics.c:3271
SCIP_Real * SCIPimplicsGetBounds(SCIP_IMPLICS *implics, SCIP_Bool varfixing)
Definition: implics.c:3322
#define SCIP_Real
Definition: def.h:149
int SCIPcliquetableGetNCliquesCreated(SCIP_CLIQUETABLE *cliquetable)
Definition: implics.c:3489
#define SCIP_Longint
Definition: def.h:134
common defines and data types used in all packages of SCIP
struct BMS_BlkMem BMS_BLKMEM
Definition: memory.h:419
SCIP_RETCODE SCIPvboundsAdd(SCIP_VBOUNDS **vbounds, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_BOUNDTYPE vboundtype, SCIP_VAR *var, SCIP_Real coef, SCIP_Real constant, SCIP_Bool *added)
Definition: implics.c:201
int SCIPcliquelistGetNCliques(SCIP_CLIQUELIST *cliquelist, SCIP_Bool value)
Definition: implics.c:3419
SCIP_RETCODE SCIPcliquelistDel(SCIP_CLIQUELIST **cliquelist, BMS_BLKMEM *blkmem, SCIP_Bool value, SCIP_CLIQUE *clique)
Definition: implics.c:1505
memory allocation routines