Scippy

SCIP

Solving Constraint Integer Programs

pub_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-2015 Konrad-Zuse-Zentrum */
7 /* fuer Informationstechnik Berlin */
8 /* */
9 /* SCIP is distributed under the terms of the ZIB Academic License. */
10 /* */
11 /* You should have received a copy of the ZIB Academic License */
12 /* along with SCIP; see the file COPYING. If not email to scip@zib.de. */
13 /* */
14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15 
16 /**@file pub_cons.h
17  * @ingroup PUBLICMETHODS
18  * @brief public methods for managing constraints
19  * @author Tobias Achterberg
20  */
21 
22 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
23 
24 #ifndef __SCIP_PUB_CONS_H__
25 #define __SCIP_PUB_CONS_H__
26 
27 
28 #include "scip/def.h"
29 #include "scip/type_misc.h"
30 #include "scip/type_cons.h"
31 
32 #ifdef NDEBUG
33 #include "scip/struct_cons.h"
34 #endif
35 
36 #ifdef __cplusplus
37 extern "C" {
38 #endif
39 
40 /*
41  * Constraint handler methods
42  */
43 
44 /** compares two constraint handlers w. r. to their separation priority */
45 extern
46 SCIP_DECL_SORTPTRCOMP(SCIPconshdlrCompSepa);
47 
48 /** compares two constraint handlers w. r. to their enforcing priority */
49 extern
50 SCIP_DECL_SORTPTRCOMP(SCIPconshdlrCompEnfo);
51 
52 /** compares two constraint handlers w. r. to their feasibility check priority */
53 extern
54 SCIP_DECL_SORTPTRCOMP(SCIPconshdlrCompCheck);
55 
56 /** gets name of constraint handler */
57 extern
58 const char* SCIPconshdlrGetName(
59  SCIP_CONSHDLR* conshdlr /**< constraint handler */
60  );
61 
62 /** gets description of constraint handler */
63 extern
64 const char* SCIPconshdlrGetDesc(
65  SCIP_CONSHDLR* conshdlr /**< constraint handler */
66  );
67 
68 /** gets user data of constraint handler */
69 extern
71  SCIP_CONSHDLR* conshdlr /**< constraint handler */
72  );
73 
74 /** sets user data of constraint handler; user has to free old data in advance! */
75 extern
77  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
78  SCIP_CONSHDLRDATA* conshdlrdata /**< new constraint handler user data */
79  );
80 
81 /** sets all separation related callbacks of the constraint handler */
82 extern
84  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
85  SCIP_DECL_CONSSEPALP ((*conssepalp)), /**< separate cutting planes for LP solution */
86  SCIP_DECL_CONSSEPASOL ((*conssepasol)), /**< separate cutting planes for arbitrary primal solution */
87  int sepafreq, /**< frequency for separating cuts; zero means to separate only in the root node */
88  int sepapriority, /**< priority of the constraint handler for separation */
89  SCIP_Bool delaysepa /**< should separation method be delayed, if other separators found cuts? */
90  );
91 
92 /** sets both the propagation callback and the propagation frequency of the constraint handler */
93 extern
95  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
96  SCIP_DECL_CONSPROP ((*consprop)), /**< propagate variable domains */
97  int propfreq, /**< frequency for propagating domains; zero means only preprocessing propagation */
98  SCIP_Bool delayprop, /**< should propagation method be delayed, if other propagators found reductions? */
99  SCIP_PROPTIMING timingmask /**< positions in the node solving loop where propagators should be executed */
100  );
101 
102 /** gets array with constraints of constraint handler; the first SCIPconshdlrGetNActiveConss() entries are the active
103  * constraints, the last SCIPconshdlrGetNConss() - SCIPconshdlrGetNActiveConss() constraints are deactivated
104  *
105  * @note A constraint is active if it is global and was not removed or it was added locally (in that case the local
106  * flag is TRUE) and the current node belongs to the corresponding sub tree.
107  */
108 extern
110  SCIP_CONSHDLR* conshdlr /**< constraint handler */
111  );
112 
113 /** gets array with enforced constraints of constraint handler; this is local information */
114 extern
116  SCIP_CONSHDLR* conshdlr /**< constraint handler */
117  );
118 
119 /** gets array with checked constraints of constraint handler; this is local information */
120 extern
122  SCIP_CONSHDLR* conshdlr /**< constraint handler */
123  );
124 
125 /** gets total number of existing transformed constraints of constraint handler */
126 extern
128  SCIP_CONSHDLR* conshdlr /**< constraint handler */
129  );
130 
131 /** gets number of enforced constraints of constraint handler; this is local information */
132 extern
134  SCIP_CONSHDLR* conshdlr /**< constraint handler */
135  );
136 
137 /** gets number of checked constraints of constraint handler; this is local information */
138 extern
140  SCIP_CONSHDLR* conshdlr /**< constraint handler */
141  );
142 
143 /** gets number of active constraints of constraint handler
144  *
145  * @note A constraint is active if it is global and was not removed or it was added locally (in that case the local
146  * flag is TRUE) and the current node belongs to the corresponding sub tree.
147  */
148 extern
150  SCIP_CONSHDLR* conshdlr /**< constraint handler */
151  );
152 
153 /** gets number of enabled constraints of constraint handler */
154 extern
156  SCIP_CONSHDLR* conshdlr /**< constraint handler */
157  );
158 
159 /** gets time in seconds used for setting up this constraint handler for new stages */
160 extern
162  SCIP_CONSHDLR* conshdlr /**< constraint handler */
163  );
164 
165 /** gets time in seconds used for presolving in this constraint handler */
166 extern
168  SCIP_CONSHDLR* conshdlr /**< constraint handler */
169  );
170 
171 /** gets time in seconds used for separation in this constraint handler */
172 extern
174  SCIP_CONSHDLR* conshdlr /**< constraint handler */
175  );
176 
177 /** gets time in seconds used for LP enforcement in this constraint handler */
178 extern
180  SCIP_CONSHDLR* conshdlr /**< constraint handler */
181  );
182 
183 /** gets time in seconds used for pseudo enforcement in this constraint handler */
184 extern
186  SCIP_CONSHDLR* conshdlr /**< constraint handler */
187  );
188 
189 /** gets time in seconds used for propagation in this constraint handler */
190 extern
192  SCIP_CONSHDLR* conshdlr /**< constraint handler */
193  );
194 
195 /** gets time in seconds used for propagation in this constraint handler during strong branching */
196 extern
198  SCIP_CONSHDLR* conshdlr /**< constraint handler */
199  );
200 
201 /** gets time in seconds used for feasibility checking in this constraint handler */
202 extern
204  SCIP_CONSHDLR* conshdlr /**< constraint handler */
205  );
206 
207 /** gets time in seconds used for resolving propagation in this constraint handler */
208 extern
210  SCIP_CONSHDLR* conshdlr /**< constraint handler */
211  );
212 
213 /** gets number of calls to the constraint handler's separation method */
214 extern
216  SCIP_CONSHDLR* conshdlr /**< constraint handler */
217  );
218 
219 /** gets number of calls to the constraint handler's LP enforcing method */
220 extern
222  SCIP_CONSHDLR* conshdlr /**< constraint handler */
223  );
224 
225 /** gets number of calls to the constraint handler's pseudo enforcing method */
226 extern
228  SCIP_CONSHDLR* conshdlr /**< constraint handler */
229  );
230 
231 /** gets number of calls to the constraint handler's propagation method */
232 extern
234  SCIP_CONSHDLR* conshdlr /**< constraint handler */
235  );
236 
237 /** gets number of calls to the constraint handler's checking method */
238 extern
240  SCIP_CONSHDLR* conshdlr /**< constraint handler */
241  );
242 
243 /** gets number of calls to the constraint handler's resolve propagation method */
244 extern
246  SCIP_CONSHDLR* conshdlr /**< constraint handler */
247  );
248 
249 /** gets total number of times, this constraint handler detected a cutoff */
250 extern
252  SCIP_CONSHDLR* conshdlr /**< constraint handler */
253  );
254 
255 /** gets total number of cuts found by this constraint handler */
256 extern
258  SCIP_CONSHDLR* conshdlr /**< constraint handler */
259  );
260 
261 /** gets total number of cuts found by this constraint handler applied to lp */
262 extern
264  SCIP_CONSHDLR* conshdlr /**< constraint handler */
265  );
266 
267 /** gets total number of additional constraints added by this constraint handler */
268 extern
270  SCIP_CONSHDLR* conshdlr /**< constraint handler */
271  );
272 
273 /** gets total number of domain reductions found by this constraint handler */
274 extern
276  SCIP_CONSHDLR* conshdlr /**< constraint handler */
277  );
278 
279 /** gets number of children created by this constraint handler */
280 extern
282  SCIP_CONSHDLR* conshdlr /**< constraint handler */
283  );
284 
285 /** gets maximum number of active constraints of constraint handler existing at the same time */
286 extern
288  SCIP_CONSHDLR* conshdlr /**< constraint handler */
289  );
290 
291 /** gets initial number of active constraints of constraint handler */
292 extern
294  SCIP_CONSHDLR* conshdlr /**< constraint handler */
295  );
296 
297 /** gets number of variables fixed in presolving method of constraint handler */
298 extern
300  SCIP_CONSHDLR* conshdlr /**< constraint handler */
301  );
302 
303 /** gets number of variables aggregated in presolving method of constraint handler */
304 extern
306  SCIP_CONSHDLR* conshdlr /**< constraint handler */
307  );
308 
309 /** gets number of variable types changed in presolving method of constraint handler */
310 extern
312  SCIP_CONSHDLR* conshdlr /**< constraint handler */
313  );
314 
315 /** gets number of bounds changed in presolving method of constraint handler */
316 extern
318  SCIP_CONSHDLR* conshdlr /**< constraint handler */
319  );
320 
321 /** gets number of holes added to domains of variables in presolving method of constraint handler */
322 extern
324  SCIP_CONSHDLR* conshdlr /**< constraint handler */
325  );
326 
327 /** gets number of constraints deleted in presolving method of constraint handler */
328 extern
330  SCIP_CONSHDLR* conshdlr /**< constraint handler */
331  );
332 
333 /** gets number of constraints added in presolving method of constraint handler */
334 extern
336  SCIP_CONSHDLR* conshdlr /**< constraint handler */
337  );
338 
339 /** gets number of constraints upgraded in presolving method of constraint handler */
340 extern
342  SCIP_CONSHDLR* conshdlr /**< constraint handler */
343  );
344 
345 /** gets number of coefficients changed in presolving method of constraint handler */
346 extern
348  SCIP_CONSHDLR* conshdlr /**< constraint handler */
349  );
350 
351 /** gets number of constraint sides changed in presolving method of constraint handler */
352 extern
354  SCIP_CONSHDLR* conshdlr /**< constraint handler */
355  );
356 
357 /** gets number of times the presolving method of the constraint handler was called and tried to find reductions */
358 extern
360  SCIP_CONSHDLR* conshdlr /**< constraint handler */
361  );
362 
363 /** gets separation priority of constraint handler */
364 extern
366  SCIP_CONSHDLR* conshdlr /**< constraint handler */
367  );
368 
369 /** gets enforcing priority of constraint handler */
370 extern
372  SCIP_CONSHDLR* conshdlr /**< constraint handler */
373  );
374 
375 /** gets checking priority of constraint handler */
376 extern
378  SCIP_CONSHDLR* conshdlr /**< constraint handler */
379  );
380 
381 /** gets separation frequency of constraint handler */
382 extern
384  SCIP_CONSHDLR* conshdlr /**< constraint handler */
385  );
386 
387 /** gets propagation frequency of constraint handler */
388 extern
390  SCIP_CONSHDLR* conshdlr /**< constraint handler */
391  );
392 
393 /** gets frequency of constraint handler for eager evaluations in separation, propagation and enforcement */
394 extern
396  SCIP_CONSHDLR* conshdlr /**< constraint handler */
397  );
398 
399 /** needs constraint handler a constraint to be called? */
400 extern
402  SCIP_CONSHDLR* conshdlr /**< constraint handler */
403  );
404 
405 /** does the constraint handler perform presolving? */
406 extern
408  SCIP_CONSHDLR* conshdlr /**< constraint handler */
409  );
410 
411 /** should separation method be delayed, if other separators found cuts? */
412 extern
414  SCIP_CONSHDLR* conshdlr /**< constraint handler */
415  );
416 
417 /** should propagation method be delayed, if other propagators found reductions? */
418 extern
420  SCIP_CONSHDLR* conshdlr /**< constraint handler */
421  );
422 
423 /** was LP separation method delayed at the last call? */
424 extern
426  SCIP_CONSHDLR* conshdlr /**< constraint handler */
427  );
428 
429 /** was primal solution separation method delayed at the last call? */
430 extern
432  SCIP_CONSHDLR* conshdlr /**< constraint handler */
433  );
434 
435 /** was propagation method delayed at the last call? */
436 extern
438  SCIP_CONSHDLR* conshdlr /**< constraint handler */
439  );
440 
441 /** is constraint handler initialized? */
442 extern
444  SCIP_CONSHDLR* conshdlr /**< constraint handler */
445  );
446 
447 /** does the constraint handler have a copy function? */
448 extern
450  SCIP_CONSHDLR* conshdlr /**< constraint handler */
451  );
452 
453 /** returns the timing mask of the propagation method of the constraint handler */
454 extern
456  SCIP_CONSHDLR* conshdlr /**< constraint handler */
457  );
458 
459 /** sets the timing mask of the propagation method of the constraint handler */
460 extern
462  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
463  SCIP_PROPTIMING proptiming /**< timing mask to be set */
464  );
465 
466 
467 /** returns the timing mask of the presolving method of the constraint handler */
468 extern
470  SCIP_CONSHDLR* conshdlr /**< constraint handler */
471  );
472 
473 /** sets the timing mask of the presolving method of the constraint handler */
474 extern
476  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
477  SCIP_PRESOLTIMING presoltiming /** timing mask to be set */
478  );
479 
480 
481 /*
482  * Constraint methods
483  */
484 
485 /** returns the name of the constraint
486  *
487  * @note to change the name of a constraint, use SCIPchgConsName() from scip.h
488  */
489 extern
490 const char* SCIPconsGetName(
491  SCIP_CONS* cons /**< constraint */
492  );
493 
494 /** returns the position of constraint in the corresponding handler's conss array */
495 extern
496 int SCIPconsGetPos(
497  SCIP_CONS* cons /**< constraint */
498  );
499 
500 /** returns the constraint handler of the constraint */
501 extern
503  SCIP_CONS* cons /**< constraint */
504  );
505 
506 /** returns the constraint data field of the constraint */
507 extern
509  SCIP_CONS* cons /**< constraint */
510  );
511 
512 /** gets number of times, the constraint is currently captured */
513 extern
514 int SCIPconsGetNUses(
515  SCIP_CONS* cons /**< constraint */
516  );
517 
518 /** for an active constraint, returns the depth in the tree at which the constraint was activated */
519 extern
521  SCIP_CONS* cons /**< constraint */
522  );
523 
524 /** returns the depth in the tree at which the constraint is valid; returns INT_MAX, if the constraint is local
525  * and currently not active
526  */
527 extern
529  SCIP_CONS* cons /**< constraint */
530  );
531 
532 /** returns TRUE iff constraint is active in the current node */
533 extern
535  SCIP_CONS* cons /**< constraint */
536  );
537 
538 /** returns TRUE iff constraint is enabled in the current node */
539 extern
541  SCIP_CONS* cons /**< constraint */
542  );
543 
544 /** returns TRUE iff constraint's separation is enabled in the current node */
545 extern
547  SCIP_CONS* cons /**< constraint */
548  );
549 
550 /** returns TRUE iff constraint's propagation is enabled in the current node */
551 extern
553  SCIP_CONS* cons /**< constraint */
554  );
555 
556 /** returns TRUE iff constraint is deleted or marked to be deleted */
557 extern
559  SCIP_CONS* cons /**< constraint */
560  );
561 
562 /** returns TRUE iff constraint is marked obsolete */
563 extern
565  SCIP_CONS* cons /**< constraint */
566  );
567 
568 /** gets age of constraint */
569 extern
571  SCIP_CONS* cons /**< constraint */
572  );
573 
574 /** returns TRUE iff the LP relaxation of constraint should be in the initial LP */
575 extern
577  SCIP_CONS* cons /**< constraint */
578  );
579 
580 /** returns TRUE iff constraint should be separated during LP processing */
581 extern
583  SCIP_CONS* cons /**< constraint */
584  );
585 
586 /** returns TRUE iff constraint should be enforced during node processing */
587 extern
589  SCIP_CONS* cons /**< constraint */
590  );
591 
592 /** returns TRUE iff constraint should be checked for feasibility */
593 extern
595  SCIP_CONS* cons /**< constraint */
596  );
597 
598 /** returns whether the constraint is marked for propagation */
599 extern
601  SCIP_CONS* cons /**< constraint */
602  );
603 
604 /** returns TRUE iff constraint should be propagated during node processing */
605 extern
607  SCIP_CONS* cons /**< constraint */
608  );
609 
610 /** returns TRUE iff constraint is globally valid */
611 extern
613  SCIP_CONS* cons /**< constraint */
614  );
615 
616 /** returns TRUE iff constraint is only locally valid or not added to any (sub)problem */
617 extern
619  SCIP_CONS* cons /**< constraint */
620  );
621 
622 /** returns TRUE iff constraint is modifiable (subject to column generation) */
623 extern
625  SCIP_CONS* cons /**< constraint */
626  );
627 
628 /** returns TRUE iff constraint is subject to aging */
629 extern
631  SCIP_CONS* cons /**< constraint */
632  );
633 
634 /** returns TRUE iff constraint's relaxation should be removed from the LP due to aging or cleanup */
635 extern
637  SCIP_CONS* cons /**< constraint */
638  );
639 
640 /** returns TRUE iff constraint's relaxation should be removed from the LP due to aging or cleanup */
641 extern
643  SCIP_CONS* cons /**< constraint */
644  );
645 
646 /** returns TRUE iff constraint belongs to the global problem */
647 extern
649  SCIP_CONS* cons /**< constraint */
650  );
651 
652 /** returns TRUE iff constraint is belonging to original space */
653 extern
655  SCIP_CONS* cons /**< constraint */
656  );
657 
658 /** returns TRUE iff constraint is belonging to transformed space */
659 extern
661  SCIP_CONS* cons /**< constraint */
662  );
663 
664 /** returns TRUE iff roundings for variables in constraint are locked */
665 extern
667  SCIP_CONS* cons /**< constraint */
668  );
669 
670 /** returns TRUE iff roundings for variables in constraint's negation are locked */
671 extern
673  SCIP_CONS* cons /**< constraint */
674  );
675 
676 /** returns TRUE iff roundings for variables in constraint or in constraint's negation are locked */
677 extern
679  SCIP_CONS* cons /**< constraint */
680  );
681 
682 /** get number of times the roundings for variables in constraint are locked */
683 extern
685  SCIP_CONS* cons /**< constraint */
686  );
687 
688 /** get number of times the roundings for variables in constraint's negation are locked */
689 extern
691  SCIP_CONS* cons /**< constraint */
692  );
693 
694 /** returns if the constraint was already added to a SCIP instance */
695 extern
697  SCIP_CONS* cons /**< constraint */
698  );
699 
700 /** adds locks to (dis-)allow upgrading of constraint */
701 extern
703  SCIP_CONS* cons, /**< constraint to add locks */
704  int nlocks /**< number of locks to add */
705  );
706 
707 /** gets number of locks against upgrading the constraint, 0 means this constraint can be upgraded */
708 extern
710  SCIP_CONS* cons /**< constraint */
711  );
712 
713 #ifdef NDEBUG
714 
715 /* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
716  * speed up the algorithms.
717  */
718 
719 #define SCIPconsGetName(cons) (cons)->name
720 #define SCIPconsGetPos(cons) (cons)->consspos
721 #define SCIPconsGetHdlr(cons) (cons)->conshdlr
722 #define SCIPconsGetData(cons) (cons)->consdata
723 #define SCIPconsGetNUses(cons) (cons)->nuses
724 #define SCIPconsGetActiveDepth(cons) (cons)->activedepth
725 #define SCIPconsGetValidDepth(cons) (!(cons)->local ? 0 \
726  : !SCIPconsIsActive(cons) ? INT_MAX \
727  : (cons)->validdepth == -1 ? SCIPconsGetActiveDepth(cons) \
728  : (cons)->validdepth)
729 #define SCIPconsIsActive(cons) ((cons)->updateactivate || ((cons)->active && !(cons)->updatedeactivate))
730 #define SCIPconsIsEnabled(cons) ((cons)->updateenable || ((cons)->enabled && !(cons)->updatedisable))
731 #define SCIPconsIsSeparationEnabled(cons) \
732  (SCIPconsIsEnabled(cons) && ((cons)->updatesepaenable || ((cons)->sepaenabled && !(cons)->updatesepadisable)))
733 #define SCIPconsIsPropagationEnabled(cons) \
734  (SCIPconsIsEnabled(cons) && ((cons)->updatepropenable || ((cons)->propenabled && !(cons)->updatepropdisable)))
735 #define SCIPconsIsDeleted(cons) ((cons)->deleted)
736 #define SCIPconsIsObsolete(cons) ((cons)->updateobsolete || (cons)->obsolete)
737 #define SCIPconsGetAge(cons) (cons)->age
738 #define SCIPconsIsInitial(cons) (cons)->initial
739 #define SCIPconsIsSeparated(cons) (cons)->separate
740 #define SCIPconsIsEnforced(cons) (cons)->enforce
741 #define SCIPconsIsChecked(cons) (cons)->check
742 #define SCIPconsIsMarkedPropagate(cons) (cons)->markpropagate
743 #define SCIPconsIsPropagated(cons) (cons)->propagate
744 #define SCIPconsIsGlobal(cons) !(cons)->local
745 #define SCIPconsIsLocal(cons) (cons)->local
746 #define SCIPconsIsModifiable(cons) (cons)->modifiable
747 #define SCIPconsIsDynamic(cons) (cons)->dynamic
748 #define SCIPconsIsRemovable(cons) (cons)->removable
749 #define SCIPconsIsStickingAtNode(cons) (cons)->stickingatnode
750 #define SCIPconsIsInProb(cons) ((cons)->addconssetchg == NULL && (cons)->addarraypos >= 0)
751 #define SCIPconsIsOriginal(cons) (cons)->original
752 #define SCIPconsIsTransformed(cons) !(cons)->original
753 #define SCIPconsIsLockedPos(cons) ((cons)->nlockspos > 0)
754 #define SCIPconsIsLockedNeg(cons) ((cons)->nlocksneg > 0)
755 #define SCIPconsIsLocked(cons) ((cons)->nlockspos > 0 || (cons)->nlocksneg > 0)
756 #define SCIPconsGetNLocksPos(cons) ((cons)->nlockspos)
757 #define SCIPconsGetNLocksNeg(cons) ((cons)->nlocksneg)
758 #define SCIPconsIsAdded(cons) ((cons)->addarraypos >= 0)
759 #define SCIPconsGetNUpgradeLocks(cons) ((cons)->nupgradelocks)
760 
761 #endif
762 
763 #ifdef __cplusplus
764 }
765 #endif
766 
767 #endif
int SCIPconshdlrGetNCheckConss(SCIP_CONSHDLR *conshdlr)
SCIP_Bool SCIPconsIsInitial(SCIP_CONS *cons)
int SCIPconshdlrGetNEnfoConss(SCIP_CONSHDLR *conshdlr)
SCIP_Longint SCIPconshdlrGetNEnfoLPCalls(SCIP_CONSHDLR *conshdlr)
SCIP_Bool SCIPconsIsMarkedPropagate(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsStickingAtNode(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsModifiable(SCIP_CONS *cons)
struct SCIP_Cons SCIP_CONS
Definition: type_cons.h:48
SCIP_Real SCIPconshdlrGetStrongBranchPropTime(SCIP_CONSHDLR *conshdlr)
type definitions for miscellaneous datastructures
int SCIPconshdlrGetNChgBds(SCIP_CONSHDLR *conshdlr)
SCIP_Bool SCIPconsIsPropagated(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsOriginal(SCIP_CONS *cons)
int SCIPconsGetNUpgradeLocks(SCIP_CONS *cons)
int SCIPconshdlrGetNUpgdConss(SCIP_CONSHDLR *conshdlr)
int SCIPconshdlrGetNActiveConss(SCIP_CONSHDLR *conshdlr)
void SCIPconshdlrSetData(SCIP_CONSHDLR *conshdlr, SCIP_CONSHDLRDATA *conshdlrdata)
SCIP_Longint SCIPconshdlrGetNPropCalls(SCIP_CONSHDLR *conshdlr)
int SCIPconsGetActiveDepth(SCIP_CONS *cons)
SCIP_Real SCIPconshdlrGetPropTime(SCIP_CONSHDLR *conshdlr)
SCIP_Real SCIPconshdlrGetRespropTime(SCIP_CONSHDLR *conshdlr)
SCIP_Bool SCIPconsIsEnabled(SCIP_CONS *cons)
void SCIPconshdlrSetPropTiming(SCIP_CONSHDLR *conshdlr, SCIP_PROPTIMING proptiming)
SCIP_Bool SCIPconshdlrNeedsCons(SCIP_CONSHDLR *conshdlr)
int SCIPconsGetNUses(SCIP_CONS *cons)
SCIP_Bool SCIPconshdlrIsClonable(SCIP_CONSHDLR *conshdlr)
SCIP_Longint SCIPconshdlrGetNCutsFound(SCIP_CONSHDLR *conshdlr)
SCIP_Bool SCIPconshdlrIsPropagationDelayed(SCIP_CONSHDLR *conshdlr)
int SCIPconshdlrGetEnfoPriority(SCIP_CONSHDLR *conshdlr)
int SCIPconshdlrGetNChgCoefs(SCIP_CONSHDLR *conshdlr)
const char * SCIPconshdlrGetDesc(SCIP_CONSHDLR *conshdlr)
SCIP_CONSHDLR * SCIPconsGetHdlr(SCIP_CONS *cons)
void SCIPconshdlrSetProp(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPROP((*consprop)), int propfreq, SCIP_Bool delayprop, SCIP_PROPTIMING timingmask)
const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)
int SCIPconshdlrGetSepaPriority(SCIP_CONSHDLR *conshdlr)
int SCIPconshdlrGetCheckPriority(SCIP_CONSHDLR *conshdlr)
int SCIPconshdlrGetNEnabledConss(SCIP_CONSHDLR *conshdlr)
SCIP_Bool SCIPconshdlrIsSeparationDelayed(SCIP_CONSHDLR *conshdlr)
SCIP_Bool SCIPconsIsLocal(SCIP_CONS *cons)
SCIP_Bool SCIPconshdlrWasLPSeparationDelayed(SCIP_CONSHDLR *conshdlr)
SCIP_Bool SCIPconsIsInProb(SCIP_CONS *cons)
SCIP_Real SCIPconshdlrGetSetupTime(SCIP_CONSHDLR *conshdlr)
int SCIPconshdlrGetMaxNActiveConss(SCIP_CONSHDLR *conshdlr)
int SCIPconshdlrGetNAddConss(SCIP_CONSHDLR *conshdlr)
SCIP_PRESOLTIMING SCIPconshdlrGetPresolTiming(SCIP_CONSHDLR *conshdlr)
SCIP_Bool SCIPconsIsGlobal(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsLockedPos(SCIP_CONS *cons)
SCIP_PROPTIMING SCIPconshdlrGetPropTiming(SCIP_CONSHDLR *conshdlr)
SCIP_Real SCIPconshdlrGetSepaTime(SCIP_CONSHDLR *conshdlr)
SCIP_Bool SCIPconsIsDeleted(SCIP_CONS *cons)
void SCIPconsAddUpgradeLocks(SCIP_CONS *cons, int nlocks)
int SCIPconshdlrGetStartNActiveConss(SCIP_CONSHDLR *conshdlr)
SCIP_Real SCIPconshdlrGetEnfoLPTime(SCIP_CONSHDLR *conshdlr)
SCIP_Bool SCIPconsIsLocked(SCIP_CONS *cons)
SCIP_Longint SCIPconshdlrGetNCheckCalls(SCIP_CONSHDLR *conshdlr)
SCIP_Real SCIPconshdlrGetCheckTime(SCIP_CONSHDLR *conshdlr)
int SCIPconshdlrGetEagerFreq(SCIP_CONSHDLR *conshdlr)
int SCIPconshdlrGetSepaFreq(SCIP_CONSHDLR *conshdlr)
int SCIPconshdlrGetNAggrVars(SCIP_CONSHDLR *conshdlr)
SCIP_CONSDATA * SCIPconsGetData(SCIP_CONS *cons)
SCIP_Bool SCIPconshdlrWasPropagationDelayed(SCIP_CONSHDLR *conshdlr)
unsigned int SCIP_PRESOLTIMING
Definition: type_timing.h:50
SCIP_CONS ** SCIPconshdlrGetEnfoConss(SCIP_CONSHDLR *conshdlr)
SCIP_Real SCIPconshdlrGetPresolTime(SCIP_CONSHDLR *conshdlr)
int SCIPconshdlrGetNAddHoles(SCIP_CONSHDLR *conshdlr)
int SCIPconsGetNLocksPos(SCIP_CONS *cons)
struct SCIP_ConsData SCIP_CONSDATA
Definition: type_cons.h:50
SCIP_Bool SCIPconsIsObsolete(SCIP_CONS *cons)
#define SCIP_DECL_CONSSEPALP(x)
Definition: type_cons.h:239
SCIP_Longint SCIPconshdlrGetNEnfoPSCalls(SCIP_CONSHDLR *conshdlr)
int SCIPconshdlrGetPropFreq(SCIP_CONSHDLR *conshdlr)
#define SCIP_Bool
Definition: def.h:50
SCIP_Longint SCIPconshdlrGetNChildren(SCIP_CONSHDLR *conshdlr)
void SCIPconshdlrSetSepa(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSSEPALP((*conssepalp)), SCIP_DECL_CONSSEPASOL((*conssepasol)), int sepafreq, int sepapriority, SCIP_Bool delaysepa)
SCIP_Bool SCIPconsIsSeparationEnabled(SCIP_CONS *cons)
SCIP_CONS ** SCIPconshdlrGetCheckConss(SCIP_CONSHDLR *conshdlr)
int SCIPconshdlrGetNChgSides(SCIP_CONSHDLR *conshdlr)
int SCIPconshdlrGetNPresolCalls(SCIP_CONSHDLR *conshdlr)
SCIP_Bool SCIPconsIsSeparated(SCIP_CONS *cons)
SCIP_Longint SCIPconshdlrGetNRespropCalls(SCIP_CONSHDLR *conshdlr)
SCIP_DECL_SORTPTRCOMP(SCIPconshdlrCompSepa)
int SCIPconshdlrGetNFixedVars(SCIP_CONSHDLR *conshdlr)
SCIP_CONS ** SCIPconshdlrGetConss(SCIP_CONSHDLR *conshdlr)
int SCIPconsGetNLocksNeg(SCIP_CONS *cons)
int SCIPconshdlrGetNConss(SCIP_CONSHDLR *conshdlr)
unsigned int SCIP_PROPTIMING
Definition: type_timing.h:64
SCIP_Longint SCIPconshdlrGetNCutoffs(SCIP_CONSHDLR *conshdlr)
SCIP_Longint SCIPconshdlrGetNDomredsFound(SCIP_CONSHDLR *conshdlr)
SCIP_Bool SCIPconshdlrWasSolSeparationDelayed(SCIP_CONSHDLR *conshdlr)
SCIP_Bool SCIPconsIsChecked(SCIP_CONS *cons)
SCIP_Longint SCIPconshdlrGetNCutsApplied(SCIP_CONSHDLR *conshdlr)
SCIP_Bool SCIPconsIsActive(SCIP_CONS *cons)
SCIP_Real SCIPconshdlrGetEnfoPSTime(SCIP_CONSHDLR *conshdlr)
const char * SCIPconsGetName(SCIP_CONS *cons)
int SCIPconshdlrGetNChgVarTypes(SCIP_CONSHDLR *conshdlr)
SCIP_Bool SCIPconshdlrDoesPresolve(SCIP_CONSHDLR *conshdlr)
struct SCIP_Conshdlr SCIP_CONSHDLR
Definition: type_cons.h:47
SCIP_Longint SCIPconshdlrGetNSepaCalls(SCIP_CONSHDLR *conshdlr)
#define SCIP_Real
Definition: def.h:124
SCIP_Bool SCIPconsIsPropagationEnabled(SCIP_CONS *cons)
#define SCIP_DECL_CONSSEPASOL(x)
Definition: type_cons.h:271
#define SCIP_DECL_CONSPROP(x)
Definition: type_cons.h:421
void SCIPconshdlrSetPresolTiming(SCIP_CONSHDLR *conshdlr, SCIP_PRESOLTIMING presoltiming)
#define SCIP_Longint
Definition: def.h:109
int SCIPconsGetValidDepth(SCIP_CONS *cons)
SCIP_Real SCIPconsGetAge(SCIP_CONS *cons)
struct SCIP_ConshdlrData SCIP_CONSHDLRDATA
Definition: type_cons.h:49
SCIP_Longint SCIPconshdlrGetNConssFound(SCIP_CONSHDLR *conshdlr)
common defines and data types used in all packages of SCIP
SCIP_CONSHDLRDATA * SCIPconshdlrGetData(SCIP_CONSHDLR *conshdlr)
SCIP_Bool SCIPconsIsEnforced(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsLockedNeg(SCIP_CONS *cons)
int SCIPconsGetPos(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsAdded(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsTransformed(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsRemovable(SCIP_CONS *cons)
type definitions for constraints and constraint handlers
int SCIPconshdlrGetNDelConss(SCIP_CONSHDLR *conshdlr)
SCIP_Bool SCIPconsIsDynamic(SCIP_CONS *cons)
SCIP_Bool SCIPconshdlrIsInitialized(SCIP_CONSHDLR *conshdlr)