Scippy

SCIP

Solving Constraint Integer Programs

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 sepa.c
17  * @brief methods and datastructures for separators
18  * @author Tobias Achterberg
19  * @author Timo Berthold
20  */
21 
22 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
23 
24 #include <assert.h>
25 #include <string.h>
26 
27 #include "scip/def.h"
28 #include "scip/set.h"
29 #include "scip/stat.h"
30 #include "scip/clock.h"
31 #include "scip/paramset.h"
32 #include "scip/sepastore.h"
33 #include "scip/scip.h"
34 #include "scip/sepa.h"
35 #include "scip/pub_message.h"
36 #include "scip/pub_misc.h"
37 
38 #include "scip/struct_sepa.h"
39 
40 
41 /** compares two separators w. r. to their priority */
42 SCIP_DECL_SORTPTRCOMP(SCIPsepaComp)
43 { /*lint --e{715}*/
44  return ((SCIP_SEPA*)elem2)->priority - ((SCIP_SEPA*)elem1)->priority;
45 }
46 
47 /** comparison method for sorting separators w.r.t. to their name */
48 SCIP_DECL_SORTPTRCOMP(SCIPsepaCompName)
49 {
50  return strcmp(SCIPsepaGetName((SCIP_SEPA*)elem1), SCIPsepaGetName((SCIP_SEPA*)elem2));
51 }
52 
53 /** method to call, when the priority of a separator was changed */
54 static
55 SCIP_DECL_PARAMCHGD(paramChgdSepaPriority)
56 { /*lint --e{715}*/
57  SCIP_PARAMDATA* paramdata;
58 
59  paramdata = SCIPparamGetData(param);
60  assert(paramdata != NULL);
61 
62  /* use SCIPsetSepaPriority() to mark the sepas unsorted */
63  SCIP_CALL( SCIPsetSepaPriority(scip, (SCIP_SEPA*)paramdata, SCIPparamGetInt(param)) ); /*lint !e740*/
64 
65  return SCIP_OKAY;
66 }
67 
68 /** copies the given separator to a new scip */
70  SCIP_SEPA* sepa, /**< separator */
71  SCIP_SET* set /**< SCIP_SET of SCIP to copy to */
72  )
73 {
74  assert(sepa != NULL);
75  assert(set != NULL);
76  assert(set->scip != NULL);
77 
78  if( sepa->sepacopy != NULL )
79  {
80  SCIPsetDebugMsg(set, "including separator %s in subscip %p\n", SCIPsepaGetName(sepa), (void*)set->scip);
81  SCIP_CALL( sepa->sepacopy(set->scip, sepa) );
82  }
83  return SCIP_OKAY;
84 }
85 
86 /** internal method for creating a separator */
87 static
89  SCIP_SEPA** sepa, /**< pointer to separator data structure */
90  SCIP_SET* set, /**< global SCIP settings */
91  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
92  BMS_BLKMEM* blkmem, /**< block memory for parameter settings */
93  const char* name, /**< name of separator */
94  const char* desc, /**< description of separator */
95  int priority, /**< priority of separator (>= 0: before, < 0: after constraint handlers) */
96  int freq, /**< frequency for calling separator */
97  SCIP_Real maxbounddist, /**< maximal relative distance from current node's dual bound to primal bound compared
98  * to best node's dual bound for applying separation */
99  SCIP_Bool usessubscip, /**< does the separator use a secondary SCIP instance? */
100  SCIP_Bool delay, /**< should separator be delayed, if other separators found cuts? */
101  SCIP_DECL_SEPACOPY ((*sepacopy)), /**< copy method of separator or NULL if you don't want to copy your plugin into sub-SCIPs */
102  SCIP_DECL_SEPAFREE ((*sepafree)), /**< destructor of separator */
103  SCIP_DECL_SEPAINIT ((*sepainit)), /**< initialize separator */
104  SCIP_DECL_SEPAEXIT ((*sepaexit)), /**< deinitialize separator */
105  SCIP_DECL_SEPAINITSOL ((*sepainitsol)), /**< solving process initialization method of separator */
106  SCIP_DECL_SEPAEXITSOL ((*sepaexitsol)), /**< solving process deinitialization method of separator */
107  SCIP_DECL_SEPAEXECLP ((*sepaexeclp)), /**< LP solution separation method of separator */
108  SCIP_DECL_SEPAEXECSOL ((*sepaexecsol)), /**< arbitrary primal solution separation method of separator */
109  SCIP_SEPADATA* sepadata /**< separator data */
110  )
111 {
112  char paramname[SCIP_MAXSTRLEN];
113  char paramdesc[SCIP_MAXSTRLEN];
114 
115  assert(sepa != NULL);
116  assert(name != NULL);
117  assert(desc != NULL);
118  assert(freq >= -1);
119  assert(0.0 <= maxbounddist && maxbounddist <= 1.0);
120  assert(sepaexeclp != NULL || sepaexecsol != NULL);
121 
122  SCIP_ALLOC( BMSallocMemory(sepa) );
123  BMSclearMemory(*sepa);
124 
125  SCIP_ALLOC( BMSduplicateMemoryArray(&(*sepa)->name, name, strlen(name)+1) );
126  SCIP_ALLOC( BMSduplicateMemoryArray(&(*sepa)->desc, desc, strlen(desc)+1) );
127  (*sepa)->priority = priority;
128  (*sepa)->freq = freq;
129  (*sepa)->maxbounddist = maxbounddist;
130  (*sepa)->usessubscip = usessubscip;
131  (*sepa)->sepacopy = sepacopy;
132  (*sepa)->sepafree = sepafree;
133  (*sepa)->sepainit = sepainit;
134  (*sepa)->sepaexit = sepaexit;
135  (*sepa)->sepainitsol = sepainitsol;
136  (*sepa)->sepaexitsol = sepaexitsol;
137  (*sepa)->sepaexeclp = sepaexeclp;
138  (*sepa)->sepaexecsol = sepaexecsol;
139  (*sepa)->sepadata = sepadata;
140  SCIP_CALL( SCIPclockCreate(&(*sepa)->setuptime, SCIP_CLOCKTYPE_DEFAULT) );
141  SCIP_CALL( SCIPclockCreate(&(*sepa)->sepaclock, SCIP_CLOCKTYPE_DEFAULT) );
142  (*sepa)->lastsepanode = -1;
143  (*sepa)->ncalls = 0;
144  (*sepa)->ncutoffs = 0;
145  (*sepa)->ncutsfound = 0;
146  (*sepa)->ncutsapplied = 0;
147  (*sepa)->nconssfound = 0;
148  (*sepa)->ndomredsfound = 0;
149  (*sepa)->ncallsatnode = 0;
150  (*sepa)->ncutsfoundatnode = 0;
151  (*sepa)->lpwasdelayed = FALSE;
152  (*sepa)->solwasdelayed = FALSE;
153  (*sepa)->initialized = FALSE;
154 
155  /* add parameters */
156  (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "separating/%s/priority", name);
157  (void) SCIPsnprintf(paramdesc, SCIP_MAXSTRLEN, "priority of separator <%s>", name);
158  SCIP_CALL( SCIPsetAddIntParam(set, messagehdlr, blkmem, paramname, paramdesc,
159  &(*sepa)->priority, TRUE, priority, INT_MIN/4, INT_MAX/4,
160  paramChgdSepaPriority, (SCIP_PARAMDATA*)(*sepa)) ); /*lint !e740*/
161 
162  (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "separating/%s/freq", name);
163  (void) SCIPsnprintf(paramdesc, SCIP_MAXSTRLEN, "frequency for calling separator <%s> (-1: never, 0: only in root node)", name);
164  SCIP_CALL( SCIPsetAddIntParam(set, messagehdlr, blkmem, paramname, paramdesc,
165  &(*sepa)->freq, FALSE, freq, -1, SCIP_MAXTREEDEPTH, NULL, NULL) );
166 
167  (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "separating/%s/maxbounddist", name);
168  (void) SCIPsnprintf(paramdesc, SCIP_MAXSTRLEN, "maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <%s> (0.0: only on current best node, 1.0: on all nodes)",
169  name);
170  SCIP_CALL( SCIPsetAddRealParam(set, messagehdlr, blkmem, paramname, paramdesc,
171  &(*sepa)->maxbounddist, TRUE, maxbounddist, 0.0, 1.0, NULL, NULL) );
172 
173  (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "separating/%s/delay", name);
174  SCIP_CALL( SCIPsetAddBoolParam(set, messagehdlr, blkmem, paramname,
175  "should separator be delayed, if other separators found cuts?",
176  &(*sepa)->delay, TRUE, delay, NULL, NULL) ); /*lint !e740*/
177 
178  (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "separating/%s/expbackoff", name);
179  (void) SCIPsnprintf(paramdesc, SCIP_MAXSTRLEN, "base for exponential increase of frequency at which separator <%s> is called (1: call at each multiple of frequency)", name);
180  SCIP_CALL( SCIPsetAddIntParam(set, messagehdlr, blkmem, paramname, paramdesc,
181  &(*sepa)->expbackoff, TRUE, 4, 1, 100, NULL, NULL) ); /*lint !e740*/
182 
183  return SCIP_OKAY;
184 }
185 
186 /** creates a separator */
188  SCIP_SEPA** sepa, /**< pointer to separator data structure */
189  SCIP_SET* set, /**< global SCIP settings */
190  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
191  BMS_BLKMEM* blkmem, /**< block memory for parameter settings */
192  const char* name, /**< name of separator */
193  const char* desc, /**< description of separator */
194  int priority, /**< priority of separator (>= 0: before, < 0: after constraint handlers) */
195  int freq, /**< frequency for calling separator */
196  SCIP_Real maxbounddist, /**< maximal relative distance from current node's dual bound to primal bound compared
197  * to best node's dual bound for applying separation */
198  SCIP_Bool usessubscip, /**< does the separator use a secondary SCIP instance? */
199  SCIP_Bool delay, /**< should separator be delayed, if other separators found cuts? */
200  SCIP_DECL_SEPACOPY ((*sepacopy)), /**< copy method of separator or NULL if you don't want to copy your plugin into sub-SCIPs */
201  SCIP_DECL_SEPAFREE ((*sepafree)), /**< destructor of separator */
202  SCIP_DECL_SEPAINIT ((*sepainit)), /**< initialize separator */
203  SCIP_DECL_SEPAEXIT ((*sepaexit)), /**< deinitialize separator */
204  SCIP_DECL_SEPAINITSOL ((*sepainitsol)), /**< solving process initialization method of separator */
205  SCIP_DECL_SEPAEXITSOL ((*sepaexitsol)), /**< solving process deinitialization method of separator */
206  SCIP_DECL_SEPAEXECLP ((*sepaexeclp)), /**< LP solution separation method of separator */
207  SCIP_DECL_SEPAEXECSOL ((*sepaexecsol)), /**< arbitrary primal solution separation method of separator */
208  SCIP_SEPADATA* sepadata /**< separator data */
209  )
210 {
211  assert(sepa != NULL);
212  assert(name != NULL);
213  assert(desc != NULL);
214  assert(freq >= -1);
215  assert(0.0 <= maxbounddist && maxbounddist <= 1.0);
216  assert(sepaexeclp != NULL || sepaexecsol != NULL);
217 
218  SCIP_CALL_FINALLY( doSepaCreate(sepa, set, messagehdlr, blkmem, name, desc, priority, freq, maxbounddist,
219  usessubscip, delay, sepacopy, sepafree, sepainit, sepaexit, sepainitsol, sepaexitsol, sepaexeclp,
220  sepaexecsol, sepadata), (void) SCIPsepaFree(sepa, set) );
221 
222  return SCIP_OKAY;
223 }
224 
225 /** calls destructor and frees memory of separator */
227  SCIP_SEPA** sepa, /**< pointer to separator data structure */
228  SCIP_SET* set /**< global SCIP settings */
229  )
230 {
231  assert(sepa != NULL);
232  if( *sepa == NULL )
233  return SCIP_OKAY;
234  assert(!(*sepa)->initialized);
235  assert(set != NULL);
236 
237  /* call destructor of separator */
238  if( (*sepa)->sepafree != NULL )
239  {
240  SCIP_CALL( (*sepa)->sepafree(set->scip, *sepa) );
241  }
242 
243  SCIPclockFree(&(*sepa)->sepaclock);
244  SCIPclockFree(&(*sepa)->setuptime);
245  BMSfreeMemoryArrayNull(&(*sepa)->name);
246  BMSfreeMemoryArrayNull(&(*sepa)->desc);
247  BMSfreeMemory(sepa);
248 
249  return SCIP_OKAY;
250 }
251 
252 /** initializes separator */
254  SCIP_SEPA* sepa, /**< separator */
255  SCIP_SET* set /**< global SCIP settings */
256  )
257 {
258  assert(sepa != NULL);
259  assert(set != NULL);
260 
261  if( sepa->initialized )
262  {
263  SCIPerrorMessage("separator <%s> already initialized\n", sepa->name);
264  return SCIP_INVALIDCALL;
265  }
266 
267  if( set->misc_resetstat )
268  {
269  SCIPclockReset(sepa->setuptime);
270  SCIPclockReset(sepa->sepaclock);
271 
272  sepa->lastsepanode = -1;
273  sepa->ncalls = 0;
274  sepa->ncutoffs = 0;
275  sepa->ncutsfound = 0;
276  sepa->ncutsapplied = 0;
277  sepa->nconssfound = 0;
278  sepa->ndomredsfound = 0;
279  sepa->ncallsatnode = 0;
280  sepa->ncutsfoundatnode = 0;
281  sepa->lpwasdelayed = FALSE;
282  sepa->solwasdelayed = FALSE;
283  }
284 
285  if( sepa->sepainit != NULL )
286  {
287  /* start timing */
288  SCIPclockStart(sepa->setuptime, set);
289 
290  SCIP_CALL( sepa->sepainit(set->scip, sepa) );
291 
292  /* stop timing */
293  SCIPclockStop(sepa->setuptime, set);
294  }
295  sepa->initialized = TRUE;
296 
297  return SCIP_OKAY;
298 }
299 
300 /** calls exit method of separator */
302  SCIP_SEPA* sepa, /**< separator */
303  SCIP_SET* set /**< global SCIP settings */
304  )
305 {
306  assert(sepa != NULL);
307  assert(set != NULL);
308 
309  if( !sepa->initialized )
310  {
311  SCIPerrorMessage("separator <%s> not initialized\n", sepa->name);
312  return SCIP_INVALIDCALL;
313  }
314 
315  if( sepa->sepaexit != NULL )
316  {
317  /* start timing */
318  SCIPclockStart(sepa->setuptime, set);
319 
320  SCIP_CALL( sepa->sepaexit(set->scip, sepa) );
321 
322  /* stop timing */
323  SCIPclockStop(sepa->setuptime, set);
324  }
325  sepa->initialized = FALSE;
326 
327  return SCIP_OKAY;
328 }
329 
330 /** informs separator that the branch and bound process is being started */
332  SCIP_SEPA* sepa, /**< separator */
333  SCIP_SET* set /**< global SCIP settings */
334  )
335 {
336  assert(sepa != NULL);
337  assert(set != NULL);
338 
339  sepa->lpwasdelayed = FALSE;
340  sepa->solwasdelayed = FALSE;
341 
342  /* call solving process initialization method of separator */
343  if( sepa->sepainitsol != NULL )
344  {
345  /* start timing */
346  SCIPclockStart(sepa->setuptime, set);
347 
348  SCIP_CALL( sepa->sepainitsol(set->scip, sepa) );
349 
350  /* stop timing */
351  SCIPclockStop(sepa->setuptime, set);
352  }
353 
354  return SCIP_OKAY;
355 }
356 
357 /** informs separator that the branch and bound process data is being freed */
359  SCIP_SEPA* sepa, /**< separator */
360  SCIP_SET* set /**< global SCIP settings */
361  )
362 {
363  assert(sepa != NULL);
364  assert(set != NULL);
365 
366  /* call solving process deinitialization method of separator */
367  if( sepa->sepaexitsol != NULL )
368  {
369  /* start timing */
370  SCIPclockStart(sepa->setuptime, set);
371 
372  SCIP_CALL( sepa->sepaexitsol(set->scip, sepa) );
373 
374  /* stop timing */
375  SCIPclockStop(sepa->setuptime, set);
376  }
377 
378  return SCIP_OKAY;
379 }
380 
381 /** calls LP separation method of separator */
383  SCIP_SEPA* sepa, /**< separator */
384  SCIP_SET* set, /**< global SCIP settings */
385  SCIP_STAT* stat, /**< dynamic problem statistics */
386  SCIP_SEPASTORE* sepastore, /**< separation storage */
387  int depth, /**< depth of current node */
388  SCIP_Real bounddist, /**< current relative distance of local dual bound to global dual bound */
389  SCIP_Bool allowlocal, /**< should the separator be asked to separate local cuts */
390  SCIP_Bool execdelayed, /**< execute separator even if it is marked to be delayed */
391  SCIP_RESULT* result /**< pointer to store the result of the callback method */
392  )
393 {
394  assert(sepa != NULL);
395  assert(sepa->freq >= -1);
396  assert(0.0 <= sepa->maxbounddist && sepa->maxbounddist <= 1.0);
397  assert(0.0 <= bounddist && bounddist <= 1.0);
398  assert(set != NULL);
399  assert(set->scip != NULL);
400  assert(stat != NULL);
401  assert(depth >= 0);
402  assert(result != NULL);
403 
404  if( sepa->sepaexeclp != NULL && SCIPsetIsLE(set, bounddist, sepa->maxbounddist) &&
405  ( (depth == 0 && sepa->freq != -1) ||
406  (sepa->freq > 0 && depth % sepa->freq == 0 &&
407  (sepa->expbackoff == 1 || SCIPsetIsIntegral(set, LOG2(depth * (1.0 / sepa->freq)) / LOG2((SCIP_Real)sepa->expbackoff)))) ||
408  sepa->lpwasdelayed )
409  )
410  {
411  if( (!sepa->delay && !sepa->lpwasdelayed) || execdelayed )
412  {
413  SCIP_Longint oldndomchgs;
414  SCIP_Longint oldnprobdomchgs;
415  int oldncuts;
416  int oldnactiveconss;
417  int ncutsfound;
418 
419  SCIPsetDebugMsg(set, "executing separator <%s> on LP solution\n", sepa->name);
420 
421  oldndomchgs = stat->nboundchgs + stat->nholechgs;
422  oldnprobdomchgs = stat->nprobboundchgs + stat->nprobholechgs;
423  oldncuts = SCIPsepastoreGetNCuts(sepastore);
424  oldnactiveconss = stat->nactiveconss;
425 
426  /* reset the statistics for current node */
427  if( sepa->lastsepanode != stat->ntotalnodes )
428  {
429  sepa->ncallsatnode = 0;
430  sepa->ncutsfoundatnode = 0;
431  }
432 
433  /* start timing */
434  SCIPclockStart(sepa->sepaclock, set);
435 
436  /* call external separation method */
437  SCIP_CALL( sepa->sepaexeclp(set->scip, sepa, result, allowlocal) );
438 
439  /* stop timing */
440  SCIPclockStop(sepa->sepaclock, set);
441 
442  /* update statistics */
443  if( *result != SCIP_DIDNOTRUN && *result != SCIP_DELAYED )
444  {
445  sepa->ncalls++;
446  sepa->ncallsatnode++;
447  sepa->lastsepanode = stat->ntotalnodes;
448  }
449  if( *result == SCIP_CUTOFF )
450  sepa->ncutoffs++;
451  ncutsfound = SCIPsepastoreGetNCuts(sepastore) - oldncuts;
452  sepa->ncutsfound += ncutsfound;
453  sepa->ncutsfoundatnode += ncutsfound;
454  sepa->nconssfound += MAX(stat->nactiveconss - oldnactiveconss, 0); /*lint !e776*/
455 
456  /* update domain reductions; therefore remove the domain
457  * reduction counts which were generated in probing mode */
458  sepa->ndomredsfound += stat->nboundchgs + stat->nholechgs - oldndomchgs;
459  sepa->ndomredsfound -= (stat->nprobboundchgs + stat->nprobholechgs - oldnprobdomchgs);
460 
461  /* evaluate result */
462  if( *result != SCIP_CUTOFF
463  && *result != SCIP_CONSADDED
464  && *result != SCIP_REDUCEDDOM
465  && *result != SCIP_SEPARATED
466  && *result != SCIP_NEWROUND
467  && *result != SCIP_DIDNOTFIND
468  && *result != SCIP_DIDNOTRUN
469  && *result != SCIP_DELAYED )
470  {
471  SCIPerrorMessage("execution method of separator <%s> returned invalid result <%d>\n",
472  sepa->name, *result);
473  return SCIP_INVALIDRESULT;
474  }
475  }
476  else
477  {
478  SCIPsetDebugMsg(set, "separator <%s> was delayed\n", sepa->name);
479  *result = SCIP_DELAYED;
480  }
481 
482  /* remember whether separator was delayed */
483  sepa->lpwasdelayed = (*result == SCIP_DELAYED);
484  }
485  else
486  *result = SCIP_DIDNOTRUN;
487 
488  return SCIP_OKAY;
489 }
490 
491 /** calls primal solution separation method of separator */
493  SCIP_SEPA* sepa, /**< separator */
494  SCIP_SET* set, /**< global SCIP settings */
495  SCIP_STAT* stat, /**< dynamic problem statistics */
496  SCIP_SEPASTORE* sepastore, /**< separation storage */
497  SCIP_SOL* sol, /**< primal solution that should be separated */
498  int depth, /**< depth of current node */
499  SCIP_Bool allowlocal, /**< should the separator allow local cuts */
500  SCIP_Bool execdelayed, /**< execute separator even if it is marked to be delayed */
501  SCIP_RESULT* result /**< pointer to store the result of the callback method */
502  )
503 {
504  assert(sepa != NULL);
505  assert(sepa->freq >= -1);
506  assert(set != NULL);
507  assert(set->scip != NULL);
508  assert(stat != NULL);
509  assert(depth >= 0);
510  assert(result != NULL);
511 
512  if( sepa->sepaexecsol != NULL &&
513  ( (depth == 0 && sepa->freq != -1) ||
514  (sepa->freq > 0 && depth % sepa->freq == 0 &&
515  (sepa->expbackoff == 1 || SCIPsetIsIntegral(set, LOG2(depth * (1.0 / sepa->freq) / LOG2((SCIP_Real)sepa->expbackoff))))) ||
516  sepa->solwasdelayed )
517  )
518  {
519  if( (!sepa->delay && !sepa->solwasdelayed) || execdelayed )
520  {
521  SCIP_Longint oldndomchgs;
522  SCIP_Longint oldnprobdomchgs;
523  int oldncuts;
524  int oldnactiveconss;
525  int ncutsfound;
526 
527  SCIPsetDebugMsg(set, "executing separator <%s> on solution %p\n", sepa->name, (void*)sol);
528 
529  oldndomchgs = stat->nboundchgs + stat->nholechgs;
530  oldnprobdomchgs = stat->nprobboundchgs + stat->nprobholechgs;
531  oldncuts = SCIPsepastoreGetNCuts(sepastore);
532  oldnactiveconss = stat->nactiveconss;
533 
534  /* reset the statistics for current node */
535  if( sepa->lastsepanode != stat->ntotalnodes )
536  {
537  sepa->ncallsatnode = 0;
538  sepa->ncutsfoundatnode = 0;
539  }
540 
541  /* start timing */
542  SCIPclockStart(sepa->sepaclock, set);
543 
544  /* call external separation method */
545  SCIP_CALL( sepa->sepaexecsol(set->scip, sepa, sol, result, allowlocal) );
546 
547  /* stop timing */
548  SCIPclockStop(sepa->sepaclock, set);
549 
550  /* update statistics */
551  if( *result != SCIP_DIDNOTRUN && *result != SCIP_DELAYED )
552  {
553  sepa->ncalls++;
554  sepa->ncallsatnode++;
555  sepa->lastsepanode = stat->ntotalnodes;
556  }
557  if( *result == SCIP_CUTOFF )
558  sepa->ncutoffs++;
559  ncutsfound = SCIPsepastoreGetNCuts(sepastore) - oldncuts;
560  sepa->ncutsfound += ncutsfound;
561  sepa->ncutsfoundatnode += ncutsfound;
562  sepa->nconssfound += MAX(stat->nactiveconss - oldnactiveconss, 0); /*lint !e776*/
563 
564  /* update domain reductions; therefore remove the domain
565  * reduction counts which were generated in probing mode */
566  sepa->ndomredsfound += stat->nboundchgs + stat->nholechgs - oldndomchgs;
567  sepa->ndomredsfound -= (stat->nprobboundchgs + stat->nprobholechgs - oldnprobdomchgs);
568 
569  /* evaluate result */
570  if( *result != SCIP_CUTOFF
571  && *result != SCIP_CONSADDED
572  && *result != SCIP_REDUCEDDOM
573  && *result != SCIP_SEPARATED
574  && *result != SCIP_NEWROUND
575  && *result != SCIP_DIDNOTFIND
576  && *result != SCIP_DIDNOTRUN
577  && *result != SCIP_DELAYED )
578  {
579  SCIPerrorMessage("execution method of separator <%s> returned invalid result <%d>\n",
580  sepa->name, *result);
581  return SCIP_INVALIDRESULT;
582  }
583  }
584  else
585  {
586  SCIPsetDebugMsg(set, "separator <%s> was delayed\n", sepa->name);
587  *result = SCIP_DELAYED;
588  }
589 
590  /* remember whether separator was delayed */
591  sepa->solwasdelayed = (*result == SCIP_DELAYED);
592  }
593  else
594  *result = SCIP_DIDNOTRUN;
595 
596  return SCIP_OKAY;
597 }
598 
599 /** gets user data of separator */
601  SCIP_SEPA* sepa /**< separator */
602  )
603 {
604  assert(sepa != NULL);
605 
606  return sepa->sepadata;
607 }
608 
609 /** sets user data of separator; user has to free old data in advance! */
611  SCIP_SEPA* sepa, /**< separator */
612  SCIP_SEPADATA* sepadata /**< new separator user data */
613  )
614 {
615  assert(sepa != NULL);
616 
617  sepa->sepadata = sepadata;
618 }
619 
620 /* new callback/method setter methods */
621 
622 /** sets copy method of separator */
624  SCIP_SEPA* sepa, /**< separator */
625  SCIP_DECL_SEPACOPY ((*sepacopy)) /**< copy method of separator or NULL if you don't want to copy your plugin into sub-SCIPs */
626  )
627 {
628  assert(sepa != NULL);
629 
630  sepa->sepacopy = sepacopy;
631 }
632 
633 /** sets destructor method of separator */
635  SCIP_SEPA* sepa, /**< separator */
636  SCIP_DECL_SEPAFREE ((*sepafree)) /**< destructor of separator */
637  )
638 {
639  assert(sepa != NULL);
640 
641  sepa->sepafree = sepafree;
642 }
643 
644 /** sets initialization method of separator */
646  SCIP_SEPA* sepa, /**< separator */
647  SCIP_DECL_SEPAINIT ((*sepainit)) /**< initialize separator */
648  )
649 {
650  assert(sepa != NULL);
651 
652  sepa->sepainit = sepainit;
653 }
654 
655 /** sets deinitialization method of separator */
657  SCIP_SEPA* sepa, /**< separator */
658  SCIP_DECL_SEPAEXIT ((*sepaexit)) /**< deinitialize separator */
659  )
660 {
661  assert(sepa != NULL);
662 
663  sepa->sepaexit = sepaexit;
664 }
665 
666 /** sets solving process initialization method of separator */
668  SCIP_SEPA* sepa, /**< separator */
669  SCIP_DECL_SEPAINITSOL ((*sepainitsol)) /**< solving process initialization method of separator */
670  )
671 {
672  assert(sepa != NULL);
673 
674  sepa->sepainitsol = sepainitsol;
675 }
676 
677 /** sets solving process deinitialization method of separator */
679  SCIP_SEPA* sepa, /**< separator */
680  SCIP_DECL_SEPAEXITSOL ((*sepaexitsol)) /**< solving process deinitialization method of separator */
681  )
682 {
683  assert(sepa != NULL);
684 
685  sepa->sepaexitsol = sepaexitsol;
686 }
687 
688 /** gets name of separator */
689 const char* SCIPsepaGetName(
690  SCIP_SEPA* sepa /**< separator */
691  )
692 {
693  assert(sepa != NULL);
694 
695  return sepa->name;
696 }
697 
698 /** gets description of separator */
699 const char* SCIPsepaGetDesc(
700  SCIP_SEPA* sepa /**< separator */
701  )
702 {
703  assert(sepa != NULL);
704 
705  return sepa->desc;
706 }
707 
708 /** gets priority of separator */
710  SCIP_SEPA* sepa /**< separator */
711  )
712 {
713  assert(sepa != NULL);
714 
715  return sepa->priority;
716 }
717 
718 /** sets priority of separator */
720  SCIP_SEPA* sepa, /**< separator */
721  SCIP_SET* set, /**< global SCIP settings */
722  int priority /**< new priority of the separator */
723  )
724 {
725  assert(sepa != NULL);
726  assert(set != NULL);
727 
728  sepa->priority = priority;
729  set->sepassorted = FALSE;
730 }
731 
732 /** gets frequency of separator */
734  SCIP_SEPA* sepa /**< separator */
735  )
736 {
737  assert(sepa != NULL);
738 
739  return sepa->freq;
740 }
741 
742 /** sets frequency of separator */
744  SCIP_SEPA* sepa, /**< separator */
745  int freq /**< new frequency of separator */
746  )
747 {
748  assert(sepa != NULL);
749 
750  sepa->freq = freq;
751 }
752 
753 /** get maximal bound distance at which the separator is called */
755  SCIP_SEPA* sepa /**< separator */
756  )
757 {
758  assert(sepa != NULL);
759 
760  return sepa->maxbounddist;
761 }
762 
763 /** does the separator use a secondary SCIP instance? */
765  SCIP_SEPA* sepa /**< separator */
766  )
767 {
768  assert(sepa != NULL);
769 
770  return sepa->usessubscip;
771 }
772 
773 /** enables or disables all clocks of \p sepa, depending on the value of the flag */
775  SCIP_SEPA* sepa, /**< the separator for which all clocks should be enabled or disabled */
776  SCIP_Bool enable /**< should the clocks of the separator be enabled? */
777  )
778 {
779  assert(sepa != NULL);
780 
781  SCIPclockEnableOrDisable(sepa->setuptime, enable);
782  SCIPclockEnableOrDisable(sepa->sepaclock, enable);
783 }
784 
785 /** gets time in seconds used in this separator for setting up for next stages */
787  SCIP_SEPA* sepa /**< separator */
788  )
789 {
790  assert(sepa != NULL);
791 
792  return SCIPclockGetTime(sepa->setuptime);
793 }
794 
795 /** gets time in seconds used in this separator */
797  SCIP_SEPA* sepa /**< separator */
798  )
799 {
800  assert(sepa != NULL);
801 
802  return SCIPclockGetTime(sepa->sepaclock);
803 }
804 
805 /** gets the total number of times, the separator was called */
807  SCIP_SEPA* sepa /**< separator */
808  )
809 {
810  assert(sepa != NULL);
811 
812  return sepa->ncalls;
813 }
814 
815 /** gets the number of times, the separator was called at the current node */
817  SCIP_SEPA* sepa /**< separator */
818  )
819 {
820  assert(sepa != NULL);
821 
822  return sepa->ncallsatnode;
823 }
824 
825 /** gets total number of times, the separator detected a cutoff */
827  SCIP_SEPA* sepa /**< separator */
828  )
829 {
830  assert(sepa != NULL);
831 
832  return sepa->ncutoffs;
833 }
834 
835 /** gets the total number of cutting planes found by this separator */
837  SCIP_SEPA* sepa /**< separator */
838  )
839 {
840  assert(sepa != NULL);
841 
842  return sepa->ncutsfound;
843 }
844 
845 /** gets the total number of cutting planes applied to lp */
847  SCIP_SEPA* sepa /**< separator */
848  )
849 {
850  assert(sepa != NULL);
851 
852  return sepa->ncutsapplied;
853 }
854 
855 /** increase count of applied cuts */
857  SCIP_SEPA* sepa /**< separator */
858  )
859 {
860  assert( sepa != NULL );
861 
862  ++sepa->ncutsapplied;
863 }
864 
865 /** increase count of found cuts */
867  SCIP_SEPA* sepa /**< separator */
868  )
869 {
870  assert( sepa != NULL );
871 
872  ++sepa->ncutsfound;
873 }
874 
875 /** increase count of found cuts at current node */
877  SCIP_SEPA* sepa /**< separator */
878  )
879 {
880  assert( sepa != NULL );
881 
882  ++sepa->ncutsfoundatnode;
883 }
884 
885 /** gets the number of cutting planes found by this separator at the current node */
887  SCIP_SEPA* sepa /**< separator */
888  )
889 {
890  assert(sepa != NULL);
891 
892  return sepa->ncutsfoundatnode;
893 }
894 
895 /** gets total number of additional constraints added by this separator */
897  SCIP_SEPA* sepa /**< separator */
898  )
899 {
900  assert(sepa != NULL);
901 
902  return sepa->nconssfound;
903 }
904 
905 /** gets total number of domain reductions found by this separator */
907  SCIP_SEPA* sepa /**< separator */
908  )
909 {
910  assert(sepa != NULL);
911 
912  return sepa->ndomredsfound;
913 }
914 
915 /** should separator be delayed, if other separators found cuts? */
917  SCIP_SEPA* sepa /**< separator */
918  )
919 {
920  assert(sepa != NULL);
921 
922  return sepa->delay;
923 }
924 
925 /** was separation of the LP solution delayed at the last call? */
927  SCIP_SEPA* sepa /**< separator */
928  )
929 {
930  assert(sepa != NULL);
931 
932  return sepa->lpwasdelayed;
933 }
934 
935 /** was separation of the primal solution delayed at the last call? */
937  SCIP_SEPA* sepa /**< separator */
938  )
939 {
940  assert(sepa != NULL);
941 
942  return sepa->solwasdelayed;
943 }
944 
945 /** is separator initialized? */
947  SCIP_SEPA* sepa /**< separator */
948  )
949 {
950  assert(sepa != NULL);
951 
952  return sepa->initialized;
953 }
enum SCIP_Result SCIP_RESULT
Definition: type_result.h:52
SCIP_Bool solwasdelayed
Definition: struct_sepa.h:69
void SCIPsepaSetFree(SCIP_SEPA *sepa, SCIP_DECL_SEPAFREE((*sepafree)))
Definition: sepa.c:634
internal methods for separators
SCIP_Bool usessubscip
Definition: struct_sepa.h:66
#define NULL
Definition: def.h:246
SCIP_SEPADATA * sepadata
Definition: struct_sepa.h:58
SCIP_Bool SCIPsetIsLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:6011
void SCIPsepaEnableOrDisableClocks(SCIP_SEPA *sepa, SCIP_Bool enable)
Definition: sepa.c:774
SCIP_CLOCK * setuptime
Definition: struct_sepa.h:59
#define BMSfreeMemoryArrayNull(ptr)
Definition: memory.h:137
SCIP_RETCODE SCIPsepaCopyInclude(SCIP_SEPA *sepa, SCIP_SET *set)
Definition: sepa.c:69
SCIP_PARAMDATA * SCIPparamGetData(SCIP_PARAM *param)
Definition: paramset.c:661
SCIP_CLOCK * sepaclock
Definition: struct_sepa.h:60
void SCIPsepaIncNAppliedCuts(SCIP_SEPA *sepa)
Definition: sepa.c:856
#define SCIP_MAXSTRLEN
Definition: def.h:267
internal methods for clocks and timing issues
SCIP_Longint ntotalnodes
Definition: struct_stat.h:78
char * name
Definition: struct_sepa.h:48
struct SCIP_ParamData SCIP_PARAMDATA
Definition: type_paramset.h:76
#define SCIP_CALL_FINALLY(x, y)
Definition: def.h:400
SCIP_Bool SCIPsepaUsesSubscip(SCIP_SEPA *sepa)
Definition: sepa.c:764
SCIP_Longint SCIPsepaGetNDomredsFound(SCIP_SEPA *sepa)
Definition: sepa.c:906
SCIP_RETCODE SCIPsepaExecSol(SCIP_SEPA *sepa, SCIP_SET *set, SCIP_STAT *stat, SCIP_SEPASTORE *sepastore, SCIP_SOL *sol, int depth, SCIP_Bool allowlocal, SCIP_Bool execdelayed, SCIP_RESULT *result)
Definition: sepa.c:492
SCIP_Real SCIPsepaGetSetupTime(SCIP_SEPA *sepa)
Definition: sepa.c:786
SCIP_Longint nholechgs
Definition: struct_stat.h:107
void SCIPclockStop(SCIP_CLOCK *clck, SCIP_SET *set)
Definition: clock.c:350
#define FALSE
Definition: def.h:72
void SCIPclockStart(SCIP_CLOCK *clck, SCIP_SET *set)
Definition: clock.c:280
int SCIPsnprintf(char *t, int len, const char *s,...)
Definition: misc.c:10253
SCIP_Real maxbounddist
Definition: struct_sepa.h:46
#define TRUE
Definition: def.h:71
const char * SCIPsepaGetName(SCIP_SEPA *sepa)
Definition: sepa.c:689
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:53
SCIP_Bool initialized
Definition: struct_sepa.h:70
SCIP_Real SCIPsepaGetTime(SCIP_SEPA *sepa)
Definition: sepa.c:796
SCIP_Longint ncutsfound
Definition: struct_sepa.h:42
void SCIPsepaSetExit(SCIP_SEPA *sepa, SCIP_DECL_SEPAEXIT((*sepaexit)))
Definition: sepa.c:656
SCIP_Longint SCIPsepaGetNCutsFound(SCIP_SEPA *sepa)
Definition: sepa.c:836
void SCIPsepaIncNCutsFoundAtNode(SCIP_SEPA *sepa)
Definition: sepa.c:876
SCIP_RETCODE SCIPsetSepaPriority(SCIP *scip, SCIP_SEPA *sepa, int priority)
Definition: scip_sepa.c:353
int ncallsatnode
Definition: struct_sepa.h:63
SCIP_RETCODE SCIPsepaFree(SCIP_SEPA **sepa, SCIP_SET *set)
Definition: sepa.c:226
#define SCIP_DECL_SEPAEXECLP(x)
Definition: type_sepa.h:116
internal methods for handling parameter settings
void SCIPclockEnableOrDisable(SCIP_CLOCK *clck, SCIP_Bool enable)
Definition: clock.c:250
#define BMSfreeMemory(ptr)
Definition: memory.h:134
SCIP_DECL_SORTPTRCOMP(SCIPsepaComp)
Definition: sepa.c:42
SCIP_SEPADATA * SCIPsepaGetData(SCIP_SEPA *sepa)
Definition: sepa.c:600
SCIP_RETCODE SCIPsepaInit(SCIP_SEPA *sepa, SCIP_SET *set)
Definition: sepa.c:253
#define SCIP_DECL_SEPACOPY(x)
Definition: type_sepa.h:47
int SCIPsepaGetFreq(SCIP_SEPA *sepa)
Definition: sepa.c:733
SCIP_RETCODE SCIPsepaInitsol(SCIP_SEPA *sepa, SCIP_SET *set)
Definition: sepa.c:331
SCIP_RETCODE SCIPsepaExecLP(SCIP_SEPA *sepa, SCIP_SET *set, SCIP_STAT *stat, SCIP_SEPASTORE *sepastore, int depth, SCIP_Real bounddist, SCIP_Bool allowlocal, SCIP_Bool execdelayed, SCIP_RESULT *result)
Definition: sepa.c:382
SCIP_Longint nconssfound
Definition: struct_sepa.h:44
#define SCIPerrorMessage
Definition: pub_message.h:45
SCIP_Longint lastsepanode
Definition: struct_sepa.h:39
SCIP_Bool lpwasdelayed
Definition: struct_sepa.h:68
SCIP_Longint ncalls
Definition: struct_sepa.h:40
void SCIPclockReset(SCIP_CLOCK *clck)
Definition: clock.c:199
static SCIP_DECL_PARAMCHGD(paramChgdSepaPriority)
Definition: sepa.c:55
SCIP_Longint SCIPsepaGetNCutoffs(SCIP_SEPA *sepa)
Definition: sepa.c:826
int SCIPsepaGetNCallsAtNode(SCIP_SEPA *sepa)
Definition: sepa.c:816
int SCIPsepastoreGetNCuts(SCIP_SEPASTORE *sepastore)
Definition: sepastore.c:1085
SCIP_Real SCIPclockGetTime(SCIP_CLOCK *clck)
Definition: clock.c:428
void SCIPsepaSetData(SCIP_SEPA *sepa, SCIP_SEPADATA *sepadata)
Definition: sepa.c:610
int ncutsfoundatnode
Definition: struct_sepa.h:64
void SCIPsepaSetFreq(SCIP_SEPA *sepa, int freq)
Definition: sepa.c:743
void SCIPsepaSetExitsol(SCIP_SEPA *sepa, SCIP_DECL_SEPAEXITSOL((*sepaexitsol)))
Definition: sepa.c:678
internal methods for global SCIP settings
#define SCIP_CALL(x)
Definition: def.h:358
#define LOG2(x)
Definition: def.h:206
SCIP_Real SCIPsepaGetMaxbounddist(SCIP_SEPA *sepa)
Definition: sepa.c:754
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:2879
internal methods for storing separated cuts
const char * SCIPsepaGetDesc(SCIP_SEPA *sepa)
Definition: sepa.c:699
#define BMSduplicateMemoryArray(ptr, source, num)
Definition: memory.h:132
SCIP_Longint nprobboundchgs
Definition: struct_stat.h:108
SCIP_RETCODE SCIPclockCreate(SCIP_CLOCK **clck, SCIP_CLOCKTYPE clocktype)
Definition: clock.c:160
void SCIPsepaSetCopy(SCIP_SEPA *sepa, SCIP_DECL_SEPACOPY((*sepacopy)))
Definition: sepa.c:623
SCIP_Longint SCIPsepaGetNCalls(SCIP_SEPA *sepa)
Definition: sepa.c:806
SCIP_Bool SCIPsepaWasLPDelayed(SCIP_SEPA *sepa)
Definition: sepa.c:926
SCIP_Bool SCIPsetIsIntegral(SCIP_SET *set, SCIP_Real val)
Definition: set.c:6098
public data structures and miscellaneous methods
void SCIPsepaSetInitsol(SCIP_SEPA *sepa, SCIP_DECL_SEPAINITSOL((*sepainitsol)))
Definition: sepa.c:667
#define SCIP_Bool
Definition: def.h:69
#define SCIP_DECL_SEPAINIT(x)
Definition: type_sepa.h:63
SCIP_Longint SCIPsepaGetNConssFound(SCIP_SEPA *sepa)
Definition: sepa.c:896
void SCIPclockFree(SCIP_CLOCK **clck)
Definition: clock.c:175
#define SCIPsetDebugMsg
Definition: set.h:1940
SCIP_Longint ncutoffs
Definition: struct_sepa.h:41
#define SCIP_DECL_SEPAEXITSOL(x)
Definition: type_sepa.h:93
#define SCIP_DECL_SEPAEXECSOL(x)
Definition: type_sepa.h:140
#define BMSclearMemory(ptr)
Definition: memory.h:118
SCIP_Bool delay
Definition: struct_sepa.h:67
#define SCIP_MAXTREEDEPTH
Definition: def.h:294
int SCIPparamGetInt(SCIP_PARAM *param)
Definition: paramset.c:716
void SCIPsepaSetPriority(SCIP_SEPA *sepa, SCIP_SET *set, int priority)
Definition: sepa.c:719
#define MAX(x, y)
Definition: def.h:215
SCIP_Bool SCIPsepaWasSolDelayed(SCIP_SEPA *sepa)
Definition: sepa.c:936
int nactiveconss
Definition: struct_stat.h:222
SCIP_RETCODE SCIPsepaExit(SCIP_SEPA *sepa, SCIP_SET *set)
Definition: sepa.c:301
#define SCIP_DECL_SEPAEXIT(x)
Definition: type_sepa.h:71
#define SCIP_DECL_SEPAINITSOL(x)
Definition: type_sepa.h:82
public methods for message output
SCIP_Longint ncutsapplied
Definition: struct_sepa.h:43
SCIP_Longint ndomredsfound
Definition: struct_sepa.h:45
SCIP_Longint nboundchgs
Definition: struct_stat.h:106
SCIP_Bool SCIPsepaIsDelayed(SCIP_SEPA *sepa)
Definition: sepa.c:916
#define SCIP_Real
Definition: def.h:157
internal methods for problem statistics
datastructures for separators
SCIP_Longint SCIPsepaGetNCutsApplied(SCIP_SEPA *sepa)
Definition: sepa.c:846
static SCIP_RETCODE doSepaCreate(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:88
#define BMSallocMemory(ptr)
Definition: memory.h:108
void SCIPsepaIncNCutsFound(SCIP_SEPA *sepa)
Definition: sepa.c:866
#define SCIP_Longint
Definition: def.h:142
int priority
Definition: struct_sepa.h:61
void SCIPsepaSetInit(SCIP_SEPA *sepa, SCIP_DECL_SEPAINIT((*sepainit)))
Definition: sepa.c:645
SCIP_Bool SCIPsepaIsInitialized(SCIP_SEPA *sepa)
Definition: sepa.c:946
common defines and data types used in all packages of SCIP
struct BMS_BlkMem BMS_BLKMEM
Definition: memory.h:426
SCIP_RETCODE SCIPsetAddRealParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, SCIP_Real *valueptr, SCIP_Bool isadvanced, SCIP_Real defaultvalue, SCIP_Real minvalue, SCIP_Real maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: set.c:2927
#define SCIP_ALLOC(x)
Definition: def.h:369
int expbackoff
Definition: struct_sepa.h:65
SCIP_RETCODE SCIPsepaExitsol(SCIP_SEPA *sepa, SCIP_SET *set)
Definition: sepa.c:358
SCIP_RETCODE SCIPsetAddBoolParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, SCIP_Bool *valueptr, SCIP_Bool isadvanced, SCIP_Bool defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: set.c:2857
SCIP_Longint nprobholechgs
Definition: struct_stat.h:109
SCIP_Longint SCIPsepaGetNCutsFoundAtNode(SCIP_SEPA *sepa)
Definition: sepa.c:886
#define SCIP_DECL_SEPAFREE(x)
Definition: type_sepa.h:55
int SCIPsepaGetPriority(SCIP_SEPA *sepa)
Definition: sepa.c:709
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
SCIP callable library.
char * desc
Definition: struct_sepa.h:49