Scippy

SCIP

Solving Constraint Integer Programs

cons.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-2019 Konrad-Zuse-Zentrum */
7 /* fuer Informationstechnik Berlin */
8 /* */
9 /* SCIP is distributed under the terms of the ZIB Academic License. */
10 /* */
11 /* You should have received a copy of the ZIB Academic License */
12 /* along with SCIP; see the file COPYING. If not visit scip.zib.de. */
13 /* */
14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15 
16 /**@file cons.h
17  * @ingroup INTERNALAPI
18  * @brief internal methods for constraints and constraint handlers
19  * @author Tobias Achterberg
20  */
21 
22 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
23 
24 #ifndef __SCIP_CONS_H__
25 #define __SCIP_CONS_H__
26 
27 
28 #include "scip/def.h"
29 #include "blockmemshell/memory.h"
30 #include "scip/type_retcode.h"
31 #include "scip/type_result.h"
32 #include "scip/type_set.h"
33 #include "scip/type_stat.h"
34 #include "scip/type_mem.h"
35 #include "scip/type_misc.h"
36 #include "scip/type_timing.h"
37 #include "scip/type_lp.h"
38 #include "scip/type_var.h"
39 #include "scip/type_prob.h"
40 #include "scip/type_sol.h"
41 #include "scip/type_tree.h"
42 #include "scip/type_sepastore.h"
43 #include "scip/type_cons.h"
44 #include "scip/type_branch.h"
45 #include "scip/type_reopt.h"
46 #include "scip/pub_cons.h"
47 
48 #ifndef NDEBUG
49 #include "scip/struct_cons.h"
50 #endif
51 
52 #ifdef __cplusplus
53 extern "C" {
54 #endif
55 
56 /*
57  * Constraint handler methods
58  */
59 
60 /** copies the given constraint handler to a new scip */
61 extern
63  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
64  SCIP_SET* set, /**< SCIP_SET of SCIP to copy to */
65  SCIP_Bool* valid /**< was the copying process valid? */
66  );
67 
68 /** creates a constraint handler */
69 extern
71  SCIP_CONSHDLR** conshdlr, /**< pointer to constraint handler data structure */
72  SCIP_SET* set, /**< global SCIP settings */
73  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
74  BMS_BLKMEM* blkmem, /**< block memory for parameter settings */
75  const char* name, /**< name of constraint handler */
76  const char* desc, /**< description of constraint handler */
77  int sepapriority, /**< priority of the constraint handler for separation */
78  int enfopriority, /**< priority of the constraint handler for constraint enforcing */
79  int checkpriority, /**< priority of the constraint handler for checking feasibility (and propagation) */
80  int sepafreq, /**< frequency for separating cuts; zero means to separate only in the root node */
81  int propfreq, /**< frequency for propagating domains; zero means only preprocessing propagation */
82  int eagerfreq, /**< frequency for using all instead of only the useful constraints in separation,
83  * propagation and enforcement, -1 for no eager evaluations, 0 for first only */
84  int maxprerounds, /**< maximal number of presolving rounds the constraint handler participates in (-1: no limit) */
85  SCIP_Bool delaysepa, /**< should separation method be delayed, if other separators found cuts? */
86  SCIP_Bool delayprop, /**< should propagation method be delayed, if other propagators found reductions? */
87  SCIP_Bool needscons, /**< should the constraint handler be skipped, if no constraints are available? */
88  SCIP_PROPTIMING proptiming, /**< positions in the node solving loop where propagation method of constraint handlers should be executed */
89  SCIP_PRESOLTIMING presoltiming, /**< timing mask of the constraint handler's presolving method */
90  SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), /**< copy method of constraint handler or NULL if you don't want to copy your plugin into sub-SCIPs */
91  SCIP_DECL_CONSFREE ((*consfree)), /**< destructor of constraint handler */
92  SCIP_DECL_CONSINIT ((*consinit)), /**< initialize constraint handler */
93  SCIP_DECL_CONSEXIT ((*consexit)), /**< deinitialize constraint handler */
94  SCIP_DECL_CONSINITPRE ((*consinitpre)), /**< presolving initialization method of constraint handler */
95  SCIP_DECL_CONSEXITPRE ((*consexitpre)), /**< presolving deinitialization method of constraint handler */
96  SCIP_DECL_CONSINITSOL ((*consinitsol)), /**< solving process initialization method of constraint handler */
97  SCIP_DECL_CONSEXITSOL ((*consexitsol)), /**< solving process deinitialization method of constraint handler */
98  SCIP_DECL_CONSDELETE ((*consdelete)), /**< free specific constraint data */
99  SCIP_DECL_CONSTRANS ((*constrans)), /**< transform constraint data into data belonging to the transformed problem */
100  SCIP_DECL_CONSINITLP ((*consinitlp)), /**< initialize LP with relaxations of "initial" constraints */
101  SCIP_DECL_CONSSEPALP ((*conssepalp)), /**< separate cutting planes for LP solution */
102  SCIP_DECL_CONSSEPASOL ((*conssepasol)), /**< separate cutting planes for arbitrary primal solution */
103  SCIP_DECL_CONSENFOLP ((*consenfolp)), /**< enforcing constraints for LP solutions */
104  SCIP_DECL_CONSENFORELAX ((*consenforelax)), /**< enforcing constraints for relaxation solutions */
105  SCIP_DECL_CONSENFOPS ((*consenfops)), /**< enforcing constraints for pseudo solutions */
106  SCIP_DECL_CONSCHECK ((*conscheck)), /**< check feasibility of primal solution */
107  SCIP_DECL_CONSPROP ((*consprop)), /**< propagate variable domains */
108  SCIP_DECL_CONSPRESOL ((*conspresol)), /**< presolving method */
109  SCIP_DECL_CONSRESPROP ((*consresprop)), /**< propagation conflict resolving method */
110  SCIP_DECL_CONSLOCK ((*conslock)), /**< variable rounding lock method */
111  SCIP_DECL_CONSACTIVE ((*consactive)), /**< activation notification method */
112  SCIP_DECL_CONSDEACTIVE((*consdeactive)), /**< deactivation notification method */
113  SCIP_DECL_CONSENABLE ((*consenable)), /**< enabling notification method */
114  SCIP_DECL_CONSDISABLE ((*consdisable)), /**< disabling notification method */
115  SCIP_DECL_CONSDELVARS ((*consdelvars)), /**< variable deletion method */
116  SCIP_DECL_CONSPRINT ((*consprint)), /**< constraint display method */
117  SCIP_DECL_CONSCOPY ((*conscopy)), /**< constraint copying method */
118  SCIP_DECL_CONSPARSE ((*consparse)), /**< constraint parsing method */
119  SCIP_DECL_CONSGETVARS ((*consgetvars)), /**< constraint get variables method */
120  SCIP_DECL_CONSGETNVARS((*consgetnvars)), /**< constraint get number of variable method */
121  SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs)), /**< constraint handler diving solution enforcement method */
122  SCIP_CONSHDLRDATA* conshdlrdata /**< constraint handler data */
123  );
124 
125 /** calls destructor and frees memory of constraint handler */
126 extern
128  SCIP_CONSHDLR** conshdlr, /**< pointer to constraint handler data structure */
129  SCIP_SET* set /**< global SCIP settings */
130  );
131 
132 /** calls init method of constraint handler */
133 extern
135  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
136  BMS_BLKMEM* blkmem, /**< block memory */
137  SCIP_SET* set, /**< global SCIP settings */
138  SCIP_STAT* stat /**< dynamic problem statistics */
139  );
140 
141 /** calls exit method of constraint handler */
142 extern
144  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
145  BMS_BLKMEM* blkmem, /**< block memory */
146  SCIP_SET* set, /**< global SCIP settings */
147  SCIP_STAT* stat /**< dynamic problem statistics */
148  );
149 
150 /** informs constraint handler that the presolving process is being started */
151 extern
153  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
154  BMS_BLKMEM* blkmem, /**< block memory */
155  SCIP_SET* set, /**< global SCIP settings */
156  SCIP_STAT* stat /**< dynamic problem statistics */
157  );
158 
159 /** informs constraint handler that the presolving is finished */
160 extern
162  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
163  BMS_BLKMEM* blkmem, /**< block memory */
164  SCIP_SET* set, /**< global SCIP settings */
165  SCIP_STAT* stat /**< dynamic problem statistics */
166  );
167 
168 /** informs constraint handler that the branch and bound process is being started */
169 extern
171  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
172  BMS_BLKMEM* blkmem, /**< block memory */
173  SCIP_SET* set, /**< global SCIP settings */
174  SCIP_STAT* stat /**< dynamic problem statistics */
175  );
176 
177 /** informs constraint handler that the branch and bound process data is being freed */
178 extern
180  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
181  BMS_BLKMEM* blkmem, /**< block memory */
182  SCIP_SET* set, /**< global SCIP settings */
183  SCIP_STAT* stat, /**< dynamic problem statistics */
184  SCIP_Bool restart /**< was this exit solve call triggered by a restart? */
185  );
186 
187 /** calls LP initialization method of constraint handler to separate all initial active constraints */
188 extern
190  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
191  BMS_BLKMEM* blkmem, /**< block memory */
192  SCIP_SET* set, /**< global SCIP settings */
193  SCIP_STAT* stat, /**< dynamic problem statistics */
194  SCIP_TREE* tree, /**< branch and bound tree */
195  SCIP_Bool initkeptconss, /**< Also initialize constraints which are valid at a more global node,
196  * but were not activated there? Should be FALSE for repeated calls at
197  * one node or if the current focusnode is a child of the former one */
198  SCIP_Bool* cutoff /**< pointer to store whether infeasibility was detected while building the LP */
199  );
200 
201 /** calls separator method of constraint handler to separate LP solution */
202 extern
204  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
205  BMS_BLKMEM* blkmem, /**< block memory */
206  SCIP_SET* set, /**< global SCIP settings */
207  SCIP_STAT* stat, /**< dynamic problem statistics */
208  SCIP_SEPASTORE* sepastore, /**< separation storage */
209  int depth, /**< depth of current node */
210  SCIP_Bool execdelayed, /**< execute separation method even if it is marked to be delayed */
211  SCIP_RESULT* result /**< pointer to store the result of the callback method */
212  );
213 
214 /** calls separator method of constraint handler to separate given primal solution */
215 extern
217  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
218  BMS_BLKMEM* blkmem, /**< block memory */
219  SCIP_SET* set, /**< global SCIP settings */
220  SCIP_STAT* stat, /**< dynamic problem statistics */
221  SCIP_SEPASTORE* sepastore, /**< separation storage */
222  SCIP_SOL* sol, /**< primal solution that should be separated */
223  int depth, /**< depth of current node */
224  SCIP_Bool execdelayed, /**< execute separation method even if it is marked to be delayed */
225  SCIP_RESULT* result /**< pointer to store the result of the callback method */
226  );
227 
228 /** calls enforcing method of constraint handler for a relaxation solution for all constraints added after last
229  * conshdlrResetEnfo() call
230  */
231 extern
233  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
234  BMS_BLKMEM* blkmem, /**< block memory */
235  SCIP_SET* set, /**< global SCIP settings */
236  SCIP_STAT* stat, /**< dynamic problem statistics */
237  SCIP_TREE* tree, /**< branch and bound tree */
238  SCIP_SEPASTORE* sepastore, /**< separation storage */
239  SCIP_SOL* relaxsol, /**< solution to be enforced */
240  SCIP_Bool solinfeasible, /**< was the solution already found out to be infeasible? */
241  SCIP_RESULT* result /**< pointer to store the result of the callback method */
242  );
243 
244 /** calls enforcing method of constraint handler for LP solution for all constraints added after last
245  * conshdlrReset() call
246  */
247 extern
249  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
250  BMS_BLKMEM* blkmem, /**< block memory */
251  SCIP_SET* set, /**< global SCIP settings */
252  SCIP_STAT* stat, /**< dynamic problem statistics */
253  SCIP_TREE* tree, /**< branch and bound tree */
254  SCIP_SEPASTORE* sepastore, /**< separation storage */
255  SCIP_Bool solinfeasible, /**< was the solution already found out to be infeasible? */
256  SCIP_RESULT* result /**< pointer to store the result of the callback method */
257  );
258 
259 /** calls diving solution enforcement callback of constraint handler, if it exists */
260 extern
262  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
263  SCIP_SET* set, /**< global SCIP settings */
264  SCIP_DIVESET* diveset, /**< diving settings to control scoring */
265  SCIP_SOL* sol, /**< current solution of diving mode */
266  SCIP_Bool* success, /**< pointer to store whether constraint handler successfully found a variable */
267  SCIP_Bool* infeasible /**< pointer to store whether the current node was detected to be infeasible */
268  );
269 
270 /** calls enforcing method of constraint handler for pseudo solution for all constraints added after last
271  * conshdlrReset() call
272  */
273 extern
275  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
276  BMS_BLKMEM* blkmem, /**< block memory */
277  SCIP_SET* set, /**< global SCIP settings */
278  SCIP_STAT* stat, /**< dynamic problem statistics */
279  SCIP_TREE* tree, /**< branch and bound tree */
280  SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */
281  SCIP_Bool solinfeasible, /**< was the solution already found out to be infeasible? */
282  SCIP_Bool objinfeasible, /**< is the solution infeasible anyway due to violating lower objective bound? */
283  SCIP_Bool forced, /**< should enforcement of pseudo solution be forced? */
284  SCIP_RESULT* result /**< pointer to store the result of the callback method */
285  );
286 
287 /** calls feasibility check method of constraint handler */
288 extern
290  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
291  BMS_BLKMEM* blkmem, /**< block memory */
292  SCIP_SET* set, /**< global SCIP settings */
293  SCIP_STAT* stat, /**< dynamic problem statistics */
294  SCIP_SOL* sol, /**< primal CIP solution */
295  SCIP_Bool checkintegrality, /**< Has integrality to be checked? */
296  SCIP_Bool checklprows, /**< Do constraints represented by rows in the current LP have to be checked? */
297  SCIP_Bool printreason, /**< Should the reason for the violation be printed? */
298  SCIP_Bool completely, /**< Should all violations be checked? */
299  SCIP_RESULT* result /**< pointer to store the result of the callback method */
300  );
301 
302 /** calls propagation method of constraint handler */
303 extern
305  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
306  BMS_BLKMEM* blkmem, /**< block memory */
307  SCIP_SET* set, /**< global SCIP settings */
308  SCIP_STAT* stat, /**< dynamic problem statistics */
309  int depth, /**< depth of current node; -1 if preprocessing domain propagation */
310  SCIP_Bool fullpropagation, /**< should all constraints be propagated (or only new ones)? */
311  SCIP_Bool execdelayed, /**< execute propagation method even if it is marked to be delayed */
312  SCIP_Bool instrongbranching, /**< are we currently doing strong branching? */
313  SCIP_PROPTIMING proptiming, /**< current point in the node solving process */
314  SCIP_RESULT* result /**< pointer to store the result of the callback method */
315  );
316 
317 /** calls presolving method of constraint handler */
318 extern
320  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
321  BMS_BLKMEM* blkmem, /**< block memory */
322  SCIP_SET* set, /**< global SCIP settings */
323  SCIP_STAT* stat, /**< dynamic problem statistics */
324  SCIP_PRESOLTIMING timing, /**< current presolving timing */
325  int nrounds, /**< number of presolving rounds already done */
326  int* nfixedvars, /**< pointer to total number of variables fixed of all presolvers */
327  int* naggrvars, /**< pointer to total number of variables aggregated of all presolvers */
328  int* nchgvartypes, /**< pointer to total number of variable type changes of all presolvers */
329  int* nchgbds, /**< pointer to total number of variable bounds tightened of all presolvers */
330  int* naddholes, /**< pointer to total number of domain holes added of all presolvers */
331  int* ndelconss, /**< pointer to total number of deleted constraints of all presolvers */
332  int* naddconss, /**< pointer to total number of added constraints of all presolvers */
333  int* nupgdconss, /**< pointer to total number of upgraded constraints of all presolvers */
334  int* nchgcoefs, /**< pointer to total number of changed coefficients of all presolvers */
335  int* nchgsides, /**< pointer to total number of changed left/right hand sides of all presolvers */
336  SCIP_RESULT* result /**< pointer to store the result of the callback method */
337  );
338 
339 /** enables or disables all clocks of \p conshdlr, depending on the value of the flag */
340 extern
342  SCIP_CONSHDLR* conshdlr, /**< the constraint handler for which all clocks should be enabled or disabled */
343  SCIP_Bool enable /**< should the clocks of the constraint handler be enabled? */
344  );
345 
346 /** calls variable deletion method of constraint handler */
347 extern
349  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
350  BMS_BLKMEM* blkmem, /**< block memory */
351  SCIP_SET* set, /**< global SCIP settings */
352  SCIP_STAT* stat /**< dynamic problem statistics */
353  );
354 
355 
356 /** locks rounding of variables involved in the given constraint constraint handler that doesn't need constraints */
358  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
359  SCIP_SET* set /**< global SCIP settings */
360  );
361 
362 /** unlocks rounding of variables involved in the given constraint constraint handler that doesn't need constraints */
363 extern
365  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
366  SCIP_SET* set /**< global SCIP settings */
367  );
368 
369 /**
370  * callback setter methods of constraint handlers
371  */
372 
373 /** sets copy method of both the constraint handler and each associated constraint */
374 extern
376  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
377  SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), /**< copy method of constraint handler or NULL if you don't want to copy your plugin into sub-SCIPs */
378  SCIP_DECL_CONSCOPY ((*conscopy)) /**< constraint copying method */
379  );
380 
381 /** sets destructor method of constraint handler */
382 extern
384  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
385  SCIP_DECL_CONSFREE ((*consfree)) /**< destructor of constraint handler */
386  );
387 
388 /** sets initialization method of constraint handler */
389 extern
391  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
392  SCIP_DECL_CONSINIT ((*consinit)) /**< initialize constraint handler */
393  );
394 
395 /** sets deinitialization method of constraint handler */
396 extern
398  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
399  SCIP_DECL_CONSEXIT ((*consexit)) /**< deinitialize constraint handler */
400  );
401 
402 /** sets solving process initialization method of constraint handler */
403 extern
405  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
406  SCIP_DECL_CONSINITSOL((*consinitsol)) /**< solving process initialization method of constraint handler */
407  );
408 
409 /** sets solving process deinitialization method of constraint handler */
410 extern
412  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
413  SCIP_DECL_CONSEXITSOL ((*consexitsol)) /**< solving process deinitialization method of constraint handler */
414  );
415 
416 /** sets preprocessing initialization method of constraint handler */
417 extern
419  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
420  SCIP_DECL_CONSINITPRE((*consinitpre)) /**< preprocessing initialization method of constraint handler */
421  );
422 
423 /** sets preprocessing deinitialization method of constraint handler */
424 extern
426  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
427  SCIP_DECL_CONSEXITPRE((*consexitpre)) /**< preprocessing deinitialization method of constraint handler */
428  );
429 
430 /** sets presolving method of constraint handler */
431 extern
433  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
434  SCIP_DECL_CONSPRESOL ((*conspresol)), /**< presolving method of constraint handler */
435  int maxprerounds, /**< maximal number of presolving rounds the constraint handler participates in (-1: no limit) */
436  SCIP_PRESOLTIMING presoltiming /**< timing mask of the constraint handler's presolving method */
437  );
438 
439 /** sets method of constraint handler to free specific constraint data */
440 extern
442  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
443  SCIP_DECL_CONSDELETE ((*consdelete)) /**< free specific constraint data */
444  );
445 
446 /** sets method of constraint handler to transform constraint data into data belonging to the transformed problem */
447 extern
449  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
450  SCIP_DECL_CONSTRANS ((*constrans)) /**< transform constraint data into data belonging to the transformed problem */
451  );
452 
453 /** sets method of constraint handler to initialize LP with relaxations of "initial" constraints */
454 extern
456  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
457  SCIP_DECL_CONSINITLP ((*consinitlp)) /**< initialize LP with relaxations of "initial" constraints */
458  );
459 
460 /** sets propagation conflict resolving method of constraint handler */
461 extern
463  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
464  SCIP_DECL_CONSRESPROP ((*consresprop)) /**< propagation conflict resolving method */
465  );
466 
467 /** sets activation notification method of constraint handler */
468 extern
470  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
471  SCIP_DECL_CONSACTIVE ((*consactive)) /**< activation notification method */
472  );
473 
474 /** sets deactivation notification method of constraint handler */
475 extern
477  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
478  SCIP_DECL_CONSDEACTIVE((*consdeactive)) /**< deactivation notification method */
479  );
480 
481 /** sets enabling notification method of constraint handler */
482 extern
484  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
485  SCIP_DECL_CONSENABLE ((*consenable)) /**< enabling notification method */
486  );
487 
488 /** sets disabling notification method of constraint handler */
489 extern
491  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
492  SCIP_DECL_CONSDISABLE ((*consdisable)) /**< disabling notification method */
493  );
494 
495 /** sets variable deletion method of constraint handler */
496 extern
498  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
499  SCIP_DECL_CONSDELVARS ((*consdelvars)) /**< variable deletion method */
500  );
501 
502 /** sets constraint display method of constraint handler */
503 extern
505  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
506  SCIP_DECL_CONSPRINT ((*consprint)) /**< constraint display method */
507  );
508 
509 /** sets constraint parsing method of constraint handler */
510 extern
512  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
513  SCIP_DECL_CONSPARSE ((*consparse)) /**< constraint parsing method */
514  );
515 
516 /** sets constraint variable getter method of constraint handler */
517 extern
519  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
520  SCIP_DECL_CONSGETVARS ((*consgetvars)) /**< constraint variable getter method */
521  );
522 
523 /** sets constraint variable number getter method of constraint handler */
524 extern
526  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
527  SCIP_DECL_CONSGETNVARS((*consgetnvars)) /**< constraint variable number getter method */
528  );
529 
530 /** sets diving enforcement method of constraint handler */
531 extern
533  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
534  SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs)) /**< constraint handler diving solution enforcement method */
535  );
536 
537 /*
538  * Constraint set change methods
539  */
540 
541 /** frees constraint set change data and releases all included constraints */
542 extern
544  SCIP_CONSSETCHG** conssetchg, /**< pointer to constraint set change */
545  BMS_BLKMEM* blkmem, /**< block memory */
546  SCIP_SET* set /**< global SCIP settings */
547  );
548 
549 /** adds constraint addition to constraint set changes, and captures constraint; activates constraint if the
550  * constraint set change data is currently active
551  */
552 extern
554  SCIP_CONSSETCHG** conssetchg, /**< pointer to constraint set change data structure */
555  BMS_BLKMEM* blkmem, /**< block memory */
556  SCIP_SET* set, /**< global SCIP settings */
557  SCIP_STAT* stat, /**< dynamic problem statistics */
558  SCIP_CONS* cons, /**< added constraint */
559  int depth, /**< depth of constraint set change's node */
560  SCIP_Bool focusnode, /**< does the constraint set change belong to the focus node? */
561  SCIP_Bool active /**< is the constraint set change currently active? */
562  );
563 
564 /** adds constraint disabling to constraint set changes, and captures constraint */
565 extern
567  SCIP_CONSSETCHG** conssetchg, /**< pointer to constraint set change data structure */
568  BMS_BLKMEM* blkmem, /**< block memory */
569  SCIP_SET* set, /**< global SCIP settings */
570  SCIP_CONS* cons /**< disabled constraint */
571  );
572 
573 /** applies constraint set change */
574 extern
576  SCIP_CONSSETCHG* conssetchg, /**< constraint set change to apply */
577  BMS_BLKMEM* blkmem, /**< block memory */
578  SCIP_SET* set, /**< global SCIP settings */
579  SCIP_STAT* stat, /**< dynamic problem statistics */
580  int depth, /**< depth of constraint set change's node */
581  SCIP_Bool focusnode /**< does the constraint set change belong to the focus node? */
582  );
583 
584 /** undoes constraint set change */
585 extern
587  SCIP_CONSSETCHG* conssetchg, /**< constraint set change to undo */
588  BMS_BLKMEM* blkmem, /**< block memory */
589  SCIP_SET* set, /**< global SCIP settings */
590  SCIP_STAT* stat /**< dynamic problem statistics */
591  );
592 
593 /** applies constraint set change to the global problem and deletes the constraint set change data */
594 extern
596  SCIP_CONSSETCHG** conssetchg, /**< pointer to constraint set change data */
597  BMS_BLKMEM* blkmem, /**< block memory */
598  SCIP_SET* set, /**< global SCIP settings */
599  SCIP_STAT* stat, /**< dynamic problem statistics */
600  SCIP_PROB* prob, /**< problem data */
601  SCIP_REOPT* reopt /**< reoptimization data */
602  );
603 
604 /** increase count of applied cuts */
605 extern
607  SCIP_CONSHDLR* conshdlr /**< constraint handler */
608  );
609 
610 /** increase count of found cuts */
611 extern
613  SCIP_CONSHDLR* conshdlr /**< constraint handler */
614  );
615 
616 
617 
618 /*
619  * Constraint methods
620  */
621 
622 /** creates and captures a constraint, and inserts it into the conss array of its constraint handler
623  *
624  * @warning If a constraint is marked to be checked for feasibility but not to be enforced, a LP or pseudo solution
625  * may be declared feasible even if it violates this particular constraint.
626  * This constellation should only be used, if no LP or pseudo solution can violate the constraint -- e.g. if a
627  * local constraint is redundant due to the variable's local bounds.
628  */
629 extern
631  SCIP_CONS** cons, /**< pointer to constraint */
632  BMS_BLKMEM* blkmem, /**< block memory */
633  SCIP_SET* set, /**< global SCIP settings */
634  const char* name, /**< name of constraint */
635  SCIP_CONSHDLR* conshdlr, /**< constraint handler for this constraint */
636  SCIP_CONSDATA* consdata, /**< data for this specific constraint */
637  SCIP_Bool initial, /**< should the LP relaxation of constraint be in the initial LP?
638  * Usually set to TRUE. Set to FALSE for 'lazy constraints'. */
639  SCIP_Bool separate, /**< should the constraint be separated during LP processing?
640  * Usually set to TRUE. */
641  SCIP_Bool enforce, /**< should the constraint be enforced during node processing?
642  * TRUE for model constraints, FALSE for additional, redundant constraints. */
643  SCIP_Bool check, /**< should the constraint be checked for feasibility?
644  * TRUE for model constraints, FALSE for additional, redundant constraints. */
645  SCIP_Bool propagate, /**< should the constraint be propagated during node processing?
646  * Usually set to TRUE. */
647  SCIP_Bool local, /**< is constraint only valid locally?
648  * Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints. */
649  SCIP_Bool modifiable, /**< is constraint modifiable (subject to column generation)?
650  * Usually set to FALSE. In column generation applications, set to TRUE if pricing
651  * adds coefficients to this constraint. */
652  SCIP_Bool dynamic, /**< is constraint subject to aging?
653  * Usually set to FALSE. Set to TRUE for own cuts which
654  * are separated as constraints. */
655  SCIP_Bool removable, /**< should the relaxation be removed from the LP due to aging or cleanup?
656  * Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'. */
657  SCIP_Bool stickingatnode, /**< should the constraint always be kept at the node where it was added, even
658  * if it may be moved to a more global node?
659  * Usually set to FALSE. Set to TRUE to for constraints that represent node data. */
660  SCIP_Bool original, /**< is constraint belonging to the original problem? */
661  SCIP_Bool deleteconsdata /**< has the constraint data to be deleted if constraint is freed? */
662  );
663 
664 /** copies source constraint of source SCIP into the target constraint for the target SCIP, using the variable map for
665  * mapping the variables of the source SCIP to the variables of the target SCIP; if the copying process was successful
666  * a constraint is created and captured;
667  *
668  * @warning If a constraint is marked to be checked for feasibility but not to be enforced, an LP or pseudo solution
669  * may be declared feasible even if it violates this particular constraint.
670  * This constellation should only be used, if no LP or pseudo solution can violate the constraint -- e.g. if a
671  * local constraint is redundant due to the variable's local bounds.
672  */
673 extern
675  SCIP_CONS** cons, /**< pointer to store the created target constraint */
676  SCIP_SET* set, /**< global SCIP settings of the target SCIP */
677  const char* name, /**< name of constraint, or NULL if the name of the source constraint should be used */
678  SCIP* sourcescip, /**< source SCIP data structure */
679  SCIP_CONSHDLR* sourceconshdlr, /**< source constraint handler for this constraint */
680  SCIP_CONS* sourcecons, /**< source constraint of the source SCIP */
681  SCIP_HASHMAP* varmap, /**< a SCIP_HASHMAP mapping variables of the source SCIP to corresponding
682  * variables of the target SCIP */
683  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
684  * target constraints, must not be NULL! */
685  SCIP_Bool initial, /**< should the LP relaxation of constraint be in the initial LP? */
686  SCIP_Bool separate, /**< should the constraint be separated during LP processing? */
687  SCIP_Bool enforce, /**< should the constraint be enforced during node processing? */
688  SCIP_Bool check, /**< should the constraint be checked for feasibility? */
689  SCIP_Bool propagate, /**< should the constraint be propagated during node processing? */
690  SCIP_Bool local, /**< is constraint only valid locally? */
691  SCIP_Bool modifiable, /**< is constraint modifiable (subject to column generation)? */
692  SCIP_Bool dynamic, /**< is constraint subject to aging? */
693  SCIP_Bool removable, /**< should the relaxation be removed from the LP due to aging or cleanup? */
694  SCIP_Bool stickingatnode, /**< should the constraint always be kept at the node where it was added, even
695  * if it may be moved to a more global node? */
696  SCIP_Bool global, /**< create a global or a local copy? */
697  SCIP_Bool* valid /**< pointer to store whether the copying was valid or not */
698  );
699 
700 /** parses constraint information (in cip format) out of a string; if the parsing process was successful a constraint is
701  * created, captured, and inserted into the conss array of its constraint handler.
702  *
703  * @warning If a constraint is marked to be checked for feasibility but not to be enforced, an LP or pseudo solution
704  * may be declared feasible even if it violates this particular constraint.
705  * This constellation should only be used, if no LP or pseudo solution can violate the constraint -- e.g. if a
706  * local constraint is redundant due to the variable's local bounds.
707  */
708 extern
710  SCIP_CONS** cons, /**< pointer to constraint */
711  SCIP_SET* set, /**< global SCIP settings */
712  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler of target SCIP */
713  const char* str, /**< name of constraint */
714  SCIP_Bool initial, /**< should the LP relaxation of constraint be in the initial LP?
715  * Usually set to TRUE. Set to FALSE for 'lazy constraints'. */
716  SCIP_Bool separate, /**< should the constraint be separated during LP processing?
717  * Usually set to TRUE. */
718  SCIP_Bool enforce, /**< should the constraint be enforced during node processing?
719  * TRUE for model constraints, FALSE for additional, redundant constraints. */
720  SCIP_Bool check, /**< should the constraint be checked for feasibility?
721  * TRUE for model constraints, FALSE for additional, redundant constraints. */
722  SCIP_Bool propagate, /**< should the constraint be propagated during node processing?
723  * Usually set to TRUE. */
724  SCIP_Bool local, /**< is constraint only valid locally?
725  * Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints. */
726  SCIP_Bool modifiable, /**< is constraint modifiable (subject to column generation)?
727  * Usually set to FALSE. In column generation applications, set to TRUE if pricing
728  * adds coefficients to this constraint. */
729  SCIP_Bool dynamic, /**< is constraint subject to aging?
730  * Usually set to FALSE. Set to TRUE for own cuts which
731  * are separated as constraints. */
732  SCIP_Bool removable, /**< should the relaxation be removed from the LP due to aging or cleanup?
733  * Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'. */
734  SCIP_Bool stickingatnode, /**< should the constraint always be kept at the node where it was added, even
735  * if it may be moved to a more global node?
736  * Usually set to FALSE. Set to TRUE to for constraints that represent node data. */
737  SCIP_Bool* success /**< pointer store if the paring process was successful */
738  );
739 
740 /** change name of given constraint */
741 extern
743  SCIP_CONS* cons, /**< problem constraint */
744  BMS_BLKMEM* blkmem, /**< block memory buffer */
745  const char* name /**< new name of constraint */
746  );
747 
748 /** frees a constraint and removes it from the conss array of its constraint handler */
749 extern
751  SCIP_CONS** cons, /**< constraint to free */
752  BMS_BLKMEM* blkmem, /**< block memory buffer */
753  SCIP_SET* set /**< global SCIP settings */
754  );
755 
756 /** increases usage counter of constraint */
757 extern
758 void SCIPconsCapture(
759  SCIP_CONS* cons /**< constraint */
760  );
761 
762 /** decreases usage counter of constraint, and frees memory if necessary */
763 extern
765  SCIP_CONS** cons, /**< pointer to constraint */
766  BMS_BLKMEM* blkmem, /**< block memory */
767  SCIP_SET* set /**< global SCIP settings */
768  );
769 
770 
771 /** outputs constraint information to file stream */
772 extern
774  SCIP_CONS* cons, /**< constraint to print */
775  SCIP_SET* set, /**< global SCIP settings */
776  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
777  FILE* file /**< output file (or NULL for standard output) */
778  );
779 
780 /** checks single constraint for feasibility of the given solution */
781 extern
783  SCIP_CONS* cons, /**< constraint to check */
784  SCIP_SET* set, /**< global SCIP settings */
785  SCIP_SOL* sol, /**< primal CIP solution */
786  SCIP_Bool checkintegrality, /**< Has integrality to be checked? */
787  SCIP_Bool checklprows, /**< Do constraints represented by rows in the current LP have to be checked? */
788  SCIP_Bool printreason, /**< Should the reason for the violation be printed? */
789  SCIP_RESULT* result /**< pointer to store the result of the callback method */
790  );
791 
792 /** enforces single constraint for a given pseudo solution */
793 extern
795  SCIP_CONS* cons, /**< constraint to enforce */
796  SCIP_SET* set, /**< global SCIP settings */
797  SCIP_Bool solinfeasible, /**< was the solution already declared infeasible by a constraint handler? */
798  SCIP_Bool objinfeasible, /**< is the solution infeasible anyway due to violating lower objective bound? */
799  SCIP_RESULT* result /**< pointer to store the result of the callback method */
800  );
801 
802 /** enforces single constraint for a given LP solution */
803 extern
805  SCIP_CONS* cons, /**< constraint to enforce */
806  SCIP_SET* set, /**< global SCIP settings */
807  SCIP_Bool solinfeasible, /**< was the solution already declared infeasible by a constraint handler? */
808  SCIP_RESULT* result /**< pointer to store the result of the callback method */
809  );
810 
811 /** enforces single constraint for a given relaxation solution */
813  SCIP_CONS* cons, /**< constraint to enforce */
814  SCIP_SET* set, /**< global SCIP settings */
815  SCIP_SOL* sol, /**< solution to be enforced */
816  SCIP_Bool solinfeasible, /**< was the solution already declared infeasible by a constraint handler? */
817  SCIP_RESULT* result /**< pointer to store the result of the callback method */
818  );
819 
820 /** calls LP initialization method for single constraint */
821 extern
823  SCIP_CONS* cons, /**< constraint to initialize */
824  SCIP_SET* set, /**< global SCIP settings */
825  SCIP_Bool* infeasible /**< pointer to store whether infeasibility was detected while building the LP */
826  );
827 
828 /** calls separation method of single constraint for LP solution */
829 extern
831  SCIP_CONS* cons, /**< constraint to separate */
832  SCIP_SET* set, /**< global SCIP settings */
833  SCIP_RESULT* result /**< pointer to store the result of the separation call */
834  );
835 
836 /** calls separation method of single constraint for given primal solution */
837 extern
839  SCIP_CONS* cons, /**< constraint to separate */
840  SCIP_SET* set, /**< global SCIP settings */
841  SCIP_SOL* sol, /**< primal solution that should be separated */
842  SCIP_RESULT* result /**< pointer to store the result of the separation call */
843  );
844 
845 /** calls domain propagation method of single constraint */
846 extern
848  SCIP_CONS* cons, /**< constraint to propagate */
849  SCIP_SET* set, /**< global SCIP settings */
850  SCIP_PROPTIMING proptiming, /**< current point in the node solving loop */
851  SCIP_RESULT* result /**< pointer to store the result of the callback method */
852  );
853 
854 /** resolves propagation conflict of single constraint */
855 extern
857  SCIP_CONS* cons, /**< constraint to resolve conflict for */
858  SCIP_SET* set, /**< global SCIP settings */
859  SCIP_VAR* infervar, /**< the conflict variable whose bound change has to be resolved */
860  int inferinfo, /**< the user information passed to the corresponding SCIPinferVarLbCons() or SCIPinferVarUbCons() call */
861  SCIP_BOUNDTYPE boundtype, /**< the type of the changed bound (lower or upper bound) */
862  SCIP_BDCHGIDX* bdchgidx, /**< the index of the bound change, representing the point of time where the change took place */
863  SCIP_Real relaxedbd, /**< the relaxed bound which is sufficient to be explained */
864  SCIP_RESULT* result /**< pointer to store the result of the callback method */
865  );
866 
867 /** presolves single constraint */
868 extern
870  SCIP_CONS* cons, /**< constraint to presolve */
871  SCIP_SET* set, /**< global SCIP settings */
872  int nrounds, /**< number of presolving rounds already done */
873  SCIP_PRESOLTIMING timing, /**< current presolving timing */
874  int nnewfixedvars, /**< number of variables fixed since the last call to the presolving method */
875  int nnewaggrvars, /**< number of variables aggregated since the last call to the presolving method */
876  int nnewchgvartypes, /**< number of variable type changes since the last call to the presolving method */
877  int nnewchgbds, /**< number of variable bounds tightened since the last call to the presolving method */
878  int nnewholes, /**< number of domain holes added since the last call to the presolving method */
879  int nnewdelconss, /**< number of deleted constraints since the last call to the presolving method */
880  int nnewaddconss, /**< number of added constraints since the last call to the presolving method */
881  int nnewupgdconss, /**< number of upgraded constraints since the last call to the presolving method */
882  int nnewchgcoefs, /**< number of changed coefficients since the last call to the presolving method */
883  int nnewchgsides, /**< number of changed left or right hand sides since the last call to the presolving method */
884  int* nfixedvars, /**< pointer to count total number of variables fixed of all presolvers */
885  int* naggrvars, /**< pointer to count total number of variables aggregated of all presolvers */
886  int* nchgvartypes, /**< pointer to count total number of variable type changes of all presolvers */
887  int* nchgbds, /**< pointer to count total number of variable bounds tightened of all presolvers */
888  int* naddholes, /**< pointer to count total number of domain holes added of all presolvers */
889  int* ndelconss, /**< pointer to count total number of deleted constraints of all presolvers */
890  int* naddconss, /**< pointer to count total number of added constraints of all presolvers */
891  int* nupgdconss, /**< pointer to count total number of upgraded constraints of all presolvers */
892  int* nchgcoefs, /**< pointer to count total number of changed coefficients of all presolvers */
893  int* nchgsides, /**< pointer to count total number of changed left/right hand sides of all presolvers */
894  SCIP_RESULT* result /**< pointer to store the result of the callback method */
895  );
896 
897 /** calls constraint activation notification method of single constraint */
898 extern
900  SCIP_CONS* cons, /**< constraint to notify */
901  SCIP_SET* set /**< global SCIP settings */
902  );
903 
904 /** calls constraint deactivation notification method of single constraint */
905 extern
907  SCIP_CONS* cons, /**< constraint to notify */
908  SCIP_SET* set /**< global SCIP settings */
909  );
910 
911 /** method to collect the variables of a constraint
912  *
913  * If the number of variables is greater than the available slots in the variable array, nothing happens except that
914  * the success point is set to FALSE. With the method SCIPgetConsNVars() it is possible to get the number of variables
915  * a constraint has in its scope.
916  *
917  * @note The success pointer indicates if all variables were copied into the vars arrray.
918  *
919  * @note It might be that a constraint handler does not support this functionality, in that case the success pointer is
920  * set to FALSE.
921  */
922 extern
924  SCIP_CONS* cons, /**< constraint to print */
925  SCIP_SET* set, /**< global SCIP settings */
926  SCIP_VAR** vars, /**< array to store the involved variable of the constraint */
927  int varssize, /**< available slots in vars array which is needed to check if the array is large enough */
928  SCIP_Bool* success /**< pointer to store whether the variables are successfully copied */
929  );
930 
931 /** method to collect the number of variables of a constraint
932  *
933  * @note The success pointer indicates if the contraint handler was able to return the number of variables
934  *
935  * @note It might be that a constraint handler does not support this functionality, in that case the success pointer is
936  * set to FALSE
937  */
938 extern
940  SCIP_CONS* cons, /**< constraint to print */
941  SCIP_SET* set, /**< global SCIP settings */
942  int* nvars, /**< pointer to store the number of variables */
943  SCIP_Bool* success /**< pointer to store whether the constraint successfully returned the number of variables */
944  );
945 
946 /** globally removes constraint from all subproblems; removes constraint from the constraint set change data of the
947  * node, where it was created, or from the problem, if it was a problem constraint
948  */
949 extern
951  SCIP_CONS* cons, /**< constraint to delete */
952  BMS_BLKMEM* blkmem, /**< block memory */
953  SCIP_SET* set, /**< global SCIP settings */
954  SCIP_STAT* stat, /**< dynamic problem statistics */
955  SCIP_PROB* prob, /**< problem data */
956  SCIP_REOPT* reopt /**< reoptimization data */
957  );
958 
959 /** gets and captures transformed constraint of a given constraint; if the constraint is not yet transformed,
960  * a new transformed constraint for this constraint is created
961  */
962 extern
964  SCIP_CONS* origcons, /**< original constraint */
965  BMS_BLKMEM* blkmem, /**< block memory buffer */
966  SCIP_SET* set, /**< global SCIP settings */
967  SCIP_CONS** transcons /**< pointer to store the transformed constraint */
968  );
969 
970 /** sets the initial flag of the given constraint */
971 extern
973  SCIP_CONS* cons, /**< constraint */
974  SCIP_SET* set, /**< global SCIP settings */
975  SCIP_STAT* stat, /**< dynamic problem statistics */
976  SCIP_Bool initial /**< new value */
977  );
978 
979 /** sets the separate flag of the given constraint */
980 extern
982  SCIP_CONS* cons, /**< constraint */
983  SCIP_SET* set, /**< global SCIP settings */
984  SCIP_Bool separate /**< new value */
985  );
986 
987 /** sets the enforce flag of the given constraint */
988 extern
990  SCIP_CONS* cons, /**< constraint */
991  SCIP_SET* set, /**< global SCIP settings */
992  SCIP_Bool enforce /**< new value */
993  );
994 
995 /** sets the check flag of the given constraint */
996 extern
998  SCIP_CONS* cons, /**< constraint */
999  SCIP_SET* set, /**< global SCIP settings */
1000  SCIP_Bool check /**< new value */
1001  );
1002 
1003 /** sets the propagate flag of the given constraint */
1004 extern
1006  SCIP_CONS* cons, /**< constraint */
1007  SCIP_SET* set, /**< global SCIP settings */
1008  SCIP_Bool propagate /**< new value */
1009  );
1010 
1011 /** sets the local flag of the given constraint */
1012 extern
1013 void SCIPconsSetLocal(
1014  SCIP_CONS* cons, /**< constraint */
1015  SCIP_Bool local /**< new value */
1016  );
1017 
1018 /** sets the modifiable flag of the given constraint */
1019 extern
1021  SCIP_CONS* cons, /**< constraint */
1022  SCIP_Bool modifiable /**< new value */
1023  );
1024 
1025 /** sets the dynamic flag of the given constraint */
1026 extern
1027 void SCIPconsSetDynamic(
1028  SCIP_CONS* cons, /**< constraint */
1029  SCIP_Bool dynamic /**< new value */
1030  );
1031 
1032 /** sets the removable flag of the given constraint */
1033 extern
1035  SCIP_CONS* cons, /**< constraint */
1036  SCIP_Bool removable /**< new value */
1037  );
1038 
1039 /** sets the stickingatnode flag of the given constraint */
1040 extern
1042  SCIP_CONS* cons, /**< constraint */
1043  SCIP_Bool stickingatnode /**< new value */
1044  );
1045 
1046 /** gives the constraint a new name; ATTENTION: to old pointer is over written that might
1047  * result in a memory leakage */
1048 extern
1050  SCIP_CONS* cons, /**< constraint */
1051  const char* name /**< new name of constraint */
1052  );
1053 
1054 /** gets associated transformed constraint of an original constraint, or NULL if no associated transformed constraint
1055  * exists
1056  */
1057 extern
1059  SCIP_CONS* cons /**< constraint */
1060  );
1061 
1062 /** activates constraint or marks constraint to be activated in next update */
1063 extern
1065  SCIP_CONS* cons, /**< constraint */
1066  SCIP_SET* set, /**< global SCIP settings */
1067  SCIP_STAT* stat, /**< dynamic problem statistics */
1068  int depth, /**< depth in the tree where the constraint activation takes place, or -1 for global problem */
1069  SCIP_Bool focusnode /**< does the constraint activation take place at the focus node? */
1070  );
1071 
1072 /** deactivates constraint or marks constraint to be deactivated in next update */
1073 extern
1075  SCIP_CONS* cons, /**< constraint */
1076  SCIP_SET* set, /**< global SCIP settings */
1077  SCIP_STAT* stat /**< dynamic problem statistics */
1078  );
1079 
1080 /** enables constraint's separation, enforcing, and propagation capabilities or marks them to be enabled in next update */
1081 extern
1083  SCIP_CONS* cons, /**< constraint */
1084  SCIP_SET* set, /**< global SCIP settings */
1085  SCIP_STAT* stat /**< dynamic problem statistics */
1086  );
1087 
1088 /** disables constraint's separation, enforcing, and propagation capabilities or marks them to be disabled in next update */
1089 extern
1091  SCIP_CONS* cons, /**< constraint */
1092  SCIP_SET* set, /**< global SCIP settings */
1093  SCIP_STAT* stat /**< dynamic problem statistics */
1094  );
1095 
1096 /** enables constraint's separation capabilities or marks them to be enabled in next update */
1097 extern
1099  SCIP_CONS* cons, /**< constraint */
1100  SCIP_SET* set /**< global SCIP settings */
1101  );
1102 
1103 /** disables constraint's separation capabilities or marks them to be disabled in next update */
1104 extern
1106  SCIP_CONS* cons, /**< constraint */
1107  SCIP_SET* set /**< global SCIP settings */
1108  );
1109 
1110 /** enables constraint's propagation capabilities or marks them to be enabled in next update */
1111 extern
1113  SCIP_CONS* cons, /**< constraint */
1114  SCIP_SET* set /**< global SCIP settings */
1115  );
1116 
1117 /** disables constraint's propagation capabilities or marks them to be disabled in next update */
1118 extern
1120  SCIP_CONS* cons, /**< constraint */
1121  SCIP_SET* set /**< global SCIP settings */
1122  );
1123 
1124 /** marks the constraint to be a conflict */
1125 extern
1127  SCIP_CONS* cons /**< constraint */
1128  );
1129 
1130 /** marks the constraint to be propagated (update might be delayed) */
1131 extern
1133  SCIP_CONS* cons, /**< constraint */
1134  SCIP_SET* set /**< global SCIP settings */
1135  );
1136 
1137 /** unmarks the constraint to be propagated (update might be delayed) */
1138 extern
1140  SCIP_CONS* cons, /**< constraint */
1141  SCIP_SET* set /**< global SCIP settings */
1142  );
1143 
1144 /** adds given value to age of constraint, but age can never become negative;
1145  * should be called
1146  * - in constraint separation, if no cut was found for this constraint,
1147  * - in constraint enforcing, if constraint was feasible, and
1148  * - in constraint propagation, if no domain reduction was deduced;
1149  * if it's age exceeds the constraint age limit, makes constraint obsolete or marks constraint to be made obsolete
1150  * in next update
1151  */
1152 extern
1154  SCIP_CONS* cons, /**< constraint */
1155  BMS_BLKMEM* blkmem, /**< block memory */
1156  SCIP_SET* set, /**< global SCIP settings */
1157  SCIP_STAT* stat, /**< dynamic problem statistics */
1158  SCIP_PROB* prob, /**< problem data */
1159  SCIP_Real deltaage, /**< value to add to the constraint's age */
1160  SCIP_REOPT* reopt /**< reoptimization data */
1161  );
1162 
1163 /** increases age of constraint by 1.0;
1164  * should be called
1165  * - in constraint separation, if no cut was found for this constraint,
1166  * - in constraint enforcing, if constraint was feasible, and
1167  * - in constraint propagation, if no domain reduction was deduced;
1168  * if it's age exceeds the constraint age limit, makes constraint obsolete or marks constraint to be made obsolete
1169  * in next update
1170  */
1171 extern
1173  SCIP_CONS* cons, /**< constraint */
1174  BMS_BLKMEM* blkmem, /**< block memory */
1175  SCIP_SET* set, /**< global SCIP settings */
1176  SCIP_STAT* stat, /**< dynamic problem statistics */
1177  SCIP_PROB* prob, /**< problem data */
1178  SCIP_REOPT* reopt /**< reoptimization data */
1179  );
1180 
1181 /** resets age of constraint to zero;
1182  * should be called
1183  * - in constraint separation, if a cut was found for this constraint,
1184  * - in constraint enforcing, if the constraint was violated, and
1185  * - in constraint propagation, if a domain reduction was deduced;
1186  * if it was obsolete, makes constraint useful again or marks constraint to be made useful again in next update
1187  */
1188 extern
1190  SCIP_CONS* cons, /**< constraint */
1191  SCIP_SET* set /**< global SCIP settings */
1192  );
1193 
1194 /** resolves the given conflicting bound, that was deduced by the given constraint, by putting all "reason" bounds
1195  * leading to the deduction into the conflict queue with calls to SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(),
1196  * SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), or SCIPaddConflictBinvar();
1197  *
1198  * @note it is sufficient to explain the relaxed bound change
1199  */
1200 extern
1202  SCIP_CONS* cons, /**< constraint that deduced the assignment */
1203  SCIP_SET* set, /**< global SCIP settings */
1204  SCIP_VAR* infervar, /**< variable whose bound was deduced by the constraint */
1205  int inferinfo, /**< user inference information attached to the bound change */
1206  SCIP_BOUNDTYPE inferboundtype, /**< bound that was deduced (lower or upper bound) */
1207  SCIP_BDCHGIDX* bdchgidx, /**< bound change index, representing the point of time where change took place */
1208  SCIP_Real relaxedbd, /**< the relaxed bound */
1209  SCIP_RESULT* result /**< pointer to store the result of the callback method */
1210  );
1211 
1212 /** adds given values to lock status of the constraint and updates the locks of the given locktype of the involved variables */
1213 extern
1215  SCIP_CONS* cons, /**< constraint */
1216  SCIP_SET* set, /**< global SCIP settings */
1217  SCIP_LOCKTYPE locktype, /**< type of variable locks */
1218  int nlockspos, /**< increase in number of rounding locks for constraint */
1219  int nlocksneg /**< increase in number of rounding locks for constraint's negation */
1220  );
1221 
1222 /*
1223  * Hash functions
1224  */
1225 
1226 /** gets the key (i.e. the name) of the given constraint */
1227 extern
1228 SCIP_DECL_HASHGETKEY(SCIPhashGetKeyCons);
1229 
1230 /*
1231  * method for arrays of contraint handlers
1232  */
1233 
1234 /** stores all constraints marked for propagation away when probing is started */
1235 extern
1237  SCIP_SET* set, /**< global SCIP settings */
1238  SCIP_CONSHDLR** conshdlrs, /**< all constraint handlers */
1239  int nconshdlrs /**< number of contraint handlers */
1240  );
1241 
1242 /** reset all constraints marked for propagation when probing was finished */
1243 extern
1245  SCIP_SET* set, /**< global SCIP settings */
1246  BMS_BLKMEM* blkmem, /**< block memory */
1247  SCIP_CONSHDLR** conshdlrs, /**< all constraint handlers */
1248  int nconshdlrs /**< number of contraint handlers */
1249  );
1250 
1251 #ifdef __cplusplus
1252 }
1253 #endif
1254 
1255 #endif
enum SCIP_Result SCIP_RESULT
Definition: type_result.h:52
void SCIPconshdlrSetInitpre(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITPRE((*consinitpre)))
Definition: cons.c:4353
SCIP_RETCODE SCIPconsEnforelax(SCIP_CONS *cons, SCIP_SET *set, SCIP_SOL *sol, SCIP_Bool solinfeasible, SCIP_RESULT *result)
Definition: cons.c:7412
enum SCIP_BoundType SCIP_BOUNDTYPE
Definition: type_lp.h:50
void SCIPconshdlrSetInitsol(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITSOL((*consinitsol)))
Definition: cons.c:4331
SCIP_RETCODE SCIPconsEnable(SCIP_CONS *cons, SCIP_SET *set, SCIP_STAT *stat)
Definition: cons.c:6799
SCIP_RETCODE SCIPconshdlrInitsol(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
Definition: cons.c:2684
SCIP_RETCODE SCIPconsFree(SCIP_CONS **cons, BMS_BLKMEM *blkmem, SCIP_SET *set)
Definition: cons.c:6129
void SCIPconshdlrSetResprop(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSRESPROP((*consresprop)))
Definition: cons.c:4437
type definitions for miscellaneous datastructures
timing definitions for SCIP
SCIP_RETCODE SCIPconshdlrSeparateSol(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_SEPASTORE *sepastore, SCIP_SOL *sol, int depth, SCIP_Bool execdelayed, SCIP_RESULT *result)
Definition: cons.c:3025
SCIP_RETCODE SCIPconshdlrLockVars(SCIP_CONSHDLR *conshdlr, SCIP_SET *set)
Definition: cons.c:4161
SCIP_RETCODE SCIPconsAddLocks(SCIP_CONS *cons, SCIP_SET *set, SCIP_LOCKTYPE locktype, int nlockspos, int nlocksneg)
Definition: cons.c:7242
void SCIPconsSetLocal(SCIP_CONS *cons, SCIP_Bool local)
Definition: cons.c:6640
void SCIPconsSetNamePointer(SCIP_CONS *cons, const char *name)
Definition: cons.c:6698
SCIP_DECL_CONSSEPALP(ConshdlrSubtour::scip_sepalp)
SCIP_RETCODE SCIPconssetchgAddDisabledCons(SCIP_CONSSETCHG **conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_CONS *cons)
Definition: cons.c:5417
#define SCIP_DECL_CONSINITPRE(x)
Definition: type_cons.h:141
SCIP_RETCODE SCIPconsEnableSeparation(SCIP_CONS *cons, SCIP_SET *set)
Definition: cons.c:6866
#define SCIP_DECL_CONSGETDIVEBDCHGS(x)
Definition: type_cons.h:904
#define SCIP_DECL_CONSPRESOL(x)
Definition: type_cons.h:545
SCIP_RETCODE SCIPconshdlrFree(SCIP_CONSHDLR **conshdlr, SCIP_SET *set)
Definition: cons.c:2343
SCIP_RETCODE SCIPconshdlrCheck(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_SOL *sol, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool printreason, SCIP_Bool completely, SCIP_RESULT *result)
Definition: cons.c:3754
SCIP_RETCODE SCIPconshdlrsStorePropagationStatus(SCIP_SET *set, SCIP_CONSHDLR **conshdlrs, int nconshdlrs)
Definition: cons.c:7815
SCIP_RETCODE SCIPconsIncAge(SCIP_CONS *cons, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_REOPT *reopt)
Definition: cons.c:7120
SCIP_DECL_CONSENFOPS(ConshdlrSubtour::scip_enfops)
SCIP_CONS * SCIPconsGetTransformed(SCIP_CONS *cons)
Definition: cons.c:6712
SCIP_RETCODE SCIPconsSetEnforced(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool enforce)
Definition: cons.c:6522
SCIP_RETCODE SCIPconsDeactive(SCIP_CONS *cons, SCIP_SET *set)
Definition: cons.c:7746
SCIP_RETCODE SCIPconsEnfolp(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool solinfeasible, SCIP_RESULT *result)
Definition: cons.c:7370
#define SCIP_DECL_CONSRESPROP(x)
Definition: type_cons.h:596
SCIP_RETCODE SCIPconssetchgFree(SCIP_CONSSETCHG **conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set)
Definition: cons.c:5297
datastructures for constraints and constraint handlers
SCIP_RETCODE SCIPconsActivate(SCIP_CONS *cons, SCIP_SET *set, SCIP_STAT *stat, int depth, SCIP_Bool focusnode)
Definition: cons.c:6722
SCIP_RETCODE SCIPconshdlrEnforcePseudoSol(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_BRANCHCAND *branchcand, SCIP_Bool solinfeasible, SCIP_Bool objinfeasible, SCIP_Bool forced, SCIP_RESULT *result)
Definition: cons.c:3558
SCIP_RETCODE SCIPconshdlrCopyInclude(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, SCIP_Bool *valid)
Definition: cons.c:1968
void SCIPconshdlrSetGetDiveBdChgs(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs)))
Definition: cons.c:4547
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:53
#define SCIP_DECL_CONSGETNVARS(x)
Definition: type_cons.h:869
SCIP_RETCODE SCIPconssetchgApply(SCIP_CONSSETCHG *conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, int depth, SCIP_Bool focusnode)
Definition: cons.c:5535
SCIP_RETCODE SCIPconsResolvePropagation(SCIP_CONS *cons, SCIP_SET *set, SCIP_VAR *infervar, int inferinfo, SCIP_BOUNDTYPE inferboundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedbd, SCIP_RESULT *result)
Definition: cons.c:7182
type definitions for global SCIP settings
SCIP_RETCODE SCIPconsSepasol(SCIP_CONS *cons, SCIP_SET *set, SCIP_SOL *sol, SCIP_RESULT *result)
Definition: cons.c:7523
SCIP_RETCODE SCIPconsResprop(SCIP_CONS *cons, SCIP_SET *set, SCIP_VAR *infervar, int inferinfo, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedbd, SCIP_RESULT *result)
Definition: cons.c:7606
#define SCIP_DECL_CONSEXITSOL(x)
Definition: type_cons.h:201
static GRAPHNODE ** active
SCIP_RETCODE SCIPconsUnmarkPropagate(SCIP_CONS *cons, SCIP_SET *set)
Definition: cons.c:7024
void SCIPconshdlrSetDeactive(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDEACTIVE((*consdeactive)))
Definition: cons.c:4459
void SCIPconshdlrSetExitsol(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSEXITSOL((*consexitsol)))
Definition: cons.c:4342
type definitions for return codes for SCIP methods
SCIP_RETCODE SCIPconsEnablePropagation(SCIP_CONS *cons, SCIP_SET *set)
Definition: cons.c:6924
SCIP_DECL_CONSSEPASOL(ConshdlrSubtour::scip_sepasol)
SCIP_DECL_CONSDELETE(ConshdlrSubtour::scip_delete)
SCIP_RETCODE SCIPconsDelete(SCIP_CONS *cons, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_REOPT *reopt)
Definition: cons.c:6343
SCIP_RETCODE SCIPconsTransform(SCIP_CONS *origcons, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_CONS **transcons)
Definition: cons.c:6403
type definitions for collecting reoptimization information
SCIP_RETCODE SCIPconshdlrExit(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
Definition: cons.c:2501
SCIP_RETCODE SCIPconshdlrCreate(SCIP_CONSHDLR **conshdlr, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, int sepapriority, int enfopriority, int checkpriority, int sepafreq, int propfreq, int eagerfreq, int maxprerounds, SCIP_Bool delaysepa, SCIP_Bool delayprop, SCIP_Bool needscons, SCIP_PROPTIMING proptiming, SCIP_PRESOLTIMING presoltiming, SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), SCIP_DECL_CONSFREE((*consfree)), SCIP_DECL_CONSINIT((*consinit)), SCIP_DECL_CONSEXIT((*consexit)), SCIP_DECL_CONSINITPRE((*consinitpre)), SCIP_DECL_CONSEXITPRE((*consexitpre)), SCIP_DECL_CONSINITSOL((*consinitsol)), SCIP_DECL_CONSEXITSOL((*consexitsol)), SCIP_DECL_CONSDELETE((*consdelete)), SCIP_DECL_CONSTRANS((*constrans)), SCIP_DECL_CONSINITLP((*consinitlp)), SCIP_DECL_CONSSEPALP((*conssepalp)), SCIP_DECL_CONSSEPASOL((*conssepasol)), SCIP_DECL_CONSENFOLP((*consenfolp)), SCIP_DECL_CONSENFORELAX((*consenforelax)), SCIP_DECL_CONSENFOPS((*consenfops)), SCIP_DECL_CONSCHECK((*conscheck)), SCIP_DECL_CONSPROP((*consprop)), SCIP_DECL_CONSPRESOL((*conspresol)), SCIP_DECL_CONSRESPROP((*consresprop)), SCIP_DECL_CONSLOCK((*conslock)), SCIP_DECL_CONSACTIVE((*consactive)), SCIP_DECL_CONSDEACTIVE((*consdeactive)), SCIP_DECL_CONSENABLE((*consenable)), SCIP_DECL_CONSDISABLE((*consdisable)), SCIP_DECL_CONSDELVARS((*consdelvars)), SCIP_DECL_CONSPRINT((*consprint)), SCIP_DECL_CONSCOPY((*conscopy)), SCIP_DECL_CONSPARSE((*consparse)), SCIP_DECL_CONSGETVARS((*consgetvars)), SCIP_DECL_CONSGETNVARS((*consgetnvars)), SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs)), SCIP_CONSHDLRDATA *conshdlrdata)
Definition: cons.c:2268
SCIP_RETCODE SCIPconsParse(SCIP_CONS **cons, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *str, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode, SCIP_Bool *success)
Definition: cons.c:6002
#define SCIP_DECL_CONSINITLP(x)
Definition: type_cons.h:244
type definitions for branching rules
type definitions for problem statistics
SCIP_DECL_CONSENFOLP(ConshdlrSubtour::scip_enfolp)
void SCIPconshdlrSetExit(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSEXIT((*consexit)))
Definition: cons.c:4320
type definitions for LP management
SCIP_DECL_CONSCHECK(ConshdlrSubtour::scip_check)
SCIP_RETCODE SCIPconsDisable(SCIP_CONS *cons, SCIP_SET *set, SCIP_STAT *stat)
Definition: cons.c:6832
#define SCIP_DECL_CONSINITSOL(x)
Definition: type_cons.h:186
SCIP_RETCODE SCIPconshdlrPresolve(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PRESOLTIMING timing, int nrounds, int *nfixedvars, int *naggrvars, int *nchgvartypes, int *nchgbds, int *naddholes, int *ndelconss, int *naddconss, int *nupgdconss, int *nchgcoefs, int *nchgsides, SCIP_RESULT *result)
Definition: cons.c:3987
void SCIPconshdlrSetActive(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSACTIVE((*consactive)))
Definition: cons.c:4448
public methods for managing constraints
SCIP_RETCODE SCIPconshdlrInitLP(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_Bool initkeptconss, SCIP_Bool *cutoff)
Definition: cons.c:2761
enum SCIP_LockType SCIP_LOCKTYPE
Definition: type_var.h:87
SCIP_RETCODE SCIPconshdlrsResetPropagationStatus(SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_CONSHDLR **conshdlrs, int nconshdlrs)
Definition: cons.c:7855
SCIP_RETCODE SCIPconshdlrPropagate(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, int depth, SCIP_Bool fullpropagation, SCIP_Bool execdelayed, SCIP_Bool instrongbranching, SCIP_PROPTIMING proptiming, SCIP_RESULT *result)
Definition: cons.c:3816
#define SCIP_DECL_CONSPARSE(x)
Definition: type_cons.h:829
SCIP_RETCODE SCIPconsSetPropagated(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool propagate)
Definition: cons.c:6605
SCIP_RETCODE SCIPconsRelease(SCIP_CONS **cons, BMS_BLKMEM *blkmem, SCIP_SET *set)
Definition: cons.c:6196
void SCIPconshdlrSetDelete(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDELETE((*consdelete)))
Definition: cons.c:4404
#define SCIP_DECL_CONSDEACTIVE(x)
Definition: type_cons.h:690
SCIP_RETCODE SCIPconsAddAge(SCIP_CONS *cons, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_Real deltaage, SCIP_REOPT *reopt)
Definition: cons.c:7061
void SCIPconshdlrSetCopy(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), SCIP_DECL_CONSCOPY((*conscopy)))
Definition: cons.c:4283
void SCIPconshdlrSetParse(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPARSE((*consparse)))
Definition: cons.c:4514
SCIP_DECL_CONSTRANS(ConshdlrSubtour::scip_trans)
SCIP_RETCODE SCIPconshdlrInit(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
Definition: cons.c:2388
SCIP_DECL_HASHGETKEY(SCIPhashGetKeyCons)
Definition: cons.c:7776
SCIP_RETCODE SCIPconshdlrSeparateLP(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_SEPASTORE *sepastore, int depth, SCIP_Bool execdelayed, SCIP_RESULT *result)
Definition: cons.c:2868
#define SCIP_DECL_CONSDISABLE(x)
Definition: type_cons.h:720
SCIP_DECL_CONSDELVARS(ConshdlrSubtour::scip_delvars)
unsigned int SCIP_PRESOLTIMING
Definition: type_timing.h:52
type definitions for problem variables
#define SCIP_DECL_CONSENABLE(x)
Definition: type_cons.h:705
SCIP_RETCODE SCIPconshdlrSetPresol(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPRESOL((*conspresol)), int maxprerounds, SCIP_PRESOLTIMING presoltiming)
Definition: cons.c:4375
type definitions for storing separated cuts
struct SCIP_ConsData SCIP_CONSDATA
Definition: type_cons.h:51
SCIP_RETCODE SCIPconsPresol(SCIP_CONS *cons, SCIP_SET *set, int nrounds, SCIP_PRESOLTIMING timing, int nnewfixedvars, int nnewaggrvars, int nnewchgvartypes, int nnewchgbds, int nnewholes, int nnewdelconss, int nnewaddconss, int nnewupgdconss, int nnewchgcoefs, int nnewchgsides, int *nfixedvars, int *naggrvars, int *nchgvartypes, int *nchgbds, int *naddholes, int *ndelconss, int *naddconss, int *nupgdconss, int *nchgcoefs, int *nchgsides, SCIP_RESULT *result)
Definition: cons.c:7648
SCIP_RETCODE SCIPconsResetAge(SCIP_CONS *cons, SCIP_SET *set)
Definition: cons.c:7141
#define SCIP_DECL_CONSGETVARS(x)
Definition: type_cons.h:851
#define SCIP_DECL_CONSEXIT(x)
Definition: type_cons.h:121
void SCIPconshdlrSetTrans(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSTRANS((*constrans)))
Definition: cons.c:4415
SCIP_RETCODE SCIPconsSetInitial(SCIP_CONS *cons, SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool initial)
Definition: cons.c:6453
#define SCIP_Bool
Definition: def.h:69
SCIP_RETCODE SCIPconshdlrExitpre(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
Definition: cons.c:2644
SCIP_DECL_CONSPROP(ConshdlrSubtour::scip_prop)
SCIP_RETCODE SCIPconsDisableSeparation(SCIP_CONS *cons, SCIP_SET *set)
Definition: cons.c:6896
SCIP_RETCODE SCIPconsActive(SCIP_CONS *cons, SCIP_SET *set)
Definition: cons.c:7722
SCIP_RETCODE SCIPconsDeactivate(SCIP_CONS *cons, SCIP_SET *set, SCIP_STAT *stat)
Definition: cons.c:6764
void SCIPconsCapture(SCIP_CONS *cons)
Definition: cons.c:6184
void SCIPconshdlrEnableOrDisableClocks(SCIP_CONSHDLR *conshdlr, SCIP_Bool enable)
Definition: cons.c:4647
#define SCIP_DECL_CONSEXITPRE(x)
Definition: type_cons.h:165
SCIP_RETCODE SCIPconssetchgMakeGlobal(SCIP_CONSSETCHG **conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_REOPT *reopt)
Definition: cons.c:5708
SCIP_RETCODE SCIPconssetchgUndo(SCIP_CONSSETCHG *conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
Definition: cons.c:5622
SCIP_RETCODE SCIPconshdlrInitpre(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
Definition: cons.c:2544
SCIP_RETCODE SCIPconssetchgAddAddedCons(SCIP_CONSSETCHG **conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_CONS *cons, int depth, SCIP_Bool focusnode, SCIP_Bool active)
Definition: cons.c:5371
void SCIPconshdlrSetDelvars(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDELVARS((*consdelvars)))
Definition: cons.c:4492
SCIP_RETCODE SCIPconsPrint(SCIP_CONS *cons, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, FILE *file)
Definition: cons.c:6236
void SCIPconshdlrSetExitpre(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSEXITPRE((*consexitpre)))
Definition: cons.c:4364
type definitions for branch and bound tree
SCIP_RETCODE SCIPconsDisablePropagation(SCIP_CONS *cons, SCIP_SET *set)
Definition: cons.c:6954
SCIP_RETCODE SCIPconshdlrGetDiveBoundChanges(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, SCIP_DIVESET *diveset, SCIP_SOL *sol, SCIP_Bool *success, SCIP_Bool *infeasible)
Definition: cons.c:3531
SCIP_RETCODE SCIPconshdlrUnlockVars(SCIP_CONSHDLR *conshdlr, SCIP_SET *set)
Definition: cons.c:4176
type definitions for storing primal CIP solutions
type definitions for storing and manipulating the main problem
SCIP_RETCODE SCIPconsCopy(SCIP_CONS **cons, SCIP_SET *set, const char *name, SCIP *sourcescip, SCIP_CONSHDLR *sourceconshdlr, SCIP_CONS *sourcecons, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode, SCIP_Bool global, SCIP_Bool *valid)
Definition: cons.c:5946
void SCIPconshdlrSetEnable(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSENABLE((*consenable)))
Definition: cons.c:4470
void SCIPconshdlrSetGetVars(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETVARS((*consgetvars)))
Definition: cons.c:4525
SCIP_RETCODE SCIPconsProp(SCIP_CONS *cons, SCIP_SET *set, SCIP_PROPTIMING proptiming, SCIP_RESULT *result)
Definition: cons.c:7566
SCIP_RETCODE SCIPconsInitlp(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool *infeasible)
Definition: cons.c:7456
SCIP_RETCODE SCIPconshdlrDelVars(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
Definition: cons.c:4130
SCIP_RETCODE SCIPconsSepalp(SCIP_CONS *cons, SCIP_SET *set, SCIP_RESULT *result)
Definition: cons.c:7482
void SCIPconsSetModifiable(SCIP_CONS *cons, SCIP_Bool modifiable)
Definition: cons.c:6653
type definitions for block memory pools and memory buffers
SCIP_RETCODE SCIPconsMarkPropagate(SCIP_CONS *cons, SCIP_SET *set)
Definition: cons.c:6994
SCIP_RETCODE SCIPconshdlrEnforceRelaxSol(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_SEPASTORE *sepastore, SCIP_SOL *relaxsol, SCIP_Bool solinfeasible, SCIP_RESULT *result)
Definition: cons.c:3154
unsigned int SCIP_PROPTIMING
Definition: type_timing.h:66
SCIP_RETCODE SCIPconshdlrEnforceLPSol(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_SEPASTORE *sepastore, SCIP_Bool solinfeasible, SCIP_RESULT *result)
Definition: cons.c:3353
SCIP_RETCODE SCIPconsGetNVars(SCIP_CONS *cons, SCIP_SET *set, int *nvars, SCIP_Bool *success)
Definition: cons.c:6311
SCIP_RETCODE SCIPconsChgName(SCIP_CONS *cons, BMS_BLKMEM *blkmem, const char *name)
Definition: cons.c:6109
SCIP_RETCODE SCIPconsSetChecked(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool check)
Definition: cons.c:6557
#define SCIP_DECL_CONSFREE(x)
Definition: type_cons.h:101
SCIP_RETCODE SCIPconsEnfops(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool solinfeasible, SCIP_Bool objinfeasible, SCIP_RESULT *result)
Definition: cons.c:7326
SCIP_RETCODE SCIPconsCheck(SCIP_CONS *cons, SCIP_SET *set, SCIP_SOL *sol, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool printreason, SCIP_RESULT *result)
Definition: cons.c:7288
void SCIPconshdlrSetPrint(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPRINT((*consprint)))
Definition: cons.c:4503
void SCIPconshdlrIncNCutsFound(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4877
#define SCIP_DECL_CONSINIT(x)
Definition: type_cons.h:111
SCIP_DECL_CONSLOCK(ConshdlrSubtour::scip_lock)
#define SCIP_DECL_CONSENFORELAX(x)
Definition: type_cons.h:373
#define SCIP_Real
Definition: def.h:157
SCIP_DECL_CONSPRINT(ConshdlrSubtour::scip_print)
result codes for SCIP callback methods
void SCIPconshdlrSetInitlp(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITLP((*consinitlp)))
Definition: cons.c:4426
void SCIPconsSetRemovable(SCIP_CONS *cons, SCIP_Bool removable)
Definition: cons.c:6675
SCIP_RETCODE SCIPconsCreate(SCIP_CONS **cons, BMS_BLKMEM *blkmem, SCIP_SET *set, const char *name, SCIP_CONSHDLR *conshdlr, SCIP_CONSDATA *consdata, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode, SCIP_Bool original, SCIP_Bool deleteconsdata)
Definition: cons.c:5804
#define SCIP_DECL_CONSACTIVE(x)
Definition: type_cons.h:675
void SCIPconshdlrSetInit(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINIT((*consinit)))
Definition: cons.c:4309
void SCIPconsSetDynamic(SCIP_CONS *cons, SCIP_Bool dynamic)
Definition: cons.c:6664
void SCIPconsSetStickingAtNode(SCIP_CONS *cons, SCIP_Bool stickingatnode)
Definition: cons.c:6686
void SCIPconshdlrIncNAppliedCuts(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4867
#define SCIP_DECL_CONSHDLRCOPY(x)
Definition: type_cons.h:93
struct SCIP_ConshdlrData SCIP_CONSHDLRDATA
Definition: type_cons.h:50
SCIP_DECL_CONSCOPY(ConshdlrSubtour::scip_copy)
void SCIPconsMarkConflict(SCIP_CONS *cons)
Definition: cons.c:6984
SCIP_RETCODE SCIPconsGetVars(SCIP_CONS *cons, SCIP_SET *set, SCIP_VAR **vars, int varssize, SCIP_Bool *success)
Definition: cons.c:6275
SCIP_RETCODE SCIPconsSetSeparated(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool separate)
Definition: cons.c:6487
common defines and data types used in all packages of SCIP
struct BMS_BlkMem BMS_BLKMEM
Definition: memory.h:426
SCIP_RETCODE SCIPconshdlrExitsol(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool restart)
Definition: cons.c:2724
void SCIPconshdlrSetDisable(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDISABLE((*consdisable)))
Definition: cons.c:4481
type definitions for constraints and constraint handlers
void SCIPconshdlrSetGetNVars(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETNVARS((*consgetnvars)))
Definition: cons.c:4536
void SCIPconshdlrSetFree(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSFREE((*consfree)))
Definition: cons.c:4298
memory allocation routines