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-2017 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 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"
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  */
48 {
49 public:
50  /*lint --e{1540}*/
51 
52  /** SCIP data structure */
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 */
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? */
84 
85  /** should propagation method be delayed, if other propagators found reductions? */
87 
88  /** should the constraint handler be skipped, if no constraints are available? */
90 
91  /** positions in the node solving loop where propagation method of constraint handler should be executed */
93 
94  /**< timing mask of the constraint handler's presolving method */
96 
97  /** default constructor */
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}*/
142  SCIPfreeMemoryArray(scip_, &scip_name_);
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 extern
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 extern
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 extern
479  SCIP* scip, /**< SCIP data structure */
480  SCIP_CONSHDLR* conshdlr /**< constraint handler */
481  );
482 
483 #endif
virtual SCIP_DECL_CONSPARSE(scip_parse)
Definition: objconshdlr.h:395
Definition of base class for all clonable classes which define problem data.
virtual ~ObjConshdlr()
Definition: objconshdlr.h:138
const SCIP_Bool scip_delaysepa_
Definition: objconshdlr.h:83
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:98
const int scip_eagerfreq_
Definition: objconshdlr.h:77
const SCIP_Bool scip_needscons_
Definition: objconshdlr.h:89
const int scip_propfreq_
Definition: objconshdlr.h:74
virtual SCIP_DECL_CONSEXITPRE(scip_exitpre)
Definition: objconshdlr.h:186
scip::ObjConshdlr * SCIPgetObjConshdlr(SCIP *scip, SCIP_CONSHDLR *conshdlr)
virtual SCIP_DECL_CONSDELVARS(scip_delvars)
Definition: objconshdlr.h:363
virtual SCIP_DECL_CONSENABLE(scip_enable)
Definition: objconshdlr.h:345
virtual SCIP_DECL_CONSENFOLP(scip_enfolp)=0
#define FALSE
Definition: def.h:64
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:53
virtual SCIP_DECL_CONSENFORELAX(scip_enforelax)
Definition: objconshdlr.h:265
virtual SCIP_DECL_CONSGETDIVEBDCHGS(scip_getdivebdchgs)
Definition: objconshdlr.h:429
virtual SCIP_DECL_CONSINITSOL(scip_initsol)
Definition: objconshdlr.h:195
scip::ObjConshdlr * SCIPfindObjConshdlr(SCIP *scip, const char *name)
const SCIP_PROPTIMING scip_proptiming_
Definition: objconshdlr.h:92
virtual SCIP_DECL_CONSRESPROP(scip_resprop)
Definition: objconshdlr.h:310
virtual SCIP_DECL_CONSINIT(scip_init)
Definition: objconshdlr.h:159
virtual SCIP_DECL_CONSEXIT(scip_exit)
Definition: objconshdlr.h:168
virtual SCIP_DECL_CONSPRINT(scip_print)
Definition: objconshdlr.h:372
virtual SCIP_DECL_CONSLOCK(scip_lock)=0
const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4113
virtual SCIP_DECL_CONSPRESOL(scip_presol)
Definition: objconshdlr.h:299
virtual SCIP_DECL_CONSSEPALP(scip_sepalp)
Definition: objconshdlr.h:237
virtual SCIP_DECL_CONSDISABLE(scip_disable)
Definition: objconshdlr.h:354
const int scip_maxprerounds_
Definition: objconshdlr.h:80
const int scip_sepapriority_
Definition: objconshdlr.h:62
virtual SCIP_DECL_CONSCHECK(scip_check)=0
const SCIP_Bool scip_delayprop_
Definition: objconshdlr.h:86
virtual SCIP_DECL_CONSPROP(scip_prop)
Definition: objconshdlr.h:288
unsigned int SCIP_PRESOLTIMING
Definition: type_timing.h:52
virtual SCIP_DECL_CONSTRANS(scip_trans)=0
#define SCIP_Bool
Definition: def.h:61
virtual SCIP_DECL_CONSDELETE(scip_delete)
Definition: objconshdlr.h:213
#define SCIPduplicateMemoryArray(scip, ptr, source, num)
Definition: scip.h:22565
virtual SCIP_DECL_CONSGETNVARS(scip_getnvars)
Definition: objconshdlr.h:416
virtual SCIP_DECL_CONSDEACTIVE(scip_deactive)
Definition: objconshdlr.h:336
const int scip_sepafreq_
Definition: objconshdlr.h:71
virtual SCIP_DECL_CONSSEPASOL(scip_sepasol)
Definition: objconshdlr.h:248
#define SCIPfreeMemoryArray(scip, ptr)
Definition: scip.h:22569
C++ wrapper for constraint handlers.
Definition: objconshdlr.h:47
Definition of base class for all clonable classes which define problem data.
SCIP_RETCODE SCIPincludeObjConshdlr(SCIP *scip, scip::ObjConshdlr *objconshdlr, SCIP_Bool deleteobject)
unsigned int SCIP_PROPTIMING
Definition: type_timing.h:66
const int scip_checkpriority_
Definition: objconshdlr.h:68
virtual SCIP_DECL_CONSINITPRE(scip_initpre)
Definition: objconshdlr.h:177
virtual SCIP_DECL_CONSCOPY(scip_copy)
Definition: objconshdlr.h:385
const SCIP_PRESOLTIMING scip_presoltiming_
Definition: objconshdlr.h:95
virtual SCIP_DECL_CONSACTIVE(scip_active)
Definition: objconshdlr.h:327
virtual SCIP_DECL_CONSGETVARS(scip_getvars)
Definition: objconshdlr.h:404
virtual SCIP_DECL_CONSEXITSOL(scip_exitsol)
Definition: objconshdlr.h:204
virtual SCIP_DECL_CONSENFOPS(scip_enfops)=0
#define SCIP_CALL_ABORT(x)
Definition: def.h:329
const int scip_enfopriority_
Definition: objconshdlr.h:65
virtual SCIP_DECL_CONSFREE(scip_free)
Definition: objconshdlr.h:150
virtual SCIP_DECL_CONSINITLP(scip_initlp)
Definition: objconshdlr.h:228
SCIP callable library.