Scippy

SCIP

Solving Constraint Integer Programs

objconshdlr.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 objconshdlr.h
26 * @brief C++ wrapper for constraint handlers
27 * @author Tobias Achterberg
28 */
29
30/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
31
32#ifndef __SCIP_OBJCONSHDLR_H__
33#define __SCIP_OBJCONSHDLR_H__
34
35
36#include <cassert>
37#include <cstring>
38#include <utility>
39
40#include "scip/scip.h"
42
43namespace scip
44{
45
46/** @brief C++ wrapper for constraint handlers
47 *
48 * This class defines the interface for constraint handlers implemented in C++. Note that there are pure virtual
49 * functions (these have to be implemented). These functions are: scip_trans(), scip_enfolp(), scip_enforelax(),
50 * scip_enfops(), scip_check(), and scip_lock().
51 *
52 * - \ref CONS "Instructions for implementing a constraint handler"
53 * - \ref CONSHDLRS "List of available constraint handlers"
54 * - \ref type_cons.h "Corresponding C interface"
55 */
57{
58public:
59 /*lint --e{1540}*/
60
61 /** SCIP data structure */
63
64 /** name of the constraint handler */
66
67 /** description of the constraint handler */
69
70 /** default separation priority of the constraint handler */
72
73 /** default enforcing priority of the constraint handler */
75
76 /** default checking priority of the constraint handler */
78
79 /** default separation frequency of the constraint handler */
80 const int scip_sepafreq_;
81
82 /** default propagation frequency of the constraint handler */
83 const int scip_propfreq_;
84
85 /** default frequency of the constraint handler for eager evaluations in separation, propagation and enforcement */
86 const int scip_eagerfreq_;
87
88 /** maximal number of presolving rounds the constraint handler participates in (-1: no limit) */
90
91 /** should separation method be delayed, if other separators found cuts? */
93
94 /** should propagation method be delayed, if other propagators found reductions? */
96
97 /** should the constraint handler be skipped, if no constraints are available? */
99
100 /** positions in the node solving loop where propagation method of constraint handler should be executed */
102
103 /**< timing mask of the constraint handler's presolving method */
105
106 /** default constructor */
108 SCIP* scip, /**< SCIP data structure */
109 const char* name, /**< name of constraint handler */
110 const char* desc, /**< description of constraint handler */
111 int sepapriority, /**< priority of the constraint handler for separation */
112 int enfopriority, /**< priority of the constraint handler for constraint enforcing */
113 int checkpriority, /**< priority of the constraint handler for checking infeasibility (and propagation) */
114 int sepafreq, /**< frequency for separating cuts; zero means to separate only in the root node */
115 int propfreq, /**< frequency for propagating domains; zero means only preprocessing propagation */
116 int eagerfreq, /**< frequency for using all instead of only the useful constraints in separation,
117 * propagation and enforcement, -1 for no eager evaluations, 0 for first only */
118 int maxprerounds, /**< maximal number of presolving rounds the constraint handler participates in (-1: no limit) */
119 SCIP_Bool delaysepa, /**< should separation method be delayed, if other separators found cuts? */
120 SCIP_Bool delayprop, /**< should propagation method be delayed, if other propagators found reductions? */
121 SCIP_Bool needscons, /**< should the constraint handler be skipped, if no constraints are available? */
122 SCIP_PROPTIMING proptiming, /**< positions in the node solving loop where propagation method of constraint handlers should be executed */
123 SCIP_PRESOLTIMING presoltiming /**< timing mask of the constraint handler's presolving method */
124 )
125 : scip_(scip),
126 scip_name_(0),
127 scip_desc_(0),
128 scip_sepapriority_(sepapriority),
129 scip_enfopriority_(enfopriority),
130 scip_checkpriority_(checkpriority),
131 scip_sepafreq_(sepafreq),
132 scip_propfreq_(propfreq),
133 scip_eagerfreq_(eagerfreq),
134 scip_maxprerounds_(maxprerounds),
135 scip_delaysepa_(delaysepa),
136 scip_delayprop_(delayprop),
137 scip_needscons_(needscons),
138 scip_proptiming_(proptiming),
139 scip_presoltiming_(presoltiming)
140 {
141 /* the macro SCIPduplicateMemoryArray does not need the first argument: */
142 SCIP_CALL_ABORT( SCIPduplicateMemoryArray(scip_, &scip_name_, name, std::strlen(name)+1) );
143 SCIP_CALL_ABORT( SCIPduplicateMemoryArray(scip_, &scip_desc_, desc, std::strlen(desc)+1) );
144 }
145
146 /** copy constructor */
151 {
152 }
153
154 /** move constructor */
156 : scip_(o.scip_),
157 scip_name_(0),
158 scip_desc_(0),
171 {
172 std::swap(scip_name_, o.scip_name_);
173 std::swap(scip_desc_, o.scip_desc_);
174 }
175
176 /** destructor */
177 virtual ~ObjConshdlr()
178 {
179 /* the macro SCIPfreeMemoryArray does not need the first argument: */
180 /*lint --e{64}*/
183 }
184
185 /** assignment of polymorphic classes causes slicing and is therefore disabled. */
186 ObjConshdlr& operator=(const ObjConshdlr& o) = delete;
187
188 /** assignment of polymorphic classes causes slicing and is therefore disabled. */
190
191 /** destructor of constraint handler to free user data (called when SCIP is exiting)
192 *
193 * @see SCIP_DECL_CONSFREE(x) in @ref type_cons.h
194 */
195 virtual SCIP_DECL_CONSFREE(scip_free)
196 { /*lint --e{715}*/
197 return SCIP_OKAY;
198 }
199
200 /** initialization method of constraint handler (called after problem has been transformed)
201 *
202 * @see SCIP_DECL_CONSINIT(x) in @ref type_cons.h
203 */
204 virtual SCIP_DECL_CONSINIT(scip_init)
205 { /*lint --e{715}*/
206 return SCIP_OKAY;
207 }
208
209 /** deinitialization method of constraint handler (called before transformed problem is freed)
210 *
211 * @see SCIP_DECL_CONSEXIT(x) in @ref type_cons.h
212 */
213 virtual SCIP_DECL_CONSEXIT(scip_exit)
214 { /*lint --e{715}*/
215 return SCIP_OKAY;
216 }
217
218 /** presolving initialization method of constraint handler (called when presolving is about to begin)
219 *
220 * @see SCIP_DECL_CONSINITPRE(x) in @ref type_cons.h
221 */
222 virtual SCIP_DECL_CONSINITPRE(scip_initpre)
223 { /*lint --e{715}*/
224 return SCIP_OKAY;
225 }
226
227 /** presolving deinitialization method of constraint handler (called after presolving has been finished)
228 *
229 * @see SCIP_DECL_CONSEXITPRE(x) in @ref type_cons.h
230 */
231 virtual SCIP_DECL_CONSEXITPRE(scip_exitpre)
232 { /*lint --e{715}*/
233 return SCIP_OKAY;
234 }
235
236 /** solving process initialization method of constraint handler (called when branch and bound process is about to begin)
237 *
238 * @see SCIP_DECL_CONSINITSOL(x) in @ref type_cons.h
239 */
240 virtual SCIP_DECL_CONSINITSOL(scip_initsol)
241 { /*lint --e{715}*/
242 return SCIP_OKAY;
243 }
244
245 /** solving process deinitialization method of constraint handler (called before branch and bound process data is freed)
246 *
247 * @see SCIP_DECL_CONSEXITSOL(x) in @ref type_cons.h
248 */
249 virtual SCIP_DECL_CONSEXITSOL(scip_exitsol)
250 { /*lint --e{715}*/
251 return SCIP_OKAY;
252 }
253
254 /** frees specific constraint data
255 *
256 * @see SCIP_DECL_CONSDELETE(x) in @ref type_cons.h
257 */
258 virtual SCIP_DECL_CONSDELETE(scip_delete)
259 { /*lint --e{715}*/
260 return SCIP_OKAY;
261 }
262
263 /** transforms constraint data into data belonging to the transformed problem
264 *
265 * @see SCIP_DECL_CONSTRANS(x) in @ref type_cons.h
266 */
267 virtual SCIP_DECL_CONSTRANS(scip_trans) = 0;
268
269 /** LP initialization method of constraint handler (called before the initial LP relaxation at a node is solved)
270 *
271 * @see SCIP_DECL_CONSINITLP(x) in @ref type_cons.h
272 */
273 virtual SCIP_DECL_CONSINITLP(scip_initlp)
274 { /*lint --e{715}*/
275 return SCIP_OKAY;
276 }
277
278 /** separation method of constraint handler for LP solution
279 *
280 * @see SCIP_DECL_CONSSEPALP(x) in @ref type_cons.h
281 */
282 virtual SCIP_DECL_CONSSEPALP(scip_sepalp)
283 { /*lint --e{715}*/
284 assert(result != NULL);
285 *result = SCIP_DIDNOTRUN;
286 return SCIP_OKAY;
287 }
288
289 /** separation method of constraint handler for arbitrary primal solution
290 *
291 * @see SCIP_DECL_CONSSEPASOL(x) in @ref type_cons.h
292 */
293 virtual SCIP_DECL_CONSSEPASOL(scip_sepasol)
294 { /*lint --e{715}*/
295 assert(result != NULL);
296 *result = SCIP_DIDNOTRUN;
297 return SCIP_OKAY;
298 }
299
300 /** constraint enforcing method of constraint handler for LP solutions
301 *
302 * @see SCIP_DECL_CONSENFOLP(x) in @ref type_cons.h
303 */
304 virtual SCIP_DECL_CONSENFOLP(scip_enfolp) = 0;
305
306 /** constraint enforcing method of constraint handler for relaxation solutions
307 *
308 * @see SCIP_DECL_CONSENFORELAX(x) in @ref type_cons.h
309 */
310 virtual SCIP_DECL_CONSENFORELAX(scip_enforelax)
311 { /*lint --e{715}*/
312 assert(result != NULL);
313 *result = SCIP_DIDNOTRUN;
314 return SCIP_OKAY;
315 }
316
317 /** constraint enforcing method of constraint handler for pseudo solutions
318 *
319 * @see SCIP_DECL_CONSENFOPS(x) in @ref type_cons.h
320 */
321 virtual SCIP_DECL_CONSENFOPS(scip_enfops) = 0;
322
323 /** feasibility check method of constraint handler for primal solutions
324 *
325 * @see SCIP_DECL_CONSCHECK(x) in @ref type_cons.h
326 */
327 virtual SCIP_DECL_CONSCHECK(scip_check) = 0;
328
329 /** domain propagation method of constraint handler
330 *
331 * @see SCIP_DECL_CONSPROP(x) in @ref type_cons.h
332 */
333 virtual SCIP_DECL_CONSPROP(scip_prop)
334 { /*lint --e{715}*/
335 assert(result != NULL);
336 *result = SCIP_DIDNOTRUN;
337 return SCIP_OKAY;
338 }
339
340 /** presolving method of constraint handler
341 *
342 * @see SCIP_DECL_CONSPRESOL(x) in @ref type_cons.h
343 */
344 virtual SCIP_DECL_CONSPRESOL(scip_presol)
345 { /*lint --e{715}*/
346 assert(result != NULL);
347 *result = SCIP_DIDNOTRUN;
348 return SCIP_OKAY;
349 }
350
351 /** propagation conflict resolving method of constraint handler
352 *
353 * @see SCIP_DECL_CONSRESPROP(x) in @ref type_cons.h
354 */
355 virtual SCIP_DECL_CONSRESPROP(scip_resprop)
356 { /*lint --e{715}*/
357 assert(result != NULL);
358 *result = SCIP_DIDNOTFIND;
359 return SCIP_OKAY;
360 }
361
362 /** variable rounding lock method of constraint handler
363 *
364 * @see SCIP_DECL_CONSLOCK(x) in @ref type_cons.h
365 */
366 virtual SCIP_DECL_CONSLOCK(scip_lock) = 0;
367
368 /** constraint activation notification method of constraint handler
369 *
370 * @see SCIP_DECL_CONSACTIVE(x) in @ref type_cons.h
371 */
372 virtual SCIP_DECL_CONSACTIVE(scip_active)
373 { /*lint --e{715}*/
374 return SCIP_OKAY;
375 }
376
377 /** constraint deactivation notification method of constraint handler
378 *
379 * @see SCIP_DECL_CONSDEACTIVE(x) in @ref type_cons.h
380 */
381 virtual SCIP_DECL_CONSDEACTIVE(scip_deactive)
382 { /*lint --e{715}*/
383 return SCIP_OKAY;
384 }
385
386 /** constraint enabling notification method of constraint handler
387 *
388 * @see SCIP_DECL_CONSENABLE(x) in @ref type_cons.h
389 */
390 virtual SCIP_DECL_CONSENABLE(scip_enable)
391 { /*lint --e{715}*/
392 return SCIP_OKAY;
393 }
394
395 /** constraint disabling notification method of constraint handler
396 *
397 * @see SCIP_DECL_CONSDISABLE(x) in @ref type_cons.h
398 */
399 virtual SCIP_DECL_CONSDISABLE(scip_disable)
400 { /*lint --e{715}*/
401 return SCIP_OKAY;
402 }
403
404 /** variable deletion method of constraint handler
405 *
406 * @see SCIP_DECL_CONSDELVARS(x) in @ref type_cons.h
407 */
408 virtual SCIP_DECL_CONSDELVARS(scip_delvars)
409 { /*lint --e{715}*/
410 return SCIP_OKAY;
411 }
412
413 /** constraint display method of constraint handler
414 *
415 * @see SCIP_DECL_CONSPRINT(x) in @ref type_cons.h
416 */
417 virtual SCIP_DECL_CONSPRINT(scip_print)
418 { /*lint --e{715}*/
419 if ( file == NULL )
420 fprintf(stdout, "constraint handler <%s> does not support printing constraints\n", SCIPconshdlrGetName(conshdlr));
421 else
422 fprintf(file, "constraint handler <%s> does not support printing constraints\n", SCIPconshdlrGetName(conshdlr));
423 return SCIP_OKAY;
424 }
425
426 /** constraint copying method of constraint handler
427 *
428 * @see SCIP_DECL_CONSCOPY(x) in @ref type_cons.h
429 */
430 virtual SCIP_DECL_CONSCOPY(scip_copy)
431 { /*lint --e{715}*/
432 assert(valid != NULL);
433 *valid = FALSE;
434 return SCIP_OKAY;
435 }
436
437 /** constraint parsing method of constraint handler
438 *
439 * @see SCIP_DECL_CONSPARSE(x) in @ref type_cons.h
440 */
441 virtual SCIP_DECL_CONSPARSE(scip_parse)
442 { /*lint --e{715}*/
443 return SCIP_OKAY;
444 }
445
446 /** constraint method of constraint handler which returns the variables (if possible)
447 *
448 * @see SCIP_DECL_CONSGETVARS(x) in @ref type_cons.h
449 */
450 virtual SCIP_DECL_CONSGETVARS(scip_getvars)
451 { /*lint --e{715}*/
452 assert(success != NULL);
453 *success = FALSE;
454 return SCIP_OKAY;
455 }
456
457 /** constraint method of constraint handler which returns the number of variables (if possible)
458 *
459 * @see SCIP_DECL_CONSGETNVARS(x) in @ref type_cons.h
460 */
461 virtual SCIP_DECL_CONSGETNVARS(scip_getnvars)
462 { /*lint --e{715}*/
463 assert(nvars != NULL);
464 assert(success != NULL);
465
466 *nvars = 0;
467 *success = FALSE;
468
469 return SCIP_OKAY;
470 }
471
472 /** constraint handler method to suggest dive bound changes during the generic diving algorithm
473 *
474 * @see SCIP_DECL_CONSGETDIVEBDCHGS(x) in @ref type_cons.h
475 */
476 virtual SCIP_DECL_CONSGETDIVEBDCHGS(scip_getdivebdchgs)
477 { /*lint --e{715}*/
478 assert(success != NULL);
479 *success = FALSE;
480 return SCIP_OKAY;
481 }
482
483 /** constraint handler method which returns the permutation symmetry detection graph of a constraint (if possible)
484 *
485 * @see SCIP_DECL_CONSGETPERMSYMGRAPH(x) in @ref type_cons.h
486 */
487 virtual SCIP_DECL_CONSGETPERMSYMGRAPH(scip_getpermsymgraph)
488 { /*lint --e{715}*/
489 assert(success != NULL);
490 *success = FALSE;
491 return SCIP_OKAY;
492 }
493
494 /** constraint handler method which returns the signed permutation symmetry detection graph of a constraint (if possible)
495 *
496 * @see SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH(x) in @ref type_cons.h
497 */
498 virtual SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH(scip_getsignedpermsymgraph)
499 { /*lint --e{715}*/
500 assert(success != NULL);
501 *success = FALSE;
502 return SCIP_OKAY;
503 }
504};
505
506} /* namespace scip */
507
508
509
510/** creates the constraint handler for the given constraint handler object and includes it in SCIP
511 *
512 * The method should be called in one of the following ways:
513 *
514 * 1. The user is resposible of deleting the object:
515 * SCIP_CALL( SCIPcreate(&scip) );
516 * ...
517 * MyConshdlr* myconshdlr = new MyConshdlr(...);
518 * SCIP_CALL( SCIPincludeObjConshdlr(scip, &myconshdlr, FALSE) );
519 * ...
520 * SCIP_CALL( SCIPfree(&scip) );
521 * delete myconshdlr; // delete conshdlr AFTER SCIPfree() !
522 *
523 * 2. The object pointer is passed to SCIP and deleted by SCIP in the SCIPfree() call:
524 * SCIP_CALL( SCIPcreate(&scip) );
525 * ...
526 * SCIP_CALL( SCIPincludeObjConshdlr(scip, new MyConshdlr(...), TRUE) );
527 * ...
528 * SCIP_CALL( SCIPfree(&scip) ); // destructor of MyConshdlr is called here
529 */
530SCIP_EXPORT
532 SCIP* scip, /**< SCIP data structure */
533 scip::ObjConshdlr* objconshdlr, /**< constraint handler object */
534 SCIP_Bool deleteobject /**< should the constraint handler object be deleted when conshdlr is freed? */
535 );
536
537/** returns the conshdlr object of the given name, or 0 if not existing */
538SCIP_EXPORT
540 SCIP* scip, /**< SCIP data structure */
541 const char* name /**< name of constraint handler */
542 );
543
544/** returns the conshdlr object for the given constraint handler */
545SCIP_EXPORT
547 SCIP* scip, /**< SCIP data structure */
548 SCIP_CONSHDLR* conshdlr /**< constraint handler */
549 );
550
551#endif
C++ wrapper for constraint handlers.
Definition: objconshdlr.h:57
ObjConshdlr(const ObjConshdlr &o)
Definition: objconshdlr.h:147
virtual SCIP_DECL_CONSPROP(scip_prop)
Definition: objconshdlr.h:333
const SCIP_PRESOLTIMING scip_presoltiming_
Definition: objconshdlr.h:104
virtual SCIP_DECL_CONSRESPROP(scip_resprop)
Definition: objconshdlr.h:355
virtual SCIP_DECL_CONSPARSE(scip_parse)
Definition: objconshdlr.h:441
virtual SCIP_DECL_CONSENFOLP(scip_enfolp)=0
virtual SCIP_DECL_CONSDELETE(scip_delete)
Definition: objconshdlr.h:258
virtual SCIP_DECL_CONSENABLE(scip_enable)
Definition: objconshdlr.h:390
const int scip_eagerfreq_
Definition: objconshdlr.h:86
const int scip_sepapriority_
Definition: objconshdlr.h:71
const SCIP_Bool scip_delaysepa_
Definition: objconshdlr.h:92
virtual SCIP_DECL_CONSINITSOL(scip_initsol)
Definition: objconshdlr.h:240
virtual SCIP_DECL_CONSINIT(scip_init)
Definition: objconshdlr.h:204
virtual SCIP_DECL_CONSSEPALP(scip_sepalp)
Definition: objconshdlr.h:282
virtual SCIP_DECL_CONSFREE(scip_free)
Definition: objconshdlr.h:195
virtual SCIP_DECL_CONSEXIT(scip_exit)
Definition: objconshdlr.h:213
virtual SCIP_DECL_CONSSEPASOL(scip_sepasol)
Definition: objconshdlr.h:293
virtual SCIP_DECL_CONSPRESOL(scip_presol)
Definition: objconshdlr.h:344
const SCIP_Bool scip_delayprop_
Definition: objconshdlr.h:95
virtual SCIP_DECL_CONSGETPERMSYMGRAPH(scip_getpermsymgraph)
Definition: objconshdlr.h:487
const SCIP_Bool scip_needscons_
Definition: objconshdlr.h:98
virtual SCIP_DECL_CONSGETVARS(scip_getvars)
Definition: objconshdlr.h:450
virtual SCIP_DECL_CONSGETDIVEBDCHGS(scip_getdivebdchgs)
Definition: objconshdlr.h:476
virtual SCIP_DECL_CONSEXITSOL(scip_exitsol)
Definition: objconshdlr.h:249
virtual SCIP_DECL_CONSDEACTIVE(scip_deactive)
Definition: objconshdlr.h:381
virtual SCIP_DECL_CONSINITLP(scip_initlp)
Definition: objconshdlr.h:273
virtual SCIP_DECL_CONSDISABLE(scip_disable)
Definition: objconshdlr.h:399
virtual SCIP_DECL_CONSINITPRE(scip_initpre)
Definition: objconshdlr.h:222
virtual SCIP_DECL_CONSLOCK(scip_lock)=0
ObjConshdlr & operator=(ObjConshdlr &&o)=delete
virtual SCIP_DECL_CONSACTIVE(scip_active)
Definition: objconshdlr.h:372
const int scip_sepafreq_
Definition: objconshdlr.h:80
virtual SCIP_DECL_CONSDELVARS(scip_delvars)
Definition: objconshdlr.h:408
const int scip_propfreq_
Definition: objconshdlr.h:83
ObjConshdlr & operator=(const ObjConshdlr &o)=delete
virtual SCIP_DECL_CONSENFOPS(scip_enfops)=0
const int scip_enfopriority_
Definition: objconshdlr.h:74
const int scip_maxprerounds_
Definition: objconshdlr.h:89
virtual ~ObjConshdlr()
Definition: objconshdlr.h:177
ObjConshdlr(ObjConshdlr &&o)
Definition: objconshdlr.h:155
virtual SCIP_DECL_CONSGETNVARS(scip_getnvars)
Definition: objconshdlr.h:461
virtual SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH(scip_getsignedpermsymgraph)
Definition: objconshdlr.h:498
virtual SCIP_DECL_CONSTRANS(scip_trans)=0
virtual SCIP_DECL_CONSCOPY(scip_copy)
Definition: objconshdlr.h:430
const int scip_checkpriority_
Definition: objconshdlr.h:77
virtual SCIP_DECL_CONSCHECK(scip_check)=0
ObjConshdlr(SCIP *scip, 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)
Definition: objconshdlr.h:107
virtual SCIP_DECL_CONSEXITPRE(scip_exitpre)
Definition: objconshdlr.h:231
virtual SCIP_DECL_CONSENFORELAX(scip_enforelax)
Definition: objconshdlr.h:310
const SCIP_PROPTIMING scip_proptiming_
Definition: objconshdlr.h:101
virtual SCIP_DECL_CONSPRINT(scip_print)
Definition: objconshdlr.h:417
#define NULL
Definition: def.h:267
#define SCIP_Bool
Definition: def.h:91
#define FALSE
Definition: def.h:94
#define SCIP_CALL_ABORT(x)
Definition: def.h:353
const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4197
#define SCIPduplicateMemoryArray(scip, ptr, source, num)
Definition: scip_mem.h:76
#define SCIPfreeMemoryArray(scip, ptr)
Definition: scip_mem.h:80
scip::ObjConshdlr * SCIPfindObjConshdlr(SCIP *scip, const char *name)
scip::ObjConshdlr * SCIPgetObjConshdlr(SCIP *scip, SCIP_CONSHDLR *conshdlr)
SCIP_RETCODE SCIPincludeObjConshdlr(SCIP *scip, scip::ObjConshdlr *objconshdlr, SCIP_Bool deleteobject)
Definition of base class for all clonable classes which define problem data.
SCIP callable library.
Definition of base class for all clonable classes which define problem data.
@ SCIP_DIDNOTRUN
Definition: type_result.h:42
@ SCIP_DIDNOTFIND
Definition: type_result.h:44
@ SCIP_OKAY
Definition: type_retcode.h:42
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