Scippy

SCIP

Solving Constraint Integer Programs

scip_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-2022 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 scipopt.org. */
13 /* */
14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15 
16 /**@file scip_cons.h
17  * @ingroup PUBLICCOREAPI
18  * @brief public methods for constraint handler plugins and constraints
19  * @author Tobias Achterberg
20  * @author Timo Berthold
21  * @author Thorsten Koch
22  * @author Alexander Martin
23  * @author Marc Pfetsch
24  * @author Kati Wolter
25  * @author Gregor Hendel
26  * @author Leona Gottwald
27  */
28 
29 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
30 
31 #ifndef __SCIP_SCIP_CONS_H__
32 #define __SCIP_SCIP_CONS_H__
33 
34 
35 #include "scip/def.h"
36 #include "scip/type_cons.h"
37 #include "scip/type_heur.h"
38 #include "scip/type_lp.h"
39 #include "scip/type_misc.h"
40 #include "scip/type_result.h"
41 #include "scip/type_retcode.h"
42 #include "scip/type_scip.h"
43 #include "scip/type_sol.h"
44 #include "scip/type_timing.h"
45 #include "scip/type_var.h"
46 
47 /* In debug mode, we include the SCIP's structure in scip.c, such that no one can access
48  * this structure except the interface methods in scip.c.
49  * In optimized mode, the structure is included in scip.h, because some of the methods
50  * are implemented as defines for performance reasons (e.g. the numerical comparisons).
51  * Additionally, the internal "set.h" is included, such that the defines in set.h are
52  * available in optimized mode.
53  */
54 #ifdef NDEBUG
55 #include "scip/struct_scip.h"
56 #include "scip/cons.h"
57 #endif
58 
59 #ifdef __cplusplus
60 extern "C" {
61 #endif
62 
63 /**@addtogroup PublicConshdlrMethods
64  *
65  * @{
66  */
67 
68 /** creates a constraint handler and includes it in SCIP.
69  *
70  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
71  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
72  *
73  * @pre This method can be called if SCIP is in one of the following stages:
74  * - \ref SCIP_STAGE_INIT
75  * - \ref SCIP_STAGE_PROBLEM
76  *
77  * @note method has all constraint handler callbacks as arguments and is thus changed every time a new
78  * callback is added
79  * in future releases; consider using SCIPincludeConshdlrBasic() and setter functions
80  * if you seek for a method which is less likely to change in future releases
81  */
82 SCIP_EXPORT
83 SCIP_RETCODE SCIPincludeConshdlr(
84  SCIP* scip, /**< SCIP data structure */
85  const char* name, /**< name of constraint handler */
86  const char* desc, /**< description of constraint handler */
87  int sepapriority, /**< priority of the constraint handler for separation */
88  int enfopriority, /**< priority of the constraint handler for constraint enforcing */
89  int chckpriority, /**< priority of the constraint handler for checking feasibility (and propagation) */
90  int sepafreq, /**< frequency for separating cuts; zero means to separate only in the root node */
91  int propfreq, /**< frequency for propagating domains; zero means only preprocessing propagation */
92  int eagerfreq, /**< frequency for using all instead of only the useful constraints in separation,
93  * propagation and enforcement, -1 for no eager evaluations, 0 for first only */
94  int maxprerounds, /**< maximal number of presolving rounds the constraint handler participates in (-1: no limit) */
95  SCIP_Bool delaysepa, /**< should separation method be delayed, if other separators found cuts? */
96  SCIP_Bool delayprop, /**< should propagation method be delayed, if other propagators found reductions? */
97  SCIP_Bool needscons, /**< should the constraint handler be skipped, if no constraints are available? */
98  SCIP_PROPTIMING proptiming, /**< positions in the node solving loop where propagation method of constraint handlers should be executed */
99  SCIP_PRESOLTIMING presoltiming, /**< timing mask of the constraint handler's presolving method */
100  SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), /**< copy method of constraint handler or NULL if you don't want to copy your plugin into sub-SCIPs */
101  SCIP_DECL_CONSFREE ((*consfree)), /**< destructor of constraint handler */
102  SCIP_DECL_CONSINIT ((*consinit)), /**< initialize constraint handler */
103  SCIP_DECL_CONSEXIT ((*consexit)), /**< deinitialize constraint handler */
104  SCIP_DECL_CONSINITPRE ((*consinitpre)), /**< presolving initialization method of constraint handler */
105  SCIP_DECL_CONSEXITPRE ((*consexitpre)), /**< presolving deinitialization method of constraint handler */
106  SCIP_DECL_CONSINITSOL ((*consinitsol)), /**< solving process initialization method of constraint handler */
107  SCIP_DECL_CONSEXITSOL ((*consexitsol)), /**< solving process deinitialization method of constraint handler */
108  SCIP_DECL_CONSDELETE ((*consdelete)), /**< free specific constraint data */
109  SCIP_DECL_CONSTRANS ((*constrans)), /**< transform constraint data into data belonging to the transformed problem */
110  SCIP_DECL_CONSINITLP ((*consinitlp)), /**< initialize LP with relaxations of "initial" constraints */
111  SCIP_DECL_CONSSEPALP ((*conssepalp)), /**< separate cutting planes for LP solution */
112  SCIP_DECL_CONSSEPASOL ((*conssepasol)), /**< separate cutting planes for arbitrary primal solution */
113  SCIP_DECL_CONSENFOLP ((*consenfolp)), /**< enforcing constraints for LP solutions */
114  SCIP_DECL_CONSENFORELAX ((*consenforelax)), /**< enforcing constraints for relaxation solutions */
115  SCIP_DECL_CONSENFOPS ((*consenfops)), /**< enforcing constraints for pseudo solutions */
116  SCIP_DECL_CONSCHECK ((*conscheck)), /**< check feasibility of primal solution */
117  SCIP_DECL_CONSPROP ((*consprop)), /**< propagate variable domains */
118  SCIP_DECL_CONSPRESOL ((*conspresol)), /**< presolving method */
119  SCIP_DECL_CONSRESPROP ((*consresprop)), /**< propagation conflict resolving method */
120  SCIP_DECL_CONSLOCK ((*conslock)), /**< variable rounding lock method */
121  SCIP_DECL_CONSACTIVE ((*consactive)), /**< activation notification method */
122  SCIP_DECL_CONSDEACTIVE((*consdeactive)), /**< deactivation notification method */
123  SCIP_DECL_CONSENABLE ((*consenable)), /**< enabling notification method */
124  SCIP_DECL_CONSDISABLE ((*consdisable)), /**< disabling notification method */
125  SCIP_DECL_CONSDELVARS ((*consdelvars)), /**< variable deletion method */
126  SCIP_DECL_CONSPRINT ((*consprint)), /**< constraint display method */
127  SCIP_DECL_CONSCOPY ((*conscopy)), /**< constraint copying method */
128  SCIP_DECL_CONSPARSE ((*consparse)), /**< constraint parsing method */
129  SCIP_DECL_CONSGETVARS ((*consgetvars)), /**< constraint get variables method */
130  SCIP_DECL_CONSGETNVARS((*consgetnvars)), /**< constraint get number of variable method */
131  SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs)), /**< constraint handler diving solution enforcement method */
132  SCIP_CONSHDLRDATA* conshdlrdata /**< constraint handler data */
133  );
134 
135 /** creates a constraint handler and includes it in SCIP. All non-fundamental (or optional) callbacks will be set to NULL.
136  * Optional callbacks can be set via specific setter functions, see SCIPsetConshdlrInit(), SCIPsetConshdlrExit(),
137  * SCIPsetConshdlrCopy(), SCIPsetConshdlrFree(), SCIPsetConshdlrInitsol(), SCIPsetConshdlrExitsol(),
138  * SCIPsetConshdlrInitpre(), SCIPsetConshdlrExitpre(), SCIPsetConshdlrPresol(), SCIPsetConshdlrDelete(),
139  * SCIPsetConshdlrDelvars(), SCIPsetConshdlrInitlp(), SCIPsetConshdlrActive(), SCIPsetConshdlrDeactive(),
140  * SCIPsetConshdlrEnable(), SCIPsetConshdlrDisable(), SCIPsetConshdlrResprop(), SCIPsetConshdlrTrans(),
141  * SCIPsetConshdlrPrint(), SCIPsetConshdlrParse(), SCIPsetConshdlrGetVars(), SCIPsetConshdlrGetNVars(), and
142  * SCIPsetConshdlrGetDiveBdChgs().
143  *
144  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
145  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
146  *
147  * @pre This method can be called if SCIP is in one of the following stages:
148  * - \ref SCIP_STAGE_INIT
149  * - \ref SCIP_STAGE_PROBLEM
150  *
151  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeConshdlr() instead
152  */
153 SCIP_EXPORT
154 SCIP_RETCODE SCIPincludeConshdlrBasic(
155  SCIP* scip, /**< SCIP data structure */
156  SCIP_CONSHDLR** conshdlrptr, /**< reference to a constraint handler pointer, or NULL */
157  const char* name, /**< name of constraint handler */
158  const char* desc, /**< description of constraint handler */
159  int enfopriority, /**< priority of the constraint handler for constraint enforcing */
160  int chckpriority, /**< priority of the constraint handler for checking feasibility (and propagation) */
161  int eagerfreq, /**< frequency for using all instead of only the useful constraints in separation,
162  * propagation and enforcement, -1 for no eager evaluations, 0 for first only */
163  SCIP_Bool needscons, /**< should the constraint handler be skipped, if no constraints are available? */
164  SCIP_DECL_CONSENFOLP ((*consenfolp)), /**< enforcing constraints for LP solutions */
165  SCIP_DECL_CONSENFOPS ((*consenfops)), /**< enforcing constraints for pseudo solutions */
166  SCIP_DECL_CONSCHECK ((*conscheck)), /**< check feasibility of primal solution */
167  SCIP_DECL_CONSLOCK ((*conslock)), /**< variable rounding lock method */
168  SCIP_CONSHDLRDATA* conshdlrdata /**< constraint handler data */
169  );
170 
171 /** sets all separation related callbacks/parameters of the constraint handler
172  *
173  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
174  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
175  *
176  * @pre This method can be called if SCIP is in one of the following stages:
177  * - \ref SCIP_STAGE_INIT
178  * - \ref SCIP_STAGE_PROBLEM
179  */
180 SCIP_EXPORT
181 SCIP_RETCODE SCIPsetConshdlrSepa(
182  SCIP* scip, /**< SCIP data structure */
183  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
184  SCIP_DECL_CONSSEPALP ((*conssepalp)), /**< separate cutting planes for LP solution */
185  SCIP_DECL_CONSSEPASOL ((*conssepasol)), /**< separate cutting planes for arbitrary primal solution */
186  int sepafreq, /**< frequency for separating cuts; zero means to separate only in the root node */
187  int sepapriority, /**< priority of the constraint handler for separation */
188  SCIP_Bool delaysepa /**< should separation method be delayed, if other separators found cuts? */
189  );
190 
191 /** sets both the propagation callback and the propagation frequency of the constraint handler
192  *
193  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
194  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
195  *
196  * @pre This method can be called if SCIP is in one of the following stages:
197  * - \ref SCIP_STAGE_INIT
198  * - \ref SCIP_STAGE_PROBLEM
199  */
200 SCIP_EXPORT
201 SCIP_RETCODE SCIPsetConshdlrProp(
202  SCIP* scip, /**< SCIP data structure */
203  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
204  SCIP_DECL_CONSPROP ((*consprop)), /**< propagate variable domains */
205  int propfreq, /**< frequency for propagating domains; zero means only preprocessing propagation */
206  SCIP_Bool delayprop, /**< should propagation method be delayed, if other propagators found reductions? */
207  SCIP_PROPTIMING proptiming /**< positions in the node solving loop where propagation should be executed */
208  );
209 
210 /** sets relaxation enforcement method of the constraint handler
211  *
212  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
213  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
214  *
215  * @pre This method can be called if SCIP is in one of the following stages:
216  * - \ref SCIP_STAGE_INIT
217  * - \ref SCIP_STAGE_PROBLEM
218  */
219 SCIP_EXPORT
220 SCIP_RETCODE SCIPsetConshdlrEnforelax(
221  SCIP* scip, /**< SCIP data structure */
222  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
223  SCIP_DECL_CONSENFORELAX ((*consenforelax)) /**< enforcement method for relaxation solution of constraint handler (might be NULL) */
224  );
225 
226 /** sets copy method of both the constraint handler and each associated constraint
227  *
228  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
229  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
230  *
231  * @pre This method can be called if SCIP is in one of the following stages:
232  * - \ref SCIP_STAGE_INIT
233  * - \ref SCIP_STAGE_PROBLEM
234  */
235 SCIP_EXPORT
236 SCIP_RETCODE SCIPsetConshdlrCopy(
237  SCIP* scip, /**< SCIP data structure */
238  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
239  SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), /**< copy method of constraint handler or NULL if you don't want to copy your plugin into sub-SCIPs */
240  SCIP_DECL_CONSCOPY ((*conscopy)) /**< constraint copying method */
241  );
242 
243 /** sets destructor method of constraint handler
244  *
245  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
246  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
247  *
248  * @pre This method can be called if SCIP is in one of the following stages:
249  * - \ref SCIP_STAGE_INIT
250  * - \ref SCIP_STAGE_PROBLEM
251  */
252 SCIP_EXPORT
253 SCIP_RETCODE SCIPsetConshdlrFree(
254  SCIP* scip, /**< SCIP data structure */
255  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
256  SCIP_DECL_CONSFREE ((*consfree)) /**< destructor of constraint handler */
257  );
258 
259 /** sets initialization method of constraint handler
260  *
261  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
262  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
263  *
264  * @pre This method can be called if SCIP is in one of the following stages:
265  * - \ref SCIP_STAGE_INIT
266  * - \ref SCIP_STAGE_PROBLEM
267  */
268 SCIP_EXPORT
269 SCIP_RETCODE SCIPsetConshdlrInit(
270  SCIP* scip, /**< SCIP data structure */
271  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
272  SCIP_DECL_CONSINIT ((*consinit)) /**< initialize constraint handler */
273  );
274 
275 /** sets deinitialization method of constraint handler
276  *
277  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
278  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
279  *
280  * @pre This method can be called if SCIP is in one of the following stages:
281  * - \ref SCIP_STAGE_INIT
282  * - \ref SCIP_STAGE_PROBLEM
283  */
284 SCIP_EXPORT
285 SCIP_RETCODE SCIPsetConshdlrExit(
286  SCIP* scip, /**< SCIP data structure */
287  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
288  SCIP_DECL_CONSEXIT ((*consexit)) /**< deinitialize constraint handler */
289  );
290 
291 /** sets solving process initialization method of constraint handler
292  *
293  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
294  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
295  *
296  * @pre This method can be called if SCIP is in one of the following stages:
297  * - \ref SCIP_STAGE_INIT
298  * - \ref SCIP_STAGE_PROBLEM
299  */
300 SCIP_EXPORT
301 SCIP_RETCODE SCIPsetConshdlrInitsol(
302  SCIP* scip, /**< SCIP data structure */
303  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
304  SCIP_DECL_CONSINITSOL((*consinitsol)) /**< solving process initialization method of constraint handler */
305  );
306 
307 /** sets solving process deinitialization method of constraint handler
308  *
309  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
310  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
311  *
312  * @pre This method can be called if SCIP is in one of the following stages:
313  * - \ref SCIP_STAGE_INIT
314  * - \ref SCIP_STAGE_PROBLEM
315  */
316 SCIP_EXPORT
317 SCIP_RETCODE SCIPsetConshdlrExitsol(
318  SCIP* scip, /**< SCIP data structure */
319  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
320  SCIP_DECL_CONSEXITSOL ((*consexitsol))/**< solving process deinitialization method of constraint handler */
321  );
322 
323 /** sets preprocessing initialization method of constraint handler
324  *
325  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
326  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
327  *
328  * @pre This method can be called if SCIP is in one of the following stages:
329  * - \ref SCIP_STAGE_INIT
330  * - \ref SCIP_STAGE_PROBLEM
331  */
332 SCIP_EXPORT
333 SCIP_RETCODE SCIPsetConshdlrInitpre(
334  SCIP* scip, /**< SCIP data structure */
335  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
336  SCIP_DECL_CONSINITPRE((*consinitpre)) /**< preprocessing initialization method of constraint handler */
337  );
338 
339 /** sets preprocessing deinitialization method of constraint handler
340  *
341  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
342  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
343  *
344  * @pre This method can be called if SCIP is in one of the following stages:
345  * - \ref SCIP_STAGE_INIT
346  * - \ref SCIP_STAGE_PROBLEM
347  */
348 SCIP_EXPORT
349 SCIP_RETCODE SCIPsetConshdlrExitpre(
350  SCIP* scip, /**< SCIP data structure */
351  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
352  SCIP_DECL_CONSEXITPRE((*consexitpre)) /**< preprocessing deinitialization method of constraint handler */
353  );
354 
355 /** sets presolving method of constraint handler
356  *
357  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
358  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
359  *
360  * @pre This method can be called if SCIP is in one of the following stages:
361  * - \ref SCIP_STAGE_INIT
362  * - \ref SCIP_STAGE_PROBLEM
363  */
364 SCIP_EXPORT
365 SCIP_RETCODE SCIPsetConshdlrPresol(
366  SCIP* scip, /**< SCIP data structure */
367  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
368  SCIP_DECL_CONSPRESOL ((*conspresol)), /**< presolving method of constraint handler */
369  int maxprerounds, /**< maximal number of presolving rounds the constraint handler participates in (-1: no limit) */
370  SCIP_PRESOLTIMING presoltiming /**< timing mask of the constraint handler's presolving method */
371  );
372 
373 /** sets method of constraint handler to free specific constraint data
374  *
375  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
376  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
377  *
378  * @pre This method can be called if SCIP is in one of the following stages:
379  * - \ref SCIP_STAGE_INIT
380  * - \ref SCIP_STAGE_PROBLEM
381  */
382 SCIP_EXPORT
383 SCIP_RETCODE SCIPsetConshdlrDelete(
384  SCIP* scip, /**< SCIP data structure */
385  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
386  SCIP_DECL_CONSDELETE ((*consdelete)) /**< free specific constraint data */
387  );
388 
389 /** sets method of constraint handler to transform constraint data into data belonging to the transformed problem
390  *
391  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
392  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
393  *
394  * @pre This method can be called if SCIP is in one of the following stages:
395  * - \ref SCIP_STAGE_INIT
396  * - \ref SCIP_STAGE_PROBLEM
397  */
398 SCIP_EXPORT
399 SCIP_RETCODE SCIPsetConshdlrTrans(
400  SCIP* scip, /**< SCIP data structure */
401  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
402  SCIP_DECL_CONSTRANS ((*constrans)) /**< transform constraint data into data belonging to the transformed problem */
403  );
404 
405 /** sets method of constraint handler to initialize LP with relaxations of "initial" constraints
406  *
407  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
408  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
409  *
410  * @pre This method can be called if SCIP is in one of the following stages:
411  * - \ref SCIP_STAGE_INIT
412  * - \ref SCIP_STAGE_PROBLEM
413  */
414 SCIP_EXPORT
415 SCIP_RETCODE SCIPsetConshdlrInitlp(
416  SCIP* scip, /**< SCIP data structure */
417  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
418  SCIP_DECL_CONSINITLP ((*consinitlp)) /**< initialize LP with relaxations of "initial" constraints */
419  );
420 
421 /** sets propagation conflict resolving method of constraint handler
422  *
423  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
424  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
425  *
426  * @pre This method can be called if SCIP is in one of the following stages:
427  * - \ref SCIP_STAGE_INIT
428  * - \ref SCIP_STAGE_PROBLEM
429  */
430 SCIP_EXPORT
431 SCIP_RETCODE SCIPsetConshdlrResprop(
432  SCIP* scip, /**< SCIP data structure */
433  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
434  SCIP_DECL_CONSRESPROP ((*consresprop)) /**< propagation conflict resolving method */
435  );
436 
437 /** sets activation notification method of constraint handler
438  *
439  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
440  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
441  *
442  * @pre This method can be called if SCIP is in one of the following stages:
443  * - \ref SCIP_STAGE_INIT
444  * - \ref SCIP_STAGE_PROBLEM
445  */
446 SCIP_EXPORT
447 SCIP_RETCODE SCIPsetConshdlrActive(
448  SCIP* scip, /**< SCIP data structure */
449  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
450  SCIP_DECL_CONSACTIVE ((*consactive)) /**< activation notification method */
451  );
452 
453 /** sets deactivation notification method of constraint handler
454  *
455  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
456  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
457  *
458  * @pre This method can be called if SCIP is in one of the following stages:
459  * - \ref SCIP_STAGE_INIT
460  * - \ref SCIP_STAGE_PROBLEM
461  */
462 SCIP_EXPORT
463 SCIP_RETCODE SCIPsetConshdlrDeactive(
464  SCIP* scip, /**< SCIP data structure */
465  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
466  SCIP_DECL_CONSDEACTIVE((*consdeactive)) /**< deactivation notification method */
467  );
468 
469 /** sets enabling notification method of constraint handler
470  *
471  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
472  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
473  *
474  * @pre This method can be called if SCIP is in one of the following stages:
475  * - \ref SCIP_STAGE_INIT
476  * - \ref SCIP_STAGE_PROBLEM
477  */
478 SCIP_EXPORT
479 SCIP_RETCODE SCIPsetConshdlrEnable(
480  SCIP* scip, /**< SCIP data structure */
481  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
482  SCIP_DECL_CONSENABLE ((*consenable)) /**< enabling notification method */
483  );
484 
485 /** sets disabling notification method of constraint handler
486  *
487  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
488  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
489  *
490  * @pre This method can be called if SCIP is in one of the following stages:
491  * - \ref SCIP_STAGE_INIT
492  * - \ref SCIP_STAGE_PROBLEM
493  */
494 SCIP_EXPORT
495 SCIP_RETCODE SCIPsetConshdlrDisable(
496  SCIP* scip, /**< SCIP data structure */
497  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
498  SCIP_DECL_CONSDISABLE ((*consdisable)) /**< disabling notification method */
499  );
500 
501 /** sets variable deletion method of constraint handler
502  *
503  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
504  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
505  *
506  * @pre This method can be called if SCIP is in one of the following stages:
507  * - \ref SCIP_STAGE_INIT
508  * - \ref SCIP_STAGE_PROBLEM
509  */
510 SCIP_EXPORT
511 SCIP_RETCODE SCIPsetConshdlrDelvars(
512  SCIP* scip, /**< SCIP data structure */
513  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
514  SCIP_DECL_CONSDELVARS ((*consdelvars)) /**< variable deletion method */
515  );
516 
517 /** sets constraint display method of constraint handler
518  *
519  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
520  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
521  *
522  * @pre This method can be called if SCIP is in one of the following stages:
523  * - \ref SCIP_STAGE_INIT
524  * - \ref SCIP_STAGE_PROBLEM
525  */
526 SCIP_EXPORT
527 SCIP_RETCODE SCIPsetConshdlrPrint(
528  SCIP* scip, /**< SCIP data structure */
529  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
530  SCIP_DECL_CONSPRINT ((*consprint)) /**< constraint display method */
531  );
532 
533 /** sets constraint parsing method of constraint handler
534  *
535  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
536  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
537  *
538  * @pre This method can be called if SCIP is in one of the following stages:
539  * - \ref SCIP_STAGE_INIT
540  * - \ref SCIP_STAGE_PROBLEM
541  */
542 SCIP_EXPORT
543 SCIP_RETCODE SCIPsetConshdlrParse(
544  SCIP* scip, /**< SCIP data structure */
545  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
546  SCIP_DECL_CONSPARSE ((*consparse)) /**< constraint parsing method */
547  );
548 
549 /** sets constraint variable getter method of constraint handler
550  *
551  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
552  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
553  *
554  * @pre This method can be called if SCIP is in one of the following stages:
555  * - \ref SCIP_STAGE_INIT
556  * - \ref SCIP_STAGE_PROBLEM
557  */
558 SCIP_EXPORT
559 SCIP_RETCODE SCIPsetConshdlrGetVars(
560  SCIP* scip, /**< SCIP data structure */
561  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
562  SCIP_DECL_CONSGETVARS ((*consgetvars)) /**< constraint variable getter method */
563  );
564 
565 /** sets constraint variable number getter method of constraint handler
566  *
567  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
568  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
569  *
570  * @pre This method can be called if SCIP is in one of the following stages:
571  * - \ref SCIP_STAGE_INIT
572  * - \ref SCIP_STAGE_PROBLEM
573  */
574 SCIP_EXPORT
575 SCIP_RETCODE SCIPsetConshdlrGetNVars(
576  SCIP* scip, /**< SCIP data structure */
577  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
578  SCIP_DECL_CONSGETNVARS((*consgetnvars)) /**< constraint variable number getter method */
579  );
580 
581 /** sets diving enforcement method of constraint handler
582  *
583  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
584  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
585  *
586  * @pre This method can be called if SCIP is in one of the following stages:
587  * - \ref SCIP_STAGE_INIT
588  * - \ref SCIP_STAGE_PROBLEM
589  */
590 SCIP_EXPORT
591 SCIP_RETCODE SCIPsetConshdlrGetDiveBdChgs(
592  SCIP* scip, /**< SCIP data structure */
593  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
594  SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs)) /**< constraint handler diving solution enforcement method */
595  );
596 
597 /** returns the constraint handler of the given name, or NULL if not existing */
598 SCIP_EXPORT
599 SCIP_CONSHDLR* SCIPfindConshdlr(
600  SCIP* scip, /**< SCIP data structure */
601  const char* name /**< name of constraint handler */
602  );
603 
604 /** returns the array of currently available constraint handlers */
605 SCIP_EXPORT
606 SCIP_CONSHDLR** SCIPgetConshdlrs(
607  SCIP* scip /**< SCIP data structure */
608  );
609 
610 /** returns the number of currently available constraint handlers */
611 SCIP_EXPORT
612 int SCIPgetNConshdlrs(
613  SCIP* scip /**< SCIP data structure */
614  );
615 
616 /** @} */
617 
618 /**@addtogroup PublicConstraintMethods
619  *
620  * @{
621  */
622 
623 /** creates and captures a constraint of the given constraint handler
624  *
625  * @warning If a constraint is marked to be checked for feasibility but not to be enforced, a LP or pseudo solution may
626  * be declared feasible even if it violates this particular constraint. This constellation should only be
627  * used, if no LP or pseudo solution can violate the constraint -- e.g. if a local constraint is redundant due
628  * to the variable's local bounds.
629  *
630  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
631  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
632  *
633  * @pre This method can be called if @p scip is in one of the following stages:
634  * - \ref SCIP_STAGE_PROBLEM
635  * - \ref SCIP_STAGE_TRANSFORMING
636  * - \ref SCIP_STAGE_INITPRESOLVE
637  * - \ref SCIP_STAGE_PRESOLVING
638  * - \ref SCIP_STAGE_EXITPRESOLVE
639  * - \ref SCIP_STAGE_PRESOLVED
640  * - \ref SCIP_STAGE_INITSOLVE
641  * - \ref SCIP_STAGE_SOLVING
642  * - \ref SCIP_STAGE_EXITSOLVE
643  *
644  * @note the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()
645  */
646 SCIP_EXPORT
647 SCIP_RETCODE SCIPcreateCons(
648  SCIP* scip, /**< SCIP data structure */
649  SCIP_CONS** cons, /**< pointer to constraint */
650  const char* name, /**< name of constraint */
651  SCIP_CONSHDLR* conshdlr, /**< constraint handler for this constraint */
652  SCIP_CONSDATA* consdata, /**< data for this specific constraint */
653  SCIP_Bool initial, /**< should the LP relaxation of constraint be in the initial LP?
654  * Usually set to TRUE. Set to FALSE for 'lazy constraints'. */
655  SCIP_Bool separate, /**< should the constraint be separated during LP processing?
656  * Usually set to TRUE. */
657  SCIP_Bool enforce, /**< should the constraint be enforced during node processing?
658  * TRUE for model constraints, FALSE for additional, redundant constraints. */
659  SCIP_Bool check, /**< should the constraint be checked for feasibility?
660  * TRUE for model constraints, FALSE for additional, redundant constraints. */
661  SCIP_Bool propagate, /**< should the constraint be propagated during node processing?
662  * Usually set to TRUE. */
663  SCIP_Bool local, /**< is constraint only valid locally?
664  * Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints. */
665  SCIP_Bool modifiable, /**< is constraint modifiable (subject to column generation)?
666  * Usually set to FALSE. In column generation applications, set to TRUE if pricing
667  * adds coefficients to this constraint. */
668  SCIP_Bool dynamic, /**< is constraint subject to aging?
669  * Usually set to FALSE. Set to TRUE for own cuts which
670  * are separated as constraints. */
671  SCIP_Bool removable, /**< should the relaxation be removed from the LP due to aging or cleanup?
672  * Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'. */
673  SCIP_Bool stickingatnode /**< should the constraint always be kept at the node where it was added, even
674  * if it may be moved to a more global node?
675  * Usually set to FALSE. Set to TRUE to for constraints that represent node data. */
676  );
677 
678 /** parses constraint information (in cip format) out of a string; if the parsing process was successful a constraint is
679  * creates and captures;
680  *
681  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
682  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
683  *
684  * @pre This method can be called if @p scip is in one of the following stages:
685  * - \ref SCIP_STAGE_PROBLEM
686  * - \ref SCIP_STAGE_TRANSFORMING
687  * - \ref SCIP_STAGE_INITPRESOLVE
688  * - \ref SCIP_STAGE_PRESOLVING
689  * - \ref SCIP_STAGE_EXITPRESOLVE
690  * - \ref SCIP_STAGE_PRESOLVED
691  * - \ref SCIP_STAGE_SOLVING
692  * - \ref SCIP_STAGE_EXITSOLVE
693  *
694  * @warning If a constraint is marked to be checked for feasibility but not to be enforced, a LP or pseudo solution may
695  * be declared feasible even if it violates this particular constraint. This constellation should only be
696  * used, if no LP or pseudo solution can violate the constraint -- e.g. if a local constraint is redundant due
697  * to the variable's local bounds.
698  */
699 SCIP_EXPORT
700 SCIP_RETCODE SCIPparseCons(
701  SCIP* scip, /**< SCIP data structure */
702  SCIP_CONS** cons, /**< pointer to store constraint */
703  const char* str, /**< string to parse for constraint */
704  SCIP_Bool initial, /**< should the LP relaxation of constraint be in the initial LP?
705  * Usually set to TRUE. Set to FALSE for 'lazy constraints'. */
706  SCIP_Bool separate, /**< should the constraint be separated during LP processing?
707  * Usually set to TRUE. */
708  SCIP_Bool enforce, /**< should the constraint be enforced during node processing?
709  * TRUE for model constraints, FALSE for additional, redundant constraints. */
710  SCIP_Bool check, /**< should the constraint be checked for feasibility?
711  * TRUE for model constraints, FALSE for additional, redundant constraints. */
712  SCIP_Bool propagate, /**< should the constraint be propagated during node processing?
713  * Usually set to TRUE. */
714  SCIP_Bool local, /**< is constraint only valid locally?
715  * Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints. */
716  SCIP_Bool modifiable, /**< is constraint modifiable (subject to column generation)?
717  * Usually set to FALSE. In column generation applications, set to TRUE if pricing
718  * adds coefficients to this constraint. */
719  SCIP_Bool dynamic, /**< is constraint subject to aging?
720  * Usually set to FALSE. Set to TRUE for own cuts which
721  * are separated as constraints. */
722  SCIP_Bool removable, /**< should the relaxation be removed from the LP due to aging or cleanup?
723  * Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'. */
724  SCIP_Bool stickingatnode, /**< should the constraint always be kept at the node where it was added, even
725  * if it may be moved to a more global node?
726  * Usually set to FALSE. Set to TRUE to for constraints that represent node data. */
727  SCIP_Bool* success /**< pointer to store if the paring process was successful */
728  );
729 
730 /** increases usage counter of constraint
731  *
732  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
733  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
734  *
735  * @pre This method can be called if @p scip is in one of the following stages:
736  * - \ref SCIP_STAGE_PROBLEM
737  * - \ref SCIP_STAGE_TRANSFORMING
738  * - \ref SCIP_STAGE_TRANSFORMED
739  * - \ref SCIP_STAGE_INITPRESOLVE
740  * - \ref SCIP_STAGE_PRESOLVING
741  * - \ref SCIP_STAGE_EXITPRESOLVE
742  * - \ref SCIP_STAGE_PRESOLVED
743  * - \ref SCIP_STAGE_INITSOLVE
744  * - \ref SCIP_STAGE_SOLVING
745  * - \ref SCIP_STAGE_SOLVED
746  */
747 SCIP_EXPORT
748 SCIP_RETCODE SCIPcaptureCons(
749  SCIP* scip, /**< SCIP data structure */
750  SCIP_CONS* cons /**< constraint to capture */
751  );
752 
753 /** decreases usage counter of constraint, if the usage pointer reaches zero the constraint gets freed
754  *
755  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
756  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
757  *
758  * @pre This method can be called if @p scip is in one of the following stages:
759  * - \ref SCIP_STAGE_PROBLEM
760  * - \ref SCIP_STAGE_TRANSFORMING
761  * - \ref SCIP_STAGE_TRANSFORMED
762  * - \ref SCIP_STAGE_INITPRESOLVE
763  * - \ref SCIP_STAGE_PRESOLVING
764  * - \ref SCIP_STAGE_EXITPRESOLVE
765  * - \ref SCIP_STAGE_PRESOLVED
766  * - \ref SCIP_STAGE_INITSOLVE
767  * - \ref SCIP_STAGE_SOLVING
768  * - \ref SCIP_STAGE_SOLVED
769  * - \ref SCIP_STAGE_EXITSOLVE
770  * - \ref SCIP_STAGE_FREETRANS
771  *
772  * @note the pointer of the constraint will be NULLed
773  */
774 SCIP_EXPORT
775 SCIP_RETCODE SCIPreleaseCons(
776  SCIP* scip, /**< SCIP data structure */
777  SCIP_CONS** cons /**< pointer to constraint */
778  );
779 
780 /** change constraint name
781  *
782  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
783  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
784  *
785  * @pre This method can be called if @p scip is in one of the following stages:
786  * - \ref SCIP_STAGE_PROBLEM
787  *
788  * @note to get the current name of a constraint, use SCIPconsGetName() from pub_cons.h
789  */
790 SCIP_EXPORT
791 SCIP_RETCODE SCIPchgConsName(
792  SCIP* scip, /**< SCIP data structure */
793  SCIP_CONS* cons, /**< constraint */
794  const char* name /**< new name of constraint */
795  );
796 
797 /** sets the initial flag of the given constraint
798  *
799  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
800  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
801  *
802  * @pre This method can be called if @p scip is in one of the following stages:
803  * - \ref SCIP_STAGE_PROBLEM
804  * - \ref SCIP_STAGE_TRANSFORMING
805  * - \ref SCIP_STAGE_PRESOLVING
806  * - \ref SCIP_STAGE_PRESOLVED
807  * - \ref SCIP_STAGE_SOLVING
808  */
809 SCIP_EXPORT
810 SCIP_RETCODE SCIPsetConsInitial(
811  SCIP* scip, /**< SCIP data structure */
812  SCIP_CONS* cons, /**< constraint */
813  SCIP_Bool initial /**< new value */
814  );
815 
816 /** sets the separate flag of the given constraint
817  *
818  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
819  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
820  *
821  * @pre This method can be called if @p scip is in one of the following stages:
822  * - \ref SCIP_STAGE_PROBLEM
823  * - \ref SCIP_STAGE_TRANSFORMING
824  * - \ref SCIP_STAGE_PRESOLVING
825  * - \ref SCIP_STAGE_PRESOLVED
826  * - \ref SCIP_STAGE_SOLVING
827  */
828 SCIP_EXPORT
829 SCIP_RETCODE SCIPsetConsSeparated(
830  SCIP* scip, /**< SCIP data structure */
831  SCIP_CONS* cons, /**< constraint */
832  SCIP_Bool separate /**< new value */
833  );
834 
835 /** sets the enforce flag of the given constraint
836  *
837  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
838  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
839  *
840  * @pre This method can be called if @p scip is in one of the following stages:
841  * - \ref SCIP_STAGE_PROBLEM
842  * - \ref SCIP_STAGE_TRANSFORMING
843  * - \ref SCIP_STAGE_PRESOLVING
844  * - \ref SCIP_STAGE_PRESOLVED
845  * - \ref SCIP_STAGE_SOLVING
846  */
847 SCIP_EXPORT
848 SCIP_RETCODE SCIPsetConsEnforced(
849  SCIP* scip, /**< SCIP data structure */
850  SCIP_CONS* cons, /**< constraint */
851  SCIP_Bool enforce /**< new value */
852  );
853 
854 /** sets the check flag of the given constraint
855  *
856  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
857  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
858  *
859  * @pre This method can be called if @p scip is in one of the following stages:
860  * - \ref SCIP_STAGE_PROBLEM
861  * - \ref SCIP_STAGE_TRANSFORMING
862  * - \ref SCIP_STAGE_PRESOLVING
863  * - \ref SCIP_STAGE_PRESOLVED
864  * - \ref SCIP_STAGE_SOLVING
865  */
866 SCIP_EXPORT
867 SCIP_RETCODE SCIPsetConsChecked(
868  SCIP* scip, /**< SCIP data structure */
869  SCIP_CONS* cons, /**< constraint */
870  SCIP_Bool check /**< new value */
871  );
872 
873 /** sets the propagate flag of the given constraint
874  *
875  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
876  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
877  *
878  * @pre This method can be called if @p scip is in one of the following stages:
879  * - \ref SCIP_STAGE_PROBLEM
880  * - \ref SCIP_STAGE_TRANSFORMING
881  * - \ref SCIP_STAGE_PRESOLVING
882  * - \ref SCIP_STAGE_PRESOLVED
883  * - \ref SCIP_STAGE_SOLVING
884  */
885 SCIP_EXPORT
886 SCIP_RETCODE SCIPsetConsPropagated(
887  SCIP* scip, /**< SCIP data structure */
888  SCIP_CONS* cons, /**< constraint */
889  SCIP_Bool propagate /**< new value */
890  );
891 
892 /** sets the local flag of the given constraint
893  *
894  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
895  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
896  *
897  * @pre This method can be called if @p scip is in one of the following stages:
898  * - \ref SCIP_STAGE_PROBLEM
899  * - \ref SCIP_STAGE_TRANSFORMING
900  * - \ref SCIP_STAGE_INITPRESOLVE
901  * - \ref SCIP_STAGE_PRESOLVING
902  * - \ref SCIP_STAGE_PRESOLVED
903  * - \ref SCIP_STAGE_INITSOLVE
904  * - \ref SCIP_STAGE_SOLVING
905  */
906 SCIP_EXPORT
907 SCIP_RETCODE SCIPsetConsLocal(
908  SCIP* scip, /**< SCIP data structure */
909  SCIP_CONS* cons, /**< constraint */
910  SCIP_Bool local /**< new value */
911  );
912 
913 /** sets the modifiable flag of the given constraint
914  *
915  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
916  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
917  *
918  * @pre This method can be called if @p scip is in one of the following stages:
919  * - \ref SCIP_STAGE_PROBLEM
920  * - \ref SCIP_STAGE_TRANSFORMING
921  * - \ref SCIP_STAGE_PRESOLVING
922  * - \ref SCIP_STAGE_PRESOLVED
923  * - \ref SCIP_STAGE_SOLVING
924  * - \ref SCIP_STAGE_EXITSOLVE
925  */
926 SCIP_EXPORT
927 SCIP_RETCODE SCIPsetConsModifiable(
928  SCIP* scip, /**< SCIP data structure */
929  SCIP_CONS* cons, /**< constraint */
930  SCIP_Bool modifiable /**< new value */
931  );
932 
933 /** sets the dynamic flag of the given constraint
934  *
935  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
936  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
937  *
938  * @pre This method can be called if @p scip is in one of the following stages:
939  * - \ref SCIP_STAGE_PROBLEM
940  * - \ref SCIP_STAGE_TRANSFORMING
941  * - \ref SCIP_STAGE_PRESOLVING
942  * - \ref SCIP_STAGE_PRESOLVED
943  * - \ref SCIP_STAGE_SOLVING
944  */
945 SCIP_EXPORT
946 SCIP_RETCODE SCIPsetConsDynamic(
947  SCIP* scip, /**< SCIP data structure */
948  SCIP_CONS* cons, /**< constraint */
949  SCIP_Bool dynamic /**< new value */
950  );
951 
952 /** sets the removable flag of the given constraint
953  *
954  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
955  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
956  *
957  * @pre This method can be called if @p scip is in one of the following stages:
958  * - \ref SCIP_STAGE_PROBLEM
959  * - \ref SCIP_STAGE_TRANSFORMING
960  * - \ref SCIP_STAGE_PRESOLVING
961  * - \ref SCIP_STAGE_PRESOLVED
962  * - \ref SCIP_STAGE_SOLVING
963  */
964 SCIP_EXPORT
965 SCIP_RETCODE SCIPsetConsRemovable(
966  SCIP* scip, /**< SCIP data structure */
967  SCIP_CONS* cons, /**< constraint */
968  SCIP_Bool removable /**< new value */
969  );
970 
971 /** sets the stickingatnode flag of the given constraint
972  *
973  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
974  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
975  *
976  * @pre This method can be called if @p scip is in one of the following stages:
977  * - \ref SCIP_STAGE_PROBLEM
978  * - \ref SCIP_STAGE_TRANSFORMING
979  * - \ref SCIP_STAGE_PRESOLVING
980  * - \ref SCIP_STAGE_PRESOLVED
981  * - \ref SCIP_STAGE_SOLVING
982  */
983 SCIP_EXPORT
984 SCIP_RETCODE SCIPsetConsStickingAtNode(
985  SCIP* scip, /**< SCIP data structure */
986  SCIP_CONS* cons, /**< constraint */
987  SCIP_Bool stickingatnode /**< new value */
988  );
989 
990 /** updates the flags of the first constraint according to the ones of the second constraint
991  *
992  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
993  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
994  *
995  * @pre This method can be called if @p scip is in one of the following stages:
996  * - \ref SCIP_STAGE_PROBLEM
997  * - \ref SCIP_STAGE_TRANSFORMING
998  * - \ref SCIP_STAGE_PRESOLVING
999  * - \ref SCIP_STAGE_PRESOLVED
1000  * - \ref SCIP_STAGE_SOLVING
1001  */
1002 SCIP_EXPORT
1003 SCIP_RETCODE SCIPupdateConsFlags(
1004  SCIP* scip, /**< SCIP data structure */
1005  SCIP_CONS* cons0, /**< constraint that should stay */
1006  SCIP_CONS* cons1 /**< constraint that should be deleted */
1007  );
1008 
1009 /** gets and captures transformed constraint of a given constraint; if the constraint is not yet transformed,
1010  * a new transformed constraint for this constraint is created
1011  *
1012  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1013  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1014  *
1015  * @pre This method can be called if @p scip is in one of the following stages:
1016  * - \ref SCIP_STAGE_TRANSFORMING
1017  * - \ref SCIP_STAGE_TRANSFORMED
1018  * - \ref SCIP_STAGE_INITPRESOLVE
1019  * - \ref SCIP_STAGE_PRESOLVING
1020  * - \ref SCIP_STAGE_EXITPRESOLVE
1021  * - \ref SCIP_STAGE_PRESOLVED
1022  * - \ref SCIP_STAGE_INITSOLVE
1023  * - \ref SCIP_STAGE_SOLVING
1024  */
1025 SCIP_EXPORT
1026 SCIP_RETCODE SCIPtransformCons(
1027  SCIP* scip, /**< SCIP data structure */
1028  SCIP_CONS* cons, /**< constraint to get/create transformed constraint for */
1029  SCIP_CONS** transcons /**< pointer to store the transformed constraint */
1030  );
1031 
1032 /** gets and captures transformed constraints for an array of constraints;
1033  * if a constraint in the array is not yet transformed, a new transformed constraint for this constraint is created;
1034  * it is possible to call this method with conss == transconss
1035  *
1036  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1037  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1038  *
1039  * @pre This method can be called if @p scip is in one of the following stages:
1040  * - \ref SCIP_STAGE_TRANSFORMING
1041  * - \ref SCIP_STAGE_TRANSFORMED
1042  * - \ref SCIP_STAGE_INITPRESOLVE
1043  * - \ref SCIP_STAGE_PRESOLVING
1044  * - \ref SCIP_STAGE_EXITPRESOLVE
1045  * - \ref SCIP_STAGE_PRESOLVED
1046  * - \ref SCIP_STAGE_INITSOLVE
1047  * - \ref SCIP_STAGE_SOLVING
1048  */
1049 SCIP_EXPORT
1050 SCIP_RETCODE SCIPtransformConss(
1051  SCIP* scip, /**< SCIP data structure */
1052  int nconss, /**< number of constraints to get/create transformed constraints for */
1053  SCIP_CONS** conss, /**< array with constraints to get/create transformed constraints for */
1054  SCIP_CONS** transconss /**< array to store the transformed constraints */
1055  );
1056 
1057 /** gets corresponding transformed constraint of a given constraint;
1058  * returns NULL as transcons, if transformed constraint is not yet existing
1059  *
1060  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1061  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1062  *
1063  * @pre This method can be called if @p scip is in one of the following stages:
1064  * - \ref SCIP_STAGE_TRANSFORMING
1065  * - \ref SCIP_STAGE_TRANSFORMED
1066  * - \ref SCIP_STAGE_INITPRESOLVE
1067  * - \ref SCIP_STAGE_PRESOLVING
1068  * - \ref SCIP_STAGE_EXITPRESOLVE
1069  * - \ref SCIP_STAGE_PRESOLVED
1070  * - \ref SCIP_STAGE_INITSOLVE
1071  * - \ref SCIP_STAGE_SOLVING
1072  * - \ref SCIP_STAGE_SOLVED
1073  * - \ref SCIP_STAGE_EXITSOLVE
1074  * - \ref SCIP_STAGE_FREETRANS
1075  */
1076 SCIP_EXPORT
1077 SCIP_RETCODE SCIPgetTransformedCons(
1078  SCIP* scip, /**< SCIP data structure */
1079  SCIP_CONS* cons, /**< constraint to get the transformed constraint for */
1080  SCIP_CONS** transcons /**< pointer to store the transformed constraint */
1081  );
1082 
1083 /** gets corresponding transformed constraints for an array of constraints;
1084  * stores NULL in a transconss slot, if the transformed constraint is not yet existing;
1085  * it is possible to call this method with conss == transconss, but remember that constraints that are not
1086  * yet transformed will be replaced with NULL
1087  *
1088  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1089  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1090  *
1091  * @pre This method can be called if @p scip is in one of the following stages:
1092  * - \ref SCIP_STAGE_TRANSFORMING
1093  * - \ref SCIP_STAGE_TRANSFORMED
1094  * - \ref SCIP_STAGE_INITPRESOLVE
1095  * - \ref SCIP_STAGE_PRESOLVING
1096  * - \ref SCIP_STAGE_EXITPRESOLVE
1097  * - \ref SCIP_STAGE_PRESOLVED
1098  * - \ref SCIP_STAGE_INITSOLVE
1099  * - \ref SCIP_STAGE_SOLVING
1100  * - \ref SCIP_STAGE_SOLVED
1101  * - \ref SCIP_STAGE_EXITSOLVE
1102  * - \ref SCIP_STAGE_FREETRANS
1103  */
1104 SCIP_EXPORT
1105 SCIP_RETCODE SCIPgetTransformedConss(
1106  SCIP* scip, /**< SCIP data structure */
1107  int nconss, /**< number of constraints to get the transformed constraints for */
1108  SCIP_CONS** conss, /**< constraints to get the transformed constraints for */
1109  SCIP_CONS** transconss /**< array to store the transformed constraints */
1110  );
1111 
1112 /** adds given value to age of constraint, but age can never become negative;
1113  * should be called
1114  * - in constraint separation, if no cut was found for this constraint,
1115  * - in constraint enforcing, if constraint was feasible, and
1116  * - in constraint propagation, if no domain reduction was deduced;
1117  *
1118  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1119  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1120  *
1121  * @pre This method can be called if @p scip is in one of the following stages:
1122  * - \ref SCIP_STAGE_TRANSFORMED
1123  * - \ref SCIP_STAGE_PRESOLVING
1124  * - \ref SCIP_STAGE_PRESOLVED
1125  * - \ref SCIP_STAGE_SOLVING
1126  * - \ref SCIP_STAGE_SOLVED
1127  */
1128 SCIP_EXPORT
1129 SCIP_RETCODE SCIPaddConsAge(
1130  SCIP* scip, /**< SCIP data structure */
1131  SCIP_CONS* cons, /**< constraint */
1132  SCIP_Real deltaage /**< value to add to the constraint's age */
1133  );
1134 
1135 /** increases age of constraint by 1.0;
1136  * should be called
1137  * - in constraint separation, if no cut was found for this constraint,
1138  * - in constraint enforcing, if constraint was feasible, and
1139  * - in constraint propagation, if no domain reduction was deduced;
1140  *
1141  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1142  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1143  *
1144  * @pre This method can be called if @p scip is in one of the following stages:
1145  * - \ref SCIP_STAGE_TRANSFORMED
1146  * - \ref SCIP_STAGE_PRESOLVING
1147  * - \ref SCIP_STAGE_PRESOLVED
1148  * - \ref SCIP_STAGE_SOLVING
1149  * - \ref SCIP_STAGE_SOLVED
1150  */
1151 SCIP_EXPORT
1152 SCIP_RETCODE SCIPincConsAge(
1153  SCIP* scip, /**< SCIP data structure */
1154  SCIP_CONS* cons /**< constraint */
1155  );
1156 
1157 /** resets age of constraint to zero;
1158  * should be called
1159  * - in constraint separation, if a cut was found for this constraint,
1160  * - in constraint enforcing, if the constraint was violated, and
1161  * - in constraint propagation, if a domain reduction was deduced;
1162  *
1163  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1164  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1165  *
1166  * @pre This method can be called if @p scip is in one of the following stages:
1167  * - \ref SCIP_STAGE_TRANSFORMED
1168  * - \ref SCIP_STAGE_PRESOLVING
1169  * - \ref SCIP_STAGE_PRESOLVED
1170  * - \ref SCIP_STAGE_SOLVING
1171  * - \ref SCIP_STAGE_SOLVED
1172  */
1173 SCIP_EXPORT
1174 SCIP_RETCODE SCIPresetConsAge(
1175  SCIP* scip, /**< SCIP data structure */
1176  SCIP_CONS* cons /**< constraint */
1177  );
1178 
1179 /** enables constraint's separation, propagation, and enforcing capabilities
1180  *
1181  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1182  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1183  *
1184  * @pre This method can be called if @p scip is in one of the following stages:
1185  * - \ref SCIP_STAGE_TRANSFORMED
1186  * - \ref SCIP_STAGE_PRESOLVING
1187  * - \ref SCIP_STAGE_PRESOLVED
1188  * - \ref SCIP_STAGE_INITSOLVE
1189  * - \ref SCIP_STAGE_SOLVING
1190  * - \ref SCIP_STAGE_SOLVED
1191  */
1192 SCIP_EXPORT
1193 SCIP_RETCODE SCIPenableCons(
1194  SCIP* scip, /**< SCIP data structure */
1195  SCIP_CONS* cons /**< constraint */
1196  );
1197 
1198 /** disables constraint's separation, propagation, and enforcing capabilities, s.t. the constraint is not propagated,
1199  * separated, and enforced anymore until it is enabled again with a call to SCIPenableCons();
1200  * in contrast to SCIPdelConsLocal() and SCIPdelConsNode(), the disabling is not associated to a node in the tree and
1201  * does not consume memory; therefore, the constraint is neither automatically enabled on leaving the node nor
1202  * automatically disabled again on entering the node again;
1203  * note that the constraints enforcing capabilities are necessary for the solution's feasibility, if the constraint
1204  * is a model constraint; that means, you must be sure that the constraint cannot be violated in the current subtree,
1205  * and you have to enable it again manually by calling SCIPenableCons(), if this subtree is left (e.g. by using
1206  * an appropriate event handler that watches the corresponding variables' domain changes)
1207  *
1208  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1209  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1210  *
1211  * @pre This method can be called if @p scip is in one of the following stages:
1212  * - \ref SCIP_STAGE_TRANSFORMED
1213  * - \ref SCIP_STAGE_INITPRESOLVE
1214  * - \ref SCIP_STAGE_PRESOLVING
1215  * - \ref SCIP_STAGE_PRESOLVED
1216  * - \ref SCIP_STAGE_INITSOLVE
1217  * - \ref SCIP_STAGE_SOLVING
1218  * - \ref SCIP_STAGE_SOLVED
1219  */
1220 SCIP_EXPORT
1221 SCIP_RETCODE SCIPdisableCons(
1222  SCIP* scip, /**< SCIP data structure */
1223  SCIP_CONS* cons /**< constraint */
1224  );
1225 
1226 /** enables constraint's separation capabilities
1227  *
1228  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1229  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1230  *
1231  * @pre This method can be called if @p scip is in one of the following stages:
1232  * - \ref SCIP_STAGE_TRANSFORMED
1233  * - \ref SCIP_STAGE_PRESOLVING
1234  * - \ref SCIP_STAGE_PRESOLVED
1235  * - \ref SCIP_STAGE_INITSOLVE
1236  * - \ref SCIP_STAGE_SOLVING
1237  * - \ref SCIP_STAGE_SOLVED
1238  */
1239 SCIP_EXPORT
1240 SCIP_RETCODE SCIPenableConsSeparation(
1241  SCIP* scip, /**< SCIP data structure */
1242  SCIP_CONS* cons /**< constraint */
1243  );
1244 
1245 /** disables constraint's separation capabilities s.t. the constraint is not propagated anymore until the separation
1246  * is enabled again with a call to SCIPenableConsSeparation(); in contrast to SCIPdelConsLocal() and SCIPdelConsNode(),
1247  * the disabling is not associated to a node in the tree and does not consume memory; therefore, the constraint
1248  * is neither automatically enabled on leaving the node nor automatically disabled again on entering the node again
1249  *
1250  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1251  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1252  *
1253  * @pre This method can be called if @p scip is in one of the following stages:
1254  * - \ref SCIP_STAGE_TRANSFORMED
1255  * - \ref SCIP_STAGE_PRESOLVING
1256  * - \ref SCIP_STAGE_PRESOLVED
1257  * - \ref SCIP_STAGE_INITSOLVE
1258  * - \ref SCIP_STAGE_SOLVING
1259  * - \ref SCIP_STAGE_SOLVED
1260  */
1261 SCIP_EXPORT
1262 SCIP_RETCODE SCIPdisableConsSeparation(
1263  SCIP* scip, /**< SCIP data structure */
1264  SCIP_CONS* cons /**< constraint */
1265  );
1266 
1267 /** enables constraint's propagation capabilities
1268  *
1269  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1270  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1271  *
1272  * @pre This method can be called if @p scip is in one of the following stages:
1273  * - \ref SCIP_STAGE_TRANSFORMED
1274  * - \ref SCIP_STAGE_INITPRESOLVE
1275  * - \ref SCIP_STAGE_PRESOLVING
1276  * - \ref SCIP_STAGE_EXITPRESOLVE
1277  * - \ref SCIP_STAGE_PRESOLVED
1278  * - \ref SCIP_STAGE_INITSOLVE
1279  * - \ref SCIP_STAGE_SOLVING
1280  * - \ref SCIP_STAGE_SOLVED
1281  */
1282 SCIP_EXPORT
1283 SCIP_RETCODE SCIPenableConsPropagation(
1284  SCIP* scip, /**< SCIP data structure */
1285  SCIP_CONS* cons /**< constraint */
1286  );
1287 
1288 /** disables constraint's propagation capabilities s.t. the constraint is not propagated anymore until the propagation
1289  * is enabled again with a call to SCIPenableConsPropagation(); in contrast to SCIPdelConsLocal() and SCIPdelConsNode(),
1290  * the disabling is not associated to a node in the tree and does not consume memory; therefore, the constraint
1291  * is neither automatically enabled on leaving the node nor automatically disabled again on entering the node again
1292  *
1293  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1294  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1295  *
1296  * @pre This method can be called if @p scip is in one of the following stages:
1297  * - \ref SCIP_STAGE_TRANSFORMED
1298  * - \ref SCIP_STAGE_INITPRESOLVE
1299  * - \ref SCIP_STAGE_PRESOLVING
1300  * - \ref SCIP_STAGE_EXITPRESOLVE
1301  * - \ref SCIP_STAGE_PRESOLVED
1302  * - \ref SCIP_STAGE_INITSOLVE
1303  * - \ref SCIP_STAGE_SOLVING
1304  * - \ref SCIP_STAGE_SOLVED
1305  */
1306 SCIP_EXPORT
1307 SCIP_RETCODE SCIPdisableConsPropagation(
1308  SCIP* scip, /**< SCIP data structure */
1309  SCIP_CONS* cons /**< constraint */
1310  );
1311 
1312 
1313 /** marks constraint to be propagated
1314  *
1315  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1316  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1317  *
1318  * @pre This method can be called if @p scip is in one of the following stages:
1319  * - \ref SCIP_STAGE_TRANSFORMING
1320  * - \ref SCIP_STAGE_TRANSFORMED
1321  * - \ref SCIP_STAGE_PRESOLVING
1322  * - \ref SCIP_STAGE_EXITPRESOLVE
1323  * - \ref SCIP_STAGE_PRESOLVED
1324  * - \ref SCIP_STAGE_INITSOLVE
1325  * - \ref SCIP_STAGE_SOLVING
1326  * - \ref SCIP_STAGE_SOLVED
1327  *
1328  * @note if a constraint is marked to be propagated, the age of the constraint will be ignored for propagation
1329  */
1330 SCIP_EXPORT
1331 SCIP_RETCODE SCIPmarkConsPropagate(
1332  SCIP* scip, /**< SCIP data structure */
1333  SCIP_CONS* cons /**< constraint */
1334  );
1335 
1336 /** unmarks the constraint to be propagated
1337  *
1338  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1339  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1340  *
1341  * @pre This method can be called if @p scip is in one of the following stages:
1342  * - \ref SCIP_STAGE_TRANSFORMED
1343  * - \ref SCIP_STAGE_PRESOLVING
1344  * - \ref SCIP_STAGE_EXITPRESOLVE
1345  * - \ref SCIP_STAGE_PRESOLVED
1346  * - \ref SCIP_STAGE_INITSOLVE
1347  * - \ref SCIP_STAGE_SOLVING
1348  * - \ref SCIP_STAGE_SOLVED
1349  */
1350 SCIP_EXPORT
1351 SCIP_RETCODE SCIPunmarkConsPropagate(
1352  SCIP* scip, /**< SCIP data structure */
1353  SCIP_CONS* cons /**< constraint */
1354  );
1355 
1356 /** adds given values to lock status of type @p locktype of the constraint and updates the rounding locks of the involved variables
1357  *
1358  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1359  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1360  *
1361  * @pre This method can be called if @p scip is in one of the following stages:
1362  * - \ref SCIP_STAGE_PROBLEM
1363  * - \ref SCIP_STAGE_TRANSFORMING
1364  * - \ref SCIP_STAGE_INITPRESOLVE
1365  * - \ref SCIP_STAGE_PRESOLVING
1366  * - \ref SCIP_STAGE_EXITPRESOLVE
1367  * - \ref SCIP_STAGE_INITSOLVE
1368  * - \ref SCIP_STAGE_SOLVING
1369  * - \ref SCIP_STAGE_EXITSOLVE
1370  * - \ref SCIP_STAGE_FREETRANS
1371  */
1372 SCIP_EXPORT
1373 SCIP_RETCODE SCIPaddConsLocksType(
1374  SCIP* scip, /**< SCIP data structure */
1375  SCIP_CONS* cons, /**< constraint */
1376  SCIP_LOCKTYPE locktype, /**< type of the variable locks */
1377  int nlockspos, /**< increase in number of rounding locks for constraint */
1378  int nlocksneg /**< increase in number of rounding locks for constraint's negation */
1379  );
1380 
1381 /** adds given values to lock status of the constraint and updates the rounding locks of the involved variables
1382  *
1383  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1384  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1385  *
1386  * @pre This method can be called if @p scip is in one of the following stages:
1387  * - \ref SCIP_STAGE_PROBLEM
1388  * - \ref SCIP_STAGE_TRANSFORMING
1389  * - \ref SCIP_STAGE_INITPRESOLVE
1390  * - \ref SCIP_STAGE_PRESOLVING
1391  * - \ref SCIP_STAGE_EXITPRESOLVE
1392  * - \ref SCIP_STAGE_INITSOLVE
1393  * - \ref SCIP_STAGE_SOLVING
1394  * - \ref SCIP_STAGE_EXITSOLVE
1395  * - \ref SCIP_STAGE_FREETRANS
1396  *
1397  * @note This methods always adds locks of type model
1398  */
1399 SCIP_EXPORT
1400 SCIP_RETCODE SCIPaddConsLocks(
1401  SCIP* scip, /**< SCIP data structure */
1402  SCIP_CONS* cons, /**< constraint */
1403  int nlockspos, /**< increase in number of rounding locks for constraint */
1404  int nlocksneg /**< increase in number of rounding locks for constraint's negation */
1405  );
1406 
1407 /** checks single constraint for feasibility of the given solution
1408  *
1409  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1410  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1411  *
1412  * @pre This method can be called if @p scip is in one of the following stages:
1413  * - \ref SCIP_STAGE_TRANSFORMED
1414  * - \ref SCIP_STAGE_INITPRESOLVE
1415  * - \ref SCIP_STAGE_PRESOLVING
1416  * - \ref SCIP_STAGE_EXITPRESOLVE
1417  * - \ref SCIP_STAGE_PRESOLVED
1418  * - \ref SCIP_STAGE_INITSOLVE
1419  * - \ref SCIP_STAGE_SOLVING
1420  * - \ref SCIP_STAGE_SOLVED
1421  */
1422 SCIP_EXPORT
1423 SCIP_RETCODE SCIPcheckCons(
1424  SCIP* scip, /**< SCIP data structure */
1425  SCIP_CONS* cons, /**< constraint to check */
1426  SCIP_SOL* sol, /**< primal CIP solution */
1427  SCIP_Bool checkintegrality, /**< Has integrality to be checked? */
1428  SCIP_Bool checklprows, /**< Do constraints represented by rows in the current LP have to be checked? */
1429  SCIP_Bool printreason, /**< Should the reason for the violation be printed? */
1430  SCIP_RESULT* result /**< pointer to store the result of the callback method */
1431  );
1432 
1433 /** enforces single constraint for a given pseudo solution
1434  *
1435  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1436  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1437  *
1438  * @pre This method can be called if @p scip is in one of the following stages:
1439  * - \ref SCIP_STAGE_SOLVING
1440  *
1441  * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
1442  * added to SCIP beforehand.
1443  */
1444 SCIP_EXPORT
1445 SCIP_RETCODE SCIPenfopsCons(
1446  SCIP* scip, /**< SCIP data structure */
1447  SCIP_CONS* cons, /**< constraint to enforce */
1448  SCIP_Bool solinfeasible, /**< was the solution already declared infeasible by a constraint handler? */
1449  SCIP_Bool objinfeasible, /**< is the solution infeasible anyway due to violating lower objective bound? */
1450  SCIP_RESULT* result /**< pointer to store the result of the callback method */
1451  );
1452 
1453 /** enforces single constraint for a given LP solution
1454  *
1455  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1456  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1457  *
1458  * @pre This method can be called if @p scip is in one of the following stages:
1459  * - \ref SCIP_STAGE_SOLVING
1460  *
1461  * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
1462  * added to SCIP beforehand.
1463  */
1464 SCIP_EXPORT
1465 SCIP_RETCODE SCIPenfolpCons(
1466  SCIP* scip, /**< SCIP data structure */
1467  SCIP_CONS* cons, /**< constraint to enforce */
1468  SCIP_Bool solinfeasible, /**< was the solution already declared infeasible by a constraint handler? */
1469  SCIP_RESULT* result /**< pointer to store the result of the callback method */
1470  );
1471 
1472 /** enforces single constraint for a given relaxation solution
1473  *
1474  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1475  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1476  *
1477  * @pre This method can be called if @p scip is in one of the following stages:
1478  * - \ref SCIP_STAGE_SOLVING
1479  *
1480  * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
1481  * added to SCIP beforehand.
1482  */
1483 SCIP_RETCODE SCIPenforelaxCons(
1484  SCIP* scip, /**< SCIP data structure */
1485  SCIP_CONS* cons, /**< constraint to enforce */
1486  SCIP_SOL* sol, /**< solution to enforce */
1487  SCIP_Bool solinfeasible, /**< was the solution already declared infeasible by a constraint handler? */
1488  SCIP_RESULT* result /**< pointer to store the result of the callback method */
1489  );
1490 
1491 /** calls LP initialization method for single constraint
1492  *
1493  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1494  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1495  *
1496  * @pre This method can be called if @p scip is in one of the following stages:
1497  * - \ref SCIP_STAGE_SOLVING
1498  *
1499  * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
1500  * added to SCIP beforehand.
1501  */
1502 SCIP_EXPORT
1503 SCIP_RETCODE SCIPinitlpCons(
1504  SCIP* scip, /**< SCIP data structure */
1505  SCIP_CONS* cons, /**< constraint to initialize */
1506  SCIP_Bool* infeasible /**< pointer to store whether infeasibility was detected while building the LP */
1507 
1508  );
1509 
1510 /** calls separation method of single constraint for LP solution
1511  *
1512  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1513  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1514  *
1515  * @pre This method can be called if @p scip is in one of the following stages:
1516  * - \ref SCIP_STAGE_SOLVING
1517  *
1518  * @note This is an advanced method and should be used with caution.
1519  */
1520 SCIP_EXPORT
1521 SCIP_RETCODE SCIPsepalpCons(
1522  SCIP* scip, /**< SCIP data structure */
1523  SCIP_CONS* cons, /**< constraint to separate */
1524  SCIP_RESULT* result /**< pointer to store the result of the separation call */
1525  );
1526 
1527 /** calls separation method of single constraint for given primal solution
1528  *
1529  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1530  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1531  *
1532  * @pre This method can be called if @p scip is in one of the following stages:
1533  * - \ref SCIP_STAGE_SOLVING
1534  *
1535  * @note This is an advanced method and should be used with caution.
1536  */
1537 SCIP_EXPORT
1538 SCIP_RETCODE SCIPsepasolCons(
1539  SCIP* scip, /**< SCIP data structure */
1540  SCIP_CONS* cons, /**< constraint to separate */
1541  SCIP_SOL* sol, /**< primal solution that should be separated*/
1542  SCIP_RESULT* result /**< pointer to store the result of the separation call */
1543  );
1544 
1545 /** calls domain propagation method of single constraint
1546  *
1547  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1548  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1549  *
1550  * @pre This method can be called if @p scip is in one of the following stages:
1551  * - \ref SCIP_STAGE_PRESOLVING
1552  * - \ref SCIP_STAGE_SOLVING
1553  *
1554  * @note This is an advanced method and should be used with caution.
1555  */
1556 SCIP_EXPORT
1557 SCIP_RETCODE SCIPpropCons(
1558  SCIP* scip, /**< SCIP data structure */
1559  SCIP_CONS* cons, /**< constraint to propagate */
1560  SCIP_PROPTIMING proptiming, /**< current point in the node solving loop */
1561  SCIP_RESULT* result /**< pointer to store the result of the callback method */
1562  );
1563 
1564 /** resolves propagation conflict of single constraint
1565  *
1566  *
1567  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1568  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1569  *
1570  * @pre This method can be called if @p scip is in one of the following stages:
1571  * - \ref SCIP_STAGE_PRESOLVING
1572  * - \ref SCIP_STAGE_SOLVING
1573  *
1574  * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
1575  * added to SCIP beforehand.
1576  */
1577 SCIP_EXPORT
1578 SCIP_RETCODE SCIPrespropCons(
1579  SCIP* scip, /**< SCIP data structure */
1580  SCIP_CONS* cons, /**< constraint to resolve conflict for */
1581  SCIP_VAR* infervar, /**< the conflict variable whose bound change has to be resolved */
1582  int inferinfo, /**< the user information passed to the corresponding SCIPinferVarLbCons() or SCIPinferVarUbCons() call */
1583  SCIP_BOUNDTYPE boundtype, /**< the type of the changed bound (lower or upper bound) */
1584  SCIP_BDCHGIDX* bdchgidx, /**< the index of the bound change, representing the point of time where the change took place */
1585  SCIP_Real relaxedbd, /**< the relaxed bound which is sufficient to be explained */
1586  SCIP_RESULT* result /**< pointer to store the result of the callback method */
1587  );
1588 
1589 /** presolves of single constraint
1590  *
1591  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1592  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1593  *
1594  * @pre This method can be called if @p scip is in one of the following stages:
1595  * - \ref SCIP_STAGE_PRESOLVING
1596  *
1597  * @note This is an advanced method and should be used with caution.
1598  */
1599 SCIP_EXPORT
1600 SCIP_RETCODE SCIPpresolCons(
1601  SCIP* scip, /**< SCIP data structure */
1602  SCIP_CONS* cons, /**< constraint to presolve */
1603  int nrounds, /**< number of presolving rounds already done */
1604  SCIP_PRESOLTIMING presoltiming, /**< presolving timing(s) to be performed */
1605  int nnewfixedvars, /**< number of variables fixed since the last call to the presolving method */
1606  int nnewaggrvars, /**< number of variables aggregated since the last call to the presolving method */
1607  int nnewchgvartypes, /**< number of variable type changes since the last call to the presolving method */
1608  int nnewchgbds, /**< number of variable bounds tightened since the last call to the presolving method */
1609  int nnewholes, /**< number of domain holes added since the last call to the presolving method */
1610  int nnewdelconss, /**< number of deleted constraints since the last call to the presolving method */
1611  int nnewaddconss, /**< number of added constraints since the last call to the presolving method */
1612  int nnewupgdconss, /**< number of upgraded constraints since the last call to the presolving method */
1613  int nnewchgcoefs, /**< number of changed coefficients since the last call to the presolving method */
1614  int nnewchgsides, /**< number of changed left or right hand sides since the last call to the presolving method */
1615  int* nfixedvars, /**< pointer to count total number of variables fixed of all presolvers */
1616  int* naggrvars, /**< pointer to count total number of variables aggregated of all presolvers */
1617  int* nchgvartypes, /**< pointer to count total number of variable type changes of all presolvers */
1618  int* nchgbds, /**< pointer to count total number of variable bounds tightened of all presolvers */
1619  int* naddholes, /**< pointer to count total number of domain holes added of all presolvers */
1620  int* ndelconss, /**< pointer to count total number of deleted constraints of all presolvers */
1621  int* naddconss, /**< pointer to count total number of added constraints of all presolvers */
1622  int* nupgdconss, /**< pointer to count total number of upgraded constraints of all presolvers */
1623  int* nchgcoefs, /**< pointer to count total number of changed coefficients of all presolvers */
1624  int* nchgsides, /**< pointer to count total number of changed left/right hand sides of all presolvers */
1625  SCIP_RESULT* result /**< pointer to store the result of the callback method */
1626  );
1627 
1628 /** calls constraint activation notification method of single constraint
1629  *
1630  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1631  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1632  *
1633  * @pre This method can be called if @p scip is in one of the following stages:
1634  * - \ref SCIP_STAGE_TRANSFORMING
1635  *
1636  * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
1637  * added to SCIP beforehand.
1638  */
1639 SCIP_EXPORT
1640 SCIP_RETCODE SCIPactiveCons(
1641  SCIP* scip, /**< SCIP data structure */
1642  SCIP_CONS* cons /**< constraint to notify */
1643  );
1644 
1645 /** calls constraint deactivation notification method of single constraint
1646  *
1647  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1648  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1649  *
1650  * @pre This method can be called if @p scip is in one of the following stages:
1651  * - \ref SCIP_STAGE_PRESOLVING
1652  * - \ref SCIP_STAGE_SOLVING
1653  *
1654  * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
1655  * added to SCIP beforehand.
1656  */
1657 SCIP_EXPORT
1658 SCIP_RETCODE SCIPdeactiveCons(
1659  SCIP* scip, /**< SCIP data structure */
1660  SCIP_CONS* cons /**< constraint to notify */
1661  );
1662 
1663 /** outputs constraint information to file stream via the message handler system
1664  *
1665  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1666  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1667  *
1668  * @pre This method can be called if @p scip is in one of the following stages:
1669  * - \ref SCIP_STAGE_PROBLEM
1670  * - \ref SCIP_STAGE_TRANSFORMING
1671  * - \ref SCIP_STAGE_TRANSFORMED
1672  * - \ref SCIP_STAGE_INITPRESOLVE
1673  * - \ref SCIP_STAGE_PRESOLVING
1674  * - \ref SCIP_STAGE_EXITPRESOLVE
1675  * - \ref SCIP_STAGE_PRESOLVED
1676  * - \ref SCIP_STAGE_INITSOLVE
1677  * - \ref SCIP_STAGE_SOLVING
1678  * - \ref SCIP_STAGE_SOLVED
1679  * - \ref SCIP_STAGE_EXITSOLVE
1680  * - \ref SCIP_STAGE_FREETRANS
1681  *
1682  * @note If the message handler is set to a NULL pointer nothing will be printed.
1683  * @note The file stream will not be flushed directly, this can be achieved by calling SCIPinfoMessage() printing a
1684  * newline character.
1685  */
1686 SCIP_EXPORT
1687 SCIP_RETCODE SCIPprintCons(
1688  SCIP* scip, /**< SCIP data structure */
1689  SCIP_CONS* cons, /**< constraint */
1690  FILE* file /**< output file (or NULL for standard output) */
1691  );
1692 
1693 /** method to collect the variables of a constraint
1694  *
1695  * If the number of variables is greater than the available slots in the variable array, nothing happens except that
1696  * the success point is set to FALSE. With the method SCIPgetConsNVars() it is possible to get the number of variables
1697  * a constraint has in its scope.
1698  *
1699  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1700  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1701  *
1702  * @pre This method can be called if @p scip is in one of the following stages:
1703  * - \ref SCIP_STAGE_PROBLEM
1704  * - \ref SCIP_STAGE_TRANSFORMING
1705  * - \ref SCIP_STAGE_TRANSFORMED
1706  * - \ref SCIP_STAGE_INITPRESOLVE
1707  * - \ref SCIP_STAGE_PRESOLVING
1708  * - \ref SCIP_STAGE_EXITPRESOLVE
1709  * - \ref SCIP_STAGE_PRESOLVED
1710  * - \ref SCIP_STAGE_INITSOLVE
1711  * - \ref SCIP_STAGE_SOLVING
1712  * - \ref SCIP_STAGE_SOLVED
1713  * - \ref SCIP_STAGE_EXITSOLVE
1714  * - \ref SCIP_STAGE_FREETRANS
1715  *
1716  * @note The success pointer indicates if all variables were copied into the vars arrray.
1717  *
1718  * @note It might be that a constraint handler does not support this functionality, in that case the success pointer is
1719  * set to FALSE.
1720  */
1721 SCIP_EXPORT
1722 SCIP_RETCODE SCIPgetConsVars(
1723  SCIP* scip, /**< SCIP data structure */
1724  SCIP_CONS* cons, /**< constraint for which the variables are wanted */
1725  SCIP_VAR** vars, /**< array to store the involved variable of the constraint */
1726  int varssize, /**< available slots in vars array which is needed to check if the array is large enough */
1727  SCIP_Bool* success /**< pointer to store whether the variables are successfully copied */
1728  );
1729 
1730 /** method to collect the number of variables of a constraint
1731  *
1732  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1733  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1734  *
1735  * @pre This method can be called if @p scip is in one of the following stages:
1736  * - \ref SCIP_STAGE_PROBLEM
1737  * - \ref SCIP_STAGE_TRANSFORMING
1738  * - \ref SCIP_STAGE_TRANSFORMED
1739  * - \ref SCIP_STAGE_INITPRESOLVE
1740  * - \ref SCIP_STAGE_PRESOLVING
1741  * - \ref SCIP_STAGE_EXITPRESOLVE
1742  * - \ref SCIP_STAGE_PRESOLVED
1743  * - \ref SCIP_STAGE_INITSOLVE
1744  * - \ref SCIP_STAGE_SOLVING
1745  * - \ref SCIP_STAGE_SOLVED
1746  * - \ref SCIP_STAGE_EXITSOLVE
1747  * - \ref SCIP_STAGE_FREETRANS
1748  *
1749  * @note The success pointer indicates if the contraint handler was able to return the number of variables
1750  *
1751  * @note It might be that a constraint handler does not support this functionality, in that case the success pointer is
1752  * set to FALSE
1753  */
1754 SCIP_EXPORT
1755 SCIP_RETCODE SCIPgetConsNVars(
1756  SCIP* scip, /**< SCIP data structure */
1757  SCIP_CONS* cons, /**< constraint for which the number of variables is wanted */
1758  int* nvars, /**< pointer to store the number of variables */
1759  SCIP_Bool* success /**< pointer to store whether the constraint successfully returned the number of variables */
1760  );
1761 
1762 /* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
1763  * speed up the algorithms.
1764  */
1765 #ifdef NDEBUG
1766 #define SCIPmarkConsPropagate(scip, cons) SCIPconsMarkPropagate(cons, (scip)->set)
1767 #endif
1768 
1769 /**@} */
1770 
1771 #ifdef __cplusplus
1772 }
1773 #endif
1774 
1775 #endif
SCIPrespropCons
SCIP_RETCODE SCIPrespropCons(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *infervar, int inferinfo, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedbd, SCIP_RESULT *result)
Definition: scip_cons.c:2308
SCIP_RESULT
enum SCIP_Result SCIP_RESULT
Definition: type_result.h:52
SCIP_BOUNDTYPE
enum SCIP_BoundType SCIP_BOUNDTYPE
Definition: type_lp.h:50
SCIPincConsAge
SCIP_RETCODE SCIPincConsAge(SCIP *scip, SCIP_CONS *cons)
Definition: scip_cons.c:1721
SCIPaddConsAge
SCIP_RETCODE SCIPaddConsAge(SCIP *scip, SCIP_CONS *cons, SCIP_Real deltaage)
Definition: scip_cons.c:1692
SCIPsetConshdlrDelete
SCIP_RETCODE SCIPsetConshdlrDelete(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDELETE((*consdelete)))
Definition: scip_cons.c:563
SCIPdisableConsSeparation
SCIP_RETCODE SCIPdisableConsSeparation(SCIP *scip, SCIP_CONS *cons)
Definition: scip_cons.c:1861
SCIP_BdChgIdx
Definition: struct_var.h:99
SCIPsetConshdlrTrans
SCIP_RETCODE SCIPsetConshdlrTrans(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSTRANS((*constrans)))
Definition: scip_cons.c:586
type_misc.h
type definitions for miscellaneous datastructures
type_timing.h
timing definitions for SCIP
SCIPfindConshdlr
SCIP_CONSHDLR * SCIPfindConshdlr(SCIP *scip, const char *name)
Definition: scip_cons.c:877
SCIP_DECL_CONSSEPALP
SCIP_DECL_CONSSEPALP(ConshdlrSubtour::scip_sepalp)
Definition: ConshdlrSubtour.cpp:273
SCIPsetConshdlrGetVars
SCIP_RETCODE SCIPsetConshdlrGetVars(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETVARS((*consgetvars)))
Definition: scip_cons.c:816
SCIP_DECL_CONSINITPRE
#define SCIP_DECL_CONSINITPRE(x)
Definition: type_cons.h:146
SCIPsetConshdlrEnforelax
SCIP_RETCODE SCIPsetConshdlrEnforelax(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSENFORELAX((*consenforelax)))
Definition: scip_cons.c:308
SCIPresetConsAge
SCIP_RETCODE SCIPresetConsAge(SCIP *scip, SCIP_CONS *cons)
Definition: scip_cons.c:1749
SCIPchgConsName
SCIP_RETCODE SCIPchgConsName(SCIP *scip, SCIP_CONS *cons, const char *name)
Definition: scip_cons.c:1161
SCIP_DECL_CONSGETDIVEBDCHGS
#define SCIP_DECL_CONSGETDIVEBDCHGS(x)
Definition: type_cons.h:909
SCIP_DECL_CONSPRESOL
#define SCIP_DECL_CONSPRESOL(x)
Definition: type_cons.h:550
SCIPsetConsPropagated
SCIP_RETCODE SCIPsetConsPropagated(SCIP *scip, SCIP_CONS *cons, SCIP_Bool propagate)
Definition: scip_cons.c:1308
SCIPdisableConsPropagation
SCIP_RETCODE SCIPdisableConsPropagation(SCIP *scip, SCIP_CONS *cons)
Definition: scip_cons.c:1918
SCIPsetConshdlrDeactive
SCIP_RETCODE SCIPsetConshdlrDeactive(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDEACTIVE((*consdeactive)))
Definition: scip_cons.c:678
SCIP_Var
Definition: struct_var.h:198
SCIPupdateConsFlags
SCIP_RETCODE SCIPupdateConsFlags(SCIP *scip, SCIP_CONS *cons0, SCIP_CONS *cons1)
Definition: scip_cons.c:1461
SCIPsetConshdlrInitpre
SCIP_RETCODE SCIPsetConshdlrInitpre(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITPRE((*consinitpre)))
Definition: scip_cons.c:477
SCIP_DECL_CONSENFOPS
SCIP_DECL_CONSENFOPS(ConshdlrSubtour::scip_enfops)
Definition: ConshdlrSubtour.cpp:397
SCIPtransformConss
SCIP_RETCODE SCIPtransformConss(SCIP *scip, int nconss, SCIP_CONS **conss, SCIP_CONS **transconss)
Definition: scip_cons.c:1562
SCIP_DECL_CONSRESPROP
#define SCIP_DECL_CONSRESPROP(x)
Definition: type_cons.h:601
SCIPincludeConshdlrBasic
SCIP_RETCODE SCIPincludeConshdlrBasic(SCIP *scip, SCIP_CONSHDLR **conshdlrptr, const char *name, const char *desc, int enfopriority, int chckpriority, int eagerfreq, SCIP_Bool needscons, SCIP_DECL_CONSENFOLP((*consenfolp)), SCIP_DECL_CONSENFOPS((*consenfops)), SCIP_DECL_CONSCHECK((*conscheck)), SCIP_DECL_CONSLOCK((*conslock)), SCIP_CONSHDLRDATA *conshdlrdata)
Definition: scip_cons.c:166
SCIPparseCons
SCIP_RETCODE SCIPparseCons(SCIP *scip, SCIP_CONS **cons, 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: scip_cons.c:1018
SCIPenableConsSeparation
SCIP_RETCODE SCIPenableConsSeparation(SCIP *scip, SCIP_CONS *cons)
Definition: scip_cons.c:1833
SCIPunmarkConsPropagate
SCIP_RETCODE SCIPunmarkConsPropagate(SCIP *scip, SCIP_CONS *cons)
Definition: scip_cons.c:1979
SCIP_RETCODE
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:54
SCIP_DECL_CONSGETNVARS
#define SCIP_DECL_CONSGETNVARS(x)
Definition: type_cons.h:874
SCIP_DECL_CONSEXITSOL
#define SCIP_DECL_CONSEXITSOL(x)
Definition: type_cons.h:206
SCIPenableConsPropagation
SCIP_RETCODE SCIPenableConsPropagation(SCIP *scip, SCIP_CONS *cons)
Definition: scip_cons.c:1888
type_retcode.h
type definitions for return codes for SCIP methods
SCIPsetConshdlrSepa
SCIP_RETCODE SCIPsetConshdlrSepa(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSSEPALP((*conssepalp)), SCIP_DECL_CONSSEPASOL((*conssepasol)), int sepafreq, int sepapriority, SCIP_Bool delaysepa)
Definition: scip_cons.c:220
SCIP_DECL_CONSSEPASOL
SCIP_DECL_CONSSEPASOL(ConshdlrSubtour::scip_sepasol)
Definition: ConshdlrSubtour.cpp:300
SCIP_DECL_CONSDELETE
SCIP_DECL_CONSDELETE(ConshdlrSubtour::scip_delete)
Definition: ConshdlrSubtour.cpp:220
SCIPsetConshdlrDelvars
SCIP_RETCODE SCIPsetConshdlrDelvars(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDELVARS((*consdelvars)))
Definition: scip_cons.c:747
SCIPsetConshdlrInitlp
SCIP_RETCODE SCIPsetConshdlrInitlp(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITLP((*consinitlp)))
Definition: scip_cons.c:609
SCIPsetConshdlrParse
SCIP_RETCODE SCIPsetConshdlrParse(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPARSE((*consparse)))
Definition: scip_cons.c:793
SCIP_DECL_CONSINITLP
#define SCIP_DECL_CONSINITLP(x)
Definition: type_cons.h:249
SCIPactiveCons
SCIP_RETCODE SCIPactiveCons(SCIP *scip, SCIP_CONS *cons)
Definition: scip_cons.c:2405
SCIPcreateCons
SCIP_RETCODE SCIPcreateCons(SCIP *scip, SCIP_CONS **cons, 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)
Definition: scip_cons.c:934
SCIP_DECL_CONSENFOLP
SCIP_DECL_CONSENFOLP(ConshdlrSubtour::scip_enfolp)
Definition: ConshdlrSubtour.cpp:338
SCIPgetNConshdlrs
int SCIPgetNConshdlrs(SCIP *scip)
Definition: scip_cons.c:901
type_lp.h
type definitions for LP management
SCIP_Sol
Definition: struct_sol.h:64
SCIP_DECL_CONSCHECK
SCIP_DECL_CONSCHECK(ConshdlrSubtour::scip_check)
Definition: ConshdlrSubtour.cpp:446
SCIP_DECL_CONSINITSOL
#define SCIP_DECL_CONSINITSOL(x)
Definition: type_cons.h:191
SCIPenableCons
SCIP_RETCODE SCIPenableCons(SCIP *scip, SCIP_CONS *cons)
Definition: scip_cons.c:1774
SCIPsetConsSeparated
SCIP_RETCODE SCIPsetConsSeparated(SCIP *scip, SCIP_CONS *cons, SCIP_Bool separate)
Definition: scip_cons.c:1233
SCIPsetConshdlrInitsol
SCIP_RETCODE SCIPsetConshdlrInitsol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITSOL((*consinitsol)))
Definition: scip_cons.c:429
SCIPsetConshdlrGetDiveBdChgs
SCIP_RETCODE SCIPsetConshdlrGetDiveBdChgs(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs)))
Definition: scip_cons.c:862
SCIPsetConsRemovable
SCIP_RETCODE SCIPsetConsRemovable(SCIP *scip, SCIP_CONS *cons, SCIP_Bool removable)
Definition: scip_cons.c:1411
SCIPsetConshdlrCopy
SCIP_RETCODE SCIPsetConshdlrCopy(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), SCIP_DECL_CONSCOPY((*conscopy)))
Definition: scip_cons.c:332
SCIP_LOCKTYPE
enum SCIP_LockType SCIP_LOCKTYPE
Definition: type_var.h:87
SCIP_Cons
Definition: struct_cons.h:37
SCIPgetConsNVars
SCIP_RETCODE SCIPgetConsNVars(SCIP *scip, SCIP_CONS *cons, int *nvars, SCIP_Bool *success)
Definition: scip_cons.c:2558
SCIPgetConshdlrs
SCIP_CONSHDLR ** SCIPgetConshdlrs(SCIP *scip)
Definition: scip_cons.c:890
type_heur.h
type definitions for primal heuristics
SCIP_Conshdlr
Definition: struct_cons.h:117
SCIP_DECL_CONSPARSE
#define SCIP_DECL_CONSPARSE(x)
Definition: type_cons.h:834
SCIP_DECL_CONSDEACTIVE
#define SCIP_DECL_CONSDEACTIVE(x)
Definition: type_cons.h:695
type_scip.h
type definitions for SCIP&#39;s main datastructure
SCIPpresolCons
SCIP_RETCODE SCIPpresolCons(SCIP *scip, SCIP_CONS *cons, int nrounds, SCIP_PRESOLTIMING presoltiming, 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: scip_cons.c:2343
SCIPcheckCons
SCIP_RETCODE SCIPcheckCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool printreason, SCIP_RESULT *result)
Definition: scip_cons.c:2072
SCIPsetConsChecked
SCIP_RETCODE SCIPsetConsChecked(SCIP *scip, SCIP_CONS *cons, SCIP_Bool check)
Definition: scip_cons.c:1283
SCIPsetConsDynamic
SCIP_RETCODE SCIPsetConsDynamic(SCIP *scip, SCIP_CONS *cons, SCIP_Bool dynamic)
Definition: scip_cons.c:1386
SCIPsetConshdlrFree
SCIP_RETCODE SCIPsetConshdlrFree(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSFREE((*consfree)))
Definition: scip_cons.c:357
SCIP_DECL_CONSTRANS
SCIP_DECL_CONSTRANS(ConshdlrSubtour::scip_trans)
Definition: ConshdlrSubtour.cpp:232
SCIPenforelaxCons
SCIP_RETCODE SCIPenforelaxCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool solinfeasible, SCIP_RESULT *result)
Definition: scip_cons.c:2161
SCIPmarkConsPropagate
SCIP_RETCODE SCIPmarkConsPropagate(SCIP *scip, SCIP_CONS *cons)
Definition: scip_cons.c:1951
SCIP_DECL_CONSDISABLE
#define SCIP_DECL_CONSDISABLE(x)
Definition: type_cons.h:725
SCIPtransformCons
SCIP_RETCODE SCIPtransformCons(SCIP *scip, SCIP_CONS *cons, SCIP_CONS **transcons)
Definition: scip_cons.c:1521
SCIP_DECL_CONSDELVARS
SCIP_DECL_CONSDELVARS(ConshdlrSubtour::scip_delvars)
Definition: ConshdlrSubtour.cpp:581
SCIP_PRESOLTIMING
unsigned int SCIP_PRESOLTIMING
Definition: type_timing.h:52
struct_scip.h
SCIP main data structure.
type_var.h
type definitions for problem variables
SCIP_DECL_CONSENABLE
#define SCIP_DECL_CONSENABLE(x)
Definition: type_cons.h:710
SCIPgetTransformedCons
SCIP_RETCODE SCIPgetTransformedCons(SCIP *scip, SCIP_CONS *cons, SCIP_CONS **transcons)
Definition: scip_cons.c:1611
SCIPcaptureCons
SCIP_RETCODE SCIPcaptureCons(SCIP *scip, SCIP_CONS *cons)
Definition: scip_cons.c:1075
SCIPsetConshdlrResprop
SCIP_RETCODE SCIPsetConshdlrResprop(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSRESPROP((*consresprop)))
Definition: scip_cons.c:632
SCIP_CONSDATA
struct SCIP_ConsData SCIP_CONSDATA
Definition: type_cons.h:56
SCIPdisableCons
SCIP_RETCODE SCIPdisableCons(SCIP *scip, SCIP_CONS *cons)
Definition: scip_cons.c:1808
SCIPgetConsVars
SCIP_RETCODE SCIPgetConsVars(SCIP *scip, SCIP_CONS *cons, SCIP_VAR **vars, int varssize, SCIP_Bool *success)
Definition: scip_cons.c:2514
SCIP_DECL_CONSGETVARS
#define SCIP_DECL_CONSGETVARS(x)
Definition: type_cons.h:856
SCIPpropCons
SCIP_RETCODE SCIPpropCons(SCIP *scip, SCIP_CONS *cons, SCIP_PROPTIMING proptiming, SCIP_RESULT *result)
Definition: scip_cons.c:2277
SCIP_DECL_CONSEXIT
#define SCIP_DECL_CONSEXIT(x)
Definition: type_cons.h:126
SCIP_Bool
#define SCIP_Bool
Definition: def.h:84
SCIPsetConsLocal
SCIP_RETCODE SCIPsetConsLocal(SCIP *scip, SCIP_CONS *cons, SCIP_Bool local)
Definition: scip_cons.c:1335
SCIP_DECL_CONSPROP
SCIP_DECL_CONSPROP(ConshdlrSubtour::scip_prop)
Definition: ConshdlrSubtour.cpp:493
SCIPprintCons
SCIP_RETCODE SCIPprintCons(SCIP *scip, SCIP_CONS *cons, FILE *file)
Definition: scip_cons.c:2473
SCIP_DECL_CONSEXITPRE
#define SCIP_DECL_CONSEXITPRE(x)
Definition: type_cons.h:170
SCIPsetConshdlrDisable
SCIP_RETCODE SCIPsetConshdlrDisable(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDISABLE((*consdisable)))
Definition: scip_cons.c:724
SCIPsepasolCons
SCIP_RETCODE SCIPsepasolCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_RESULT *result)
Definition: scip_cons.c:2247
SCIPenfolpCons
SCIP_RETCODE SCIPenfolpCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool solinfeasible, SCIP_RESULT *result)
Definition: scip_cons.c:2131
SCIPsetConshdlrPrint
SCIP_RETCODE SCIPsetConshdlrPrint(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPRINT((*consprint)))
Definition: scip_cons.c:770
SCIPsetConshdlrEnable
SCIP_RETCODE SCIPsetConshdlrEnable(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSENABLE((*consenable)))
Definition: scip_cons.c:701
type_sol.h
type definitions for storing primal CIP solutions
SCIPsetConshdlrExitpre
SCIP_RETCODE SCIPsetConshdlrExitpre(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSEXITPRE((*consexitpre)))
Definition: scip_cons.c:501
SCIPsetConsStickingAtNode
SCIP_RETCODE SCIPsetConsStickingAtNode(SCIP *scip, SCIP_CONS *cons, SCIP_Bool stickingatnode)
Definition: scip_cons.c:1436
SCIP_PROPTIMING
unsigned int SCIP_PROPTIMING
Definition: type_timing.h:66
SCIPenfopsCons
SCIP_RETCODE SCIPenfopsCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool solinfeasible, SCIP_Bool objinfeasible, SCIP_RESULT *result)
Definition: scip_cons.c:2100
SCIPsepalpCons
SCIP_RETCODE SCIPsepalpCons(SCIP *scip, SCIP_CONS *cons, SCIP_RESULT *result)
Definition: scip_cons.c:2220
SCIPsetConshdlrInit
SCIP_RETCODE SCIPsetConshdlrInit(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINIT((*consinit)))
Definition: scip_cons.c:381
SCIPsetConsEnforced
SCIP_RETCODE SCIPsetConsEnforced(SCIP *scip, SCIP_CONS *cons, SCIP_Bool enforce)
Definition: scip_cons.c:1258
SCIPsetConshdlrExit
SCIP_RETCODE SCIPsetConshdlrExit(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSEXIT((*consexit)))
Definition: scip_cons.c:405
SCIP_DECL_CONSFREE
#define SCIP_DECL_CONSFREE(x)
Definition: type_cons.h:106
SCIPreleaseCons
SCIP_RETCODE SCIPreleaseCons(SCIP *scip, SCIP_CONS **cons)
Definition: scip_cons.c:1110
SCIPsetConshdlrPresol
SCIP_RETCODE SCIPsetConshdlrPresol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPRESOL((*conspresol)), int maxprerounds, SCIP_PRESOLTIMING presoltiming)
Definition: scip_cons.c:525
SCIP_DECL_CONSINIT
#define SCIP_DECL_CONSINIT(x)
Definition: type_cons.h:116
SCIP_DECL_CONSLOCK
SCIP_DECL_CONSLOCK(ConshdlrSubtour::scip_lock)
Definition: ConshdlrSubtour.cpp:551
SCIP_DECL_CONSENFORELAX
#define SCIP_DECL_CONSENFORELAX(x)
Definition: type_cons.h:378
SCIP_Real
#define SCIP_Real
Definition: def.h:177
SCIPaddConsLocksType
SCIP_RETCODE SCIPaddConsLocksType(SCIP *scip, SCIP_CONS *cons, SCIP_LOCKTYPE locktype, int nlockspos, int nlocksneg)
Definition: scip_cons.c:2009
SCIP_DECL_CONSPRINT
SCIP_DECL_CONSPRINT(ConshdlrSubtour::scip_print)
Definition: ConshdlrSubtour.cpp:591
type_result.h
result codes for SCIP callback methods
SCIPsetConshdlrGetNVars
SCIP_RETCODE SCIPsetConshdlrGetNVars(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETNVARS((*consgetnvars)))
Definition: scip_cons.c:839
cons.h
internal methods for constraints and constraint handlers
SCIP_DECL_CONSACTIVE
#define SCIP_DECL_CONSACTIVE(x)
Definition: type_cons.h:680
SCIPsetConsModifiable
SCIP_RETCODE SCIPsetConsModifiable(SCIP *scip, SCIP_CONS *cons, SCIP_Bool modifiable)
Definition: scip_cons.c:1361
SCIPaddConsLocks
SCIP_RETCODE SCIPaddConsLocks(SCIP *scip, SCIP_CONS *cons, int nlockspos, int nlocksneg)
Definition: scip_cons.c:2042
SCIP_DECL_CONSHDLRCOPY
#define SCIP_DECL_CONSHDLRCOPY(x)
Definition: type_cons.h:98
SCIP_CONSHDLRDATA
struct SCIP_ConshdlrData SCIP_CONSHDLRDATA
Definition: type_cons.h:55
SCIP_DECL_CONSCOPY
SCIP_DECL_CONSCOPY(ConshdlrSubtour::scip_copy)
Definition: ConshdlrSubtour.cpp:620
SCIPincludeConshdlr
SCIP_RETCODE SCIPincludeConshdlr(SCIP *scip, const char *name, const char *desc, int sepapriority, int enfopriority, int chckpriority, 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: scip_cons.c:73
SCIPgetTransformedConss
SCIP_RETCODE SCIPgetTransformedConss(SCIP *scip, int nconss, SCIP_CONS **conss, SCIP_CONS **transconss)
Definition: scip_cons.c:1651
def.h
common defines and data types used in all packages of SCIP
SCIPsetConshdlrActive
SCIP_RETCODE SCIPsetConshdlrActive(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSACTIVE((*consactive)))
Definition: scip_cons.c:655
SCIPsetConshdlrExitsol
SCIP_RETCODE SCIPsetConshdlrExitsol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSEXITSOL((*consexitsol)))
Definition: scip_cons.c:453
SCIPdeactiveCons
SCIP_RETCODE SCIPdeactiveCons(SCIP *scip, SCIP_CONS *cons)
Definition: scip_cons.c:2434
SCIPinitlpCons
SCIP_RETCODE SCIPinitlpCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *infeasible)
Definition: scip_cons.c:2193
type_cons.h
type definitions for constraints and constraint handlers
SCIPsetConshdlrProp
SCIP_RETCODE SCIPsetConshdlrProp(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPROP((*consprop)), int propfreq, SCIP_Bool delayprop, SCIP_PROPTIMING proptiming)
Definition: scip_cons.c:266
SCIPsetConsInitial
SCIP_RETCODE SCIPsetConsInitial(SCIP *scip, SCIP_CONS *cons, SCIP_Bool initial)
Definition: scip_cons.c:1208