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