Scippy

SCIP

Solving Constraint Integer Programs

scip_cons.c
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-2025 Zuse Institute Berlin (ZIB) */
7/* */
8/* Licensed under the Apache License, Version 2.0 (the "License"); */
9/* you may not use this file except in compliance with the License. */
10/* You may obtain a copy of the License at */
11/* */
12/* http://www.apache.org/licenses/LICENSE-2.0 */
13/* */
14/* Unless required by applicable law or agreed to in writing, software */
15/* distributed under the License is distributed on an "AS IS" BASIS, */
16/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */
17/* See the License for the specific language governing permissions and */
18/* limitations under the License. */
19/* */
20/* You should have received a copy of the Apache-2.0 license */
21/* along with SCIP; see the file LICENSE. If not visit scipopt.org. */
22/* */
23/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
24
25/**@file scip_cons.c
26 * @ingroup OTHER_CFILES
27 * @brief public methods for constraint handler plugins and constraints
28 * @author Tobias Achterberg
29 * @author Timo Berthold
30 * @author Gerald Gamrath
31 * @author Leona Gottwald
32 * @author Stefan Heinz
33 * @author Gregor Hendel
34 * @author Christopher Hojny
35 * @author Thorsten Koch
36 * @author Alexander Martin
37 * @author Marc Pfetsch
38 * @author Michael Winkler
39 * @author Kati Wolter
40 *
41 * @todo check all SCIP_STAGE_* switches, and include the new stages TRANSFORMED and INITSOLVE
42 */
43
44/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
45
46#include "scip/cons.h"
47#include "scip/debug.h"
48#include "scip/prob.h"
49#include "scip/pub_cons.h"
50#include "scip/pub_message.h"
51#include "scip/pub_misc.h"
52#include "scip/scip_cons.h"
53#include "scip/scip_general.h"
54#include "scip/scip_mem.h"
55#include "scip/set.h"
56#include "scip/struct_cons.h"
57#include "scip/struct_mem.h"
58#include "scip/struct_scip.h"
59#include "scip/struct_set.h"
60
61/* In debug mode, the following methods are implemented as function calls to ensure
62 * type validity.
63 * In optimized mode, the methods are implemented as defines to improve performance.
64 * However, we want to have them in the library anyways, so we have to undef the defines.
65 */
66
67#undef SCIPmarkConsPropagate
68
69/** creates a constraint handler and includes it in SCIP.
70 *
71 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
72 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
73 *
74 * @pre This method can be called if SCIP is in one of the following stages:
75 * - \ref SCIP_STAGE_INIT
76 * - \ref SCIP_STAGE_PROBLEM
77 *
78 * @note method has all constraint handler callbacks as arguments and is thus changed every time a new
79 * callback is added
80 * in future releases; consider using SCIPincludeConshdlrBasic() and setter functions
81 * if you seek for a method which is less likely to change in future releases
82 */
83SCIP_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_DECL_CONSGETPERMSYMGRAPH((*consgetpermsymgraph)), /**< constraint permutation symmetry detection graph
133 * getter method */
134 SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH((*consgetsignedpermsymgraph)), /**< constraint signed permutation symmetry
135 * detection graph getter method */
136 SCIP_CONSHDLRDATA* conshdlrdata /**< constraint handler data */
137 )
138{
139 SCIP_CONSHDLR* conshdlr;
140
141 SCIP_CALL( SCIPcheckStage(scip, "SCIPincludeConshdlr", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
142
143 /* check whether constraint handler is already present */
144 if( SCIPfindConshdlr(scip, name) != NULL )
145 {
146 SCIPerrorMessage("constraint handler <%s> already included.\n", name);
147 return SCIP_INVALIDDATA;
148 }
149
150 SCIP_CALL( SCIPconshdlrCreate(&conshdlr, scip->set, scip->messagehdlr, scip->mem->setmem,
151 name, desc, sepapriority, enfopriority, chckpriority, sepafreq, propfreq, eagerfreq, maxprerounds,
152 delaysepa, delayprop, needscons, proptiming, presoltiming, conshdlrcopy,
153 consfree, consinit, consexit, consinitpre, consexitpre, consinitsol, consexitsol,
154 consdelete, constrans, consinitlp, conssepalp, conssepasol, consenfolp, consenforelax, consenfops, conscheck, consprop,
155 conspresol, consresprop, conslock, consactive, consdeactive, consenable, consdisable, consdelvars, consprint,
156 conscopy, consparse, consgetvars, consgetnvars, consgetdivebdchgs, consgetpermsymgraph,
157 consgetsignedpermsymgraph, conshdlrdata) );
158 SCIP_CALL( SCIPsetIncludeConshdlr(scip->set, conshdlr) );
159
160 return SCIP_OKAY;
161}
162
163/** creates a constraint handler and includes it in SCIP. All non-fundamental (or optional) callbacks will be set to NULL.
164 * Optional callbacks can be set via specific setter functions, see SCIPsetConshdlrInit(), SCIPsetConshdlrExit(),
165 * SCIPsetConshdlrCopy(), SCIPsetConshdlrFree(), SCIPsetConshdlrInitsol(), SCIPsetConshdlrExitsol(),
166 * SCIPsetConshdlrInitpre(), SCIPsetConshdlrExitpre(), SCIPsetConshdlrPresol(), SCIPsetConshdlrDelete(),
167 * SCIPsetConshdlrDelvars(), SCIPsetConshdlrInitlp(), SCIPsetConshdlrActive(), SCIPsetConshdlrDeactive(),
168 * SCIPsetConshdlrEnable(), SCIPsetConshdlrDisable(), SCIPsetConshdlrResprop(), SCIPsetConshdlrTrans(),
169 * SCIPsetConshdlrPrint(), SCIPsetConshdlrParse(), SCIPsetConshdlrGetVars(), SCIPsetConshdlrGetNVars(), and
170 * SCIPsetConshdlrGetDiveBdChgs().
171 *
172 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
173 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
174 *
175 * @pre This method can be called if SCIP is in one of the following stages:
176 * - \ref SCIP_STAGE_INIT
177 * - \ref SCIP_STAGE_PROBLEM
178 *
179 * @note if you want to set all callbacks with a single method call, consider using SCIPincludeConshdlr() instead
180 */
181SCIP_RETCODE SCIPincludeConshdlrBasic(
182 SCIP* scip, /**< SCIP data structure */
183 SCIP_CONSHDLR** conshdlrptr, /**< reference to a constraint handler pointer, or NULL */
184 const char* name, /**< name of constraint handler */
185 const char* desc, /**< description of constraint handler */
186 int enfopriority, /**< priority of the constraint handler for constraint enforcing */
187 int chckpriority, /**< priority of the constraint handler for checking feasibility (and propagation) */
188 int eagerfreq, /**< frequency for using all instead of only the useful constraints in separation,
189 * propagation and enforcement, -1 for no eager evaluations, 0 for first only */
190 SCIP_Bool needscons, /**< should the constraint handler be skipped, if no constraints are available? */
191 SCIP_DECL_CONSENFOLP ((*consenfolp)), /**< enforcing constraints for LP solutions */
192 SCIP_DECL_CONSENFOPS ((*consenfops)), /**< enforcing constraints for pseudo solutions */
193 SCIP_DECL_CONSCHECK ((*conscheck)), /**< check feasibility of primal solution */
194 SCIP_DECL_CONSLOCK ((*conslock)), /**< variable rounding lock method */
195 SCIP_CONSHDLRDATA* conshdlrdata /**< constraint handler data */
196 )
197{
198 SCIP_CONSHDLR* conshdlr;
199
200 SCIP_CALL( SCIPcheckStage(scip, "SCIPincludeConshdlrBasic", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
201
202 /* check whether constraint handler is already present */
203 if( SCIPfindConshdlr(scip, name) != NULL )
204 {
205 SCIPerrorMessage("constraint handler <%s> already included.\n", name);
206 return SCIP_INVALIDDATA;
207 }
208
209 SCIP_CALL( SCIPconshdlrCreate(&conshdlr, scip->set, scip->messagehdlr, scip->mem->setmem,
210 name, desc, 0, enfopriority, chckpriority, -1, -1, eagerfreq, 0,
211 FALSE, FALSE, needscons,
212 SCIP_PROPTIMING_BEFORELP, SCIP_PRESOLTIMING_ALWAYS,
213 NULL,
214 NULL, NULL, NULL, NULL, NULL, NULL, NULL,
215 NULL, NULL, NULL, NULL, NULL, consenfolp, NULL, consenfops, conscheck, NULL,
216 NULL, NULL, conslock, NULL, NULL, NULL, NULL, NULL, NULL,
217 NULL, NULL, NULL, NULL, NULL, NULL, NULL, conshdlrdata) );
218 SCIP_CALL( SCIPsetIncludeConshdlr(scip->set, conshdlr) );
219
220 if( conshdlrptr != NULL )
221 *conshdlrptr = conshdlr;
222
223 return SCIP_OKAY;
224}
225
226/** sets all separation related callbacks/parameters of the constraint handler
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 */
235SCIP_RETCODE SCIPsetConshdlrSepa(
236 SCIP* scip, /**< SCIP data structure */
237 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
238 SCIP_DECL_CONSSEPALP ((*conssepalp)), /**< separate cutting planes for LP solution */
239 SCIP_DECL_CONSSEPASOL ((*conssepasol)), /**< separate cutting planes for arbitrary primal solution */
240 int sepafreq, /**< frequency for separating cuts; zero means to separate only in the root node */
241 int sepapriority, /**< priority of the constraint handler for separation */
242 SCIP_Bool delaysepa /**< should separation method be delayed, if other separators found cuts? */
243 )
244{
245 int oldsepapriority;
246 const char* name;
247 char paramname[SCIP_MAXSTRLEN];
248
249 assert(scip != NULL);
250 assert(conshdlr != NULL);
251
252 SCIP_CALL( SCIPcheckStage(scip, "SCIPsetConshdlrSepa", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
253
254 oldsepapriority = SCIPconshdlrGetSepaPriority(conshdlr);
255 SCIPconshdlrSetSepa(conshdlr, conssepalp, conssepasol, sepafreq, sepapriority, delaysepa);
256
257 /* change the position of the constraint handler in the constraint handler array w.r.t. its new sepa priority */
258 if( oldsepapriority != sepapriority )
259 SCIPsetReinsertConshdlrSepaPrio(scip->set, conshdlr, oldsepapriority);
260
261 name = SCIPconshdlrGetName(conshdlr);
262
263 (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "constraints/%s/sepafreq", name);
264 SCIP_CALL( SCIPsetSetDefaultIntParam(scip->set, paramname, sepafreq) );
265
266 (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "constraints/%s/delaysepa", name);
267 SCIP_CALL( SCIPsetSetDefaultBoolParam(scip->set, paramname, delaysepa) );
268
269 return SCIP_OKAY;
270}
271
272/** sets both the propagation callback and the propagation frequency of the constraint handler
273 *
274 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
275 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
276 *
277 * @pre This method can be called if SCIP is in one of the following stages:
278 * - \ref SCIP_STAGE_INIT
279 * - \ref SCIP_STAGE_PROBLEM
280 */
281SCIP_RETCODE SCIPsetConshdlrProp(
282 SCIP* scip, /**< SCIP data structure */
283 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
284 SCIP_DECL_CONSPROP ((*consprop)), /**< propagate variable domains */
285 int propfreq, /**< frequency for propagating domains; zero means only preprocessing propagation */
286 SCIP_Bool delayprop, /**< should propagation method be delayed, if other propagators found reductions? */
287 SCIP_PROPTIMING proptiming /**< positions in the node solving loop where propagation should be executed */
288 )
289{
290 const char* name;
291 char paramname[SCIP_MAXSTRLEN];
292
293 assert(scip != NULL);
294 assert(conshdlr != NULL);
295
296 SCIP_CALL( SCIPcheckStage(scip, "SCIPsetConshdlrProp", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
297
298 SCIPconshdlrSetProp(conshdlr, consprop, propfreq, delayprop, proptiming);
299
300 name = SCIPconshdlrGetName(conshdlr);
301
302 (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "constraints/%s/propfreq", name);
303 SCIP_CALL( SCIPsetSetDefaultIntParam(scip->set, paramname, propfreq) );
304
305 (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "constraints/%s/proptiming", name);
306 SCIP_CALL( SCIPsetSetDefaultIntParam(scip->set, paramname, (int) proptiming) );
307
308 (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "constraints/%s/delayprop", name);
309 SCIP_CALL( SCIPsetSetDefaultBoolParam(scip->set, paramname, delayprop) );
310
311 return SCIP_OKAY;
312}
313
314/** sets relaxation enforcement method of the constraint handler
315 *
316 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
317 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
318 *
319 * @pre This method can be called if SCIP is in one of the following stages:
320 * - \ref SCIP_STAGE_INIT
321 * - \ref SCIP_STAGE_PROBLEM
322 */
323SCIP_RETCODE SCIPsetConshdlrEnforelax(
324 SCIP* scip, /**< SCIP data structure */
325 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
326 SCIP_DECL_CONSENFORELAX ((*consenforelax)) /**< enforcement method for relaxation solution of constraint handler (might be NULL) */
327 )
328{
329 SCIP_CALL( SCIPcheckStage(scip, "SCIPsetConshdlrEnforelax", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
330
331 assert(conshdlr != NULL);
332
333 SCIPconshdlrSetEnforelax(conshdlr, consenforelax);
334
335 return SCIP_OKAY;
336}
337
338/** sets copy method of both the constraint handler and each associated constraint
339 *
340 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
341 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
342 *
343 * @pre This method can be called if SCIP is in one of the following stages:
344 * - \ref SCIP_STAGE_INIT
345 * - \ref SCIP_STAGE_PROBLEM
346 */
347SCIP_RETCODE SCIPsetConshdlrCopy(
348 SCIP* scip, /**< SCIP data structure */
349 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
350 SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), /**< copy method of constraint handler or NULL if you don't want to copy your plugin into sub-SCIPs */
351 SCIP_DECL_CONSCOPY ((*conscopy)) /**< constraint copying method */
352 )
353{
354 SCIP_CALL( SCIPcheckStage(scip, "SCIPsetConshdlrCopy", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
355
356 assert(conshdlr != NULL);
357
358 SCIPconshdlrSetCopy(conshdlr, conshdlrcopy, conscopy);
359
360 return SCIP_OKAY;
361}
362
363/** sets destructor method of constraint handler
364 *
365 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
366 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
367 *
368 * @pre This method can be called if SCIP is in one of the following stages:
369 * - \ref SCIP_STAGE_INIT
370 * - \ref SCIP_STAGE_PROBLEM
371 */
372SCIP_RETCODE SCIPsetConshdlrFree(
373 SCIP* scip, /**< SCIP data structure */
374 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
375 SCIP_DECL_CONSFREE ((*consfree)) /**< destructor of constraint handler */
376 )
377{
378 SCIP_CALL( SCIPcheckStage(scip, "SCIPsetConshdlrFree", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
379
380 assert(conshdlr != NULL);
381
382 SCIPconshdlrSetFree(conshdlr, consfree);
383
384 return SCIP_OKAY;
385}
386
387/** sets initialization method of constraint handler
388 *
389 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
390 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
391 *
392 * @pre This method can be called if SCIP is in one of the following stages:
393 * - \ref SCIP_STAGE_INIT
394 * - \ref SCIP_STAGE_PROBLEM
395 */
396SCIP_RETCODE SCIPsetConshdlrInit(
397 SCIP* scip, /**< SCIP data structure */
398 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
399 SCIP_DECL_CONSINIT ((*consinit)) /**< initialize constraint handler */
400 )
401{
402 SCIP_CALL( SCIPcheckStage(scip, "SCIPsetConshdlrInit", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
403
404 assert(conshdlr != NULL);
405
406 SCIPconshdlrSetInit(conshdlr, consinit);
407
408 return SCIP_OKAY;
409}
410
411/** sets deinitialization method of constraint handler
412 *
413 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
414 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
415 *
416 * @pre This method can be called if SCIP is in one of the following stages:
417 * - \ref SCIP_STAGE_INIT
418 * - \ref SCIP_STAGE_PROBLEM
419 */
420SCIP_RETCODE SCIPsetConshdlrExit(
421 SCIP* scip, /**< SCIP data structure */
422 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
423 SCIP_DECL_CONSEXIT ((*consexit)) /**< deinitialize constraint handler */
424 )
425{
426 SCIP_CALL( SCIPcheckStage(scip, "SCIPsetConshdlrExit", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
427
428 assert(conshdlr != NULL);
429
430 SCIPconshdlrSetExit(conshdlr, consexit);
431
432 return SCIP_OKAY;
433}
434
435/** sets solving process initialization method of constraint handler
436 *
437 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
438 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
439 *
440 * @pre This method can be called if SCIP is in one of the following stages:
441 * - \ref SCIP_STAGE_INIT
442 * - \ref SCIP_STAGE_PROBLEM
443 */
444SCIP_RETCODE SCIPsetConshdlrInitsol(
445 SCIP* scip, /**< SCIP data structure */
446 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
447 SCIP_DECL_CONSINITSOL((*consinitsol)) /**< solving process initialization method of constraint handler */
448 )
449{
450 SCIP_CALL( SCIPcheckStage(scip, "SCIPsetConshdlrInitsol", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
451
452 assert(conshdlr != NULL);
453
454 SCIPconshdlrSetInitsol(conshdlr, consinitsol);
455
456 return SCIP_OKAY;
457}
458
459/** sets solving process deinitialization method of constraint handler
460 *
461 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
462 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
463 *
464 * @pre This method can be called if SCIP is in one of the following stages:
465 * - \ref SCIP_STAGE_INIT
466 * - \ref SCIP_STAGE_PROBLEM
467 */
468SCIP_RETCODE SCIPsetConshdlrExitsol(
469 SCIP* scip, /**< SCIP data structure */
470 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
471 SCIP_DECL_CONSEXITSOL ((*consexitsol))/**< solving process deinitialization method of constraint handler */
472 )
473{
474 SCIP_CALL( SCIPcheckStage(scip, "SCIPsetConshdlrExitsol", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
475
476 assert(conshdlr != NULL);
477
478 SCIPconshdlrSetExitsol(conshdlr, consexitsol);
479
480 return SCIP_OKAY;
481}
482
483/** sets preprocessing initialization method of constraint handler
484 *
485 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
486 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
487 *
488 * @pre This method can be called if SCIP is in one of the following stages:
489 * - \ref SCIP_STAGE_INIT
490 * - \ref SCIP_STAGE_PROBLEM
491 */
492SCIP_RETCODE SCIPsetConshdlrInitpre(
493 SCIP* scip, /**< SCIP data structure */
494 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
495 SCIP_DECL_CONSINITPRE((*consinitpre)) /**< preprocessing initialization method of constraint handler */
496 )
497{
498 SCIP_CALL( SCIPcheckStage(scip, "SCIPsetConshdlrInitpre", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
499
500 assert(conshdlr != NULL);
501
502 SCIPconshdlrSetInitpre(conshdlr, consinitpre);
503
504 return SCIP_OKAY;
505}
506
507/** sets preprocessing deinitialization method of constraint handler
508 *
509 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
510 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
511 *
512 * @pre This method can be called if SCIP is in one of the following stages:
513 * - \ref SCIP_STAGE_INIT
514 * - \ref SCIP_STAGE_PROBLEM
515 */
516SCIP_RETCODE SCIPsetConshdlrExitpre(
517 SCIP* scip, /**< SCIP data structure */
518 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
519 SCIP_DECL_CONSEXITPRE((*consexitpre)) /**< preprocessing deinitialization method of constraint handler */
520 )
521{
522 SCIP_CALL( SCIPcheckStage(scip, "SCIPsetConshdlrExitpre", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
523
524 assert(conshdlr != NULL);
525
526 SCIPconshdlrSetExitpre(conshdlr, consexitpre);
527
528 return SCIP_OKAY;
529}
530
531/** sets presolving method of constraint handler
532 *
533 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
534 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
535 *
536 * @pre This method can be called if SCIP is in one of the following stages:
537 * - \ref SCIP_STAGE_INIT
538 * - \ref SCIP_STAGE_PROBLEM
539 */
540SCIP_RETCODE SCIPsetConshdlrPresol(
541 SCIP* scip, /**< SCIP data structure */
542 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
543 SCIP_DECL_CONSPRESOL ((*conspresol)), /**< presolving method of constraint handler */
544 int maxprerounds, /**< maximal number of presolving rounds the constraint handler participates in (-1: no limit) */
545 SCIP_PRESOLTIMING presoltiming /**< timing mask of the constraint handler's presolving method */
546 )
547{
548 const char* name;
549 char paramname[SCIP_MAXSTRLEN];
550
551 assert(scip != NULL);
552 assert(conshdlr != NULL);
553
554 SCIP_CALL( SCIPcheckStage(scip, "SCIPsetConshdlrPresol", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
555
556 SCIP_CALL( SCIPconshdlrSetPresol(conshdlr, conspresol, maxprerounds, presoltiming) );
557
558 name = SCIPconshdlrGetName(conshdlr);
559
560 (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "constraints/%s/maxprerounds", name);
561 SCIP_CALL( SCIPsetSetDefaultIntParam(scip->set, paramname, maxprerounds) );
562
563 (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "constraints/%s/presoltiming", name);
564 SCIP_CALL( SCIPsetSetDefaultIntParam(scip->set, paramname, (int) presoltiming) );
565
566 return SCIP_OKAY;
567}
568
569/** sets method of constraint handler to free specific constraint data
570 *
571 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
572 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
573 *
574 * @pre This method can be called if SCIP is in one of the following stages:
575 * - \ref SCIP_STAGE_INIT
576 * - \ref SCIP_STAGE_PROBLEM
577 */
578SCIP_RETCODE SCIPsetConshdlrDelete(
579 SCIP* scip, /**< SCIP data structure */
580 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
581 SCIP_DECL_CONSDELETE ((*consdelete)) /**< free specific constraint data */
582 )
583{
584 assert(scip != NULL);
585 SCIP_CALL( SCIPcheckStage(scip, "SCIPsetConshdlrDelete", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
586
587 SCIPconshdlrSetDelete(conshdlr, consdelete);
588
589 return SCIP_OKAY;
590}
591
592/** sets method of constraint handler to transform constraint data into data belonging to the transformed problem
593 *
594 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
595 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
596 *
597 * @pre This method can be called if SCIP is in one of the following stages:
598 * - \ref SCIP_STAGE_INIT
599 * - \ref SCIP_STAGE_PROBLEM
600 */
601SCIP_RETCODE SCIPsetConshdlrTrans(
602 SCIP* scip, /**< SCIP data structure */
603 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
604 SCIP_DECL_CONSTRANS ((*constrans)) /**< transform constraint data into data belonging to the transformed problem */
605 )
606{
607 assert(scip != NULL);
608 SCIP_CALL( SCIPcheckStage(scip, "SCIPsetConshdlrTrans", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
609
610 SCIPconshdlrSetTrans(conshdlr, constrans);
611
612 return SCIP_OKAY;
613}
614
615/** sets method of constraint handler to initialize LP with relaxations of "initial" constraints
616 *
617 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
618 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
619 *
620 * @pre This method can be called if SCIP is in one of the following stages:
621 * - \ref SCIP_STAGE_INIT
622 * - \ref SCIP_STAGE_PROBLEM
623 */
624SCIP_RETCODE SCIPsetConshdlrInitlp(
625 SCIP* scip, /**< SCIP data structure */
626 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
627 SCIP_DECL_CONSINITLP ((*consinitlp)) /**< initialize LP with relaxations of "initial" constraints */
628 )
629{
630 assert(scip != NULL);
631 SCIP_CALL( SCIPcheckStage(scip, "SCIPsetConshdlrInitlp", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
632
633 SCIPconshdlrSetInitlp(conshdlr, consinitlp);
634
635 return SCIP_OKAY;
636}
637
638/** sets propagation conflict resolving method of constraint handler
639 *
640 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
641 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
642 *
643 * @pre This method can be called if SCIP is in one of the following stages:
644 * - \ref SCIP_STAGE_INIT
645 * - \ref SCIP_STAGE_PROBLEM
646 */
647SCIP_RETCODE SCIPsetConshdlrResprop(
648 SCIP* scip, /**< SCIP data structure */
649 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
650 SCIP_DECL_CONSRESPROP ((*consresprop)) /**< propagation conflict resolving method */
651 )
652{
653 assert(scip != NULL);
654 SCIP_CALL( SCIPcheckStage(scip, "SCIPsetConshdlrResprop", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
655
656 SCIPconshdlrSetResprop(conshdlr, consresprop);
657
658 return SCIP_OKAY;
659}
660
661/** sets activation notification method of constraint handler
662 *
663 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
664 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
665 *
666 * @pre This method can be called if SCIP is in one of the following stages:
667 * - \ref SCIP_STAGE_INIT
668 * - \ref SCIP_STAGE_PROBLEM
669 */
670SCIP_RETCODE SCIPsetConshdlrActive(
671 SCIP* scip, /**< SCIP data structure */
672 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
673 SCIP_DECL_CONSACTIVE ((*consactive)) /**< activation notification method */
674 )
675{
676 assert(scip != NULL);
677 SCIP_CALL( SCIPcheckStage(scip, "SCIPsetConshdlrActive", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
678
679 SCIPconshdlrSetActive(conshdlr, consactive);
680
681 return SCIP_OKAY;
682}
683
684/** sets deactivation notification method of constraint handler
685 *
686 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
687 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
688 *
689 * @pre This method can be called if SCIP is in one of the following stages:
690 * - \ref SCIP_STAGE_INIT
691 * - \ref SCIP_STAGE_PROBLEM
692 */
693SCIP_RETCODE SCIPsetConshdlrDeactive(
694 SCIP* scip, /**< SCIP data structure */
695 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
696 SCIP_DECL_CONSDEACTIVE((*consdeactive)) /**< deactivation notification method */
697 )
698{
699 assert(scip != NULL);
700 SCIP_CALL( SCIPcheckStage(scip, "SCIPsetConshdlrDeactive", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
701
702 SCIPconshdlrSetDeactive(conshdlr, consdeactive);
703
704 return SCIP_OKAY;
705}
706
707/** sets enabling notification method of constraint handler
708 *
709 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
710 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
711 *
712 * @pre This method can be called if SCIP is in one of the following stages:
713 * - \ref SCIP_STAGE_INIT
714 * - \ref SCIP_STAGE_PROBLEM
715 */
716SCIP_RETCODE SCIPsetConshdlrEnable(
717 SCIP* scip, /**< SCIP data structure */
718 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
719 SCIP_DECL_CONSENABLE ((*consenable)) /**< enabling notification method */
720 )
721{
722 assert(scip != NULL);
723 SCIP_CALL( SCIPcheckStage(scip, "SCIPsetConshdlrEnable", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
724
725 SCIPconshdlrSetEnable(conshdlr, consenable);
726
727 return SCIP_OKAY;
728}
729
730/** sets disabling notification method of constraint handler
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 SCIP is in one of the following stages:
736 * - \ref SCIP_STAGE_INIT
737 * - \ref SCIP_STAGE_PROBLEM
738 */
739SCIP_RETCODE SCIPsetConshdlrDisable(
740 SCIP* scip, /**< SCIP data structure */
741 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
742 SCIP_DECL_CONSDISABLE ((*consdisable)) /**< disabling notification method */
743 )
744{
745 assert(scip != NULL);
746 SCIP_CALL( SCIPcheckStage(scip, "SCIPsetConshdlrDisable", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
747
748 SCIPconshdlrSetDisable(conshdlr, consdisable);
749
750 return SCIP_OKAY;
751}
752
753/** sets variable deletion method of constraint handler
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 SCIP is in one of the following stages:
759 * - \ref SCIP_STAGE_INIT
760 * - \ref SCIP_STAGE_PROBLEM
761 */
762SCIP_RETCODE SCIPsetConshdlrDelvars(
763 SCIP* scip, /**< SCIP data structure */
764 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
765 SCIP_DECL_CONSDELVARS ((*consdelvars)) /**< variable deletion method */
766 )
767{
768 assert(scip != NULL);
769 SCIP_CALL( SCIPcheckStage(scip, "SCIPsetConshdlrDelvars", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
770
771 SCIPconshdlrSetDelvars(conshdlr, consdelvars);
772
773 return SCIP_OKAY;
774}
775
776/** sets constraint display method of constraint handler
777 *
778 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
779 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
780 *
781 * @pre This method can be called if SCIP is in one of the following stages:
782 * - \ref SCIP_STAGE_INIT
783 * - \ref SCIP_STAGE_PROBLEM
784 */
785SCIP_RETCODE SCIPsetConshdlrPrint(
786 SCIP* scip, /**< SCIP data structure */
787 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
788 SCIP_DECL_CONSPRINT ((*consprint)) /**< constraint display method */
789 )
790{
791 assert(scip != NULL);
792 SCIP_CALL( SCIPcheckStage(scip, "SCIPsetConshdlrPrint", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
793
794 SCIPconshdlrSetPrint(conshdlr, consprint);
795
796 return SCIP_OKAY;
797}
798
799/** sets constraint parsing method of constraint handler
800 *
801 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
802 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
803 *
804 * @pre This method can be called if SCIP is in one of the following stages:
805 * - \ref SCIP_STAGE_INIT
806 * - \ref SCIP_STAGE_PROBLEM
807 */
808SCIP_RETCODE SCIPsetConshdlrParse(
809 SCIP* scip, /**< SCIP data structure */
810 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
811 SCIP_DECL_CONSPARSE ((*consparse)) /**< constraint parsing method */
812 )
813{
814 assert(scip != NULL);
815 SCIP_CALL( SCIPcheckStage(scip, "SCIPsetConshdlrParse", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
816
817 SCIPconshdlrSetParse(conshdlr, consparse);
818
819 return SCIP_OKAY;
820}
821
822/** sets constraint variable getter method of constraint handler
823 *
824 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
825 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
826 *
827 * @pre This method can be called if SCIP is in one of the following stages:
828 * - \ref SCIP_STAGE_INIT
829 * - \ref SCIP_STAGE_PROBLEM
830 */
831SCIP_RETCODE SCIPsetConshdlrGetVars(
832 SCIP* scip, /**< SCIP data structure */
833 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
834 SCIP_DECL_CONSGETVARS ((*consgetvars)) /**< constraint variable getter method */
835 )
836{
837 assert(scip != NULL);
838 SCIP_CALL( SCIPcheckStage(scip, "SCIPsetConshdlrGetVars", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
839
840 SCIPconshdlrSetGetVars(conshdlr, consgetvars);
841
842 return SCIP_OKAY;
843}
844
845/** sets constraint variable number getter method of constraint handler
846 *
847 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
848 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
849 *
850 * @pre This method can be called if SCIP is in one of the following stages:
851 * - \ref SCIP_STAGE_INIT
852 * - \ref SCIP_STAGE_PROBLEM
853 */
854SCIP_RETCODE SCIPsetConshdlrGetNVars(
855 SCIP* scip, /**< SCIP data structure */
856 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
857 SCIP_DECL_CONSGETNVARS((*consgetnvars)) /**< constraint variable number getter method */
858 )
859{
860 assert(scip != NULL);
861 SCIP_CALL( SCIPcheckStage(scip, "SCIPsetConshdlrGetNVars", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
862
863 SCIPconshdlrSetGetNVars(conshdlr, consgetnvars);
864
865 return SCIP_OKAY;
866}
867
868/** sets diving bound change method of constraint handler
869 *
870 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
871 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
872 *
873 * @pre This method can be called if SCIP is in one of the following stages:
874 * - \ref SCIP_STAGE_INIT
875 * - \ref SCIP_STAGE_PROBLEM
876 */
877SCIP_RETCODE SCIPsetConshdlrGetDiveBdChgs(
878 SCIP* scip, /**< SCIP data structure */
879 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
880 SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs)) /**< constraint handler diving solution enforcement method */
881 )
882{
883 assert(scip != NULL);
884 SCIP_CALL( SCIPcheckStage(scip, "SCIPsetConshdlrGetDiveBdChgs", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
885
886 SCIPconshdlrSetGetDiveBdChgs(conshdlr, consgetdivebdchgs);
887
888 return SCIP_OKAY;
889}
890
891/** sets permutation symmetry detection graph getter method of constraint handler
892 *
893 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
894 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
895 *
896 * @pre This method can be called if SCIP is in one of the following stages:
897 * - \ref SCIP_STAGE_INIT
898 * - \ref SCIP_STAGE_PROBLEM
899 */
900SCIP_RETCODE SCIPsetConshdlrGetPermsymGraph(
901 SCIP* scip, /**< SCIP data structure */
902 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
903 SCIP_DECL_CONSGETPERMSYMGRAPH((*consgetpermsymgraph)) /**< constraint permutation symmetry detection graph
904 * getter method */
905 )
906{
907 assert(scip != NULL);
908 SCIP_CALL( SCIPcheckStage(scip, "SCIPsetConshdlrGetPermsymGraph", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
909
910 SCIPconshdlrSetGetPermsymGraph(conshdlr, consgetpermsymgraph);
911
912 return SCIP_OKAY;
913}
914
915/** sets signed permutation symmetry detection graph getter method of constraint handler
916 *
917 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
918 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
919 *
920 * @pre This method can be called if SCIP is in one of the following stages:
921 * - \ref SCIP_STAGE_INIT
922 * - \ref SCIP_STAGE_PROBLEM
923 */
924SCIP_RETCODE SCIPsetConshdlrGetSignedPermsymGraph(
925 SCIP* scip, /**< SCIP data structure */
926 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
927 SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH((*consgetsignedpermsymgraph)) /**< constraint signed permutation symmetry
928 * detection graph getter method */
929 )
930{
931 assert(scip != NULL);
932 SCIP_CALL( SCIPcheckStage(scip, "SCIPsetConshdlrGetSignedPermsymGraph", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
933
934 SCIPconshdlrSetGetSignedPermsymGraph(conshdlr, consgetsignedpermsymgraph);
935
936 return SCIP_OKAY;
937}
938
939/** returns the constraint handler of the given name, or NULL if not existing */
940SCIP_CONSHDLR* SCIPfindConshdlr(
941 SCIP* scip, /**< SCIP data structure */
942 const char* name /**< name of constraint handler */
943 )
944{
945 assert(scip != NULL);
946 assert(scip->set != NULL);
947 assert(name != NULL);
948
949 return SCIPsetFindConshdlr(scip->set, name);
950}
951
952/** returns the array of currently available constraint handlers */
953SCIP_CONSHDLR** SCIPgetConshdlrs(
954 SCIP* scip /**< SCIP data structure */
955 )
956{
957 assert(scip != NULL);
958 assert(scip->set != NULL);
959
960 return scip->set->conshdlrs;
961}
962
963/** returns the number of currently available constraint handlers */
964int SCIPgetNConshdlrs(
965 SCIP* scip /**< SCIP data structure */
966 )
967{
968 assert(scip != NULL);
969 assert(scip->set != NULL);
970
971 return scip->set->nconshdlrs;
972}
973
974/** creates and captures a constraint of the given constraint handler
975 *
976 * @warning If a constraint is marked to be checked for feasibility but not to be enforced, a LP or pseudo solution may
977 * be declared feasible even if it violates this particular constraint. This constellation should only be
978 * used, if no LP or pseudo solution can violate the constraint -- e.g. if a local constraint is redundant due
979 * to the variable's local bounds.
980 *
981 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
982 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
983 *
984 * @pre This method can be called if @p scip is in one of the following stages:
985 * - \ref SCIP_STAGE_PROBLEM
986 * - \ref SCIP_STAGE_TRANSFORMING
987 * - \ref SCIP_STAGE_INITPRESOLVE
988 * - \ref SCIP_STAGE_PRESOLVING
989 * - \ref SCIP_STAGE_EXITPRESOLVE
990 * - \ref SCIP_STAGE_PRESOLVED
991 * - \ref SCIP_STAGE_INITSOLVE
992 * - \ref SCIP_STAGE_SOLVING
993 * - \ref SCIP_STAGE_EXITSOLVE
994 *
995 * @note the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()
996 */
997SCIP_RETCODE SCIPcreateCons(
998 SCIP* scip, /**< SCIP data structure */
999 SCIP_CONS** cons, /**< pointer to constraint */
1000 const char* name, /**< name of constraint */
1001 SCIP_CONSHDLR* conshdlr, /**< constraint handler for this constraint */
1002 SCIP_CONSDATA* consdata, /**< data for this specific constraint */
1003 SCIP_Bool initial, /**< should the LP relaxation of constraint be in the initial LP?
1004 * Usually set to TRUE. Set to FALSE for 'lazy constraints'. */
1005 SCIP_Bool separate, /**< should the constraint be separated during LP processing?
1006 * Usually set to TRUE. */
1007 SCIP_Bool enforce, /**< should the constraint be enforced during node processing?
1008 * TRUE for model constraints, FALSE for additional, redundant constraints. */
1009 SCIP_Bool check, /**< should the constraint be checked for feasibility?
1010 * TRUE for model constraints, FALSE for additional, redundant constraints. */
1011 SCIP_Bool propagate, /**< should the constraint be propagated during node processing?
1012 * Usually set to TRUE. */
1013 SCIP_Bool local, /**< is constraint only valid locally?
1014 * Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints. */
1015 SCIP_Bool modifiable, /**< is constraint modifiable (subject to column generation)?
1016 * Usually set to FALSE. In column generation applications, set to TRUE if pricing
1017 * adds coefficients to this constraint. */
1018 SCIP_Bool dynamic, /**< is constraint subject to aging?
1019 * Usually set to FALSE. Set to TRUE for own cuts which
1020 * are separated as constraints. */
1021 SCIP_Bool removable, /**< should the relaxation be removed from the LP due to aging or cleanup?
1022 * Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'. */
1023 SCIP_Bool stickingatnode /**< should the constraint always be kept at the node where it was added, even
1024 * if it may be moved to a more global node?
1025 * Usually set to FALSE. Set to TRUE to for constraints that represent node data. */
1026 )
1027{
1028 assert(cons != NULL);
1029 assert(name != NULL);
1030 assert(conshdlr != NULL);
1031
1032 SCIP_CALL( SCIPcheckStage(scip, "SCIPcreateCons", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, FALSE, FALSE) );
1033
1034 switch( scip->set->stage )
1035 {
1036 case SCIP_STAGE_PROBLEM:
1037 SCIP_CALL( SCIPconsCreate(cons, scip->mem->probmem, scip->set, name, conshdlr, consdata,
1038 initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, stickingatnode, TRUE, TRUE) );
1039 return SCIP_OKAY;
1040
1041 case SCIP_STAGE_TRANSFORMING:
1042 case SCIP_STAGE_TRANSFORMED:
1043 case SCIP_STAGE_INITPRESOLVE:
1044 case SCIP_STAGE_PRESOLVING:
1045 case SCIP_STAGE_EXITPRESOLVE:
1046 case SCIP_STAGE_PRESOLVED:
1047 case SCIP_STAGE_INITSOLVE:
1048 case SCIP_STAGE_SOLVING:
1049 case SCIP_STAGE_EXITSOLVE:
1050 SCIP_CALL( SCIPconsCreate(cons, scip->mem->probmem, scip->set, name, conshdlr, consdata,
1051 initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, stickingatnode, FALSE, TRUE) );
1052 return SCIP_OKAY;
1053
1054 default:
1055 SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
1056 return SCIP_INVALIDCALL;
1057 } /*lint !e788*/
1058}
1059
1060/** parses constraint information (in cip format) out of a string; if the parsing process was successful a constraint is
1061 * creates and captures;
1062 *
1063 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1064 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1065 *
1066 * @pre This method can be called if @p scip is in one of the following stages:
1067 * - \ref SCIP_STAGE_PROBLEM
1068 * - \ref SCIP_STAGE_TRANSFORMING
1069 * - \ref SCIP_STAGE_INITPRESOLVE
1070 * - \ref SCIP_STAGE_PRESOLVING
1071 * - \ref SCIP_STAGE_EXITPRESOLVE
1072 * - \ref SCIP_STAGE_PRESOLVED
1073 * - \ref SCIP_STAGE_SOLVING
1074 * - \ref SCIP_STAGE_EXITSOLVE
1075 *
1076 * @warning If a constraint is marked to be checked for feasibility but not to be enforced, a LP or pseudo solution may
1077 * be declared feasible even if it violates this particular constraint. This constellation should only be
1078 * used, if no LP or pseudo solution can violate the constraint -- e.g. if a local constraint is redundant due
1079 * to the variable's local bounds.
1080 */
1081SCIP_RETCODE SCIPparseCons(
1082 SCIP* scip, /**< SCIP data structure */
1083 SCIP_CONS** cons, /**< pointer to store constraint */
1084 const char* str, /**< string to parse for constraint */
1085 SCIP_Bool initial, /**< should the LP relaxation of constraint be in the initial LP?
1086 * Usually set to TRUE. Set to FALSE for 'lazy constraints'. */
1087 SCIP_Bool separate, /**< should the constraint be separated during LP processing?
1088 * Usually set to TRUE. */
1089 SCIP_Bool enforce, /**< should the constraint be enforced during node processing?
1090 * TRUE for model constraints, FALSE for additional, redundant constraints. */
1091 SCIP_Bool check, /**< should the constraint be checked for feasibility?
1092 * TRUE for model constraints, FALSE for additional, redundant constraints. */
1093 SCIP_Bool propagate, /**< should the constraint be propagated during node processing?
1094 * Usually set to TRUE. */
1095 SCIP_Bool local, /**< is constraint only valid locally?
1096 * Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints. */
1097 SCIP_Bool modifiable, /**< is constraint modifiable (subject to column generation)?
1098 * Usually set to FALSE. In column generation applications, set to TRUE if pricing
1099 * adds coefficients to this constraint. */
1100 SCIP_Bool dynamic, /**< is constraint subject to aging?
1101 * Usually set to FALSE. Set to TRUE for own cuts which
1102 * are separated as constraints. */
1103 SCIP_Bool removable, /**< should the relaxation be removed from the LP due to aging or cleanup?
1104 * Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'. */
1105 SCIP_Bool stickingatnode, /**< should the constraint always be kept at the node where it was added, even
1106 * if it may be moved to a more global node?
1107 * Usually set to FALSE. Set to TRUE to for constraints that represent node data. */
1108 SCIP_Bool* success /**< pointer to store if the paring process was successful */
1109 )
1110{
1111 assert(cons != NULL);
1112
1113 SCIP_CALL( SCIPcheckStage(scip, "SCIPparseCons", FALSE, TRUE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE) );
1114
1115 SCIP_CALL( SCIPconsParse(cons, scip->set, scip->messagehdlr, str,
1116 initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, stickingatnode, success) );
1117
1118 return SCIP_OKAY;
1119}
1120
1121/** increases usage counter of constraint
1122 *
1123 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1124 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1125 *
1126 * @pre This method can be called if @p scip is in one of the following stages:
1127 * - \ref SCIP_STAGE_PROBLEM
1128 * - \ref SCIP_STAGE_TRANSFORMING
1129 * - \ref SCIP_STAGE_TRANSFORMED
1130 * - \ref SCIP_STAGE_INITPRESOLVE
1131 * - \ref SCIP_STAGE_PRESOLVING
1132 * - \ref SCIP_STAGE_EXITPRESOLVE
1133 * - \ref SCIP_STAGE_PRESOLVED
1134 * - \ref SCIP_STAGE_INITSOLVE
1135 * - \ref SCIP_STAGE_SOLVING
1136 * - \ref SCIP_STAGE_SOLVED
1137 */
1138SCIP_RETCODE SCIPcaptureCons(
1139 SCIP* scip, /**< SCIP data structure */
1140 SCIP_CONS* cons /**< constraint to capture */
1141 )
1142{
1143 SCIP_CALL( SCIPcheckStage(scip, "SCIPcaptureCons", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1144
1145 assert( cons->scip == scip );
1146
1147 SCIPconsCapture(cons);
1148
1149 return SCIP_OKAY;
1150}
1151
1152/** decreases usage counter of constraint, if the usage pointer reaches zero the constraint gets freed
1153 *
1154 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1155 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1156 *
1157 * @pre This method can be called if @p scip is in one of the following stages:
1158 * - \ref SCIP_STAGE_PROBLEM
1159 * - \ref SCIP_STAGE_TRANSFORMING
1160 * - \ref SCIP_STAGE_TRANSFORMED
1161 * - \ref SCIP_STAGE_INITPRESOLVE
1162 * - \ref SCIP_STAGE_PRESOLVING
1163 * - \ref SCIP_STAGE_EXITPRESOLVE
1164 * - \ref SCIP_STAGE_PRESOLVED
1165 * - \ref SCIP_STAGE_INITSOLVE
1166 * - \ref SCIP_STAGE_SOLVING
1167 * - \ref SCIP_STAGE_SOLVED
1168 * - \ref SCIP_STAGE_EXITSOLVE
1169 * - \ref SCIP_STAGE_FREETRANS
1170 *
1171 * @note the pointer of the constraint will be NULLed
1172 */
1173SCIP_RETCODE SCIPreleaseCons(
1174 SCIP* scip, /**< SCIP data structure */
1175 SCIP_CONS** cons /**< pointer to constraint */
1176 )
1177{
1178 assert(cons != NULL);
1179 assert(*cons != NULL);
1180
1181 SCIP_CALL( SCIPcheckStage(scip, "SCIPreleaseCons", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
1182
1183 switch( scip->set->stage )
1184 {
1185 case SCIP_STAGE_PROBLEM:
1186 SCIP_CALL( SCIPconsRelease(cons, scip->mem->probmem, scip->set) );
1187 return SCIP_OKAY;
1188
1189 case SCIP_STAGE_TRANSFORMING:
1190 case SCIP_STAGE_TRANSFORMED:
1191 case SCIP_STAGE_INITPRESOLVE:
1192 case SCIP_STAGE_PRESOLVING:
1193 case SCIP_STAGE_EXITPRESOLVE:
1194 case SCIP_STAGE_PRESOLVED:
1195 case SCIP_STAGE_INITSOLVE:
1196 case SCIP_STAGE_SOLVING:
1197 case SCIP_STAGE_SOLVED:
1198 case SCIP_STAGE_EXITSOLVE:
1199 case SCIP_STAGE_FREETRANS:
1200 if( SCIPconsIsOriginal(*cons) && (*cons)->nuses == 1 && (*cons)->transorigcons != NULL )
1201 {
1202 SCIPerrorMessage("cannot release last use of original constraint while an associated transformed constraint exists\n");
1203 return SCIP_INVALIDCALL;
1204 }
1205 SCIP_CALL( SCIPconsRelease(cons, scip->mem->probmem, scip->set) );
1206 return SCIP_OKAY;
1207
1208 default:
1209 SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
1210 return SCIP_INVALIDCALL;
1211 } /*lint !e788*/
1212}
1213
1214/** change constraint name
1215 *
1216 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1217 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1218 *
1219 * @pre This method can be called if @p scip is in one of the following stages:
1220 * - \ref SCIP_STAGE_PROBLEM
1221 *
1222 * @note to get the current name of a constraint, use SCIPconsGetName() from pub_cons.h
1223 */
1224SCIP_RETCODE SCIPchgConsName(
1225 SCIP* scip, /**< SCIP data structure */
1226 SCIP_CONS* cons, /**< constraint */
1227 const char* name /**< new name of constraint */
1228 )
1229{
1230 SCIP_CALL( SCIPcheckStage(scip, "SCIPchgConsName", FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE , FALSE, FALSE, FALSE) );
1231
1232 assert( cons->scip == scip );
1233
1234 if( SCIPgetStage(scip) != SCIP_STAGE_PROBLEM )
1235 {
1236 SCIPerrorMessage("constraint names can only be changed in problem creation stage\n");
1237 SCIPABORT();
1238 return SCIP_INVALIDCALL; /*lint !e527*/
1239 }
1240
1241 /* remove constraint's name from the namespace if the constraint was already added */
1242 if( SCIPconsIsAdded(cons) )
1243 {
1244 SCIP_CALL( SCIPprobRemoveConsName(scip->origprob, cons) );
1245 }
1246
1247 /* change constraint name */
1248 SCIP_CALL( SCIPconsChgName(cons, SCIPblkmem(scip), name) );
1249
1250 /* add constraint's name to the namespace if the constraint was already added */
1251 if( SCIPconsIsAdded(cons) )
1252 {
1253 SCIP_CALL( SCIPprobAddConsName(scip->origprob, cons) );
1254 }
1255
1256 return SCIP_OKAY;
1257}
1258
1259/** sets the initial flag of the given constraint
1260 *
1261 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1262 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1263 *
1264 * @pre This method can be called if @p scip is in one of the following stages:
1265 * - \ref SCIP_STAGE_PROBLEM
1266 * - \ref SCIP_STAGE_TRANSFORMING
1267 * - \ref SCIP_STAGE_PRESOLVING
1268 * - \ref SCIP_STAGE_PRESOLVED
1269 * - \ref SCIP_STAGE_SOLVING
1270 */
1271SCIP_RETCODE SCIPsetConsInitial(
1272 SCIP* scip, /**< SCIP data structure */
1273 SCIP_CONS* cons, /**< constraint */
1274 SCIP_Bool initial /**< new value */
1275 )
1276{
1277 SCIP_CALL( SCIPcheckStage(scip, "SCIPsetConsInitial", FALSE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1278
1279 SCIP_CALL( SCIPconsSetInitial(cons, scip->set, scip->stat, initial) );
1280
1281 return SCIP_OKAY;
1282}
1283
1284/** sets the separate flag of the given constraint
1285 *
1286 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1287 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1288 *
1289 * @pre This method can be called if @p scip is in one of the following stages:
1290 * - \ref SCIP_STAGE_PROBLEM
1291 * - \ref SCIP_STAGE_TRANSFORMING
1292 * - \ref SCIP_STAGE_PRESOLVING
1293 * - \ref SCIP_STAGE_PRESOLVED
1294 * - \ref SCIP_STAGE_SOLVING
1295 */
1296SCIP_RETCODE SCIPsetConsSeparated(
1297 SCIP* scip, /**< SCIP data structure */
1298 SCIP_CONS* cons, /**< constraint */
1299 SCIP_Bool separate /**< new value */
1300 )
1301{
1302 SCIP_CALL( SCIPcheckStage(scip, "SCIPsetConsSeparated", FALSE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1303
1304 SCIP_CALL( SCIPconsSetSeparated(cons, scip->set, separate) );
1305
1306 return SCIP_OKAY;
1307}
1308
1309/** sets the enforce flag of the given constraint
1310 *
1311 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1312 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1313 *
1314 * @pre This method can be called if @p scip is in one of the following stages:
1315 * - \ref SCIP_STAGE_PROBLEM
1316 * - \ref SCIP_STAGE_TRANSFORMING
1317 * - \ref SCIP_STAGE_PRESOLVING
1318 * - \ref SCIP_STAGE_PRESOLVED
1319 * - \ref SCIP_STAGE_SOLVING
1320 */
1321SCIP_RETCODE SCIPsetConsEnforced(
1322 SCIP* scip, /**< SCIP data structure */
1323 SCIP_CONS* cons, /**< constraint */
1324 SCIP_Bool enforce /**< new value */
1325 )
1326{
1327 SCIP_CALL( SCIPcheckStage(scip, "SCIPsetConsEnforced", FALSE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1328
1329 SCIP_CALL( SCIPconsSetEnforced(cons, scip->set, enforce) );
1330
1331 return SCIP_OKAY;
1332}
1333
1334/** sets the check flag of the given constraint
1335 *
1336 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1337 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1338 *
1339 * @pre This method can be called if @p scip is in one of the following stages:
1340 * - \ref SCIP_STAGE_PROBLEM
1341 * - \ref SCIP_STAGE_TRANSFORMING
1342 * - \ref SCIP_STAGE_PRESOLVING
1343 * - \ref SCIP_STAGE_PRESOLVED
1344 * - \ref SCIP_STAGE_SOLVING
1345 */
1346SCIP_RETCODE SCIPsetConsChecked(
1347 SCIP* scip, /**< SCIP data structure */
1348 SCIP_CONS* cons, /**< constraint */
1349 SCIP_Bool check /**< new value */
1350 )
1351{
1352 SCIP_CALL( SCIPcheckStage(scip, "SCIPsetConsChecked", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1353
1354 SCIP_CALL( SCIPconsSetChecked(cons, scip->set, check) );
1355
1356 return SCIP_OKAY;
1357}
1358
1359/** sets the propagate flag of the given constraint
1360 *
1361 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1362 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1363 *
1364 * @pre This method can be called if @p scip is in one of the following stages:
1365 * - \ref SCIP_STAGE_PROBLEM
1366 * - \ref SCIP_STAGE_TRANSFORMING
1367 * - \ref SCIP_STAGE_PRESOLVING
1368 * - \ref SCIP_STAGE_PRESOLVED
1369 * - \ref SCIP_STAGE_SOLVING
1370 */
1371SCIP_RETCODE SCIPsetConsPropagated(
1372 SCIP* scip, /**< SCIP data structure */
1373 SCIP_CONS* cons, /**< constraint */
1374 SCIP_Bool propagate /**< new value */
1375 )
1376{
1377 SCIP_CALL( SCIPcheckStage(scip, "SCIPsetConsPropagated", FALSE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1378
1379 SCIP_CALL( SCIPconsSetPropagated(cons, scip->set, propagate) );
1380
1381 return SCIP_OKAY;
1382}
1383
1384/** sets the local flag of the given constraint
1385 *
1386 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1387 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1388 *
1389 * @pre This method can be called if @p scip is in one of the following stages:
1390 * - \ref SCIP_STAGE_PROBLEM
1391 * - \ref SCIP_STAGE_TRANSFORMING
1392 * - \ref SCIP_STAGE_INITPRESOLVE
1393 * - \ref SCIP_STAGE_PRESOLVING
1394 * - \ref SCIP_STAGE_PRESOLVED
1395 * - \ref SCIP_STAGE_INITSOLVE
1396 * - \ref SCIP_STAGE_SOLVING
1397 */
1398SCIP_RETCODE SCIPsetConsLocal(
1399 SCIP* scip, /**< SCIP data structure */
1400 SCIP_CONS* cons, /**< constraint */
1401 SCIP_Bool local /**< new value */
1402 )
1403{
1404 SCIP_CALL( SCIPcheckStage(scip, "SCIPsetConsLocal", FALSE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1405
1406 SCIPconsSetLocal(cons, local);
1407
1408 return SCIP_OKAY;
1409}
1410
1411/** sets the modifiable flag of the given constraint
1412 *
1413 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1414 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1415 *
1416 * @pre This method can be called if @p scip is in one of the following stages:
1417 * - \ref SCIP_STAGE_PROBLEM
1418 * - \ref SCIP_STAGE_TRANSFORMING
1419 * - \ref SCIP_STAGE_PRESOLVING
1420 * - \ref SCIP_STAGE_PRESOLVED
1421 * - \ref SCIP_STAGE_SOLVING
1422 * - \ref SCIP_STAGE_EXITSOLVE
1423 */
1424SCIP_RETCODE SCIPsetConsModifiable(
1425 SCIP* scip, /**< SCIP data structure */
1426 SCIP_CONS* cons, /**< constraint */
1427 SCIP_Bool modifiable /**< new value */
1428 )
1429{
1430 SCIP_CALL( SCIPcheckStage(scip, "SCIPsetConsModifiable", FALSE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE) );
1431
1432 SCIPconsSetModifiable(cons, modifiable);
1433
1434 return SCIP_OKAY;
1435}
1436
1437/** sets the dynamic flag of the given constraint
1438 *
1439 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1440 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1441 *
1442 * @pre This method can be called if @p scip is in one of the following stages:
1443 * - \ref SCIP_STAGE_PROBLEM
1444 * - \ref SCIP_STAGE_TRANSFORMING
1445 * - \ref SCIP_STAGE_PRESOLVING
1446 * - \ref SCIP_STAGE_PRESOLVED
1447 * - \ref SCIP_STAGE_SOLVING
1448 */
1449SCIP_RETCODE SCIPsetConsDynamic(
1450 SCIP* scip, /**< SCIP data structure */
1451 SCIP_CONS* cons, /**< constraint */
1452 SCIP_Bool dynamic /**< new value */
1453 )
1454{
1455 SCIP_CALL( SCIPcheckStage(scip, "SCIPsetConsDynamic", FALSE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1456
1457 SCIPconsSetDynamic(cons, dynamic);
1458
1459 return SCIP_OKAY;
1460}
1461
1462/** sets the removable flag of the given constraint
1463 *
1464 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1465 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1466 *
1467 * @pre This method can be called if @p scip is in one of the following stages:
1468 * - \ref SCIP_STAGE_PROBLEM
1469 * - \ref SCIP_STAGE_TRANSFORMING
1470 * - \ref SCIP_STAGE_PRESOLVING
1471 * - \ref SCIP_STAGE_PRESOLVED
1472 * - \ref SCIP_STAGE_SOLVING
1473 */
1474SCIP_RETCODE SCIPsetConsRemovable(
1475 SCIP* scip, /**< SCIP data structure */
1476 SCIP_CONS* cons, /**< constraint */
1477 SCIP_Bool removable /**< new value */
1478 )
1479{
1480 SCIP_CALL( SCIPcheckStage(scip, "SCIPsetConsRemovable", FALSE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1481
1482 SCIPconsSetRemovable(cons, removable);
1483
1484 return SCIP_OKAY;
1485}
1486
1487/** sets the stickingatnode flag of the given constraint
1488 *
1489 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1490 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1491 *
1492 * @pre This method can be called if @p scip is in one of the following stages:
1493 * - \ref SCIP_STAGE_PROBLEM
1494 * - \ref SCIP_STAGE_TRANSFORMING
1495 * - \ref SCIP_STAGE_PRESOLVING
1496 * - \ref SCIP_STAGE_PRESOLVED
1497 * - \ref SCIP_STAGE_SOLVING
1498 */
1499SCIP_RETCODE SCIPsetConsStickingAtNode(
1500 SCIP* scip, /**< SCIP data structure */
1501 SCIP_CONS* cons, /**< constraint */
1502 SCIP_Bool stickingatnode /**< new value */
1503 )
1504{
1505 SCIP_CALL( SCIPcheckStage(scip, "SCIPsetConsStickingAtNode", FALSE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1506
1507 SCIPconsSetStickingAtNode(cons, stickingatnode);
1508
1509 return SCIP_OKAY;
1510}
1511
1512/** updates the flags of the first constraint according to the ones of the second constraint
1513 *
1514 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1515 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1516 *
1517 * @pre This method can be called if @p scip is in one of the following stages:
1518 * - \ref SCIP_STAGE_PROBLEM
1519 * - \ref SCIP_STAGE_TRANSFORMING
1520 * - \ref SCIP_STAGE_PRESOLVING
1521 * - \ref SCIP_STAGE_PRESOLVED
1522 * - \ref SCIP_STAGE_SOLVING
1523 */
1524SCIP_RETCODE SCIPupdateConsFlags(
1525 SCIP* scip, /**< SCIP data structure */
1526 SCIP_CONS* cons0, /**< constraint that should stay */
1527 SCIP_CONS* cons1 /**< constraint that should be deleted */
1528 )
1529{
1530 SCIP_CALL( SCIPcheckStage(scip, "SCIPupdateConsFlags", FALSE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1531
1532 if( SCIPconsIsInitial(cons1) )
1533 {
1534 SCIP_CALL( SCIPsetConsInitial(scip, cons0, TRUE) );
1535 }
1536 if( SCIPconsIsSeparated(cons1) )
1537 {
1538 SCIP_CALL( SCIPsetConsSeparated(scip, cons0, TRUE) );
1539 }
1540 if( SCIPconsIsEnforced(cons1) )
1541 {
1542 SCIP_CALL( SCIPsetConsEnforced(scip, cons0, TRUE) );
1543 }
1544 if( SCIPconsIsChecked(cons1) )
1545 {
1546 SCIP_CALL( SCIPsetConsChecked(scip, cons0, TRUE) );
1547 }
1548 if( SCIPconsIsPropagated(cons1) )
1549 {
1550 SCIP_CALL( SCIPsetConsPropagated(scip, cons0, TRUE) );
1551 }
1552 if( !SCIPconsIsDynamic(cons1) )
1553 {
1554 SCIP_CALL( SCIPsetConsDynamic(scip, cons0, FALSE) );
1555 }
1556 if( !SCIPconsIsRemovable(cons1) )
1557 {
1558 SCIP_CALL( SCIPsetConsRemovable(scip, cons0, FALSE) );
1559 }
1560 if( SCIPconsIsStickingAtNode(cons1) )
1561 {
1562 SCIP_CALL( SCIPsetConsStickingAtNode(scip, cons0, TRUE) );
1563 }
1564
1565 return SCIP_OKAY;
1566}
1567
1568/** gets and captures transformed constraint of a given constraint; if the constraint is not yet transformed,
1569 * a new transformed constraint for this constraint is created
1570 *
1571 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1572 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1573 *
1574 * @pre This method can be called if @p scip is in one of the following stages:
1575 * - \ref SCIP_STAGE_TRANSFORMING
1576 * - \ref SCIP_STAGE_TRANSFORMED
1577 * - \ref SCIP_STAGE_INITPRESOLVE
1578 * - \ref SCIP_STAGE_PRESOLVING
1579 * - \ref SCIP_STAGE_EXITPRESOLVE
1580 * - \ref SCIP_STAGE_PRESOLVED
1581 * - \ref SCIP_STAGE_INITSOLVE
1582 * - \ref SCIP_STAGE_SOLVING
1583 */
1584SCIP_RETCODE SCIPtransformCons(
1585 SCIP* scip, /**< SCIP data structure */
1586 SCIP_CONS* cons, /**< constraint to get/create transformed constraint for */
1587 SCIP_CONS** transcons /**< pointer to store the transformed constraint */
1588 )
1589{
1590 assert(transcons != NULL);
1591 assert(cons->scip == scip);
1592
1593 SCIP_CALL( SCIPcheckStage(scip, "SCIPtransformCons", FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1594
1595 if( SCIPconsIsTransformed(cons) )
1596 {
1597 *transcons = cons;
1598 SCIPconsCapture(*transcons);
1599 }
1600 else
1601 {
1602 SCIP_CALL( SCIPconsTransform(cons, scip->mem->probmem, scip->set, transcons) );
1603 }
1604
1605 return SCIP_OKAY;
1606}
1607
1608/** gets and captures transformed constraints for an array of constraints;
1609 * if a constraint in the array is not yet transformed, a new transformed constraint for this constraint is created;
1610 * it is possible to call this method with conss == transconss
1611 *
1612 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1613 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1614 *
1615 * @pre This method can be called if @p scip is in one of the following stages:
1616 * - \ref SCIP_STAGE_TRANSFORMING
1617 * - \ref SCIP_STAGE_TRANSFORMED
1618 * - \ref SCIP_STAGE_INITPRESOLVE
1619 * - \ref SCIP_STAGE_PRESOLVING
1620 * - \ref SCIP_STAGE_EXITPRESOLVE
1621 * - \ref SCIP_STAGE_PRESOLVED
1622 * - \ref SCIP_STAGE_INITSOLVE
1623 * - \ref SCIP_STAGE_SOLVING
1624 */
1625SCIP_RETCODE SCIPtransformConss(
1626 SCIP* scip, /**< SCIP data structure */
1627 int nconss, /**< number of constraints to get/create transformed constraints for */
1628 SCIP_CONS** conss, /**< array with constraints to get/create transformed constraints for */
1629 SCIP_CONS** transconss /**< array to store the transformed constraints */
1630 )
1631{
1632 int c;
1633
1634 assert(nconss == 0 || conss != NULL);
1635 assert(nconss == 0 || transconss != NULL);
1636
1637 SCIP_CALL( SCIPcheckStage(scip, "SCIPtransformConss", FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1638
1639 for( c = 0; c < nconss; ++c )
1640 {
1641 if( SCIPconsIsTransformed(conss[c]) )
1642 {
1643 transconss[c] = conss[c];
1644 SCIPconsCapture(transconss[c]);
1645 }
1646 else
1647 {
1648 SCIP_CALL( SCIPconsTransform(conss[c], scip->mem->probmem, scip->set, &transconss[c]) );
1649 }
1650 }
1651
1652 return SCIP_OKAY;
1653}
1654
1655/** gets corresponding transformed constraint of a given constraint;
1656 * returns NULL as transcons, if transformed constraint is not yet existing
1657 *
1658 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1659 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1660 *
1661 * @pre This method can be called if @p scip is in one of the following stages:
1662 * - \ref SCIP_STAGE_TRANSFORMING
1663 * - \ref SCIP_STAGE_TRANSFORMED
1664 * - \ref SCIP_STAGE_INITPRESOLVE
1665 * - \ref SCIP_STAGE_PRESOLVING
1666 * - \ref SCIP_STAGE_EXITPRESOLVE
1667 * - \ref SCIP_STAGE_PRESOLVED
1668 * - \ref SCIP_STAGE_INITSOLVE
1669 * - \ref SCIP_STAGE_SOLVING
1670 * - \ref SCIP_STAGE_SOLVED
1671 * - \ref SCIP_STAGE_EXITSOLVE
1672 * - \ref SCIP_STAGE_FREETRANS
1673 */
1674SCIP_RETCODE SCIPgetTransformedCons(
1675 SCIP* scip, /**< SCIP data structure */
1676 SCIP_CONS* cons, /**< constraint to get the transformed constraint for */
1677 SCIP_CONS** transcons /**< pointer to store the transformed constraint */
1678 )
1679{
1680 assert(transcons != NULL);
1681 assert(cons->scip == scip);
1682
1683 SCIP_CALL( SCIPcheckStage(scip, "SCIPgetTransformedCons", FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
1684
1685 if( SCIPconsIsTransformed(cons) )
1686 *transcons = cons;
1687 else
1688 *transcons = SCIPconsGetTransformed(cons);
1689
1690 return SCIP_OKAY;
1691}
1692
1693/** gets corresponding transformed constraints for an array of constraints;
1694 * stores NULL in a transconss slot, if the transformed constraint is not yet existing;
1695 * it is possible to call this method with conss == transconss, but remember that constraints that are not
1696 * yet transformed will be replaced with NULL
1697 *
1698 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1699 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1700 *
1701 * @pre This method can be called if @p scip is in one of the following stages:
1702 * - \ref SCIP_STAGE_TRANSFORMING
1703 * - \ref SCIP_STAGE_TRANSFORMED
1704 * - \ref SCIP_STAGE_INITPRESOLVE
1705 * - \ref SCIP_STAGE_PRESOLVING
1706 * - \ref SCIP_STAGE_EXITPRESOLVE
1707 * - \ref SCIP_STAGE_PRESOLVED
1708 * - \ref SCIP_STAGE_INITSOLVE
1709 * - \ref SCIP_STAGE_SOLVING
1710 * - \ref SCIP_STAGE_SOLVED
1711 * - \ref SCIP_STAGE_EXITSOLVE
1712 * - \ref SCIP_STAGE_FREETRANS
1713 */
1714SCIP_RETCODE SCIPgetTransformedConss(
1715 SCIP* scip, /**< SCIP data structure */
1716 int nconss, /**< number of constraints to get the transformed constraints for */
1717 SCIP_CONS** conss, /**< constraints to get the transformed constraints for */
1718 SCIP_CONS** transconss /**< array to store the transformed constraints */
1719 )
1720{
1721 int c;
1722
1723 assert(nconss == 0 || conss != NULL);
1724 assert(nconss == 0 || transconss != NULL);
1725
1726 SCIP_CALL( SCIPcheckStage(scip, "SCIPgetTransformedConss", FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
1727
1728 for( c = 0; c < nconss; ++c )
1729 {
1730 if( SCIPconsIsTransformed(conss[c]) )
1731 transconss[c] = conss[c];
1732 else
1733 transconss[c] = SCIPconsGetTransformed(conss[c]);
1734 }
1735
1736 return SCIP_OKAY;
1737}
1738
1739/** adds given value to age of constraint, but age can never become negative;
1740 * should be called
1741 * - in constraint separation, if no cut was found for this constraint,
1742 * - in constraint enforcing, if constraint was feasible, and
1743 * - in constraint propagation, if no domain reduction was deduced;
1744 *
1745 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1746 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1747 *
1748 * @pre This method can be called if @p scip is in one of the following stages:
1749 * - \ref SCIP_STAGE_TRANSFORMED
1750 * - \ref SCIP_STAGE_PRESOLVING
1751 * - \ref SCIP_STAGE_PRESOLVED
1752 * - \ref SCIP_STAGE_SOLVING
1753 * - \ref SCIP_STAGE_SOLVED
1754 */
1755SCIP_RETCODE SCIPaddConsAge(
1756 SCIP* scip, /**< SCIP data structure */
1757 SCIP_CONS* cons, /**< constraint */
1758 SCIP_Real deltaage /**< value to add to the constraint's age */
1759 )
1760{
1761 SCIP_CALL( SCIPcheckStage(scip, "SCIPaddConsAge", FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1762
1763 SCIP_CALL( SCIPconsAddAge(cons, scip->mem->probmem, scip->set, scip->stat, scip->transprob, deltaage, scip->reopt) );
1764
1765 return SCIP_OKAY;
1766}
1767
1768/** increases age of constraint by 1.0;
1769 * should be called
1770 * - in constraint separation, if no cut was found for this constraint,
1771 * - in constraint enforcing, if constraint was feasible, and
1772 * - in constraint propagation, if no domain reduction was deduced;
1773 *
1774 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1775 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1776 *
1777 * @pre This method can be called if @p scip is in one of the following stages:
1778 * - \ref SCIP_STAGE_TRANSFORMED
1779 * - \ref SCIP_STAGE_PRESOLVING
1780 * - \ref SCIP_STAGE_PRESOLVED
1781 * - \ref SCIP_STAGE_SOLVING
1782 * - \ref SCIP_STAGE_SOLVED
1783 */
1784SCIP_RETCODE SCIPincConsAge(
1785 SCIP* scip, /**< SCIP data structure */
1786 SCIP_CONS* cons /**< constraint */
1787 )
1788{
1789 SCIP_CALL( SCIPcheckStage(scip, "SCIPincConsAge", FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1790
1791 SCIP_CALL( SCIPconsIncAge(cons, scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->reopt) );
1792
1793 return SCIP_OKAY;
1794}
1795
1796/** resets age of constraint to zero;
1797 * should be called
1798 * - in constraint separation, if a cut was found for this constraint,
1799 * - in constraint enforcing, if the constraint was violated, and
1800 * - in constraint propagation, if a domain reduction was deduced;
1801 *
1802 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1803 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1804 *
1805 * @pre This method can be called if @p scip is in one of the following stages:
1806 * - \ref SCIP_STAGE_TRANSFORMED
1807 * - \ref SCIP_STAGE_PRESOLVING
1808 * - \ref SCIP_STAGE_PRESOLVED
1809 * - \ref SCIP_STAGE_SOLVING
1810 * - \ref SCIP_STAGE_SOLVED
1811 */
1812SCIP_RETCODE SCIPresetConsAge(
1813 SCIP* scip, /**< SCIP data structure */
1814 SCIP_CONS* cons /**< constraint */
1815 )
1816{
1817 SCIP_CALL( SCIPcheckStage(scip, "SCIPresetConsAge", FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1818
1819 SCIP_CALL( SCIPconsResetAge(cons, scip->set) );
1820
1821 return SCIP_OKAY;
1822}
1823
1824/** enables constraint's separation, propagation, and enforcing capabilities
1825 *
1826 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1827 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1828 *
1829 * @pre This method can be called if @p scip is in one of the following stages:
1830 * - \ref SCIP_STAGE_TRANSFORMED
1831 * - \ref SCIP_STAGE_PRESOLVING
1832 * - \ref SCIP_STAGE_PRESOLVED
1833 * - \ref SCIP_STAGE_INITSOLVE
1834 * - \ref SCIP_STAGE_SOLVING
1835 * - \ref SCIP_STAGE_SOLVED
1836 */
1837SCIP_RETCODE SCIPenableCons(
1838 SCIP* scip, /**< SCIP data structure */
1839 SCIP_CONS* cons /**< constraint */
1840 )
1841{
1842 SCIP_CALL( SCIPcheckStage(scip, "SCIPenableCons", FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1843
1844 SCIP_CALL( SCIPconsEnable(cons, scip->set, scip->stat) );
1845
1846 return SCIP_OKAY;
1847}
1848
1849/** disables constraint's separation, propagation, and enforcing capabilities, s.t. the constraint is not propagated,
1850 * separated, and enforced anymore until it is enabled again with a call to SCIPenableCons();
1851 * in contrast to SCIPdelConsLocal() and SCIPdelConsNode(), the disabling is not associated to a node in the tree and
1852 * does not consume memory; therefore, the constraint is neither automatically enabled on leaving the node nor
1853 * automatically disabled again on entering the node again;
1854 * note that the constraints enforcing capabilities are necessary for the solution's feasibility, if the constraint
1855 * is a model constraint; that means, you must be sure that the constraint cannot be violated in the current subtree,
1856 * and you have to enable it again manually by calling SCIPenableCons(), if this subtree is left (e.g. by using
1857 * an appropriate event handler that watches the corresponding variables' domain changes)
1858 *
1859 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1860 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1861 *
1862 * @pre This method can be called if @p scip is in one of the following stages:
1863 * - \ref SCIP_STAGE_TRANSFORMED
1864 * - \ref SCIP_STAGE_INITPRESOLVE
1865 * - \ref SCIP_STAGE_PRESOLVING
1866 * - \ref SCIP_STAGE_PRESOLVED
1867 * - \ref SCIP_STAGE_INITSOLVE
1868 * - \ref SCIP_STAGE_SOLVING
1869 * - \ref SCIP_STAGE_SOLVED
1870 */
1871SCIP_RETCODE SCIPdisableCons(
1872 SCIP* scip, /**< SCIP data structure */
1873 SCIP_CONS* cons /**< constraint */
1874 )
1875{
1876 SCIP_CALL( SCIPcheckStage(scip, "SCIPdisableCons", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1877
1878 SCIP_CALL( SCIPconsDisable(cons, scip->set, scip->stat) );
1879
1880 return SCIP_OKAY;
1881}
1882
1883/** enables constraint's separation capabilities
1884 *
1885 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1886 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1887 *
1888 * @pre This method can be called if @p scip is in one of the following stages:
1889 * - \ref SCIP_STAGE_TRANSFORMED
1890 * - \ref SCIP_STAGE_PRESOLVING
1891 * - \ref SCIP_STAGE_PRESOLVED
1892 * - \ref SCIP_STAGE_INITSOLVE
1893 * - \ref SCIP_STAGE_SOLVING
1894 * - \ref SCIP_STAGE_SOLVED
1895 */
1896SCIP_RETCODE SCIPenableConsSeparation(
1897 SCIP* scip, /**< SCIP data structure */
1898 SCIP_CONS* cons /**< constraint */
1899 )
1900{
1901 SCIP_CALL( SCIPcheckStage(scip, "SCIPenableConsSeparation", FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1902
1903 SCIP_CALL( SCIPconsEnableSeparation(cons, scip->set) );
1904
1905 return SCIP_OKAY;
1906}
1907
1908/** disables constraint's separation capabilities s.t. the constraint is not separated anymore until the separation
1909 * is enabled again with a call to SCIPenableConsSeparation(); in contrast to SCIPdelConsLocal() and SCIPdelConsNode(),
1910 * the disabling is not associated to a node in the tree and does not consume memory; therefore, the constraint
1911 * is neither automatically enabled on leaving the node nor automatically disabled again on entering the node again
1912 *
1913 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1914 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1915 *
1916 * @pre This method can be called if @p scip is in one of the following stages:
1917 * - \ref SCIP_STAGE_TRANSFORMED
1918 * - \ref SCIP_STAGE_PRESOLVING
1919 * - \ref SCIP_STAGE_PRESOLVED
1920 * - \ref SCIP_STAGE_INITSOLVE
1921 * - \ref SCIP_STAGE_SOLVING
1922 * - \ref SCIP_STAGE_SOLVED
1923 */
1924SCIP_RETCODE SCIPdisableConsSeparation(
1925 SCIP* scip, /**< SCIP data structure */
1926 SCIP_CONS* cons /**< constraint */
1927 )
1928{
1929 SCIP_CALL( SCIPcheckStage(scip, "SCIPdisableConsSeparation", FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1930
1931 SCIP_CALL( SCIPconsDisableSeparation(cons, scip->set) );
1932
1933 return SCIP_OKAY;
1934}
1935
1936/** enables constraint's propagation capabilities
1937 *
1938 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1939 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1940 *
1941 * @pre This method can be called if @p scip is in one of the following stages:
1942 * - \ref SCIP_STAGE_TRANSFORMED
1943 * - \ref SCIP_STAGE_INITPRESOLVE
1944 * - \ref SCIP_STAGE_PRESOLVING
1945 * - \ref SCIP_STAGE_EXITPRESOLVE
1946 * - \ref SCIP_STAGE_PRESOLVED
1947 * - \ref SCIP_STAGE_INITSOLVE
1948 * - \ref SCIP_STAGE_SOLVING
1949 * - \ref SCIP_STAGE_SOLVED
1950 */
1951SCIP_RETCODE SCIPenableConsPropagation(
1952 SCIP* scip, /**< SCIP data structure */
1953 SCIP_CONS* cons /**< constraint */
1954 )
1955{
1956 SCIP_CALL( SCIPcheckStage(scip, "SCIPenableConsPropagation", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1957
1958 SCIP_CALL( SCIPconsEnablePropagation(cons, scip->set) );
1959
1960 return SCIP_OKAY;
1961}
1962
1963/** disables constraint's propagation capabilities s.t. the constraint is not propagated anymore until the propagation
1964 * is enabled again with a call to SCIPenableConsPropagation(); in contrast to SCIPdelConsLocal() and SCIPdelConsNode(),
1965 * the disabling is not associated to a node in the tree and does not consume memory; therefore, the constraint
1966 * is neither automatically enabled on leaving the node nor automatically disabled again on entering the node again
1967 *
1968 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1969 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1970 *
1971 * @pre This method can be called if @p scip is in one of the following stages:
1972 * - \ref SCIP_STAGE_TRANSFORMED
1973 * - \ref SCIP_STAGE_INITPRESOLVE
1974 * - \ref SCIP_STAGE_PRESOLVING
1975 * - \ref SCIP_STAGE_EXITPRESOLVE
1976 * - \ref SCIP_STAGE_PRESOLVED
1977 * - \ref SCIP_STAGE_INITSOLVE
1978 * - \ref SCIP_STAGE_SOLVING
1979 * - \ref SCIP_STAGE_SOLVED
1980 */
1981SCIP_RETCODE SCIPdisableConsPropagation(
1982 SCIP* scip, /**< SCIP data structure */
1983 SCIP_CONS* cons /**< constraint */
1984 )
1985{
1986 SCIP_CALL( SCIPcheckStage(scip, "SCIPdisableConsPropagation", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1987
1988 SCIP_CALL( SCIPconsDisablePropagation(cons, scip->set) );
1989
1990 return SCIP_OKAY;
1991}
1992
1993#undef SCIPmarkConsPropagate
1994
1995/** marks constraint to be propagated
1996 *
1997 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1998 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1999 *
2000 * @pre This method can be called if @p scip is in one of the following stages:
2001 * - \ref SCIP_STAGE_TRANSFORMING
2002 * - \ref SCIP_STAGE_TRANSFORMED
2003 * - \ref SCIP_STAGE_INITPRESOLVE
2004 * - \ref SCIP_STAGE_PRESOLVING
2005 * - \ref SCIP_STAGE_EXITPRESOLVE
2006 * - \ref SCIP_STAGE_PRESOLVED
2007 * - \ref SCIP_STAGE_INITSOLVE
2008 * - \ref SCIP_STAGE_SOLVING
2009 * - \ref SCIP_STAGE_SOLVED
2010 * - \ref SCIP_STAGE_EXITSOLVE
2011 *
2012 * @note if a constraint is marked to be propagated, the age of the constraint will be ignored for propagation
2013 */
2014SCIP_RETCODE SCIPmarkConsPropagate(
2015 SCIP* scip, /**< SCIP data structure */
2016 SCIP_CONS* cons /**< constraint */
2017 )
2018{
2019 SCIP_CALL( SCIPcheckStage(scip, "SCIPmarkConsPropagate", FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
2020
2021 SCIP_CALL( SCIPconsMarkPropagate(cons, scip->set) );
2022
2023 assert(!SCIPconsIsEnabled(cons) || SCIPconsIsMarkedPropagate(cons));
2024
2025 return SCIP_OKAY;
2026}
2027
2028/** unmarks the constraint to be propagated
2029 *
2030 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2031 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2032 *
2033 * @pre This method can be called if @p scip is in one of the following stages:
2034 * - \ref SCIP_STAGE_TRANSFORMED
2035 * - \ref SCIP_STAGE_PRESOLVING
2036 * - \ref SCIP_STAGE_EXITPRESOLVE
2037 * - \ref SCIP_STAGE_PRESOLVED
2038 * - \ref SCIP_STAGE_INITSOLVE
2039 * - \ref SCIP_STAGE_SOLVING
2040 * - \ref SCIP_STAGE_SOLVED
2041 */
2042SCIP_RETCODE SCIPunmarkConsPropagate(
2043 SCIP* scip, /**< SCIP data structure */
2044 SCIP_CONS* cons /**< constraint */
2045 )
2046{
2047 SCIP_CALL( SCIPcheckStage(scip, "SCIPunmarkConsPropagate", FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2048
2049 SCIP_CALL( SCIPconsUnmarkPropagate(cons, scip->set) );
2050
2051 assert(!SCIPconsIsEnabled(cons) || !SCIPconsIsMarkedPropagate(cons));
2052
2053 return SCIP_OKAY;
2054}
2055
2056/** adds given values to lock status of type @p locktype of the constraint and updates the rounding locks of the involved variables
2057 *
2058 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2059 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2060 *
2061 * @pre This method can be called if @p scip is in one of the following stages:
2062 * - \ref SCIP_STAGE_PROBLEM
2063 * - \ref SCIP_STAGE_TRANSFORMING
2064 * - \ref SCIP_STAGE_INITPRESOLVE
2065 * - \ref SCIP_STAGE_PRESOLVING
2066 * - \ref SCIP_STAGE_EXITPRESOLVE
2067 * - \ref SCIP_STAGE_INITSOLVE
2068 * - \ref SCIP_STAGE_SOLVING
2069 * - \ref SCIP_STAGE_EXITSOLVE
2070 * - \ref SCIP_STAGE_FREETRANS
2071 */
2072SCIP_RETCODE SCIPaddConsLocksType(
2073 SCIP* scip, /**< SCIP data structure */
2074 SCIP_CONS* cons, /**< constraint */
2075 SCIP_LOCKTYPE locktype, /**< type of the variable locks */
2076 int nlockspos, /**< increase in number of rounding locks for constraint */
2077 int nlocksneg /**< increase in number of rounding locks for constraint's negation */
2078 )
2079{
2080 SCIP_CALL( SCIPcheckStage(scip, "SCIPaddConsLocksType", FALSE, TRUE, TRUE, FALSE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE) );
2081
2082 SCIP_CALL( SCIPconsAddLocks(cons, scip->set, locktype, nlockspos, nlocksneg) );
2083
2084 return SCIP_OKAY;
2085}
2086
2087/** adds given values to lock status of the constraint and updates the rounding locks of the involved variables
2088 *
2089 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2090 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2091 *
2092 * @pre This method can be called if @p scip is in one of the following stages:
2093 * - \ref SCIP_STAGE_PROBLEM
2094 * - \ref SCIP_STAGE_TRANSFORMING
2095 * - \ref SCIP_STAGE_INITPRESOLVE
2096 * - \ref SCIP_STAGE_PRESOLVING
2097 * - \ref SCIP_STAGE_EXITPRESOLVE
2098 * - \ref SCIP_STAGE_INITSOLVE
2099 * - \ref SCIP_STAGE_SOLVING
2100 * - \ref SCIP_STAGE_EXITSOLVE
2101 * - \ref SCIP_STAGE_FREETRANS
2102 *
2103 * @note This methods always adds locks of type model
2104 */
2105SCIP_RETCODE SCIPaddConsLocks(
2106 SCIP* scip, /**< SCIP data structure */
2107 SCIP_CONS* cons, /**< constraint */
2108 int nlockspos, /**< increase in number of rounding locks for constraint */
2109 int nlocksneg /**< increase in number of rounding locks for constraint's negation */
2110 )
2111{
2112 SCIP_CALL( SCIPcheckStage(scip, "SCIPaddConsLocks", FALSE, TRUE, TRUE, FALSE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE) );
2113
2114 SCIP_CALL( SCIPaddConsLocksType(scip, cons, SCIP_LOCKTYPE_MODEL, nlockspos, nlocksneg) );
2115
2116 return SCIP_OKAY;
2117}
2118
2119/** checks single constraint for feasibility of the given solution
2120 *
2121 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2122 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2123 *
2124 * @pre This method can be called if @p scip is in one of the following stages:
2125 * - \ref SCIP_STAGE_PROBLEM
2126 * - \ref SCIP_STAGE_TRANSFORMED
2127 * - \ref SCIP_STAGE_INITPRESOLVE
2128 * - \ref SCIP_STAGE_PRESOLVING
2129 * - \ref SCIP_STAGE_EXITPRESOLVE
2130 * - \ref SCIP_STAGE_PRESOLVED
2131 * - \ref SCIP_STAGE_INITSOLVE
2132 * - \ref SCIP_STAGE_SOLVING
2133 * - \ref SCIP_STAGE_SOLVED
2134 */
2135SCIP_RETCODE SCIPcheckCons(
2136 SCIP* scip, /**< SCIP data structure */
2137 SCIP_CONS* cons, /**< constraint to check */
2138 SCIP_SOL* sol, /**< primal CIP solution */
2139 SCIP_Bool checkintegrality, /**< Has integrality to be checked? */
2140 SCIP_Bool checklprows, /**< Do constraints represented by rows in the current LP have to be checked? */
2141 SCIP_Bool printreason, /**< Should the reason for the violation be printed? */
2142 SCIP_RESULT* result /**< pointer to store the result of the callback method */
2143 )
2144{
2145 SCIP_CALL( SCIPcheckStage(scip, "SCIPcheckCons", FALSE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2146
2147 SCIP_CALL( SCIPconsCheck(cons, scip->set, sol, checkintegrality, checklprows, printreason, result) );
2148
2149 return SCIP_OKAY;
2150}
2151
2152/** enforces single constraint for a given pseudo solution
2153 *
2154 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2155 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2156 *
2157 * @pre This method can be called if @p scip is in one of the following stages:
2158 * - \ref SCIP_STAGE_SOLVING
2159 *
2160 * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
2161 * added to SCIP beforehand.
2162 */
2163SCIP_RETCODE SCIPenfopsCons(
2164 SCIP* scip, /**< SCIP data structure */
2165 SCIP_CONS* cons, /**< constraint to enforce */
2166 SCIP_Bool solinfeasible, /**< was the solution already declared infeasible by a constraint handler? */
2167 SCIP_Bool objinfeasible, /**< is the solution infeasible anyway due to violating lower objective bound? */
2168 SCIP_RESULT* result /**< pointer to store the result of the callback method */
2169 )
2170{
2171 assert(scip != NULL);
2172 assert(cons != NULL);
2173 assert(!SCIPconsIsAdded(cons));
2174 assert(result != NULL);
2175
2176 SCIP_CALL( SCIPcheckStage(scip, "SCIPenfopsCons", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2177
2178 SCIP_CALL( SCIPconsEnfops(cons, scip->set, solinfeasible, objinfeasible, result) );
2179
2180 return SCIP_OKAY;
2181}
2182
2183/** enforces single constraint for a given LP solution
2184 *
2185 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2186 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2187 *
2188 * @pre This method can be called if @p scip is in one of the following stages:
2189 * - \ref SCIP_STAGE_SOLVING
2190 *
2191 * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
2192 * added to SCIP beforehand.
2193 */
2194SCIP_RETCODE SCIPenfolpCons(
2195 SCIP* scip, /**< SCIP data structure */
2196 SCIP_CONS* cons, /**< constraint to enforce */
2197 SCIP_Bool solinfeasible, /**< was the solution already declared infeasible by a constraint handler? */
2198 SCIP_RESULT* result /**< pointer to store the result of the callback method */
2199 )
2200{
2201 assert(scip != NULL);
2202 assert(cons != NULL);
2203 assert(!SCIPconsIsAdded(cons));
2204 assert(result != NULL);
2205
2206 SCIP_CALL( SCIPcheckStage(scip, "SCIPenfolpCons", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2207
2208 SCIP_CALL( SCIPconsEnfolp(cons, scip->set, solinfeasible, result) );
2209
2210 return SCIP_OKAY;
2211}
2212
2213/** enforces single constraint for a given relaxation solution
2214 *
2215 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2216 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2217 *
2218 * @pre This method can be called if @p scip is in one of the following stages:
2219 * - \ref SCIP_STAGE_SOLVING
2220 *
2221 * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
2222 * added to SCIP beforehand.
2223 */
2224SCIP_RETCODE SCIPenforelaxCons(
2225 SCIP* scip, /**< SCIP data structure */
2226 SCIP_CONS* cons, /**< constraint to enforce */
2227 SCIP_SOL* sol, /**< solution to enforce */
2228 SCIP_Bool solinfeasible, /**< was the solution already declared infeasible by a constraint handler? */
2229 SCIP_RESULT* result /**< pointer to store the result of the callback method */
2230 )
2231{
2232 assert(scip != NULL);
2233 assert(cons != NULL);
2234 assert(!SCIPconsIsAdded(cons));
2235 assert(sol != NULL);
2236 assert(result != NULL);
2237
2238 SCIP_CALL( SCIPcheckStage(scip, "SCIPenforelaxCons", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2239
2240 SCIP_CALL( SCIPconsEnforelax(cons, scip->set, sol, solinfeasible, result) );
2241
2242 return SCIP_OKAY;
2243}
2244
2245/** calls LP initialization method for single constraint
2246 *
2247 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2248 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2249 *
2250 * @pre This method can be called if @p scip is in one of the following stages:
2251 * - \ref SCIP_STAGE_SOLVING
2252 *
2253 * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
2254 * added to SCIP beforehand.
2255 */
2256SCIP_RETCODE SCIPinitlpCons(
2257 SCIP* scip, /**< SCIP data structure */
2258 SCIP_CONS* cons, /**< constraint to initialize */
2259 SCIP_Bool* infeasible /**< pointer to store whether infeasibility was detected while building the LP */
2260 )
2261{
2262 assert(scip != NULL);
2263 assert(cons != NULL);
2264 assert(!SCIPconsIsAdded(cons));
2265
2266 SCIP_CALL( SCIPcheckStage(scip, "SCIPinitlpCons", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2267
2268 SCIP_CALL( SCIPconsInitlp(cons, scip->set, infeasible) );
2269
2270 return SCIP_OKAY;
2271}
2272
2273/** calls separation method of single constraint for LP solution
2274 *
2275 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2276 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2277 *
2278 * @pre This method can be called if @p scip is in one of the following stages:
2279 * - \ref SCIP_STAGE_SOLVING
2280 *
2281 * @note This is an advanced method and should be used with caution.
2282 */
2283SCIP_RETCODE SCIPsepalpCons(
2284 SCIP* scip, /**< SCIP data structure */
2285 SCIP_CONS* cons, /**< constraint to separate */
2286 SCIP_RESULT* result /**< pointer to store the result of the separation call */
2287 )
2288{
2289 assert(scip != NULL);
2290 assert(cons != NULL);
2291 assert(result != NULL);
2292
2293 SCIP_CALL( SCIPcheckStage(scip, "SCIPsepalpCons", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2294
2295 SCIP_CALL( SCIPconsSepalp(cons, scip->set, result) );
2296
2297 return SCIP_OKAY;
2298}
2299
2300/** calls separation method of single constraint for given primal solution
2301 *
2302 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2303 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2304 *
2305 * @pre This method can be called if @p scip is in one of the following stages:
2306 * - \ref SCIP_STAGE_SOLVING
2307 *
2308 * @note This is an advanced method and should be used with caution.
2309 */
2310SCIP_RETCODE SCIPsepasolCons(
2311 SCIP* scip, /**< SCIP data structure */
2312 SCIP_CONS* cons, /**< constraint to separate */
2313 SCIP_SOL* sol, /**< primal solution that should be separated*/
2314 SCIP_RESULT* result /**< pointer to store the result of the separation call */
2315 )
2316{
2317 assert(scip != NULL);
2318 assert(cons != NULL);
2319 assert(sol != NULL);
2320 assert(result != NULL);
2321
2322 SCIP_CALL( SCIPcheckStage(scip, "SCIPsepasolCons", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2323
2324 SCIP_CALL( SCIPconsSepasol(cons, scip->set, sol, result) );
2325
2326 return SCIP_OKAY;
2327}
2328
2329/** calls domain propagation method of single constraint
2330 *
2331 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2332 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2333 *
2334 * @pre This method can be called if @p scip is in one of the following stages:
2335 * - \ref SCIP_STAGE_PRESOLVING
2336 * - \ref SCIP_STAGE_SOLVING
2337 *
2338 * @note This is an advanced method and should be used with caution.
2339 */
2340SCIP_RETCODE SCIPpropCons(
2341 SCIP* scip, /**< SCIP data structure */
2342 SCIP_CONS* cons, /**< constraint to propagate */
2343 SCIP_PROPTIMING proptiming, /**< current point in the node solving loop */
2344 SCIP_RESULT* result /**< pointer to store the result of the callback method */
2345 )
2346{
2347 assert(scip != NULL);
2348 assert(cons != NULL);
2349 assert(result != NULL);
2350
2351 SCIP_CALL( SCIPcheckStage(scip, "SCIPpropCons", FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2352
2353 SCIP_CALL( SCIPconsProp(cons, scip->set, proptiming, result) );
2354
2355 return SCIP_OKAY;
2356}
2357
2358/** resolves propagation conflict of single constraint
2359 *
2360 *
2361 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2362 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2363 *
2364 * @pre This method can be called if @p scip is in one of the following stages:
2365 * - \ref SCIP_STAGE_PRESOLVING
2366 * - \ref SCIP_STAGE_SOLVING
2367 *
2368 * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
2369 * added to SCIP beforehand.
2370 */
2371SCIP_RETCODE SCIPrespropCons(
2372 SCIP* scip, /**< SCIP data structure */
2373 SCIP_CONS* cons, /**< constraint to resolve conflict for */
2374 SCIP_VAR* infervar, /**< the conflict variable whose bound change has to be resolved */
2375 int inferinfo, /**< the user information passed to the corresponding SCIPinferVarLbCons() or SCIPinferVarUbCons() call */
2376 SCIP_BOUNDTYPE boundtype, /**< the type of the changed bound (lower or upper bound) */
2377 SCIP_BDCHGIDX* bdchgidx, /**< the index of the bound change, representing the point of time where the change took place */
2378 SCIP_Real relaxedbd, /**< the relaxed bound which is sufficient to be explained */
2379 SCIP_RESULT* result /**< pointer to store the result of the callback method */
2380 )
2381{
2382 assert(scip != NULL);
2383 assert(cons != NULL);
2384 assert(!SCIPconsIsAdded(cons));
2385 assert(infervar != NULL);
2386 assert(bdchgidx != NULL);
2387 assert(result != NULL);
2388
2389 SCIP_CALL( SCIPcheckStage(scip, "SCIPrespropCons", FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2390
2391 SCIP_CALL( SCIPconsResprop(cons, scip->set, infervar, inferinfo, boundtype, bdchgidx, relaxedbd, result) );
2392
2393 return SCIP_OKAY;
2394}
2395
2396/** presolves of single constraint
2397 *
2398 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2399 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2400 *
2401 * @pre This method can be called if @p scip is in one of the following stages:
2402 * - \ref SCIP_STAGE_PRESOLVING
2403 *
2404 * @note This is an advanced method and should be used with caution.
2405 */
2406SCIP_RETCODE SCIPpresolCons(
2407 SCIP* scip, /**< SCIP data structure */
2408 SCIP_CONS* cons, /**< constraint to presolve */
2409 int nrounds, /**< number of presolving rounds already done */
2410 SCIP_PRESOLTIMING presoltiming, /**< presolving timing(s) to be performed */
2411 int nnewfixedvars, /**< number of variables fixed since the last call to the presolving method */
2412 int nnewaggrvars, /**< number of variables aggregated since the last call to the presolving method */
2413 int nnewchgvartypes, /**< number of variable type changes since the last call to the presolving method */
2414 int nnewchgbds, /**< number of variable bounds tightened since the last call to the presolving method */
2415 int nnewholes, /**< number of domain holes added since the last call to the presolving method */
2416 int nnewdelconss, /**< number of deleted constraints since the last call to the presolving method */
2417 int nnewaddconss, /**< number of added constraints since the last call to the presolving method */
2418 int nnewupgdconss, /**< number of upgraded constraints since the last call to the presolving method */
2419 int nnewchgcoefs, /**< number of changed coefficients since the last call to the presolving method */
2420 int nnewchgsides, /**< number of changed left or right hand sides since the last call to the presolving method */
2421 int* nfixedvars, /**< pointer to count total number of variables fixed of all presolvers */
2422 int* naggrvars, /**< pointer to count total number of variables aggregated of all presolvers */
2423 int* nchgvartypes, /**< pointer to count total number of variable type changes of all presolvers */
2424 int* nchgbds, /**< pointer to count total number of variable bounds tightened of all presolvers */
2425 int* naddholes, /**< pointer to count total number of domain holes added of all presolvers */
2426 int* ndelconss, /**< pointer to count total number of deleted constraints of all presolvers */
2427 int* naddconss, /**< pointer to count total number of added constraints of all presolvers */
2428 int* nupgdconss, /**< pointer to count total number of upgraded constraints of all presolvers */
2429 int* nchgcoefs, /**< pointer to count total number of changed coefficients of all presolvers */
2430 int* nchgsides, /**< pointer to count total number of changed left/right hand sides of all presolvers */
2431 SCIP_RESULT* result /**< pointer to store the result of the callback method */
2432 )
2433{
2434 assert(scip != NULL);
2435 assert(cons != NULL);
2436 assert(nfixedvars != NULL);
2437 assert(naggrvars != NULL);
2438 assert(nchgvartypes != NULL);
2439 assert(nchgbds != NULL);
2440 assert(naddholes != NULL);
2441 assert(ndelconss != NULL);
2442 assert(naddconss != NULL);
2443 assert(nupgdconss != NULL);
2444 assert(nchgcoefs != NULL);
2445 assert(nchgsides != NULL);
2446 assert(result != NULL);
2447
2448 SCIP_CALL( SCIPcheckStage(scip, "SCIPpresolCons", FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
2449
2450 SCIP_CALL( SCIPconsPresol(cons, scip->set, nrounds, presoltiming, nnewfixedvars, nnewaggrvars, nnewchgvartypes, nnewchgbds, nnewholes,
2451 nnewdelconss, nnewaddconss, nnewupgdconss, nnewchgcoefs, nnewchgsides, nfixedvars, naggrvars, nchgvartypes,
2452 nchgbds, naddholes, ndelconss, naddconss, nupgdconss, nchgcoefs, nchgsides , result) );
2453
2454 return SCIP_OKAY;
2455}
2456
2457/** calls constraint activation notification method of single constraint
2458 *
2459 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2460 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2461 *
2462 * @pre This method can be called if @p scip is in one of the following stages:
2463 * - \ref SCIP_STAGE_TRANSFORMING
2464 *
2465 * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
2466 * added to SCIP beforehand.
2467 */
2468SCIP_RETCODE SCIPactiveCons(
2469 SCIP* scip, /**< SCIP data structure */
2470 SCIP_CONS* cons /**< constraint to notify */
2471 )
2472{
2473 assert(scip != NULL);
2474 assert(cons != NULL);
2475 assert(!SCIPconsIsAdded(cons));
2476 assert(!SCIPconsIsDeleted(cons));
2477
2478 SCIP_CALL( SCIPcheckStage(scip, "SCIPactiveCons", FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
2479
2480 SCIP_CALL( SCIPconsActive(cons, scip->set) );
2481
2482 return SCIP_OKAY;
2483}
2484
2485/** calls constraint deactivation notification method of single constraint
2486 *
2487 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2488 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2489 *
2490 * @pre This method can be called if @p scip is in one of the following stages:
2491 * - \ref SCIP_STAGE_PRESOLVING
2492 * - \ref SCIP_STAGE_SOLVING
2493 *
2494 * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
2495 * added to SCIP beforehand.
2496 */
2497SCIP_RETCODE SCIPdeactiveCons(
2498 SCIP* scip, /**< SCIP data structure */
2499 SCIP_CONS* cons /**< constraint to notify */
2500 )
2501{
2502 assert(scip != NULL);
2503 assert(cons != NULL);
2504 assert(!SCIPconsIsAdded(cons));
2505
2506 SCIP_CALL( SCIPcheckStage(scip, "SCIPdeactiveCons", FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2507
2508 SCIP_CALL( SCIPconsDeactive(cons, scip->set) );
2509
2510 return SCIP_OKAY;
2511}
2512
2513/** outputs constraint information to file stream via the message handler system
2514 *
2515 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2516 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2517 *
2518 * @pre This method can be called if @p scip is in one of the following stages:
2519 * - \ref SCIP_STAGE_PROBLEM
2520 * - \ref SCIP_STAGE_TRANSFORMING
2521 * - \ref SCIP_STAGE_TRANSFORMED
2522 * - \ref SCIP_STAGE_INITPRESOLVE
2523 * - \ref SCIP_STAGE_PRESOLVING
2524 * - \ref SCIP_STAGE_EXITPRESOLVE
2525 * - \ref SCIP_STAGE_PRESOLVED
2526 * - \ref SCIP_STAGE_INITSOLVE
2527 * - \ref SCIP_STAGE_SOLVING
2528 * - \ref SCIP_STAGE_SOLVED
2529 * - \ref SCIP_STAGE_EXITSOLVE
2530 * - \ref SCIP_STAGE_FREETRANS
2531 *
2532 * @note If the message handler is set to a NULL pointer nothing will be printed.
2533 * @note The file stream will not be flushed directly, this can be achieved by calling SCIPinfoMessage() printing a
2534 * newline character.
2535 */
2536SCIP_RETCODE SCIPprintCons(
2537 SCIP* scip, /**< SCIP data structure */
2538 SCIP_CONS* cons, /**< constraint */
2539 FILE* file /**< output file (or NULL for standard output) */
2540 )
2541{
2542 SCIP_CALL( SCIPcheckStage(scip, "SCIPprintCons", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
2543
2544 SCIP_CALL( SCIPconsPrint(cons, scip->set, scip->messagehdlr, file) );
2545
2546 return SCIP_OKAY;
2547}
2548
2549/** method to collect the variables of a constraint
2550 *
2551 * If the number of variables is greater than the available slots in the variable array, nothing happens except that
2552 * the success point is set to FALSE. With the method SCIPgetConsNVars() it is possible to get the number of variables
2553 * a constraint has in its scope.
2554 *
2555 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2556 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2557 *
2558 * @pre This method can be called if @p scip is in one of the following stages:
2559 * - \ref SCIP_STAGE_PROBLEM
2560 * - \ref SCIP_STAGE_TRANSFORMING
2561 * - \ref SCIP_STAGE_TRANSFORMED
2562 * - \ref SCIP_STAGE_INITPRESOLVE
2563 * - \ref SCIP_STAGE_PRESOLVING
2564 * - \ref SCIP_STAGE_EXITPRESOLVE
2565 * - \ref SCIP_STAGE_PRESOLVED
2566 * - \ref SCIP_STAGE_INITSOLVE
2567 * - \ref SCIP_STAGE_SOLVING
2568 * - \ref SCIP_STAGE_SOLVED
2569 * - \ref SCIP_STAGE_EXITSOLVE
2570 * - \ref SCIP_STAGE_FREETRANS
2571 *
2572 * @note The success pointer indicates if all variables were copied into the vars arrray.
2573 *
2574 * @note It might be that a constraint handler does not support this functionality, in that case the success pointer is
2575 * set to FALSE.
2576 */
2577SCIP_RETCODE SCIPgetConsVars(
2578 SCIP* scip, /**< SCIP data structure */
2579 SCIP_CONS* cons, /**< constraint for which the variables are wanted */
2580 SCIP_VAR** vars, /**< array to store the involved variable of the constraint */
2581 int varssize, /**< available slots in vars array which is needed to check if the array is large enough */
2582 SCIP_Bool* success /**< pointer to store whether the variables are successfully copied */
2583 )
2584{
2585 SCIP_CALL( SCIPcheckStage(scip, "SCIPgetConsVars", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
2586
2587 assert(scip != NULL);
2588 assert(cons != NULL);
2589 assert(vars != NULL);
2590 assert(success != NULL);
2591
2592 SCIP_CALL( SCIPconsGetVars(cons, scip->set, vars, varssize, success) );
2593
2594 return SCIP_OKAY;
2595}
2596
2597/** method to collect the number of variables of a constraint
2598 *
2599 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2600 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2601 *
2602 * @pre This method can be called if @p scip is in one of the following stages:
2603 * - \ref SCIP_STAGE_PROBLEM
2604 * - \ref SCIP_STAGE_TRANSFORMING
2605 * - \ref SCIP_STAGE_TRANSFORMED
2606 * - \ref SCIP_STAGE_INITPRESOLVE
2607 * - \ref SCIP_STAGE_PRESOLVING
2608 * - \ref SCIP_STAGE_EXITPRESOLVE
2609 * - \ref SCIP_STAGE_PRESOLVED
2610 * - \ref SCIP_STAGE_INITSOLVE
2611 * - \ref SCIP_STAGE_SOLVING
2612 * - \ref SCIP_STAGE_SOLVED
2613 * - \ref SCIP_STAGE_EXITSOLVE
2614 * - \ref SCIP_STAGE_FREETRANS
2615 *
2616 * @note The success pointer indicates if the contraint handler was able to return the number of variables
2617 *
2618 * @note It might be that a constraint handler does not support this functionality, in that case the success pointer is
2619 * set to FALSE
2620 */
2621SCIP_RETCODE SCIPgetConsNVars(
2622 SCIP* scip, /**< SCIP data structure */
2623 SCIP_CONS* cons, /**< constraint for which the number of variables is wanted */
2624 int* nvars, /**< pointer to store the number of variables */
2625 SCIP_Bool* success /**< pointer to store whether the constraint successfully returned the number of variables */
2626 )
2627{
2628 SCIP_CALL( SCIPcheckStage(scip, "SCIPgetConsNVars", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
2629
2630 assert(scip != NULL);
2631 assert(cons != NULL);
2632 assert(nvars != NULL);
2633 assert(success != NULL);
2634
2635 SCIP_CALL( SCIPconsGetNVars(cons, scip->set, nvars, success) );
2636
2637 return SCIP_OKAY;
2638}
2639
2640/** method to get the permutation symmetry detection graph of a constraint
2641 *
2642 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2643 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2644 *
2645 * @pre This method can be called if SCIP is in one of the following stages:
2646 * - \ref SCIP_STAGE_TRANSFORMED
2647 * - \ref SCIP_STAGE_INITPRESOLVE
2648 * - \ref SCIP_STAGE_PRESOLVING
2649 * - \ref SCIP_STAGE_EXITPRESOLVE
2650 * - \ref SCIP_STAGE_PRESOLVED
2651 * - \ref SCIP_STAGE_INITSOLVE
2652 * - \ref SCIP_STAGE_SOLVING
2653 */
2654SCIP_RETCODE SCIPgetConsPermsymGraph(
2655 SCIP* scip, /**< SCIP data structure */
2656 SCIP_CONS* cons, /**< constraint for which the symmetry graph is requested */
2657 SYM_GRAPH* graph, /**< symmetry detection graph */
2658 SCIP_Bool* success /**< pointer to store whether the constraint successfully returned the graph */
2659 )
2660{
2661 SCIP_CALL( SCIPcheckStage(scip, "SCIPgetConsGetPermsymGraph", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2662
2663 assert(scip != NULL);
2664 assert(cons != NULL);
2665 assert(graph != NULL);
2666 assert(success != NULL);
2667
2668 SCIP_CALL( SCIPconsGetPermsymGraph(cons, scip->set, graph, success) );
2669
2670 return SCIP_OKAY;
2671}
2672
2673/** method to get the signed permutation symmetry detection graph of a constraint
2674 *
2675 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2676 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2677 *
2678 * @pre This method can be called if SCIP is in one of the following stages:
2679 * - \ref SCIP_STAGE_TRANSFORMED
2680 * - \ref SCIP_STAGE_INITPRESOLVE
2681 * - \ref SCIP_STAGE_PRESOLVING
2682 * - \ref SCIP_STAGE_EXITPRESOLVE
2683 * - \ref SCIP_STAGE_PRESOLVED
2684 * - \ref SCIP_STAGE_INITSOLVE
2685 * - \ref SCIP_STAGE_SOLVING
2686 */
2687SCIP_RETCODE SCIPgetConsSignedPermsymGraph(
2688 SCIP* scip, /**< SCIP data structure */
2689 SCIP_CONS* cons, /**< constraint for which the symmetry graph is requested */
2690 SYM_GRAPH* graph, /**< symmetry detection graph */
2691 SCIP_Bool* success /**< pointer to store whether the constraint successfully returned the graph */
2692 )
2693{
2694 SCIP_CALL( SCIPcheckStage(scip, "SCIPgetConsGetSignedPermsymGraph", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2695
2696 assert(scip != NULL);
2697 assert(cons != NULL);
2698 assert(graph != NULL);
2699 assert(success != NULL);
2700
2701 SCIP_CALL( SCIPconsGetSignedPermsymGraph(cons, scip->set, graph, success) );
2702
2703 return SCIP_OKAY;
2704}
SCIP_DECL_CONSENFOPS
SCIP_DECL_CONSENFOPS(ConshdlrSubtour::scip_enfops)
Definition: ConshdlrSubtour.cpp:394
SCIP_DECL_CONSSEPASOL
SCIP_DECL_CONSSEPASOL(ConshdlrSubtour::scip_sepasol)
Definition: ConshdlrSubtour.cpp:312
SCIP_DECL_CONSLOCK
SCIP_DECL_CONSLOCK(ConshdlrSubtour::scip_lock)
Definition: ConshdlrSubtour.cpp:534
SCIP_DECL_CONSDELETE
SCIP_DECL_CONSDELETE(ConshdlrSubtour::scip_delete)
Definition: ConshdlrSubtour.cpp:232
SCIP_DECL_CONSCOPY
SCIP_DECL_CONSCOPY(ConshdlrSubtour::scip_copy)
Definition: ConshdlrSubtour.cpp:603
SCIP_DECL_CONSSEPALP
SCIP_DECL_CONSSEPALP(ConshdlrSubtour::scip_sepalp)
Definition: ConshdlrSubtour.cpp:285
SCIP_DECL_CONSTRANS
SCIP_DECL_CONSTRANS(ConshdlrSubtour::scip_trans)
Definition: ConshdlrSubtour.cpp:244
SCIP_DECL_CONSDELVARS
SCIP_DECL_CONSDELVARS(ConshdlrSubtour::scip_delvars)
Definition: ConshdlrSubtour.cpp:564
SCIP_DECL_CONSPRINT
SCIP_DECL_CONSPRINT(ConshdlrSubtour::scip_print)
Definition: ConshdlrSubtour.cpp:574
SCIP_DECL_CONSCHECK
SCIP_DECL_CONSCHECK(ConshdlrSubtour::scip_check)
Definition: ConshdlrSubtour.cpp:429
SCIP_DECL_CONSPROP
SCIP_DECL_CONSPROP(ConshdlrSubtour::scip_prop)
Definition: ConshdlrSubtour.cpp:476
SCIP_DECL_CONSENFOLP
SCIP_DECL_CONSENFOLP(ConshdlrSubtour::scip_enfolp)
Definition: ConshdlrSubtour.cpp:350
SCIPconshdlrSetFree
void SCIPconshdlrSetFree(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSFREE((*consfree)))
Definition: cons.c:4323
SCIPconsAddLocks
SCIP_RETCODE SCIPconsAddLocks(SCIP_CONS *cons, SCIP_SET *set, SCIP_LOCKTYPE locktype, int nlockspos, int nlocksneg)
Definition: cons.c:7397
SCIPconshdlrSetInitsol
void SCIPconshdlrSetInitsol(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITSOL((*consinitsol)))
Definition: cons.c:4356
SCIPconsParse
SCIP_RETCODE SCIPconsParse(SCIP_CONS **cons, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *str, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode, SCIP_Bool *success)
Definition: cons.c:6093
SCIPconsEnableSeparation
SCIP_RETCODE SCIPconsEnableSeparation(SCIP_CONS *cons, SCIP_SET *set)
Definition: cons.c:7021
SCIPconshdlrSetTrans
void SCIPconshdlrSetTrans(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSTRANS((*constrans)))
Definition: cons.c:4440
SCIPconshdlrSetPresol
SCIP_RETCODE SCIPconshdlrSetPresol(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPRESOL((*conspresol)), int maxprerounds, SCIP_PRESOLTIMING presoltiming)
Definition: cons.c:4400
SCIPconsEnable
SCIP_RETCODE SCIPconsEnable(SCIP_CONS *cons, SCIP_SET *set, SCIP_STAT *stat)
Definition: cons.c:6954
SCIPconsCapture
void SCIPconsCapture(SCIP_CONS *cons)
Definition: cons.c:6273
SCIPconsProp
SCIP_RETCODE SCIPconsProp(SCIP_CONS *cons, SCIP_SET *set, SCIP_PROPTIMING proptiming, SCIP_RESULT *result)
Definition: cons.c:7721
SCIPconsPrint
SCIP_RETCODE SCIPconsPrint(SCIP_CONS *cons, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, FILE *file)
Definition: cons.c:6325
SCIPconsCreate
SCIP_RETCODE SCIPconsCreate(SCIP_CONS **cons, BMS_BLKMEM *blkmem, SCIP_SET *set, const char *name, SCIP_CONSHDLR *conshdlr, SCIP_CONSDATA *consdata, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode, SCIP_Bool original, SCIP_Bool deleteconsdata)
Definition: cons.c:5895
SCIPconsSetLocal
void SCIPconsSetLocal(SCIP_CONS *cons, SCIP_Bool local)
Definition: cons.c:6795
SCIPconsMarkPropagate
SCIP_RETCODE SCIPconsMarkPropagate(SCIP_CONS *cons, SCIP_SET *set)
Definition: cons.c:7149
SCIPconshdlrSetInit
void SCIPconshdlrSetInit(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINIT((*consinit)))
Definition: cons.c:4334
SCIPconshdlrSetDelete
void SCIPconshdlrSetDelete(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDELETE((*consdelete)))
Definition: cons.c:4429
SCIPconshdlrSetParse
void SCIPconshdlrSetParse(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPARSE((*consparse)))
Definition: cons.c:4539
SCIPconshdlrSetGetPermsymGraph
void SCIPconshdlrSetGetPermsymGraph(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETPERMSYMGRAPH((*consgetpermsymgraph)))
Definition: cons.c:4583
SCIPconshdlrSetGetNVars
void SCIPconshdlrSetGetNVars(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETNVARS((*consgetnvars)))
Definition: cons.c:4561
SCIPconsDisable
SCIP_RETCODE SCIPconsDisable(SCIP_CONS *cons, SCIP_SET *set, SCIP_STAT *stat)
Definition: cons.c:6987
SCIPconsDeactive
SCIP_RETCODE SCIPconsDeactive(SCIP_CONS *cons, SCIP_SET *set)
Definition: cons.c:7901
SCIPconshdlrSetActive
void SCIPconshdlrSetActive(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSACTIVE((*consactive)))
Definition: cons.c:4473
SCIPconsGetPermsymGraph
SCIP_RETCODE SCIPconsGetPermsymGraph(SCIP_CONS *cons, SCIP_SET *set, SYM_GRAPH *graph, SCIP_Bool *success)
Definition: cons.c:6435
SCIPconsGetNVars
SCIP_RETCODE SCIPconsGetNVars(SCIP_CONS *cons, SCIP_SET *set, int *nvars, SCIP_Bool *success)
Definition: cons.c:6400
SCIPconshdlrSetInitpre
void SCIPconshdlrSetInitpre(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITPRE((*consinitpre)))
Definition: cons.c:4378
SCIPconsSetStickingAtNode
void SCIPconsSetStickingAtNode(SCIP_CONS *cons, SCIP_Bool stickingatnode)
Definition: cons.c:6841
SCIPconsSetSeparated
SCIP_RETCODE SCIPconsSetSeparated(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool separate)
Definition: cons.c:6642
SCIPconsSepalp
SCIP_RETCODE SCIPconsSepalp(SCIP_CONS *cons, SCIP_SET *set, SCIP_RESULT *result)
Definition: cons.c:7637
SCIPconsEnfops
SCIP_RETCODE SCIPconsEnfops(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool solinfeasible, SCIP_Bool objinfeasible, SCIP_RESULT *result)
Definition: cons.c:7481
SCIPconsActive
SCIP_RETCODE SCIPconsActive(SCIP_CONS *cons, SCIP_SET *set)
Definition: cons.c:7877
SCIPconsResetAge
SCIP_RETCODE SCIPconsResetAge(SCIP_CONS *cons, SCIP_SET *set)
Definition: cons.c:7296
SCIPconsResprop
SCIP_RETCODE SCIPconsResprop(SCIP_CONS *cons, SCIP_SET *set, SCIP_VAR *infervar, int inferinfo, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedbd, SCIP_RESULT *result)
Definition: cons.c:7761
SCIPconsSetRemovable
void SCIPconsSetRemovable(SCIP_CONS *cons, SCIP_Bool removable)
Definition: cons.c:6830
SCIPconshdlrCreate
SCIP_RETCODE SCIPconshdlrCreate(SCIP_CONSHDLR **conshdlr, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, int sepapriority, int enfopriority, int checkpriority, int sepafreq, int propfreq, int eagerfreq, int maxprerounds, SCIP_Bool delaysepa, SCIP_Bool delayprop, SCIP_Bool needscons, SCIP_PROPTIMING proptiming, SCIP_PRESOLTIMING presoltiming, SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), SCIP_DECL_CONSFREE((*consfree)), SCIP_DECL_CONSINIT((*consinit)), SCIP_DECL_CONSEXIT((*consexit)), SCIP_DECL_CONSINITPRE((*consinitpre)), SCIP_DECL_CONSEXITPRE((*consexitpre)), SCIP_DECL_CONSINITSOL((*consinitsol)), SCIP_DECL_CONSEXITSOL((*consexitsol)), SCIP_DECL_CONSDELETE((*consdelete)), SCIP_DECL_CONSTRANS((*constrans)), SCIP_DECL_CONSINITLP((*consinitlp)), SCIP_DECL_CONSSEPALP((*conssepalp)), SCIP_DECL_CONSSEPASOL((*conssepasol)), SCIP_DECL_CONSENFOLP((*consenfolp)), SCIP_DECL_CONSENFORELAX((*consenforelax)), SCIP_DECL_CONSENFOPS((*consenfops)), SCIP_DECL_CONSCHECK((*conscheck)), SCIP_DECL_CONSPROP((*consprop)), SCIP_DECL_CONSPRESOL((*conspresol)), SCIP_DECL_CONSRESPROP((*consresprop)), SCIP_DECL_CONSLOCK((*conslock)), SCIP_DECL_CONSACTIVE((*consactive)), SCIP_DECL_CONSDEACTIVE((*consdeactive)), SCIP_DECL_CONSENABLE((*consenable)), SCIP_DECL_CONSDISABLE((*consdisable)), SCIP_DECL_CONSDELVARS((*consdelvars)), SCIP_DECL_CONSPRINT((*consprint)), SCIP_DECL_CONSCOPY((*conscopy)), SCIP_DECL_CONSPARSE((*consparse)), SCIP_DECL_CONSGETVARS((*consgetvars)), SCIP_DECL_CONSGETNVARS((*consgetnvars)), SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs)), SCIP_DECL_CONSGETPERMSYMGRAPH((*consgetpermsymgraph)), SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH((*consgetsignedpermsymgraph)), SCIP_CONSHDLRDATA *conshdlrdata)
Definition: cons.c:2286
SCIPconsTransform
SCIP_RETCODE SCIPconsTransform(SCIP_CONS *origcons, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_CONS **transcons)
Definition: cons.c:6558
SCIPconsCheck
SCIP_RETCODE SCIPconsCheck(SCIP_CONS *cons, SCIP_SET *set, SCIP_SOL *sol, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool printreason, SCIP_RESULT *result)
Definition: cons.c:7443
SCIPconshdlrSetDisable
void SCIPconshdlrSetDisable(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDISABLE((*consdisable)))
Definition: cons.c:4506
SCIPconsAddAge
SCIP_RETCODE SCIPconsAddAge(SCIP_CONS *cons, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_Real deltaage, SCIP_REOPT *reopt)
Definition: cons.c:7216
SCIPconshdlrSetGetSignedPermsymGraph
void SCIPconshdlrSetGetSignedPermsymGraph(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH((*consgetsignedpermsymgraph)))
Definition: cons.c:4595
SCIPconsEnablePropagation
SCIP_RETCODE SCIPconsEnablePropagation(SCIP_CONS *cons, SCIP_SET *set)
Definition: cons.c:7079
SCIPconsEnfolp
SCIP_RETCODE SCIPconsEnfolp(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool solinfeasible, SCIP_RESULT *result)
Definition: cons.c:7525
SCIPconsSetInitial
SCIP_RETCODE SCIPconsSetInitial(SCIP_CONS *cons, SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool initial)
Definition: cons.c:6608
SCIPconsChgName
SCIP_RETCODE SCIPconsChgName(SCIP_CONS *cons, BMS_BLKMEM *blkmem, const char *name)
Definition: cons.c:6198
SCIPconsIncAge
SCIP_RETCODE SCIPconsIncAge(SCIP_CONS *cons, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_REOPT *reopt)
Definition: cons.c:7275
SCIPconshdlrSetExitsol
void SCIPconshdlrSetExitsol(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSEXITSOL((*consexitsol)))
Definition: cons.c:4367
SCIPconsSetDynamic
void SCIPconsSetDynamic(SCIP_CONS *cons, SCIP_Bool dynamic)
Definition: cons.c:6819
SCIPconsSepasol
SCIP_RETCODE SCIPconsSepasol(SCIP_CONS *cons, SCIP_SET *set, SCIP_SOL *sol, SCIP_RESULT *result)
Definition: cons.c:7678
SCIPconsPresol
SCIP_RETCODE SCIPconsPresol(SCIP_CONS *cons, SCIP_SET *set, int nrounds, SCIP_PRESOLTIMING timing, int nnewfixedvars, int nnewaggrvars, int nnewchgvartypes, int nnewchgbds, int nnewholes, int nnewdelconss, int nnewaddconss, int nnewupgdconss, int nnewchgcoefs, int nnewchgsides, int *nfixedvars, int *naggrvars, int *nchgvartypes, int *nchgbds, int *naddholes, int *ndelconss, int *naddconss, int *nupgdconss, int *nchgcoefs, int *nchgsides, SCIP_RESULT *result)
Definition: cons.c:7803
SCIPconsDisablePropagation
SCIP_RETCODE SCIPconsDisablePropagation(SCIP_CONS *cons, SCIP_SET *set)
Definition: cons.c:7109
SCIPconshdlrSetResprop
void SCIPconshdlrSetResprop(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSRESPROP((*consresprop)))
Definition: cons.c:4462
SCIPconsRelease
SCIP_RETCODE SCIPconsRelease(SCIP_CONS **cons, BMS_BLKMEM *blkmem, SCIP_SET *set)
Definition: cons.c:6285
SCIPconshdlrSetInitlp
void SCIPconshdlrSetInitlp(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITLP((*consinitlp)))
Definition: cons.c:4451
SCIPconsSetPropagated
SCIP_RETCODE SCIPconsSetPropagated(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool propagate)
Definition: cons.c:6760
SCIPconsDisableSeparation
SCIP_RETCODE SCIPconsDisableSeparation(SCIP_CONS *cons, SCIP_SET *set)
Definition: cons.c:7051
SCIPconshdlrSetGetDiveBdChgs
void SCIPconshdlrSetGetDiveBdChgs(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs)))
Definition: cons.c:4572
SCIPconsGetSignedPermsymGraph
SCIP_RETCODE SCIPconsGetSignedPermsymGraph(SCIP_CONS *cons, SCIP_SET *set, SYM_GRAPH *graph, SCIP_Bool *success)
Definition: cons.c:6468
SCIPconsSetChecked
SCIP_RETCODE SCIPconsSetChecked(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool check)
Definition: cons.c:6712
SCIPconsInitlp
SCIP_RETCODE SCIPconsInitlp(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool *infeasible)
Definition: cons.c:7611
SCIPconsEnforelax
SCIP_RETCODE SCIPconsEnforelax(SCIP_CONS *cons, SCIP_SET *set, SCIP_SOL *sol, SCIP_Bool solinfeasible, SCIP_RESULT *result)
Definition: cons.c:7567
SCIPconshdlrSetExit
void SCIPconshdlrSetExit(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSEXIT((*consexit)))
Definition: cons.c:4345
SCIPconshdlrSetCopy
void SCIPconshdlrSetCopy(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), SCIP_DECL_CONSCOPY((*conscopy)))
Definition: cons.c:4308
SCIPconshdlrSetDelvars
void SCIPconshdlrSetDelvars(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDELVARS((*consdelvars)))
Definition: cons.c:4517
SCIPconshdlrSetEnable
void SCIPconshdlrSetEnable(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSENABLE((*consenable)))
Definition: cons.c:4495
SCIPconsGetTransformed
SCIP_CONS * SCIPconsGetTransformed(SCIP_CONS *cons)
Definition: cons.c:6867
SCIPconshdlrSetPrint
void SCIPconshdlrSetPrint(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPRINT((*consprint)))
Definition: cons.c:4528
SCIPconsUnmarkPropagate
SCIP_RETCODE SCIPconsUnmarkPropagate(SCIP_CONS *cons, SCIP_SET *set)
Definition: cons.c:7179
SCIPconshdlrSetDeactive
void SCIPconshdlrSetDeactive(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDEACTIVE((*consdeactive)))
Definition: cons.c:4484
SCIPconsGetVars
SCIP_RETCODE SCIPconsGetVars(SCIP_CONS *cons, SCIP_SET *set, SCIP_VAR **vars, int varssize, SCIP_Bool *success)
Definition: cons.c:6364
SCIPconsSetEnforced
SCIP_RETCODE SCIPconsSetEnforced(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool enforce)
Definition: cons.c:6677
SCIPconsSetModifiable
void SCIPconsSetModifiable(SCIP_CONS *cons, SCIP_Bool modifiable)
Definition: cons.c:6808
SCIPconshdlrSetGetVars
void SCIPconshdlrSetGetVars(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETVARS((*consgetvars)))
Definition: cons.c:4550
SCIPconshdlrSetExitpre
void SCIPconshdlrSetExitpre(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSEXITPRE((*consexitpre)))
Definition: cons.c:4389
cons.h
internal methods for constraints and constraint handlers
SCIPcheckStage
SCIP_RETCODE SCIPcheckStage(SCIP *scip, const char *method, SCIP_Bool init, SCIP_Bool problem, SCIP_Bool transforming, SCIP_Bool transformed, SCIP_Bool initpresolve, SCIP_Bool presolving, SCIP_Bool exitpresolve, SCIP_Bool presolved, SCIP_Bool initsolve, SCIP_Bool solving, SCIP_Bool solved, SCIP_Bool exitsolve, SCIP_Bool freetrans, SCIP_Bool freescip)
Definition: debug.c:2202
debug.h
methods for debugging
NULL
#define NULL
Definition: def.h:262
SCIP_MAXSTRLEN
#define SCIP_MAXSTRLEN
Definition: def.h:283
SCIP_Bool
#define SCIP_Bool
Definition: def.h:91
SCIP_Real
#define SCIP_Real
Definition: def.h:172
TRUE
#define TRUE
Definition: def.h:93
FALSE
#define FALSE
Definition: def.h:94
SCIPABORT
#define SCIPABORT()
Definition: def.h:341
SCIP_CALL
#define SCIP_CALL(x)
Definition: def.h:369
SCIPgetStage
SCIP_STAGE SCIPgetStage(SCIP *scip)
Definition: scip_general.c:390
SCIPsetConshdlrParse
SCIP_RETCODE SCIPsetConshdlrParse(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPARSE((*consparse)))
Definition: scip_cons.c:808
SCIPsetConshdlrEnable
SCIP_RETCODE SCIPsetConshdlrEnable(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSENABLE((*consenable)))
Definition: scip_cons.c:716
SCIPsetConshdlrPresol
SCIP_RETCODE SCIPsetConshdlrPresol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPRESOL((*conspresol)), int maxprerounds, SCIP_PRESOLTIMING presoltiming)
Definition: scip_cons.c:540
SCIPsetConshdlrInit
SCIP_RETCODE SCIPsetConshdlrInit(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINIT((*consinit)))
Definition: scip_cons.c:396
SCIPsetConshdlrGetVars
SCIP_RETCODE SCIPsetConshdlrGetVars(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETVARS((*consgetvars)))
Definition: scip_cons.c:831
SCIPconshdlrSetProp
void SCIPconshdlrSetProp(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPROP((*consprop)), int propfreq, SCIP_Bool delayprop, SCIP_PROPTIMING timingmask)
Definition: cons.c:4278
SCIPsetConshdlrInitpre
SCIP_RETCODE SCIPsetConshdlrInitpre(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITPRE((*consinitpre)))
Definition: scip_cons.c:492
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:235
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:281
SCIPgetNConshdlrs
int SCIPgetNConshdlrs(SCIP *scip)
Definition: scip_cons.c:964
SCIPconshdlrGetSepaPriority
int SCIPconshdlrGetSepaPriority(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5119
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:181
SCIPsetConshdlrDisable
SCIP_RETCODE SCIPsetConshdlrDisable(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDISABLE((*consdisable)))
Definition: scip_cons.c:739
SCIPconshdlrSetSepa
void SCIPconshdlrSetSepa(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSSEPALP((*conssepalp)), SCIP_DECL_CONSSEPASOL((*conssepasol)), int sepafreq, int sepapriority, SCIP_Bool delaysepa)
Definition: cons.c:4257
SCIPsetConshdlrDeactive
SCIP_RETCODE SCIPsetConshdlrDeactive(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDEACTIVE((*consdeactive)))
Definition: scip_cons.c:693
SCIPconshdlrSetEnforelax
void SCIPconshdlrSetEnforelax(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSENFORELAX((*consenforelax)))
Definition: cons.c:4297
SCIPsetConshdlrGetPermsymGraph
SCIP_RETCODE SCIPsetConshdlrGetPermsymGraph(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETPERMSYMGRAPH((*consgetpermsymgraph)))
Definition: scip_cons.c:900
SCIPsetConshdlrDelete
SCIP_RETCODE SCIPsetConshdlrDelete(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDELETE((*consdelete)))
Definition: scip_cons.c:578
SCIPsetConshdlrFree
SCIP_RETCODE SCIPsetConshdlrFree(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSFREE((*consfree)))
Definition: scip_cons.c:372
SCIPsetConshdlrEnforelax
SCIP_RETCODE SCIPsetConshdlrEnforelax(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSENFORELAX((*consenforelax)))
Definition: scip_cons.c:323
SCIPsetConshdlrGetDiveBdChgs
SCIP_RETCODE SCIPsetConshdlrGetDiveBdChgs(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs)))
Definition: scip_cons.c:877
SCIPconshdlrGetName
const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4216
SCIPsetConshdlrExit
SCIP_RETCODE SCIPsetConshdlrExit(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSEXIT((*consexit)))
Definition: scip_cons.c:420
SCIPsetConshdlrExitpre
SCIP_RETCODE SCIPsetConshdlrExitpre(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSEXITPRE((*consexitpre)))
Definition: scip_cons.c:516
SCIPsetConshdlrCopy
SCIP_RETCODE SCIPsetConshdlrCopy(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), SCIP_DECL_CONSCOPY((*conscopy)))
Definition: scip_cons.c:347
SCIPfindConshdlr
SCIP_CONSHDLR * SCIPfindConshdlr(SCIP *scip, const char *name)
Definition: scip_cons.c:940
SCIPsetConshdlrGetSignedPermsymGraph
SCIP_RETCODE SCIPsetConshdlrGetSignedPermsymGraph(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH((*consgetsignedpermsymgraph)))
Definition: scip_cons.c:924
SCIPsetConshdlrExitsol
SCIP_RETCODE SCIPsetConshdlrExitsol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSEXITSOL((*consexitsol)))
Definition: scip_cons.c:468
SCIPsetConshdlrDelvars
SCIP_RETCODE SCIPsetConshdlrDelvars(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDELVARS((*consdelvars)))
Definition: scip_cons.c:762
SCIPsetConshdlrInitlp
SCIP_RETCODE SCIPsetConshdlrInitlp(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITLP((*consinitlp)))
Definition: scip_cons.c:624
SCIPsetConshdlrInitsol
SCIP_RETCODE SCIPsetConshdlrInitsol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITSOL((*consinitsol)))
Definition: scip_cons.c:444
SCIPsetConshdlrTrans
SCIP_RETCODE SCIPsetConshdlrTrans(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSTRANS((*constrans)))
Definition: scip_cons.c:601
SCIPsetConshdlrResprop
SCIP_RETCODE SCIPsetConshdlrResprop(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSRESPROP((*consresprop)))
Definition: scip_cons.c:647
SCIPsetConshdlrGetNVars
SCIP_RETCODE SCIPsetConshdlrGetNVars(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETNVARS((*consgetnvars)))
Definition: scip_cons.c:854
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_DECL_CONSGETPERMSYMGRAPH((*consgetpermsymgraph)), SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH((*consgetsignedpermsymgraph)), SCIP_CONSHDLRDATA *conshdlrdata)
Definition: scip_cons.c:83
SCIPsetConshdlrActive
SCIP_RETCODE SCIPsetConshdlrActive(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSACTIVE((*consactive)))
Definition: scip_cons.c:670
SCIPgetConshdlrs
SCIP_CONSHDLR ** SCIPgetConshdlrs(SCIP *scip)
Definition: scip_cons.c:953
SCIPsetConshdlrPrint
SCIP_RETCODE SCIPsetConshdlrPrint(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPRINT((*consprint)))
Definition: scip_cons.c:785
SCIPgetConsNVars
SCIP_RETCODE SCIPgetConsNVars(SCIP *scip, SCIP_CONS *cons, int *nvars, SCIP_Bool *success)
Definition: scip_cons.c:2621
SCIPgetConsSignedPermsymGraph
SCIP_RETCODE SCIPgetConsSignedPermsymGraph(SCIP *scip, SCIP_CONS *cons, SYM_GRAPH *graph, SCIP_Bool *success)
Definition: scip_cons.c:2687
SCIPenfopsCons
SCIP_RETCODE SCIPenfopsCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool solinfeasible, SCIP_Bool objinfeasible, SCIP_RESULT *result)
Definition: scip_cons.c:2163
SCIPdisableConsSeparation
SCIP_RETCODE SCIPdisableConsSeparation(SCIP *scip, SCIP_CONS *cons)
Definition: scip_cons.c:1924
SCIPgetTransformedConss
SCIP_RETCODE SCIPgetTransformedConss(SCIP *scip, int nconss, SCIP_CONS **conss, SCIP_CONS **transconss)
Definition: scip_cons.c:1714
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:2135
SCIPconsIsDynamic
SCIP_Bool SCIPconsIsDynamic(SCIP_CONS *cons)
Definition: cons.c:8492
SCIPenableCons
SCIP_RETCODE SCIPenableCons(SCIP *scip, SCIP_CONS *cons)
Definition: scip_cons.c:1837
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:2406
SCIPconsIsInitial
SCIP_Bool SCIPconsIsInitial(SCIP_CONS *cons)
Definition: cons.c:8402
SCIPsetConsStickingAtNode
SCIP_RETCODE SCIPsetConsStickingAtNode(SCIP *scip, SCIP_CONS *cons, SCIP_Bool stickingatnode)
Definition: scip_cons.c:1499
SCIPchgConsName
SCIP_RETCODE SCIPchgConsName(SCIP *scip, SCIP_CONS *cons, const char *name)
Definition: scip_cons.c:1224
SCIPenfolpCons
SCIP_RETCODE SCIPenfolpCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool solinfeasible, SCIP_RESULT *result)
Definition: scip_cons.c:2194
SCIPprintCons
SCIP_RETCODE SCIPprintCons(SCIP *scip, SCIP_CONS *cons, FILE *file)
Definition: scip_cons.c:2536
SCIPpropCons
SCIP_RETCODE SCIPpropCons(SCIP *scip, SCIP_CONS *cons, SCIP_PROPTIMING proptiming, SCIP_RESULT *result)
Definition: scip_cons.c:2340
SCIPtransformConss
SCIP_RETCODE SCIPtransformConss(SCIP *scip, int nconss, SCIP_CONS **conss, SCIP_CONS **transconss)
Definition: scip_cons.c:1625
SCIPenableConsPropagation
SCIP_RETCODE SCIPenableConsPropagation(SCIP *scip, SCIP_CONS *cons)
Definition: scip_cons.c:1951
SCIPgetConsPermsymGraph
SCIP_RETCODE SCIPgetConsPermsymGraph(SCIP *scip, SCIP_CONS *cons, SYM_GRAPH *graph, SCIP_Bool *success)
Definition: scip_cons.c:2654
SCIPdeactiveCons
SCIP_RETCODE SCIPdeactiveCons(SCIP *scip, SCIP_CONS *cons)
Definition: scip_cons.c:2497
SCIPsetConsSeparated
SCIP_RETCODE SCIPsetConsSeparated(SCIP *scip, SCIP_CONS *cons, SCIP_Bool separate)
Definition: scip_cons.c:1296
SCIPconsIsMarkedPropagate
SCIP_Bool SCIPconsIsMarkedPropagate(SCIP_CONS *cons)
Definition: cons.c:8442
SCIPconsIsOriginal
SCIP_Bool SCIPconsIsOriginal(SCIP_CONS *cons)
Definition: cons.c:8532
SCIPconsIsChecked
SCIP_Bool SCIPconsIsChecked(SCIP_CONS *cons)
Definition: cons.c:8432
SCIPconsIsDeleted
SCIP_Bool SCIPconsIsDeleted(SCIP_CONS *cons)
Definition: cons.c:8362
SCIPsepalpCons
SCIP_RETCODE SCIPsepalpCons(SCIP *scip, SCIP_CONS *cons, SCIP_RESULT *result)
Definition: scip_cons.c:2283
SCIPsetConsDynamic
SCIP_RETCODE SCIPsetConsDynamic(SCIP *scip, SCIP_CONS *cons, SCIP_Bool dynamic)
Definition: scip_cons.c:1449
SCIPconsIsTransformed
SCIP_Bool SCIPconsIsTransformed(SCIP_CONS *cons)
Definition: cons.c:8542
SCIPgetConsVars
SCIP_RETCODE SCIPgetConsVars(SCIP *scip, SCIP_CONS *cons, SCIP_VAR **vars, int varssize, SCIP_Bool *success)
Definition: scip_cons.c:2577
SCIPsetConsInitial
SCIP_RETCODE SCIPsetConsInitial(SCIP *scip, SCIP_CONS *cons, SCIP_Bool initial)
Definition: scip_cons.c:1271
SCIPsetConsEnforced
SCIP_RETCODE SCIPsetConsEnforced(SCIP *scip, SCIP_CONS *cons, SCIP_Bool enforce)
Definition: scip_cons.c:1321
SCIPactiveCons
SCIP_RETCODE SCIPactiveCons(SCIP *scip, SCIP_CONS *cons)
Definition: scip_cons.c:2468
SCIPconsIsEnforced
SCIP_Bool SCIPconsIsEnforced(SCIP_CONS *cons)
Definition: cons.c:8422
SCIPunmarkConsPropagate
SCIP_RETCODE SCIPunmarkConsPropagate(SCIP *scip, SCIP_CONS *cons)
Definition: scip_cons.c:2042
SCIPenableConsSeparation
SCIP_RETCODE SCIPenableConsSeparation(SCIP *scip, SCIP_CONS *cons)
Definition: scip_cons.c:1896
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:997
SCIPconsIsPropagated
SCIP_Bool SCIPconsIsPropagated(SCIP_CONS *cons)
Definition: cons.c:8452
SCIPaddConsLocksType
SCIP_RETCODE SCIPaddConsLocksType(SCIP *scip, SCIP_CONS *cons, SCIP_LOCKTYPE locktype, int nlockspos, int nlocksneg)
Definition: scip_cons.c:2072
SCIPconsIsEnabled
SCIP_Bool SCIPconsIsEnabled(SCIP_CONS *cons)
Definition: cons.c:8330
SCIPdisableCons
SCIP_RETCODE SCIPdisableCons(SCIP *scip, SCIP_CONS *cons)
Definition: scip_cons.c:1871
SCIPresetConsAge
SCIP_RETCODE SCIPresetConsAge(SCIP *scip, SCIP_CONS *cons)
Definition: scip_cons.c:1812
SCIPsetConsModifiable
SCIP_RETCODE SCIPsetConsModifiable(SCIP *scip, SCIP_CONS *cons, SCIP_Bool modifiable)
Definition: scip_cons.c:1424
SCIPmarkConsPropagate
SCIP_RETCODE SCIPmarkConsPropagate(SCIP *scip, SCIP_CONS *cons)
Definition: scip_cons.c:2014
SCIPinitlpCons
SCIP_RETCODE SCIPinitlpCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *infeasible)
Definition: scip_cons.c:2256
SCIPsetConsRemovable
SCIP_RETCODE SCIPsetConsRemovable(SCIP *scip, SCIP_CONS *cons, SCIP_Bool removable)
Definition: scip_cons.c:1474
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:2371
SCIPsetConsLocal
SCIP_RETCODE SCIPsetConsLocal(SCIP *scip, SCIP_CONS *cons, SCIP_Bool local)
Definition: scip_cons.c:1398
SCIPaddConsLocks
SCIP_RETCODE SCIPaddConsLocks(SCIP *scip, SCIP_CONS *cons, int nlockspos, int nlocksneg)
Definition: scip_cons.c:2105
SCIPgetTransformedCons
SCIP_RETCODE SCIPgetTransformedCons(SCIP *scip, SCIP_CONS *cons, SCIP_CONS **transcons)
Definition: scip_cons.c:1674
SCIPconsIsAdded
SCIP_Bool SCIPconsIsAdded(SCIP_CONS *cons)
Definition: cons.c:8662
SCIPenforelaxCons
SCIP_RETCODE SCIPenforelaxCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool solinfeasible, SCIP_RESULT *result)
Definition: scip_cons.c:2224
SCIPupdateConsFlags
SCIP_RETCODE SCIPupdateConsFlags(SCIP *scip, SCIP_CONS *cons0, SCIP_CONS *cons1)
Definition: scip_cons.c:1524
SCIPconsIsStickingAtNode
SCIP_Bool SCIPconsIsStickingAtNode(SCIP_CONS *cons)
Definition: cons.c:8512
SCIPdisableConsPropagation
SCIP_RETCODE SCIPdisableConsPropagation(SCIP *scip, SCIP_CONS *cons)
Definition: scip_cons.c:1981
SCIPaddConsAge
SCIP_RETCODE SCIPaddConsAge(SCIP *scip, SCIP_CONS *cons, SCIP_Real deltaage)
Definition: scip_cons.c:1755
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:1081
SCIPsepasolCons
SCIP_RETCODE SCIPsepasolCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_RESULT *result)
Definition: scip_cons.c:2310
SCIPreleaseCons
SCIP_RETCODE SCIPreleaseCons(SCIP *scip, SCIP_CONS **cons)
Definition: scip_cons.c:1173
SCIPsetConsPropagated
SCIP_RETCODE SCIPsetConsPropagated(SCIP *scip, SCIP_CONS *cons, SCIP_Bool propagate)
Definition: scip_cons.c:1371
SCIPtransformCons
SCIP_RETCODE SCIPtransformCons(SCIP *scip, SCIP_CONS *cons, SCIP_CONS **transcons)
Definition: scip_cons.c:1584
SCIPsetConsChecked
SCIP_RETCODE SCIPsetConsChecked(SCIP *scip, SCIP_CONS *cons, SCIP_Bool check)
Definition: scip_cons.c:1346
SCIPconsIsSeparated
SCIP_Bool SCIPconsIsSeparated(SCIP_CONS *cons)
Definition: cons.c:8412
SCIPcaptureCons
SCIP_RETCODE SCIPcaptureCons(SCIP *scip, SCIP_CONS *cons)
Definition: scip_cons.c:1138
SCIPincConsAge
SCIP_RETCODE SCIPincConsAge(SCIP *scip, SCIP_CONS *cons)
Definition: scip_cons.c:1784
SCIPconsIsRemovable
SCIP_Bool SCIPconsIsRemovable(SCIP_CONS *cons)
Definition: cons.c:8502
SCIPsnprintf
int SCIPsnprintf(char *t, int len, const char *s,...)
Definition: misc.c:10878
paramname
static const char * paramname[]
Definition: lpi_msk.c:5171
SCIPblkmem
BMS_BLKMEM * SCIPblkmem(SCIP *scip)
Definition: scip_mem.c:57
SCIPprobAddConsName
SCIP_RETCODE SCIPprobAddConsName(SCIP_PROB *prob, SCIP_CONS *cons)
Definition: prob.c:1282
SCIPprobRemoveConsName
SCIP_RETCODE SCIPprobRemoveConsName(SCIP_PROB *prob, SCIP_CONS *cons)
Definition: prob.c:1297
prob.h
internal methods for storing and manipulating the main problem
pub_cons.h
public methods for managing constraints
pub_message.h
public methods for message output
SCIPerrorMessage
#define SCIPerrorMessage
Definition: pub_message.h:64
pub_misc.h
public data structures and miscellaneous methods
scip_cons.h
public methods for constraint handler plugins and constraints
scip_general.h
general public methods
scip_mem.h
public methods for memory management
SCIPsetSetDefaultIntParam
SCIP_RETCODE SCIPsetSetDefaultIntParam(SCIP_SET *set, const char *name, int defaultvalue)
Definition: set.c:3311
SCIPsetSetDefaultBoolParam
SCIP_RETCODE SCIPsetSetDefaultBoolParam(SCIP_SET *set, const char *name, SCIP_Bool defaultvalue)
Definition: set.c:3258
SCIPsetFindConshdlr
SCIP_CONSHDLR * SCIPsetFindConshdlr(SCIP_SET *set, const char *name)
Definition: set.c:3985
SCIPsetIncludeConshdlr
SCIP_RETCODE SCIPsetIncludeConshdlr(SCIP_SET *set, SCIP_CONSHDLR *conshdlr)
Definition: set.c:3846
SCIPsetReinsertConshdlrSepaPrio
void SCIPsetReinsertConshdlrSepaPrio(SCIP_SET *set, SCIP_CONSHDLR *conshdlr, int oldpriority)
Definition: set.c:3902
set.h
internal methods for global SCIP settings
SCIP_BdChgIdx
Definition: struct_var.h:109
SCIP_Cons
Definition: struct_cons.h:47
SCIP_Cons::scip
SCIP * scip
Definition: struct_cons.h:110
SCIP_Conshdlr
Definition: struct_cons.h:127
SCIP_Sol
Definition: struct_sol.h:74
SCIP_Var
Definition: struct_var.h:208
SYM_Graph
Definition: struct_symmetry.h:46
struct_cons.h
datastructures for constraints and constraint handlers
struct_mem.h
datastructures for block memory pools and memory buffers
struct_scip.h
SCIP main data structure.
struct_set.h
datastructures for global SCIP settings
SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH
#define SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH(x)
Definition: type_cons.h:955
SCIP_DECL_CONSGETPERMSYMGRAPH
#define SCIP_DECL_CONSGETPERMSYMGRAPH(x)
Definition: type_cons.h:937
SCIP_DECL_CONSINITPRE
#define SCIP_DECL_CONSINITPRE(x)
Definition: type_cons.h:156
SCIP_DECL_CONSEXIT
#define SCIP_DECL_CONSEXIT(x)
Definition: type_cons.h:136
SCIP_DECL_CONSGETVARS
#define SCIP_DECL_CONSGETVARS(x)
Definition: type_cons.h:866
SCIP_DECL_CONSINITSOL
#define SCIP_DECL_CONSINITSOL(x)
Definition: type_cons.h:201
SCIP_CONSHDLRDATA
struct SCIP_ConshdlrData SCIP_CONSHDLRDATA
Definition: type_cons.h:64
SCIP_DECL_CONSDISABLE
#define SCIP_DECL_CONSDISABLE(x)
Definition: type_cons.h:735
SCIP_DECL_CONSENFORELAX
#define SCIP_DECL_CONSENFORELAX(x)
Definition: type_cons.h:388
SCIP_DECL_CONSGETDIVEBDCHGS
#define SCIP_DECL_CONSGETDIVEBDCHGS(x)
Definition: type_cons.h:919
SCIP_DECL_CONSGETNVARS
#define SCIP_DECL_CONSGETNVARS(x)
Definition: type_cons.h:884
SCIP_DECL_CONSRESPROP
#define SCIP_DECL_CONSRESPROP(x)
Definition: type_cons.h:611
SCIP_DECL_CONSACTIVE
#define SCIP_DECL_CONSACTIVE(x)
Definition: type_cons.h:690
SCIP_DECL_CONSPARSE
#define SCIP_DECL_CONSPARSE(x)
Definition: type_cons.h:844
SCIP_DECL_CONSDEACTIVE
#define SCIP_DECL_CONSDEACTIVE(x)
Definition: type_cons.h:705
SCIP_DECL_CONSPRESOL
#define SCIP_DECL_CONSPRESOL(x)
Definition: type_cons.h:560
SCIP_DECL_CONSENABLE
#define SCIP_DECL_CONSENABLE(x)
Definition: type_cons.h:720
SCIP_DECL_CONSINITLP
#define SCIP_DECL_CONSINITLP(x)
Definition: type_cons.h:259
SCIP_DECL_CONSEXITPRE
#define SCIP_DECL_CONSEXITPRE(x)
Definition: type_cons.h:180
SCIP_DECL_CONSINIT
#define SCIP_DECL_CONSINIT(x)
Definition: type_cons.h:126
SCIP_CONSDATA
struct SCIP_ConsData SCIP_CONSDATA
Definition: type_cons.h:65
SCIP_DECL_CONSHDLRCOPY
#define SCIP_DECL_CONSHDLRCOPY(x)
Definition: type_cons.h:108
SCIP_DECL_CONSEXITSOL
#define SCIP_DECL_CONSEXITSOL(x)
Definition: type_cons.h:216
SCIP_DECL_CONSFREE
#define SCIP_DECL_CONSFREE(x)
Definition: type_cons.h:116
SCIP_BOUNDTYPE
enum SCIP_BoundType SCIP_BOUNDTYPE
Definition: type_lp.h:59
SCIP_RESULT
enum SCIP_Result SCIP_RESULT
Definition: type_result.h:61
SCIP_INVALIDDATA
@ SCIP_INVALIDDATA
Definition: type_retcode.h:52
SCIP_OKAY
@ SCIP_OKAY
Definition: type_retcode.h:42
SCIP_INVALIDCALL
@ SCIP_INVALIDCALL
Definition: type_retcode.h:51
SCIP_RETCODE
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:63
SCIP_STAGE_PROBLEM
@ SCIP_STAGE_PROBLEM
Definition: type_set.h:45
SCIP_STAGE_INITPRESOLVE
@ SCIP_STAGE_INITPRESOLVE
Definition: type_set.h:48
SCIP_STAGE_SOLVED
@ SCIP_STAGE_SOLVED
Definition: type_set.h:54
SCIP_STAGE_PRESOLVING
@ SCIP_STAGE_PRESOLVING
Definition: type_set.h:49
SCIP_STAGE_TRANSFORMED
@ SCIP_STAGE_TRANSFORMED
Definition: type_set.h:47
SCIP_STAGE_INITSOLVE
@ SCIP_STAGE_INITSOLVE
Definition: type_set.h:52
SCIP_STAGE_EXITPRESOLVE
@ SCIP_STAGE_EXITPRESOLVE
Definition: type_set.h:50
SCIP_STAGE_EXITSOLVE
@ SCIP_STAGE_EXITSOLVE
Definition: type_set.h:55
SCIP_STAGE_FREETRANS
@ SCIP_STAGE_FREETRANS
Definition: type_set.h:56
SCIP_STAGE_SOLVING
@ SCIP_STAGE_SOLVING
Definition: type_set.h:53
SCIP_STAGE_TRANSFORMING
@ SCIP_STAGE_TRANSFORMING
Definition: type_set.h:46
SCIP_STAGE_PRESOLVED
@ SCIP_STAGE_PRESOLVED
Definition: type_set.h:51
SCIP_PROPTIMING
unsigned int SCIP_PROPTIMING
Definition: type_timing.h:74
SCIP_PRESOLTIMING_ALWAYS
#define SCIP_PRESOLTIMING_ALWAYS
Definition: type_timing.h:58
SCIP_PRESOLTIMING
unsigned int SCIP_PRESOLTIMING
Definition: type_timing.h:61
SCIP_PROPTIMING_BEFORELP
#define SCIP_PROPTIMING_BEFORELP
Definition: type_timing.h:65
SCIP_LOCKTYPE
enum SCIP_LockType SCIP_LOCKTYPE
Definition: type_var.h:100
SCIP_LOCKTYPE_MODEL
@ SCIP_LOCKTYPE_MODEL
Definition: type_var.h:97