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-2025 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 scip_heur.c
26 * @ingroup OTHER_CFILES
27 * @brief public methods for primal heuristic plugins and divesets
28 * @author Tobias Achterberg
29 * @author Timo Berthold
30 * @author Gerald Gamrath
31 * @author Leona Gottwald
32 * @author Stefan Heinz
33 * @author Gregor Hendel
34 * @author Thorsten Koch
35 * @author Alexander Martin
36 * @author Marc Pfetsch
37 * @author Michael Winkler
38 * @author Kati Wolter
39 *
40 * @todo check all SCIP_STAGE_* switches, and include the new stages TRANSFORMED and INITSOLVE
41 */
42
43/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
44
45#include "scip/debug.h"
46#include "scip/heur.h"
47#include "scip/pub_message.h"
48#include "scip/scip_heur.h"
49#include "scip/set.h"
50#include "scip/struct_mem.h"
51#include "scip/struct_scip.h"
52#include "scip/struct_set.h"
53
54/** creates a primal heuristic and includes it in SCIP.
55 *
56 * @note method has all heuristic callbacks as arguments and is thus changed every time a new
57 * callback is added in future releases; consider using SCIPincludeHeurBasic() and setter functions
58 * if you seek for a method which is less likely to change in future releases
59 *
60 * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
61 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
62 *
63 * @pre This method can be called if @p scip is in one of the following stages:
64 * - \ref SCIP_STAGE_INIT
65 * - \ref SCIP_STAGE_PROBLEM
66 */
68 SCIP* scip, /**< SCIP data structure */
69 const char* name, /**< name of primal heuristic */
70 const char* desc, /**< description of primal heuristic */
71 char dispchar, /**< display character of primal heuristic */
72 int priority, /**< priority of the primal heuristic */
73 int freq, /**< frequency for calling primal heuristic */
74 int freqofs, /**< frequency offset for calling primal heuristic */
75 int maxdepth, /**< maximal depth level to call heuristic at (-1: no limit) */
76 SCIP_HEURTIMING timingmask, /**< positions in the node solving loop where heuristic should be executed;
77 * see definition of SCIP_HEURTIMING for possible values */
78 SCIP_Bool usessubscip, /**< does the heuristic use a secondary SCIP instance? */
79 SCIP_DECL_HEURCOPY ((*heurcopy)), /**< copy method of primal heuristic or NULL if you don't want to copy your plugin into sub-SCIPs */
80 SCIP_DECL_HEURFREE ((*heurfree)), /**< destructor of primal heuristic */
81 SCIP_DECL_HEURINIT ((*heurinit)), /**< initialize primal heuristic */
82 SCIP_DECL_HEUREXIT ((*heurexit)), /**< deinitialize primal heuristic */
83 SCIP_DECL_HEURINITSOL ((*heurinitsol)), /**< solving process initialization method of primal heuristic */
84 SCIP_DECL_HEUREXITSOL ((*heurexitsol)), /**< solving process deinitialization method of primal heuristic */
85 SCIP_DECL_HEUREXEC ((*heurexec)), /**< execution method of primal heuristic */
86 SCIP_HEURDATA* heurdata /**< primal heuristic data */
87 )
88{
89 SCIP_HEUR* heur;
90
92
93 /* check whether heuristic is already present */
94 if( SCIPfindHeur(scip, name) != NULL )
95 {
96 SCIPerrorMessage("heuristic <%s> already included.\n", name);
97 return SCIP_INVALIDDATA;
98 }
99
100 SCIP_CALL( SCIPheurCreate(&heur, scip->set, scip->messagehdlr, scip->mem->setmem,
101 name, desc, dispchar, priority, freq, freqofs, maxdepth, timingmask, usessubscip,
102 heurcopy, heurfree, heurinit, heurexit, heurinitsol, heurexitsol, heurexec, heurdata) );
103
104 SCIP_CALL( SCIPsetIncludeHeur(scip->set, heur) );
105
106 return SCIP_OKAY;
107}
108
109/** creates a primal heuristic and includes it in SCIP with its most fundamental callbacks.
110 * All non-fundamental (or optional) callbacks
111 * as, e. g., init and exit callbacks, will be set to NULL.
112 * Optional callbacks can be set via specific setter functions, see SCIPsetHeurCopy(), SCIPsetHeurFree(),
113 * SCIPsetHeurInit(), SCIPsetHeurExit(), SCIPsetHeurInitsol(), and SCIPsetHeurExitsol()
114 *
115 * @pre This method can be called if SCIP is in one of the following stages:
116 * - \ref SCIP_STAGE_INIT
117 * - \ref SCIP_STAGE_PROBLEM
118 *
119 * @note if you want to set all callbacks with a single method call, consider using SCIPincludeHeur() instead
120 *
121 */
123 SCIP* scip, /**< SCIP data structure */
124 SCIP_HEUR** heur, /**< pointer to primal heuristic */
125 const char* name, /**< name of primal heuristic */
126 const char* desc, /**< description of primal heuristic */
127 char dispchar, /**< display character of primal heuristic */
128 int priority, /**< priority of the primal heuristic */
129 int freq, /**< frequency for calling primal heuristic */
130 int freqofs, /**< frequency offset for calling primal heuristic */
131 int maxdepth, /**< maximal depth level to call heuristic at (-1: no limit) */
132 SCIP_HEURTIMING timingmask, /**< positions in the node solving loop where heuristic should be executed;
133 * see definition of SCIP_HEURTIMING for possible values */
134 SCIP_Bool usessubscip, /**< does the heuristic use a secondary SCIP instance? */
135 SCIP_DECL_HEUREXEC ((*heurexec)), /**< execution method of primal heuristic */
136 SCIP_HEURDATA* heurdata /**< primal heuristic data */
137 )
138{
139 SCIP_HEUR* heurptr;
140
141 SCIP_CALL( SCIPcheckStage(scip, "SCIPincludeHeurBasic", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
142
143 /* check whether heuristic is already present */
144 if( SCIPfindHeur(scip, name) != NULL )
145 {
146 SCIPerrorMessage("heuristic <%s> already included.\n", name);
147 return SCIP_INVALIDDATA;
148 }
149
150 SCIP_CALL( SCIPheurCreate(&heurptr, scip->set, scip->messagehdlr, scip->mem->setmem,
151 name, desc, dispchar, priority, freq, freqofs, maxdepth, timingmask, usessubscip,
152 NULL, NULL, NULL, NULL, NULL, NULL, heurexec, heurdata) );
153
154 assert(heurptr != NULL);
155
156 SCIP_CALL( SCIPsetIncludeHeur(scip->set, heurptr) );
157
158 if( heur != NULL )
159 *heur = heurptr;
160
161 return SCIP_OKAY;
162}
163
164/* new callback/method setter methods */
165
166/** sets copy method of primal heuristic */
168 SCIP* scip, /**< SCIP data structure */
169 SCIP_HEUR* heur, /**< primal heuristic */
170 SCIP_DECL_HEURCOPY ((*heurcopy)) /**< copy method of primal heuristic or NULL if you don't want to copy your plugin into sub-SCIPs */
171 )
172{
174
175 assert(heur != NULL);
176
177 SCIPheurSetCopy(heur, heurcopy);
178
179 return SCIP_OKAY;
180}
181
182/** sets destructor method of primal heuristic */
184 SCIP* scip, /**< SCIP data structure */
185 SCIP_HEUR* heur, /**< primal heuristic */
186 SCIP_DECL_HEURFREE ((*heurfree)) /**< destructor of primal heuristic */
187 )
188{
190
191 assert(heur != NULL);
192
193 SCIPheurSetFree(heur, heurfree);
194
195 return SCIP_OKAY;
196}
197
198/** sets initialization method of primal heuristic */
200 SCIP* scip, /**< SCIP data structure */
201 SCIP_HEUR* heur, /**< primal heuristic */
202 SCIP_DECL_HEURINIT ((*heurinit)) /**< initialize primal heuristic */
203 )
204{
206
207 assert(heur != NULL);
208
209 SCIPheurSetInit(heur, heurinit);
210
211 return SCIP_OKAY;
212}
213
214/** sets deinitialization method of primal heuristic */
216 SCIP* scip, /**< SCIP data structure */
217 SCIP_HEUR* heur, /**< primal heuristic */
218 SCIP_DECL_HEUREXIT ((*heurexit)) /**< deinitialize primal heuristic */
219 )
220{
222
223 assert(heur != NULL);
224
225 SCIPheurSetExit(heur, heurexit);
226
227 return SCIP_OKAY;
228}
229
230/** sets solving process initialization method of primal heuristic */
232 SCIP* scip, /**< SCIP data structure */
233 SCIP_HEUR* heur, /**< primal heuristic */
234 SCIP_DECL_HEURINITSOL ((*heurinitsol)) /**< solving process initialization method of primal heuristic */
235 )
236{
238
239 assert(heur != NULL);
240
241 SCIPheurSetInitsol(heur, heurinitsol);
242
243 return SCIP_OKAY;
244}
245
246/** sets solving process deinitialization method of primal heuristic */
248 SCIP* scip, /**< SCIP data structure */
249 SCIP_HEUR* heur, /**< primal heuristic */
250 SCIP_DECL_HEUREXITSOL ((*heurexitsol)) /**< solving process deinitialization method of primal heuristic */
251 )
252{
254
255 assert(heur != NULL);
256
257 SCIPheurSetExitsol(heur, heurexitsol);
258
259 return SCIP_OKAY;
260}
261
262/** returns the primal heuristic of the given name, or NULL if not existing */
264 SCIP* scip, /**< SCIP data structure */
265 const char* name /**< name of primal heuristic */
266 )
267{
268 assert(scip != NULL);
269 assert(scip->set != NULL);
270 assert(name != NULL);
271
272 return SCIPsetFindHeur(scip->set, name);
273}
274
275/** returns the array of currently available primal heuristics */
277 SCIP* scip /**< SCIP data structure */
278 )
279{
280 assert(scip != NULL);
281 assert(scip->set != NULL);
282
283 return scip->set->heurs;
284}
285
286/** returns the number of currently available primal heuristics */
288 SCIP* scip /**< SCIP data structure */
289 )
290{
291 assert(scip != NULL);
292 assert(scip->set != NULL);
293
294 return scip->set->nheurs;
295}
296
297/** sets the priority of a primal heuristic */
299 SCIP* scip, /**< SCIP data structure */
300 SCIP_HEUR* heur, /**< primal heuristic */
301 int priority /**< new priority of the primal heuristic */
302 )
303{
304 assert(scip != NULL);
305 assert(scip->set != NULL);
306
307 SCIPheurSetPriority(heur, scip->set, priority);
308
309 return SCIP_OKAY;
310}
311
312/** create a diving set associated with a primal heuristic. The primal heuristic needs to be included
313 * before this method can be called. The diveset is installed in the array of divesets of the heuristic
314 * and can be retrieved later by accessing SCIPheurGetDivesets()
315 *
316 * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
317 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
318 *
319 * @pre This method can be called if @p scip is in one of the following stages:
320 * - \ref SCIP_STAGE_INIT
321 * - \ref SCIP_STAGE_PROBLEM
322 */
324 SCIP* scip, /**< SCIP data structure */
325 SCIP_DIVESET** diveset, /**< pointer to created diving heuristic settings, or NULL if not needed */
326 SCIP_HEUR* heur, /**< primal heuristic to which the diveset belongs */
327 const char* name, /**< name for the diveset, or NULL if the name of the heuristic should be used */
328 SCIP_Real minreldepth, /**< minimal relative depth to start diving */
329 SCIP_Real maxreldepth, /**< maximal relative depth to start diving */
330 SCIP_Real maxlpiterquot, /**< maximal fraction of diving LP iterations compared to node LP iterations */
331 SCIP_Real maxdiveubquot, /**< maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound)
332 * where diving is performed (0.0: no limit) */
333 SCIP_Real maxdiveavgquot, /**< maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound)
334 * where diving is performed (0.0: no limit) */
335 SCIP_Real maxdiveubquotnosol, /**< maximal UBQUOT when no solution was found yet (0.0: no limit) */
336 SCIP_Real maxdiveavgquotnosol,/**< maximal AVGQUOT when no solution was found yet (0.0: no limit) */
337 SCIP_Real lpresolvedomchgquot,/**< percentage of immediate domain changes during probing to trigger LP resolve */
338 int lpsolvefreq, /**< LP solve frequency for (0: only if enough domain reductions are found by propagation)*/
339 int maxlpiterofs, /**< additional number of allowed LP iterations */
340 unsigned int initialseed, /**< initial seed for random number generation */
341 SCIP_Bool backtrack, /**< use one level of backtracking if infeasibility is encountered? */
342 SCIP_Bool onlylpbranchcands, /**< should only LP branching candidates be considered instead of the slower but
343 * more general constraint handler diving variable selection? */
344 SCIP_Bool ispublic, /**< is this dive set publicly available (ie., can be used by other primal heuristics?) */
345 SCIP_Bool specificsos1score, /**< should SOS1 variables be scored by the diving heuristics specific score function;
346 * otherwise use the score function of the SOS1 constraint handler */
347 SCIP_DECL_DIVESETGETSCORE((*divesetgetscore)), /**< method for candidate score and rounding direction */
348 SCIP_DECL_DIVESETAVAILABLE((*divesetavailable)) /**< callback to check availability of dive set at the current stage, or NULL if always available */
349 )
350{
351 SCIP_DIVESET* divesetptr = NULL;
353
354 /* create the diveset (this will add diving specific parameters for this heuristic) */
355 SCIP_CALL( SCIPdivesetCreate(&divesetptr, heur, name, scip->set, scip->messagehdlr, scip->mem->setmem,
356 minreldepth, maxreldepth, maxlpiterquot, maxdiveubquot, maxdiveavgquot, maxdiveubquotnosol,
357 maxdiveavgquotnosol, lpresolvedomchgquot, lpsolvefreq, maxlpiterofs, initialseed, backtrack,
358 onlylpbranchcands, ispublic, specificsos1score, divesetgetscore, divesetavailable) );
359
360 assert(divesetptr != NULL);
361 if( diveset != NULL )
362 *diveset = divesetptr;
363
364 return SCIP_OKAY;
365}
366
367/** check specific preconditions for diving, e.g., if an incumbent solution is available */
369 SCIP* scip, /**< SCIP data structure */
370 SCIP_DIVESET* diveset, /**< diving heuristic settings */
371 SCIP_Bool* available /**< pointer to store if the diving can run at the current solving stage */
372 )
373{
374 assert(scip != NULL);
375 assert(diveset != NULL);
376 assert(available != NULL);
377
378 SCIP_CALL( SCIPdivesetIsAvailable(diveset, scip->set, available) );
379
380 return SCIP_OKAY;
381}
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:2203
methods for debugging
#define NULL
Definition: def.h:266
#define SCIP_Bool
Definition: def.h:91
#define SCIP_Real
Definition: def.h:172
#define TRUE
Definition: def.h:93
#define FALSE
Definition: def.h:94
#define SCIP_CALL(x)
Definition: def.h:373
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 ispublic, SCIP_Bool specificsos1score, SCIP_DECL_DIVESETGETSCORE((*divesetgetscore)), SCIP_DECL_DIVESETAVAILABLE((*divesetavailable)))
Definition: scip_heur.c:323
SCIP_RETCODE SCIPisDivesetAvailable(SCIP *scip, SCIP_DIVESET *diveset, SCIP_Bool *available)
Definition: scip_heur.c:368
SCIP_RETCODE SCIPsetHeurPriority(SCIP *scip, SCIP_HEUR *heur, int priority)
Definition: scip_heur.c:298
SCIP_RETCODE SCIPsetHeurExitsol(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEUREXITSOL((*heurexitsol)))
Definition: scip_heur.c:247
SCIP_RETCODE SCIPsetHeurCopy(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEURCOPY((*heurcopy)))
Definition: scip_heur.c:167
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:122
SCIP_HEUR ** SCIPgetHeurs(SCIP *scip)
Definition: scip_heur.c:276
SCIP_RETCODE SCIPsetHeurFree(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEURFREE((*heurfree)))
Definition: scip_heur.c:183
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:67
SCIP_RETCODE SCIPsetHeurExit(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEUREXIT((*heurexit)))
Definition: scip_heur.c:215
int SCIPgetNHeurs(SCIP *scip)
Definition: scip_heur.c:287
SCIP_RETCODE SCIPsetHeurInitsol(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEURINITSOL((*heurinitsol)))
Definition: scip_heur.c:231
SCIP_HEUR * SCIPfindHeur(SCIP *scip, const char *name)
Definition: scip_heur.c:263
SCIP_RETCODE SCIPsetHeurInit(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEURINIT((*heurinit)))
Definition: scip_heur.c:199
void SCIPheurSetCopy(SCIP_HEUR *heur, SCIP_DECL_HEURCOPY((*heurcopy)))
Definition: heur.c:1387
void SCIPheurSetInitsol(SCIP_HEUR *heur, SCIP_DECL_HEURINITSOL((*heurinitsol)))
Definition: heur.c:1431
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_Bool ispublic, SCIP_DIVETYPE divetypemask, SCIP_DECL_DIVESETGETSCORE((*divesetgetscore)), SCIP_DECL_DIVESETAVAILABLE((*divesetavailable)))
Definition: heur.c:266
SCIP_RETCODE SCIPdivesetIsAvailable(SCIP_DIVESET *diveset, SCIP_SET *set, SCIP_Bool *available)
Definition: heur.c:858
void SCIPheurSetFree(SCIP_HEUR *heur, SCIP_DECL_HEURFREE((*heurfree)))
Definition: heur.c:1398
void SCIPheurSetPriority(SCIP_HEUR *heur, SCIP_SET *set, int priority)
Definition: heur.c:1524
void SCIPheurSetInit(SCIP_HEUR *heur, SCIP_DECL_HEURINIT((*heurinit)))
Definition: heur.c:1409
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:989
void SCIPheurSetExitsol(SCIP_HEUR *heur, SCIP_DECL_HEUREXITSOL((*heurexitsol)))
Definition: heur.c:1442
void SCIPheurSetExit(SCIP_HEUR *heur, SCIP_DECL_HEUREXIT((*heurexit)))
Definition: heur.c:1420
internal methods for primal heuristics
public methods for message output
#define SCIPerrorMessage
Definition: pub_message.h:64
public methods for primal heuristic plugins and divesets
SCIP_HEUR * SCIPsetFindHeur(SCIP_SET *set, const char *name)
Definition: set.c:4605
SCIP_RETCODE SCIPsetIncludeHeur(SCIP_SET *set, SCIP_HEUR *heur)
Definition: set.c:4581
internal methods for global SCIP settings
datastructures for block memory pools and memory buffers
SCIP main data structure.
datastructures for global SCIP settings
#define SCIP_DECL_DIVESETAVAILABLE(x)
Definition: type_heur.h:199
#define SCIP_DECL_HEURINITSOL(x)
Definition: type_heur.h:132
#define SCIP_DECL_HEURCOPY(x)
Definition: type_heur.h:97
struct SCIP_HeurData SCIP_HEURDATA
Definition: type_heur.h:77
#define SCIP_DECL_HEURINIT(x)
Definition: type_heur.h:113
#define SCIP_DECL_HEUREXIT(x)
Definition: type_heur.h:121
#define SCIP_DECL_HEURFREE(x)
Definition: type_heur.h:105
#define SCIP_DECL_DIVESETGETSCORE(x)
Definition: type_heur.h:184
#define SCIP_DECL_HEUREXITSOL(x)
Definition: type_heur.h:143
#define SCIP_DECL_HEUREXEC(x)
Definition: type_heur.h:163
@ SCIP_INVALIDDATA
Definition: type_retcode.h:52
@ SCIP_OKAY
Definition: type_retcode.h:42
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:63
unsigned int SCIP_HEURTIMING
Definition: type_timing.h:101