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-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 pub_cons.h
26 * @ingroup PUBLICCOREAPI
27 * @brief public methods for managing constraints
28 * @author Tobias Achterberg
29 */
30
31/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
32
33#ifndef __SCIP_PUB_CONS_H__
34#define __SCIP_PUB_CONS_H__
35
36
37#include "scip/def.h"
38#include "scip/type_misc.h"
39#include "scip/type_cons.h"
40
41#ifdef NDEBUG
42#include "scip/struct_cons.h"
43#endif
44
45#ifdef __cplusplus
46extern "C" {
47#endif
48
49/*
50 * Constraint handler methods
51 */
52
53/**@addtogroup PublicConshdlrMethods
54 *
55 * @{
56 */
57
58/** compares two constraint handlers w.r.t. their separation priority */
59SCIP_EXPORT
60SCIP_DECL_SORTPTRCOMP(SCIPconshdlrCompSepa);
61
62/** compares two constraint handlers w.r.t. their enforcing priority */
63SCIP_EXPORT
64SCIP_DECL_SORTPTRCOMP(SCIPconshdlrCompEnfo);
65
66/** compares two constraint handlers w.r.t. their feasibility check priority */
67SCIP_EXPORT
68SCIP_DECL_SORTPTRCOMP(SCIPconshdlrCompCheck);
69
70/** compares two constraints w.r.t. their feasibility check priority */
71SCIP_EXPORT
72SCIP_DECL_SORTPTRCOMP(SCIPconsCompCheck);
73
74/** gets name of constraint handler */
75SCIP_EXPORT
76const char* SCIPconshdlrGetName(
77 SCIP_CONSHDLR* conshdlr /**< constraint handler */
78 );
79
80/** gets description of constraint handler */
81SCIP_EXPORT
82const char* SCIPconshdlrGetDesc(
83 SCIP_CONSHDLR* conshdlr /**< constraint handler */
84 );
85
86/** gets user data of constraint handler */
87SCIP_EXPORT
89 SCIP_CONSHDLR* conshdlr /**< constraint handler */
90 );
91
92/** sets user data of constraint handler; user has to free old data in advance! */
93SCIP_EXPORT
95 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
96 SCIP_CONSHDLRDATA* conshdlrdata /**< new constraint handler user data */
97 );
98
99/** sets all separation related callbacks of the constraint handler */
100SCIP_EXPORT
102 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
103 SCIP_DECL_CONSSEPALP ((*conssepalp)), /**< separate cutting planes for LP solution */
104 SCIP_DECL_CONSSEPASOL ((*conssepasol)), /**< separate cutting planes for arbitrary primal solution */
105 int sepafreq, /**< frequency for separating cuts; zero means to separate only in the root node */
106 int sepapriority, /**< priority of the constraint handler for separation */
107 SCIP_Bool delaysepa /**< should separation method be delayed, if other separators found cuts? */
108 );
109
110/** sets both the propagation callback and the propagation frequency of the constraint handler */
111SCIP_EXPORT
113 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
114 SCIP_DECL_CONSPROP ((*consprop)), /**< propagate variable domains */
115 int propfreq, /**< frequency for propagating domains; zero means only preprocessing propagation */
116 SCIP_Bool delayprop, /**< should propagation method be delayed, if other propagators found reductions? */
117 SCIP_PROPTIMING timingmask /**< positions in the node solving loop where propagators should be executed */
118 );
119
120/** sets the relaxation enforcement method of the constraint handler */
121SCIP_EXPORT
123 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
124 SCIP_DECL_CONSENFORELAX ((*consenforelax)) /**< constraint copying method */
125 );
126
127/** gets array with constraints of constraint handler; the first SCIPconshdlrGetNActiveConss() entries are the active
128 * constraints, the last SCIPconshdlrGetNConss() - SCIPconshdlrGetNActiveConss() constraints are deactivated
129 *
130 * @note A constraint is active if it is global and was not removed or it was added locally (in that case the local
131 * flag is TRUE) and the current node belongs to the corresponding sub tree.
132 */
133SCIP_EXPORT
135 SCIP_CONSHDLR* conshdlr /**< constraint handler */
136 );
137
138/** gets array with enforced constraints of constraint handler; this is local information */
139SCIP_EXPORT
141 SCIP_CONSHDLR* conshdlr /**< constraint handler */
142 );
143
144/** gets array with checked constraints of constraint handler; this is local information */
145SCIP_EXPORT
147 SCIP_CONSHDLR* conshdlr /**< constraint handler */
148 );
149
150/** gets array with delayed update constraints
151 *
152 * @attention Usually, there should be no need to access this array. Use this only if you are absolutely sure what you are doing.
153 */
154SCIP_EXPORT
156 SCIP_CONSHDLR* conshdlr /**< constraint handler */
157 );
158
159/** gets total number of existing transformed constraints of constraint handler */
160SCIP_EXPORT
162 SCIP_CONSHDLR* conshdlr /**< constraint handler */
163 );
164
165/** gets number of enforced constraints of constraint handler; this is local information */
166SCIP_EXPORT
168 SCIP_CONSHDLR* conshdlr /**< constraint handler */
169 );
170
171/** gets number of checked constraints of constraint handler; this is local information */
172SCIP_EXPORT
174 SCIP_CONSHDLR* conshdlr /**< constraint handler */
175 );
176
177/** gets number of active constraints of constraint handler
178 *
179 * @note A constraint is active if it is global and was not removed or it was added locally (in that case the local
180 * flag is TRUE) and the current node belongs to the corresponding sub tree.
181 */
182SCIP_EXPORT
184 SCIP_CONSHDLR* conshdlr /**< constraint handler */
185 );
186
187/** gets number of enabled constraints of constraint handler */
188SCIP_EXPORT
190 SCIP_CONSHDLR* conshdlr /**< constraint handler */
191 );
192
193/** gets number of constraints that have delayed updates */
194SCIP_EXPORT
196 SCIP_CONSHDLR* conshdlr /**< constraint handler */
197 );
198
199/** gets time in seconds used for setting up this constraint handler for new stages */
200SCIP_EXPORT
202 SCIP_CONSHDLR* conshdlr /**< constraint handler */
203 );
204
205/** gets time in seconds used for presolving in this constraint handler */
206SCIP_EXPORT
208 SCIP_CONSHDLR* conshdlr /**< constraint handler */
209 );
210
211/** gets time in seconds used for separation in this constraint handler */
212SCIP_EXPORT
214 SCIP_CONSHDLR* conshdlr /**< constraint handler */
215 );
216
217/** gets time in seconds used for LP enforcement in this constraint handler */
218SCIP_EXPORT
220 SCIP_CONSHDLR* conshdlr /**< constraint handler */
221 );
222
223/** gets time in seconds used for pseudo enforcement in this constraint handler */
224SCIP_EXPORT
226 SCIP_CONSHDLR* conshdlr /**< constraint handler */
227 );
228
229/** gets time in seconds used for relaxation enforcement in this constraint handler */
230SCIP_EXPORT
232 SCIP_CONSHDLR* conshdlr /**< constraint handler */
233 );
234
235/** gets time in seconds used for propagation in this constraint handler */
236SCIP_EXPORT
238 SCIP_CONSHDLR* conshdlr /**< constraint handler */
239 );
240
241/** gets time in seconds used for propagation in this constraint handler during strong branching */
242SCIP_EXPORT
244 SCIP_CONSHDLR* conshdlr /**< constraint handler */
245 );
246
247/** gets time in seconds used for feasibility checking in this constraint handler */
248SCIP_EXPORT
250 SCIP_CONSHDLR* conshdlr /**< constraint handler */
251 );
252
253/** gets time in seconds used for resolving propagation in this constraint handler */
254SCIP_EXPORT
256 SCIP_CONSHDLR* conshdlr /**< constraint handler */
257 );
258
259/** gets number of calls to the constraint handler's separation method */
260SCIP_EXPORT
262 SCIP_CONSHDLR* conshdlr /**< constraint handler */
263 );
264
265/** gets number of calls to the constraint handler's LP enforcing method */
266SCIP_EXPORT
268 SCIP_CONSHDLR* conshdlr /**< constraint handler */
269 );
270
271/** gets number of calls to the constraint handler's pseudo enforcing method */
272SCIP_EXPORT
274 SCIP_CONSHDLR* conshdlr /**< constraint handler */
275 );
276
277/** gets number of calls to the constraint handler's relaxation enforcing method */
278SCIP_EXPORT
280 SCIP_CONSHDLR* conshdlr /**< constraint handler */
281 );
282
283/** gets number of calls to the constraint handler's propagation method */
284SCIP_EXPORT
286 SCIP_CONSHDLR* conshdlr /**< constraint handler */
287 );
288
289/** gets number of calls to the constraint handler's checking method */
290SCIP_EXPORT
292 SCIP_CONSHDLR* conshdlr /**< constraint handler */
293 );
294
295/** gets number of calls to the constraint handler's resolve propagation method */
296SCIP_EXPORT
298 SCIP_CONSHDLR* conshdlr /**< constraint handler */
299 );
300
301/** gets total number of times, this constraint handler detected a cutoff */
302SCIP_EXPORT
304 SCIP_CONSHDLR* conshdlr /**< constraint handler */
305 );
306
307/** gets total number of cuts found by this constraint handler */
308SCIP_EXPORT
310 SCIP_CONSHDLR* conshdlr /**< constraint handler */
311 );
312
313/** gets total number of cuts found by this constraint handler applied to lp */
314SCIP_EXPORT
316 SCIP_CONSHDLR* conshdlr /**< constraint handler */
317 );
318
319/** gets total number of additional constraints added by this constraint handler */
320SCIP_EXPORT
322 SCIP_CONSHDLR* conshdlr /**< constraint handler */
323 );
324
325/** gets total number of domain reductions found by this constraint handler */
326SCIP_EXPORT
328 SCIP_CONSHDLR* conshdlr /**< constraint handler */
329 );
330
331/** gets number of children created by this constraint handler */
332SCIP_EXPORT
334 SCIP_CONSHDLR* conshdlr /**< constraint handler */
335 );
336
337/** gets maximum number of active constraints of constraint handler existing at the same time */
338SCIP_EXPORT
340 SCIP_CONSHDLR* conshdlr /**< constraint handler */
341 );
342
343/** gets initial number of active constraints of constraint handler */
344SCIP_EXPORT
346 SCIP_CONSHDLR* conshdlr /**< constraint handler */
347 );
348
349/** gets number of variables fixed in presolving method of constraint handler */
350SCIP_EXPORT
352 SCIP_CONSHDLR* conshdlr /**< constraint handler */
353 );
354
355/** gets number of variables aggregated in presolving method of constraint handler */
356SCIP_EXPORT
358 SCIP_CONSHDLR* conshdlr /**< constraint handler */
359 );
360
361/** gets number of variable types changed in presolving method of constraint handler */
362SCIP_EXPORT
364 SCIP_CONSHDLR* conshdlr /**< constraint handler */
365 );
366
367/** gets number of bounds changed in presolving method of constraint handler */
368SCIP_EXPORT
370 SCIP_CONSHDLR* conshdlr /**< constraint handler */
371 );
372
373/** gets number of holes added to domains of variables in presolving method of constraint handler */
374SCIP_EXPORT
376 SCIP_CONSHDLR* conshdlr /**< constraint handler */
377 );
378
379/** gets number of constraints deleted in presolving method of constraint handler */
380SCIP_EXPORT
382 SCIP_CONSHDLR* conshdlr /**< constraint handler */
383 );
384
385/** gets number of constraints added in presolving method of constraint handler */
386SCIP_EXPORT
388 SCIP_CONSHDLR* conshdlr /**< constraint handler */
389 );
390
391/** gets number of constraints upgraded in presolving method of constraint handler */
392SCIP_EXPORT
394 SCIP_CONSHDLR* conshdlr /**< constraint handler */
395 );
396
397/** gets number of coefficients changed in presolving method of constraint handler */
398SCIP_EXPORT
400 SCIP_CONSHDLR* conshdlr /**< constraint handler */
401 );
402
403/** gets number of constraint sides changed in presolving method of constraint handler */
404SCIP_EXPORT
406 SCIP_CONSHDLR* conshdlr /**< constraint handler */
407 );
408
409/** gets number of times the presolving method of the constraint handler was called and tried to find reductions */
410SCIP_EXPORT
412 SCIP_CONSHDLR* conshdlr /**< constraint handler */
413 );
414
415/** gets separation priority of constraint handler */
416SCIP_EXPORT
418 SCIP_CONSHDLR* conshdlr /**< constraint handler */
419 );
420
421/** gets enforcing priority of constraint handler */
422SCIP_EXPORT
424 SCIP_CONSHDLR* conshdlr /**< constraint handler */
425 );
426
427/** gets checking priority of constraint handler */
428SCIP_EXPORT
430 SCIP_CONSHDLR* conshdlr /**< constraint handler */
431 );
432
433/** gets separation frequency of constraint handler */
434SCIP_EXPORT
436 SCIP_CONSHDLR* conshdlr /**< constraint handler */
437 );
438
439/** gets propagation frequency of constraint handler */
440SCIP_EXPORT
442 SCIP_CONSHDLR* conshdlr /**< constraint handler */
443 );
444
445/** gets frequency of constraint handler for eager evaluations in separation, propagation and enforcement */
446SCIP_EXPORT
448 SCIP_CONSHDLR* conshdlr /**< constraint handler */
449 );
450
451/** needs constraint handler a constraint to be called? */
452SCIP_EXPORT
454 SCIP_CONSHDLR* conshdlr /**< constraint handler */
455 );
456
457/** does the constraint handler perform presolving? */
458SCIP_EXPORT
460 SCIP_CONSHDLR* conshdlr /**< constraint handler */
461 );
462
463/** should separation method be delayed, if other separators found cuts? */
464SCIP_EXPORT
466 SCIP_CONSHDLR* conshdlr /**< constraint handler */
467 );
468
469/** should propagation method be delayed, if other propagators found reductions? */
470SCIP_EXPORT
472 SCIP_CONSHDLR* conshdlr /**< constraint handler */
473 );
474
475/** was LP separation method delayed at the last call? */
476SCIP_EXPORT
478 SCIP_CONSHDLR* conshdlr /**< constraint handler */
479 );
480
481/** was primal solution separation method delayed at the last call? */
482SCIP_EXPORT
484 SCIP_CONSHDLR* conshdlr /**< constraint handler */
485 );
486
487/** was propagation method delayed at the last call? */
488SCIP_EXPORT
490 SCIP_CONSHDLR* conshdlr /**< constraint handler */
491 );
492
493/** is constraint handler initialized? */
494SCIP_EXPORT
496 SCIP_CONSHDLR* conshdlr /**< constraint handler */
497 );
498
499/** does the constraint handler have a copy function? */
500SCIP_EXPORT
502 SCIP_CONSHDLR* conshdlr /**< constraint handler */
503 );
504
505/** returns the timing mask of the propagation method of the constraint handler */
506SCIP_EXPORT
508 SCIP_CONSHDLR* conshdlr /**< constraint handler */
509 );
510
511/*
512 * Methods for constraint change sets
513 */
514/** gets added constraints data for a constraint set change */
515SCIP_EXPORT
517 SCIP_CONSSETCHG* conssetchg, /**< constraint set change to get data from */
518 SCIP_CONS*** conss, /**< reference to constraints array added in the conssetchg, or NULL */
519 int* nconss /**< reference to store the size of the constraints array, or NULL */
520 );
521
522/** sets the timing mask of the propagation method of the constraint handler */
523SCIP_EXPORT
525 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
526 SCIP_PROPTIMING proptiming /**< timing mask to be set */
527 );
528
529
530/** returns the timing mask of the presolving method of the constraint handler */
531SCIP_EXPORT
533 SCIP_CONSHDLR* conshdlr /**< constraint handler */
534 );
535
536/** sets the timing mask of the presolving method of the constraint handler */
537SCIP_EXPORT
539 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
540 SCIP_PRESOLTIMING presoltiming /** timing mask to be set */
541 );
542
543/** returns whether conshdlr supports permutation symmetry detection */
544SCIP_EXPORT
546 SCIP_CONSHDLR* conshdlr /**< constraint handler */
547 );
548
549/** returns whether conshdlr supports signed permutation symmetry detection */
550SCIP_EXPORT
552 SCIP_CONSHDLR* conshdlr /**< constraint handler */
553 );
554
555/** @} */
556
557/*
558 * Constraint methods
559 */
560
561/**@addtogroup PublicConstraintMethods
562 *
563 * @{
564 */
565
566
567/** returns the name of the constraint
568 *
569 * @note to change the name of a constraint, use SCIPchgConsName() from scip.h
570 */
571SCIP_EXPORT
572const char* SCIPconsGetName(
573 SCIP_CONS* cons /**< constraint */
574 );
575
576/** returns the position of constraint in the corresponding handler's conss array */
577SCIP_EXPORT
579 SCIP_CONS* cons /**< constraint */
580 );
581
582/** returns the constraint handler of the constraint */
583SCIP_EXPORT
585 SCIP_CONS* cons /**< constraint */
586 );
587
588/** returns the constraint data field of the constraint */
589SCIP_EXPORT
591 SCIP_CONS* cons /**< constraint */
592 );
593
594/** gets number of times, the constraint is currently captured */
595SCIP_EXPORT
597 SCIP_CONS* cons /**< constraint */
598 );
599
600/** for an active constraint, returns the depth in the tree at which the constraint was activated */
601SCIP_EXPORT
603 SCIP_CONS* cons /**< constraint */
604 );
605
606/** returns the depth in the tree at which the constraint is valid; returns INT_MAX, if the constraint is local
607 * and currently not active
608 */
609SCIP_EXPORT
611 SCIP_CONS* cons /**< constraint */
612 );
613
614/** returns TRUE iff constraint is active in the current node */
615SCIP_EXPORT
617 SCIP_CONS* cons /**< constraint */
618 );
619
620/** returns TRUE iff constraint has to be deactivated in update phase */
621SCIP_EXPORT
623 SCIP_CONS* cons /**< constraint */
624 );
625
626/** returns TRUE iff constraint is enabled in the current node */
627SCIP_EXPORT
629 SCIP_CONS* cons /**< constraint */
630 );
631
632/** returns TRUE iff constraint's separation is enabled in the current node */
633SCIP_EXPORT
635 SCIP_CONS* cons /**< constraint */
636 );
637
638/** returns TRUE iff constraint's propagation is enabled in the current node */
639SCIP_EXPORT
641 SCIP_CONS* cons /**< constraint */
642 );
643
644/** returns TRUE iff constraint is deleted or marked to be deleted */
645SCIP_EXPORT
647 SCIP_CONS* cons /**< constraint */
648 );
649
650/** returns TRUE iff constraint is marked obsolete */
651SCIP_EXPORT
653 SCIP_CONS* cons /**< constraint */
654 );
655
656/** returns TRUE iff constraint is marked as a conflict */
657SCIP_EXPORT
659 SCIP_CONS* cons /**< constraint */
660 );
661
662/** gets age of constraint */
663SCIP_EXPORT
665 SCIP_CONS* cons /**< constraint */
666 );
667
668/** returns TRUE iff the LP relaxation of constraint should be in the initial LP */
669SCIP_EXPORT
671 SCIP_CONS* cons /**< constraint */
672 );
673
674/** returns TRUE iff constraint should be separated during LP processing */
675SCIP_EXPORT
677 SCIP_CONS* cons /**< constraint */
678 );
679
680/** returns TRUE iff constraint should be enforced during node processing */
681SCIP_EXPORT
683 SCIP_CONS* cons /**< constraint */
684 );
685
686/** returns TRUE iff constraint should be checked for feasibility */
687SCIP_EXPORT
689 SCIP_CONS* cons /**< constraint */
690 );
691
692/** returns whether the constraint is marked for propagation */
693SCIP_EXPORT
695 SCIP_CONS* cons /**< constraint */
696 );
697
698/** returns TRUE iff constraint should be propagated during node processing */
699SCIP_EXPORT
701 SCIP_CONS* cons /**< constraint */
702 );
703
704/** returns TRUE iff constraint is globally valid */
705SCIP_EXPORT
707 SCIP_CONS* cons /**< constraint */
708 );
709
710/** returns TRUE iff constraint is only locally valid or not added to any (sub)problem */
711SCIP_EXPORT
713 SCIP_CONS* cons /**< constraint */
714 );
715
716/** returns TRUE iff constraint is modifiable (subject to column generation) */
717SCIP_EXPORT
719 SCIP_CONS* cons /**< constraint */
720 );
721
722/** returns TRUE iff constraint is subject to aging */
723SCIP_EXPORT
725 SCIP_CONS* cons /**< constraint */
726 );
727
728/** returns TRUE iff constraint's relaxation should be removed from the LP due to aging or cleanup */
729SCIP_EXPORT
731 SCIP_CONS* cons /**< constraint */
732 );
733
734/** returns TRUE iff constraint's relaxation should be removed from the LP due to aging or cleanup */
735SCIP_EXPORT
737 SCIP_CONS* cons /**< constraint */
738 );
739
740/** returns TRUE iff constraint belongs to the global problem */
741SCIP_EXPORT
743 SCIP_CONS* cons /**< constraint */
744 );
745
746/** returns TRUE iff constraint is belonging to original space */
747SCIP_EXPORT
749 SCIP_CONS* cons /**< constraint */
750 );
751
752/** returns TRUE iff constraint is belonging to transformed space */
753SCIP_EXPORT
755 SCIP_CONS* cons /**< constraint */
756 );
757
758/** returns TRUE iff roundings for variables in constraint are locked */
759SCIP_EXPORT
761 SCIP_CONS* cons /**< constraint */
762 );
763
764/** returns TRUE iff roundings for variables in constraint's negation are locked */
765SCIP_EXPORT
767 SCIP_CONS* cons /**< constraint */
768 );
769
770/** returns TRUE iff roundings for variables in constraint or in constraint's negation are locked */
771SCIP_EXPORT
773 SCIP_CONS* cons /**< constraint */
774 );
775
776/** get number of times the roundings for variables in constraint are locked */
777SCIP_EXPORT
779 SCIP_CONS* cons /**< constraint */
780 );
781
782/** get number of times the roundings for variables in constraint's negation are locked */
783SCIP_EXPORT
785 SCIP_CONS* cons /**< constraint */
786 );
787
788/** returns TRUE iff roundings of the given locktype for variables in constraint are locked */
789SCIP_EXPORT
791 SCIP_CONS* cons, /**< constraint */
792 SCIP_LOCKTYPE locktype /**< variable lock type */
793 );
794
795/** returns TRUE iff roundings of the given locktype for variables in constraint are locked */
796SCIP_EXPORT
798 SCIP_CONS* cons, /**< constraint */
799 SCIP_LOCKTYPE locktype /**< variable lock type */
800 );
801
802/** returns TRUE iff roundings of the given locktype for variables in constraint or in constraint's negation are locked */
803SCIP_EXPORT
805 SCIP_CONS* cons, /**< constraint */
806 SCIP_LOCKTYPE locktype /**< variable lock type */
807 );
808
809/** get number of times the roundings of given locktype for variables in constraint are locked */
810SCIP_EXPORT
812 SCIP_CONS* cons, /**< constraint */
813 SCIP_LOCKTYPE locktype /**< variable lock type */
814 );
815
816/** get number of times the roundings of given locktype for variables in constraint's negation are locked */
817SCIP_EXPORT
819 SCIP_CONS* cons, /**< constraint */
820 SCIP_LOCKTYPE locktype /**< variable lock type */
821 );
822
823/** returns if the constraint was already added to a SCIP instance */
824SCIP_EXPORT
826 SCIP_CONS* cons /**< constraint */
827 );
828
829/** adds locks to (dis-)allow upgrading of constraint */
830SCIP_EXPORT
832 SCIP_CONS* cons, /**< constraint to add locks */
833 int nlocks /**< number of locks to add */
834 );
835
836/** gets number of locks against upgrading the constraint, 0 means this constraint can be upgraded */
837SCIP_EXPORT
839 SCIP_CONS* cons /**< constraint */
840 );
841
842#ifdef NDEBUG
843
844/* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
845 * speed up the algorithms.
846 */
847
848#define SCIPconsGetName(cons) (cons)->name
849#define SCIPconsGetPos(cons) (cons)->consspos
850#define SCIPconsGetHdlr(cons) (cons)->conshdlr
851#define SCIPconsGetData(cons) (cons)->consdata
852#define SCIPconsGetNUses(cons) (cons)->nuses
853#define SCIPconsGetActiveDepth(cons) (cons)->activedepth
854#define SCIPconsGetValidDepth(cons) (!(cons)->local ? 0 \
855 : !SCIPconsIsActive(cons) ? INT_MAX \
856 : (cons)->validdepth == -1 ? SCIPconsGetActiveDepth(cons) \
857 : (cons)->validdepth)
858#define SCIPconsIsActive(cons) ((cons)->updateactivate || ((cons)->active && !(cons)->updatedeactivate))
859#define SCIPconsIsEnabled(cons) ((cons)->updateenable || ((cons)->enabled && !(cons)->updatedisable))
860#define SCIPconsIsSeparationEnabled(cons) \
861 (SCIPconsIsEnabled(cons) && ((cons)->updatesepaenable || ((cons)->sepaenabled && !(cons)->updatesepadisable)))
862#define SCIPconsIsPropagationEnabled(cons) \
863 (SCIPconsIsEnabled(cons) && ((cons)->updatepropenable || ((cons)->propenabled && !(cons)->updatepropdisable)))
864#define SCIPconsIsDeleted(cons) ((cons)->deleted)
865#define SCIPconsIsObsolete(cons) ((cons)->updateobsolete || (cons)->obsolete)
866#define SCIPconsIsConflict(cons) ((cons)->conflict)
867#define SCIPconsGetAge(cons) (cons)->age
868#define SCIPconsIsInitial(cons) (cons)->initial
869#define SCIPconsIsSeparated(cons) (cons)->separate
870#define SCIPconsIsEnforced(cons) (cons)->enforce
871#define SCIPconsIsChecked(cons) (cons)->check
872#define SCIPconsIsMarkedPropagate(cons) ((cons)->updatemarkpropagate || ((cons)->markpropagate && !(cons)->updateunmarkpropagate))
873#define SCIPconsIsPropagated(cons) (cons)->propagate
874#define SCIPconsIsGlobal(cons) !(cons)->local
875#define SCIPconsIsLocal(cons) (cons)->local
876#define SCIPconsIsModifiable(cons) (cons)->modifiable
877#define SCIPconsIsDynamic(cons) (cons)->dynamic
878#define SCIPconsIsRemovable(cons) (cons)->removable
879#define SCIPconsIsStickingAtNode(cons) (cons)->stickingatnode
880#define SCIPconsIsInProb(cons) ((cons)->addconssetchg == NULL && (cons)->addarraypos >= 0)
881#define SCIPconsIsOriginal(cons) (cons)->original
882#define SCIPconsIsTransformed(cons) !(cons)->original
883#define SCIPconsIsLockedPos(cons) ((cons)->nlockspos[SCIP_LOCKTYPE_MODEL] > 0)
884#define SCIPconsIsLockedNeg(cons) ((cons)->nlocksneg[SCIP_LOCKTYPE_MODEL] > 0)
885#define SCIPconsIsLocked(cons) ((cons)->nlockspos[SCIP_LOCKTYPE_MODEL] > 0 || (cons)->nlocksneg[SCIP_LOCKTYPE_MODEL] > 0)
886#define SCIPconsGetNLocksPos(cons) ((cons)->nlockspos[SCIP_LOCKTYPE_MODEL])
887#define SCIPconsGetNLocksNeg(cons) ((cons)->nlocksneg[SCIP_LOCKTYPE_MODEL])
888#define SCIPconsIsLockedTypePos(cons, locktype) ((cons)->nlockspos[locktype] > 0)
889#define SCIPconsIsLockedTypeNeg(cons, locktype) ((cons)->nlocksneg[locktype] > 0)
890#define SCIPconsIsLockedType(cons, locktype) ((cons)->nlockspos[locktype] > 0 || (cons)->nlocksneg[locktype] > 0)
891#define SCIPconsGetNLocksTypePos(cons, locktype) ((cons)->nlockspos[locktype])
892#define SCIPconsGetNLocksTypeNeg(cons, locktype) ((cons)->nlocksneg[locktype])
893#define SCIPconsIsAdded(cons) ((cons)->addarraypos >= 0)
894#define SCIPconsGetNUpgradeLocks(cons) ((cons)->nupgradelocks)
895
896#endif
897
898/** @} */
899
900/**@addtogroup PublicProblemMethods
901 *
902 * public methods to query linear constraint classification statistics
903 *
904 * @{
905 */
906
907/** create linear constraint statistics */
908SCIP_EXPORT
910 SCIP* scip, /**< scip data structure */
911 SCIP_LINCONSSTATS** linconsstats /**< pointer to linear constraint classification statistics */
912 );
913
914/** free linear constraint statistics */
915SCIP_EXPORT
917 SCIP* scip, /**< scip data structure */
918 SCIP_LINCONSSTATS** linconsstats /**< pointer to linear constraint classification statistics */
919 );
920
921/** resets linear constraint statistics */
922SCIP_EXPORT
924 SCIP_LINCONSSTATS* linconsstats /**< linear constraint classification statistics */
925 );
926
927/** returns the number of occurrences of a specific type of linear constraint */
928SCIP_EXPORT
930 SCIP_LINCONSSTATS* linconsstats, /**< linear constraint classification statistics */
931 SCIP_LINCONSTYPE linconstype /**< linear constraint type */
932 );
933
934/** returns the total number of classified constraints */
935SCIP_EXPORT
937 SCIP_LINCONSSTATS* linconsstats /**< linear constraint classification statistics */
938 );
939
940/** increases the number of occurrences of a specific type of linear constraint */
941SCIP_EXPORT
943 SCIP_LINCONSSTATS* linconsstats, /**< linear constraint classification statistics */
944 SCIP_LINCONSTYPE linconstype, /**< linear constraint type */
945 int increment /**< positive increment */
946 );
947
948/** print linear constraint classification statistics */
949SCIP_EXPORT
951 SCIP* scip, /**< scip data structure */
952 FILE* file, /**< file handle or NULL to print to standard out */
953 SCIP_LINCONSSTATS* linconsstats /**< linear constraint classification statistics */
954 );
955
956/** @} */
957
958#ifdef __cplusplus
959}
960#endif
961
962#endif
SCIP_DECL_CONSSEPASOL(ConshdlrSubtour::scip_sepasol)
SCIP_DECL_CONSSEPALP(ConshdlrSubtour::scip_sepalp)
SCIP_DECL_CONSPROP(ConshdlrSubtour::scip_prop)
common defines and data types used in all packages of SCIP
#define SCIP_Longint
Definition: def.h:158
#define SCIP_Bool
Definition: def.h:91
#define SCIP_Real
Definition: def.h:173
int SCIPconshdlrGetNCheckConss(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4656
void SCIPconshdlrSetData(SCIP_CONSHDLR *conshdlr, SCIP_CONSHDLRDATA *conshdlrdata)
Definition: cons.c:4227
int SCIPconshdlrGetMaxNActiveConss(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4970
SCIP_Real SCIPconshdlrGetCheckTime(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4800
SCIP_PROPTIMING SCIPconshdlrGetPropTiming(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5250
SCIP_Bool SCIPconshdlrWasSolSeparationDelayed(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5210
SCIP_Longint SCIPconshdlrGetNCheckCalls(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4870
SCIP_CONS ** SCIPconshdlrGetCheckConss(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4613
int SCIPconshdlrGetNChgSides(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5080
SCIP_Real SCIPconshdlrGetPresolTime(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4730
int SCIPconshdlrGetEagerFreq(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5150
SCIP_Bool SCIPconshdlrDoesPresolve(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5170
void SCIPconshdlrSetProp(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPROP((*consprop)), int propfreq, SCIP_Bool delayprop, SCIP_PROPTIMING timingmask)
Definition: cons.c:4259
int SCIPconshdlrGetNFixedVars(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4990
SCIP_PRESOLTIMING SCIPconshdlrGetPresolTiming(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5272
SCIP_Real SCIPconshdlrGetEnfoLPTime(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4750
int SCIPconshdlrGetNPresolCalls(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5090
SCIP_Longint SCIPconshdlrGetNDomredsFound(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4950
int SCIPconshdlrGetSepaPriority(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5100
SCIP_Longint SCIPconshdlrGetNCutsApplied(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4910
int SCIPconshdlrGetNChgCoefs(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5070
void SCIPconshdlrSetPresolTiming(SCIP_CONSHDLR *conshdlr, SCIP_PRESOLTIMING presoltiming)
Definition: cons.c:5282
int SCIPconshdlrGetNUpdateConss(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4690
SCIP_CONS ** SCIPconshdlrGetEnfoConss(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4603
void SCIPconshdlrSetSepa(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSSEPALP((*conssepalp)), SCIP_DECL_CONSSEPASOL((*conssepasol)), int sepafreq, int sepapriority, SCIP_Bool delaysepa)
Definition: cons.c:4238
SCIP_Real SCIPconshdlrGetStrongBranchPropTime(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4790
void SCIPconshdlrSetEnforelax(SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSENFORELAX((*consenforelax)))
Definition: cons.c:4278
SCIP_Longint SCIPconshdlrGetNCutsFound(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4900
SCIP_Bool SCIPconshdlrSupportsSignedPermsymDetection(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5303
SCIP_Bool SCIPconshdlrIsPropagationDelayed(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5190
SCIP_Real SCIPconshdlrGetPropTime(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4780
void SCIPconssetchgGetAddedConsData(SCIP_CONSSETCHG *conssetchg, SCIP_CONS ***conss, int *nconss)
Definition: cons.c:5593
SCIP_Real SCIPconshdlrGetEnfoPSTime(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4760
int SCIPconshdlrGetPropFreq(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5140
int SCIPconshdlrGetNConss(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4636
SCIP_Longint SCIPconshdlrGetNCutoffs(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4890
const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4197
int SCIPconshdlrGetNEnabledConss(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4680
SCIP_CONS ** SCIPconshdlrGetUpdateConss(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4626
SCIP_Bool SCIPconshdlrIsSeparationDelayed(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5180
SCIP_Longint SCIPconshdlrGetNSepaCalls(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4820
int SCIPconshdlrGetNDelConss(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5040
SCIP_DECL_SORTPTRCOMP(SCIPconshdlrCompSepa)
Definition: cons.c:1956
SCIP_Bool SCIPconshdlrWasLPSeparationDelayed(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5200
SCIP_Longint SCIPconshdlrGetNChildren(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4960
SCIP_Real SCIPconshdlrGetEnfoRelaxTime(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4770
void SCIPconshdlrSetPropTiming(SCIP_CONSHDLR *conshdlr, SCIP_PROPTIMING proptiming)
Definition: cons.c:5260
SCIP_Bool SCIPconshdlrNeedsCons(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5160
int SCIPconshdlrGetNAggrVars(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5000
SCIP_Longint SCIPconshdlrGetNEnfoPSCalls(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4840
int SCIPconshdlrGetNAddHoles(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5030
int SCIPconshdlrGetNEnfoConss(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4646
SCIP_Bool SCIPconshdlrIsInitialized(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5230
int SCIPconshdlrGetNUpgdConss(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5060
int SCIPconshdlrGetStartNActiveConss(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4980
SCIP_Bool SCIPconshdlrWasPropagationDelayed(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5220
int SCIPconshdlrGetNAddConss(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5050
SCIP_Bool SCIPconshdlrSupportsPermsymDetection(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5293
int SCIPconshdlrGetNChgBds(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5020
const char * SCIPconshdlrGetDesc(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4207
SCIP_CONSHDLRDATA * SCIPconshdlrGetData(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4217
SCIP_Longint SCIPconshdlrGetNConssFound(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4940
int SCIPconshdlrGetNActiveConss(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4670
int SCIPconshdlrGetCheckPriority(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5120
int SCIPconshdlrGetSepaFreq(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5130
SCIP_Longint SCIPconshdlrGetNPropCalls(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4860
SCIP_Longint SCIPconshdlrGetNEnfoLPCalls(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4830
SCIP_CONS ** SCIPconshdlrGetConss(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4593
int SCIPconshdlrGetEnfoPriority(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5110
SCIP_Real SCIPconshdlrGetSetupTime(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4720
SCIP_Longint SCIPconshdlrGetNRespropCalls(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4880
SCIP_Real SCIPconshdlrGetSepaTime(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4740
SCIP_Bool SCIPconshdlrIsClonable(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5240
int SCIPconshdlrGetNChgVarTypes(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5010
SCIP_Real SCIPconshdlrGetRespropTime(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4810
SCIP_Longint SCIPconshdlrGetNEnfoRelaxCalls(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4850
SCIP_Bool SCIPconsIsLockedNeg(SCIP_CONS *cons)
Definition: cons.c:8543
SCIP_CONSDATA * SCIPconsGetData(SCIP_CONS *cons)
Definition: cons.c:8244
void SCIPconsAddUpgradeLocks(SCIP_CONS *cons, int nlocks)
Definition: cons.c:8653
int SCIPconsGetPos(SCIP_CONS *cons)
Definition: cons.c:8224
SCIP_Bool SCIPconsIsConflict(SCIP_CONS *cons)
Definition: cons.c:8363
SCIP_Bool SCIPconsIsDynamic(SCIP_CONS *cons)
Definition: cons.c:8473
SCIP_Real SCIPconsGetAge(SCIP_CONS *cons)
Definition: cons.c:8373
SCIP_CONSHDLR * SCIPconsGetHdlr(SCIP_CONS *cons)
Definition: cons.c:8234
int SCIPconsGetActiveDepth(SCIP_CONS *cons)
Definition: cons.c:8264
SCIP_Bool SCIPconsIsLockedPos(SCIP_CONS *cons)
Definition: cons.c:8533
SCIP_Bool SCIPconsIsPropagationEnabled(SCIP_CONS *cons)
Definition: cons.c:8332
SCIP_Bool SCIPconsIsInitial(SCIP_CONS *cons)
Definition: cons.c:8383
int SCIPconsGetNUpgradeLocks(SCIP_CONS *cons)
Definition: cons.c:8665
SCIP_Bool SCIPconsIsMarkedPropagate(SCIP_CONS *cons)
Definition: cons.c:8423
int SCIPconsGetNLocksTypeNeg(SCIP_CONS *cons, SCIP_LOCKTYPE locktype)
Definition: cons.c:8631
int SCIPconsGetValidDepth(SCIP_CONS *cons)
Definition: cons.c:8297
SCIP_Bool SCIPconsIsOriginal(SCIP_CONS *cons)
Definition: cons.c:8513
SCIP_Bool SCIPconsIsChecked(SCIP_CONS *cons)
Definition: cons.c:8413
SCIP_Bool SCIPconsIsDeleted(SCIP_CONS *cons)
Definition: cons.c:8343
SCIP_Bool SCIPconsIsUpdatedeactivate(SCIP_CONS *cons)
Definition: cons.c:8285
SCIP_Bool SCIPconsIsTransformed(SCIP_CONS *cons)
Definition: cons.c:8523
int SCIPconsGetNLocksPos(SCIP_CONS *cons)
Definition: cons.c:8563
SCIP_Bool SCIPconsIsLockedType(SCIP_CONS *cons, SCIP_LOCKTYPE locktype)
Definition: cons.c:8607
SCIP_Bool SCIPconsIsEnforced(SCIP_CONS *cons)
Definition: cons.c:8403
SCIP_Bool SCIPconsIsInProb(SCIP_CONS *cons)
Definition: cons.c:8503
SCIP_Bool SCIPconsIsGlobal(SCIP_CONS *cons)
Definition: cons.c:8443
SCIP_Bool SCIPconsIsActive(SCIP_CONS *cons)
Definition: cons.c:8275
SCIP_Bool SCIPconsIsPropagated(SCIP_CONS *cons)
Definition: cons.c:8433
SCIP_Bool SCIPconsIsLocal(SCIP_CONS *cons)
Definition: cons.c:8453
int SCIPconsGetNLocksNeg(SCIP_CONS *cons)
Definition: cons.c:8573
int SCIPconsGetNUses(SCIP_CONS *cons)
Definition: cons.c:8254
SCIP_Bool SCIPconsIsLockedTypePos(SCIP_CONS *cons, SCIP_LOCKTYPE locktype)
Definition: cons.c:8583
SCIP_Bool SCIPconsIsEnabled(SCIP_CONS *cons)
Definition: cons.c:8311
const char * SCIPconsGetName(SCIP_CONS *cons)
Definition: cons.c:8214
SCIP_Bool SCIPconsIsLocked(SCIP_CONS *cons)
Definition: cons.c:8553
SCIP_Bool SCIPconsIsSeparationEnabled(SCIP_CONS *cons)
Definition: cons.c:8321
SCIP_Bool SCIPconsIsLockedTypeNeg(SCIP_CONS *cons, SCIP_LOCKTYPE locktype)
Definition: cons.c:8595
SCIP_Bool SCIPconsIsModifiable(SCIP_CONS *cons)
Definition: cons.c:8463
SCIP_Bool SCIPconsIsAdded(SCIP_CONS *cons)
Definition: cons.c:8643
SCIP_Bool SCIPconsIsObsolete(SCIP_CONS *cons)
Definition: cons.c:8353
SCIP_Bool SCIPconsIsStickingAtNode(SCIP_CONS *cons)
Definition: cons.c:8493
int SCIPconsGetNLocksTypePos(SCIP_CONS *cons, SCIP_LOCKTYPE locktype)
Definition: cons.c:8619
SCIP_Bool SCIPconsIsSeparated(SCIP_CONS *cons)
Definition: cons.c:8393
SCIP_Bool SCIPconsIsRemovable(SCIP_CONS *cons)
Definition: cons.c:8483
int SCIPlinConsStatsGetSum(SCIP_LINCONSSTATS *linconsstats)
Definition: cons.c:8098
void SCIPlinConsStatsIncTypeCount(SCIP_LINCONSSTATS *linconsstats, SCIP_LINCONSTYPE linconstype, int increment)
Definition: cons.c:8108
int SCIPlinConsStatsGetTypeCount(SCIP_LINCONSSTATS *linconsstats, SCIP_LINCONSTYPE linconstype)
Definition: cons.c:8085
void SCIPlinConsStatsFree(SCIP *scip, SCIP_LINCONSSTATS **linconsstats)
Definition: cons.c:8064
void SCIPlinConsStatsReset(SCIP_LINCONSSTATS *linconsstats)
Definition: cons.c:8076
void SCIPprintLinConsStats(SCIP *scip, FILE *file, SCIP_LINCONSSTATS *linconsstats)
Definition: cons.c:8124
SCIP_RETCODE SCIPlinConsStatsCreate(SCIP *scip, SCIP_LINCONSSTATS **linconsstats)
Definition: cons.c:8051
datastructures for constraints and constraint handlers
type definitions for constraints and constraint handlers
struct SCIP_ConshdlrData SCIP_CONSHDLRDATA
Definition: type_cons.h:64
#define SCIP_DECL_CONSENFORELAX(x)
Definition: type_cons.h:388
struct SCIP_ConsData SCIP_CONSDATA
Definition: type_cons.h:65
enum SCIP_LinConstype SCIP_LINCONSTYPE
Definition: type_cons.h:91
type definitions for miscellaneous datastructures
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:63
unsigned int SCIP_PROPTIMING
Definition: type_timing.h:74
unsigned int SCIP_PRESOLTIMING
Definition: type_timing.h:61
enum SCIP_LockType SCIP_LOCKTYPE
Definition: type_var.h:100