Scippy

SCIP

Solving Constraint Integer Programs

scip_sepa.c
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-2019 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 scip.zib.de. */
13 /* */
14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15 
16 /**@file scip_sepa.c
17  * @brief public methods for separator plugins
18  * @author Tobias Achterberg
19  * @author Timo Berthold
20  * @author Gerald Gamrath
21  * @author Robert Lion Gottwald
22  * @author Stefan Heinz
23  * @author Gregor Hendel
24  * @author Thorsten Koch
25  * @author Alexander Martin
26  * @author Marc Pfetsch
27  * @author Michael Winkler
28  * @author Kati Wolter
29  *
30  * @todo check all SCIP_STAGE_* switches, and include the new stages TRANSFORMED and INITSOLVE
31  */
32 
33 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
34 
35 #include <ctype.h>
36 #include <stdarg.h>
37 #include <assert.h>
38 #include <string.h>
39 #if defined(_WIN32) || defined(_WIN64)
40 #else
41 #include <strings.h> /*lint --e{766}*/
42 #endif
43 
44 
45 #include "lpi/lpi.h"
46 #include "nlpi/exprinterpret.h"
47 #include "nlpi/nlpi.h"
48 #include "scip/benders.h"
49 #include "scip/benderscut.h"
50 #include "scip/branch.h"
51 #include "scip/branch_nodereopt.h"
52 #include "scip/clock.h"
53 #include "scip/compr.h"
54 #include "scip/concsolver.h"
55 #include "scip/concurrent.h"
56 #include "scip/conflict.h"
57 #include "scip/conflictstore.h"
58 #include "scip/cons.h"
59 #include "scip/cons_linear.h"
60 #include "scip/cutpool.h"
61 #include "scip/cuts.h"
62 #include "scip/debug.h"
63 #include "scip/def.h"
64 #include "scip/dialog.h"
65 #include "scip/dialog_default.h"
66 #include "scip/disp.h"
67 #include "scip/event.h"
68 #include "scip/heur.h"
69 #include "scip/heur_ofins.h"
70 #include "scip/heur_reoptsols.h"
72 #include "scip/heuristics.h"
73 #include "scip/history.h"
74 #include "scip/implics.h"
75 #include "scip/interrupt.h"
76 #include "scip/lp.h"
77 #include "scip/mem.h"
78 #include "scip/message_default.h"
79 #include "scip/misc.h"
80 #include "scip/nlp.h"
81 #include "scip/nodesel.h"
82 #include "scip/paramset.h"
83 #include "scip/presol.h"
84 #include "scip/presolve.h"
85 #include "scip/pricer.h"
86 #include "scip/pricestore.h"
87 #include "scip/primal.h"
88 #include "scip/prob.h"
89 #include "scip/prop.h"
90 #include "scip/reader.h"
91 #include "scip/relax.h"
92 #include "scip/reopt.h"
93 #include "scip/retcode.h"
94 #include "scip/scipbuildflags.h"
95 #include "scip/scipcoreplugins.h"
96 #include "scip/scipgithash.h"
97 #include "scip/sepa.h"
98 #include "scip/sepastore.h"
99 #include "scip/set.h"
100 #include "scip/sol.h"
101 #include "scip/solve.h"
102 #include "scip/stat.h"
103 #include "scip/syncstore.h"
104 #include "scip/table.h"
105 #include "scip/tree.h"
106 #include "scip/var.h"
107 #include "scip/visual.h"
108 #include "xml/xml.h"
109 
110 #include "scip/scip_sepa.h"
111 
112 #include "scip/pub_message.h"
113 
114 
115 /* In debug mode, we include the SCIP's structure in scip.c, such that no one can access
116  * this structure except the interface methods in scip.c.
117  * In optimized mode, the structure is included in scip.h, because some of the methods
118  * are implemented as defines for performance reasons (e.g. the numerical comparisons)
119  */
120 #ifndef NDEBUG
121 #include "scip/struct_scip.h"
122 #endif
123 
124 /** creates a separator and includes it in SCIP.
125  *
126  * @note method has all separator callbacks as arguments and is thus changed every time a new
127  * callback is added
128  * in future releases; consider using SCIPincludeSepaBasic() and setter functions
129  * if you seek for a method which is less likely to change in future releases
130  */
132  SCIP* scip, /**< SCIP data structure */
133  const char* name, /**< name of separator */
134  const char* desc, /**< description of separator */
135  int priority, /**< priority of separator (>= 0: before, < 0: after constraint handlers) */
136  int freq, /**< frequency for calling separator */
137  SCIP_Real maxbounddist, /**< maximal relative distance from current node's dual bound to primal bound compared
138  * to best node's dual bound for applying separation */
139  SCIP_Bool usessubscip, /**< does the separator use a secondary SCIP instance? */
140  SCIP_Bool delay, /**< should separator be delayed, if other separators found cuts? */
141  SCIP_DECL_SEPACOPY ((*sepacopy)), /**< copy method of separator or NULL if you don't want to copy your plugin into sub-SCIPs */
142  SCIP_DECL_SEPAFREE ((*sepafree)), /**< destructor of separator */
143  SCIP_DECL_SEPAINIT ((*sepainit)), /**< initialize separator */
144  SCIP_DECL_SEPAEXIT ((*sepaexit)), /**< deinitialize separator */
145  SCIP_DECL_SEPAINITSOL ((*sepainitsol)), /**< solving process initialization method of separator */
146  SCIP_DECL_SEPAEXITSOL ((*sepaexitsol)), /**< solving process deinitialization method of separator */
147  SCIP_DECL_SEPAEXECLP ((*sepaexeclp)), /**< LP solution separation method of separator */
148  SCIP_DECL_SEPAEXECSOL ((*sepaexecsol)), /**< arbitrary primal solution separation method of separator */
149  SCIP_SEPADATA* sepadata /**< separator data */
150  )
151 {
152  SCIP_SEPA* sepa;
153 
154  SCIP_CALL( SCIPcheckStage(scip, "SCIPincludeSepa", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
155 
156  /* check whether separator is already present */
157  if( SCIPfindSepa(scip, name) != NULL )
158  {
159  SCIPerrorMessage("separator <%s> already included.\n", name);
160  return SCIP_INVALIDDATA;
161  }
162 
163  SCIP_CALL( SCIPsepaCreate(&sepa, scip->set, scip->messagehdlr, scip->mem->setmem,
164  name, desc, priority, freq, maxbounddist, usessubscip, delay,
165  sepacopy, sepafree, sepainit, sepaexit, sepainitsol, sepaexitsol, sepaexeclp, sepaexecsol, sepadata) );
166  SCIP_CALL( SCIPsetIncludeSepa(scip->set, sepa) );
167 
168  return SCIP_OKAY;
169 }
170 
171 /** creates a separator and includes it in SCIP with its most fundamental callbacks. All non-fundamental
172  * (or optional) callbacks as, e.g., init and exit callbacks, will be set to NULL.
173  * Optional callbacks can be set via specific setter functions, see SCIPsetSepaInit(), SCIPsetSepaFree(),
174  * SCIPsetSepaInitsol(), SCIPsetSepaExitsol(), SCIPsetSepaCopy(), SCIPsetExit().
175  *
176  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeSepa() instead
177  */
179  SCIP* scip, /**< SCIP data structure */
180  SCIP_SEPA** sepa, /**< reference to a separator, or NULL */
181  const char* name, /**< name of separator */
182  const char* desc, /**< description of separator */
183  int priority, /**< priority of separator (>= 0: before, < 0: after constraint handlers) */
184  int freq, /**< frequency for calling separator */
185  SCIP_Real maxbounddist, /**< maximal relative distance from current node's dual bound to primal bound compared
186  * to best node's dual bound for applying separation */
187  SCIP_Bool usessubscip, /**< does the separator use a secondary SCIP instance? */
188  SCIP_Bool delay, /**< should separator be delayed, if other separators found cuts? */
189  SCIP_DECL_SEPAEXECLP ((*sepaexeclp)), /**< LP solution separation method of separator */
190  SCIP_DECL_SEPAEXECSOL ((*sepaexecsol)), /**< arbitrary primal solution separation method of separator */
191  SCIP_SEPADATA* sepadata /**< separator data */
192  )
193 {
194  SCIP_SEPA* sepaptr;
195 
196  SCIP_CALL( SCIPcheckStage(scip, "SCIPincludeSepaBasic", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
197 
198  /* check whether separator is already present */
199  if( SCIPfindSepa(scip, name) != NULL )
200  {
201  SCIPerrorMessage("separator <%s> already included.\n", name);
202  return SCIP_INVALIDDATA;
203  }
204 
205  SCIP_CALL( SCIPsepaCreate(&sepaptr, scip->set, scip->messagehdlr, scip->mem->setmem,
206  name, desc, priority, freq, maxbounddist, usessubscip, delay,
207  NULL, NULL, NULL, NULL, NULL, NULL, sepaexeclp, sepaexecsol, sepadata) );
208 
209  assert(sepaptr != NULL);
210 
211  SCIP_CALL( SCIPsetIncludeSepa(scip->set, sepaptr) );
212 
213  if( sepa != NULL)
214  *sepa = sepaptr;
215 
216  return SCIP_OKAY;
217 }
218 
219 /** sets copy method of separator */
221  SCIP* scip, /**< SCIP data structure */
222  SCIP_SEPA* sepa, /**< separator */
223  SCIP_DECL_SEPACOPY ((*sepacopy)) /**< copy method of separator or NULL if you don't want to copy your plugin into sub-SCIPs */
224  )
225 {
226  SCIP_CALL( SCIPcheckStage(scip, "SCIPsetSepaCopy", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
227 
228  assert(sepa != NULL);
229 
230  SCIPsepaSetCopy(sepa, sepacopy);
231 
232  return SCIP_OKAY;
233 }
234 
235 /** sets destructor method of separator */
237  SCIP* scip, /**< SCIP data structure */
238  SCIP_SEPA* sepa, /**< separator */
239  SCIP_DECL_SEPAFREE ((*sepafree)) /**< destructor of separator */
240  )
241 {
242  SCIP_CALL( SCIPcheckStage(scip, "SCIPsetSepaFree", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
243 
244  assert(sepa != NULL);
245 
246  SCIPsepaSetFree(sepa, sepafree);
247 
248  return SCIP_OKAY;
249 }
250 
251 /** sets initialization method of separator */
253  SCIP* scip, /**< SCIP data structure */
254  SCIP_SEPA* sepa, /**< separator */
255  SCIP_DECL_SEPAINIT ((*sepainit)) /**< initialize separator */
256  )
257 {
258  SCIP_CALL( SCIPcheckStage(scip, "SCIPsetSepaInit", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
259 
260  assert(sepa != NULL);
261 
262  SCIPsepaSetInit(sepa, sepainit);
263 
264  return SCIP_OKAY;
265 }
266 
267 /** sets deinitialization method of separator */
269  SCIP* scip, /**< SCIP data structure */
270  SCIP_SEPA* sepa, /**< separator */
271  SCIP_DECL_SEPAEXIT ((*sepaexit)) /**< deinitialize separator */
272  )
273 {
274  SCIP_CALL( SCIPcheckStage(scip, "SCIPsetSepaExit", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
275 
276  assert(sepa != NULL);
277 
278  SCIPsepaSetExit(sepa, sepaexit);
279 
280  return SCIP_OKAY;
281 }
282 
283 /** sets solving process initialization method of separator */
285  SCIP* scip, /**< SCIP data structure */
286  SCIP_SEPA* sepa, /**< separator */
287  SCIP_DECL_SEPAINITSOL ((*sepainitsol)) /**< solving process initialization method of separator */
288  )
289 {
290  SCIP_CALL( SCIPcheckStage(scip, "SCIPsetSepaInitsol", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
291 
292  assert(sepa != NULL);
293 
294  SCIPsepaSetInitsol(sepa, sepainitsol);
295 
296  return SCIP_OKAY;
297 }
298 
299 /** sets solving process deinitialization method of separator */
301  SCIP* scip, /**< SCIP data structure */
302  SCIP_SEPA* sepa, /**< separator */
303  SCIP_DECL_SEPAEXITSOL ((*sepaexitsol)) /**< solving process deinitialization method of separator */
304  )
305 {
306  SCIP_CALL( SCIPcheckStage(scip, "SCIPsetSepaExitsol", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
307 
308  assert(sepa != NULL);
309 
310  SCIPsepaSetExitsol(sepa, sepaexitsol);
311 
312  return SCIP_OKAY;
313 }
314 
315 /** returns the separator of the given name, or NULL if not existing */
317  SCIP* scip, /**< SCIP data structure */
318  const char* name /**< name of separator */
319  )
320 {
321  assert(scip != NULL);
322  assert(scip->set != NULL);
323  assert(name != NULL);
324 
325  return SCIPsetFindSepa(scip->set, name);
326 }
327 
328 /** returns the array of currently available separators */
330  SCIP* scip /**< SCIP data structure */
331  )
332 {
333  assert(scip != NULL);
334  assert(scip->set != NULL);
335 
336  SCIPsetSortSepas(scip->set);
337 
338  return scip->set->sepas;
339 }
340 
341 /** returns the number of currently available separators */
343  SCIP* scip /**< SCIP data structure */
344  )
345 {
346  assert(scip != NULL);
347  assert(scip->set != NULL);
348 
349  return scip->set->nsepas;
350 }
351 
352 /** sets the priority of a separator */
354  SCIP* scip, /**< SCIP data structure */
355  SCIP_SEPA* sepa, /**< separator */
356  int priority /**< new priority of the separator */
357  )
358 {
359  assert(scip != NULL);
360  assert(scip->set != NULL);
361 
362  SCIPsepaSetPriority(sepa, scip->set, priority);
363 
364  return SCIP_OKAY;
365 }
366 
367 #undef SCIPgetSepaMinEfficacy
368 
369 /** gets value of minimal efficacy for a cut to enter the LP
370  *
371  * @pre This method can be called if @p scip is in one of the following stages:
372  * - \ref SCIP_STAGE_SOLVING
373  *
374  * @return value of "separating/minefficacyroot" if at root node, otherwise value of "separating/minefficacy"
375  */
377  SCIP* scip /**< SCIP data structure */
378  )
379 {
380  assert(scip != NULL);
381  assert(scip->tree != NULL);
382  assert(scip->set != NULL);
383 
384  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetSepaMinEfficacy", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
385 
386  if( SCIPtreeGetCurrentDepth(scip->tree) != 0 )
387  return scip->set->sepa_minefficacyroot;
388  return scip->set->sepa_minefficacy;
389 }
void SCIPsepaSetFree(SCIP_SEPA *sepa, SCIP_DECL_SEPAFREE((*sepafree)))
Definition: sepa.c:634
internal methods for separators
SCIP_Real sepa_minefficacyroot
Definition: struct_set.h:497
#define NULL
Definition: def.h:246
internal methods for managing events
default message handler
trivialnegation primal heuristic
internal methods for storing primal CIP solutions
methods to interpret (evaluate) an expression tree "fast"
internal methods for branch and bound tree
methods for implications, variable bounds, and cliques
SCIP_SEPA * SCIPfindSepa(SCIP *scip, const char *name)
Definition: scip_sepa.c:316
internal methods for clocks and timing issues
internal methods for NLPI solver interfaces
interface methods for specific LP solvers
internal methods for displaying statistics tables
#define FALSE
Definition: def.h:72
SCIP_SEPA ** sepas
Definition: struct_set.h:77
methods for the aggregation rows
internal methods for Benders&#39; decomposition
#define TRUE
Definition: def.h:71
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:53
methods commonly used by primal heuristics
SCIP_Real sepa_minefficacy
Definition: struct_set.h:496
int SCIPtreeGetCurrentDepth(SCIP_TREE *tree)
Definition: tree.c:8307
void SCIPsepaSetExit(SCIP_SEPA *sepa, SCIP_DECL_SEPAEXIT((*sepaexit)))
Definition: sepa.c:656
internal methods for branching rules and branching candidate storage
datastructures for concurrent solvers
SCIP_RETCODE SCIPsetSepaPriority(SCIP *scip, SCIP_SEPA *sepa, int priority)
Definition: scip_sepa.c:353
#define SCIP_DECL_SEPAEXECLP(x)
Definition: type_sepa.h:116
internal methods for handling parameter settings
methods for creating output for visualization tools (VBC, BAK)
nodereopt branching rule
SCIP_RETCODE SCIPsetSepaCopy(SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPACOPY((*sepacopy)))
Definition: scip_sepa.c:220
public methods for separator plugins
internal methods for LP management
SCIP_RETCODE SCIPsetIncludeSepa(SCIP_SET *set, SCIP_SEPA *sepa)
Definition: set.c:4121
internal methods for branching and inference history
internal methods for collecting primal CIP solutions and primal informations
#define SCIP_DECL_SEPACOPY(x)
Definition: type_sepa.h:47
internal methods for propagators
SCIP_MEM * mem
Definition: struct_scip.h:61
SCIP_RETCODE SCIPincludeSepa(SCIP *scip, const char *name, const char *desc, int priority, int freq, SCIP_Real maxbounddist, SCIP_Bool usessubscip, SCIP_Bool delay, SCIP_DECL_SEPACOPY((*sepacopy)), SCIP_DECL_SEPAFREE((*sepafree)), SCIP_DECL_SEPAINIT((*sepainit)), SCIP_DECL_SEPAEXIT((*sepaexit)), SCIP_DECL_SEPAINITSOL((*sepainitsol)), SCIP_DECL_SEPAEXITSOL((*sepaexitsol)), SCIP_DECL_SEPAEXECLP((*sepaexeclp)), SCIP_DECL_SEPAEXECSOL((*sepaexecsol)), SCIP_SEPADATA *sepadata)
Definition: scip_sepa.c:131
git hash methods
internal methods for storing and manipulating the main problem
#define SCIPerrorMessage
Definition: pub_message.h:45
methods for block memory pools and memory buffers
SCIP_RETCODE SCIPsetSepaExit(SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPAEXIT((*sepaexit)))
Definition: scip_sepa.c:268
register additional core functionality that is designed as plugins
SCIP_RETCODE SCIPcheckStage(SCIP *scip, const char *method, SCIP_Bool init, SCIP_Bool problem, SCIP_Bool transforming, SCIP_Bool transformed, SCIP_Bool initpresolve, SCIP_Bool presolving, SCIP_Bool exitpresolve, SCIP_Bool presolved, SCIP_Bool initsolve, SCIP_Bool solving, SCIP_Bool solved, SCIP_Bool exitsolve, SCIP_Bool freetrans, SCIP_Bool freescip)
Definition: debug.c:2010
internal methods for presolvers
internal methods for NLP management
internal miscellaneous methods
SCIP_SEPA * SCIPsetFindSepa(SCIP_SET *set, const char *name)
Definition: set.c:4145
internal methods for node selectors and node priority queues
internal methods for variable pricers
SCIP_RETCODE SCIPsetSepaInitsol(SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPAINITSOL((*sepainitsol)))
Definition: scip_sepa.c:284
SCIP_Real SCIPgetSepaMinEfficacy(SCIP *scip)
Definition: scip_sepa.c:376
void SCIPsepaSetExitsol(SCIP_SEPA *sepa, SCIP_DECL_SEPAEXITSOL((*sepaexitsol)))
Definition: sepa.c:678
internal methods for global SCIP settings
internal methods for storing conflicts
#define SCIP_CALL(x)
Definition: def.h:358
SCIP main data structure.
BMS_BLKMEM * setmem
Definition: struct_mem.h:39
internal methods for storing priced variables
internal methods for relaxators
int nsepas
Definition: struct_set.h:110
internal methods for storing separated cuts
methods commonly used for presolving
SCIP_RETCODE SCIPincludeSepaBasic(SCIP *scip, SCIP_SEPA **sepa, const char *name, const char *desc, int priority, int freq, SCIP_Real maxbounddist, SCIP_Bool usessubscip, SCIP_Bool delay, SCIP_DECL_SEPAEXECLP((*sepaexeclp)), SCIP_DECL_SEPAEXECSOL((*sepaexecsol)), SCIP_SEPADATA *sepadata)
Definition: scip_sepa.c:178
methods for catching the user CTRL-C interrupt
void SCIPsepaSetCopy(SCIP_SEPA *sepa, SCIP_DECL_SEPACOPY((*sepacopy)))
Definition: sepa.c:623
internal methods for problem variables
data structures and methods for collecting reoptimization information
the function declarations for the synchronization store
void SCIPsepaSetInitsol(SCIP_SEPA *sepa, SCIP_DECL_SEPAINITSOL((*sepainitsol)))
Definition: sepa.c:667
SCIP_RETCODE SCIPsetSepaExitsol(SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPAEXITSOL((*sepaexitsol)))
Definition: scip_sepa.c:300
internal methods for user interface dialog
#define SCIP_Bool
Definition: def.h:69
#define SCIP_DECL_SEPAINIT(x)
Definition: type_sepa.h:63
internal methods for input file readers
methods for debugging
reoptsols primal heuristic
internal methods for storing cuts in a cut pool
Constraint handler for linear constraints in their most general form, .
#define SCIP_DECL_SEPAEXITSOL(x)
Definition: type_sepa.h:93
#define SCIP_DECL_SEPAEXECSOL(x)
Definition: type_sepa.h:140
helper functions for concurrent scip solvers
internal methods for return codes for SCIP methods
void SCIPsepaSetPriority(SCIP_SEPA *sepa, SCIP_SET *set, int priority)
Definition: sepa.c:719
SCIP_RETCODE SCIPsetSepaFree(SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPAFREE((*sepafree)))
Definition: scip_sepa.c:236
SCIP_RETCODE SCIPsetSepaInit(SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPAINIT((*sepainit)))
Definition: scip_sepa.c:252
internal methods for conflict analysis
internal methods for tree compressions
internal methods for main solving loop and node processing
#define SCIP_DECL_SEPAEXIT(x)
Definition: type_sepa.h:71
#define SCIP_DECL_SEPAINITSOL(x)
Definition: type_sepa.h:82
SCIP_SET * set
Definition: struct_scip.h:62
public methods for message output
SCIP_MESSAGEHDLR * messagehdlr
Definition: struct_scip.h:65
default user interface dialog
#define SCIP_Real
Definition: def.h:157
internal methods for problem statistics
internal methods for constraints and constraint handlers
SCIP_TREE * tree
Definition: struct_scip.h:84
declarations for XML parsing
build flags methods
SCIP_SEPA ** SCIPgetSepas(SCIP *scip)
Definition: scip_sepa.c:329
void SCIPsepaSetInit(SCIP_SEPA *sepa, SCIP_DECL_SEPAINIT((*sepainit)))
Definition: sepa.c:645
int SCIPgetNSepas(SCIP *scip)
Definition: scip_sepa.c:342
common defines and data types used in all packages of SCIP
#define SCIP_CALL_ABORT(x)
Definition: def.h:337
internal methods for primal heuristics
void SCIPsetSortSepas(SCIP_SET *set)
Definition: set.c:4165
internal methods for Benders&#39; decomposition cuts
#define SCIP_DECL_SEPAFREE(x)
Definition: type_sepa.h:55
struct SCIP_SepaData SCIP_SEPADATA
Definition: type_sepa.h:38
SCIP_RETCODE SCIPsepaCreate(SCIP_SEPA **sepa, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, int priority, int freq, SCIP_Real maxbounddist, SCIP_Bool usessubscip, SCIP_Bool delay, SCIP_DECL_SEPACOPY((*sepacopy)), SCIP_DECL_SEPAFREE((*sepafree)), SCIP_DECL_SEPAINIT((*sepainit)), SCIP_DECL_SEPAEXIT((*sepaexit)), SCIP_DECL_SEPAINITSOL((*sepainitsol)), SCIP_DECL_SEPAEXITSOL((*sepaexitsol)), SCIP_DECL_SEPAEXECLP((*sepaexeclp)), SCIP_DECL_SEPAEXECSOL((*sepaexecsol)), SCIP_SEPADATA *sepadata)
Definition: sepa.c:187
internal methods for displaying runtime statistics
OFINS - Objective Function Induced Neighborhood Search - a primal heuristic for reoptimization.