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-2022 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.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 Leona 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 row's cutoff distance in the direction of the given primal solution
53  *
54  * @return the cutoff distance of the cut with respect to the LP solution in the direction of the given primal solution
55  *
56  * @pre This method can be called if @p scip is in one of the following stages:
57  * - \ref SCIP_STAGE_SOLVING
58  */
59 SCIP_EXPORT
61  SCIP* scip, /**< SCIP data structure */
62  SCIP_SOL* sol, /**< solution to compute direction for cutoff distance; must not be NULL */
63  SCIP_ROW* cut /**< separated cut */
64  );
65 
66 /** returns efficacy of the cut with respect to the given primal solution or the current LP solution:
67  * e = -feasibility/norm
68  *
69  * @return the efficacy of the cut with respect to the given primal solution or the current LP solution:
70  * e = -feasibility/norm
71  *
72  * @pre This method can be called if @p scip is in one of the following stages:
73  * - \ref SCIP_STAGE_SOLVING
74  */
75 SCIP_EXPORT
77  SCIP* scip, /**< SCIP data structure */
78  SCIP_SOL* sol, /**< primal CIP solution, or NULL for current LP solution */
79  SCIP_ROW* cut /**< separated cut */
80  );
81 
82 /** returns whether the cut's efficacy with respect to the given primal solution or the current LP solution is greater
83  * than the minimal cut efficacy
84  *
85  * @return TRUE if the cut's efficacy with respect to the given primal solution or the current LP solution is greater
86  * than the minimal cut efficacy, otherwise FALSE
87  *
88  * @pre This method can be called if @p scip is in one of the following stages:
89  * - \ref SCIP_STAGE_SOLVING
90  */
91 SCIP_EXPORT
93  SCIP* scip, /**< SCIP data structure */
94  SCIP_SOL* sol, /**< primal CIP solution, or NULL for current LP solution */
95  SCIP_ROW* cut /**< separated cut */
96  );
97 
98 /** checks, if the given cut's efficacy is larger than the minimal cut efficacy
99  *
100  * @return TRUE if the given cut's efficacy is larger than the minimal cut efficacy, otherwise FALSE
101  */
102 SCIP_EXPORT
104  SCIP* scip, /**< SCIP data structure */
105  SCIP_Real efficacy /**< efficacy of the cut */
106  );
107 
108 /** calculates the efficacy norm of the given vector, which depends on the "separating/efficacynorm" parameter
109  *
110  * @return the efficacy norm of the given vector, which depends on the "separating/efficacynorm" parameter
111  */
112 SCIP_EXPORT
114  SCIP* scip, /**< SCIP data structure */
115  SCIP_Real* vals, /**< array of values */
116  int nvals /**< number of values */
117  );
118 
119 /** indicates whether a cut is applicable
120  *
121  * If the cut has only one variable and this method returns FALSE, it may
122  * still be possible that the cut can be added to the LP (as a row instead
123  * of a boundchange), but it will be a very weak cut. The user is asked
124  * to avoid such cuts.
125  *
126  * @pre This method can be called if @p scip is in one of the following stages:
127  * - \ref SCIP_STAGE_SOLVING
128  *
129  * @return whether the cut is modifiable, not a bound change, or a bound change that changes bounds by at least epsilon
130  */
131 SCIP_EXPORT
133  SCIP* scip, /**< SCIP data structure */
134  SCIP_ROW* cut /**< separated cut */
135  );
136 
137 /** adds cut to separation storage
138  *
139  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
140  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
141  *
142  * @pre This method can be called if @p scip is in one of the following stages:
143  * - \ref SCIP_STAGE_SOLVING
144  *
145  * @deprecated Please use SCIPaddRow() instead, or, if the row is a global cut and it might be useful to keep it for future use,
146  * consider adding it to the global cutpool with SCIPaddPoolCut().
147  */
149  SCIP* scip, /**< SCIP data structure */
150  SCIP_SOL* sol, /**< primal solution that was separated, or NULL for LP solution */
151  SCIP_ROW* cut, /**< separated cut */
152  SCIP_Bool forcecut, /**< should the cut be forced to enter the LP? */
153  SCIP_Bool* infeasible /**< pointer to store whether cut has been detected to be infeasible for local bounds */
154  );
155 
156 /** adds row to separation storage
157  *
158  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
159  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
160  *
161  * @pre This method can be called if @p scip is in one of the following stages:
162  * - \ref SCIP_STAGE_SOLVING
163  */
164 SCIP_EXPORT
166  SCIP* scip, /**< SCIP data structure */
167  SCIP_ROW* row, /**< row */
168  SCIP_Bool forcecut, /**< should the row be forced to enter the LP? */
169  SCIP_Bool* infeasible /**< pointer to store whether row has been detected to be infeasible for local bounds */
170  );
171 
172 /** checks if cut is already existing in global cutpool
173  *
174  * @return TRUE is returned if the cut is not already existing in the global cutpool, FALSE otherwise
175  *
176  * @pre This method can be called if @p scip is in one of the following stages:
177  * - \ref SCIP_STAGE_SOLVING
178  */
179 SCIP_EXPORT
181  SCIP* scip, /**< SCIP data structure */
182  SCIP_ROW* row /**< cutting plane to add */
183  );
184 
185 /** if not already existing, adds row to 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  */
193 SCIP_EXPORT
195  SCIP* scip, /**< SCIP data structure */
196  SCIP_ROW* row /**< cutting plane to add */
197  );
198 
199 /** removes the row from the global cut pool
200  *
201  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
202  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
203  *
204  * @pre This method can be called if @p scip is in one of the following stages:
205  * - \ref SCIP_STAGE_SOLVING
206  */
207 SCIP_EXPORT
209  SCIP* scip, /**< SCIP data structure */
210  SCIP_ROW* row /**< row to remove */
211  );
212 
213 /** gets current cuts in the global cut pool
214  *
215  * @return the current cuts 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  */
222 SCIP_EXPORT
224  SCIP* scip /**< SCIP data structure */
225  );
226 
227 /** gets current number of rows in the global cut pool
228  *
229  * @return the current number of rows in the global cut pool
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  */
236 SCIP_EXPORT
237 int SCIPgetNPoolCuts(
238  SCIP* scip /**< SCIP data structure */
239  );
240 
241 /** gets the global cut pool used by SCIP
242  *
243  * @return the global cut pool used by SCIP
244  *
245  * @pre This method can be called if @p scip is in one of the following stages:
246  * - \ref SCIP_STAGE_SOLVING
247  * - \ref SCIP_STAGE_SOLVED
248  * - \ref SCIP_STAGE_EXITSOLVE
249  */
250 SCIP_EXPORT
252  SCIP* scip /**< SCIP data structure */
253  );
254 
255 /** creates a cut pool
256  *
257  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
258  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
259  *
260  * @pre This method can be called if @p scip is in one of the following stages:
261  * - \ref SCIP_STAGE_TRANSFORMING
262  * - \ref SCIP_STAGE_TRANSFORMED
263  * - \ref SCIP_STAGE_INITPRESOLVE
264  * - \ref SCIP_STAGE_PRESOLVING
265  * - \ref SCIP_STAGE_EXITPRESOLVE
266  * - \ref SCIP_STAGE_PRESOLVED
267  * - \ref SCIP_STAGE_INITSOLVE
268  * - \ref SCIP_STAGE_SOLVING
269  */
270 SCIP_EXPORT
272  SCIP* scip, /**< SCIP data structure */
273  SCIP_CUTPOOL** cutpool, /**< pointer to store cut pool */
274  int agelimit /**< maximum age a cut can reach before it is deleted from the pool */
275  );
276 
277 /** frees a cut pool
278  *
279  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
280  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
281  *
282  * @pre This method can be called if @p scip is in one of the following stages:
283  * - \ref SCIP_STAGE_TRANSFORMING
284  * - \ref SCIP_STAGE_TRANSFORMED
285  * - \ref SCIP_STAGE_INITPRESOLVE
286  * - \ref SCIP_STAGE_PRESOLVING
287  * - \ref SCIP_STAGE_EXITPRESOLVE
288  * - \ref SCIP_STAGE_PRESOLVED
289  * - \ref SCIP_STAGE_INITSOLVE
290  * - \ref SCIP_STAGE_SOLVING
291  * - \ref SCIP_STAGE_SOLVED
292  * - \ref SCIP_STAGE_EXITSOLVE
293  * - \ref SCIP_STAGE_FREETRANS
294  */
295 SCIP_EXPORT
297  SCIP* scip, /**< SCIP data structure */
298  SCIP_CUTPOOL** cutpool /**< pointer to store cut pool */
299  );
300 
301 /** if not already existing, adds row to a cut pool and captures it
302  *
303  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
304  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
305  *
306  * @pre This method can be called if @p scip is in one of the following stages:
307  * - \ref SCIP_STAGE_INITSOLVE
308  * - \ref SCIP_STAGE_SOLVING
309  */
310 SCIP_EXPORT
312  SCIP* scip, /**< SCIP data structure */
313  SCIP_CUTPOOL* cutpool, /**< cut pool */
314  SCIP_ROW* row /**< cutting plane to add */
315  );
316 
317 /** adds row to a cut pool and captures it; doesn't check for multiple cuts
318  *
319  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
320  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
321  *
322  * @pre This method can be called if @p scip is in one of the following stages:
323  * - \ref SCIP_STAGE_INITSOLVE
324  * - \ref SCIP_STAGE_SOLVING
325  */
326 SCIP_EXPORT
328  SCIP* scip, /**< SCIP data structure */
329  SCIP_CUTPOOL* cutpool, /**< cut pool */
330  SCIP_ROW* row /**< cutting plane to add */
331  );
332 
333 /** removes the LP row from a cut pool
334  *
335  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
336  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
337  *
338  * @pre This method can be called if @p scip is in one of the following stages:
339  * - \ref SCIP_STAGE_INITSOLVE
340  * - \ref SCIP_STAGE_SOLVING
341  * - \ref SCIP_STAGE_SOLVED
342  */
343 SCIP_EXPORT
345  SCIP* scip, /**< SCIP data structure */
346  SCIP_CUTPOOL* cutpool, /**< cut pool */
347  SCIP_ROW* row /**< row to remove */
348  );
349 
350 /** separates cuts from a cut pool
351  *
352  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
353  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
354  *
355  * @pre This method can be called if @p scip is in one of the following stages:
356  * - \ref SCIP_STAGE_SOLVING
357  */
358 SCIP_EXPORT
360  SCIP* scip, /**< SCIP data structure */
361  SCIP_CUTPOOL* cutpool, /**< cut pool */
362  SCIP_RESULT* result /**< pointer to store the result of the separation call */
363  );
364 
365 /** separates cuts w.r.t. given solution from a cut pool
366  *
367  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
368  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
369  *
370  * @pre This method can be called if @p scip is in one of the following stages:
371  * - \ref SCIP_STAGE_SOLVING
372  */
373 SCIP_EXPORT
375  SCIP* scip, /**< SCIP data structure */
376  SCIP_CUTPOOL* cutpool, /**< cut pool */
377  SCIP_SOL* sol, /**< solution to be separated */
378  SCIP_Bool pretendroot, /**< should the cut separators be called as if we are at the root node? */
379  SCIP_RESULT* result /**< pointer to store the result of the separation call */
380  );
381 
382 /** if not already existing, adds row to the delayed global cut pool
383  *
384  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
385  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
386  *
387  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
388  */
389 SCIP_EXPORT
391  SCIP* scip, /**< SCIP data structure */
392  SCIP_ROW* row /**< cutting plane to add */
393  );
394 
395 /** removes the row from the delayed global cut pool
396  *
397  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
398  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
399  *
400  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
401  */
402 SCIP_EXPORT
404  SCIP* scip, /**< SCIP data structure */
405  SCIP_ROW* row /**< cutting plane to add */
406  );
407 
408 /** gets current cuts in the delayed global cut pool
409  *
410  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
411  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
412  *
413  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
414  */
415 SCIP_EXPORT
417  SCIP* scip /**< SCIP data structure */
418  );
419 
420 /** gets current number of rows in the delayed global cut pool
421  *
422  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
423  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
424  *
425  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
426  */
427 SCIP_EXPORT
429  SCIP* scip /**< SCIP data structure */
430  );
431 
432 /** gets the delayed global cut pool used by SCIP
433  *
434  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
435  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
436  *
437  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
438  */
439 SCIP_EXPORT
441  SCIP* scip /**< SCIP data structure */
442  );
443 
444 /** separates the given primal solution or the current LP solution by calling the separators and constraint handlers'
445  * separation methods;
446  * the generated cuts are stored in the separation storage and can be accessed with the methods SCIPgetCuts() and
447  * SCIPgetNCuts();
448  * after evaluating the cuts, you have to call SCIPclearCuts() in order to remove the cuts from the
449  * separation storage;
450  * it is possible to call SCIPseparateSol() multiple times with different solutions and evaluate the found cuts
451  * afterwards
452  *
453  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
454  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
455  *
456  * @pre This method can be called if @p scip is in one of the following stages:
457  * - \ref SCIP_STAGE_SOLVING
458  */
459 SCIP_EXPORT
461  SCIP* scip, /**< SCIP data structure */
462  SCIP_SOL* sol, /**< primal solution that should be separated, or NULL for LP solution */
463  SCIP_Bool pretendroot, /**< should the cut separators be called as if we are at the root node? */
464  SCIP_Bool allowlocal, /**< should the separator be asked to separate local cuts */
465  SCIP_Bool onlydelayed, /**< should only separators be called that were delayed in the previous round? */
466  SCIP_Bool* delayed, /**< pointer to store whether a separator was delayed */
467  SCIP_Bool* cutoff /**< pointer to store whether the node can be cut off */
468  );
469 
470 /** gets the array of cuts currently stored in the separation storage
471  *
472  * @return the array of cuts currently stored in the separation storage
473  *
474  * @pre This method can be called if @p scip is in one of the following stages:
475  * - \ref SCIP_STAGE_PRESOLVED
476  * - \ref SCIP_STAGE_SOLVING
477  * - \ref SCIP_STAGE_SOLVED
478  */
479 SCIP_EXPORT
481  SCIP* scip /**< SCIP data structure */
482  );
483 
484 /** get current number of cuts in the separation storage
485  *
486  * @return the current number of cuts in the separation storage
487  *
488  * @pre This method can be called if @p scip is in one of the following stages:
489  * - \ref SCIP_STAGE_PRESOLVED
490  * - \ref SCIP_STAGE_SOLVING
491  * - \ref SCIP_STAGE_SOLVED
492  */
493 SCIP_EXPORT
494 int SCIPgetNCuts(
495  SCIP* scip /**< SCIP data structure */
496  );
497 
498 /** clears the separation storage
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_SOLVING
505  */
506 SCIP_EXPORT
508  SCIP* scip /**< SCIP data structure */
509  );
510 
511 /** removes cuts that are inefficacious w.r.t. the current LP solution from separation storage without adding the cuts to the LP
512  *
513  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
514  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
515  *
516  * @pre This method can be called if @p scip is in one of the following stages:
517  * - \ref SCIP_STAGE_SOLVING
518  */
519 SCIP_EXPORT
521  SCIP* scip /**< SCIP data structure */
522  );
523 
524 /**@} */
525 
526 #ifdef __cplusplus
527 }
528 #endif
529 
530 #endif
enum SCIP_Result SCIP_RESULT
Definition: type_result.h:52
SCIP_RETCODE SCIPclearCuts(SCIP *scip)
Definition: scip_cut.c:795
int SCIPgetNDelayedPoolCuts(SCIP *scip)
Definition: scip_cut.c:686
SCIP_RETCODE SCIPseparateSolCutpool(SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_SOL *sol, SCIP_Bool pretendroot, SCIP_RESULT *result)
Definition: scip_cut.c:601
SCIP_CUT ** SCIPgetDelayedPoolCuts(SCIP *scip)
Definition: scip_cut.c:670
SCIP_RETCODE SCIPaddNewRowCutpool(SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_ROW *row)
Definition: scip_cut.c:527
SCIP_RETCODE SCIPaddDelayedPoolCut(SCIP *scip, SCIP_ROW *row)
Definition: scip_cut.c:632
SCIP_RETCODE SCIPdelPoolCut(SCIP *scip, SCIP_ROW *row)
Definition: scip_cut.c:372
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:54
SCIP_Real SCIPgetVectorEfficacyNorm(SCIP *scip, SCIP_Real *vals, int nvals)
Definition: scip_cut.c:140
SCIP_Real SCIPgetCutLPSolCutoffDistance(SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut)
Definition: scip_cut.c:63
type definitions for return codes for SCIP methods
SCIP_CUT ** SCIPgetPoolCuts(SCIP *scip)
Definition: scip_cut.c:393
type definitions for LP management
SCIP_Bool SCIPisCutEfficacious(SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut)
Definition: scip_cut.c:108
SCIP_RETCODE SCIPdelRowCutpool(SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_ROW *row)
Definition: scip_cut.c:550
SCIP_RETCODE SCIPcreateCutpool(SCIP *scip, SCIP_CUTPOOL **cutpool, int agelimit)
Definition: scip_cut.c:453
SCIP_RETCODE SCIPfreeCutpool(SCIP *scip, SCIP_CUTPOOL **cutpool)
Definition: scip_cut.c:484
SCIP_RETCODE SCIPseparateCutpool(SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_RESULT *result)
Definition: scip_cut.c:571
type definitions for SCIP&#39;s main datastructure
type definitions for storing cuts in a cut pool
SCIP_Bool SCIPisEfficacious(SCIP *scip, SCIP_Real efficacy)
Definition: scip_cut.c:126
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:726
SCIP_CUTPOOL * SCIPgetDelayedGlobalCutpool(SCIP *scip)
Definition: scip_cut.c:702
SCIP_RETCODE SCIPremoveInefficaciousCuts(SCIP *scip)
Definition: scip_cut.c:814
SCIP_RETCODE SCIPaddRow(SCIP *scip, SCIP_ROW *row, SCIP_Bool forcecut, SCIP_Bool *infeasible)
Definition: scip_cut.c:241
SCIP_RETCODE SCIPaddCut(SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut, SCIP_Bool forcecut, SCIP_Bool *infeasible)
Definition: scip_cut.c:218
#define SCIP_Bool
Definition: def.h:84
SCIP_RETCODE SCIPaddPoolCut(SCIP *scip, SCIP_ROW *row)
Definition: scip_cut.c:352
SCIP_Real SCIPgetCutEfficacy(SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut)
Definition: scip_cut.c:85
SCIP_Bool SCIPisCutApplicable(SCIP *scip, SCIP_ROW *cut)
Definition: scip_cut.c:198
SCIP_Bool SCIPisCutNew(SCIP *scip, SCIP_ROW *row)
Definition: scip_cut.c:334
type definitions for storing primal CIP solutions
SCIP_RETCODE SCIPdelDelayedPoolCut(SCIP *scip, SCIP_ROW *row)
Definition: scip_cut.c:651
SCIP_RETCODE SCIPaddRowCutpool(SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_ROW *row)
Definition: scip_cut.c:505
int SCIPgetNCuts(SCIP *scip)
Definition: scip_cut.c:778
#define SCIP_Real
Definition: def.h:177
result codes for SCIP callback methods
int SCIPgetNPoolCuts(SCIP *scip)
Definition: scip_cut.c:411
common defines and data types used in all packages of SCIP
SCIP_CUTPOOL * SCIPgetGlobalCutpool(SCIP *scip)
Definition: scip_cut.c:429
SCIP_ROW ** SCIPgetCuts(SCIP *scip)
Definition: scip_cut.c:760