SCIP Doxygen Documentation
 
Loading...
Searching...
No Matches
cons.h
Go to the documentation of this file.
1/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2/* */
3/* This file is part of the program and library */
4/* SCIP --- Solving Constraint Integer Programs */
5/* */
6/* Copyright (c) 2002-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 cons.h
26 * @ingroup INTERNALAPI
27 * @brief internal methods for constraints and constraint handlers
28 * @author Tobias Achterberg
29 */
30
31/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
32
33#ifndef __SCIP_CONS_H__
34#define __SCIP_CONS_H__
35
36
37#include "scip/def.h"
39#include "scip/type_retcode.h"
40#include "scip/type_result.h"
41#include "scip/type_set.h"
42#include "scip/type_stat.h"
43#include "scip/type_mem.h"
44#include "scip/type_misc.h"
45#include "scip/type_timing.h"
46#include "scip/type_lp.h"
47#include "scip/type_var.h"
48#include "scip/type_prob.h"
49#include "scip/type_sol.h"
50#include "scip/type_tree.h"
51#include "scip/type_sepastore.h"
52#include "scip/type_cons.h"
53#include "scip/type_branch.h"
54#include "scip/type_reopt.h"
55#include "scip/type_message.h"
56#include "scip/pub_cons.h"
57
58#ifndef NDEBUG
59#include "scip/struct_cons.h"
60#endif
61
62#ifdef __cplusplus
63extern "C" {
64#endif
65
66/*
67 * Constraint handler methods
68 */
69
70/** copies the given constraint handler to a new scip */
72 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
73 SCIP_SET* set, /**< SCIP_SET of SCIP to copy to */
74 SCIP_Bool* valid /**< was the copying process valid? */
75 );
76
77/** creates a constraint handler */
79 SCIP_CONSHDLR** conshdlr, /**< pointer to constraint handler data structure */
80 SCIP_SET* set, /**< global SCIP settings */
81 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
82 BMS_BLKMEM* blkmem, /**< block memory for parameter settings */
83 const char* name, /**< name of constraint handler */
84 const char* desc, /**< description of constraint handler */
85 int sepapriority, /**< priority of the constraint handler for separation */
86 int enfopriority, /**< priority of the constraint handler for constraint enforcing */
87 int checkpriority, /**< priority of the constraint handler for checking feasibility (and propagation) */
88 int sepafreq, /**< frequency for separating cuts; zero means to separate only in the root node */
89 int propfreq, /**< frequency for propagating domains; zero means only preprocessing propagation */
90 int eagerfreq, /**< frequency for using all instead of only the useful constraints in separation,
91 * propagation and enforcement, -1 for no eager evaluations, 0 for first only */
92 int maxprerounds, /**< maximal number of presolving rounds the constraint handler participates in (-1: no limit) */
93 SCIP_Bool delaysepa, /**< should separation method be delayed, if other separators found cuts? */
94 SCIP_Bool delayprop, /**< should propagation method be delayed, if other propagators found reductions? */
95 SCIP_Bool needscons, /**< should the constraint handler be skipped, if no constraints are available? */
96 SCIP_PROPTIMING proptiming, /**< positions in the node solving loop where propagation method of constraint handlers should be executed */
97 SCIP_PRESOLTIMING presoltiming, /**< timing mask of the constraint handler's presolving method */
98 SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), /**< copy method of constraint handler or NULL if you don't want to copy your plugin into sub-SCIPs */
99 SCIP_DECL_CONSFREE ((*consfree)), /**< destructor of constraint handler */
100 SCIP_DECL_CONSINIT ((*consinit)), /**< initialize constraint handler */
101 SCIP_DECL_CONSEXIT ((*consexit)), /**< deinitialize constraint handler */
102 SCIP_DECL_CONSINITPRE ((*consinitpre)), /**< presolving initialization method of constraint handler */
103 SCIP_DECL_CONSEXITPRE ((*consexitpre)), /**< presolving deinitialization method of constraint handler */
104 SCIP_DECL_CONSINITSOL ((*consinitsol)), /**< solving process initialization method of constraint handler */
105 SCIP_DECL_CONSEXITSOL ((*consexitsol)), /**< solving process deinitialization method of constraint handler */
106 SCIP_DECL_CONSDELETE ((*consdelete)), /**< free specific constraint data */
107 SCIP_DECL_CONSTRANS ((*constrans)), /**< transform constraint data into data belonging to the transformed problem */
108 SCIP_DECL_CONSINITLP ((*consinitlp)), /**< initialize LP with relaxations of "initial" constraints */
109 SCIP_DECL_CONSSEPALP ((*conssepalp)), /**< separate cutting planes for LP solution */
110 SCIP_DECL_CONSSEPASOL ((*conssepasol)), /**< separate cutting planes for arbitrary primal solution */
111 SCIP_DECL_CONSENFOLP ((*consenfolp)), /**< enforcing constraints for LP solutions */
112 SCIP_DECL_CONSENFORELAX ((*consenforelax)), /**< enforcing constraints for relaxation solutions */
113 SCIP_DECL_CONSENFOPS ((*consenfops)), /**< enforcing constraints for pseudo solutions */
114 SCIP_DECL_CONSCHECK ((*conscheck)), /**< check feasibility of primal solution */
115 SCIP_DECL_CONSPROP ((*consprop)), /**< propagate variable domains */
116 SCIP_DECL_CONSPRESOL ((*conspresol)), /**< presolving method */
117 SCIP_DECL_CONSRESPROP ((*consresprop)), /**< propagation conflict resolving method */
118 SCIP_DECL_CONSLOCK ((*conslock)), /**< variable rounding lock method */
119 SCIP_DECL_CONSACTIVE ((*consactive)), /**< activation notification method */
120 SCIP_DECL_CONSDEACTIVE((*consdeactive)), /**< deactivation notification method */
121 SCIP_DECL_CONSENABLE ((*consenable)), /**< enabling notification method */
122 SCIP_DECL_CONSDISABLE ((*consdisable)), /**< disabling notification method */
123 SCIP_DECL_CONSDELVARS ((*consdelvars)), /**< variable deletion method */
124 SCIP_DECL_CONSPRINT ((*consprint)), /**< constraint display method */
125 SCIP_DECL_CONSCOPY ((*conscopy)), /**< constraint copying method */
126 SCIP_DECL_CONSPARSE ((*consparse)), /**< constraint parsing method */
127 SCIP_DECL_CONSGETVARS ((*consgetvars)), /**< constraint get variables method */
128 SCIP_DECL_CONSGETNVARS((*consgetnvars)), /**< constraint get number of variable method */
129 SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs)), /**< constraint handler diving solution enforcement method */
130 SCIP_DECL_CONSGETPERMSYMGRAPH((*consgetpermsymgraph)), /**< constraint permutation symmetry detection graph
131 * getter method */
132 SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH((*consgetsignedpermsymgraph)), /**< constraint signed permutation symmetry
133 * detection graph getter method */
134 SCIP_CONSHDLRDATA* conshdlrdata /**< constraint handler data */
135 );
136
137/** calls destructor and frees memory of constraint handler */
139 SCIP_CONSHDLR** conshdlr, /**< pointer to constraint handler data structure */
140 SCIP_SET* set /**< global SCIP settings */
141 );
142
143/** calls init method of constraint handler */
145 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
146 BMS_BLKMEM* blkmem, /**< block memory */
147 SCIP_SET* set, /**< global SCIP settings */
148 SCIP_STAT* stat /**< dynamic problem statistics */
149 );
150
151/** calls exit method of constraint handler */
153 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
154 BMS_BLKMEM* blkmem, /**< block memory */
155 SCIP_SET* set, /**< global SCIP settings */
156 SCIP_STAT* stat /**< dynamic problem statistics */
157 );
158
159/** informs constraint handler that the presolving process is being started */
161 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
162 BMS_BLKMEM* blkmem, /**< block memory */
163 SCIP_SET* set, /**< global SCIP settings */
164 SCIP_STAT* stat /**< dynamic problem statistics */
165 );
166
167/** informs constraint handler that the presolving is finished */
169 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
170 BMS_BLKMEM* blkmem, /**< block memory */
171 SCIP_SET* set, /**< global SCIP settings */
172 SCIP_STAT* stat /**< dynamic problem statistics */
173 );
174
175/** informs constraint handler that the branch and bound process is being started */
177 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
178 BMS_BLKMEM* blkmem, /**< block memory */
179 SCIP_SET* set, /**< global SCIP settings */
180 SCIP_STAT* stat /**< dynamic problem statistics */
181 );
182
183/** informs constraint handler that the branch and bound process data is being freed */
185 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
186 BMS_BLKMEM* blkmem, /**< block memory */
187 SCIP_SET* set, /**< global SCIP settings */
188 SCIP_STAT* stat, /**< dynamic problem statistics */
189 SCIP_Bool restart /**< was this exit solve call triggered by a restart? */
190 );
191
192/** calls LP initialization method of constraint handler to separate all initial active constraints */
194 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
195 BMS_BLKMEM* blkmem, /**< block memory */
196 SCIP_SET* set, /**< global SCIP settings */
197 SCIP_STAT* stat, /**< dynamic problem statistics */
198 SCIP_TREE* tree, /**< branch and bound tree */
199 SCIP_Bool initkeptconss, /**< Also initialize constraints which are valid at a more global node,
200 * but were not activated there? Should be FALSE for repeated calls at
201 * one node or if the current focusnode is a child of the former one */
202 SCIP_Bool* cutoff /**< pointer to store whether infeasibility was detected while building the LP */
203 );
204
205/** calls separator method of constraint handler to separate LP solution */
207 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
208 BMS_BLKMEM* blkmem, /**< block memory */
209 SCIP_SET* set, /**< global SCIP settings */
210 SCIP_STAT* stat, /**< dynamic problem statistics */
211 SCIP_SEPASTORE* sepastore, /**< separation storage */
212 int depth, /**< depth of current node */
213 SCIP_Bool execdelayed, /**< execute separation method even if it is marked to be delayed */
214 SCIP_RESULT* result /**< pointer to store the result of the callback method */
215 );
216
217/** calls separator method of constraint handler to separate given primal solution */
219 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
220 BMS_BLKMEM* blkmem, /**< block memory */
221 SCIP_SET* set, /**< global SCIP settings */
222 SCIP_STAT* stat, /**< dynamic problem statistics */
223 SCIP_SEPASTORE* sepastore, /**< separation storage */
224 SCIP_SOL* sol, /**< primal solution that should be separated */
225 int depth, /**< depth of current node */
226 SCIP_Bool execdelayed, /**< execute separation method even if it is marked to be delayed */
227 SCIP_RESULT* result /**< pointer to store the result of the callback method */
228 );
229
230/** calls enforcing method of constraint handler for a relaxation solution for all constraints added after last
231 * conshdlrResetEnfo() call
232 */
234 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
235 BMS_BLKMEM* blkmem, /**< block memory */
236 SCIP_SET* set, /**< global SCIP settings */
237 SCIP_STAT* stat, /**< dynamic problem statistics */
238 SCIP_TREE* tree, /**< branch and bound tree */
239 SCIP_SEPASTORE* sepastore, /**< separation storage */
240 SCIP_SOL* relaxsol, /**< solution to be enforced */
241 SCIP_Bool solinfeasible, /**< was the solution already found out to be infeasible? */
242 SCIP_RESULT* result /**< pointer to store the result of the callback method */
243 );
244
245/** calls enforcing method of constraint handler for LP solution for all constraints added after last
246 * conshdlrReset() call
247 */
249 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
250 BMS_BLKMEM* blkmem, /**< block memory */
251 SCIP_SET* set, /**< global SCIP settings */
252 SCIP_STAT* stat, /**< dynamic problem statistics */
253 SCIP_TREE* tree, /**< branch and bound tree */
254 SCIP_SEPASTORE* sepastore, /**< separation storage */
255 SCIP_Bool solinfeasible, /**< was the solution already found out to be infeasible? */
256 SCIP_RESULT* result /**< pointer to store the result of the callback method */
257 );
258
259/** calls diving solution enforcement callback of constraint handler, if it exists */
261 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
262 SCIP_SET* set, /**< global SCIP settings */
263 SCIP_DIVESET* diveset, /**< diving settings to control scoring */
264 SCIP_SOL* sol, /**< current solution of diving mode */
265 SCIP_Bool* success, /**< pointer to store whether constraint handler successfully found a variable */
266 SCIP_Bool* infeasible /**< pointer to store whether the current node was detected to be infeasible */
267 );
268
269/** calls enforcing method of constraint handler for pseudo solution for all constraints added after last
270 * conshdlrReset() call
271 */
273 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
274 BMS_BLKMEM* blkmem, /**< block memory */
275 SCIP_SET* set, /**< global SCIP settings */
276 SCIP_STAT* stat, /**< dynamic problem statistics */
277 SCIP_TREE* tree, /**< branch and bound tree */
278 SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */
279 SCIP_Bool solinfeasible, /**< was the solution already found out to be infeasible? */
280 SCIP_Bool objinfeasible, /**< is the solution infeasible anyway due to violating lower objective bound? */
281 SCIP_Bool forced, /**< should enforcement of pseudo solution be forced? */
282 SCIP_RESULT* result /**< pointer to store the result of the callback method */
283 );
284
285/** calls feasibility check method of constraint handler */
287 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
288 BMS_BLKMEM* blkmem, /**< block memory */
289 SCIP_SET* set, /**< global SCIP settings */
290 SCIP_STAT* stat, /**< dynamic problem statistics */
291 SCIP_SOL* sol, /**< primal CIP solution */
292 SCIP_Bool checkintegrality, /**< Has integrality to be checked? */
293 SCIP_Bool checklprows, /**< Do constraints represented by rows in the current LP have to be checked? */
294 SCIP_Bool printreason, /**< Should the reason for the violation be printed? */
295 SCIP_Bool completely, /**< Should all violations be checked? */
296 SCIP_RESULT* result /**< pointer to store the result of the callback method */
297 );
298
299/** calls propagation method of constraint handler */
301 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
302 BMS_BLKMEM* blkmem, /**< block memory */
303 SCIP_SET* set, /**< global SCIP settings */
304 SCIP_STAT* stat, /**< dynamic problem statistics */
305 int depth, /**< depth of current node; -1 if preprocessing domain propagation */
306 SCIP_Bool fullpropagation, /**< should all constraints be propagated (or only new ones)? */
307 SCIP_Bool execdelayed, /**< execute propagation method even if it is marked to be delayed */
308 SCIP_Bool instrongbranching, /**< are we currently doing strong branching? */
309 SCIP_PROPTIMING proptiming, /**< current point in the node solving process */
310 SCIP_RESULT* result /**< pointer to store the result of the callback method */
311 );
312
313/** calls presolving method of constraint handler */
315 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
316 BMS_BLKMEM* blkmem, /**< block memory */
317 SCIP_SET* set, /**< global SCIP settings */
318 SCIP_STAT* stat, /**< dynamic problem statistics */
319 SCIP_PRESOLTIMING timing, /**< current presolving timing */
320 int nrounds, /**< number of presolving rounds already done */
321 int* nfixedvars, /**< pointer to total number of variables fixed of all presolvers */
322 int* naggrvars, /**< pointer to total number of variables aggregated of all presolvers */
323 int* nchgvartypes, /**< pointer to total number of variable type changes of all presolvers */
324 int* nchgbds, /**< pointer to total number of variable bounds tightened of all presolvers */
325 int* naddholes, /**< pointer to total number of domain holes added of all presolvers */
326 int* ndelconss, /**< pointer to total number of deleted constraints of all presolvers */
327 int* naddconss, /**< pointer to total number of added constraints of all presolvers */
328 int* nupgdconss, /**< pointer to total number of upgraded constraints of all presolvers */
329 int* nchgcoefs, /**< pointer to total number of changed coefficients of all presolvers */
330 int* nchgsides, /**< pointer to total number of changed left/right hand sides of all presolvers */
331 SCIP_RESULT* result /**< pointer to store the result of the callback method */
332 );
333
334/** enables or disables all clocks of \p conshdlr, depending on the value of the flag */
336 SCIP_CONSHDLR* conshdlr, /**< the constraint handler for which all clocks should be enabled or disabled */
337 SCIP_Bool enable /**< should the clocks of the constraint handler be enabled? */
338 );
339
340/** calls variable deletion method of constraint handler */
342 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
343 BMS_BLKMEM* blkmem, /**< block memory */
344 SCIP_SET* set, /**< global SCIP settings */
345 SCIP_STAT* stat /**< dynamic problem statistics */
346 );
347
348
349/** locks rounding of variables involved in the given constraint constraint handler that doesn't need constraints */
351 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
352 SCIP_SET* set /**< global SCIP settings */
353 );
354
355/** unlocks rounding of variables involved in the given constraint constraint handler that doesn't need constraints */
357 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
358 SCIP_SET* set /**< global SCIP settings */
359 );
360
361/**
362 * callback setter methods of constraint handlers
363 */
364
365/** sets copy method of both the constraint handler and each associated constraint */
367 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
368 SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), /**< copy method of constraint handler or NULL if you don't want to copy your plugin into sub-SCIPs */
369 SCIP_DECL_CONSCOPY ((*conscopy)) /**< constraint copying method */
370 );
371
372/** sets destructor method of constraint handler */
374 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
375 SCIP_DECL_CONSFREE ((*consfree)) /**< destructor of constraint handler */
376 );
377
378/** sets initialization method of constraint handler */
380 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
381 SCIP_DECL_CONSINIT ((*consinit)) /**< initialize constraint handler */
382 );
383
384/** sets deinitialization method of constraint handler */
386 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
387 SCIP_DECL_CONSEXIT ((*consexit)) /**< deinitialize constraint handler */
388 );
389
390/** sets solving process initialization method of constraint handler */
392 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
393 SCIP_DECL_CONSINITSOL((*consinitsol)) /**< solving process initialization method of constraint handler */
394 );
395
396/** sets solving process deinitialization method of constraint handler */
398 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
399 SCIP_DECL_CONSEXITSOL ((*consexitsol)) /**< solving process deinitialization method of constraint handler */
400 );
401
402/** sets preprocessing initialization method of constraint handler */
404 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
405 SCIP_DECL_CONSINITPRE((*consinitpre)) /**< preprocessing initialization method of constraint handler */
406 );
407
408/** sets preprocessing deinitialization method of constraint handler */
410 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
411 SCIP_DECL_CONSEXITPRE((*consexitpre)) /**< preprocessing deinitialization method of constraint handler */
412 );
413
414/** sets presolving method of constraint handler */
416 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
417 SCIP_DECL_CONSPRESOL ((*conspresol)), /**< presolving method of constraint handler */
418 int maxprerounds, /**< maximal number of presolving rounds the constraint handler participates in (-1: no limit) */
419 SCIP_PRESOLTIMING presoltiming /**< timing mask of the constraint handler's presolving method */
420 );
421
422/** sets method of constraint handler to free specific constraint data */
424 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
425 SCIP_DECL_CONSDELETE ((*consdelete)) /**< free specific constraint data */
426 );
427
428/** sets method of constraint handler to transform constraint data into data belonging to the transformed problem */
430 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
431 SCIP_DECL_CONSTRANS ((*constrans)) /**< transform constraint data into data belonging to the transformed problem */
432 );
433
434/** sets method of constraint handler to initialize LP with relaxations of "initial" constraints */
436 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
437 SCIP_DECL_CONSINITLP ((*consinitlp)) /**< initialize LP with relaxations of "initial" constraints */
438 );
439
440/** sets propagation conflict resolving method of constraint handler */
442 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
443 SCIP_DECL_CONSRESPROP ((*consresprop)) /**< propagation conflict resolving method */
444 );
445
446/** sets activation notification method of constraint handler */
448 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
449 SCIP_DECL_CONSACTIVE ((*consactive)) /**< activation notification method */
450 );
451
452/** sets deactivation notification method of constraint handler */
454 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
455 SCIP_DECL_CONSDEACTIVE((*consdeactive)) /**< deactivation notification method */
456 );
457
458/** sets enabling notification method of constraint handler */
460 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
461 SCIP_DECL_CONSENABLE ((*consenable)) /**< enabling notification method */
462 );
463
464/** sets disabling notification method of constraint handler */
466 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
467 SCIP_DECL_CONSDISABLE ((*consdisable)) /**< disabling notification method */
468 );
469
470/** sets variable deletion method of constraint handler */
472 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
473 SCIP_DECL_CONSDELVARS ((*consdelvars)) /**< variable deletion method */
474 );
475
476/** sets constraint display method of constraint handler */
478 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
479 SCIP_DECL_CONSPRINT ((*consprint)) /**< constraint display method */
480 );
481
482/** sets constraint parsing method of constraint handler */
484 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
485 SCIP_DECL_CONSPARSE ((*consparse)) /**< constraint parsing method */
486 );
487
488/** sets constraint variable getter method of constraint handler */
490 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
491 SCIP_DECL_CONSGETVARS ((*consgetvars)) /**< constraint variable getter method */
492 );
493
494/** sets constraint variable number getter method of constraint handler */
496 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
497 SCIP_DECL_CONSGETNVARS((*consgetnvars)) /**< constraint variable number getter method */
498 );
499
500/** sets diving enforcement method of constraint handler */
502 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
503 SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs)) /**< constraint handler diving solution enforcement method */
504 );
505
506/** sets permutation symmetry detection graph getter method of constraint handler */
508 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
509 SCIP_DECL_CONSGETPERMSYMGRAPH((*consgetpermsymgraph)) /**< constraint permutation symmetry detection graph
510 * getter method */
511 );
512
513/** sets signed permutation symmetry detection graph getter method of constraint handler */
515 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
516 SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH((*consgetsignedpermsymgraph)) /**< constraint permutation symmetry detection
517 * graph getter method */
518 );
519
520/*
521 * Constraint set change methods
522 */
523
524/** frees constraint set change data and releases all included constraints */
526 SCIP_CONSSETCHG** conssetchg, /**< pointer to constraint set change */
527 BMS_BLKMEM* blkmem, /**< block memory */
528 SCIP_SET* set /**< global SCIP settings */
529 );
530
531/** adds constraint addition to constraint set changes, and captures constraint; activates constraint if the
532 * constraint set change data is currently active
533 */
535 SCIP_CONSSETCHG** conssetchg, /**< pointer to constraint set change data structure */
536 BMS_BLKMEM* blkmem, /**< block memory */
537 SCIP_SET* set, /**< global SCIP settings */
538 SCIP_STAT* stat, /**< dynamic problem statistics */
539 SCIP_CONS* cons, /**< added constraint */
540 int depth, /**< depth of constraint set change's node */
541 SCIP_Bool focusnode, /**< does the constraint set change belong to the focus node? */
542 SCIP_Bool active /**< is the constraint set change currently active? */
543 );
544
545/** adds constraint disabling to constraint set changes, and captures constraint */
547 SCIP_CONSSETCHG** conssetchg, /**< pointer to constraint set change data structure */
548 BMS_BLKMEM* blkmem, /**< block memory */
549 SCIP_SET* set, /**< global SCIP settings */
550 SCIP_CONS* cons /**< disabled constraint */
551 );
552
553/** applies constraint set change */
555 SCIP_CONSSETCHG* conssetchg, /**< constraint set change to apply */
556 BMS_BLKMEM* blkmem, /**< block memory */
557 SCIP_SET* set, /**< global SCIP settings */
558 SCIP_STAT* stat, /**< dynamic problem statistics */
559 int depth, /**< depth of constraint set change's node */
560 SCIP_Bool focusnode /**< does the constraint set change belong to the focus node? */
561 );
562
563/** undoes constraint set change */
565 SCIP_CONSSETCHG* conssetchg, /**< constraint set change to undo */
566 BMS_BLKMEM* blkmem, /**< block memory */
567 SCIP_SET* set, /**< global SCIP settings */
568 SCIP_STAT* stat /**< dynamic problem statistics */
569 );
570
571/** applies constraint set change to the global problem and deletes the constraint set change data */
573 SCIP_CONSSETCHG** conssetchg, /**< pointer to constraint set change data */
574 BMS_BLKMEM* blkmem, /**< block memory */
575 SCIP_SET* set, /**< global SCIP settings */
576 SCIP_STAT* stat, /**< dynamic problem statistics */
577 SCIP_PROB* prob, /**< problem data */
578 SCIP_REOPT* reopt /**< reoptimization data */
579 );
580
581/** increase count of applied cuts */
583 SCIP_CONSHDLR* conshdlr /**< constraint handler */
584 );
585
586/** increase count of found cuts */
588 SCIP_CONSHDLR* conshdlr /**< constraint handler */
589 );
590
591
592
593/*
594 * Constraint methods
595 */
596
597/** creates and captures a constraint, and inserts it into the conss array of its constraint handler
598 *
599 * @warning If a constraint is marked to be checked for feasibility but not to be enforced, a LP or pseudo solution
600 * may be declared feasible even if it violates this particular constraint.
601 * This constellation should only be used, if no LP or pseudo solution can violate the constraint -- e.g. if a
602 * local constraint is redundant due to the variable's local bounds.
603 */
605 SCIP_CONS** cons, /**< pointer to constraint */
606 BMS_BLKMEM* blkmem, /**< block memory */
607 SCIP_SET* set, /**< global SCIP settings */
608 const char* name, /**< name of constraint */
609 SCIP_CONSHDLR* conshdlr, /**< constraint handler for this constraint */
610 SCIP_CONSDATA* consdata, /**< data for this specific constraint */
611 SCIP_Bool initial, /**< should the LP relaxation of constraint be in the initial LP?
612 * Usually set to TRUE. Set to FALSE for 'lazy constraints'. */
613 SCIP_Bool separate, /**< should the constraint be separated during LP processing?
614 * Usually set to TRUE. */
615 SCIP_Bool enforce, /**< should the constraint be enforced during node processing?
616 * TRUE for model constraints, FALSE for additional, redundant constraints. */
617 SCIP_Bool check, /**< should the constraint be checked for feasibility?
618 * TRUE for model constraints, FALSE for additional, redundant constraints. */
619 SCIP_Bool propagate, /**< should the constraint be propagated during node processing?
620 * Usually set to TRUE. */
621 SCIP_Bool local, /**< is constraint only valid locally?
622 * Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints. */
623 SCIP_Bool modifiable, /**< is constraint modifiable (subject to column generation)?
624 * Usually set to FALSE. In column generation applications, set to TRUE if pricing
625 * adds coefficients to this constraint. */
626 SCIP_Bool dynamic, /**< is constraint subject to aging?
627 * Usually set to FALSE. Set to TRUE for own cuts which
628 * are separated as constraints. */
629 SCIP_Bool removable, /**< should the relaxation be removed from the LP due to aging or cleanup?
630 * Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'. */
631 SCIP_Bool stickingatnode, /**< should the constraint always be kept at the node where it was added, even
632 * if it may be moved to a more global node?
633 * Usually set to FALSE. Set to TRUE to for constraints that represent node data. */
634 SCIP_Bool original, /**< is constraint belonging to the original problem? */
635 SCIP_Bool deleteconsdata /**< has the constraint data to be deleted if constraint is freed? */
636 );
637
638/** copies source constraint of source SCIP into the target constraint for the target SCIP, using the variable map for
639 * mapping the variables of the source SCIP to the variables of the target SCIP; if the copying process was successful
640 * a constraint is created and captured;
641 *
642 * @warning If a constraint is marked to be checked for feasibility but not to be enforced, an LP or pseudo solution
643 * may be declared feasible even if it violates this particular constraint.
644 * This constellation should only be used, if no LP or pseudo solution can violate the constraint -- e.g. if a
645 * local constraint is redundant due to the variable's local bounds.
646 */
648 SCIP_CONS** cons, /**< pointer to store the created target constraint */
649 SCIP_SET* set, /**< global SCIP settings of the target SCIP */
650 const char* name, /**< name of constraint, or NULL if the name of the source constraint should be used */
651 SCIP* sourcescip, /**< source SCIP data structure */
652 SCIP_CONSHDLR* sourceconshdlr, /**< source constraint handler for this constraint */
653 SCIP_CONS* sourcecons, /**< source constraint of the source SCIP */
654 SCIP_HASHMAP* varmap, /**< a SCIP_HASHMAP mapping variables of the source SCIP to corresponding
655 * variables of the target SCIP */
656 SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
657 * target constraints, must not be NULL! */
658 SCIP_Bool initial, /**< should the LP relaxation of constraint be in the initial LP? */
659 SCIP_Bool separate, /**< should the constraint be separated during LP processing? */
660 SCIP_Bool enforce, /**< should the constraint be enforced during node processing? */
661 SCIP_Bool check, /**< should the constraint be checked for feasibility? */
662 SCIP_Bool propagate, /**< should the constraint be propagated during node processing? */
663 SCIP_Bool local, /**< is constraint only valid locally? */
664 SCIP_Bool modifiable, /**< is constraint modifiable (subject to column generation)? */
665 SCIP_Bool dynamic, /**< is constraint subject to aging? */
666 SCIP_Bool removable, /**< should the relaxation be removed from the LP due to aging or cleanup? */
667 SCIP_Bool stickingatnode, /**< should the constraint always be kept at the node where it was added, even
668 * if it may be moved to a more global node? */
669 SCIP_Bool global, /**< create a global or a local copy? */
670 SCIP_Bool* valid /**< pointer to store whether the copying was valid or not */
671 );
672
673/** parses constraint information (in cip format) out of a string; if the parsing process was successful a constraint is
674 * created, captured, and inserted into the conss array of its constraint handler.
675 *
676 * @warning If a constraint is marked to be checked for feasibility but not to be enforced, an LP or pseudo solution
677 * may be declared feasible even if it violates this particular constraint.
678 * This constellation should only be used, if no LP or pseudo solution can violate the constraint -- e.g. if a
679 * local constraint is redundant due to the variable's local bounds.
680 */
682 SCIP_CONS** cons, /**< pointer to constraint */
683 SCIP_SET* set, /**< global SCIP settings */
684 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler of target SCIP */
685 const char* str, /**< name of constraint */
686 SCIP_Bool initial, /**< should the LP relaxation of constraint be in the initial LP?
687 * Usually set to TRUE. Set to FALSE for 'lazy constraints'. */
688 SCIP_Bool separate, /**< should the constraint be separated during LP processing?
689 * Usually set to TRUE. */
690 SCIP_Bool enforce, /**< should the constraint be enforced during node processing?
691 * TRUE for model constraints, FALSE for additional, redundant constraints. */
692 SCIP_Bool check, /**< should the constraint be checked for feasibility?
693 * TRUE for model constraints, FALSE for additional, redundant constraints. */
694 SCIP_Bool propagate, /**< should the constraint be propagated during node processing?
695 * Usually set to TRUE. */
696 SCIP_Bool local, /**< is constraint only valid locally?
697 * Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints. */
698 SCIP_Bool modifiable, /**< is constraint modifiable (subject to column generation)?
699 * Usually set to FALSE. In column generation applications, set to TRUE if pricing
700 * adds coefficients to this constraint. */
701 SCIP_Bool dynamic, /**< is constraint subject to aging?
702 * Usually set to FALSE. Set to TRUE for own cuts which
703 * are separated as constraints. */
704 SCIP_Bool removable, /**< should the relaxation be removed from the LP due to aging or cleanup?
705 * Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'. */
706 SCIP_Bool stickingatnode, /**< should the constraint always be kept at the node where it was added, even
707 * if it may be moved to a more global node?
708 * Usually set to FALSE. Set to TRUE to for constraints that represent node data. */
709 SCIP_Bool* success /**< pointer store if the paring process was successful */
710 );
711
712/** change name of given constraint */
714 SCIP_CONS* cons, /**< problem constraint */
715 BMS_BLKMEM* blkmem, /**< block memory buffer */
716 const char* name /**< new name of constraint */
717 );
718
719/** frees a constraint and removes it from the conss array of its constraint handler */
721 SCIP_CONS** cons, /**< constraint to free */
722 BMS_BLKMEM* blkmem, /**< block memory buffer */
723 SCIP_SET* set /**< global SCIP settings */
724 );
725
726/** increases usage counter of constraint */
727void SCIPconsCapture(
728 SCIP_CONS* cons /**< constraint */
729 );
730
731/** decreases usage counter of constraint, and frees memory if necessary */
733 SCIP_CONS** cons, /**< pointer to constraint */
734 BMS_BLKMEM* blkmem, /**< block memory */
735 SCIP_SET* set /**< global SCIP settings */
736 );
737
738
739/** outputs constraint information to file stream */
741 SCIP_CONS* cons, /**< constraint to print */
742 SCIP_SET* set, /**< global SCIP settings */
743 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
744 FILE* file /**< output file (or NULL for standard output) */
745 );
746
747/** checks single constraint for feasibility of the given solution */
749 SCIP_CONS* cons, /**< constraint to check */
750 SCIP_SET* set, /**< global SCIP settings */
751 SCIP_SOL* sol, /**< primal CIP solution */
752 SCIP_Bool checkintegrality, /**< Has integrality to be checked? */
753 SCIP_Bool checklprows, /**< Do constraints represented by rows in the current LP have to be checked? */
754 SCIP_Bool printreason, /**< Should the reason for the violation be printed? */
755 SCIP_RESULT* result /**< pointer to store the result of the callback method */
756 );
757
758/** enforces single constraint for a given pseudo solution */
760 SCIP_CONS* cons, /**< constraint to enforce */
761 SCIP_SET* set, /**< global SCIP settings */
762 SCIP_Bool solinfeasible, /**< was the solution already declared infeasible by a constraint handler? */
763 SCIP_Bool objinfeasible, /**< is the solution infeasible anyway due to violating lower objective bound? */
764 SCIP_RESULT* result /**< pointer to store the result of the callback method */
765 );
766
767/** enforces single constraint for a given LP solution */
769 SCIP_CONS* cons, /**< constraint to enforce */
770 SCIP_SET* set, /**< global SCIP settings */
771 SCIP_Bool solinfeasible, /**< was the solution already declared infeasible by a constraint handler? */
772 SCIP_RESULT* result /**< pointer to store the result of the callback method */
773 );
774
775/** enforces single constraint for a given relaxation solution */
777 SCIP_CONS* cons, /**< constraint to enforce */
778 SCIP_SET* set, /**< global SCIP settings */
779 SCIP_SOL* sol, /**< solution to be enforced */
780 SCIP_Bool solinfeasible, /**< was the solution already declared infeasible by a constraint handler? */
781 SCIP_RESULT* result /**< pointer to store the result of the callback method */
782 );
783
784/** calls LP initialization method for single constraint */
786 SCIP_CONS* cons, /**< constraint to initialize */
787 SCIP_SET* set, /**< global SCIP settings */
788 SCIP_Bool* infeasible /**< pointer to store whether infeasibility was detected while building the LP */
789 );
790
791/** calls separation method of single constraint for LP solution */
793 SCIP_CONS* cons, /**< constraint to separate */
794 SCIP_SET* set, /**< global SCIP settings */
795 SCIP_RESULT* result /**< pointer to store the result of the separation call */
796 );
797
798/** calls separation method of single constraint for given primal solution */
800 SCIP_CONS* cons, /**< constraint to separate */
801 SCIP_SET* set, /**< global SCIP settings */
802 SCIP_SOL* sol, /**< primal solution that should be separated */
803 SCIP_RESULT* result /**< pointer to store the result of the separation call */
804 );
805
806/** calls domain propagation method of single constraint */
808 SCIP_CONS* cons, /**< constraint to propagate */
809 SCIP_SET* set, /**< global SCIP settings */
810 SCIP_PROPTIMING proptiming, /**< current point in the node solving loop */
811 SCIP_RESULT* result /**< pointer to store the result of the callback method */
812 );
813
814/** resolves propagation conflict of single constraint */
816 SCIP_CONS* cons, /**< constraint to resolve conflict for */
817 SCIP_SET* set, /**< global SCIP settings */
818 SCIP_VAR* infervar, /**< the conflict variable whose bound change has to be resolved */
819 int inferinfo, /**< the user information passed to the corresponding SCIPinferVarLbCons() or SCIPinferVarUbCons() call */
820 SCIP_BOUNDTYPE boundtype, /**< the type of the changed bound (lower or upper bound) */
821 SCIP_BDCHGIDX* bdchgidx, /**< the index of the bound change, representing the point of time where the change took place */
822 SCIP_Real relaxedbd, /**< the relaxed bound which is sufficient to be explained */
823 SCIP_RESULT* result /**< pointer to store the result of the callback method */
824 );
825
826/** presolves single constraint */
828 SCIP_CONS* cons, /**< constraint to presolve */
829 SCIP_SET* set, /**< global SCIP settings */
830 int nrounds, /**< number of presolving rounds already done */
831 SCIP_PRESOLTIMING timing, /**< current presolving timing */
832 int nnewfixedvars, /**< number of variables fixed since the last call to the presolving method */
833 int nnewaggrvars, /**< number of variables aggregated since the last call to the presolving method */
834 int nnewchgvartypes, /**< number of variable type changes since the last call to the presolving method */
835 int nnewchgbds, /**< number of variable bounds tightened since the last call to the presolving method */
836 int nnewholes, /**< number of domain holes added since the last call to the presolving method */
837 int nnewdelconss, /**< number of deleted constraints since the last call to the presolving method */
838 int nnewaddconss, /**< number of added constraints since the last call to the presolving method */
839 int nnewupgdconss, /**< number of upgraded constraints since the last call to the presolving method */
840 int nnewchgcoefs, /**< number of changed coefficients since the last call to the presolving method */
841 int nnewchgsides, /**< number of changed left or right hand sides since the last call to the presolving method */
842 int* nfixedvars, /**< pointer to count total number of variables fixed of all presolvers */
843 int* naggrvars, /**< pointer to count total number of variables aggregated of all presolvers */
844 int* nchgvartypes, /**< pointer to count total number of variable type changes of all presolvers */
845 int* nchgbds, /**< pointer to count total number of variable bounds tightened of all presolvers */
846 int* naddholes, /**< pointer to count total number of domain holes added of all presolvers */
847 int* ndelconss, /**< pointer to count total number of deleted constraints of all presolvers */
848 int* naddconss, /**< pointer to count total number of added constraints of all presolvers */
849 int* nupgdconss, /**< pointer to count total number of upgraded constraints of all presolvers */
850 int* nchgcoefs, /**< pointer to count total number of changed coefficients of all presolvers */
851 int* nchgsides, /**< pointer to count total number of changed left/right hand sides of all presolvers */
852 SCIP_RESULT* result /**< pointer to store the result of the callback method */
853 );
854
855/** calls constraint activation notification method of single constraint */
857 SCIP_CONS* cons, /**< constraint to notify */
858 SCIP_SET* set /**< global SCIP settings */
859 );
860
861/** calls constraint deactivation notification method of single constraint */
863 SCIP_CONS* cons, /**< constraint to notify */
864 SCIP_SET* set /**< global SCIP settings */
865 );
866
867/** method to collect the variables of a constraint
868 *
869 * If the number of variables is greater than the available slots in the variable array, nothing happens except that
870 * the success point is set to FALSE. With the method SCIPgetConsNVars() it is possible to get the number of variables
871 * a constraint has in its scope.
872 *
873 * @note The success pointer indicates if all variables were copied into the vars arrray.
874 *
875 * @note It might be that a constraint handler does not support this functionality, in that case the success pointer is
876 * set to FALSE.
877 */
879 SCIP_CONS* cons, /**< constraint to get variables for */
880 SCIP_SET* set, /**< global SCIP settings */
881 SCIP_VAR** vars, /**< array to store the involved variable of the constraint */
882 int varssize, /**< available slots in vars array which is needed to check if the array is large enough */
883 SCIP_Bool* success /**< pointer to store whether the variables are successfully copied */
884 );
885
886/** method to collect the number of variables of a constraint
887 *
888 * @note The success pointer indicates if the contraint handler was able to return the number of variables
889 *
890 * @note It might be that a constraint handler does not support this functionality, in that case the success pointer is
891 * set to FALSE
892 */
894 SCIP_CONS* cons, /**< constraint to get number of variables for */
895 SCIP_SET* set, /**< global SCIP settings */
896 int* nvars, /**< pointer to store the number of variables */
897 SCIP_Bool* success /**< pointer to store whether the constraint successfully returned the number of variables */
898 );
899
900/** method to collect the permutation symmetry detection graph of a constraint
901 *
902 * @note The success pointer indicates if the contraint handler was able to return the graph.
903 *
904 * @note If a constraint handler does not support this functionality, the success pointer is set to FALSE.
905 */
907 SCIP_CONS* cons, /**< constraint to get graph for */
908 SCIP_SET* set, /**< global SCIP settings */
909 SYM_GRAPH* graph, /**< symmetry detection graph */
910 SCIP_Bool* success /**< pointer to store whether the constraint successfully returned the graph */
911 );
912
913/** method to collect the signed permutation symmetry detection graph of a constraint
914 *
915 * @note The success pointer indicates whether the constraint handler was able to return the graph.
916 *
917 * @note If a constraint handler does not support this functionality, the success pointer is set to FALSE.
918 */
920 SCIP_CONS* cons, /**< constraint to get graph for */
921 SCIP_SET* set, /**< global SCIP settings */
922 SYM_GRAPH* graph, /**< symmetry detection graph */
923 SCIP_Bool* success /**< pointer to store whether the constraint successfully returned the graph */
924 );
925
926/** globally removes constraint from all subproblems; removes constraint from the constraint set change data of the
927 * node, where it was created, or from the problem, if it was a problem constraint
928 */
930 SCIP_CONS* cons, /**< constraint to delete */
931 BMS_BLKMEM* blkmem, /**< block memory */
932 SCIP_SET* set, /**< global SCIP settings */
933 SCIP_STAT* stat, /**< dynamic problem statistics */
934 SCIP_PROB* prob, /**< problem data */
935 SCIP_REOPT* reopt /**< reoptimization data */
936 );
937
938/** gets and captures transformed constraint of a given constraint; if the constraint is not yet transformed,
939 * a new transformed constraint for this constraint is created
940 */
942 SCIP_CONS* origcons, /**< original constraint */
943 BMS_BLKMEM* blkmem, /**< block memory buffer */
944 SCIP_SET* set, /**< global SCIP settings */
945 SCIP_CONS** transcons /**< pointer to store the transformed constraint */
946 );
947
948/** sets the initial flag of the given constraint */
950 SCIP_CONS* cons, /**< constraint */
951 SCIP_SET* set, /**< global SCIP settings */
952 SCIP_STAT* stat, /**< dynamic problem statistics */
953 SCIP_Bool initial /**< new value */
954 );
955
956/** sets the separate flag of the given constraint */
958 SCIP_CONS* cons, /**< constraint */
959 SCIP_SET* set, /**< global SCIP settings */
960 SCIP_Bool separate /**< new value */
961 );
962
963/** sets the enforce flag of the given constraint */
965 SCIP_CONS* cons, /**< constraint */
966 SCIP_SET* set, /**< global SCIP settings */
967 SCIP_Bool enforce /**< new value */
968 );
969
970/** sets the check flag of the given constraint */
972 SCIP_CONS* cons, /**< constraint */
973 SCIP_SET* set, /**< global SCIP settings */
974 SCIP_Bool check /**< new value */
975 );
976
977/** sets the propagate flag of the given constraint */
979 SCIP_CONS* cons, /**< constraint */
980 SCIP_SET* set, /**< global SCIP settings */
981 SCIP_Bool propagate /**< new value */
982 );
983
984/** sets the local flag of the given constraint */
986 SCIP_CONS* cons, /**< constraint */
987 SCIP_Bool local /**< new value */
988 );
989
990/** sets the modifiable flag of the given constraint */
992 SCIP_CONS* cons, /**< constraint */
993 SCIP_Bool modifiable /**< new value */
994 );
995
996/** sets the dynamic flag of the given constraint */
998 SCIP_CONS* cons, /**< constraint */
999 SCIP_Bool dynamic /**< new value */
1000 );
1001
1002/** sets the removable flag of the given constraint */
1004 SCIP_CONS* cons, /**< constraint */
1005 SCIP_Bool removable /**< new value */
1006 );
1007
1008/** sets the stickingatnode flag of the given constraint */
1010 SCIP_CONS* cons, /**< constraint */
1011 SCIP_Bool stickingatnode /**< new value */
1012 );
1013
1014/** gives the constraint a new name; ATTENTION: to old pointer is over written that might
1015 * result in a memory leakage */
1017 SCIP_CONS* cons, /**< constraint */
1018 const char* name /**< new name of constraint */
1019 );
1020
1021/** gets associated transformed constraint of an original constraint, or NULL if no associated transformed constraint
1022 * exists
1023 */
1025 SCIP_CONS* cons /**< constraint */
1026 );
1027
1028/** activates constraint or marks constraint to be activated in next update */
1030 SCIP_CONS* cons, /**< constraint */
1031 SCIP_SET* set, /**< global SCIP settings */
1032 SCIP_STAT* stat, /**< dynamic problem statistics */
1033 int depth, /**< depth in the tree where the constraint activation takes place, or -1 for global problem */
1034 SCIP_Bool focusnode /**< does the constraint activation take place at the focus node? */
1035 );
1036
1037/** deactivates constraint or marks constraint to be deactivated in next update */
1039 SCIP_CONS* cons, /**< constraint */
1040 SCIP_SET* set, /**< global SCIP settings */
1041 SCIP_STAT* stat /**< dynamic problem statistics */
1042 );
1043
1044/** enables constraint's separation, enforcing, and propagation capabilities or marks them to be enabled in next update */
1046 SCIP_CONS* cons, /**< constraint */
1047 SCIP_SET* set, /**< global SCIP settings */
1048 SCIP_STAT* stat /**< dynamic problem statistics */
1049 );
1050
1051/** disables constraint's separation, enforcing, and propagation capabilities or marks them to be disabled in next update */
1053 SCIP_CONS* cons, /**< constraint */
1054 SCIP_SET* set, /**< global SCIP settings */
1055 SCIP_STAT* stat /**< dynamic problem statistics */
1056 );
1057
1058/** enables constraint's separation capabilities or marks them to be enabled in next update */
1060 SCIP_CONS* cons, /**< constraint */
1061 SCIP_SET* set /**< global SCIP settings */
1062 );
1063
1064/** disables constraint's separation capabilities or marks them to be disabled in next update */
1066 SCIP_CONS* cons, /**< constraint */
1067 SCIP_SET* set /**< global SCIP settings */
1068 );
1069
1070/** enables constraint's propagation capabilities or marks them to be enabled in next update */
1072 SCIP_CONS* cons, /**< constraint */
1073 SCIP_SET* set /**< global SCIP settings */
1074 );
1075
1076/** disables constraint's propagation capabilities or marks them to be disabled in next update */
1078 SCIP_CONS* cons, /**< constraint */
1079 SCIP_SET* set /**< global SCIP settings */
1080 );
1081
1082/** marks the constraint to be a conflict */
1084 SCIP_CONS* cons /**< constraint */
1085 );
1086
1087/** marks the constraint to be propagated (update might be delayed) */
1088SCIP_EXPORT
1090 SCIP_CONS* cons, /**< constraint */
1091 SCIP_SET* set /**< global SCIP settings */
1092 );
1093
1094/** unmarks the constraint to be propagated (update might be delayed) */
1096 SCIP_CONS* cons, /**< constraint */
1097 SCIP_SET* set /**< global SCIP settings */
1098 );
1099
1100/** adds given value to age of constraint, but age can never become negative;
1101 * should be called
1102 * - in constraint separation, if no cut was found for this constraint,
1103 * - in constraint enforcing, if constraint was feasible, and
1104 * - in constraint propagation, if no domain reduction was deduced;
1105 * if it's age exceeds the constraint age limit, makes constraint obsolete or marks constraint to be made obsolete
1106 * in next update
1107 */
1109 SCIP_CONS* cons, /**< constraint */
1110 BMS_BLKMEM* blkmem, /**< block memory */
1111 SCIP_SET* set, /**< global SCIP settings */
1112 SCIP_STAT* stat, /**< dynamic problem statistics */
1113 SCIP_PROB* prob, /**< problem data */
1114 SCIP_Real deltaage, /**< value to add to the constraint's age */
1115 SCIP_REOPT* reopt /**< reoptimization data */
1116 );
1117
1118/** increases age of constraint by 1.0;
1119 * should be called
1120 * - in constraint separation, if no cut was found for this constraint,
1121 * - in constraint enforcing, if constraint was feasible, and
1122 * - in constraint propagation, if no domain reduction was deduced;
1123 * if it's age exceeds the constraint age limit, makes constraint obsolete or marks constraint to be made obsolete
1124 * in next update
1125 */
1127 SCIP_CONS* cons, /**< constraint */
1128 BMS_BLKMEM* blkmem, /**< block memory */
1129 SCIP_SET* set, /**< global SCIP settings */
1130 SCIP_STAT* stat, /**< dynamic problem statistics */
1131 SCIP_PROB* prob, /**< problem data */
1132 SCIP_REOPT* reopt /**< reoptimization data */
1133 );
1134
1135/** resets age of constraint to zero;
1136 * should be called
1137 * - in constraint separation, if a cut was found for this constraint,
1138 * - in constraint enforcing, if the constraint was violated, and
1139 * - in constraint propagation, if a domain reduction was deduced;
1140 * if it was obsolete, makes constraint useful again or marks constraint to be made useful again in next update
1141 */
1143 SCIP_CONS* cons, /**< constraint */
1144 SCIP_SET* set /**< global SCIP settings */
1145 );
1146
1147/** resolves the given conflicting bound, that was deduced by the given constraint, by putting all "reason" bounds
1148 * leading to the deduction into the conflict queue with calls to SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(),
1149 * SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), or SCIPaddConflictBinvar();
1150 *
1151 * @note it is sufficient to explain the relaxed bound change
1152 */
1154 SCIP_CONS* cons, /**< constraint that deduced the assignment */
1155 SCIP_SET* set, /**< global SCIP settings */
1156 SCIP_VAR* infervar, /**< variable whose bound was deduced by the constraint */
1157 int inferinfo, /**< user inference information attached to the bound change */
1158 SCIP_BOUNDTYPE inferboundtype, /**< bound that was deduced (lower or upper bound) */
1159 SCIP_BDCHGIDX* bdchgidx, /**< bound change index, representing the point of time where change took place */
1160 SCIP_Real relaxedbd, /**< the relaxed bound */
1161 SCIP_RESULT* result /**< pointer to store the result of the callback method */
1162 );
1163
1164/** adds given values to lock status of the constraint and updates the locks of the given locktype of the involved variables */
1166 SCIP_CONS* cons, /**< constraint */
1167 SCIP_SET* set, /**< global SCIP settings */
1168 SCIP_LOCKTYPE locktype, /**< type of variable locks */
1169 int nlockspos, /**< increase in number of rounding locks for constraint */
1170 int nlocksneg /**< increase in number of rounding locks for constraint's negation */
1171 );
1172
1173/*
1174 * Hash functions
1175 */
1176
1177/** gets the key (i.e. the name) of the given constraint */
1178SCIP_DECL_HASHGETKEY(SCIPhashGetKeyCons);
1179
1180/*
1181 * method for arrays of contraint handlers
1182 */
1183
1184/** stores all constraints marked for propagation away when probing is started */
1186 SCIP_SET* set, /**< global SCIP settings */
1187 SCIP_CONSHDLR** conshdlrs, /**< all constraint handlers */
1188 int nconshdlrs /**< number of contraint handlers */
1189 );
1190
1191/** reset all constraints marked for propagation when probing was finished */
1193 SCIP_SET* set, /**< global SCIP settings */
1194 BMS_BLKMEM* blkmem, /**< block memory */
1195 SCIP_CONSHDLR** conshdlrs, /**< all constraint handlers */
1196 int nconshdlrs /**< number of contraint handlers */
1197 );
1198
1199#ifdef __cplusplus
1200}
1201#endif
1202
1203#endif
static GRAPHNODE ** active
SCIP_RETCODE SCIPconshdlrsStorePropagationStatus(SCIP_SET *set, SCIP_CONSHDLR **conshdlrs, int nconshdlrs)
Definition cons.c:7951
void SCIPconshdlrSetExitpre(SCIP_CONSHDLR *conshdlr,)
Definition cons.c:4370
SCIP_RETCODE SCIPconsAddLocks(SCIP_CONS *cons, SCIP_SET *set, SCIP_LOCKTYPE locktype, int nlockspos, int nlocksneg)
Definition cons.c:7378
SCIP_RETCODE SCIPconshdlrSeparateLP(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_SEPASTORE *sepastore, int depth, SCIP_Bool execdelayed, SCIP_RESULT *result)
Definition cons.c:2877
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:6074
void SCIPconshdlrSetGetPermsymGraph(SCIP_CONSHDLR *conshdlr,)
Definition cons.c:4564
SCIP_RETCODE SCIPconssetchgUndo(SCIP_CONSSETCHG *conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
Definition cons.c:5694
SCIP_RETCODE SCIPconsEnableSeparation(SCIP_CONS *cons, SCIP_SET *set)
Definition cons.c:7002
SCIP_RETCODE SCIPconshdlrSetPresol(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPRESOL((*conspresol)), int maxprerounds, SCIP_PRESOLTIMING presoltiming)
Definition cons.c:4381
void SCIPconshdlrIncNCutsFound(SCIP_CONSHDLR *conshdlr)
Definition cons.c:4930
SCIP_RETCODE SCIPconshdlrInit(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
Definition cons.c:2411
void SCIPconshdlrSetDelvars(SCIP_CONSHDLR *conshdlr,)
Definition cons.c:4498
void SCIPconsMarkConflict(SCIP_CONS *cons)
Definition cons.c:7120
SCIP_RETCODE SCIPconsEnable(SCIP_CONS *cons, SCIP_SET *set, SCIP_STAT *stat)
Definition cons.c:6935
void SCIPconsCapture(SCIP_CONS *cons)
Definition cons.c:6254
SCIP_RETCODE SCIPconsProp(SCIP_CONS *cons, SCIP_SET *set, SCIP_PROPTIMING proptiming, SCIP_RESULT *result)
Definition cons.c:7702
SCIP_RETCODE SCIPconsPrint(SCIP_CONS *cons, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, FILE *file)
Definition cons.c:6306
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:5876
void SCIPconshdlrIncNAppliedCuts(SCIP_CONSHDLR *conshdlr)
Definition cons.c:4920
void SCIPconshdlrSetInit(SCIP_CONSHDLR *conshdlr,)
Definition cons.c:4315
void SCIPconsSetLocal(SCIP_CONS *cons, SCIP_Bool local)
Definition cons.c:6776
SCIP_RETCODE SCIPconsMarkPropagate(SCIP_CONS *cons, SCIP_SET *set)
Definition cons.c:7130
SCIP_RETCODE SCIPconshdlrEnforceRelaxSol(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_SEPASTORE *sepastore, SCIP_SOL *relaxsol, SCIP_Bool solinfeasible, SCIP_RESULT *result)
Definition cons.c:3163
void SCIPconshdlrSetGetNVars(SCIP_CONSHDLR *conshdlr,)
Definition cons.c:4542
void SCIPconshdlrSetGetSignedPermsymGraph(SCIP_CONSHDLR *conshdlr,)
Definition cons.c:4576
SCIP_RETCODE SCIPconsDeactivate(SCIP_CONS *cons, SCIP_SET *set, SCIP_STAT *stat)
Definition cons.c:6900
SCIP_RETCODE SCIPconshdlrExitsol(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool restart)
Definition cons.c:2733
SCIP_RETCODE SCIPconshdlrSeparateSol(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_SEPASTORE *sepastore, SCIP_SOL *sol, int depth, SCIP_Bool execdelayed, SCIP_RESULT *result)
Definition cons.c:3034
SCIP_RETCODE SCIPconsDisable(SCIP_CONS *cons, SCIP_SET *set, SCIP_STAT *stat)
Definition cons.c:6968
SCIP_RETCODE SCIPconsDeactive(SCIP_CONS *cons, SCIP_SET *set)
Definition cons.c:7882
SCIP_RETCODE SCIPconshdlrLockVars(SCIP_CONSHDLR *conshdlr, SCIP_SET *set)
Definition cons.c:4167
SCIP_RETCODE SCIPconshdlrEnforceLPSol(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_SEPASTORE *sepastore, SCIP_Bool solinfeasible, SCIP_RESULT *result)
Definition cons.c:3351
SCIP_RETCODE SCIPconsGetPermsymGraph(SCIP_CONS *cons, SCIP_SET *set, SYM_GRAPH *graph, SCIP_Bool *success)
Definition cons.c:6416
SCIP_RETCODE SCIPconsGetNVars(SCIP_CONS *cons, SCIP_SET *set, int *nvars, SCIP_Bool *success)
Definition cons.c:6381
void SCIPconsSetStickingAtNode(SCIP_CONS *cons, SCIP_Bool stickingatnode)
Definition cons.c:6822
SCIP_RETCODE SCIPconsSetSeparated(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool separate)
Definition cons.c:6623
SCIP_RETCODE SCIPconsSepalp(SCIP_CONS *cons, SCIP_SET *set, SCIP_RESULT *result)
Definition cons.c:7618
SCIP_RETCODE SCIPconsEnfops(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool solinfeasible, SCIP_Bool objinfeasible, SCIP_RESULT *result)
Definition cons.c:7462
SCIP_RETCODE SCIPconsActive(SCIP_CONS *cons, SCIP_SET *set)
Definition cons.c:7858
SCIP_RETCODE SCIPconsResetAge(SCIP_CONS *cons, SCIP_SET *set)
Definition cons.c:7277
void SCIPconshdlrSetExit(SCIP_CONSHDLR *conshdlr,)
Definition cons.c:4326
void SCIPconshdlrSetResprop(SCIP_CONSHDLR *conshdlr,)
Definition cons.c:4443
void SCIPconshdlrSetTrans(SCIP_CONSHDLR *conshdlr,)
Definition cons.c:4421
void SCIPconshdlrSetDelete(SCIP_CONSHDLR *conshdlr,)
Definition cons.c:4410
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:7742
void SCIPconshdlrSetParse(SCIP_CONSHDLR *conshdlr,)
Definition cons.c:4520
void SCIPconsSetRemovable(SCIP_CONS *cons, SCIP_Bool removable)
Definition cons.c:6811
void SCIPconshdlrSetExitsol(SCIP_CONSHDLR *conshdlr,)
Definition cons.c:4348
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
void SCIPconshdlrEnableOrDisableClocks(SCIP_CONSHDLR *conshdlr, SCIP_Bool enable)
Definition cons.c:4700
void SCIPconshdlrSetDisable(SCIP_CONSHDLR *conshdlr,)
Definition cons.c:4487
void SCIPconshdlrSetActive(SCIP_CONSHDLR *conshdlr,)
Definition cons.c:4454
SCIP_RETCODE SCIPconsTransform(SCIP_CONS *origcons, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_CONS **transcons)
Definition cons.c:6539
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:7424
SCIP_RETCODE SCIPconssetchgAddAddedCons(SCIP_CONSSETCHG **conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_CONS *cons, int depth, SCIP_Bool focusnode, SCIP_Bool active)
Definition cons.c:5443
SCIP_RETCODE SCIPconshdlrInitLP(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_Bool initkeptconss, SCIP_Bool *cutoff)
Definition cons.c:2770
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:7197
SCIP_RETCODE SCIPconsEnablePropagation(SCIP_CONS *cons, SCIP_SET *set)
Definition cons.c:7060
SCIP_RETCODE SCIPconsEnfolp(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool solinfeasible, SCIP_RESULT *result)
Definition cons.c:7506
SCIP_RETCODE SCIPconsSetInitial(SCIP_CONS *cons, SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool initial)
Definition cons.c:6589
SCIP_RETCODE SCIPconssetchgFree(SCIP_CONSSETCHG **conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set)
Definition cons.c:5369
SCIP_RETCODE SCIPconsChgName(SCIP_CONS *cons, BMS_BLKMEM *blkmem, const char *name)
Definition cons.c:6179
SCIP_RETCODE SCIPconsIncAge(SCIP_CONS *cons, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_REOPT *reopt)
Definition cons.c:7256
void SCIPconshdlrSetEnable(SCIP_CONSHDLR *conshdlr,)
Definition cons.c:4476
SCIP_RETCODE SCIPconshdlrInitpre(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
Definition cons.c:2567
void SCIPconsSetDynamic(SCIP_CONS *cons, SCIP_Bool dynamic)
Definition cons.c:6800
SCIP_RETCODE SCIPconsSepasol(SCIP_CONS *cons, SCIP_SET *set, SCIP_SOL *sol, SCIP_RESULT *result)
Definition cons.c:7659
SCIP_RETCODE SCIPconsFree(SCIP_CONS **cons, BMS_BLKMEM *blkmem, SCIP_SET *set)
Definition cons.c:6199
SCIP_RETCODE SCIPconssetchgAddDisabledCons(SCIP_CONSSETCHG **conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_CONS *cons)
Definition cons.c:5489
void SCIPconshdlrSetDeactive(SCIP_CONSHDLR *conshdlr,)
Definition cons.c:4465
SCIP_RETCODE SCIPconsDelete(SCIP_CONS *cons, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_REOPT *reopt)
Definition cons.c:6479
void SCIPconshdlrSetGetVars(SCIP_CONSHDLR *conshdlr,)
Definition cons.c:4531
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:7784
SCIP_RETCODE SCIPconsDisablePropagation(SCIP_CONS *cons, SCIP_SET *set)
Definition cons.c:7090
SCIP_RETCODE SCIPconsCopy(SCIP_CONS **cons, SCIP_SET *set, const char *name, SCIP *sourcescip, SCIP_CONSHDLR *sourceconshdlr, SCIP_CONS *sourcecons, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode, SCIP_Bool global, SCIP_Bool *valid)
Definition cons.c:6018
void SCIPconshdlrSetGetDiveBdChgs(SCIP_CONSHDLR *conshdlr,)
Definition cons.c:4553
SCIP_RETCODE SCIPconsRelease(SCIP_CONS **cons, BMS_BLKMEM *blkmem, SCIP_SET *set)
Definition cons.c:6266
SCIP_RETCODE SCIPconsResolvePropagation(SCIP_CONS *cons, SCIP_SET *set, SCIP_VAR *infervar, int inferinfo, SCIP_BOUNDTYPE inferboundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedbd, SCIP_RESULT *result)
Definition cons.c:7318
SCIP_RETCODE SCIPconsSetPropagated(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool propagate)
Definition cons.c:6741
SCIP_RETCODE SCIPconsDisableSeparation(SCIP_CONS *cons, SCIP_SET *set)
Definition cons.c:7032
void SCIPconshdlrSetInitsol(SCIP_CONSHDLR *conshdlr,)
Definition cons.c:4337
SCIP_RETCODE SCIPconsGetSignedPermsymGraph(SCIP_CONS *cons, SCIP_SET *set, SYM_GRAPH *graph, SCIP_Bool *success)
Definition cons.c:6449
SCIP_RETCODE SCIPconshdlrUnlockVars(SCIP_CONSHDLR *conshdlr, SCIP_SET *set)
Definition cons.c:4182
SCIP_RETCODE SCIPconsSetChecked(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool check)
Definition cons.c:6693
SCIP_RETCODE SCIPconsInitlp(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool *infeasible)
Definition cons.c:7592
SCIP_RETCODE SCIPconsEnforelax(SCIP_CONS *cons, SCIP_SET *set, SCIP_SOL *sol, SCIP_Bool solinfeasible, SCIP_RESULT *result)
Definition cons.c:7548
SCIP_RETCODE SCIPconshdlrsResetPropagationStatus(SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_CONSHDLR **conshdlrs, int nconshdlrs)
Definition cons.c:7991
SCIP_RETCODE SCIPconshdlrCopyInclude(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, SCIP_Bool *valid)
Definition cons.c:1980
SCIP_RETCODE SCIPconsActivate(SCIP_CONS *cons, SCIP_SET *set, SCIP_STAT *stat, int depth, SCIP_Bool focusnode)
Definition cons.c:6858
SCIP_CONS * SCIPconsGetTransformed(SCIP_CONS *cons)
Definition cons.c:6848
SCIP_RETCODE SCIPconshdlrPropagate(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, int depth, SCIP_Bool fullpropagation, SCIP_Bool execdelayed, SCIP_Bool instrongbranching, SCIP_PROPTIMING proptiming, SCIP_RESULT *result)
Definition cons.c:3822
void SCIPconshdlrSetInitlp(SCIP_CONSHDLR *conshdlr,)
Definition cons.c:4432
SCIP_RETCODE SCIPconsUnmarkPropagate(SCIP_CONS *cons, SCIP_SET *set)
Definition cons.c:7160
SCIP_RETCODE SCIPconshdlrGetDiveBoundChanges(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, SCIP_DIVESET *diveset, SCIP_SOL *sol, SCIP_Bool *success, SCIP_Bool *infeasible)
Definition cons.c:3529
void SCIPconshdlrSetCopy(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)),)
Definition cons.c:4289
void SCIPconshdlrSetFree(SCIP_CONSHDLR *conshdlr,)
Definition cons.c:4304
SCIP_RETCODE SCIPconshdlrPresolve(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PRESOLTIMING timing, int nrounds, int *nfixedvars, int *naggrvars, int *nchgvartypes, int *nchgbds, int *naddholes, int *ndelconss, int *naddconss, int *nupgdconss, int *nchgcoefs, int *nchgsides, SCIP_RESULT *result)
Definition cons.c:3993
SCIP_RETCODE SCIPconsGetVars(SCIP_CONS *cons, SCIP_SET *set, SCIP_VAR **vars, int varssize, SCIP_Bool *success)
Definition cons.c:6345
void SCIPconsSetNamePointer(SCIP_CONS *cons, const char *name)
Definition cons.c:6834
SCIP_RETCODE SCIPconshdlrEnforcePseudoSol(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_BRANCHCAND *branchcand, SCIP_Bool solinfeasible, SCIP_Bool objinfeasible, SCIP_Bool forced, SCIP_RESULT *result)
Definition cons.c:3556
void SCIPconshdlrSetInitpre(SCIP_CONSHDLR *conshdlr,)
Definition cons.c:4359
SCIP_RETCODE SCIPconssetchgApply(SCIP_CONSSETCHG *conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, int depth, SCIP_Bool focusnode)
Definition cons.c:5607
SCIP_RETCODE SCIPconshdlrDelVars(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
Definition cons.c:4136
SCIP_RETCODE SCIPconsSetEnforced(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool enforce)
Definition cons.c:6658
void SCIPconsSetModifiable(SCIP_CONS *cons, SCIP_Bool modifiable)
Definition cons.c:6789
SCIP_RETCODE SCIPconshdlrExitpre(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
Definition cons.c:2653
SCIP_RETCODE SCIPconshdlrInitsol(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
Definition cons.c:2693
SCIP_RETCODE SCIPconssetchgMakeGlobal(SCIP_CONSSETCHG **conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_REOPT *reopt)
Definition cons.c:5780
void SCIPconshdlrSetPrint(SCIP_CONSHDLR *conshdlr,)
Definition cons.c:4509
SCIP_RETCODE SCIPconshdlrCheck(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_SOL *sol, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool printreason, SCIP_Bool completely, SCIP_RESULT *result)
Definition cons.c:3760
SCIP_RETCODE SCIPconshdlrExit(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
Definition cons.c:2524
SCIP_RETCODE SCIPconshdlrFree(SCIP_CONSHDLR **conshdlr, SCIP_SET *set)
Definition cons.c:2366
common defines and data types used in all packages of SCIP
#define SCIP_Bool
Definition def.h:91
#define SCIP_Real
Definition def.h:172
static SCIP_DIVESET * diveset
int depth
SCIP_Bool cutoff
static SCIP_SOL * sol
int nvars
static SCIP_Bool propagate
static SCIP_VAR ** vars
memory allocation routines
struct BMS_BlkMem BMS_BLKMEM
Definition memory.h:437
public methods for managing constraints
datastructures for constraints and constraint handlers
type definitions for branching rules
struct SCIP_BranchCand SCIP_BRANCHCAND
Definition type_branch.h:55
type definitions for constraints and constraint handlers
#define SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH(x)
Definition type_cons.h:955
#define SCIP_DECL_CONSGETPERMSYMGRAPH(x)
Definition type_cons.h:937
#define SCIP_DECL_CONSENFOLP(x)
Definition type_cons.h:363
#define SCIP_DECL_CONSINITPRE(x)
Definition type_cons.h:156
#define SCIP_DECL_CONSDELETE(x)
Definition type_cons.h:229
struct SCIP_Cons SCIP_CONS
Definition type_cons.h:63
#define SCIP_DECL_CONSEXIT(x)
Definition type_cons.h:136
#define SCIP_DECL_CONSGETVARS(x)
Definition type_cons.h:866
#define SCIP_DECL_CONSINITSOL(x)
Definition type_cons.h:201
#define SCIP_DECL_CONSPRINT(x)
Definition type_cons.h:768
struct SCIP_ConshdlrData SCIP_CONSHDLRDATA
Definition type_cons.h:64
#define SCIP_DECL_CONSSEPALP(x)
Definition type_cons.h:288
#define SCIP_DECL_CONSDISABLE(x)
Definition type_cons.h:735
struct SCIP_ConsSetChg SCIP_CONSSETCHG
Definition type_cons.h:66
struct SYM_Graph SYM_GRAPH
Definition type_cons.h:68
#define SCIP_DECL_CONSENFORELAX(x)
Definition type_cons.h:388
#define SCIP_DECL_CONSGETDIVEBDCHGS(x)
Definition type_cons.h:919
#define SCIP_DECL_CONSPROP(x)
Definition type_cons.h:505
#define SCIP_DECL_CONSGETNVARS(x)
Definition type_cons.h:884
#define SCIP_DECL_CONSRESPROP(x)
Definition type_cons.h:611
#define SCIP_DECL_CONSACTIVE(x)
Definition type_cons.h:690
#define SCIP_DECL_CONSENFOPS(x)
Definition type_cons.h:431
#define SCIP_DECL_CONSPARSE(x)
Definition type_cons.h:844
#define SCIP_DECL_CONSTRANS(x)
Definition type_cons.h:239
#define SCIP_DECL_CONSDEACTIVE(x)
Definition type_cons.h:705
#define SCIP_DECL_CONSPRESOL(x)
Definition type_cons.h:560
#define SCIP_DECL_CONSENABLE(x)
Definition type_cons.h:720
#define SCIP_DECL_CONSINITLP(x)
Definition type_cons.h:259
#define SCIP_DECL_CONSEXITPRE(x)
Definition type_cons.h:180
#define SCIP_DECL_CONSLOCK(x)
Definition type_cons.h:675
struct SCIP_Conshdlr SCIP_CONSHDLR
Definition type_cons.h:62
#define SCIP_DECL_CONSCOPY(x)
Definition type_cons.h:809
#define SCIP_DECL_CONSINIT(x)
Definition type_cons.h:126
struct SCIP_ConsData SCIP_CONSDATA
Definition type_cons.h:65
#define SCIP_DECL_CONSCHECK(x)
Definition type_cons.h:474
#define SCIP_DECL_CONSHDLRCOPY(x)
Definition type_cons.h:108
#define SCIP_DECL_CONSEXITSOL(x)
Definition type_cons.h:216
#define SCIP_DECL_CONSFREE(x)
Definition type_cons.h:116
#define SCIP_DECL_CONSSEPASOL(x)
Definition type_cons.h:320
#define SCIP_DECL_CONSDELVARS(x)
Definition type_cons.h:752
struct SCIP_Diveset SCIP_DIVESET
Definition type_heur.h:78
type definitions for LP management
enum SCIP_BoundType SCIP_BOUNDTYPE
Definition type_lp.h:59
type definitions for block memory pools and memory buffers
type definitions for message output methods
struct SCIP_Messagehdlr SCIP_MESSAGEHDLR
type definitions for miscellaneous datastructures
struct SCIP_HashMap SCIP_HASHMAP
Definition type_misc.h:105
#define SCIP_DECL_HASHGETKEY(x)
Definition type_misc.h:191
type definitions for storing and manipulating the main problem
struct SCIP_Prob SCIP_PROB
Definition type_prob.h:52
type definitions for collecting reoptimization information
struct SCIP_Reopt SCIP_REOPT
Definition type_reopt.h:39
result codes for SCIP callback methods
enum SCIP_Result SCIP_RESULT
Definition type_result.h:61
type definitions for return codes for SCIP methods
enum SCIP_Retcode SCIP_RETCODE
struct Scip SCIP
Definition type_scip.h:39
type definitions for storing separated cuts
struct SCIP_SepaStore SCIP_SEPASTORE
type definitions for global SCIP settings
struct SCIP_Set SCIP_SET
Definition type_set.h:71
type definitions for storing primal CIP solutions
struct SCIP_Sol SCIP_SOL
Definition type_sol.h:57
type definitions for problem statistics
struct SCIP_Stat SCIP_STAT
Definition type_stat.h:69
timing definitions for SCIP
unsigned int SCIP_PROPTIMING
Definition type_timing.h:74
unsigned int SCIP_PRESOLTIMING
Definition type_timing.h:61
type definitions for branch and bound tree
struct SCIP_Tree SCIP_TREE
Definition type_tree.h:65
type definitions for problem variables
struct SCIP_Var SCIP_VAR
Definition type_var.h:119
struct SCIP_BdChgIdx SCIP_BDCHGIDX
Definition type_var.h:107
enum SCIP_LockType SCIP_LOCKTYPE
Definition type_var.h:100