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-2023 Zuse Institute Berlin (ZIB) */
7 /* */
8 /* Licensed under the Apache License, Version 2.0 (the "License"); */
9 /* you may not use this file except in compliance with the License. */
10 /* You may obtain a copy of the License at */
11 /* */
12 /* http://www.apache.org/licenses/LICENSE-2.0 */
13 /* */
14 /* Unless required by applicable law or agreed to in writing, software */
15 /* distributed under the License is distributed on an "AS IS" BASIS, */
16 /* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */
17 /* See the License for the specific language governing permissions and */
18 /* limitations under the License. */
19 /* */
20 /* You should have received a copy of the Apache-2.0 license */
21 /* along with SCIP; see the file LICENSE. If not visit scipopt.org. */
22 /* */
23 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
24 
25 /**@file cons.h
26  * @ingroup INTERNALAPI
27  * @brief internal methods for constraints and constraint handlers
28  * @author Tobias Achterberg
29  */
30 
31 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
32 
33 #ifndef __SCIP_CONS_H__
34 #define __SCIP_CONS_H__
35 
36 
37 #include "scip/def.h"
38 #include "blockmemshell/memory.h"
39 #include "scip/type_retcode.h"
40 #include "scip/type_result.h"
41 #include "scip/type_set.h"
42 #include "scip/type_stat.h"
43 #include "scip/type_mem.h"
44 #include "scip/type_misc.h"
45 #include "scip/type_timing.h"
46 #include "scip/type_lp.h"
47 #include "scip/type_var.h"
48 #include "scip/type_prob.h"
49 #include "scip/type_sol.h"
50 #include "scip/type_tree.h"
51 #include "scip/type_sepastore.h"
52 #include "scip/type_cons.h"
53 #include "scip/type_branch.h"
54 #include "scip/type_reopt.h"
55 #include "scip/pub_cons.h"
56 
57 #ifndef NDEBUG
58 #include "scip/struct_cons.h"
59 #endif
60 
61 #ifdef __cplusplus
62 extern "C" {
63 #endif
64 
65 /*
66  * Constraint handler methods
67  */
68 
69 /** copies the given constraint handler to a new scip */
71  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
72  SCIP_SET* set, /**< SCIP_SET of SCIP to copy to */
73  SCIP_Bool* valid /**< was the copying process valid? */
74  );
75 
76 /** creates a constraint handler */
78  SCIP_CONSHDLR** conshdlr, /**< pointer to constraint handler data structure */
79  SCIP_SET* set, /**< global SCIP settings */
80  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
81  BMS_BLKMEM* blkmem, /**< block memory for parameter settings */
82  const char* name, /**< name of constraint handler */
83  const char* desc, /**< description of constraint handler */
84  int sepapriority, /**< priority of the constraint handler for separation */
85  int enfopriority, /**< priority of the constraint handler for constraint enforcing */
86  int checkpriority, /**< priority of the constraint handler for checking feasibility (and propagation) */
87  int sepafreq, /**< frequency for separating cuts; zero means to separate only in the root node */
88  int propfreq, /**< frequency for propagating domains; zero means only preprocessing propagation */
89  int eagerfreq, /**< frequency for using all instead of only the useful constraints in separation,
90  * propagation and enforcement, -1 for no eager evaluations, 0 for first only */
91  int maxprerounds, /**< maximal number of presolving rounds the constraint handler participates in (-1: no limit) */
92  SCIP_Bool delaysepa, /**< should separation method be delayed, if other separators found cuts? */
93  SCIP_Bool delayprop, /**< should propagation method be delayed, if other propagators found reductions? */
94  SCIP_Bool needscons, /**< should the constraint handler be skipped, if no constraints are available? */
95  SCIP_PROPTIMING proptiming, /**< positions in the node solving loop where propagation method of constraint handlers should be executed */
96  SCIP_PRESOLTIMING presoltiming, /**< timing mask of the constraint handler's presolving method */
97  SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), /**< copy method of constraint handler or NULL if you don't want to copy your plugin into sub-SCIPs */
98  SCIP_DECL_CONSFREE ((*consfree)), /**< destructor of constraint handler */
99  SCIP_DECL_CONSINIT ((*consinit)), /**< initialize constraint handler */
100  SCIP_DECL_CONSEXIT ((*consexit)), /**< deinitialize constraint handler */
101  SCIP_DECL_CONSINITPRE ((*consinitpre)), /**< presolving initialization method of constraint handler */
102  SCIP_DECL_CONSEXITPRE ((*consexitpre)), /**< presolving deinitialization method of constraint handler */
103  SCIP_DECL_CONSINITSOL ((*consinitsol)), /**< solving process initialization method of constraint handler */
104  SCIP_DECL_CONSEXITSOL ((*consexitsol)), /**< solving process deinitialization method of constraint handler */
105  SCIP_DECL_CONSDELETE ((*consdelete)), /**< free specific constraint data */
106  SCIP_DECL_CONSTRANS ((*constrans)), /**< transform constraint data into data belonging to the transformed problem */
107  SCIP_DECL_CONSINITLP ((*consinitlp)), /**< initialize LP with relaxations of "initial" constraints */
108  SCIP_DECL_CONSSEPALP ((*conssepalp)), /**< separate cutting planes for LP solution */
109  SCIP_DECL_CONSSEPASOL ((*conssepasol)), /**< separate cutting planes for arbitrary primal solution */
110  SCIP_DECL_CONSENFOLP ((*consenfolp)), /**< enforcing constraints for LP solutions */
111  SCIP_DECL_CONSENFORELAX ((*consenforelax)), /**< enforcing constraints for relaxation solutions */
112  SCIP_DECL_CONSENFOPS ((*consenfops)), /**< enforcing constraints for pseudo solutions */
113  SCIP_DECL_CONSCHECK ((*conscheck)), /**< check feasibility of primal solution */
114  SCIP_DECL_CONSPROP ((*consprop)), /**< propagate variable domains */
115  SCIP_DECL_CONSPRESOL ((*conspresol)), /**< presolving method */
116  SCIP_DECL_CONSRESPROP ((*consresprop)), /**< propagation conflict resolving method */
117  SCIP_DECL_CONSLOCK ((*conslock)), /**< variable rounding lock method */
118  SCIP_DECL_CONSACTIVE ((*consactive)), /**< activation notification method */
119  SCIP_DECL_CONSDEACTIVE((*consdeactive)), /**< deactivation notification method */
120  SCIP_DECL_CONSENABLE ((*consenable)), /**< enabling notification method */
121  SCIP_DECL_CONSDISABLE ((*consdisable)), /**< disabling notification method */
122  SCIP_DECL_CONSDELVARS ((*consdelvars)), /**< variable deletion method */
123  SCIP_DECL_CONSPRINT ((*consprint)), /**< constraint display method */
124  SCIP_DECL_CONSCOPY ((*conscopy)), /**< constraint copying method */
125  SCIP_DECL_CONSPARSE ((*consparse)), /**< constraint parsing method */
126  SCIP_DECL_CONSGETVARS ((*consgetvars)), /**< constraint get variables method */
127  SCIP_DECL_CONSGETNVARS((*consgetnvars)), /**< constraint get number of variable method */
128  SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs)), /**< constraint handler diving solution enforcement method */
129  SCIP_CONSHDLRDATA* conshdlrdata /**< constraint handler data */
130  );
131 
132 /** calls destructor and frees memory of constraint handler */
134  SCIP_CONSHDLR** conshdlr, /**< pointer to constraint handler data structure */
135  SCIP_SET* set /**< global SCIP settings */
136  );
137 
138 /** calls init method of constraint handler */
140  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
141  BMS_BLKMEM* blkmem, /**< block memory */
142  SCIP_SET* set, /**< global SCIP settings */
143  SCIP_STAT* stat /**< dynamic problem statistics */
144  );
145 
146 /** calls exit method of constraint handler */
148  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
149  BMS_BLKMEM* blkmem, /**< block memory */
150  SCIP_SET* set, /**< global SCIP settings */
151  SCIP_STAT* stat /**< dynamic problem statistics */
152  );
153 
154 /** informs constraint handler that the presolving process is being started */
156  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
157  BMS_BLKMEM* blkmem, /**< block memory */
158  SCIP_SET* set, /**< global SCIP settings */
159  SCIP_STAT* stat /**< dynamic problem statistics */
160  );
161 
162 /** informs constraint handler that the presolving is finished */
164  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
165  BMS_BLKMEM* blkmem, /**< block memory */
166  SCIP_SET* set, /**< global SCIP settings */
167  SCIP_STAT* stat /**< dynamic problem statistics */
168  );
169 
170 /** informs constraint handler that the branch and bound process is being started */
172  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
173  BMS_BLKMEM* blkmem, /**< block memory */
174  SCIP_SET* set, /**< global SCIP settings */
175  SCIP_STAT* stat /**< dynamic problem statistics */
176  );
177 
178 /** informs constraint handler that the branch and bound process data is being freed */
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 */
189  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
190  BMS_BLKMEM* blkmem, /**< block memory */
191  SCIP_SET* set, /**< global SCIP settings */
192  SCIP_STAT* stat, /**< dynamic problem statistics */
193  SCIP_TREE* tree, /**< branch and bound tree */
194  SCIP_Bool initkeptconss, /**< Also initialize constraints which are valid at a more global node,
195  * but were not activated there? Should be FALSE for repeated calls at
196  * one node or if the current focusnode is a child of the former one */
197  SCIP_Bool* cutoff /**< pointer to store whether infeasibility was detected while building the LP */
198  );
199 
200 /** calls separator method of constraint handler to separate LP solution */
202  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
203  BMS_BLKMEM* blkmem, /**< block memory */
204  SCIP_SET* set, /**< global SCIP settings */
205  SCIP_STAT* stat, /**< dynamic problem statistics */
206  SCIP_SEPASTORE* sepastore, /**< separation storage */
207  int depth, /**< depth of current node */
208  SCIP_Bool execdelayed, /**< execute separation method even if it is marked to be delayed */
209  SCIP_RESULT* result /**< pointer to store the result of the callback method */
210  );
211 
212 /** calls separator method of constraint handler to separate given primal solution */
214  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
215  BMS_BLKMEM* blkmem, /**< block memory */
216  SCIP_SET* set, /**< global SCIP settings */
217  SCIP_STAT* stat, /**< dynamic problem statistics */
218  SCIP_SEPASTORE* sepastore, /**< separation storage */
219  SCIP_SOL* sol, /**< primal solution that should be separated */
220  int depth, /**< depth of current node */
221  SCIP_Bool execdelayed, /**< execute separation method even if it is marked to be delayed */
222  SCIP_RESULT* result /**< pointer to store the result of the callback method */
223  );
224 
225 /** calls enforcing method of constraint handler for a relaxation solution for all constraints added after last
226  * conshdlrResetEnfo() call
227  */
229  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
230  BMS_BLKMEM* blkmem, /**< block memory */
231  SCIP_SET* set, /**< global SCIP settings */
232  SCIP_STAT* stat, /**< dynamic problem statistics */
233  SCIP_TREE* tree, /**< branch and bound tree */
234  SCIP_SEPASTORE* sepastore, /**< separation storage */
235  SCIP_SOL* relaxsol, /**< solution to be enforced */
236  SCIP_Bool solinfeasible, /**< was the solution already found out to be infeasible? */
237  SCIP_RESULT* result /**< pointer to store the result of the callback method */
238  );
239 
240 /** calls enforcing method of constraint handler for LP solution for all constraints added after last
241  * conshdlrReset() call
242  */
244  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
245  BMS_BLKMEM* blkmem, /**< block memory */
246  SCIP_SET* set, /**< global SCIP settings */
247  SCIP_STAT* stat, /**< dynamic problem statistics */
248  SCIP_TREE* tree, /**< branch and bound tree */
249  SCIP_SEPASTORE* sepastore, /**< separation storage */
250  SCIP_Bool solinfeasible, /**< was the solution already found out to be infeasible? */
251  SCIP_RESULT* result /**< pointer to store the result of the callback method */
252  );
253 
254 /** calls diving solution enforcement callback of constraint handler, if it exists */
256  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
257  SCIP_SET* set, /**< global SCIP settings */
258  SCIP_DIVESET* diveset, /**< diving settings to control scoring */
259  SCIP_SOL* sol, /**< current solution of diving mode */
260  SCIP_Bool* success, /**< pointer to store whether constraint handler successfully found a variable */
261  SCIP_Bool* infeasible /**< pointer to store whether the current node was detected to be infeasible */
262  );
263 
264 /** calls enforcing method of constraint handler for pseudo solution for all constraints added after last
265  * conshdlrReset() call
266  */
268  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
269  BMS_BLKMEM* blkmem, /**< block memory */
270  SCIP_SET* set, /**< global SCIP settings */
271  SCIP_STAT* stat, /**< dynamic problem statistics */
272  SCIP_TREE* tree, /**< branch and bound tree */
273  SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */
274  SCIP_Bool solinfeasible, /**< was the solution already found out to be infeasible? */
275  SCIP_Bool objinfeasible, /**< is the solution infeasible anyway due to violating lower objective bound? */
276  SCIP_Bool forced, /**< should enforcement of pseudo solution be forced? */
277  SCIP_RESULT* result /**< pointer to store the result of the callback method */
278  );
279 
280 /** calls feasibility check method of constraint handler */
282  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
283  BMS_BLKMEM* blkmem, /**< block memory */
284  SCIP_SET* set, /**< global SCIP settings */
285  SCIP_STAT* stat, /**< dynamic problem statistics */
286  SCIP_SOL* sol, /**< primal CIP solution */
287  SCIP_Bool checkintegrality, /**< Has integrality to be checked? */
288  SCIP_Bool checklprows, /**< Do constraints represented by rows in the current LP have to be checked? */
289  SCIP_Bool printreason, /**< Should the reason for the violation be printed? */
290  SCIP_Bool completely, /**< Should all violations be checked? */
291  SCIP_RESULT* result /**< pointer to store the result of the callback method */
292  );
293 
294 /** calls propagation method of constraint handler */
296  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
297  BMS_BLKMEM* blkmem, /**< block memory */
298  SCIP_SET* set, /**< global SCIP settings */
299  SCIP_STAT* stat, /**< dynamic problem statistics */
300  int depth, /**< depth of current node; -1 if preprocessing domain propagation */
301  SCIP_Bool fullpropagation, /**< should all constraints be propagated (or only new ones)? */
302  SCIP_Bool execdelayed, /**< execute propagation method even if it is marked to be delayed */
303  SCIP_Bool instrongbranching, /**< are we currently doing strong branching? */
304  SCIP_PROPTIMING proptiming, /**< current point in the node solving process */
305  SCIP_RESULT* result /**< pointer to store the result of the callback method */
306  );
307 
308 /** calls presolving method of constraint handler */
310  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
311  BMS_BLKMEM* blkmem, /**< block memory */
312  SCIP_SET* set, /**< global SCIP settings */
313  SCIP_STAT* stat, /**< dynamic problem statistics */
314  SCIP_PRESOLTIMING timing, /**< current presolving timing */
315  int nrounds, /**< number of presolving rounds already done */
316  int* nfixedvars, /**< pointer to total number of variables fixed of all presolvers */
317  int* naggrvars, /**< pointer to total number of variables aggregated of all presolvers */
318  int* nchgvartypes, /**< pointer to total number of variable type changes of all presolvers */
319  int* nchgbds, /**< pointer to total number of variable bounds tightened of all presolvers */
320  int* naddholes, /**< pointer to total number of domain holes added of all presolvers */
321  int* ndelconss, /**< pointer to total number of deleted constraints of all presolvers */
322  int* naddconss, /**< pointer to total number of added constraints of all presolvers */
323  int* nupgdconss, /**< pointer to total number of upgraded constraints of all presolvers */
324  int* nchgcoefs, /**< pointer to total number of changed coefficients of all presolvers */
325  int* nchgsides, /**< pointer to total number of changed left/right hand sides of all presolvers */
326  SCIP_RESULT* result /**< pointer to store the result of the callback method */
327  );
328 
329 /** enables or disables all clocks of \p conshdlr, depending on the value of the flag */
331  SCIP_CONSHDLR* conshdlr, /**< the constraint handler for which all clocks should be enabled or disabled */
332  SCIP_Bool enable /**< should the clocks of the constraint handler be enabled? */
333  );
334 
335 /** calls variable deletion method of constraint handler */
337  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
338  BMS_BLKMEM* blkmem, /**< block memory */
339  SCIP_SET* set, /**< global SCIP settings */
340  SCIP_STAT* stat /**< dynamic problem statistics */
341  );
342 
343 
344 /** locks rounding of variables involved in the given constraint constraint handler that doesn't need constraints */
346  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
347  SCIP_SET* set /**< global SCIP settings */
348  );
349 
350 /** unlocks rounding of variables involved in the given constraint constraint handler that doesn't need constraints */
352  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
353  SCIP_SET* set /**< global SCIP settings */
354  );
355 
356 /**
357  * callback setter methods of constraint handlers
358  */
359 
360 /** sets copy method of both the constraint handler and each associated constraint */
362  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
363  SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), /**< copy method of constraint handler or NULL if you don't want to copy your plugin into sub-SCIPs */
364  SCIP_DECL_CONSCOPY ((*conscopy)) /**< constraint copying method */
365  );
366 
367 /** sets destructor method of constraint handler */
369  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
370  SCIP_DECL_CONSFREE ((*consfree)) /**< destructor of constraint handler */
371  );
372 
373 /** sets initialization method of constraint handler */
375  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
376  SCIP_DECL_CONSINIT ((*consinit)) /**< initialize constraint handler */
377  );
378 
379 /** sets deinitialization method of constraint handler */
381  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
382  SCIP_DECL_CONSEXIT ((*consexit)) /**< deinitialize constraint handler */
383  );
384 
385 /** sets solving process initialization method of constraint handler */
387  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
388  SCIP_DECL_CONSINITSOL((*consinitsol)) /**< solving process initialization method of constraint handler */
389  );
390 
391 /** sets solving process deinitialization method of constraint handler */
393  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
394  SCIP_DECL_CONSEXITSOL ((*consexitsol)) /**< solving process deinitialization method of constraint handler */
395  );
396 
397 /** sets preprocessing initialization method of constraint handler */
399  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
400  SCIP_DECL_CONSINITPRE((*consinitpre)) /**< preprocessing initialization method of constraint handler */
401  );
402 
403 /** sets preprocessing deinitialization method of constraint handler */
405  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
406  SCIP_DECL_CONSEXITPRE((*consexitpre)) /**< preprocessing deinitialization method of constraint handler */
407  );
408 
409 /** sets presolving method of constraint handler */
411  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
412  SCIP_DECL_CONSPRESOL ((*conspresol)), /**< presolving method of constraint handler */
413  int maxprerounds, /**< maximal number of presolving rounds the constraint handler participates in (-1: no limit) */
414  SCIP_PRESOLTIMING presoltiming /**< timing mask of the constraint handler's presolving method */
415  );
416 
417 /** sets method of constraint handler to free specific constraint data */
419  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
420  SCIP_DECL_CONSDELETE ((*consdelete)) /**< free specific constraint data */
421  );
422 
423 /** sets method of constraint handler to transform constraint data into data belonging to the transformed problem */
425  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
426  SCIP_DECL_CONSTRANS ((*constrans)) /**< transform constraint data into data belonging to the transformed problem */
427  );
428 
429 /** sets method of constraint handler to initialize LP with relaxations of "initial" constraints */
431  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
432  SCIP_DECL_CONSINITLP ((*consinitlp)) /**< initialize LP with relaxations of "initial" constraints */
433  );
434 
435 /** sets propagation conflict resolving method of constraint handler */
437  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
438  SCIP_DECL_CONSRESPROP ((*consresprop)) /**< propagation conflict resolving method */
439  );
440 
441 /** sets activation notification method of constraint handler */
443  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
444  SCIP_DECL_CONSACTIVE ((*consactive)) /**< activation notification method */
445  );
446 
447 /** sets deactivation notification method of constraint handler */
449  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
450  SCIP_DECL_CONSDEACTIVE((*consdeactive)) /**< deactivation notification method */
451  );
452 
453 /** sets enabling notification method of constraint handler */
455  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
456  SCIP_DECL_CONSENABLE ((*consenable)) /**< enabling notification method */
457  );
458 
459 /** sets disabling notification method of constraint handler */
461  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
462  SCIP_DECL_CONSDISABLE ((*consdisable)) /**< disabling notification method */
463  );
464 
465 /** sets variable deletion method of constraint handler */
467  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
468  SCIP_DECL_CONSDELVARS ((*consdelvars)) /**< variable deletion method */
469  );
470 
471 /** sets constraint display method of constraint handler */
473  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
474  SCIP_DECL_CONSPRINT ((*consprint)) /**< constraint display method */
475  );
476 
477 /** sets constraint parsing method of constraint handler */
479  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
480  SCIP_DECL_CONSPARSE ((*consparse)) /**< constraint parsing method */
481  );
482 
483 /** sets constraint variable getter method of constraint handler */
485  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
486  SCIP_DECL_CONSGETVARS ((*consgetvars)) /**< constraint variable getter method */
487  );
488 
489 /** sets constraint variable number getter method of constraint handler */
491  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
492  SCIP_DECL_CONSGETNVARS((*consgetnvars)) /**< constraint variable number getter method */
493  );
494 
495 /** sets diving enforcement method of constraint handler */
497  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
498  SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs)) /**< constraint handler diving solution enforcement method */
499  );
500 
501 /*
502  * Constraint set change methods
503  */
504 
505 /** frees constraint set change data and releases all included constraints */
507  SCIP_CONSSETCHG** conssetchg, /**< pointer to constraint set change */
508  BMS_BLKMEM* blkmem, /**< block memory */
509  SCIP_SET* set /**< global SCIP settings */
510  );
511 
512 /** adds constraint addition to constraint set changes, and captures constraint; activates constraint if the
513  * constraint set change data is currently active
514  */
516  SCIP_CONSSETCHG** conssetchg, /**< pointer to constraint set change data structure */
517  BMS_BLKMEM* blkmem, /**< block memory */
518  SCIP_SET* set, /**< global SCIP settings */
519  SCIP_STAT* stat, /**< dynamic problem statistics */
520  SCIP_CONS* cons, /**< added constraint */
521  int depth, /**< depth of constraint set change's node */
522  SCIP_Bool focusnode, /**< does the constraint set change belong to the focus node? */
523  SCIP_Bool active /**< is the constraint set change currently active? */
524  );
525 
526 /** adds constraint disabling to constraint set changes, and captures constraint */
528  SCIP_CONSSETCHG** conssetchg, /**< pointer to constraint set change data structure */
529  BMS_BLKMEM* blkmem, /**< block memory */
530  SCIP_SET* set, /**< global SCIP settings */
531  SCIP_CONS* cons /**< disabled constraint */
532  );
533 
534 /** applies constraint set change */
536  SCIP_CONSSETCHG* conssetchg, /**< constraint set change to apply */
537  BMS_BLKMEM* blkmem, /**< block memory */
538  SCIP_SET* set, /**< global SCIP settings */
539  SCIP_STAT* stat, /**< dynamic problem statistics */
540  int depth, /**< depth of constraint set change's node */
541  SCIP_Bool focusnode /**< does the constraint set change belong to the focus node? */
542  );
543 
544 /** undoes constraint set change */
546  SCIP_CONSSETCHG* conssetchg, /**< constraint set change to undo */
547  BMS_BLKMEM* blkmem, /**< block memory */
548  SCIP_SET* set, /**< global SCIP settings */
549  SCIP_STAT* stat /**< dynamic problem statistics */
550  );
551 
552 /** applies constraint set change to the global problem and deletes the constraint set change data */
554  SCIP_CONSSETCHG** conssetchg, /**< pointer to constraint set change data */
555  BMS_BLKMEM* blkmem, /**< block memory */
556  SCIP_SET* set, /**< global SCIP settings */
557  SCIP_STAT* stat, /**< dynamic problem statistics */
558  SCIP_PROB* prob, /**< problem data */
559  SCIP_REOPT* reopt /**< reoptimization data */
560  );
561 
562 /** increase count of applied cuts */
564  SCIP_CONSHDLR* conshdlr /**< constraint handler */
565  );
566 
567 /** increase count of found cuts */
569  SCIP_CONSHDLR* conshdlr /**< constraint handler */
570  );
571 
572 
573 
574 /*
575  * Constraint methods
576  */
577 
578 /** creates and captures a constraint, and inserts it into the conss array of its constraint handler
579  *
580  * @warning If a constraint is marked to be checked for feasibility but not to be enforced, a LP or pseudo solution
581  * may be declared feasible even if it violates this particular constraint.
582  * This constellation should only be used, if no LP or pseudo solution can violate the constraint -- e.g. if a
583  * local constraint is redundant due to the variable's local bounds.
584  */
586  SCIP_CONS** cons, /**< pointer to constraint */
587  BMS_BLKMEM* blkmem, /**< block memory */
588  SCIP_SET* set, /**< global SCIP settings */
589  const char* name, /**< name of constraint */
590  SCIP_CONSHDLR* conshdlr, /**< constraint handler for this constraint */
591  SCIP_CONSDATA* consdata, /**< data for this specific constraint */
592  SCIP_Bool initial, /**< should the LP relaxation of constraint be in the initial LP?
593  * Usually set to TRUE. Set to FALSE for 'lazy constraints'. */
594  SCIP_Bool separate, /**< should the constraint be separated during LP processing?
595  * Usually set to TRUE. */
596  SCIP_Bool enforce, /**< should the constraint be enforced during node processing?
597  * TRUE for model constraints, FALSE for additional, redundant constraints. */
598  SCIP_Bool check, /**< should the constraint be checked for feasibility?
599  * TRUE for model constraints, FALSE for additional, redundant constraints. */
600  SCIP_Bool propagate, /**< should the constraint be propagated during node processing?
601  * Usually set to TRUE. */
602  SCIP_Bool local, /**< is constraint only valid locally?
603  * Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints. */
604  SCIP_Bool modifiable, /**< is constraint modifiable (subject to column generation)?
605  * Usually set to FALSE. In column generation applications, set to TRUE if pricing
606  * adds coefficients to this constraint. */
607  SCIP_Bool dynamic, /**< is constraint subject to aging?
608  * Usually set to FALSE. Set to TRUE for own cuts which
609  * are separated as constraints. */
610  SCIP_Bool removable, /**< should the relaxation be removed from the LP due to aging or cleanup?
611  * Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'. */
612  SCIP_Bool stickingatnode, /**< should the constraint always be kept at the node where it was added, even
613  * if it may be moved to a more global node?
614  * Usually set to FALSE. Set to TRUE to for constraints that represent node data. */
615  SCIP_Bool original, /**< is constraint belonging to the original problem? */
616  SCIP_Bool deleteconsdata /**< has the constraint data to be deleted if constraint is freed? */
617  );
618 
619 /** copies source constraint of source SCIP into the target constraint for the target SCIP, using the variable map for
620  * mapping the variables of the source SCIP to the variables of the target SCIP; if the copying process was successful
621  * a constraint is created and captured;
622  *
623  * @warning If a constraint is marked to be checked for feasibility but not to be enforced, an LP or pseudo solution
624  * may be declared feasible even if it violates this particular constraint.
625  * This constellation should only be used, if no LP or pseudo solution can violate the constraint -- e.g. if a
626  * local constraint is redundant due to the variable's local bounds.
627  */
629  SCIP_CONS** cons, /**< pointer to store the created target constraint */
630  SCIP_SET* set, /**< global SCIP settings of the target SCIP */
631  const char* name, /**< name of constraint, or NULL if the name of the source constraint should be used */
632  SCIP* sourcescip, /**< source SCIP data structure */
633  SCIP_CONSHDLR* sourceconshdlr, /**< source constraint handler for this constraint */
634  SCIP_CONS* sourcecons, /**< source constraint of the source SCIP */
635  SCIP_HASHMAP* varmap, /**< a SCIP_HASHMAP mapping variables of the source SCIP to corresponding
636  * variables of the target SCIP */
637  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
638  * target constraints, must not be NULL! */
639  SCIP_Bool initial, /**< should the LP relaxation of constraint be in the initial LP? */
640  SCIP_Bool separate, /**< should the constraint be separated during LP processing? */
641  SCIP_Bool enforce, /**< should the constraint be enforced during node processing? */
642  SCIP_Bool check, /**< should the constraint be checked for feasibility? */
643  SCIP_Bool propagate, /**< should the constraint be propagated during node processing? */
644  SCIP_Bool local, /**< is constraint only valid locally? */
645  SCIP_Bool modifiable, /**< is constraint modifiable (subject to column generation)? */
646  SCIP_Bool dynamic, /**< is constraint subject to aging? */
647  SCIP_Bool removable, /**< should the relaxation be removed from the LP due to aging or cleanup? */
648  SCIP_Bool stickingatnode, /**< should the constraint always be kept at the node where it was added, even
649  * if it may be moved to a more global node? */
650  SCIP_Bool global, /**< create a global or a local copy? */
651  SCIP_Bool* valid /**< pointer to store whether the copying was valid or not */
652  );
653 
654 /** parses constraint information (in cip format) out of a string; if the parsing process was successful a constraint is
655  * created, captured, and inserted into the conss array of its constraint handler.
656  *
657  * @warning If a constraint is marked to be checked for feasibility but not to be enforced, an LP or pseudo solution
658  * may be declared feasible even if it violates this particular constraint.
659  * This constellation should only be used, if no LP or pseudo solution can violate the constraint -- e.g. if a
660  * local constraint is redundant due to the variable's local bounds.
661  */
663  SCIP_CONS** cons, /**< pointer to constraint */
664  SCIP_SET* set, /**< global SCIP settings */
665  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler of target SCIP */
666  const char* str, /**< name of constraint */
667  SCIP_Bool initial, /**< should the LP relaxation of constraint be in the initial LP?
668  * Usually set to TRUE. Set to FALSE for 'lazy constraints'. */
669  SCIP_Bool separate, /**< should the constraint be separated during LP processing?
670  * Usually set to TRUE. */
671  SCIP_Bool enforce, /**< should the constraint be enforced during node processing?
672  * TRUE for model constraints, FALSE for additional, redundant constraints. */
673  SCIP_Bool check, /**< should the constraint be checked for feasibility?
674  * TRUE for model constraints, FALSE for additional, redundant constraints. */
675  SCIP_Bool propagate, /**< should the constraint be propagated during node processing?
676  * Usually set to TRUE. */
677  SCIP_Bool local, /**< is constraint only valid locally?
678  * Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints. */
679  SCIP_Bool modifiable, /**< is constraint modifiable (subject to column generation)?
680  * Usually set to FALSE. In column generation applications, set to TRUE if pricing
681  * adds coefficients to this constraint. */
682  SCIP_Bool dynamic, /**< is constraint subject to aging?
683  * Usually set to FALSE. Set to TRUE for own cuts which
684  * are separated as constraints. */
685  SCIP_Bool removable, /**< should the relaxation be removed from the LP due to aging or cleanup?
686  * Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'. */
687  SCIP_Bool stickingatnode, /**< should the constraint always be kept at the node where it was added, even
688  * if it may be moved to a more global node?
689  * Usually set to FALSE. Set to TRUE to for constraints that represent node data. */
690  SCIP_Bool* success /**< pointer store if the paring process was successful */
691  );
692 
693 /** change name of given constraint */
695  SCIP_CONS* cons, /**< problem constraint */
696  BMS_BLKMEM* blkmem, /**< block memory buffer */
697  const char* name /**< new name of constraint */
698  );
699 
700 /** frees a constraint and removes it from the conss array of its constraint handler */
702  SCIP_CONS** cons, /**< constraint to free */
703  BMS_BLKMEM* blkmem, /**< block memory buffer */
704  SCIP_SET* set /**< global SCIP settings */
705  );
706 
707 /** increases usage counter of constraint */
708 void SCIPconsCapture(
709  SCIP_CONS* cons /**< constraint */
710  );
711 
712 /** decreases usage counter of constraint, and frees memory if necessary */
714  SCIP_CONS** cons, /**< pointer to constraint */
715  BMS_BLKMEM* blkmem, /**< block memory */
716  SCIP_SET* set /**< global SCIP settings */
717  );
718 
719 
720 /** outputs constraint information to file stream */
722  SCIP_CONS* cons, /**< constraint to print */
723  SCIP_SET* set, /**< global SCIP settings */
724  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
725  FILE* file /**< output file (or NULL for standard output) */
726  );
727 
728 /** checks single constraint for feasibility of the given solution */
730  SCIP_CONS* cons, /**< constraint to check */
731  SCIP_SET* set, /**< global SCIP settings */
732  SCIP_SOL* sol, /**< primal CIP solution */
733  SCIP_Bool checkintegrality, /**< Has integrality to be checked? */
734  SCIP_Bool checklprows, /**< Do constraints represented by rows in the current LP have to be checked? */
735  SCIP_Bool printreason, /**< Should the reason for the violation be printed? */
736  SCIP_RESULT* result /**< pointer to store the result of the callback method */
737  );
738 
739 /** enforces single constraint for a given pseudo solution */
741  SCIP_CONS* cons, /**< constraint to enforce */
742  SCIP_SET* set, /**< global SCIP settings */
743  SCIP_Bool solinfeasible, /**< was the solution already declared infeasible by a constraint handler? */
744  SCIP_Bool objinfeasible, /**< is the solution infeasible anyway due to violating lower objective bound? */
745  SCIP_RESULT* result /**< pointer to store the result of the callback method */
746  );
747 
748 /** enforces single constraint for a given LP solution */
750  SCIP_CONS* cons, /**< constraint to enforce */
751  SCIP_SET* set, /**< global SCIP settings */
752  SCIP_Bool solinfeasible, /**< was the solution already declared infeasible by a constraint handler? */
753  SCIP_RESULT* result /**< pointer to store the result of the callback method */
754  );
755 
756 /** enforces single constraint for a given relaxation solution */
758  SCIP_CONS* cons, /**< constraint to enforce */
759  SCIP_SET* set, /**< global SCIP settings */
760  SCIP_SOL* sol, /**< solution to be enforced */
761  SCIP_Bool solinfeasible, /**< was the solution already declared infeasible by a constraint handler? */
762  SCIP_RESULT* result /**< pointer to store the result of the callback method */
763  );
764 
765 /** calls LP initialization method for single constraint */
767  SCIP_CONS* cons, /**< constraint to initialize */
768  SCIP_SET* set, /**< global SCIP settings */
769  SCIP_Bool* infeasible /**< pointer to store whether infeasibility was detected while building the LP */
770  );
771 
772 /** calls separation method of single constraint for LP solution */
774  SCIP_CONS* cons, /**< constraint to separate */
775  SCIP_SET* set, /**< global SCIP settings */
776  SCIP_RESULT* result /**< pointer to store the result of the separation call */
777  );
778 
779 /** calls separation method of single constraint for given primal solution */
781  SCIP_CONS* cons, /**< constraint to separate */
782  SCIP_SET* set, /**< global SCIP settings */
783  SCIP_SOL* sol, /**< primal solution that should be separated */
784  SCIP_RESULT* result /**< pointer to store the result of the separation call */
785  );
786 
787 /** calls domain propagation method of single constraint */
789  SCIP_CONS* cons, /**< constraint to propagate */
790  SCIP_SET* set, /**< global SCIP settings */
791  SCIP_PROPTIMING proptiming, /**< current point in the node solving loop */
792  SCIP_RESULT* result /**< pointer to store the result of the callback method */
793  );
794 
795 /** resolves propagation conflict of single constraint */
797  SCIP_CONS* cons, /**< constraint to resolve conflict for */
798  SCIP_SET* set, /**< global SCIP settings */
799  SCIP_VAR* infervar, /**< the conflict variable whose bound change has to be resolved */
800  int inferinfo, /**< the user information passed to the corresponding SCIPinferVarLbCons() or SCIPinferVarUbCons() call */
801  SCIP_BOUNDTYPE boundtype, /**< the type of the changed bound (lower or upper bound) */
802  SCIP_BDCHGIDX* bdchgidx, /**< the index of the bound change, representing the point of time where the change took place */
803  SCIP_Real relaxedbd, /**< the relaxed bound which is sufficient to be explained */
804  SCIP_RESULT* result /**< pointer to store the result of the callback method */
805  );
806 
807 /** presolves single constraint */
809  SCIP_CONS* cons, /**< constraint to presolve */
810  SCIP_SET* set, /**< global SCIP settings */
811  int nrounds, /**< number of presolving rounds already done */
812  SCIP_PRESOLTIMING timing, /**< current presolving timing */
813  int nnewfixedvars, /**< number of variables fixed since the last call to the presolving method */
814  int nnewaggrvars, /**< number of variables aggregated since the last call to the presolving method */
815  int nnewchgvartypes, /**< number of variable type changes since the last call to the presolving method */
816  int nnewchgbds, /**< number of variable bounds tightened since the last call to the presolving method */
817  int nnewholes, /**< number of domain holes added since the last call to the presolving method */
818  int nnewdelconss, /**< number of deleted constraints since the last call to the presolving method */
819  int nnewaddconss, /**< number of added constraints since the last call to the presolving method */
820  int nnewupgdconss, /**< number of upgraded constraints since the last call to the presolving method */
821  int nnewchgcoefs, /**< number of changed coefficients since the last call to the presolving method */
822  int nnewchgsides, /**< number of changed left or right hand sides since the last call to the presolving method */
823  int* nfixedvars, /**< pointer to count total number of variables fixed of all presolvers */
824  int* naggrvars, /**< pointer to count total number of variables aggregated of all presolvers */
825  int* nchgvartypes, /**< pointer to count total number of variable type changes of all presolvers */
826  int* nchgbds, /**< pointer to count total number of variable bounds tightened of all presolvers */
827  int* naddholes, /**< pointer to count total number of domain holes added of all presolvers */
828  int* ndelconss, /**< pointer to count total number of deleted constraints of all presolvers */
829  int* naddconss, /**< pointer to count total number of added constraints of all presolvers */
830  int* nupgdconss, /**< pointer to count total number of upgraded constraints of all presolvers */
831  int* nchgcoefs, /**< pointer to count total number of changed coefficients of all presolvers */
832  int* nchgsides, /**< pointer to count total number of changed left/right hand sides of all presolvers */
833  SCIP_RESULT* result /**< pointer to store the result of the callback method */
834  );
835 
836 /** calls constraint activation notification method of single constraint */
838  SCIP_CONS* cons, /**< constraint to notify */
839  SCIP_SET* set /**< global SCIP settings */
840  );
841 
842 /** calls constraint deactivation notification method of single constraint */
844  SCIP_CONS* cons, /**< constraint to notify */
845  SCIP_SET* set /**< global SCIP settings */
846  );
847 
848 /** method to collect the variables of a constraint
849  *
850  * If the number of variables is greater than the available slots in the variable array, nothing happens except that
851  * the success point is set to FALSE. With the method SCIPgetConsNVars() it is possible to get the number of variables
852  * a constraint has in its scope.
853  *
854  * @note The success pointer indicates if all variables were copied into the vars arrray.
855  *
856  * @note It might be that a constraint handler does not support this functionality, in that case the success pointer is
857  * set to FALSE.
858  */
860  SCIP_CONS* cons, /**< constraint to print */
861  SCIP_SET* set, /**< global SCIP settings */
862  SCIP_VAR** vars, /**< array to store the involved variable of the constraint */
863  int varssize, /**< available slots in vars array which is needed to check if the array is large enough */
864  SCIP_Bool* success /**< pointer to store whether the variables are successfully copied */
865  );
866 
867 /** method to collect the number of variables of a constraint
868  *
869  * @note The success pointer indicates if the contraint handler was able to return the number of variables
870  *
871  * @note It might be that a constraint handler does not support this functionality, in that case the success pointer is
872  * set to FALSE
873  */
875  SCIP_CONS* cons, /**< constraint to print */
876  SCIP_SET* set, /**< global SCIP settings */
877  int* nvars, /**< pointer to store the number of variables */
878  SCIP_Bool* success /**< pointer to store whether the constraint successfully returned the number of variables */
879  );
880 
881 /** globally removes constraint from all subproblems; removes constraint from the constraint set change data of the
882  * node, where it was created, or from the problem, if it was a problem constraint
883  */
885  SCIP_CONS* cons, /**< constraint to delete */
886  BMS_BLKMEM* blkmem, /**< block memory */
887  SCIP_SET* set, /**< global SCIP settings */
888  SCIP_STAT* stat, /**< dynamic problem statistics */
889  SCIP_PROB* prob, /**< problem data */
890  SCIP_REOPT* reopt /**< reoptimization data */
891  );
892 
893 /** gets and captures transformed constraint of a given constraint; if the constraint is not yet transformed,
894  * a new transformed constraint for this constraint is created
895  */
897  SCIP_CONS* origcons, /**< original constraint */
898  BMS_BLKMEM* blkmem, /**< block memory buffer */
899  SCIP_SET* set, /**< global SCIP settings */
900  SCIP_CONS** transcons /**< pointer to store the transformed constraint */
901  );
902 
903 /** sets the initial flag of the given constraint */
905  SCIP_CONS* cons, /**< constraint */
906  SCIP_SET* set, /**< global SCIP settings */
907  SCIP_STAT* stat, /**< dynamic problem statistics */
908  SCIP_Bool initial /**< new value */
909  );
910 
911 /** sets the separate flag of the given constraint */
913  SCIP_CONS* cons, /**< constraint */
914  SCIP_SET* set, /**< global SCIP settings */
915  SCIP_Bool separate /**< new value */
916  );
917 
918 /** sets the enforce flag of the given constraint */
920  SCIP_CONS* cons, /**< constraint */
921  SCIP_SET* set, /**< global SCIP settings */
922  SCIP_Bool enforce /**< new value */
923  );
924 
925 /** sets the check flag of the given constraint */
927  SCIP_CONS* cons, /**< constraint */
928  SCIP_SET* set, /**< global SCIP settings */
929  SCIP_Bool check /**< new value */
930  );
931 
932 /** sets the propagate flag of the given constraint */
934  SCIP_CONS* cons, /**< constraint */
935  SCIP_SET* set, /**< global SCIP settings */
936  SCIP_Bool propagate /**< new value */
937  );
938 
939 /** sets the local flag of the given constraint */
940 void SCIPconsSetLocal(
941  SCIP_CONS* cons, /**< constraint */
942  SCIP_Bool local /**< new value */
943  );
944 
945 /** sets the modifiable flag of the given constraint */
947  SCIP_CONS* cons, /**< constraint */
948  SCIP_Bool modifiable /**< new value */
949  );
950 
951 /** sets the dynamic flag of the given constraint */
952 void SCIPconsSetDynamic(
953  SCIP_CONS* cons, /**< constraint */
954  SCIP_Bool dynamic /**< new value */
955  );
956 
957 /** sets the removable flag of the given constraint */
959  SCIP_CONS* cons, /**< constraint */
960  SCIP_Bool removable /**< new value */
961  );
962 
963 /** sets the stickingatnode flag of the given constraint */
965  SCIP_CONS* cons, /**< constraint */
966  SCIP_Bool stickingatnode /**< new value */
967  );
968 
969 /** gives the constraint a new name; ATTENTION: to old pointer is over written that might
970  * result in a memory leakage */
972  SCIP_CONS* cons, /**< constraint */
973  const char* name /**< new name of constraint */
974  );
975 
976 /** gets associated transformed constraint of an original constraint, or NULL if no associated transformed constraint
977  * exists
978  */
980  SCIP_CONS* cons /**< constraint */
981  );
982 
983 /** activates constraint or marks constraint to be activated in next update */
985  SCIP_CONS* cons, /**< constraint */
986  SCIP_SET* set, /**< global SCIP settings */
987  SCIP_STAT* stat, /**< dynamic problem statistics */
988  int depth, /**< depth in the tree where the constraint activation takes place, or -1 for global problem */
989  SCIP_Bool focusnode /**< does the constraint activation take place at the focus node? */
990  );
991 
992 /** deactivates constraint or marks constraint to be deactivated in next update */
994  SCIP_CONS* cons, /**< constraint */
995  SCIP_SET* set, /**< global SCIP settings */
996  SCIP_STAT* stat /**< dynamic problem statistics */
997  );
998 
999 /** enables constraint's separation, enforcing, and propagation capabilities or marks them to be enabled in next update */
1001  SCIP_CONS* cons, /**< constraint */
1002  SCIP_SET* set, /**< global SCIP settings */
1003  SCIP_STAT* stat /**< dynamic problem statistics */
1004  );
1005 
1006 /** disables constraint's separation, enforcing, and propagation capabilities or marks them to be disabled in next update */
1008  SCIP_CONS* cons, /**< constraint */
1009  SCIP_SET* set, /**< global SCIP settings */
1010  SCIP_STAT* stat /**< dynamic problem statistics */
1011  );
1012 
1013 /** enables constraint's separation capabilities or marks them to be enabled in next update */
1015  SCIP_CONS* cons, /**< constraint */
1016  SCIP_SET* set /**< global SCIP settings */
1017  );
1018 
1019 /** disables constraint's separation capabilities or marks them to be disabled in next update */
1021  SCIP_CONS* cons, /**< constraint */
1022  SCIP_SET* set /**< global SCIP settings */
1023  );
1024 
1025 /** enables constraint's propagation capabilities or marks them to be enabled in next update */
1027  SCIP_CONS* cons, /**< constraint */
1028  SCIP_SET* set /**< global SCIP settings */
1029  );
1030 
1031 /** disables constraint's propagation capabilities or marks them to be disabled in next update */
1033  SCIP_CONS* cons, /**< constraint */
1034  SCIP_SET* set /**< global SCIP settings */
1035  );
1036 
1037 /** marks the constraint to be a conflict */
1039  SCIP_CONS* cons /**< constraint */
1040  );
1041 
1042 /** marks the constraint to be propagated (update might be delayed) */
1043 SCIP_EXPORT
1045  SCIP_CONS* cons, /**< constraint */
1046  SCIP_SET* set /**< global SCIP settings */
1047  );
1048 
1049 /** unmarks the constraint to be propagated (update might be delayed) */
1051  SCIP_CONS* cons, /**< constraint */
1052  SCIP_SET* set /**< global SCIP settings */
1053  );
1054 
1055 /** adds given value to age of constraint, but age can never become negative;
1056  * should be called
1057  * - in constraint separation, if no cut was found for this constraint,
1058  * - in constraint enforcing, if constraint was feasible, and
1059  * - in constraint propagation, if no domain reduction was deduced;
1060  * if it's age exceeds the constraint age limit, makes constraint obsolete or marks constraint to be made obsolete
1061  * in next update
1062  */
1064  SCIP_CONS* cons, /**< constraint */
1065  BMS_BLKMEM* blkmem, /**< block memory */
1066  SCIP_SET* set, /**< global SCIP settings */
1067  SCIP_STAT* stat, /**< dynamic problem statistics */
1068  SCIP_PROB* prob, /**< problem data */
1069  SCIP_Real deltaage, /**< value to add to the constraint's age */
1070  SCIP_REOPT* reopt /**< reoptimization data */
1071  );
1072 
1073 /** increases age of constraint by 1.0;
1074  * should be called
1075  * - in constraint separation, if no cut was found for this constraint,
1076  * - in constraint enforcing, if constraint was feasible, and
1077  * - in constraint propagation, if no domain reduction was deduced;
1078  * if it's age exceeds the constraint age limit, makes constraint obsolete or marks constraint to be made obsolete
1079  * in next update
1080  */
1082  SCIP_CONS* cons, /**< constraint */
1083  BMS_BLKMEM* blkmem, /**< block memory */
1084  SCIP_SET* set, /**< global SCIP settings */
1085  SCIP_STAT* stat, /**< dynamic problem statistics */
1086  SCIP_PROB* prob, /**< problem data */
1087  SCIP_REOPT* reopt /**< reoptimization data */
1088  );
1089 
1090 /** resets age of constraint to zero;
1091  * should be called
1092  * - in constraint separation, if a cut was found for this constraint,
1093  * - in constraint enforcing, if the constraint was violated, and
1094  * - in constraint propagation, if a domain reduction was deduced;
1095  * if it was obsolete, makes constraint useful again or marks constraint to be made useful again in next update
1096  */
1098  SCIP_CONS* cons, /**< constraint */
1099  SCIP_SET* set /**< global SCIP settings */
1100  );
1101 
1102 /** resolves the given conflicting bound, that was deduced by the given constraint, by putting all "reason" bounds
1103  * leading to the deduction into the conflict queue with calls to SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(),
1104  * SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), or SCIPaddConflictBinvar();
1105  *
1106  * @note it is sufficient to explain the relaxed bound change
1107  */
1109  SCIP_CONS* cons, /**< constraint that deduced the assignment */
1110  SCIP_SET* set, /**< global SCIP settings */
1111  SCIP_VAR* infervar, /**< variable whose bound was deduced by the constraint */
1112  int inferinfo, /**< user inference information attached to the bound change */
1113  SCIP_BOUNDTYPE inferboundtype, /**< bound that was deduced (lower or upper bound) */
1114  SCIP_BDCHGIDX* bdchgidx, /**< bound change index, representing the point of time where change took place */
1115  SCIP_Real relaxedbd, /**< the relaxed bound */
1116  SCIP_RESULT* result /**< pointer to store the result of the callback method */
1117  );
1118 
1119 /** adds given values to lock status of the constraint and updates the locks of the given locktype of the involved variables */
1121  SCIP_CONS* cons, /**< constraint */
1122  SCIP_SET* set, /**< global SCIP settings */
1123  SCIP_LOCKTYPE locktype, /**< type of variable locks */
1124  int nlockspos, /**< increase in number of rounding locks for constraint */
1125  int nlocksneg /**< increase in number of rounding locks for constraint's negation */
1126  );
1127 
1128 /*
1129  * Hash functions
1130  */
1131 
1132 /** gets the key (i.e. the name) of the given constraint */
1133 SCIP_DECL_HASHGETKEY(SCIPhashGetKeyCons);
1134 
1135 /*
1136  * method for arrays of contraint handlers
1137  */
1138 
1139 /** stores all constraints marked for propagation away when probing is started */
1141  SCIP_SET* set, /**< global SCIP settings */
1142  SCIP_CONSHDLR** conshdlrs, /**< all constraint handlers */
1143  int nconshdlrs /**< number of contraint handlers */
1144  );
1145 
1146 /** reset all constraints marked for propagation when probing was finished */
1148  SCIP_SET* set, /**< global SCIP settings */
1149  BMS_BLKMEM* blkmem, /**< block memory */
1150  SCIP_CONSHDLR** conshdlrs, /**< all constraint handlers */
1151  int nconshdlrs /**< number of contraint handlers */
1152  );
1153 
1154 #ifdef __cplusplus
1155 }
1156 #endif
1157 
1158 #endif
enum SCIP_Result SCIP_RESULT
Definition: type_result.h:61
void SCIPconshdlrSetInitpre(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITPRE((*consinitpre)))
Definition: cons.c:4344
SCIP_RETCODE SCIPconsEnforelax(SCIP_CONS *cons, SCIP_SET *set, SCIP_SOL *sol, SCIP_Bool solinfeasible, SCIP_RESULT *result)
Definition: cons.c:7424
enum SCIP_BoundType SCIP_BOUNDTYPE
Definition: type_lp.h:59
void SCIPconshdlrSetInitsol(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITSOL((*consinitsol)))
Definition: cons.c:4322
SCIP_RETCODE SCIPconsEnable(SCIP_CONS *cons, SCIP_SET *set, SCIP_STAT *stat)
Definition: cons.c:6811
SCIP_RETCODE SCIPconshdlrInitsol(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
Definition: cons.c:2678
SCIP_RETCODE SCIPconsFree(SCIP_CONS **cons, BMS_BLKMEM *blkmem, SCIP_SET *set)
Definition: cons.c:6141
void SCIPconshdlrSetResprop(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSRESPROP((*consresprop)))
Definition: cons.c:4428
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:3019
SCIP_RETCODE SCIPconshdlrLockVars(SCIP_CONSHDLR *conshdlr, SCIP_SET *set)
Definition: cons.c:4152
SCIP_RETCODE SCIPconsAddLocks(SCIP_CONS *cons, SCIP_SET *set, SCIP_LOCKTYPE locktype, int nlockspos, int nlocksneg)
Definition: cons.c:7254
void SCIPconsSetLocal(SCIP_CONS *cons, SCIP_Bool local)
Definition: cons.c:6652
void SCIPconsSetNamePointer(SCIP_CONS *cons, const char *name)
Definition: cons.c:6710
SCIP_DECL_CONSSEPALP(ConshdlrSubtour::scip_sepalp)
SCIP_RETCODE SCIPconssetchgAddDisabledCons(SCIP_CONSSETCHG **conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_CONS *cons)
Definition: cons.c:5431
#define SCIP_DECL_CONSINITPRE(x)
Definition: type_cons.h:155
SCIP_RETCODE SCIPconsEnableSeparation(SCIP_CONS *cons, SCIP_SET *set)
Definition: cons.c:6878
#define SCIP_DECL_CONSGETDIVEBDCHGS(x)
Definition: type_cons.h:918
#define SCIP_DECL_CONSPRESOL(x)
Definition: type_cons.h:559
SCIP_RETCODE SCIPconshdlrFree(SCIP_CONSHDLR **conshdlr, SCIP_SET *set)
Definition: cons.c:2351
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:3745
SCIP_RETCODE SCIPconshdlrsStorePropagationStatus(SCIP_SET *set, SCIP_CONSHDLR **conshdlrs, int nconshdlrs)
Definition: cons.c:7827
SCIP_RETCODE SCIPconsIncAge(SCIP_CONS *cons, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_REOPT *reopt)
Definition: cons.c:7132
SCIP_DECL_CONSENFOPS(ConshdlrSubtour::scip_enfops)
SCIP_CONS * SCIPconsGetTransformed(SCIP_CONS *cons)
Definition: cons.c:6724
SCIP_RETCODE SCIPconsSetEnforced(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool enforce)
Definition: cons.c:6534
SCIP_RETCODE SCIPconsDeactive(SCIP_CONS *cons, SCIP_SET *set)
Definition: cons.c:7758
SCIP_RETCODE SCIPconsEnfolp(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool solinfeasible, SCIP_RESULT *result)
Definition: cons.c:7382
#define SCIP_DECL_CONSRESPROP(x)
Definition: type_cons.h:610
SCIP_RETCODE SCIPconssetchgFree(SCIP_CONSSETCHG **conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set)
Definition: cons.c:5311
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:6734
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:3541
SCIP_RETCODE SCIPconshdlrCopyInclude(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, SCIP_Bool *valid)
Definition: cons.c:1976
void SCIPconshdlrSetGetDiveBdChgs(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs)))
Definition: cons.c:4538
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:63
#define SCIP_DECL_CONSGETNVARS(x)
Definition: type_cons.h:883
SCIP_RETCODE SCIPconssetchgApply(SCIP_CONSSETCHG *conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, int depth, SCIP_Bool focusnode)
Definition: cons.c:5549
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:7194
type definitions for global SCIP settings
SCIP_RETCODE SCIPconsSepasol(SCIP_CONS *cons, SCIP_SET *set, SCIP_SOL *sol, SCIP_RESULT *result)
Definition: cons.c:7535
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:7618
#define SCIP_DECL_CONSEXITSOL(x)
Definition: type_cons.h:215
static GRAPHNODE ** active
SCIP_RETCODE SCIPconsUnmarkPropagate(SCIP_CONS *cons, SCIP_SET *set)
Definition: cons.c:7036
void SCIPconshdlrSetDeactive(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDEACTIVE((*consdeactive)))
Definition: cons.c:4450
void SCIPconshdlrSetExitsol(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSEXITSOL((*consexitsol)))
Definition: cons.c:4333
type definitions for return codes for SCIP methods
SCIP_RETCODE SCIPconsEnablePropagation(SCIP_CONS *cons, SCIP_SET *set)
Definition: cons.c:6936
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:6355
SCIP_RETCODE SCIPconsTransform(SCIP_CONS *origcons, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_CONS **transcons)
Definition: cons.c:6415
type definitions for collecting reoptimization information
SCIP_RETCODE SCIPconshdlrExit(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
Definition: cons.c:2509
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:2276
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:6016
#define SCIP_DECL_CONSINITLP(x)
Definition: type_cons.h:258
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:4311
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:6844
#define SCIP_DECL_CONSINITSOL(x)
Definition: type_cons.h:200
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:3978
void SCIPconshdlrSetActive(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSACTIVE((*consactive)))
Definition: cons.c:4439
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:2755
enum SCIP_LockType SCIP_LOCKTYPE
Definition: type_var.h:100
SCIP_RETCODE SCIPconshdlrsResetPropagationStatus(SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_CONSHDLR **conshdlrs, int nconshdlrs)
Definition: cons.c:7867
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:3807
#define SCIP_DECL_CONSPARSE(x)
Definition: type_cons.h:843
SCIP_RETCODE SCIPconsSetPropagated(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool propagate)
Definition: cons.c:6617
SCIP_RETCODE SCIPconsRelease(SCIP_CONS **cons, BMS_BLKMEM *blkmem, SCIP_SET *set)
Definition: cons.c:6208
void SCIPconshdlrSetDelete(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDELETE((*consdelete)))
Definition: cons.c:4395
#define SCIP_DECL_CONSDEACTIVE(x)
Definition: type_cons.h:704
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:7073
void SCIPconshdlrSetCopy(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), SCIP_DECL_CONSCOPY((*conscopy)))
Definition: cons.c:4274
void SCIPconshdlrSetParse(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPARSE((*consparse)))
Definition: cons.c:4505
SCIP_DECL_CONSTRANS(ConshdlrSubtour::scip_trans)
SCIP_RETCODE SCIPconshdlrInit(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
Definition: cons.c:2396
SCIP_DECL_HASHGETKEY(SCIPhashGetKeyCons)
Definition: cons.c:7788
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:2862
#define SCIP_DECL_CONSDISABLE(x)
Definition: type_cons.h:734
SCIP_DECL_CONSDELVARS(ConshdlrSubtour::scip_delvars)
unsigned int SCIP_PRESOLTIMING
Definition: type_timing.h:61
type definitions for problem variables
#define SCIP_DECL_CONSENABLE(x)
Definition: type_cons.h:719
SCIP_RETCODE SCIPconshdlrSetPresol(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPRESOL((*conspresol)), int maxprerounds, SCIP_PRESOLTIMING presoltiming)
Definition: cons.c:4366
type definitions for storing separated cuts
struct SCIP_ConsData SCIP_CONSDATA
Definition: type_cons.h:65
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:7660
SCIP_RETCODE SCIPconsResetAge(SCIP_CONS *cons, SCIP_SET *set)
Definition: cons.c:7153
#define SCIP_DECL_CONSGETVARS(x)
Definition: type_cons.h:865
#define SCIP_DECL_CONSEXIT(x)
Definition: type_cons.h:135
void SCIPconshdlrSetTrans(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSTRANS((*constrans)))
Definition: cons.c:4406
SCIP_RETCODE SCIPconsSetInitial(SCIP_CONS *cons, SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool initial)
Definition: cons.c:6465
#define SCIP_Bool
Definition: def.h:93
SCIP_RETCODE SCIPconshdlrExitpre(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
Definition: cons.c:2638
SCIP_DECL_CONSPROP(ConshdlrSubtour::scip_prop)
SCIP_RETCODE SCIPconsDisableSeparation(SCIP_CONS *cons, SCIP_SET *set)
Definition: cons.c:6908
SCIP_RETCODE SCIPconsActive(SCIP_CONS *cons, SCIP_SET *set)
Definition: cons.c:7734
SCIP_RETCODE SCIPconsDeactivate(SCIP_CONS *cons, SCIP_SET *set, SCIP_STAT *stat)
Definition: cons.c:6776
void SCIPconsCapture(SCIP_CONS *cons)
Definition: cons.c:6196
void SCIPconshdlrEnableOrDisableClocks(SCIP_CONSHDLR *conshdlr, SCIP_Bool enable)
Definition: cons.c:4661
#define SCIP_DECL_CONSEXITPRE(x)
Definition: type_cons.h:179
SCIP_RETCODE SCIPconssetchgMakeGlobal(SCIP_CONSSETCHG **conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_REOPT *reopt)
Definition: cons.c:5722
SCIP_RETCODE SCIPconssetchgUndo(SCIP_CONSSETCHG *conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
Definition: cons.c:5636
SCIP_RETCODE SCIPconshdlrInitpre(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
Definition: cons.c:2552
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:5385
void SCIPconshdlrSetDelvars(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDELVARS((*consdelvars)))
Definition: cons.c:4483
SCIP_RETCODE SCIPconsPrint(SCIP_CONS *cons, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, FILE *file)
Definition: cons.c:6248
void SCIPconshdlrSetExitpre(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSEXITPRE((*consexitpre)))
Definition: cons.c:4355
type definitions for branch and bound tree
SCIP_RETCODE SCIPconsDisablePropagation(SCIP_CONS *cons, SCIP_SET *set)
Definition: cons.c:6966
SCIP_RETCODE SCIPconshdlrGetDiveBoundChanges(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, SCIP_DIVESET *diveset, SCIP_SOL *sol, SCIP_Bool *success, SCIP_Bool *infeasible)
Definition: cons.c:3514
SCIP_RETCODE SCIPconshdlrUnlockVars(SCIP_CONSHDLR *conshdlr, SCIP_SET *set)
Definition: cons.c:4167
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:5960
void SCIPconshdlrSetEnable(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSENABLE((*consenable)))
Definition: cons.c:4461
void SCIPconshdlrSetGetVars(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETVARS((*consgetvars)))
Definition: cons.c:4516
SCIP_RETCODE SCIPconsProp(SCIP_CONS *cons, SCIP_SET *set, SCIP_PROPTIMING proptiming, SCIP_RESULT *result)
Definition: cons.c:7578
SCIP_RETCODE SCIPconsInitlp(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool *infeasible)
Definition: cons.c:7468
SCIP_RETCODE SCIPconshdlrDelVars(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
Definition: cons.c:4121
SCIP_RETCODE SCIPconsSepalp(SCIP_CONS *cons, SCIP_SET *set, SCIP_RESULT *result)
Definition: cons.c:7494
void SCIPconsSetModifiable(SCIP_CONS *cons, SCIP_Bool modifiable)
Definition: cons.c:6665
type definitions for block memory pools and memory buffers
SCIP_RETCODE SCIPconsMarkPropagate(SCIP_CONS *cons, SCIP_SET *set)
Definition: cons.c:7006
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:3148
unsigned int SCIP_PROPTIMING
Definition: type_timing.h:75
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:3336
SCIP_RETCODE SCIPconsGetNVars(SCIP_CONS *cons, SCIP_SET *set, int *nvars, SCIP_Bool *success)
Definition: cons.c:6323
SCIP_RETCODE SCIPconsChgName(SCIP_CONS *cons, BMS_BLKMEM *blkmem, const char *name)
Definition: cons.c:6121
SCIP_RETCODE SCIPconsSetChecked(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool check)
Definition: cons.c:6569
#define SCIP_DECL_CONSFREE(x)
Definition: type_cons.h:115
SCIP_RETCODE SCIPconsEnfops(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool solinfeasible, SCIP_Bool objinfeasible, SCIP_RESULT *result)
Definition: cons.c:7338
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:7300
void SCIPconshdlrSetPrint(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPRINT((*consprint)))
Definition: cons.c:4494
void SCIPconshdlrIncNCutsFound(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4891
#define SCIP_DECL_CONSINIT(x)
Definition: type_cons.h:125
SCIP_DECL_CONSLOCK(ConshdlrSubtour::scip_lock)
#define SCIP_DECL_CONSENFORELAX(x)
Definition: type_cons.h:387
#define SCIP_Real
Definition: def.h:186
SCIP_DECL_CONSPRINT(ConshdlrSubtour::scip_print)
result codes for SCIP callback methods
void SCIPconshdlrSetInitlp(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITLP((*consinitlp)))
Definition: cons.c:4417
void SCIPconsSetRemovable(SCIP_CONS *cons, SCIP_Bool removable)
Definition: cons.c:6687
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:5818
#define SCIP_DECL_CONSACTIVE(x)
Definition: type_cons.h:689
void SCIPconshdlrSetInit(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINIT((*consinit)))
Definition: cons.c:4300
void SCIPconsSetDynamic(SCIP_CONS *cons, SCIP_Bool dynamic)
Definition: cons.c:6676
void SCIPconsSetStickingAtNode(SCIP_CONS *cons, SCIP_Bool stickingatnode)
Definition: cons.c:6698
void SCIPconshdlrIncNAppliedCuts(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4881
#define SCIP_DECL_CONSHDLRCOPY(x)
Definition: type_cons.h:107
struct SCIP_ConshdlrData SCIP_CONSHDLRDATA
Definition: type_cons.h:64
SCIP_DECL_CONSCOPY(ConshdlrSubtour::scip_copy)
void SCIPconsMarkConflict(SCIP_CONS *cons)
Definition: cons.c:6996
SCIP_RETCODE SCIPconsGetVars(SCIP_CONS *cons, SCIP_SET *set, SCIP_VAR **vars, int varssize, SCIP_Bool *success)
Definition: cons.c:6287
SCIP_RETCODE SCIPconsSetSeparated(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool separate)
Definition: cons.c:6499
common defines and data types used in all packages of SCIP
struct BMS_BlkMem BMS_BLKMEM
Definition: memory.h:439
SCIP_RETCODE SCIPconshdlrExitsol(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool restart)
Definition: cons.c:2718
void SCIPconshdlrSetDisable(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDISABLE((*consdisable)))
Definition: cons.c:4472
type definitions for constraints and constraint handlers
void SCIPconshdlrSetGetNVars(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETNVARS((*consgetnvars)))
Definition: cons.c:4527
void SCIPconshdlrSetFree(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSFREE((*consfree)))
Definition: cons.c:4289
memory allocation routines