Scippy

SCIP

Solving Constraint Integer Programs

scip_heur.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-2018 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_heur.c
17  * @brief public methods for primal heuristic plugins and divesets
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_heur.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 primal heuristic and includes it in SCIP.
125  *
126  * @note method has all heuristic callbacks as arguments and is thus changed every time a new
127  * callback is added in future releases; consider using SCIPincludeHeurBasic() and setter functions
128  * if you seek for a method which is less likely to change in future releases
129  *
130  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
131  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
132  *
133  * @pre This method can be called if @p scip is in one of the following stages:
134  * - \ref SCIP_STAGE_INIT
135  * - \ref SCIP_STAGE_PROBLEM
136  */
138  SCIP* scip, /**< SCIP data structure */
139  const char* name, /**< name of primal heuristic */
140  const char* desc, /**< description of primal heuristic */
141  char dispchar, /**< display character of primal heuristic */
142  int priority, /**< priority of the primal heuristic */
143  int freq, /**< frequency for calling primal heuristic */
144  int freqofs, /**< frequency offset for calling primal heuristic */
145  int maxdepth, /**< maximal depth level to call heuristic at (-1: no limit) */
146  SCIP_HEURTIMING timingmask, /**< positions in the node solving loop where heuristic should be executed;
147  * see definition of SCIP_HEURTIMING for possible values */
148  SCIP_Bool usessubscip, /**< does the heuristic use a secondary SCIP instance? */
149  SCIP_DECL_HEURCOPY ((*heurcopy)), /**< copy method of primal heuristic or NULL if you don't want to copy your plugin into sub-SCIPs */
150  SCIP_DECL_HEURFREE ((*heurfree)), /**< destructor of primal heuristic */
151  SCIP_DECL_HEURINIT ((*heurinit)), /**< initialize primal heuristic */
152  SCIP_DECL_HEUREXIT ((*heurexit)), /**< deinitialize primal heuristic */
153  SCIP_DECL_HEURINITSOL ((*heurinitsol)), /**< solving process initialization method of primal heuristic */
154  SCIP_DECL_HEUREXITSOL ((*heurexitsol)), /**< solving process deinitialization method of primal heuristic */
155  SCIP_DECL_HEUREXEC ((*heurexec)), /**< execution method of primal heuristic */
156  SCIP_HEURDATA* heurdata /**< primal heuristic data */
157  )
158 {
159  SCIP_HEUR* heur;
160 
161  SCIP_CALL( SCIPcheckStage(scip, "SCIPincludeHeur", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
162 
163  /* check whether heuristic is already present */
164  if( SCIPfindHeur(scip, name) != NULL )
165  {
166  SCIPerrorMessage("heuristic <%s> already included.\n", name);
167  return SCIP_INVALIDDATA;
168  }
169 
170  SCIP_CALL( SCIPheurCreate(&heur, scip->set, scip->messagehdlr, scip->mem->setmem,
171  name, desc, dispchar, priority, freq, freqofs, maxdepth, timingmask, usessubscip,
172  heurcopy, heurfree, heurinit, heurexit, heurinitsol, heurexitsol, heurexec, heurdata) );
173 
174  SCIP_CALL( SCIPsetIncludeHeur(scip->set, heur) );
175 
176  return SCIP_OKAY;
177 }
178 
179 /** creates a primal heuristic and includes it in SCIP with its most fundamental callbacks.
180  * All non-fundamental (or optional) callbacks
181  * as, e. g., init and exit callbacks, will be set to NULL.
182  * Optional callbacks can be set via specific setter functions, see SCIPsetHeurCopy(), SCIPsetHeurFree(),
183  * SCIPsetHeurInit(), SCIPsetHeurExit(), SCIPsetHeurInitsol(), and SCIPsetHeurExitsol()
184  *
185 * @note if you want to set all callbacks with a single method call, consider using SCIPincludeHeur() instead
186  */
188  SCIP* scip, /**< SCIP data structure */
189  SCIP_HEUR** heur, /**< pointer to primal heuristic */
190  const char* name, /**< name of primal heuristic */
191  const char* desc, /**< description of primal heuristic */
192  char dispchar, /**< display character of primal heuristic */
193  int priority, /**< priority of the primal heuristic */
194  int freq, /**< frequency for calling primal heuristic */
195  int freqofs, /**< frequency offset for calling primal heuristic */
196  int maxdepth, /**< maximal depth level to call heuristic at (-1: no limit) */
197  SCIP_HEURTIMING timingmask, /**< positions in the node solving loop where heuristic should be executed;
198  * see definition of SCIP_HEURTIMING for possible values */
199  SCIP_Bool usessubscip, /**< does the heuristic use a secondary SCIP instance? */
200  SCIP_DECL_HEUREXEC ((*heurexec)), /**< execution method of primal heuristic */
201  SCIP_HEURDATA* heurdata /**< primal heuristic data */
202  )
203 {
204  SCIP_HEUR* heurptr;
205 
206  SCIP_CALL( SCIPcheckStage(scip, "SCIPincludeHeurBasic", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
207 
208  /* check whether heuristic is already present */
209  if( SCIPfindHeur(scip, name) != NULL )
210  {
211  SCIPerrorMessage("heuristic <%s> already included.\n", name);
212  return SCIP_INVALIDDATA;
213  }
214 
215  SCIP_CALL( SCIPheurCreate(&heurptr, scip->set, scip->messagehdlr, scip->mem->setmem,
216  name, desc, dispchar, priority, freq, freqofs, maxdepth, timingmask, usessubscip,
217  NULL, NULL, NULL, NULL, NULL, NULL, heurexec, heurdata) );
218 
219  assert(heurptr != NULL);
220 
221  SCIP_CALL( SCIPsetIncludeHeur(scip->set, heurptr) );
222 
223  if( heur != NULL )
224  *heur = heurptr;
225 
226  return SCIP_OKAY;
227 }
228 
229 /* new callback/method setter methods */
230 
231 /** sets copy method of primal heuristic */
233  SCIP* scip, /**< SCIP data structure */
234  SCIP_HEUR* heur, /**< primal heuristic */
235  SCIP_DECL_HEURCOPY ((*heurcopy)) /**< copy method of primal heuristic or NULL if you don't want to copy your plugin into sub-SCIPs */
236  )
237 {
238  SCIP_CALL( SCIPcheckStage(scip, "SCIPsetHeurCopy", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
239 
240  assert(heur != NULL);
241 
242  SCIPheurSetCopy(heur, heurcopy);
243 
244  return SCIP_OKAY;
245 }
246 
247 /** sets destructor method of primal heuristic */
249  SCIP* scip, /**< SCIP data structure */
250  SCIP_HEUR* heur, /**< primal heuristic */
251  SCIP_DECL_HEURFREE ((*heurfree)) /**< destructor of primal heuristic */
252  )
253 {
254  SCIP_CALL( SCIPcheckStage(scip, "SCIPsetHeurFree", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
255 
256  assert(heur != NULL);
257 
258  SCIPheurSetFree(heur, heurfree);
259 
260  return SCIP_OKAY;
261 }
262 
263 /** sets initialization method of primal heuristic */
265  SCIP* scip, /**< SCIP data structure */
266  SCIP_HEUR* heur, /**< primal heuristic */
267  SCIP_DECL_HEURINIT ((*heurinit)) /**< initialize primal heuristic */
268  )
269 {
270  SCIP_CALL( SCIPcheckStage(scip, "SCIPsetHeurInit", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
271 
272  assert(heur != NULL);
273 
274  SCIPheurSetInit(heur, heurinit);
275 
276  return SCIP_OKAY;
277 }
278 
279 /** sets deinitialization method of primal heuristic */
281  SCIP* scip, /**< SCIP data structure */
282  SCIP_HEUR* heur, /**< primal heuristic */
283  SCIP_DECL_HEUREXIT ((*heurexit)) /**< deinitialize primal heuristic */
284  )
285 {
286  SCIP_CALL( SCIPcheckStage(scip, "SCIPsetHeurExit", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
287 
288  assert(heur != NULL);
289 
290  SCIPheurSetExit(heur, heurexit);
291 
292  return SCIP_OKAY;
293 }
294 
295 /** sets solving process initialization method of primal heuristic */
297  SCIP* scip, /**< SCIP data structure */
298  SCIP_HEUR* heur, /**< primal heuristic */
299  SCIP_DECL_HEURINITSOL ((*heurinitsol)) /**< solving process initialization method of primal heuristic */
300  )
301 {
302  SCIP_CALL( SCIPcheckStage(scip, "SCIPsetHeurInitsol", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
303 
304  assert(heur != NULL);
305 
306  SCIPheurSetInitsol(heur, heurinitsol);
307 
308  return SCIP_OKAY;
309 }
310 
311 /** sets solving process deinitialization method of primal heuristic */
313  SCIP* scip, /**< SCIP data structure */
314  SCIP_HEUR* heur, /**< primal heuristic */
315  SCIP_DECL_HEUREXITSOL ((*heurexitsol)) /**< solving process deinitialization method of primal heuristic */
316  )
317 {
318  SCIP_CALL( SCIPcheckStage(scip, "SCIPsetHeurExitsol", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
319 
320  assert(heur != NULL);
321 
322  SCIPheurSetExitsol(heur, heurexitsol);
323 
324  return SCIP_OKAY;
325 }
326 
327 /** returns the primal heuristic of the given name, or NULL if not existing */
329  SCIP* scip, /**< SCIP data structure */
330  const char* name /**< name of primal heuristic */
331  )
332 {
333  assert(scip != NULL);
334  assert(scip->set != NULL);
335  assert(name != NULL);
336 
337  return SCIPsetFindHeur(scip->set, name);
338 }
339 
340 /** returns the array of currently available primal heuristics */
342  SCIP* scip /**< SCIP data structure */
343  )
344 {
345  assert(scip != NULL);
346  assert(scip->set != NULL);
347 
348  SCIPsetSortHeurs(scip->set);
349 
350  return scip->set->heurs;
351 }
352 
353 /** returns the number of currently available primal heuristics */
355  SCIP* scip /**< SCIP data structure */
356  )
357 {
358  assert(scip != NULL);
359  assert(scip->set != NULL);
360 
361  return scip->set->nheurs;
362 }
363 
364 /** sets the priority of a primal heuristic */
366  SCIP* scip, /**< SCIP data structure */
367  SCIP_HEUR* heur, /**< primal heuristic */
368  int priority /**< new priority of the primal heuristic */
369  )
370 {
371  assert(scip != NULL);
372  assert(scip->set != NULL);
373 
374  SCIPheurSetPriority(heur, scip->set, priority);
375 
376  return SCIP_OKAY;
377 }
378 
379 /** create a diving set associated with a primal heuristic. The primal heuristic needs to be included
380  * before this method can be called. The diveset is installed in the array of divesets of the heuristic
381  * and can be retrieved later by accessing SCIPheurGetDivesets()
382  *
383  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
384  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
385  *
386  * @pre This method can be called if @p scip is in one of the following stages:
387  * - \ref SCIP_STAGE_INIT
388  * - \ref SCIP_STAGE_PROBLEM
389  */
391  SCIP* scip, /**< SCIP data structure */
392  SCIP_DIVESET** diveset, /**< pointer to created diving heuristic settings, or NULL if not needed */
393  SCIP_HEUR* heur, /**< primal heuristic to which the diveset belongs */
394  const char* name, /**< name for the diveset, or NULL if the name of the heuristic should be used */
395  SCIP_Real minreldepth, /**< minimal relative depth to start diving */
396  SCIP_Real maxreldepth, /**< maximal relative depth to start diving */
397  SCIP_Real maxlpiterquot, /**< maximal fraction of diving LP iterations compared to node LP iterations */
398  SCIP_Real maxdiveubquot, /**< maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound)
399  * where diving is performed (0.0: no limit) */
400  SCIP_Real maxdiveavgquot, /**< maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound)
401  * where diving is performed (0.0: no limit) */
402  SCIP_Real maxdiveubquotnosol, /**< maximal UBQUOT when no solution was found yet (0.0: no limit) */
403  SCIP_Real maxdiveavgquotnosol,/**< maximal AVGQUOT when no solution was found yet (0.0: no limit) */
404  SCIP_Real lpresolvedomchgquot,/**< percentage of immediate domain changes during probing to trigger LP resolve */
405  int lpsolvefreq, /**< LP solve frequency for (0: only if enough domain reductions are found by propagation)*/
406  int maxlpiterofs, /**< additional number of allowed LP iterations */
407  unsigned int initialseed, /**< initial seed for random number generation */
408  SCIP_Bool backtrack, /**< use one level of backtracking if infeasibility is encountered? */
409  SCIP_Bool onlylpbranchcands, /**< should only LP branching candidates be considered instead of the slower but
410  * more general constraint handler diving variable selection? */
411  SCIP_Bool specificsos1score, /**< should SOS1 variables be scored by the diving heuristics specific score function;
412  * otherwise use the score function of the SOS1 constraint handler */
413  SCIP_DECL_DIVESETGETSCORE((*divesetgetscore)) /**< method for candidate score and rounding direction */
414  )
415 {
416  SCIP_DIVESET* divesetptr = NULL;
417  SCIP_CALL( SCIPcheckStage(scip, "SCIPcreateDiveset", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
418 
419  /* create the diveset (this will add diving specific parameters for this heuristic) */
420  SCIP_CALL( SCIPdivesetCreate(&divesetptr, heur, name, scip->set, scip->messagehdlr, scip->mem->setmem,
421  minreldepth, maxreldepth, maxlpiterquot, maxdiveubquot, maxdiveavgquot, maxdiveubquotnosol,
422  maxdiveavgquotnosol, lpresolvedomchgquot, lpsolvefreq, maxlpiterofs, initialseed, backtrack,
423  onlylpbranchcands, specificsos1score, divesetgetscore) );
424 
425  assert(divesetptr != NULL);
426  if( diveset != NULL )
427  *diveset = divesetptr;
428 
429  return SCIP_OKAY;
430 }
SCIP_RETCODE SCIPsetHeurExitsol(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEUREXITSOL((*heurexitsol)))
Definition: scip_heur.c:312
internal methods for separators
void SCIPheurSetInitsol(SCIP_HEUR *heur, SCIP_DECL_HEURINITSOL((*heurinitsol)))
Definition: heur.c:1232
#define SCIP_DECL_HEURINITSOL(x)
Definition: type_heur.h:97
#define NULL
Definition: def.h:239
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
internal methods for clocks and timing issues
unsigned int SCIP_HEURTIMING
Definition: type_timing.h:97
SCIP_RETCODE SCIPsetHeurExit(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEUREXIT((*heurexit)))
Definition: scip_heur.c:280
void SCIPheurSetExitsol(SCIP_HEUR *heur, SCIP_DECL_HEUREXITSOL((*heurexitsol)))
Definition: heur.c:1243
internal methods for NLPI solver interfaces
interface methods for specific LP solvers
internal methods for displaying statistics tables
void SCIPsetSortHeurs(SCIP_SET *set)
Definition: set.c:4462
#define FALSE
Definition: def.h:65
methods for the aggregation rows
internal methods for Benders&#39; decomposition
#define TRUE
Definition: def.h:64
#define SCIP_DECL_HEURCOPY(x)
Definition: type_heur.h:62
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:53
#define SCIP_DECL_HEUREXEC(x)
Definition: type_heur.h:128
methods commonly used by primal heuristics
SCIP_RETCODE SCIPincludeHeur(SCIP *scip, const char *name, const char *desc, char dispchar, int priority, int freq, int freqofs, int maxdepth, SCIP_HEURTIMING timingmask, SCIP_Bool usessubscip, SCIP_DECL_HEURCOPY((*heurcopy)), SCIP_DECL_HEURFREE((*heurfree)), SCIP_DECL_HEURINIT((*heurinit)), SCIP_DECL_HEUREXIT((*heurexit)), SCIP_DECL_HEURINITSOL((*heurinitsol)), SCIP_DECL_HEUREXITSOL((*heurexitsol)), SCIP_DECL_HEUREXEC((*heurexec)), SCIP_HEURDATA *heurdata)
Definition: scip_heur.c:137
SCIP_HEUR ** SCIPgetHeurs(SCIP *scip)
Definition: scip_heur.c:341
internal methods for branching rules and branching candidate storage
void SCIPheurSetPriority(SCIP_HEUR *heur, SCIP_SET *set, int priority)
Definition: heur.c:1325
datastructures for concurrent solvers
struct SCIP_HeurData SCIP_HEURDATA
Definition: type_heur.h:51
int nheurs
Definition: struct_set.h:114
SCIP_RETCODE SCIPincludeHeurBasic(SCIP *scip, SCIP_HEUR **heur, const char *name, const char *desc, char dispchar, int priority, int freq, int freqofs, int maxdepth, SCIP_HEURTIMING timingmask, SCIP_Bool usessubscip, SCIP_DECL_HEUREXEC((*heurexec)), SCIP_HEURDATA *heurdata)
Definition: scip_heur.c:187
internal methods for handling parameter settings
methods for creating output for visualization tools (VBC, BAK)
nodereopt branching rule
SCIP_RETCODE SCIPheurCreate(SCIP_HEUR **heur, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, char dispchar, int priority, int freq, int freqofs, int maxdepth, SCIP_HEURTIMING timingmask, SCIP_Bool usessubscip, SCIP_DECL_HEURCOPY((*heurcopy)), SCIP_DECL_HEURFREE((*heurfree)), SCIP_DECL_HEURINIT((*heurinit)), SCIP_DECL_HEUREXIT((*heurexit)), SCIP_DECL_HEURINITSOL((*heurinitsol)), SCIP_DECL_HEUREXITSOL((*heurexitsol)), SCIP_DECL_HEUREXEC((*heurexec)), SCIP_HEURDATA *heurdata)
Definition: heur.c:793
#define SCIP_DECL_DIVESETGETSCORE(x)
Definition: type_heur.h:149
internal methods for LP management
internal methods for branching and inference history
internal methods for collecting primal CIP solutions and primal informations
internal methods for propagators
SCIP_RETCODE SCIPsetHeurPriority(SCIP *scip, SCIP_HEUR *heur, int priority)
Definition: scip_heur.c:365
SCIP_MEM * mem
Definition: struct_scip.h:61
SCIP_RETCODE SCIPsetIncludeHeur(SCIP_SET *set, SCIP_HEUR *heur)
Definition: set.c:4418
SCIP_RETCODE SCIPsetHeurInitsol(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEURINITSOL((*heurinitsol)))
Definition: scip_heur.c:296
git hash methods
SCIP_HEUR * SCIPfindHeur(SCIP *scip, const char *name)
Definition: scip_heur.c:328
internal methods for storing and manipulating the main problem
#define SCIPerrorMessage
Definition: pub_message.h:45
SCIP_RETCODE SCIPsetHeurFree(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEURFREE((*heurfree)))
Definition: scip_heur.c:248
methods for block memory pools and memory buffers
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:1933
internal methods for presolvers
internal methods for NLP management
void SCIPheurSetCopy(SCIP_HEUR *heur, SCIP_DECL_HEURCOPY((*heurcopy)))
Definition: heur.c:1188
internal miscellaneous methods
internal methods for node selectors and node priority queues
internal methods for variable pricers
internal methods for global SCIP settings
internal methods for storing conflicts
#define SCIP_CALL(x)
Definition: def.h:351
SCIP main data structure.
BMS_BLKMEM * setmem
Definition: struct_mem.h:39
internal methods for storing priced variables
internal methods for relaxators
internal methods for storing separated cuts
public methods for primal heuristic plugins and divesets
methods commonly used for presolving
methods for catching the user CTRL-C interrupt
internal methods for problem variables
data structures and methods for collecting reoptimization information
the function declarations for the synchronization store
internal methods for user interface dialog
#define SCIP_Bool
Definition: def.h:62
internal methods for input file readers
SCIP_HEUR ** heurs
Definition: struct_set.h:80
methods for debugging
void SCIPheurSetFree(SCIP_HEUR *heur, SCIP_DECL_HEURFREE((*heurfree)))
Definition: heur.c:1199
SCIP_RETCODE SCIPcreateDiveset(SCIP *scip, SCIP_DIVESET **diveset, SCIP_HEUR *heur, const char *name, SCIP_Real minreldepth, SCIP_Real maxreldepth, SCIP_Real maxlpiterquot, SCIP_Real maxdiveubquot, SCIP_Real maxdiveavgquot, SCIP_Real maxdiveubquotnosol, SCIP_Real maxdiveavgquotnosol, SCIP_Real lpresolvedomchgquot, int lpsolvefreq, int maxlpiterofs, unsigned int initialseed, SCIP_Bool backtrack, SCIP_Bool onlylpbranchcands, SCIP_Bool specificsos1score, SCIP_DECL_DIVESETGETSCORE((*divesetgetscore)))
Definition: scip_heur.c:390
SCIP_HEUR * SCIPsetFindHeur(SCIP_SET *set, const char *name)
Definition: set.c:4442
reoptsols primal heuristic
internal methods for storing cuts in a cut pool
Constraint handler for linear constraints in their most general form, .
helper functions for concurrent scip solvers
internal methods for return codes for SCIP methods
int SCIPgetNHeurs(SCIP *scip)
Definition: scip_heur.c:354
internal methods for conflict analysis
internal methods for tree compressions
internal methods for main solving loop and node processing
void SCIPheurSetExit(SCIP_HEUR *heur, SCIP_DECL_HEUREXIT((*heurexit)))
Definition: heur.c:1221
#define SCIP_DECL_HEUREXIT(x)
Definition: type_heur.h:86
SCIP_SET * set
Definition: struct_scip.h:62
public methods for message output
#define SCIP_DECL_HEURINIT(x)
Definition: type_heur.h:78
SCIP_RETCODE SCIPsetHeurInit(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEURINIT((*heurinit)))
Definition: scip_heur.c:264
SCIP_MESSAGEHDLR * messagehdlr
Definition: struct_scip.h:65
default user interface dialog
#define SCIP_Real
Definition: def.h:150
internal methods for problem statistics
void SCIPheurSetInit(SCIP_HEUR *heur, SCIP_DECL_HEURINIT((*heurinit)))
Definition: heur.c:1210
#define SCIP_DECL_HEURFREE(x)
Definition: type_heur.h:70
internal methods for constraints and constraint handlers
SCIP_RETCODE SCIPdivesetCreate(SCIP_DIVESET **divesetptr, SCIP_HEUR *heur, const char *name, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, SCIP_Real minreldepth, SCIP_Real maxreldepth, SCIP_Real maxlpiterquot, SCIP_Real maxdiveubquot, SCIP_Real maxdiveavgquot, SCIP_Real maxdiveubquotnosol, SCIP_Real maxdiveavgquotnosol, SCIP_Real lpresolvedomchgquot, int lpsolvefreq, int maxlpiterofs, unsigned int initialseed, SCIP_Bool backtrack, SCIP_Bool onlylpbranchcands, SCIP_DIVETYPE divetypemask, SCIP_DECL_DIVESETGETSCORE((*divesetgetscore)))
Definition: heur.c:187
declarations for XML parsing
build flags methods
SCIP_RETCODE SCIPsetHeurCopy(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEURCOPY((*heurcopy)))
Definition: scip_heur.c:232
common defines and data types used in all packages of SCIP
internal methods for primal heuristics
#define SCIP_DECL_HEUREXITSOL(x)
Definition: type_heur.h:108
internal methods for Benders&#39; decomposition cuts
internal methods for displaying runtime statistics
OFINS - Objective Function Induced Neighborhood Search - a primal heuristic for reoptimization.