Scippy

SCIP

Solving Constraint Integer Programs

cons.h
Go to the documentation of this file.
1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2 /* */
3 /* This file is part of the program and library */
4 /* SCIP --- Solving Constraint Integer Programs */
5 /* */
6 /* Copyright (c) 2002-2024 Zuse Institute Berlin (ZIB) */
7 /* */
8 /* Licensed under the Apache License, Version 2.0 (the "License"); */
9 /* you may not use this file except in compliance with the License. */
10 /* You may obtain a copy of the License at */
11 /* */
12 /* http://www.apache.org/licenses/LICENSE-2.0 */
13 /* */
14 /* Unless required by applicable law or agreed to in writing, software */
15 /* distributed under the License is distributed on an "AS IS" BASIS, */
16 /* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */
17 /* See the License for the specific language governing permissions and */
18 /* limitations under the License. */
19 /* */
20 /* You should have received a copy of the Apache-2.0 license */
21 /* along with SCIP; see the file LICENSE. If not visit scipopt.org. */
22 /* */
23 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
24 
25 /**@file cons.h
26  * @ingroup INTERNALAPI
27  * @brief internal methods for constraints and constraint handlers
28  * @author Tobias Achterberg
29  */
30 
31 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
32 
33 #ifndef __SCIP_CONS_H__
34 #define __SCIP_CONS_H__
35 
36 
37 #include "scip/def.h"
38 #include "blockmemshell/memory.h"
39 #include "scip/type_retcode.h"
40 #include "scip/type_result.h"
41 #include "scip/type_set.h"
42 #include "scip/type_stat.h"
43 #include "scip/type_mem.h"
44 #include "scip/type_misc.h"
45 #include "scip/type_timing.h"
46 #include "scip/type_lp.h"
47 #include "scip/type_var.h"
48 #include "scip/type_prob.h"
49 #include "scip/type_sol.h"
50 #include "scip/type_tree.h"
51 #include "scip/type_sepastore.h"
52 #include "scip/type_cons.h"
53 #include "scip/type_branch.h"
54 #include "scip/type_reopt.h"
55 #include "scip/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
63 extern "C" {
64 #endif
65 
66 /*
67  * Constraint handler methods
68  */
69 
70 /** copies the given constraint handler to a new scip */
71 SCIP_RETCODE SCIPconshdlrCopyInclude(
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 */
78 SCIP_RETCODE SCIPconshdlrCreate(
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 */
138 SCIP_RETCODE SCIPconshdlrFree(
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 */
144 SCIP_RETCODE SCIPconshdlrInit(
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 */
152 SCIP_RETCODE SCIPconshdlrExit(
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 */
160 SCIP_RETCODE SCIPconshdlrInitpre(
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 */
168 SCIP_RETCODE SCIPconshdlrExitpre(
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 */
176 SCIP_RETCODE SCIPconshdlrInitsol(
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 */
184 SCIP_RETCODE SCIPconshdlrExitsol(
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 */
193 SCIP_RETCODE SCIPconshdlrInitLP(
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 */
206 SCIP_RETCODE SCIPconshdlrSeparateLP(
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 */
218 SCIP_RETCODE SCIPconshdlrSeparateSol(
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  */
233 SCIP_RETCODE SCIPconshdlrEnforceRelaxSol(
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  */
248 SCIP_RETCODE SCIPconshdlrEnforceLPSol(
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 */
260 SCIP_RETCODE SCIPconshdlrGetDiveBoundChanges(
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  */
272 SCIP_RETCODE SCIPconshdlrEnforcePseudoSol(
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 */
286 SCIP_RETCODE SCIPconshdlrCheck(
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 */
300 SCIP_RETCODE SCIPconshdlrPropagate(
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 */
314 SCIP_RETCODE SCIPconshdlrPresolve(
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 */
335 void SCIPconshdlrEnableOrDisableClocks(
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 */
341 SCIP_RETCODE SCIPconshdlrDelVars(
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 */
350 SCIP_RETCODE SCIPconshdlrLockVars(
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 */
356 SCIP_RETCODE SCIPconshdlrUnlockVars(
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 */
366 void SCIPconshdlrSetCopy(
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 */
373 void SCIPconshdlrSetFree(
374  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
375  SCIP_DECL_CONSFREE ((*consfree)) /**< destructor of constraint handler */
376  );
377 
378 /** sets initialization method of constraint handler */
379 void SCIPconshdlrSetInit(
380  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
381  SCIP_DECL_CONSINIT ((*consinit)) /**< initialize constraint handler */
382  );
383 
384 /** sets deinitialization method of constraint handler */
385 void SCIPconshdlrSetExit(
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 */
391 void SCIPconshdlrSetInitsol(
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 */
397 void SCIPconshdlrSetExitsol(
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 */
403 void SCIPconshdlrSetInitpre(
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 */
409 void SCIPconshdlrSetExitpre(
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 */
415 SCIP_RETCODE SCIPconshdlrSetPresol(
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 */
423 void SCIPconshdlrSetDelete(
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 */
429 void SCIPconshdlrSetTrans(
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 */
435 void SCIPconshdlrSetInitlp(
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 */
441 void SCIPconshdlrSetResprop(
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 */
447 void SCIPconshdlrSetActive(
448  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
449  SCIP_DECL_CONSACTIVE ((*consactive)) /**< activation notification method */
450  );
451 
452 /** sets deactivation notification method of constraint handler */
453 void SCIPconshdlrSetDeactive(
454  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
455  SCIP_DECL_CONSDEACTIVE((*consdeactive)) /**< deactivation notification method */
456  );
457 
458 /** sets enabling notification method of constraint handler */
459 void SCIPconshdlrSetEnable(
460  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
461  SCIP_DECL_CONSENABLE ((*consenable)) /**< enabling notification method */
462  );
463 
464 /** sets disabling notification method of constraint handler */
465 void SCIPconshdlrSetDisable(
466  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
467  SCIP_DECL_CONSDISABLE ((*consdisable)) /**< disabling notification method */
468  );
469 
470 /** sets variable deletion method of constraint handler */
471 void SCIPconshdlrSetDelvars(
472  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
473  SCIP_DECL_CONSDELVARS ((*consdelvars)) /**< variable deletion method */
474  );
475 
476 /** sets constraint display method of constraint handler */
477 void SCIPconshdlrSetPrint(
478  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
479  SCIP_DECL_CONSPRINT ((*consprint)) /**< constraint display method */
480  );
481 
482 /** sets constraint parsing method of constraint handler */
483 void SCIPconshdlrSetParse(
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 */
489 void SCIPconshdlrSetGetVars(
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 */
495 void SCIPconshdlrSetGetNVars(
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 */
501 void SCIPconshdlrSetGetDiveBdChgs(
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 */
507 void SCIPconshdlrSetGetPermsymGraph(
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 */
514 void SCIPconshdlrSetGetSignedPermsymGraph(
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 */
525 SCIP_RETCODE SCIPconssetchgFree(
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  */
534 SCIP_RETCODE SCIPconssetchgAddAddedCons(
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 */
546 SCIP_RETCODE SCIPconssetchgAddDisabledCons(
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 */
554 SCIP_RETCODE SCIPconssetchgApply(
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 */
564 SCIP_RETCODE SCIPconssetchgUndo(
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 */
572 SCIP_RETCODE SCIPconssetchgMakeGlobal(
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 */
582 void SCIPconshdlrIncNAppliedCuts(
583  SCIP_CONSHDLR* conshdlr /**< constraint handler */
584  );
585 
586 /** increase count of found cuts */
587 void SCIPconshdlrIncNCutsFound(
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  */
604 SCIP_RETCODE SCIPconsCreate(
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  */
647 SCIP_RETCODE SCIPconsCopy(
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  */
681 SCIP_RETCODE SCIPconsParse(
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 */
713 SCIP_RETCODE SCIPconsChgName(
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 */
720 SCIP_RETCODE SCIPconsFree(
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 */
727 void SCIPconsCapture(
728  SCIP_CONS* cons /**< constraint */
729  );
730 
731 /** decreases usage counter of constraint, and frees memory if necessary */
732 SCIP_RETCODE SCIPconsRelease(
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 */
740 SCIP_RETCODE SCIPconsPrint(
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 */
748 SCIP_RETCODE SCIPconsCheck(
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 */
759 SCIP_RETCODE SCIPconsEnfops(
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 */
768 SCIP_RETCODE SCIPconsEnfolp(
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 */
776 SCIP_RETCODE SCIPconsEnforelax(
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 */
785 SCIP_RETCODE SCIPconsInitlp(
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 */
792 SCIP_RETCODE SCIPconsSepalp(
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 */
799 SCIP_RETCODE SCIPconsSepasol(
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 */
807 SCIP_RETCODE SCIPconsProp(
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 */
815 SCIP_RETCODE SCIPconsResprop(
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 */
827 SCIP_RETCODE SCIPconsPresol(
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 */
856 SCIP_RETCODE SCIPconsActive(
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 */
862 SCIP_RETCODE SCIPconsDeactive(
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  */
878 SCIP_RETCODE SCIPconsGetVars(
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  */
893 SCIP_RETCODE SCIPconsGetNVars(
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  */
906 SCIP_RETCODE SCIPconsGetPermsymGraph(
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  */
919 SCIP_RETCODE SCIPconsGetSignedPermsymGraph(
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  */
929 SCIP_RETCODE SCIPconsDelete(
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  */
941 SCIP_RETCODE SCIPconsTransform(
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 */
949 SCIP_RETCODE SCIPconsSetInitial(
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 */
957 SCIP_RETCODE SCIPconsSetSeparated(
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 */
964 SCIP_RETCODE SCIPconsSetEnforced(
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 */
971 SCIP_RETCODE SCIPconsSetChecked(
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 */
978 SCIP_RETCODE SCIPconsSetPropagated(
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 */
985 void SCIPconsSetLocal(
986  SCIP_CONS* cons, /**< constraint */
987  SCIP_Bool local /**< new value */
988  );
989 
990 /** sets the modifiable flag of the given constraint */
991 void SCIPconsSetModifiable(
992  SCIP_CONS* cons, /**< constraint */
993  SCIP_Bool modifiable /**< new value */
994  );
995 
996 /** sets the dynamic flag of the given constraint */
997 void SCIPconsSetDynamic(
998  SCIP_CONS* cons, /**< constraint */
999  SCIP_Bool dynamic /**< new value */
1000  );
1001 
1002 /** sets the removable flag of the given constraint */
1003 void SCIPconsSetRemovable(
1004  SCIP_CONS* cons, /**< constraint */
1005  SCIP_Bool removable /**< new value */
1006  );
1007 
1008 /** sets the stickingatnode flag of the given constraint */
1009 void SCIPconsSetStickingAtNode(
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 */
1016 void SCIPconsSetNamePointer(
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  */
1024 SCIP_CONS* SCIPconsGetTransformed(
1025  SCIP_CONS* cons /**< constraint */
1026  );
1027 
1028 /** activates constraint or marks constraint to be activated in next update */
1029 SCIP_RETCODE SCIPconsActivate(
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 */
1038 SCIP_RETCODE SCIPconsDeactivate(
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 */
1045 SCIP_RETCODE SCIPconsEnable(
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 */
1052 SCIP_RETCODE SCIPconsDisable(
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 */
1059 SCIP_RETCODE SCIPconsEnableSeparation(
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 */
1065 SCIP_RETCODE SCIPconsDisableSeparation(
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 */
1071 SCIP_RETCODE SCIPconsEnablePropagation(
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 */
1077 SCIP_RETCODE SCIPconsDisablePropagation(
1078  SCIP_CONS* cons, /**< constraint */
1079  SCIP_SET* set /**< global SCIP settings */
1080  );
1081 
1082 /** marks the constraint to be a conflict */
1083 void SCIPconsMarkConflict(
1084  SCIP_CONS* cons /**< constraint */
1085  );
1086 
1087 /** marks the constraint to be propagated (update might be delayed) */
1088 SCIP_EXPORT
1089 SCIP_RETCODE SCIPconsMarkPropagate(
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) */
1095 SCIP_RETCODE SCIPconsUnmarkPropagate(
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  */
1108 SCIP_RETCODE SCIPconsAddAge(
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  */
1126 SCIP_RETCODE SCIPconsIncAge(
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  */
1142 SCIP_RETCODE SCIPconsResetAge(
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  */
1153 SCIP_RETCODE SCIPconsResolvePropagation(
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 */
1165 SCIP_RETCODE SCIPconsAddLocks(
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 */
1178 SCIP_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 */
1185 SCIP_RETCODE SCIPconshdlrsStorePropagationStatus(
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 */
1192 SCIP_RETCODE SCIPconshdlrsResetPropagationStatus(
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
SCIP_RESULT
enum SCIP_Result SCIP_RESULT
Definition: type_result.h:61
SCIPconshdlrSetInitpre
void SCIPconshdlrSetInitpre(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITPRE((*consinitpre)))
Definition: cons.c:4361
SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH
#define SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH(x)
Definition: type_cons.h:955
SCIPconsEnforelax
SCIP_RETCODE SCIPconsEnforelax(SCIP_CONS *cons, SCIP_SET *set, SCIP_SOL *sol, SCIP_Bool solinfeasible, SCIP_RESULT *result)
Definition: cons.c:7550
SCIP_BOUNDTYPE
enum SCIP_BoundType SCIP_BOUNDTYPE
Definition: type_lp.h:59
SCIPconshdlrSetInitsol
void SCIPconshdlrSetInitsol(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITSOL((*consinitsol)))
Definition: cons.c:4339
SCIPconsEnable
SCIP_RETCODE SCIPconsEnable(SCIP_CONS *cons, SCIP_SET *set, SCIP_STAT *stat)
Definition: cons.c:6937
SCIPconshdlrInitsol
SCIP_RETCODE SCIPconshdlrInitsol(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
Definition: cons.c:2695
SCIP_BdChgIdx
Definition: struct_var.h:108
SCIPconsFree
SCIP_RETCODE SCIPconsFree(SCIP_CONS **cons, BMS_BLKMEM *blkmem, SCIP_SET *set)
Definition: cons.c:6201
SCIPconshdlrSetResprop
void SCIPconshdlrSetResprop(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSRESPROP((*consresprop)))
Definition: cons.c:4445
type_misc.h
type definitions for miscellaneous datastructures
type_timing.h
timing definitions for SCIP
SCIPconshdlrSeparateSol
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:3036
SCIPconshdlrLockVars
SCIP_RETCODE SCIPconshdlrLockVars(SCIP_CONSHDLR *conshdlr, SCIP_SET *set)
Definition: cons.c:4169
SCIPconsAddLocks
SCIP_RETCODE SCIPconsAddLocks(SCIP_CONS *cons, SCIP_SET *set, SCIP_LOCKTYPE locktype, int nlockspos, int nlocksneg)
Definition: cons.c:7380
SCIPconsSetLocal
void SCIPconsSetLocal(SCIP_CONS *cons, SCIP_Bool local)
Definition: cons.c:6778
SCIPconsSetNamePointer
void SCIPconsSetNamePointer(SCIP_CONS *cons, const char *name)
Definition: cons.c:6836
SCIP_DECL_CONSSEPALP
SCIP_DECL_CONSSEPALP(ConshdlrSubtour::scip_sepalp)
Definition: ConshdlrSubtour.cpp:285
SCIPconssetchgAddDisabledCons
SCIP_RETCODE SCIPconssetchgAddDisabledCons(SCIP_CONSSETCHG **conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_CONS *cons)
Definition: cons.c:5491
SCIP_DECL_CONSINITPRE
#define SCIP_DECL_CONSINITPRE(x)
Definition: type_cons.h:156
SCIPconsEnableSeparation
SCIP_RETCODE SCIPconsEnableSeparation(SCIP_CONS *cons, SCIP_SET *set)
Definition: cons.c:7004
SCIP_DECL_CONSGETDIVEBDCHGS
#define SCIP_DECL_CONSGETDIVEBDCHGS(x)
Definition: type_cons.h:919
SCIP_DECL_CONSPRESOL
#define SCIP_DECL_CONSPRESOL(x)
Definition: type_cons.h:560
SCIPconshdlrFree
SCIP_RETCODE SCIPconshdlrFree(SCIP_CONSHDLR **conshdlr, SCIP_SET *set)
Definition: cons.c:2368
SCIPconshdlrCheck
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:3762
SCIPconshdlrsStorePropagationStatus
SCIP_RETCODE SCIPconshdlrsStorePropagationStatus(SCIP_SET *set, SCIP_CONSHDLR **conshdlrs, int nconshdlrs)
Definition: cons.c:7953
SCIP_Var
Definition: struct_var.h:207
SCIPconsIncAge
SCIP_RETCODE SCIPconsIncAge(SCIP_CONS *cons, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_REOPT *reopt)
Definition: cons.c:7258
SCIP_DECL_CONSENFOPS
SCIP_DECL_CONSENFOPS(ConshdlrSubtour::scip_enfops)
Definition: ConshdlrSubtour.cpp:394
SCIPconsGetTransformed
SCIP_CONS * SCIPconsGetTransformed(SCIP_CONS *cons)
Definition: cons.c:6850
SCIPconsSetEnforced
SCIP_RETCODE SCIPconsSetEnforced(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool enforce)
Definition: cons.c:6660
SCIPconsDeactive
SCIP_RETCODE SCIPconsDeactive(SCIP_CONS *cons, SCIP_SET *set)
Definition: cons.c:7884
SCIPconsEnfolp
SCIP_RETCODE SCIPconsEnfolp(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool solinfeasible, SCIP_RESULT *result)
Definition: cons.c:7508
SCIP_DECL_CONSRESPROP
#define SCIP_DECL_CONSRESPROP(x)
Definition: type_cons.h:611
SCIPconssetchgFree
SCIP_RETCODE SCIPconssetchgFree(SCIP_CONSSETCHG **conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set)
Definition: cons.c:5371
struct_cons.h
datastructures for constraints and constraint handlers
SCIPconsActivate
SCIP_RETCODE SCIPconsActivate(SCIP_CONS *cons, SCIP_SET *set, SCIP_STAT *stat, int depth, SCIP_Bool focusnode)
Definition: cons.c:6860
SCIP_SepaStore
Definition: struct_sepastore.h:48
SCIPconshdlrEnforcePseudoSol
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:3558
SCIPconshdlrCopyInclude
SCIP_RETCODE SCIPconshdlrCopyInclude(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, SCIP_Bool *valid)
Definition: cons.c:1982
SCIPconshdlrSetGetDiveBdChgs
void SCIPconshdlrSetGetDiveBdChgs(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs)))
Definition: cons.c:4555
SCIP_Messagehdlr
Definition: struct_message.h:45
SCIP_RETCODE
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:63
SCIP_DECL_CONSGETNVARS
#define SCIP_DECL_CONSGETNVARS(x)
Definition: type_cons.h:884
SCIPconssetchgApply
SCIP_RETCODE SCIPconssetchgApply(SCIP_CONSSETCHG *conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, int depth, SCIP_Bool focusnode)
Definition: cons.c:5609
SCIPconsResolvePropagation
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:7320
type_set.h
type definitions for global SCIP settings
SCIPconsSepasol
SCIP_RETCODE SCIPconsSepasol(SCIP_CONS *cons, SCIP_SET *set, SCIP_SOL *sol, SCIP_RESULT *result)
Definition: cons.c:7661
SCIPconsResprop
SCIP_RETCODE SCIPconsResprop(SCIP_CONS *cons, SCIP_SET *set, SCIP_VAR *infervar, int inferinfo, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedbd, SCIP_RESULT *result)
Definition: cons.c:7744
SCIP_Prob
Definition: struct_prob.h:48
SCIP_DECL_CONSEXITSOL
#define SCIP_DECL_CONSEXITSOL(x)
Definition: type_cons.h:216
active
static GRAPHNODE ** active
Definition: GomoryHuTree.cpp:44
SCIPconsUnmarkPropagate
SCIP_RETCODE SCIPconsUnmarkPropagate(SCIP_CONS *cons, SCIP_SET *set)
Definition: cons.c:7162
SCIPconshdlrSetDeactive
void SCIPconshdlrSetDeactive(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDEACTIVE((*consdeactive)))
Definition: cons.c:4467
SCIPconshdlrSetExitsol
void SCIPconshdlrSetExitsol(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSEXITSOL((*consexitsol)))
Definition: cons.c:4350
type_retcode.h
type definitions for return codes for SCIP methods
SCIPconsEnablePropagation
SCIP_RETCODE SCIPconsEnablePropagation(SCIP_CONS *cons, SCIP_SET *set)
Definition: cons.c:7062
SCIP_DECL_CONSSEPASOL
SCIP_DECL_CONSSEPASOL(ConshdlrSubtour::scip_sepasol)
Definition: ConshdlrSubtour.cpp:312
SCIP_DECL_CONSDELETE
SCIP_DECL_CONSDELETE(ConshdlrSubtour::scip_delete)
Definition: ConshdlrSubtour.cpp:232
SCIPconsDelete
SCIP_RETCODE SCIPconsDelete(SCIP_CONS *cons, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_REOPT *reopt)
Definition: cons.c:6481
SCIPconshdlrSetGetSignedPermsymGraph
void SCIPconshdlrSetGetSignedPermsymGraph(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH((*consgetsignedpermsymgraph)))
Definition: cons.c:4578
SCIPconsTransform
SCIP_RETCODE SCIPconsTransform(SCIP_CONS *origcons, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_CONS **transcons)
Definition: cons.c:6541
type_reopt.h
type definitions for collecting reoptimization information
SCIPconshdlrExit
SCIP_RETCODE SCIPconshdlrExit(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
Definition: cons.c:2526
SCIPconsParse
SCIP_RETCODE SCIPconsParse(SCIP_CONS **cons, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *str, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode, SCIP_Bool *success)
Definition: cons.c:6076
SCIP_DECL_CONSINITLP
#define SCIP_DECL_CONSINITLP(x)
Definition: type_cons.h:259
type_branch.h
type definitions for branching rules
type_stat.h
type definitions for problem statistics
SCIP_DECL_CONSENFOLP
SCIP_DECL_CONSENFOLP(ConshdlrSubtour::scip_enfolp)
Definition: ConshdlrSubtour.cpp:350
SCIPconshdlrSetExit
void SCIPconshdlrSetExit(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSEXIT((*consexit)))
Definition: cons.c:4328
type_lp.h
type definitions for LP management
SCIP_Sol
Definition: struct_sol.h:73
SCIP_Set
Definition: struct_set.h:73
SCIP_DECL_CONSCHECK
SCIP_DECL_CONSCHECK(ConshdlrSubtour::scip_check)
Definition: ConshdlrSubtour.cpp:429
SCIPconsDisable
SCIP_RETCODE SCIPconsDisable(SCIP_CONS *cons, SCIP_SET *set, SCIP_STAT *stat)
Definition: cons.c:6970
SCIP_DECL_CONSINITSOL
#define SCIP_DECL_CONSINITSOL(x)
Definition: type_cons.h:201
SCIPconshdlrPresolve
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:3995
SCIPconshdlrSetActive
void SCIPconshdlrSetActive(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSACTIVE((*consactive)))
Definition: cons.c:4456
SCIP_HashMap
Definition: struct_misc.h:137
pub_cons.h
public methods for managing constraints
SCIPconshdlrInitLP
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:2772
SCIP_LOCKTYPE
enum SCIP_LockType SCIP_LOCKTYPE
Definition: type_var.h:100
SCIPconsGetPermsymGraph
SCIP_RETCODE SCIPconsGetPermsymGraph(SCIP_CONS *cons, SCIP_SET *set, SYM_GRAPH *graph, SCIP_Bool *success)
Definition: cons.c:6418
SCIP_Cons
Definition: struct_cons.h:46
SCIPconshdlrsResetPropagationStatus
SCIP_RETCODE SCIPconshdlrsResetPropagationStatus(SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_CONSHDLR **conshdlrs, int nconshdlrs)
Definition: cons.c:7993
SCIPconshdlrPropagate
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:3824
SCIP_Conshdlr
Definition: struct_cons.h:126
SCIP_DECL_CONSPARSE
#define SCIP_DECL_CONSPARSE(x)
Definition: type_cons.h:844
SCIPconsSetPropagated
SCIP_RETCODE SCIPconsSetPropagated(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool propagate)
Definition: cons.c:6743
SCIPconshdlrSetGetPermsymGraph
void SCIPconshdlrSetGetPermsymGraph(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETPERMSYMGRAPH((*consgetpermsymgraph)))
Definition: cons.c:4566
SCIPconsRelease
SCIP_RETCODE SCIPconsRelease(SCIP_CONS **cons, BMS_BLKMEM *blkmem, SCIP_SET *set)
Definition: cons.c:6268
SCIPconshdlrSetDelete
void SCIPconshdlrSetDelete(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDELETE((*consdelete)))
Definition: cons.c:4412
SCIP_DECL_CONSDEACTIVE
#define SCIP_DECL_CONSDEACTIVE(x)
Definition: type_cons.h:705
SCIPconsAddAge
SCIP_RETCODE SCIPconsAddAge(SCIP_CONS *cons, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_Real deltaage, SCIP_REOPT *reopt)
Definition: cons.c:7199
SCIPconshdlrSetCopy
void SCIPconshdlrSetCopy(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), SCIP_DECL_CONSCOPY((*conscopy)))
Definition: cons.c:4291
SCIPconshdlrSetParse
void SCIPconshdlrSetParse(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPARSE((*consparse)))
Definition: cons.c:4522
SCIP_DECL_CONSTRANS
SCIP_DECL_CONSTRANS(ConshdlrSubtour::scip_trans)
Definition: ConshdlrSubtour.cpp:244
SCIPconshdlrInit
SCIP_RETCODE SCIPconshdlrInit(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
Definition: cons.c:2413
SCIP_DECL_HASHGETKEY
SCIP_DECL_HASHGETKEY(SCIPhashGetKeyCons)
Definition: cons.c:7914
SCIPconshdlrSeparateLP
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:2879
SCIP_DECL_CONSGETPERMSYMGRAPH
#define SCIP_DECL_CONSGETPERMSYMGRAPH(x)
Definition: type_cons.h:937
SCIP_DECL_CONSDISABLE
#define SCIP_DECL_CONSDISABLE(x)
Definition: type_cons.h:735
SCIP_DECL_CONSDELVARS
SCIP_DECL_CONSDELVARS(ConshdlrSubtour::scip_delvars)
Definition: ConshdlrSubtour.cpp:564
SCIP_PRESOLTIMING
unsigned int SCIP_PRESOLTIMING
Definition: type_timing.h:61
type_var.h
type definitions for problem variables
SCIP_DECL_CONSENABLE
#define SCIP_DECL_CONSENABLE(x)
Definition: type_cons.h:720
SCIPconshdlrSetPresol
SCIP_RETCODE SCIPconshdlrSetPresol(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPRESOL((*conspresol)), int maxprerounds, SCIP_PRESOLTIMING presoltiming)
Definition: cons.c:4383
type_sepastore.h
type definitions for storing separated cuts
SCIP_CONSDATA
struct SCIP_ConsData SCIP_CONSDATA
Definition: type_cons.h:65
SCIPconsPresol
SCIP_RETCODE SCIPconsPresol(SCIP_CONS *cons, SCIP_SET *set, int nrounds, SCIP_PRESOLTIMING timing, int nnewfixedvars, int nnewaggrvars, int nnewchgvartypes, int nnewchgbds, int nnewholes, int nnewdelconss, int nnewaddconss, int nnewupgdconss, int nnewchgcoefs, int nnewchgsides, int *nfixedvars, int *naggrvars, int *nchgvartypes, int *nchgbds, int *naddholes, int *ndelconss, int *naddconss, int *nupgdconss, int *nchgcoefs, int *nchgsides, SCIP_RESULT *result)
Definition: cons.c:7786
SCIPconsResetAge
SCIP_RETCODE SCIPconsResetAge(SCIP_CONS *cons, SCIP_SET *set)
Definition: cons.c:7279
SCIP_DECL_CONSGETVARS
#define SCIP_DECL_CONSGETVARS(x)
Definition: type_cons.h:866
SCIP_DECL_CONSEXIT
#define SCIP_DECL_CONSEXIT(x)
Definition: type_cons.h:136
SCIPconshdlrSetTrans
void SCIPconshdlrSetTrans(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSTRANS((*constrans)))
Definition: cons.c:4423
SCIPconsSetInitial
SCIP_RETCODE SCIPconsSetInitial(SCIP_CONS *cons, SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool initial)
Definition: cons.c:6591
SCIP_Bool
#define SCIP_Bool
Definition: def.h:91
SCIPconshdlrExitpre
SCIP_RETCODE SCIPconshdlrExitpre(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
Definition: cons.c:2655
SCIP_DECL_CONSPROP
SCIP_DECL_CONSPROP(ConshdlrSubtour::scip_prop)
Definition: ConshdlrSubtour.cpp:476
SCIPconsDisableSeparation
SCIP_RETCODE SCIPconsDisableSeparation(SCIP_CONS *cons, SCIP_SET *set)
Definition: cons.c:7034
SCIPconsActive
SCIP_RETCODE SCIPconsActive(SCIP_CONS *cons, SCIP_SET *set)
Definition: cons.c:7860
SCIP_Diveset
Definition: struct_heur.h:67
SCIPconsDeactivate
SCIP_RETCODE SCIPconsDeactivate(SCIP_CONS *cons, SCIP_SET *set, SCIP_STAT *stat)
Definition: cons.c:6902
SCIPconsGetSignedPermsymGraph
SCIP_RETCODE SCIPconsGetSignedPermsymGraph(SCIP_CONS *cons, SCIP_SET *set, SYM_GRAPH *graph, SCIP_Bool *success)
Definition: cons.c:6451
SCIPconsCapture
void SCIPconsCapture(SCIP_CONS *cons)
Definition: cons.c:6256
SCIPconshdlrEnableOrDisableClocks
void SCIPconshdlrEnableOrDisableClocks(SCIP_CONSHDLR *conshdlr, SCIP_Bool enable)
Definition: cons.c:4702
SCIP_DECL_CONSEXITPRE
#define SCIP_DECL_CONSEXITPRE(x)
Definition: type_cons.h:180
SCIPconssetchgMakeGlobal
SCIP_RETCODE SCIPconssetchgMakeGlobal(SCIP_CONSSETCHG **conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_REOPT *reopt)
Definition: cons.c:5782
SCIPconssetchgUndo
SCIP_RETCODE SCIPconssetchgUndo(SCIP_CONSSETCHG *conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
Definition: cons.c:5696
SCIPconshdlrInitpre
SCIP_RETCODE SCIPconshdlrInitpre(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
Definition: cons.c:2569
SCIPconssetchgAddAddedCons
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:5445
SCIPconshdlrSetDelvars
void SCIPconshdlrSetDelvars(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDELVARS((*consdelvars)))
Definition: cons.c:4500
SCIP_Reopt
Definition: struct_reopt.h:139
SCIPconsPrint
SCIP_RETCODE SCIPconsPrint(SCIP_CONS *cons, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, FILE *file)
Definition: cons.c:6308
SCIPconshdlrSetExitpre
void SCIPconshdlrSetExitpre(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSEXITPRE((*consexitpre)))
Definition: cons.c:4372
type_tree.h
type definitions for branch and bound tree
SCIPconsDisablePropagation
SCIP_RETCODE SCIPconsDisablePropagation(SCIP_CONS *cons, SCIP_SET *set)
Definition: cons.c:7092
SCIPconshdlrGetDiveBoundChanges
SCIP_RETCODE SCIPconshdlrGetDiveBoundChanges(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, SCIP_DIVESET *diveset, SCIP_SOL *sol, SCIP_Bool *success, SCIP_Bool *infeasible)
Definition: cons.c:3531
SCIPconshdlrUnlockVars
SCIP_RETCODE SCIPconshdlrUnlockVars(SCIP_CONSHDLR *conshdlr, SCIP_SET *set)
Definition: cons.c:4184
type_sol.h
type definitions for storing primal CIP solutions
type_prob.h
type definitions for storing and manipulating the main problem
SCIPconsCopy
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:6020
SCIPconshdlrSetEnable
void SCIPconshdlrSetEnable(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSENABLE((*consenable)))
Definition: cons.c:4478
SCIPconshdlrSetGetVars
void SCIPconshdlrSetGetVars(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETVARS((*consgetvars)))
Definition: cons.c:4533
SCIPconsProp
SCIP_RETCODE SCIPconsProp(SCIP_CONS *cons, SCIP_SET *set, SCIP_PROPTIMING proptiming, SCIP_RESULT *result)
Definition: cons.c:7704
SCIPconsInitlp
SCIP_RETCODE SCIPconsInitlp(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool *infeasible)
Definition: cons.c:7594
SCIPconshdlrDelVars
SCIP_RETCODE SCIPconshdlrDelVars(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
Definition: cons.c:4138
SCIPconsSepalp
SCIP_RETCODE SCIPconsSepalp(SCIP_CONS *cons, SCIP_SET *set, SCIP_RESULT *result)
Definition: cons.c:7620
SCIPconsSetModifiable
void SCIPconsSetModifiable(SCIP_CONS *cons, SCIP_Bool modifiable)
Definition: cons.c:6791
SCIPconshdlrCreate
SCIP_RETCODE SCIPconshdlrCreate(SCIP_CONSHDLR **conshdlr, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, int sepapriority, int enfopriority, int checkpriority, int sepafreq, int propfreq, int eagerfreq, int maxprerounds, SCIP_Bool delaysepa, SCIP_Bool delayprop, SCIP_Bool needscons, SCIP_PROPTIMING proptiming, SCIP_PRESOLTIMING presoltiming, SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), SCIP_DECL_CONSFREE((*consfree)), SCIP_DECL_CONSINIT((*consinit)), SCIP_DECL_CONSEXIT((*consexit)), SCIP_DECL_CONSINITPRE((*consinitpre)), SCIP_DECL_CONSEXITPRE((*consexitpre)), SCIP_DECL_CONSINITSOL((*consinitsol)), SCIP_DECL_CONSEXITSOL((*consexitsol)), SCIP_DECL_CONSDELETE((*consdelete)), SCIP_DECL_CONSTRANS((*constrans)), SCIP_DECL_CONSINITLP((*consinitlp)), SCIP_DECL_CONSSEPALP((*conssepalp)), SCIP_DECL_CONSSEPASOL((*conssepasol)), SCIP_DECL_CONSENFOLP((*consenfolp)), SCIP_DECL_CONSENFORELAX((*consenforelax)), SCIP_DECL_CONSENFOPS((*consenfops)), SCIP_DECL_CONSCHECK((*conscheck)), SCIP_DECL_CONSPROP((*consprop)), SCIP_DECL_CONSPRESOL((*conspresol)), SCIP_DECL_CONSRESPROP((*consresprop)), SCIP_DECL_CONSLOCK((*conslock)), SCIP_DECL_CONSACTIVE((*consactive)), SCIP_DECL_CONSDEACTIVE((*consdeactive)), SCIP_DECL_CONSENABLE((*consenable)), SCIP_DECL_CONSDISABLE((*consdisable)), SCIP_DECL_CONSDELVARS((*consdelvars)), SCIP_DECL_CONSPRINT((*consprint)), SCIP_DECL_CONSCOPY((*conscopy)), SCIP_DECL_CONSPARSE((*consparse)), SCIP_DECL_CONSGETVARS((*consgetvars)), SCIP_DECL_CONSGETNVARS((*consgetnvars)), SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs)), SCIP_DECL_CONSGETPERMSYMGRAPH((*consgetpermsymgraph)), SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH((*consgetsignedpermsymgraph)), SCIP_CONSHDLRDATA *conshdlrdata)
Definition: cons.c:2288
type_mem.h
type definitions for block memory pools and memory buffers
SCIPconsMarkPropagate
SCIP_RETCODE SCIPconsMarkPropagate(SCIP_CONS *cons, SCIP_SET *set)
Definition: cons.c:7132
SCIPconshdlrEnforceRelaxSol
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:3165
SCIP_PROPTIMING
unsigned int SCIP_PROPTIMING
Definition: type_timing.h:75
SCIPconshdlrEnforceLPSol
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:3353
SCIPconsGetNVars
SCIP_RETCODE SCIPconsGetNVars(SCIP_CONS *cons, SCIP_SET *set, int *nvars, SCIP_Bool *success)
Definition: cons.c:6383
SCIPconsChgName
SCIP_RETCODE SCIPconsChgName(SCIP_CONS *cons, BMS_BLKMEM *blkmem, const char *name)
Definition: cons.c:6181
SCIPconsSetChecked
SCIP_RETCODE SCIPconsSetChecked(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool check)
Definition: cons.c:6695
SCIP_DECL_CONSFREE
#define SCIP_DECL_CONSFREE(x)
Definition: type_cons.h:116
SCIPconsEnfops
SCIP_RETCODE SCIPconsEnfops(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool solinfeasible, SCIP_Bool objinfeasible, SCIP_RESULT *result)
Definition: cons.c:7464
SCIPconsCheck
SCIP_RETCODE SCIPconsCheck(SCIP_CONS *cons, SCIP_SET *set, SCIP_SOL *sol, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool printreason, SCIP_RESULT *result)
Definition: cons.c:7426
SCIPconshdlrSetPrint
void SCIPconshdlrSetPrint(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPRINT((*consprint)))
Definition: cons.c:4511
SCIPconshdlrIncNCutsFound
void SCIPconshdlrIncNCutsFound(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4932
SCIP_DECL_CONSINIT
#define SCIP_DECL_CONSINIT(x)
Definition: type_cons.h:126
SCIP_DECL_CONSLOCK
SCIP_DECL_CONSLOCK(ConshdlrSubtour::scip_lock)
Definition: ConshdlrSubtour.cpp:534
SCIP_DECL_CONSENFORELAX
#define SCIP_DECL_CONSENFORELAX(x)
Definition: type_cons.h:388
SCIP_Real
#define SCIP_Real
Definition: def.h:173
SCIP_ConsSetChg
Definition: struct_cons.h:115
SCIP_DECL_CONSPRINT
SCIP_DECL_CONSPRINT(ConshdlrSubtour::scip_print)
Definition: ConshdlrSubtour.cpp:574
type_result.h
result codes for SCIP callback methods
SCIPconshdlrSetInitlp
void SCIPconshdlrSetInitlp(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITLP((*consinitlp)))
Definition: cons.c:4434
SYM_Graph
Definition: struct_symmetry.h:45
SCIPconsSetRemovable
void SCIPconsSetRemovable(SCIP_CONS *cons, SCIP_Bool removable)
Definition: cons.c:6813
SCIPconsCreate
SCIP_RETCODE SCIPconsCreate(SCIP_CONS **cons, BMS_BLKMEM *blkmem, SCIP_SET *set, const char *name, SCIP_CONSHDLR *conshdlr, SCIP_CONSDATA *consdata, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode, SCIP_Bool original, SCIP_Bool deleteconsdata)
Definition: cons.c:5878
SCIP_DECL_CONSACTIVE
#define SCIP_DECL_CONSACTIVE(x)
Definition: type_cons.h:690
SCIPconshdlrSetInit
void SCIPconshdlrSetInit(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINIT((*consinit)))
Definition: cons.c:4317
SCIPconsSetDynamic
void SCIPconsSetDynamic(SCIP_CONS *cons, SCIP_Bool dynamic)
Definition: cons.c:6802
SCIPconsSetStickingAtNode
void SCIPconsSetStickingAtNode(SCIP_CONS *cons, SCIP_Bool stickingatnode)
Definition: cons.c:6824
SCIPconshdlrIncNAppliedCuts
void SCIPconshdlrIncNAppliedCuts(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4922
type_message.h
type definitions for message output methods
SCIP_DECL_CONSHDLRCOPY
#define SCIP_DECL_CONSHDLRCOPY(x)
Definition: type_cons.h:108
SCIP_CONSHDLRDATA
struct SCIP_ConshdlrData SCIP_CONSHDLRDATA
Definition: type_cons.h:64
SCIP_DECL_CONSCOPY
SCIP_DECL_CONSCOPY(ConshdlrSubtour::scip_copy)
Definition: ConshdlrSubtour.cpp:603
SCIPconsMarkConflict
void SCIPconsMarkConflict(SCIP_CONS *cons)
Definition: cons.c:7122
SCIP_Stat
Definition: struct_stat.h:59
SCIP_Tree
Definition: struct_tree.h:184
SCIPconsGetVars
SCIP_RETCODE SCIPconsGetVars(SCIP_CONS *cons, SCIP_SET *set, SCIP_VAR **vars, int varssize, SCIP_Bool *success)
Definition: cons.c:6347
SCIPconsSetSeparated
SCIP_RETCODE SCIPconsSetSeparated(SCIP_CONS *cons, SCIP_SET *set, SCIP_Bool separate)
Definition: cons.c:6625
def.h
common defines and data types used in all packages of SCIP
BMS_BLKMEM
struct BMS_BlkMem BMS_BLKMEM
Definition: memory.h:437
SCIP_BranchCand
Definition: struct_branch.h:46
SCIPconshdlrExitsol
SCIP_RETCODE SCIPconshdlrExitsol(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool restart)
Definition: cons.c:2735
SCIPconshdlrSetDisable
void SCIPconshdlrSetDisable(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDISABLE((*consdisable)))
Definition: cons.c:4489
type_cons.h
type definitions for constraints and constraint handlers
SCIPconshdlrSetGetNVars
void SCIPconshdlrSetGetNVars(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETNVARS((*consgetnvars)))
Definition: cons.c:4544
SCIPconshdlrSetFree
void SCIPconshdlrSetFree(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSFREE((*consfree)))
Definition: cons.c:4306
memory.h
memory allocation routines