Scippy

SCIP

Solving Constraint Integer Programs

scip_cut.h
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 scip_cut.h
17  * @ingroup PUBLICCOREAPI
18  * @brief public methods for cuts and aggregation rows
19  * @author Tobias Achterberg
20  * @author Timo Berthold
21  * @author Thorsten Koch
22  * @author Alexander Martin
23  * @author Marc Pfetsch
24  * @author Kati Wolter
25  * @author Gregor Hendel
26  * @author Robert Lion Gottwald
27  */
28 
29 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
30 
31 #ifndef __SCIP_SCIP_CUT_H__
32 #define __SCIP_SCIP_CUT_H__
33 
34 
35 #include "scip/def.h"
36 #include "scip/type_cutpool.h"
37 #include "scip/type_lp.h"
38 #include "scip/type_result.h"
39 #include "scip/type_retcode.h"
40 #include "scip/type_scip.h"
41 #include "scip/type_sol.h"
42 
43 #ifdef __cplusplus
44 extern "C" {
45 #endif
46 
47 /**@addtogroup PublicCutMethods
48  *
49  * @{
50  */
51 
52 /** returns efficacy of the cut with respect to the given primal solution or the current LP solution:
53  * e = -feasibility/norm
54  *
55  * @return the efficacy of the cut with respect to the given primal solution or the current LP solution:
56  * e = -feasibility/norm
57  *
58  * @pre This method can be called if @p scip is in one of the following stages:
59  * - \ref SCIP_STAGE_SOLVING
60  */
63  SCIP* scip, /**< SCIP data structure */
64  SCIP_SOL* sol, /**< primal CIP solution, or NULL for current LP solution */
65  SCIP_ROW* cut /**< separated cut */
66  );
67 
68 /** returns whether the cut's efficacy with respect to the given primal solution or the current LP solution is greater
69  * than the minimal cut efficacy
70  *
71  * @return TRUE if the cut's efficacy with respect to the given primal solution or the current LP solution is greater
72  * than the minimal cut efficacy, otherwise FALSE
73  *
74  * @pre This method can be called if @p scip is in one of the following stages:
75  * - \ref SCIP_STAGE_SOLVING
76  */
79  SCIP* scip, /**< SCIP data structure */
80  SCIP_SOL* sol, /**< primal CIP solution, or NULL for current LP solution */
81  SCIP_ROW* cut /**< separated cut */
82  );
83 
84 /** checks, if the given cut's efficacy is larger than the minimal cut efficacy
85  *
86  * @return TRUE if the given cut's efficacy is larger than the minimal cut efficacy, otherwise FALSE
87  */
90  SCIP* scip, /**< SCIP data structure */
91  SCIP_Real efficacy /**< efficacy of the cut */
92  );
93 
94 /** calculates the efficacy norm of the given vector, which depends on the "separating/efficacynorm" parameter
95  *
96  * @return the efficacy norm of the given vector, which depends on the "separating/efficacynorm" parameter
97  */
100  SCIP* scip, /**< SCIP data structure */
101  SCIP_Real* vals, /**< array of values */
102  int nvals /**< number of values */
103  );
104 
105 /** indicates whether a cut is applicable
106  *
107  * If the cut has only one variable and this method returns FALSE, it may
108  * still be possible that the cut can be added to the LP (as a row instead
109  * of a boundchange), but it will be a very weak cut. The user is asked
110  * to avoid such cuts.
111  *
112  * @pre This method can be called if @p scip is in one of the following stages:
113  * - \ref SCIP_STAGE_SOLVING
114  *
115  * @return whether the cut is modifiable, not a bound change, or a bound change that changes bounds by at least epsilon
116  */
119  SCIP* scip, /**< SCIP data structure */
120  SCIP_ROW* cut /**< separated cut */
121  );
122 
123 /** adds cut to separation storage
124  *
125  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
126  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
127  *
128  * @pre This method can be called if @p scip is in one of the following stages:
129  * - \ref SCIP_STAGE_SOLVING
130  *
131  * @deprecated Please use SCIPaddRow() instead, or, if the row is a global cut and it might be useful to keep it for future use,
132  * consider adding it to the global cutpool with SCIPaddPoolCut().
133  */
135  SCIP* scip, /**< SCIP data structure */
136  SCIP_SOL* sol, /**< primal solution that was separated, or NULL for LP solution */
137  SCIP_ROW* cut, /**< separated cut */
138  SCIP_Bool forcecut, /**< should the cut be forced to enter the LP? */
139  SCIP_Bool* infeasible /**< pointer to store whether cut has been detected to be infeasible for local bounds */
140  );
141 
142 /** adds row to separation storage
143  *
144  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
145  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
146  *
147  * @pre This method can be called if @p scip is in one of the following stages:
148  * - \ref SCIP_STAGE_SOLVING
149  */
152  SCIP* scip, /**< SCIP data structure */
153  SCIP_ROW* row, /**< row */
154  SCIP_Bool forcecut, /**< should the row be forced to enter the LP? */
155  SCIP_Bool* infeasible /**< pointer to store whether row has been detected to be infeasible for local bounds */
156  );
157 
158 /** checks if cut is already existing in global cutpool
159  *
160  * @return TRUE is returned if the cut is not already existing in the global cutpool, FALSE otherwise
161  *
162  * @pre This method can be called if @p scip is in one of the following stages:
163  * - \ref SCIP_STAGE_SOLVING
164  */
167  SCIP* scip, /**< SCIP data structure */
168  SCIP_ROW* row /**< cutting plane to add */
169  );
170 
171 /** if not already existing, adds row to global cut pool
172  *
173  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
174  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
175  *
176  * @pre This method can be called if @p scip is in one of the following stages:
177  * - \ref SCIP_STAGE_SOLVING
178  */
181  SCIP* scip, /**< SCIP data structure */
182  SCIP_ROW* row /**< cutting plane to add */
183  );
184 
185 /** removes the row from the global cut pool
186  *
187  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
188  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
189  *
190  * @pre This method can be called if @p scip is in one of the following stages:
191  * - \ref SCIP_STAGE_SOLVING
192  */
195  SCIP* scip, /**< SCIP data structure */
196  SCIP_ROW* row /**< row to remove */
197  );
198 
199 /** gets current cuts in the global cut pool
200  *
201  * @return the current cuts in the global cut pool
202  *
203  * @pre This method can be called if @p scip is in one of the following stages:
204  * - \ref SCIP_STAGE_SOLVING
205  * - \ref SCIP_STAGE_SOLVED
206  * - \ref SCIP_STAGE_EXITSOLVE
207  */
210  SCIP* scip /**< SCIP data structure */
211  );
212 
213 /** gets current number of rows in the global cut pool
214  *
215  * @return the current number of rows in the global cut pool
216  *
217  * @pre This method can be called if @p scip is in one of the following stages:
218  * - \ref SCIP_STAGE_SOLVING
219  * - \ref SCIP_STAGE_SOLVED
220  * - \ref SCIP_STAGE_EXITSOLVE
221  */
223 int SCIPgetNPoolCuts(
224  SCIP* scip /**< SCIP data structure */
225  );
226 
227 /** gets the global cut pool used by SCIP
228  *
229  * @return the global cut pool used by SCIP
230  *
231  * @pre This method can be called if @p scip is in one of the following stages:
232  * - \ref SCIP_STAGE_SOLVING
233  * - \ref SCIP_STAGE_SOLVED
234  * - \ref SCIP_STAGE_EXITSOLVE
235  */
238  SCIP* scip /**< SCIP data structure */
239  );
240 
241 /** creates a cut pool
242  *
243  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
244  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
245  *
246  * @pre This method can be called if @p scip is in one of the following stages:
247  * - \ref SCIP_STAGE_TRANSFORMING
248  * - \ref SCIP_STAGE_TRANSFORMED
249  * - \ref SCIP_STAGE_INITPRESOLVE
250  * - \ref SCIP_STAGE_PRESOLVING
251  * - \ref SCIP_STAGE_EXITPRESOLVE
252  * - \ref SCIP_STAGE_PRESOLVED
253  * - \ref SCIP_STAGE_INITSOLVE
254  * - \ref SCIP_STAGE_SOLVING
255  */
258  SCIP* scip, /**< SCIP data structure */
259  SCIP_CUTPOOL** cutpool, /**< pointer to store cut pool */
260  int agelimit /**< maximum age a cut can reach before it is deleted from the pool */
261  );
262 
263 /** frees a cut pool
264  *
265  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
266  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
267  *
268  * @pre This method can be called if @p scip is in one of the following stages:
269  * - \ref SCIP_STAGE_TRANSFORMING
270  * - \ref SCIP_STAGE_TRANSFORMED
271  * - \ref SCIP_STAGE_INITPRESOLVE
272  * - \ref SCIP_STAGE_PRESOLVING
273  * - \ref SCIP_STAGE_EXITPRESOLVE
274  * - \ref SCIP_STAGE_PRESOLVED
275  * - \ref SCIP_STAGE_INITSOLVE
276  * - \ref SCIP_STAGE_SOLVING
277  * - \ref SCIP_STAGE_SOLVED
278  * - \ref SCIP_STAGE_EXITSOLVE
279  * - \ref SCIP_STAGE_FREETRANS
280  */
283  SCIP* scip, /**< SCIP data structure */
284  SCIP_CUTPOOL** cutpool /**< pointer to store cut pool */
285  );
286 
287 /** if not already existing, adds row to a cut pool and captures it
288  *
289  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
290  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
291  *
292  * @pre This method can be called if @p scip is in one of the following stages:
293  * - \ref SCIP_STAGE_INITSOLVE
294  * - \ref SCIP_STAGE_SOLVING
295  */
298  SCIP* scip, /**< SCIP data structure */
299  SCIP_CUTPOOL* cutpool, /**< cut pool */
300  SCIP_ROW* row /**< cutting plane to add */
301  );
302 
303 /** adds row to a cut pool and captures it; doesn't check for multiple cuts
304  *
305  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
306  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
307  *
308  * @pre This method can be called if @p scip is in one of the following stages:
309  * - \ref SCIP_STAGE_INITSOLVE
310  * - \ref SCIP_STAGE_SOLVING
311  */
314  SCIP* scip, /**< SCIP data structure */
315  SCIP_CUTPOOL* cutpool, /**< cut pool */
316  SCIP_ROW* row /**< cutting plane to add */
317  );
318 
319 /** removes the LP row from a cut pool
320  *
321  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
322  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
323  *
324  * @pre This method can be called if @p scip is in one of the following stages:
325  * - \ref SCIP_STAGE_INITSOLVE
326  * - \ref SCIP_STAGE_SOLVING
327  * - \ref SCIP_STAGE_SOLVED
328  */
331  SCIP* scip, /**< SCIP data structure */
332  SCIP_CUTPOOL* cutpool, /**< cut pool */
333  SCIP_ROW* row /**< row to remove */
334  );
335 
336 /** separates cuts from a cut pool
337  *
338  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
339  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
340  *
341  * @pre This method can be called if @p scip is in one of the following stages:
342  * - \ref SCIP_STAGE_SOLVING
343  */
346  SCIP* scip, /**< SCIP data structure */
347  SCIP_CUTPOOL* cutpool, /**< cut pool */
348  SCIP_RESULT* result /**< pointer to store the result of the separation call */
349  );
350 
351 /** separates cuts w.r.t. given solution from a cut pool
352  *
353  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
354  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
355  *
356  * @pre This method can be called if @p scip is in one of the following stages:
357  * - \ref SCIP_STAGE_SOLVING
358  */
361  SCIP* scip, /**< SCIP data structure */
362  SCIP_CUTPOOL* cutpool, /**< cut pool */
363  SCIP_SOL* sol, /**< solution to be separated */
364  SCIP_RESULT* result /**< pointer to store the result of the separation call */
365  );
366 
367 /** if not already existing, adds row to the delayed global cut pool
368  *
369  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
370  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
371  *
372  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
373  */
376  SCIP* scip, /**< SCIP data structure */
377  SCIP_ROW* row /**< cutting plane to add */
378  );
379 
380 /** removes the row from the delayed global cut pool
381  *
382  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
383  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
384  *
385  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
386  */
389  SCIP* scip, /**< SCIP data structure */
390  SCIP_ROW* row /**< cutting plane to add */
391  );
392 
393 /** gets current cuts in the delayed global cut pool
394  *
395  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
396  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
397  *
398  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
399  */
402  SCIP* scip /**< SCIP data structure */
403  );
404 
405 /** gets current number of rows in the delayed global cut pool
406  *
407  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
408  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
409  *
410  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
411  */
414  SCIP* scip /**< SCIP data structure */
415  );
416 
417 /** gets the delayed global cut pool used by SCIP
418  *
419  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
420  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
421  *
422  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
423  */
426  SCIP* scip /**< SCIP data structure */
427  );
428 
429 /** separates the given primal solution or the current LP solution by calling the separators and constraint handlers'
430  * separation methods;
431  * the generated cuts are stored in the separation storage and can be accessed with the methods SCIPgetCuts() and
432  * SCIPgetNCuts();
433  * after evaluating the cuts, you have to call SCIPclearCuts() in order to remove the cuts from the
434  * separation storage;
435  * it is possible to call SCIPseparateSol() multiple times with different solutions and evaluate the found cuts
436  * afterwards
437  *
438  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
439  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
440  *
441  * @pre This method can be called if @p scip is in one of the following stages:
442  * - \ref SCIP_STAGE_SOLVING
443  */
446  SCIP* scip, /**< SCIP data structure */
447  SCIP_SOL* sol, /**< primal solution that should be separated, or NULL for LP solution */
448  SCIP_Bool pretendroot, /**< should the cut separators be called as if we are at the root node? */
449  SCIP_Bool allowlocal, /**< should the separator be asked to separate local cuts */
450  SCIP_Bool onlydelayed, /**< should only separators be called that were delayed in the previous round? */
451  SCIP_Bool* delayed, /**< pointer to store whether a separator was delayed */
452  SCIP_Bool* cutoff /**< pointer to store whether the node can be cut off */
453  );
454 
455 /** gets the array of cuts currently stored in the separation storage
456  *
457  * @return the array of cuts currently stored in the separation storage
458  *
459  * @pre This method can be called if @p scip is in one of the following stages:
460  * - \ref SCIP_STAGE_PRESOLVED
461  * - \ref SCIP_STAGE_SOLVING
462  * - \ref SCIP_STAGE_SOLVED
463  */
466  SCIP* scip /**< SCIP data structure */
467  );
468 
469 /** get current number of cuts in the separation storage
470  *
471  * @return the current number of cuts in the separation storage
472  *
473  * @pre This method can be called if @p scip is in one of the following stages:
474  * - \ref SCIP_STAGE_PRESOLVED
475  * - \ref SCIP_STAGE_SOLVING
476  * - \ref SCIP_STAGE_SOLVED
477  */
479 int SCIPgetNCuts(
480  SCIP* scip /**< SCIP data structure */
481  );
482 
483 /** clears the separation storage
484  *
485  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
486  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
487  *
488  * @pre This method can be called if @p scip is in one of the following stages:
489  * - \ref SCIP_STAGE_SOLVING
490  */
493  SCIP* scip /**< SCIP data structure */
494  );
495 
496 /** removes cuts that are inefficacious w.r.t. the current LP solution from separation storage without adding the cuts to the LP
497  *
498  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
499  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
500  *
501  * @pre This method can be called if @p scip is in one of the following stages:
502  * - \ref SCIP_STAGE_SOLVING
503  */
506  SCIP* scip /**< SCIP data structure */
507  );
508 
509 /**@} */
510 
511 #ifdef __cplusplus
512 }
513 #endif
514 
515 #endif
enum SCIP_Result SCIP_RESULT
Definition: type_result.h:52
SCIP_EXPORT 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:704
#define SCIP_EXPORT
Definition: def.h:98
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:53
SCIP_EXPORT SCIP_RETCODE SCIPaddNewRowCutpool(SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_ROW *row)
Definition: scip_cut.c:506
type definitions for return codes for SCIP methods
SCIP_EXPORT SCIP_Real SCIPgetCutEfficacy(SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut)
Definition: scip_cut.c:64
type definitions for LP management
SCIP_EXPORT SCIP_RETCODE SCIPremoveInefficaciousCuts(SCIP *scip)
Definition: scip_cut.c:792
SCIP_EXPORT SCIP_CUTPOOL * SCIPgetDelayedGlobalCutpool(SCIP *scip)
Definition: scip_cut.c:680
SCIP_EXPORT SCIP_CUTPOOL * SCIPgetGlobalCutpool(SCIP *scip)
Definition: scip_cut.c:408
SCIP_EXPORT SCIP_CUT ** SCIPgetPoolCuts(SCIP *scip)
Definition: scip_cut.c:372
type definitions for SCIP&#39;s main datastructure
SCIP_EXPORT SCIP_RETCODE SCIPcreateCutpool(SCIP *scip, SCIP_CUTPOOL **cutpool, int agelimit)
Definition: scip_cut.c:432
type definitions for storing cuts in a cut pool
SCIP_EXPORT SCIP_RETCODE SCIPseparateCutpool(SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_RESULT *result)
Definition: scip_cut.c:550
SCIP_EXPORT SCIP_ROW ** SCIPgetCuts(SCIP *scip)
Definition: scip_cut.c:738
SCIP_EXPORT SCIP_CUT ** SCIPgetDelayedPoolCuts(SCIP *scip)
Definition: scip_cut.c:648
SCIP_RETCODE SCIPaddCut(SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut, SCIP_Bool forcecut, SCIP_Bool *infeasible)
Definition: scip_cut.c:197
#define SCIP_Bool
Definition: def.h:70
SCIP_EXPORT SCIP_RETCODE SCIPdelRowCutpool(SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_ROW *row)
Definition: scip_cut.c:529
SCIP_EXPORT SCIP_Bool SCIPisCutApplicable(SCIP *scip, SCIP_ROW *cut)
Definition: scip_cut.c:177
SCIP_EXPORT SCIP_RETCODE SCIPclearCuts(SCIP *scip)
Definition: scip_cut.c:773
SCIP_EXPORT SCIP_RETCODE SCIPaddRowCutpool(SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_ROW *row)
Definition: scip_cut.c:484
SCIP_EXPORT int SCIPgetNPoolCuts(SCIP *scip)
Definition: scip_cut.c:390
SCIP_EXPORT SCIP_Bool SCIPisCutEfficacious(SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut)
Definition: scip_cut.c:87
SCIP_EXPORT SCIP_Real SCIPgetVectorEfficacyNorm(SCIP *scip, SCIP_Real *vals, int nvals)
Definition: scip_cut.c:119
type definitions for storing primal CIP solutions
SCIP_EXPORT SCIP_RETCODE SCIPdelDelayedPoolCut(SCIP *scip, SCIP_ROW *row)
Definition: scip_cut.c:629
SCIP_EXPORT SCIP_RETCODE SCIPaddRow(SCIP *scip, SCIP_ROW *row, SCIP_Bool forcecut, SCIP_Bool *infeasible)
Definition: scip_cut.c:220
SCIP_EXPORT SCIP_RETCODE SCIPaddDelayedPoolCut(SCIP *scip, SCIP_ROW *row)
Definition: scip_cut.c:610
SCIP_EXPORT int SCIPgetNCuts(SCIP *scip)
Definition: scip_cut.c:756
#define SCIP_Real
Definition: def.h:164
result codes for SCIP callback methods
SCIP_EXPORT SCIP_RETCODE SCIPaddPoolCut(SCIP *scip, SCIP_ROW *row)
Definition: scip_cut.c:331
SCIP_EXPORT SCIP_RETCODE SCIPdelPoolCut(SCIP *scip, SCIP_ROW *row)
Definition: scip_cut.c:351
common defines and data types used in all packages of SCIP
SCIP_EXPORT int SCIPgetNDelayedPoolCuts(SCIP *scip)
Definition: scip_cut.c:664
SCIP_EXPORT SCIP_Bool SCIPisEfficacious(SCIP *scip, SCIP_Real efficacy)
Definition: scip_cut.c:105
SCIP_EXPORT SCIP_RETCODE SCIPfreeCutpool(SCIP *scip, SCIP_CUTPOOL **cutpool)
Definition: scip_cut.c:463
SCIP_EXPORT SCIP_RETCODE SCIPseparateSolCutpool(SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_SOL *sol, SCIP_RESULT *result)
Definition: scip_cut.c:580
SCIP_EXPORT SCIP_Bool SCIPisCutNew(SCIP *scip, SCIP_ROW *row)
Definition: scip_cut.c:313