Scippy

SCIP

Solving Constraint Integer Programs

compr.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-2016 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 compr.c
17  * @brief methods for tree compressions
18  * @author Jakob Witzig
19  */
20 
21 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
22 
23 #include <assert.h>
24 #include <string.h>
25 
26 #include "scip/def.h"
27 #include "scip/set.h"
28 #include "scip/clock.h"
29 #include "scip/paramset.h"
30 #include "scip/scip.h"
31 #include "scip/compr.h"
32 #include "scip/reopt.h"
33 #include "scip/pub_message.h"
34 #include "scip/pub_misc.h"
35 
36 #include "scip/struct_compr.h"
37 
38 
39 
40 /** compares two compression methods w. r. to their delay positions and their priority */
41 SCIP_DECL_SORTPTRCOMP(SCIPcomprComp)
42 { /*lint --e{715}*/
43  SCIP_COMPR* compr1 = (SCIP_COMPR*)elem1;
44  SCIP_COMPR* compr2 = (SCIP_COMPR*)elem2;
45 
46  assert(compr1 != NULL);
47  assert(compr2 != NULL);
48 
49  return compr2->priority - compr1->priority; /* prefer higher priorities */
50 }
51 
52 /** comparison method for sorting heuristics w.r.t. to their name */
53 SCIP_DECL_SORTPTRCOMP(SCIPcomprCompName)
54 {
55  return strcmp(SCIPcomprGetName((SCIP_COMPR*)elem1), SCIPcomprGetName((SCIP_COMPR*)elem2));
56 }
57 
58 /** method to call, when the priority of a compression was changed */
59 static
60 SCIP_DECL_PARAMCHGD(paramChgdComprPriority)
61 { /*lint --e{715}*/
62  SCIP_PARAMDATA* paramdata;
63 
64  paramdata = SCIPparamGetData(param);
65  assert(paramdata != NULL);
66 
67  /* use SCIPsetComprPriority() to mark the compressions unsorted */
68  SCIP_CALL( SCIPsetComprPriority(scip, (SCIP_COMPR*)paramdata, SCIPparamGetInt(param)) ); /*lint !e740*/
69 
70  return SCIP_OKAY;
71 }
72 
73 /** copies the given tree compression to a new scip */
75  SCIP_COMPR* compr, /**< tree compression */
76  SCIP_SET* set /**< SCIP_SET of SCIP to copy to */
77  )
78 {
79  assert(compr != NULL);
80  assert(set != NULL);
81  assert(set->scip != NULL);
82 
83  if( compr->comprcopy != NULL )
84  {
85  SCIPdebugMessage("including compr %s in subscip %p\n", SCIPcomprGetName(compr), (void*)set->scip);
86  SCIP_CALL( compr->comprcopy(set->scip, compr) );
87  }
88 
89  return SCIP_OKAY;
90 }
91 
92 /** creates a tree compression */
94  SCIP_COMPR** compr, /**< pointer to tree compression data structure */
95  SCIP_SET* set, /**< global SCIP settings */
96  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
97  BMS_BLKMEM* blkmem, /**< block memory for parameter settings */
98  const char* name, /**< name of tree compression */
99  const char* desc, /**< description of tree compression */
100  int priority, /**< priority of the tree compression */
101  int minnnodes, /**< minimal number of nodes for calling compression */
102  SCIP_DECL_COMPRCOPY ((*comprcopy)), /**< copy method of tree compression or NULL if you don't want to copy your plugin into sub-SCIPs */
103  SCIP_DECL_COMPRFREE ((*comprfree)), /**< destructor of tree compression */
104  SCIP_DECL_COMPRINIT ((*comprinit)), /**< initialize tree compression */
105  SCIP_DECL_COMPREXIT ((*comprexit)), /**< deinitialize tree compression */
106  SCIP_DECL_COMPRINITSOL ((*comprinitsol)), /**< solving process initialization method of tree compression */
107  SCIP_DECL_COMPREXITSOL ((*comprexitsol)), /**< solving process deinitialization method of tree compression */
108  SCIP_DECL_COMPREXEC ((*comprexec)), /**< execution method of tree compression */
109  SCIP_COMPRDATA* comprdata /**< tree compression data */
110  )
111 {
113  char paramdesc[SCIP_MAXSTRLEN];
114 
115  assert(compr != NULL);
116  assert(name != NULL);
117  assert(desc != NULL);
118  assert(comprexec != NULL);
119 
120  SCIP_ALLOC( BMSallocMemory(compr) );
121  SCIP_ALLOC( BMSduplicateMemoryArray(&(*compr)->name, name, strlen(name)+1) );
122  SCIP_ALLOC( BMSduplicateMemoryArray(&(*compr)->desc, desc, strlen(desc)+1) );
123  (*compr)->priority = priority;
124  (*compr)->minnnodes = minnnodes;
125  (*compr)->comprcopy = comprcopy;
126  (*compr)->comprfree = comprfree;
127  (*compr)->comprinit = comprinit;
128  (*compr)->comprexit = comprexit;
129  (*compr)->comprinitsol = comprinitsol;
130  (*compr)->comprexitsol = comprexitsol;
131  (*compr)->comprexec = comprexec;
132  (*compr)->comprdata = comprdata;
133  SCIP_CALL( SCIPclockCreate(&(*compr)->setuptime, SCIP_CLOCKTYPE_DEFAULT) );
134  SCIP_CALL( SCIPclockCreate(&(*compr)->comprclock, SCIP_CLOCKTYPE_DEFAULT) );
135  (*compr)->ncalls = 0;
136  (*compr)->nfound = 0;
137  (*compr)->rate = 0.0;
138  (*compr)->initialized = FALSE;
139  (*compr)->nnodes = 0;
140  (*compr)->loi = 0.0;
141 
142  /* add parameters */
143  (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "compression/%s/priority", name);
144  (void) SCIPsnprintf(paramdesc, SCIP_MAXSTRLEN, "priority of compression <%s>", name);
145  SCIP_CALL( SCIPsetAddIntParam(set, messagehdlr, blkmem, paramname, paramdesc,
146  &(*compr)->priority, TRUE, priority, INT_MIN/4, INT_MAX/4,
147  paramChgdComprPriority, (SCIP_PARAMDATA*)(*compr)) ); /*lint !e740*/
148  (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "compression/%s/minnleaves", name);
149  (void) SCIPsnprintf(paramdesc, SCIP_MAXSTRLEN, "minimal number of leave nodes for calling tree compression <%s>", name);
150  SCIP_CALL( SCIPsetAddIntParam(set, messagehdlr, blkmem, paramname, paramdesc,
151  &(*compr)->minnnodes, FALSE, minnnodes, 1, INT_MAX, NULL, NULL) );
152 
153  return SCIP_OKAY;
154 }
155 
156 /** calls destructor and frees memory of tree compression */
158  SCIP_COMPR** compr, /**< pointer to tree compression data structure */
159  SCIP_SET* set /**< global SCIP settings */
160  )
161 {
162  assert(compr != NULL);
163  assert(*compr != NULL);
164  assert(!(*compr)->initialized);
165  assert(set != NULL);
166 
167  /* call destructor of tree compression */
168  if( (*compr)->comprfree != NULL )
169  {
170  SCIP_CALL( (*compr)->comprfree(set->scip, *compr) );
171  }
172 
173  SCIPclockFree(&(*compr)->comprclock);
174  SCIPclockFree(&(*compr)->setuptime);
175  BMSfreeMemoryArray(&(*compr)->name);
176  BMSfreeMemoryArray(&(*compr)->desc);
177  BMSfreeMemory(compr);
178 
179  return SCIP_OKAY;
180 }
181 
182 /** initializes tree compression */
184  SCIP_COMPR* compr, /**< tree compression */
185  SCIP_SET* set /**< global SCIP settings */
186  )
187 {
188  assert(compr != NULL);
189  assert(set != NULL);
190 
191  if( compr->initialized )
192  {
193  SCIPerrorMessage("tree compression <%s> already initialized\n", compr->name);
194  return SCIP_INVALIDCALL;
195  }
196 
197  if( set->misc_resetstat && !set->reopt_enable )
198  {
199  SCIPclockReset(compr->setuptime);
200  SCIPclockReset(compr->comprclock);
201 
202  compr->ncalls = 0;
203  compr->nfound = 0;
204  }
205 
206  if( compr->comprinit != NULL )
207  {
208  /* start timing */
209  SCIPclockStart(compr->setuptime, set);
210 
211  SCIP_CALL( compr->comprinit(set->scip, compr) );
212 
213  /* stop timing */
214  SCIPclockStop(compr->setuptime, set);
215  }
216  compr->initialized = TRUE;
217 
218  return SCIP_OKAY;
219 }
220 
221 /** calls exit method of tree compression */
223  SCIP_COMPR* compr, /**< tree compression */
224  SCIP_SET* set /**< global SCIP settings */
225  )
226 {
227  assert(compr != NULL);
228  assert(set != NULL);
229 
230  if( !compr->initialized )
231  {
232  SCIPerrorMessage("tree compression <%s> not initialized\n", compr->name);
233  return SCIP_INVALIDCALL;
234  }
235 
236  if( compr->comprexit != NULL )
237  {
238  /* start timing */
239  SCIPclockStart(compr->setuptime, set);
240 
241  SCIP_CALL( compr->comprexit(set->scip, compr) );
242 
243  /* stop timing */
244  SCIPclockStop(compr->setuptime, set);
245  }
246  compr->initialized = FALSE;
247 
248  return SCIP_OKAY;
249 }
250 
251 /** calls execution method of tree compression */
253  SCIP_COMPR* compr, /**< tree compression */
254  SCIP_SET* set, /**< global SCIP settings */
255  SCIP_REOPT* reopt, /**< reoptimization data structure */
256  SCIP_RESULT* result /**< pointer to store the result of the callback method */
257  )
258 {
259  assert(compr != NULL);
260  assert(compr->comprexec != NULL);
261  assert(set != NULL);
262  assert(set->scip != NULL);
263  assert(result != NULL);
264 
265  *result = SCIP_DIDNOTRUN;
266 
267  /* do not run if reoptimization data structure is not initialized */
268  if( reopt == NULL )
269  return SCIP_OKAY;
270 
271  /* do not run if the reoptimization tree is not large enough */
272  if( SCIPreoptGetNLeaves(reopt, NULL) < compr->minnnodes )
273  return SCIP_OKAY;
274 
275  SCIPdebugMessage("executing tree compression <%s>\n", compr->name);
276 
277  /* start timing */
278  SCIPclockStart(compr->comprclock, set);
279 
280  /* call external method */
281  SCIP_CALL( compr->comprexec(set->scip, compr, result) );
282 
283  /* stop timing */
284  SCIPclockStop(compr->comprclock, set);
285 
286  /* evaluate result */
287  if( *result != SCIP_SUCCESS
288  && *result != SCIP_DIDNOTFIND
289  && *result != SCIP_DIDNOTRUN )
290  {
291  SCIPerrorMessage("execution method of tree compression <%s> returned invalid result <%d>\n",
292  compr->name, *result);
293  return SCIP_INVALIDRESULT;
294  }
295 
296  if( *result != SCIP_DIDNOTRUN )
297  compr->ncalls++;
298 
299  if( *result == SCIP_SUCCESS )
300  compr->nfound++;
301 
302  return SCIP_OKAY;
303 }
304 
305 /** gets user data of tree compression */
307  SCIP_COMPR* compr /**< tree compression */
308  )
309 {
310  assert(compr != NULL);
311 
312  return compr->comprdata;
313 }
314 
315 /** sets user data of tree compression; user has to free old data in advance! */
317  SCIP_COMPR* compr, /**< tree compression */
318  SCIP_COMPRDATA* comprdata /**< new tree compression user data */
319  )
320 {
321  assert(compr != NULL);
322 
323  compr->comprdata = comprdata;
324 }
325 
326 /* new callback setter methods */
327 
328 /** sets copy callback of tree compression */
330  SCIP_COMPR* compr, /**< tree compression */
331  SCIP_DECL_COMPRCOPY ((*comprcopy)) /**< copy callback of tree compression or NULL if you don't want to copy your plugin into sub-SCIPs */
332  )
333 {
334  assert(compr != NULL);
335 
336  compr->comprcopy = comprcopy;
337 }
338 
339 /** sets destructor callback of tree compression */
341  SCIP_COMPR* compr, /**< tree compression */
342  SCIP_DECL_COMPRFREE ((*comprfree)) /**< destructor of tree compression */
343  )
344 {
345  assert(compr != NULL);
346 
347  compr->comprfree = comprfree;
348 }
349 
350 /** sets initialization callback of tree compression */
352  SCIP_COMPR* compr, /**< tree compression */
353  SCIP_DECL_COMPRINIT ((*comprinit)) /**< initialize tree compression */
354  )
355 {
356  assert(compr != NULL);
357 
358  compr->comprinit = comprinit;
359 }
360 
361 /** sets deinitialization callback of tree compression */
363  SCIP_COMPR* compr, /**< tree compression */
364  SCIP_DECL_COMPREXIT ((*comprexit)) /**< deinitialize tree compression */
365  )
366 {
367  assert(compr != NULL);
368 
369  compr->comprexit = comprexit;
370 }
371 
372 /** sets solving process initialization callback of tree compression */
374  SCIP_COMPR* compr, /**< tree compression */
375  SCIP_DECL_COMPRINITSOL ((*comprinitsol)) /**< solving process initialization callback of tree compression */
376  )
377 {
378  assert(compr != NULL);
379 
380  compr->comprinitsol = comprinitsol;
381 }
382 
383 /** sets solving process deinitialization callback of tree compression */
385  SCIP_COMPR* compr, /**< tree compression */
386  SCIP_DECL_COMPREXITSOL ((*comprexitsol)) /**< solving process deinitialization callback of tree compression */
387  )
388 {
389  assert(compr != NULL);
390 
391  compr->comprexitsol = comprexitsol;
392 }
393 
394 /** should the compression be executed at the given depth, number of nodes */
396  SCIP_COMPR* compr, /**< tree compression */
397  int depth, /**< depth of current node */
398  int nnodes /**< number of open nodes */
399  )
400 {
401  assert(compr != NULL);
402  assert(depth >= 0);
403  assert(nnodes >= 0);
404 
405  return nnodes >= compr->minnnodes;
406 }
407 
408 /** gets name of tree compression */
409 const char* SCIPcomprGetName(
410  SCIP_COMPR* compr /**< tree compression */
411  )
412 {
413  assert(compr != NULL);
414 
415  return compr->name;
416 }
417 
418 /** gets description of tree compression */
419 const char* SCIPcomprGetDesc(
420  SCIP_COMPR* compr /**< tree compression */
421  )
422 {
423  assert(compr != NULL);
424 
425  return compr->desc;
426 }
427 
428 /** gets priority of tree compression */
430  SCIP_COMPR* compr /**< tree compression */
431  )
432 {
433  assert(compr != NULL);
434 
435  return compr->priority;
436 }
437 
438 /** sets priority of tree compression */
440  SCIP_COMPR* compr, /**< tree compression */
441  SCIP_SET* set, /**< global SCIP settings */
442  int priority /**< new priority of the tree compression */
443  )
444 {
445  assert(compr != NULL);
446  assert(set != NULL);
447 
448  compr->priority = priority;
449  set->comprssorted = FALSE;
450 }
451 
452 /** gets minimal number of nodes for calling tree compression (returns -1, if no node threshold exists) */
454  SCIP_COMPR* compr /**< tree compression */
455  )
456 {
457  assert(compr != NULL);
458 
459  return compr->minnnodes;
460 }
461 
462 /** gets the number of times, the heuristic was called and tried to find a solution */
464  SCIP_COMPR* compr /**< tree compression */
465  )
466 {
467  assert(compr != NULL);
468 
469  return compr->ncalls;
470 }
471 
472 /** gets the number of compressions found by this compression */
474  SCIP_COMPR* compr /**< tree compression */
475  )
476 {
477  assert(compr != NULL);
478 
479  return compr->nfound;
480 }
481 
482 /** is tree compression initialized? */
484  SCIP_COMPR* compr /**< tree compression */
485  )
486 {
487  assert(compr != NULL);
488 
489  return compr->initialized;
490 }
491 
492 /** gets time in seconds used in this heuristic for setting up for next stages */
494  SCIP_COMPR* compr /**< tree compression */
495  )
496 {
497  assert(compr != NULL);
498 
499  return SCIPclockGetTime(compr->setuptime);
500 }
501 
502 /** gets time in seconds used in this heuristic */
504  SCIP_COMPR* compr /**< tree compression */
505  )
506 {
507  assert(compr != NULL);
508 
509  return SCIPclockGetTime(compr->comprclock);
510 }
enum SCIP_Result SCIP_RESULT
Definition: type_result.h:51
int SCIPcomprGetMinNodes(SCIP_COMPR *compr)
Definition: compr.c:453
#define BMSfreeMemoryArray(ptr)
Definition: memory.h:102
void SCIPcomprSetInitsol(SCIP_COMPR *compr, SCIP_DECL_COMPRINITSOL((*comprinitsol)))
Definition: compr.c:373
SCIP_Longint SCIPcomprGetNCalls(SCIP_COMPR *compr)
Definition: compr.c:463
int SCIPreoptGetNLeaves(SCIP_REOPT *reopt, SCIP_NODE *node)
Definition: reopt.c:4766
#define SCIP_DECL_COMPREXEC(x)
Definition: type_compr.h:111
void SCIPcomprSetCopy(SCIP_COMPR *compr, SCIP_DECL_COMPRCOPY((*comprcopy)))
Definition: compr.c:329
SCIP_PARAMDATA * SCIPparamGetData(SCIP_PARAM *param)
Definition: paramset.c:651
#define SCIP_MAXSTRLEN
Definition: def.h:201
SCIP_RETCODE SCIPcomprInit(SCIP_COMPR *compr, SCIP_SET *set)
Definition: compr.c:183
internal methods for clocks and timing issues
#define NULL
Definition: lpi_spx.cpp:130
struct SCIP_ParamData SCIP_PARAMDATA
Definition: type_paramset.h:73
SCIP_RETCODE SCIPcomprCreate(SCIP_COMPR **compr, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, int priority, int minnnodes, SCIP_DECL_COMPRCOPY((*comprcopy)), SCIP_DECL_COMPRFREE((*comprfree)), SCIP_DECL_COMPRINIT((*comprinit)), SCIP_DECL_COMPREXIT((*comprexit)), SCIP_DECL_COMPRINITSOL((*comprinitsol)), SCIP_DECL_COMPREXITSOL((*comprexitsol)), SCIP_DECL_COMPREXEC((*comprexec)), SCIP_COMPRDATA *comprdata)
Definition: compr.c:93
#define SCIP_DECL_COMPREXITSOL(x)
Definition: type_compr.h:95
void SCIPcomprSetExitsol(SCIP_COMPR *compr, SCIP_DECL_COMPREXITSOL((*comprexitsol)))
Definition: compr.c:384
SCIP_RETCODE SCIPsetComprPriority(SCIP *scip, SCIP_COMPR *compr, int priority)
Definition: scip.c:7664
void SCIPclockStop(SCIP_CLOCK *clck, SCIP_SET *set)
Definition: clock.c:350
SCIP_COMPRDATA * SCIPcomprGetData(SCIP_COMPR *compr)
Definition: compr.c:306
#define FALSE
Definition: def.h:56
SCIP_CLOCK * comprclock
Definition: struct_compr.h:53
void SCIPclockStart(SCIP_CLOCK *clck, SCIP_SET *set)
Definition: clock.c:280
SCIP_RETCODE SCIPcomprFree(SCIP_COMPR **compr, SCIP_SET *set)
Definition: compr.c:157
int SCIPsnprintf(char *t, int len, const char *s,...)
Definition: misc.c:8174
#define TRUE
Definition: def.h:55
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:53
void SCIPcomprSetPriority(SCIP_COMPR *compr, SCIP_SET *set, int priority)
Definition: compr.c:439
void SCIPcomprSetInit(SCIP_COMPR *compr, SCIP_DECL_COMPRINIT((*comprinit)))
Definition: compr.c:351
#define SCIP_CALL(x)
Definition: def.h:266
void SCIPcomprSetData(SCIP_COMPR *compr, SCIP_COMPRDATA *comprdata)
Definition: compr.c:316
static SCIP_DECL_PARAMCHGD(paramChgdComprPriority)
Definition: compr.c:60
#define SCIPdebugMessage
Definition: pub_message.h:77
SCIP_RETCODE SCIPcomprExec(SCIP_COMPR *compr, SCIP_SET *set, SCIP_REOPT *reopt, SCIP_RESULT *result)
Definition: compr.c:252
internal methods for handling parameter settings
SCIP_Real SCIPcomprGetSetupTime(SCIP_COMPR *compr)
Definition: compr.c:493
SCIP_Bool SCIPcomprIsInitialized(SCIP_COMPR *compr)
Definition: compr.c:483
#define SCIP_DECL_COMPRINIT(x)
Definition: type_compr.h:65
#define SCIP_DECL_COMPRFREE(x)
Definition: type_compr.h:57
SCIP_Longint nfound
Definition: struct_compr.h:39
SCIP_Bool SCIPcomprShouldBeExecuted(SCIP_COMPR *compr, int depth, int nnodes)
Definition: compr.c:395
char * desc
Definition: struct_compr.h:43
#define SCIPerrorMessage
Definition: pub_message.h:45
SCIP_COMPRDATA * comprdata
Definition: struct_compr.h:51
#define SCIP_DECL_COMPRCOPY(x)
Definition: type_compr.h:49
void SCIPclockReset(SCIP_CLOCK *clck)
Definition: clock.c:199
SCIP_CLOCK * setuptime
Definition: struct_compr.h:52
#define BMSallocMemory(ptr)
Definition: memory.h:74
SCIP_Longint ncalls
Definition: struct_compr.h:38
SCIP_Real SCIPclockGetTime(SCIP_CLOCK *clck)
Definition: clock.c:428
internal methods for global SCIP settings
#define BMSfreeMemory(ptr)
Definition: memory.h:100
struct SCIP_ComprData SCIP_COMPRDATA
Definition: type_compr.h:40
SCIP_RETCODE SCIPsetAddIntParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, int *valueptr, SCIP_Bool isadvanced, int defaultvalue, int minvalue, int maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: set.c:2455
SCIP_RETCODE SCIPcomprExit(SCIP_COMPR *compr, SCIP_SET *set)
Definition: compr.c:222
#define BMSduplicateMemoryArray(ptr, source, num)
Definition: memory.h:98
SCIP_RETCODE SCIPclockCreate(SCIP_CLOCK **clck, SCIP_CLOCKTYPE clocktype)
Definition: clock.c:160
#define SCIP_DECL_COMPRINITSOL(x)
Definition: type_compr.h:84
data structures and methods for collecting reoptimization information
public data structures and miscellaneous methods
#define SCIP_Bool
Definition: def.h:53
static const char * paramname[]
Definition: lpi_msk.c:4201
datastructures for tree compression techniques
void SCIPclockFree(SCIP_CLOCK **clck)
Definition: clock.c:175
SCIP_RETCODE SCIPcomprCopyInclude(SCIP_COMPR *compr, SCIP_SET *set)
Definition: compr.c:74
const char * SCIPcomprGetName(SCIP_COMPR *compr)
Definition: compr.c:409
const char * SCIPcomprGetDesc(SCIP_COMPR *compr)
Definition: compr.c:419
#define SCIP_DECL_COMPREXIT(x)
Definition: type_compr.h:73
SCIP_DECL_SORTPTRCOMP(SCIPcomprComp)
Definition: compr.c:41
int SCIPparamGetInt(SCIP_PARAM *param)
Definition: paramset.c:706
internal methods for tree compressions
public methods for message output
SCIP_Real SCIPcomprGetTime(SCIP_COMPR *compr)
Definition: compr.c:503
SCIP_Bool initialized
Definition: struct_compr.h:57
#define SCIP_Real
Definition: def.h:127
SCIP_Longint SCIPcomprGetNFound(SCIP_COMPR *compr)
Definition: compr.c:473
#define SCIP_Longint
Definition: def.h:112
void SCIPcomprSetFree(SCIP_COMPR *compr, SCIP_DECL_COMPRFREE((*comprfree)))
Definition: compr.c:340
char * name
Definition: struct_compr.h:42
common defines and data types used in all packages of SCIP
struct BMS_BlkMem BMS_BLKMEM
Definition: memory.h:392
void SCIPcomprSetExit(SCIP_COMPR *compr, SCIP_DECL_COMPREXIT((*comprexit)))
Definition: compr.c:362
#define SCIP_ALLOC(x)
Definition: def.h:277
SCIP callable library.
int SCIPcomprGetPriority(SCIP_COMPR *compr)
Definition: compr.c:429