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