Scippy

SCIP

Solving Constraint Integer Programs

scip_cut.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-2020 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 scipopt.org. */
13 /* */
14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15 
16 /**@file scip_cut.c
17  * @ingroup OTHER_CFILES
18  * @brief public methods for cuts and aggregation rows
19  * @author Tobias Achterberg
20  * @author Timo Berthold
21  * @author Gerald Gamrath
22  * @author Leona Gottwald
23  * @author Stefan Heinz
24  * @author Gregor Hendel
25  * @author Thorsten Koch
26  * @author Alexander Martin
27  * @author Marc Pfetsch
28  * @author Michael Winkler
29  * @author Kati Wolter
30  *
31  * @todo check all SCIP_STAGE_* switches, and include the new stages TRANSFORMED and INITSOLVE
32  */
33 
34 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
35 
36 #include "scip/cutpool.h"
37 #include "scip/debug.h"
38 #include "scip/lp.h"
39 #include "scip/prob.h"
40 #include "scip/pub_cutpool.h"
41 #include "scip/pub_lp.h"
42 #include "scip/pub_message.h"
43 #include "scip/scip_conflict.h"
44 #include "scip/scip_cut.h"
45 #include "scip/scip_numerics.h"
46 #include "scip/scip_tree.h"
47 #include "scip/sepastore.h"
48 #include "scip/set.h"
49 #include "scip/solve.h"
50 #include "scip/struct_lp.h"
51 #include "scip/struct_mem.h"
52 #include "scip/struct_scip.h"
53 #include "scip/struct_set.h"
54 #include "scip/tree.h"
55 
56 /** returns efficacy of the cut with respect to the given primal solution or the current LP solution:
57  * e = -feasibility/norm
58  *
59  * @return the efficacy of the cut with respect to the given primal solution or the current LP solution:
60  * e = -feasibility/norm
61  *
62  * @pre This method can be called if @p scip is in one of the following stages:
63  * - \ref SCIP_STAGE_SOLVING
64  */
66  SCIP* scip, /**< SCIP data structure */
67  SCIP_SOL* sol, /**< primal CIP solution, or NULL for current LP solution */
68  SCIP_ROW* cut /**< separated cut */
69  )
70 {
71  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetCutEfficacy", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
72 
73  if( sol == NULL )
74  return SCIProwGetLPEfficacy(cut, scip->set, scip->stat, scip->lp);
75  else
76  return SCIProwGetSolEfficacy(cut, scip->set, scip->stat, sol);
77 }
78 
79 /** returns whether the cut's efficacy with respect to the given primal solution or the current LP solution is greater
80  * than the minimal cut efficacy
81  *
82  * @return TRUE if the cut's efficacy with respect to the given primal solution or the current LP solution is greater
83  * than the minimal cut efficacy, otherwise FALSE
84  *
85  * @pre This method can be called if @p scip is in one of the following stages:
86  * - \ref SCIP_STAGE_SOLVING
87  */
89  SCIP* scip, /**< SCIP data structure */
90  SCIP_SOL* sol, /**< primal CIP solution, or NULL for current LP solution */
91  SCIP_ROW* cut /**< separated cut */
92  )
93 {
94  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPisCutEfficacious", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
95 
96  if( sol == NULL )
97  return SCIProwIsLPEfficacious(cut, scip->set, scip->stat, scip->lp, (SCIPtreeGetCurrentDepth(scip->tree) == 0));
98  else
99  return SCIProwIsSolEfficacious(cut, scip->set, scip->stat, sol, (SCIPtreeGetCurrentDepth(scip->tree) == 0));
100 }
101 
102 /** checks, if the given cut's efficacy is larger than the minimal cut efficacy
103  *
104  * @return TRUE if the given cut's efficacy is larger than the minimal cut efficacy, otherwise FALSE
105  */
107  SCIP* scip, /**< SCIP data structure */
108  SCIP_Real efficacy /**< efficacy of the cut */
109  )
110 {
111  assert(scip != NULL);
112 
113  return SCIPsetIsEfficacious(scip->set, (SCIPtreeGetCurrentDepth(scip->tree) == 0), efficacy);
114 }
115 
116 /** calculates the efficacy norm of the given vector, which depends on the "separating/efficacynorm" parameter
117  *
118  * @return the efficacy norm of the given vector, which depends on the "separating/efficacynorm" parameter
119  */
121  SCIP* scip, /**< SCIP data structure */
122  SCIP_Real* vals, /**< array of values */
123  int nvals /**< number of values */
124  )
125 {
126  SCIP_Real norm;
127  int i;
128 
129  assert(scip != NULL);
130  assert(scip->set != NULL);
131 
132  norm = 0.0;
133  switch( scip->set->sepa_efficacynorm )
134  {
135  case 'e':
136  for( i = 0; i < nvals; ++i )
137  norm += SQR(vals[i]);
138  norm = SQRT(norm);
139  break;
140  case 'm':
141  for( i = 0; i < nvals; ++i )
142  {
143  SCIP_Real absval;
144 
145  absval = REALABS(vals[i]);
146  norm = MAX(norm, absval);
147  }
148  break;
149  case 's':
150  for( i = 0; i < nvals; ++i )
151  norm += REALABS(vals[i]);
152  break;
153  case 'd':
154  for( i = 0; i < nvals; ++i )
155  {
156  if( !SCIPisZero(scip, vals[i]) )
157  {
158  norm = 1.0;
159  break;
160  }
161  }
162  break;
163  default:
164  SCIPerrorMessage("invalid efficacy norm parameter '%c'\n", scip->set->sepa_efficacynorm);
165  assert(FALSE); /*lint !e506*/
166  }
167 
168  return norm;
169 }
170 
171 /** indicates whether a cut is applicable, i.e., will modify the LP when applied
172  *
173  * @pre This method can be called if @p scip is in one of the following stages:
174  * - \ref SCIP_STAGE_SOLVING
175  *
176  * @return whether the cut is modifiable, not a bound change, or a bound change that changes bounds by at least epsilon
177  */
179  SCIP* scip, /**< SCIP data structure */
180  SCIP_ROW* cut /**< separated cut */
181  )
182 {
183  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPisCutApplicable", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
184 
185  return SCIPsepastoreIsCutApplicable(scip->set, cut);
186 }
187 
188 /** adds cut to separation storage
189  *
190  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
191  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
192  *
193  * @pre This method can be called if @p scip is in one of the following stages:
194  * - \ref SCIP_STAGE_SOLVING
195  *
196  * @deprecated Please use SCIPaddRow() instead, or, if the row is a global cut, add it only to the global cutpool.
197  */
199  SCIP* scip, /**< SCIP data structure */
200  SCIP_SOL* sol, /**< primal solution that was separated, or NULL for LP solution */
201  SCIP_ROW* cut, /**< separated cut */
202  SCIP_Bool forcecut, /**< should the cut be forced to enter the LP? */
203  SCIP_Bool* infeasible /**< pointer to store whether cut has been detected to be infeasible for local bounds */
204  )
205 {
207 
208  SCIP_UNUSED(sol);
209 
210  return SCIPaddRow(scip, cut, forcecut, infeasible);
211 }
212 
213 /** adds row to separation storage
214  *
215  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
216  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
217  *
218  * @pre This method can be called if @p scip is in one of the following stages:
219  * - \ref SCIP_STAGE_SOLVING
220  */
222  SCIP* scip, /**< SCIP data structure */
223  SCIP_ROW* row, /**< row */
224  SCIP_Bool forcecut, /**< should the row be forced to enter the LP? */
225  SCIP_Bool* infeasible /**< pointer to store whether row has been detected to be infeasible for local bounds */
226  )
227 {
229 
230  assert(SCIPtreeGetCurrentNode(scip->tree) != NULL);
231 
232  SCIP_CALL( SCIPsepastoreAddCut(scip->sepastore, scip->mem->probmem, scip->set, scip->stat, scip->eventqueue,
233  scip->eventfilter, scip->lp, row, forcecut, (SCIPtreeGetCurrentDepth(scip->tree) == 0), infeasible) );
234 
235  /* possibly run conflict analysis */
236  if ( *infeasible && SCIPprobAllColsInLP(scip->transprob, scip->set, scip->lp) && SCIPisConflictAnalysisApplicable(scip) )
237  {
238  SCIP_Real act;
239  SCIP_VAR* var;
240  SCIP_Real val;
241  int ncols;
242  int j;
243 
244  /* initialize conflict analysis */
246 
247  if ( ! SCIPisInfinity(scip, -row->lhs) )
248  {
249  act = SCIProwGetMaxActivity(row, scip->set, scip->stat);
250  if ( SCIPisLT(scip, act, row->lhs) )
251  {
252  ncols = SCIProwGetNNonz(row);
253  for (j = 0; j < ncols; ++j)
254  {
255  val = row->vals[j];
256  if ( ! SCIPisZero(scip, val) )
257  {
258  var = SCIPcolGetVar(row->cols[j]);
259  assert( var != NULL );
260 
261  if ( val > 0.0 )
262  {
263  SCIP_CALL( SCIPaddConflictUb(scip, var, NULL) );
264  }
265  else
266  {
267  SCIP_CALL( SCIPaddConflictLb(scip, var, NULL) );
268  }
269  }
270  }
271  }
272  }
273  else if ( ! SCIPisInfinity(scip, row->rhs) )
274  {
275  act = SCIProwGetMinActivity(row, scip->set, scip->stat);
276  if ( SCIPisGT(scip, act, row->rhs) )
277  {
278  ncols = SCIProwGetNNonz(row);
279  for (j = 0; j < ncols; ++j)
280  {
281  val = row->vals[j];
282  if ( ! SCIPisZero(scip, val) )
283  {
284  var = SCIPcolGetVar(row->cols[j]);
285  assert( var != NULL );
286 
287  if ( val > 0.0 )
288  {
289  SCIP_CALL( SCIPaddConflictLb(scip, var, NULL) );
290  }
291  else
292  {
293  SCIP_CALL( SCIPaddConflictUb(scip, var, NULL) );
294  }
295  }
296  }
297  }
298  }
299 
300  /* analyze the conflict */
302  }
303 
304  return SCIP_OKAY;
305 }
306 
307 /** checks if cut is already existing in global cutpool
308  *
309  * @return TRUE is returned if the cut is not already existing in the global cutpool, FALSE otherwise
310  *
311  * @pre This method can be called if @p scip is in one of the following stages:
312  * - \ref SCIP_STAGE_SOLVING
313  */
315  SCIP* scip, /**< SCIP data structure */
316  SCIP_ROW* row /**< cutting plane to add */
317  )
318 {
320 
321  return SCIPcutpoolIsCutNew(scip->cutpool, scip->set, row);
322 }
323 
324 /** if not already existing, adds row to global cut pool
325  *
326  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
327  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
328  *
329  * @pre This method can be called if @p scip is in one of the following stages:
330  * - \ref SCIP_STAGE_SOLVING
331  */
333  SCIP* scip, /**< SCIP data structure */
334  SCIP_ROW* row /**< row to remove */
335  )
336 {
337  SCIP_CALL( SCIPcheckStage(scip, "SCIPaddPoolCut", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
338 
339  SCIP_CALL( SCIPcutpoolAddRow(scip->cutpool, scip->mem->probmem, scip->set, scip->stat, scip->lp, row) );
340 
341  return SCIP_OKAY;
342 }
343 
344 /** removes the row from the global cut pool
345  *
346  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
347  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
348  *
349  * @pre This method can be called if @p scip is in one of the following stages:
350  * - \ref SCIP_STAGE_SOLVING
351  */
353  SCIP* scip, /**< SCIP data structure */
354  SCIP_ROW* row /**< cutting plane to add */
355  )
356 {
357  SCIP_CALL( SCIPcheckStage(scip, "SCIPdelPoolCut", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
358 
359  SCIP_CALL( SCIPcutpoolDelRow(scip->cutpool, scip->mem->probmem, scip->set, scip->stat, scip->lp, row) );
360 
361  return SCIP_OKAY;
362 }
363 
364 /** gets current cuts in the global cut pool
365  *
366  * @return the current cuts in the global cut pool
367  *
368  * @pre This method can be called if @p scip is in one of the following stages:
369  * - \ref SCIP_STAGE_SOLVING
370  * - \ref SCIP_STAGE_SOLVED
371  * - \ref SCIP_STAGE_EXITSOLVE
372  */
374  SCIP* scip /**< SCIP data structure */
375  )
376 {
377  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetPoolCuts", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, FALSE, FALSE) );
378 
379  return SCIPcutpoolGetCuts(scip->cutpool);
380 }
381 
382 /** gets current number of rows in the global cut pool
383  *
384  * @return the current number of rows in the global cut pool
385  *
386  * @pre This method can be called if @p scip is in one of the following stages:
387  * - \ref SCIP_STAGE_SOLVING
388  * - \ref SCIP_STAGE_SOLVED
389  * - \ref SCIP_STAGE_EXITSOLVE
390  */
392  SCIP* scip /**< SCIP data structure */
393  )
394 {
395  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNPoolCuts", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, FALSE, FALSE) );
396 
397  return SCIPcutpoolGetNCuts(scip->cutpool);
398 }
399 
400 /** gets the global cut pool used by SCIP
401  *
402  * @return the global cut pool used by SCIP
403  *
404  * @pre This method can be called if @p scip is in one of the following stages:
405  * - \ref SCIP_STAGE_SOLVING
406  * - \ref SCIP_STAGE_SOLVED
407  * - \ref SCIP_STAGE_EXITSOLVE
408  */
410  SCIP* scip /**< SCIP data structure */
411  )
412 {
413  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetGlobalCutpool", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, FALSE, FALSE) );
414 
415  return scip->cutpool;
416 }
417 
418 /** creates a cut pool
419  *
420  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
421  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
422  *
423  * @pre This method can be called if @p scip is in one of the following stages:
424  * - \ref SCIP_STAGE_TRANSFORMING
425  * - \ref SCIP_STAGE_TRANSFORMED
426  * - \ref SCIP_STAGE_INITPRESOLVE
427  * - \ref SCIP_STAGE_PRESOLVING
428  * - \ref SCIP_STAGE_EXITPRESOLVE
429  * - \ref SCIP_STAGE_PRESOLVED
430  * - \ref SCIP_STAGE_INITSOLVE
431  * - \ref SCIP_STAGE_SOLVING
432  */
434  SCIP* scip, /**< SCIP data structure */
435  SCIP_CUTPOOL** cutpool, /**< pointer to store cut pool */
436  int agelimit /**< maximum age a cut can reach before it is deleted from the pool */
437  )
438 {
439  SCIP_CALL( SCIPcheckStage(scip, "SCIPcreateCutpool", FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE) );
440 
441  SCIP_CALL( SCIPcutpoolCreate(cutpool, scip->mem->probmem, scip->set, agelimit, FALSE) );
442 
443  return SCIP_OKAY;
444 }
445 
446 /** frees a cut pool
447  *
448  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
449  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
450  *
451  * @pre This method can be called if @p scip is in one of the following stages:
452  * - \ref SCIP_STAGE_TRANSFORMING
453  * - \ref SCIP_STAGE_TRANSFORMED
454  * - \ref SCIP_STAGE_INITPRESOLVE
455  * - \ref SCIP_STAGE_PRESOLVING
456  * - \ref SCIP_STAGE_EXITPRESOLVE
457  * - \ref SCIP_STAGE_PRESOLVED
458  * - \ref SCIP_STAGE_INITSOLVE
459  * - \ref SCIP_STAGE_SOLVING
460  * - \ref SCIP_STAGE_SOLVED
461  * - \ref SCIP_STAGE_EXITSOLVE
462  * - \ref SCIP_STAGE_FREETRANS
463  */
465  SCIP* scip, /**< SCIP data structure */
466  SCIP_CUTPOOL** cutpool /**< pointer to store cut pool */
467  )
468 {
469  SCIP_CALL( SCIPcheckStage(scip, "SCIPfreeCutpool", FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
470 
471  SCIP_CALL( SCIPcutpoolFree(cutpool, scip->mem->probmem, scip->set, scip->lp) );
472 
473  return SCIP_OKAY;
474 }
475 
476 /** if not already existing, adds row to a cut pool and captures it
477  *
478  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
479  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
480  *
481  * @pre This method can be called if @p scip is in one of the following stages:
482  * - \ref SCIP_STAGE_INITSOLVE
483  * - \ref SCIP_STAGE_SOLVING
484  */
486  SCIP* scip, /**< SCIP data structure */
487  SCIP_CUTPOOL* cutpool, /**< cut pool */
488  SCIP_ROW* row /**< cutting plane to add */
489  )
490 {
491  SCIP_CALL( SCIPcheckStage(scip, "SCIPaddRowCutpool", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE) );
492 
493  SCIP_CALL( SCIPcutpoolAddRow(cutpool, scip->mem->probmem, scip->set, scip->stat, scip->lp, row) );
494 
495  return SCIP_OKAY;
496 }
497 
498 /** adds row to a cut pool and captures it; doesn't check for multiple cuts
499  *
500  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
501  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
502  *
503  * @pre This method can be called if @p scip is in one of the following stages:
504  * - \ref SCIP_STAGE_INITSOLVE
505  * - \ref SCIP_STAGE_SOLVING
506  */
508  SCIP* scip, /**< SCIP data structure */
509  SCIP_CUTPOOL* cutpool, /**< cut pool */
510  SCIP_ROW* row /**< cutting plane to add */
511  )
512 {
513  SCIP_CALL( SCIPcheckStage(scip, "SCIPaddNewRowCutpool", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE) );
514 
515  SCIP_CALL( SCIPcutpoolAddNewRow(cutpool, scip->mem->probmem, scip->set, scip->stat, scip->lp, row) );
516 
517  return SCIP_OKAY;
518 }
519 
520 /** removes the LP row from a cut pool
521  *
522  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
523  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
524  *
525  * @pre This method can be called if @p scip is in one of the following stages:
526  * - \ref SCIP_STAGE_INITSOLVE
527  * - \ref SCIP_STAGE_SOLVING
528  * - \ref SCIP_STAGE_SOLVED
529  */
531  SCIP* scip, /**< SCIP data structure */
532  SCIP_CUTPOOL* cutpool, /**< cut pool */
533  SCIP_ROW* row /**< row to remove */
534  )
535 {
536  SCIP_CALL( SCIPcheckStage(scip, "SCIPdelRowCutpool", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
537 
538  SCIP_CALL( SCIPcutpoolDelRow(cutpool, scip->mem->probmem, scip->set, scip->stat, scip->lp, row) );
539 
540  return SCIP_OKAY;
541 }
542 
543 /** separates cuts from a cut pool
544  *
545  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
546  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
547  *
548  * @pre This method can be called if @p scip is in one of the following stages:
549  * - \ref SCIP_STAGE_SOLVING
550  */
552  SCIP* scip, /**< SCIP data structure */
553  SCIP_CUTPOOL* cutpool, /**< cut pool */
554  SCIP_RESULT* result /**< pointer to store the result of the separation call */
555  )
556 {
557  SCIP_CALL( SCIPcheckStage(scip, "SCIPseparateCutpool", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
558 
559  assert(SCIPtreeGetCurrentNode(scip->tree) != NULL);
560 
561  if( !SCIPtreeHasCurrentNodeLP(scip->tree) )
562  {
563  SCIPerrorMessage("cannot add cuts, because node LP is not processed\n");
564  return SCIP_INVALIDCALL;
565  }
566 
567  SCIP_CALL( SCIPcutpoolSeparate(cutpool, scip->mem->probmem, scip->set, scip->stat, scip->eventqueue, scip->eventfilter,
568  scip->lp, scip->sepastore, NULL, FALSE, (SCIPtreeGetCurrentDepth(scip->tree) == 0), result) );
569 
570  return SCIP_OKAY;
571 }
572 
573 /** separates cuts w.r.t. given solution from a cut pool
574  *
575  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
576  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
577  *
578  * @pre This method can be called if @p scip is in one of the following stages:
579  * - \ref SCIP_STAGE_SOLVING
580  */
582  SCIP* scip, /**< SCIP data structure */
583  SCIP_CUTPOOL* cutpool, /**< cut pool */
584  SCIP_SOL* sol, /**< solution to be separated */
585  SCIP_RESULT* result /**< pointer to store the result of the separation call */
586  )
587 {
588  SCIP_CALL( SCIPcheckStage(scip, "SCIPseparateSolCutpool", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
589 
590  assert(SCIPtreeGetCurrentNode(scip->tree) != NULL);
591 
592  if( !SCIPtreeHasCurrentNodeLP(scip->tree) )
593  {
594  SCIPerrorMessage("cannot add cuts, because node LP is not processed\n");
595  return SCIP_INVALIDCALL;
596  }
597 
598  SCIP_CALL( SCIPcutpoolSeparate(cutpool, scip->mem->probmem, scip->set, scip->stat, scip->eventqueue, scip->eventfilter,
599  scip->lp, scip->sepastore, sol, FALSE, (SCIPtreeGetCurrentDepth(scip->tree) == 0), result) );
600 
601  return SCIP_OKAY;
602 }
603 
604 /** if not already existing, adds row to delayed global cut pool
605  *
606  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
607  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
608  *
609  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
610  */
612  SCIP* scip, /**< SCIP data structure */
613  SCIP_ROW* row /**< cutting plane to add */
614  )
615 {
616  SCIP_CALL( SCIPcheckStage(scip, "SCIPaddDelayedPoolCut", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
617 
618  SCIP_CALL( SCIPcutpoolAddRow(scip->delayedcutpool, scip->mem->probmem, scip->set, scip->stat, scip->lp, row) );
619 
620  return SCIP_OKAY;
621 }
622 
623 /** removes the row from the delayed global cut pool
624  *
625  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
626  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
627  *
628  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
629  */
631  SCIP* scip, /**< SCIP data structure */
632  SCIP_ROW* row /**< cutting plane to add */
633  )
634 {
635  SCIP_CALL( SCIPcheckStage(scip, "SCIPdelDelayedPoolCut", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
636 
637  SCIP_CALL( SCIPcutpoolDelRow(scip->delayedcutpool, scip->mem->probmem, scip->set, scip->stat, scip->lp, row) );
638 
639  return SCIP_OKAY;
640 }
641 
642 /** gets current cuts in the delayed global cut pool
643  *
644  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
645  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
646  *
647  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
648  */
650  SCIP* scip /**< SCIP data structure */
651  )
652 {
653  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetDelayedPoolCuts", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, FALSE, FALSE) );
654 
655  return SCIPcutpoolGetCuts(scip->delayedcutpool);
656 }
657 
658 /** gets current number of rows in the delayed global cut pool
659  *
660  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
661  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
662  *
663  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
664  */
666  SCIP* scip /**< SCIP data structure */
667  )
668 {
669  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNDelayedPoolCuts", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, FALSE, FALSE) );
670 
671  return SCIPcutpoolGetNCuts(scip->delayedcutpool);
672 }
673 
674 /** gets the delayed global cut pool used by SCIP
675  *
676  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
677  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
678  *
679  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
680  */
682  SCIP* scip /**< SCIP data structure */
683  )
684 {
685  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetDelayedGlobalCutpool", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, FALSE, FALSE) );
686 
687  return scip->delayedcutpool;
688 }
689 
690 /** separates the given primal solution or the current LP solution by calling the separators and constraint handlers'
691  * separation methods;
692  * the generated cuts are stored in the separation storage and can be accessed with the methods SCIPgetCuts() and
693  * SCIPgetNCuts();
694  * after evaluating the cuts, you have to call SCIPclearCuts() in order to remove the cuts from the
695  * separation storage;
696  * it is possible to call SCIPseparateSol() multiple times with different solutions and evaluate the found cuts
697  * afterwards
698  *
699  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
700  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
701  *
702  * @pre This method can be called if @p scip is in one of the following stages:
703  * - \ref SCIP_STAGE_SOLVING
704  */
706  SCIP* scip, /**< SCIP data structure */
707  SCIP_SOL* sol, /**< primal solution that should be separated, or NULL for LP solution */
708  SCIP_Bool pretendroot, /**< should the cut separators be called as if we are at the root node? */
709  SCIP_Bool allowlocal, /**< should the separator be asked to separate local cuts */
710  SCIP_Bool onlydelayed, /**< should only separators be called that were delayed in the previous round? */
711  SCIP_Bool* delayed, /**< pointer to store whether a separator was delayed */
712  SCIP_Bool* cutoff /**< pointer to store whether the node can be cut off */
713  )
714 {
715  int actdepth;
716 
717  SCIP_CALL( SCIPcheckStage(scip, "SCIPseparateSol", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
718 
719  /* get current depth */
720  actdepth = (pretendroot ? 0 : SCIPtreeGetCurrentDepth(scip->tree));
721 
722  /* apply separation round */
723  SCIP_CALL( SCIPseparationRound(scip->mem->probmem, scip->set, scip->messagehdlr, scip->stat, scip->eventqueue,
724  scip->eventfilter, scip->transprob, scip->primal, scip->tree, scip->lp, scip->sepastore,
725  sol, actdepth, allowlocal, onlydelayed, delayed, cutoff) );
726 
727  return SCIP_OKAY;
728 }
729 
730 /** gets the array of cuts currently stored in the separation storage
731  *
732  * @return the array of cuts currently stored in the separation storage
733  *
734  * @pre This method can be called if @p scip is in one of the following stages:
735  * - \ref SCIP_STAGE_PRESOLVED
736  * - \ref SCIP_STAGE_SOLVING
737  * - \ref SCIP_STAGE_SOLVED
738  */
740  SCIP* scip /**< SCIP data structure */
741  )
742 {
744 
745  return SCIPsepastoreGetCuts(scip->sepastore);
746 }
747 
748 /** get current number of cuts in the separation storage
749  *
750  * @return the current number of cuts in the separation storage
751  *
752  * @pre This method can be called if @p scip is in one of the following stages:
753  * - \ref SCIP_STAGE_PRESOLVED
754  * - \ref SCIP_STAGE_SOLVING
755  * - \ref SCIP_STAGE_SOLVED
756  */
758  SCIP* scip /**< SCIP data structure */
759  )
760 {
762 
763  return SCIPsepastoreGetNCuts(scip->sepastore);
764 }
765 
766 /** clears the separation storage
767  *
768  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
769  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
770  *
771  * @pre This method can be called if @p scip is in one of the following stages:
772  * - \ref SCIP_STAGE_SOLVING
773  */
775  SCIP* scip /**< SCIP data structure */
776  )
777 {
778  SCIP_CALL( SCIPcheckStage(scip, "SCIPclearCuts", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
779 
780  SCIP_CALL( SCIPsepastoreClearCuts(scip->sepastore, scip->mem->probmem, scip->set, scip->eventqueue, scip->eventfilter, scip->lp) );
781 
782  return SCIP_OKAY;
783 }
784 
785 /** removes cuts that are inefficacious w.r.t. the current LP solution from separation storage without adding the cuts to the LP
786  *
787  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
788  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
789  *
790  * @pre This method can be called if @p scip is in one of the following stages:
791  * - \ref SCIP_STAGE_SOLVING
792  */
794  SCIP* scip /**< SCIP data structure */
795  )
796 {
797  SCIP_Bool isroot = FALSE;
798 
799  SCIP_CALL( SCIPcheckStage(scip, "SCIPremoveInefficaciousCuts", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
800 
801  if( SCIPtreeGetCurrentDepth(scip->tree) == 0 )
802  isroot = TRUE;
803 
805  scip->eventqueue, scip->eventfilter, scip->lp, isroot, SCIP_EFFICIACYCHOICE_LP) );
806 
807  return SCIP_OKAY;
808 }
enum SCIP_Result SCIP_RESULT
Definition: type_result.h:52
SCIP_STAT * stat
Definition: struct_scip.h:70
SCIP_Bool SCIPisConflictAnalysisApplicable(SCIP *scip)
SCIP_RETCODE SCIPseparationRound(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_PROB *prob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_LP *lp, SCIP_SEPASTORE *sepastore, SCIP_SOL *sol, int actdepth, SCIP_Bool allowlocal, SCIP_Bool onlydelayed, SCIP_Bool *delayed, SCIP_Bool *cutoff)
Definition: solve.c:1949
SCIP_RETCODE SCIPseparateSol(SCIP *scip, SCIP_SOL *sol, SCIP_Bool pretendroot, SCIP_Bool allowlocal, SCIP_Bool onlydelayed, SCIP_Bool *delayed, SCIP_Bool *cutoff)
Definition: scip_cut.c:705
internal methods for branch and bound tree
public methods for conflict handler plugins and conflict analysis
SCIP_ROW ** SCIPsepastoreGetCuts(SCIP_SEPASTORE *sepastore)
Definition: sepastore.c:1081
int SCIProwGetNNonz(SCIP_ROW *row)
Definition: lp.c:17075
SCIP_EVENTQUEUE * eventqueue
Definition: struct_scip.h:80
SCIP_PRIMAL * primal
Definition: struct_scip.h:85
SCIP_CUTPOOL * delayedcutpool
Definition: struct_scip.h:97
SCIP_RETCODE SCIPinitConflictAnalysis(SCIP *scip, SCIP_CONFTYPE conftype, SCIP_Bool iscutoffinvolved)
#define FALSE
Definition: def.h:73
#define TRUE
Definition: def.h:72
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:54
SCIP_RETCODE SCIPaddNewRowCutpool(SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_ROW *row)
Definition: scip_cut.c:507
SCIP_Real SCIProwGetLPEfficacy(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp)
Definition: lp.c:6796
int SCIPtreeGetCurrentDepth(SCIP_TREE *tree)
Definition: tree.c:8389
SCIP_RETCODE SCIPaddConflictLb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx)
SCIP_RETCODE SCIPcutpoolAddNewRow(SCIP_CUTPOOL *cutpool, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_ROW *row)
Definition: cutpool.c:715
#define SCIP_UNUSED(x)
Definition: def.h:418
SCIP_RETCODE SCIPanalyzeConflict(SCIP *scip, int validdepth, SCIP_Bool *success)
int SCIPcutpoolGetNCuts(SCIP_CUTPOOL *cutpool)
Definition: cutpool.c:1052
SCIP_PROB * transprob
Definition: struct_scip.h:89
SCIP_RETCODE SCIPcutpoolFree(SCIP_CUTPOOL **cutpool, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_LP *lp)
Definition: cutpool.c:457
internal methods for LP management
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPgetCutEfficacy(SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut)
Definition: scip_cut.c:65
public methods for numerical tolerances
SCIP_RETCODE SCIPremoveInefficaciousCuts(SCIP *scip)
Definition: scip_cut.c:793
public methods for the branch-and-bound tree
SCIP_Bool SCIPsetIsEfficacious(SCIP_SET *set, SCIP_Bool root, SCIP_Real efficacy)
Definition: set.c:6849
SCIP_Real * vals
Definition: struct_lp.h:220
SCIP_Bool SCIPsepastoreIsCutApplicable(SCIP_SET *set, SCIP_ROW *cut)
Definition: sepastore.c:1072
SCIP_CUTPOOL * SCIPgetDelayedGlobalCutpool(SCIP *scip)
Definition: scip_cut.c:681
SCIP_MEM * mem
Definition: struct_scip.h:62
SCIP_CUTPOOL * SCIPgetGlobalCutpool(SCIP *scip)
Definition: scip_cut.c:409
SCIP_RETCODE SCIPcutpoolDelRow(SCIP_CUTPOOL *cutpool, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_ROW *row)
Definition: cutpool.c:784
SCIP_CUT ** SCIPgetPoolCuts(SCIP *scip)
Definition: scip_cut.c:373
internal methods for storing and manipulating the main problem
#define SCIPerrorMessage
Definition: pub_message.h:55
SCIP_EVENTFILTER * eventfilter
Definition: struct_scip.h:79
SCIP_COL ** cols
Definition: struct_lp.h:218
SCIP_RETCODE SCIPcreateCutpool(SCIP *scip, SCIP_CUTPOOL **cutpool, int agelimit)
Definition: scip_cut.c:433
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:2025
SCIP_Real lhs
Definition: struct_lp.h:195
int SCIPsepastoreGetNCuts(SCIP_SEPASTORE *sepastore)
Definition: sepastore.c:1091
SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)
SCIP_RETCODE SCIPsepastoreRemoveInefficaciousCuts(SCIP_SEPASTORE *sepastore, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_LP *lp, SCIP_Bool root, SCIP_EFFICIACYCHOICE efficiacychoice)
Definition: sepastore.c:1015
#define NULL
Definition: lpi_spx1.cpp:155
#define REALABS(x)
Definition: def.h:187
SCIP_RETCODE SCIPseparateCutpool(SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_RESULT *result)
Definition: scip_cut.c:551
SCIP_ROW ** SCIPgetCuts(SCIP *scip)
Definition: scip_cut.c:739
SCIP_CUT ** SCIPgetDelayedPoolCuts(SCIP *scip)
Definition: scip_cut.c:649
internal methods for global SCIP settings
#define SCIP_CALL(x)
Definition: def.h:364
SCIP main data structure.
SCIP_RETCODE SCIPaddCut(SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut, SCIP_Bool forcecut, SCIP_Bool *infeasible)
Definition: scip_cut.c:198
internal methods for storing separated cuts
SCIP_Bool SCIProwIsSolEfficacious(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_SOL *sol, SCIP_Bool root)
Definition: lp.c:6896
SCIP_CUTPOOL * cutpool
Definition: struct_scip.h:96
SCIP_RETCODE SCIPaddConflictUb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx)
SCIP_SEPASTORE * sepastore
Definition: struct_scip.h:93
int SCIPgetDepth(SCIP *scip)
Definition: scip_tree.c:638
#define SCIP_Bool
Definition: def.h:70
public methods for storing cuts in a cut pool
SCIP_Bool SCIPcutpoolIsCutNew(SCIP_CUTPOOL *cutpool, SCIP_SET *set, SCIP_ROW *row)
Definition: cutpool.c:582
SCIP_RETCODE SCIPdelRowCutpool(SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_ROW *row)
Definition: scip_cut.c:530
SCIP_CUT ** SCIPcutpoolGetCuts(SCIP_CUTPOOL *cutpool)
Definition: cutpool.c:1042
#define MAX(x, y)
Definition: tclique_def.h:83
SCIP_Bool SCIPisCutApplicable(SCIP *scip, SCIP_ROW *cut)
Definition: scip_cut.c:178
SCIP_RETCODE SCIPclearCuts(SCIP *scip)
Definition: scip_cut.c:774
methods for debugging
public methods for LP management
SCIP_RETCODE SCIPaddRowCutpool(SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_ROW *row)
Definition: scip_cut.c:485
datastructures for block memory pools and memory buffers
public methods for cuts and aggregation rows
SCIP_Bool SCIPprobAllColsInLP(SCIP_PROB *prob, SCIP_SET *set, SCIP_LP *lp)
Definition: prob.c:2275
SCIP_RETCODE SCIPcutpoolCreate(SCIP_CUTPOOL **cutpool, BMS_BLKMEM *blkmem, SCIP_SET *set, int agelimit, SCIP_Bool globalcutpool)
Definition: cutpool.c:418
int SCIPgetNPoolCuts(SCIP *scip)
Definition: scip_cut.c:391
SCIP_Bool SCIPtreeHasCurrentNodeLP(SCIP_TREE *tree)
Definition: tree.c:8406
SCIP_Bool SCIPisCutEfficacious(SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut)
Definition: scip_cut.c:88
SCIP_Real SCIPgetVectorEfficacyNorm(SCIP *scip, SCIP_Real *vals, int nvals)
Definition: scip_cut.c:120
internal methods for storing cuts in a cut pool
char sepa_efficacynorm
Definition: struct_set.h:524
SCIP_Real SCIProwGetSolEfficacy(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_SOL *sol)
Definition: lp.c:6853
SCIP_VAR * SCIPcolGetVar(SCIP_COL *col)
Definition: lp.c:16904
SCIP_Real SCIProwGetMaxActivity(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)
Definition: lp.c:6607
SCIP_Real rhs
Definition: struct_lp.h:196
SCIP_RETCODE SCIPdelDelayedPoolCut(SCIP *scip, SCIP_ROW *row)
Definition: scip_cut.c:630
SCIP_RETCODE SCIPaddRow(SCIP *scip, SCIP_ROW *row, SCIP_Bool forcecut, SCIP_Bool *infeasible)
Definition: scip_cut.c:221
SCIP_Bool SCIProwIsLPEfficacious(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_Bool root)
Definition: lp.c:6837
BMS_BLKMEM * probmem
Definition: struct_mem.h:40
SCIP_Real SCIProwGetMinActivity(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)
Definition: lp.c:6586
internal methods for main solving loop and node processing
SCIP_NODE * SCIPtreeGetCurrentNode(SCIP_TREE *tree)
Definition: tree.c:8372
SCIP_SET * set
Definition: struct_scip.h:63
SCIP_RETCODE SCIPaddDelayedPoolCut(SCIP *scip, SCIP_ROW *row)
Definition: scip_cut.c:611
public methods for message output
data structures for LP management
SCIP_MESSAGEHDLR * messagehdlr
Definition: struct_scip.h:66
int SCIPgetNCuts(SCIP *scip)
Definition: scip_cut.c:757
#define SCIP_Real
Definition: def.h:163
SCIP_Bool SCIPisLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_RETCODE SCIPcutpoolAddRow(SCIP_CUTPOOL *cutpool, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_ROW *row)
Definition: cutpool.c:645
SCIP_RETCODE SCIPcutpoolSeparate(SCIP_CUTPOOL *cutpool, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_LP *lp, SCIP_SEPASTORE *sepastore, SCIP_SOL *sol, SCIP_Bool cutpoolisdelayed, SCIP_Bool root, SCIP_RESULT *result)
Definition: cutpool.c:813
SCIP_TREE * tree
Definition: struct_scip.h:86
SCIP_RETCODE SCIPaddPoolCut(SCIP *scip, SCIP_ROW *row)
Definition: scip_cut.c:332
SCIP_RETCODE SCIPdelPoolCut(SCIP *scip, SCIP_ROW *row)
Definition: scip_cut.c:352
#define SCIP_CALL_ABORT(x)
Definition: def.h:343
SCIP_RETCODE SCIPsepastoreClearCuts(SCIP_SEPASTORE *sepastore, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_LP *lp)
Definition: sepastore.c:969
SCIP_LP * lp
Definition: struct_scip.h:82
int SCIPgetNDelayedPoolCuts(SCIP *scip)
Definition: scip_cut.c:665
datastructures for global SCIP settings
SCIP_Bool SCIPisEfficacious(SCIP *scip, SCIP_Real efficacy)
Definition: scip_cut.c:106
SCIP_RETCODE SCIPsepastoreAddCut(SCIP_SEPASTORE *sepastore, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_LP *lp, SCIP_ROW *cut, SCIP_Bool forcecut, SCIP_Bool root, SCIP_Bool *infeasible)
Definition: sepastore.c:401
SCIP_RETCODE SCIPfreeCutpool(SCIP *scip, SCIP_CUTPOOL **cutpool)
Definition: scip_cut.c:464
SCIP_RETCODE SCIPseparateSolCutpool(SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_SOL *sol, SCIP_RESULT *result)
Definition: scip_cut.c:581
SCIP_Bool SCIPisCutNew(SCIP *scip, SCIP_ROW *row)
Definition: scip_cut.c:314