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