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-2018 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 /* In debug mode, we include the SCIP's structure in scip.c, such that no one can access
44  * this structure except the interface methods in scip.c.
45  * In optimized mode, the structure is included in scip.h, because some of the methods
46  * are implemented as defines for performance reasons (e.g. the numerical comparisons).
47  * Additionally, the internal "set.h" is included, such that the defines in set.h are
48  * available in optimized mode.
49  */
50 #ifdef NDEBUG
51 #include "scip/struct_scip.h"
52 #include "scip/struct_stat.h"
53 #include "scip/set.h"
54 #include "scip/tree.h"
55 #include "scip/misc.h"
56 #include "scip/var.h"
57 #include "scip/cons.h"
58 #include "scip/solve.h"
59 #include "scip/debug.h"
60 #endif
61 
62 #ifdef __cplusplus
63 extern "C" {
64 #endif
65 
66 /**@addtogroup PublicCutMethods
67  *
68  * @{
69  */
70 
71 /** returns efficacy of the cut with respect to the given primal solution or the current LP solution:
72  * e = -feasibility/norm
73  *
74  * @return the efficacy of the cut with respect to the given primal solution or the current LP solution:
75  * e = -feasibility/norm
76  *
77  * @pre This method can be called if @p scip is in one of the following stages:
78  * - \ref SCIP_STAGE_SOLVING
79  */
80 extern
82  SCIP* scip, /**< SCIP data structure */
83  SCIP_SOL* sol, /**< primal CIP solution, or NULL for current LP solution */
84  SCIP_ROW* cut /**< separated cut */
85  );
86 
87 /** returns whether the cut's efficacy with respect to the given primal solution or the current LP solution is greater
88  * than the minimal cut efficacy
89  *
90  * @return TRUE if the cut's efficacy with respect to the given primal solution or the current LP solution is greater
91  * than the minimal cut efficacy, otherwise FALSE
92  *
93  * @pre This method can be called if @p scip is in one of the following stages:
94  * - \ref SCIP_STAGE_SOLVING
95  */
96 extern
98  SCIP* scip, /**< SCIP data structure */
99  SCIP_SOL* sol, /**< primal CIP solution, or NULL for current LP solution */
100  SCIP_ROW* cut /**< separated cut */
101  );
102 
103 /** checks, if the given cut's efficacy is larger than the minimal cut efficacy
104  *
105  * @return TRUE if the given cut's efficacy is larger than the minimal cut efficacy, otherwise FALSE
106  */
107 extern
109  SCIP* scip, /**< SCIP data structure */
110  SCIP_Real efficacy /**< efficacy of the cut */
111  );
112 
113 /** calculates the efficacy norm of the given vector, which depends on the "separating/efficacynorm" parameter
114  *
115  * @return the efficacy norm of the given vector, which depends on the "separating/efficacynorm" parameter
116  */
117 extern
119  SCIP* scip, /**< SCIP data structure */
120  SCIP_Real* vals, /**< array of values */
121  int nvals /**< number of values */
122  );
123 
124 /** indicates whether a cut is applicable
125  *
126  * If the cut has only one variable and this method returns FALSE, it may
127  * still be possible that the cut can be added to the LP (as a row instead
128  * of a boundchange), but it will be a very weak cut. The user is asked
129  * to avoid such cuts.
130  *
131  * @pre This method can be called if @p scip is in one of the following stages:
132  * - \ref SCIP_STAGE_SOLVING
133  *
134  * @return whether the cut is modifiable, not a bound change, or a bound change that changes bounds by at least epsilon
135  */
136 extern
138  SCIP* scip, /**< SCIP data structure */
139  SCIP_ROW* cut /**< separated cut */
140  );
141 
142 /** adds cut 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  *
150  * @deprecated Please use SCIPaddRow() instead, or, if the row is a global cut and it might be useful to keep it for future use,
151  * consider adding it to the global cutpool with SCIPaddPoolCut().
152  */
155  SCIP* scip, /**< SCIP data structure */
156  SCIP_SOL* sol, /**< primal solution that was separated, or NULL for LP solution */
157  SCIP_ROW* cut, /**< separated cut */
158  SCIP_Bool forcecut, /**< should the cut be forced to enter the LP? */
159  SCIP_Bool* infeasible /**< pointer to store whether cut has been detected to be infeasible for local bounds */
160  );
161 
162 /** adds row to separation storage
163  *
164  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
165  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
166  *
167  * @pre This method can be called if @p scip is in one of the following stages:
168  * - \ref SCIP_STAGE_SOLVING
169  */
170 extern
172  SCIP* scip, /**< SCIP data structure */
173  SCIP_ROW* row, /**< row */
174  SCIP_Bool forcecut, /**< should the row be forced to enter the LP? */
175  SCIP_Bool* infeasible /**< pointer to store whether row has been detected to be infeasible for local bounds */
176  );
177 
178 /** checks if cut is already existing in global cutpool
179  *
180  * @return TRUE is returned if the cut is not already existing in the global cutpool, FALSE otherwise
181  *
182  * @pre This method can be called if @p scip is in one of the following stages:
183  * - \ref SCIP_STAGE_SOLVING
184  */
185 extern
187  SCIP* scip, /**< SCIP data structure */
188  SCIP_ROW* row /**< cutting plane to add */
189  );
190 
191 /** if not already existing, adds row to global cut pool
192  *
193  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
194  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
195  *
196  * @pre This method can be called if @p scip is in one of the following stages:
197  * - \ref SCIP_STAGE_SOLVING
198  */
199 extern
201  SCIP* scip, /**< SCIP data structure */
202  SCIP_ROW* row /**< cutting plane to add */
203  );
204 
205 /** removes the row from the global cut pool
206  *
207  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
208  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
209  *
210  * @pre This method can be called if @p scip is in one of the following stages:
211  * - \ref SCIP_STAGE_SOLVING
212  */
213 extern
215  SCIP* scip, /**< SCIP data structure */
216  SCIP_ROW* row /**< row to remove */
217  );
218 
219 /** gets current cuts in the global cut pool
220  *
221  * @return the current cuts in the global cut pool
222  *
223  * @pre This method can be called if @p scip is in one of the following stages:
224  * - \ref SCIP_STAGE_SOLVING
225  * - \ref SCIP_STAGE_SOLVED
226  * - \ref SCIP_STAGE_EXITSOLVE
227  */
228 extern
230  SCIP* scip /**< SCIP data structure */
231  );
232 
233 /** gets current number of rows in the global cut pool
234  *
235  * @return the current number of rows in the global cut pool
236  *
237  * @pre This method can be called if @p scip is in one of the following stages:
238  * - \ref SCIP_STAGE_SOLVING
239  * - \ref SCIP_STAGE_SOLVED
240  * - \ref SCIP_STAGE_EXITSOLVE
241  */
242 extern
243 int SCIPgetNPoolCuts(
244  SCIP* scip /**< SCIP data structure */
245  );
246 
247 /** gets the global cut pool used by SCIP
248  *
249  * @return the global cut pool used by SCIP
250  *
251  * @pre This method can be called if @p scip is in one of the following stages:
252  * - \ref SCIP_STAGE_SOLVING
253  * - \ref SCIP_STAGE_SOLVED
254  * - \ref SCIP_STAGE_EXITSOLVE
255  */
256 extern
258  SCIP* scip /**< SCIP data structure */
259  );
260 
261 /** creates a cut pool
262  *
263  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
264  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
265  *
266  * @pre This method can be called if @p scip is in one of the following stages:
267  * - \ref SCIP_STAGE_TRANSFORMING
268  * - \ref SCIP_STAGE_TRANSFORMED
269  * - \ref SCIP_STAGE_INITPRESOLVE
270  * - \ref SCIP_STAGE_PRESOLVING
271  * - \ref SCIP_STAGE_EXITPRESOLVE
272  * - \ref SCIP_STAGE_PRESOLVED
273  * - \ref SCIP_STAGE_INITSOLVE
274  * - \ref SCIP_STAGE_SOLVING
275  */
276 extern
278  SCIP* scip, /**< SCIP data structure */
279  SCIP_CUTPOOL** cutpool, /**< pointer to store cut pool */
280  int agelimit /**< maximum age a cut can reach before it is deleted from the pool */
281  );
282 
283 /** frees a cut pool
284  *
285  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
286  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
287  *
288  * @pre This method can be called if @p scip is in one of the following stages:
289  * - \ref SCIP_STAGE_TRANSFORMING
290  * - \ref SCIP_STAGE_TRANSFORMED
291  * - \ref SCIP_STAGE_INITPRESOLVE
292  * - \ref SCIP_STAGE_PRESOLVING
293  * - \ref SCIP_STAGE_EXITPRESOLVE
294  * - \ref SCIP_STAGE_PRESOLVED
295  * - \ref SCIP_STAGE_INITSOLVE
296  * - \ref SCIP_STAGE_SOLVING
297  * - \ref SCIP_STAGE_SOLVED
298  * - \ref SCIP_STAGE_EXITSOLVE
299  * - \ref SCIP_STAGE_FREETRANS
300  */
301 extern
303  SCIP* scip, /**< SCIP data structure */
304  SCIP_CUTPOOL** cutpool /**< pointer to store cut pool */
305  );
306 
307 /** if not already existing, adds row to a cut pool and captures it
308  *
309  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
310  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
311  *
312  * @pre This method can be called if @p scip is in one of the following stages:
313  * - \ref SCIP_STAGE_INITSOLVE
314  * - \ref SCIP_STAGE_SOLVING
315  */
316 extern
318  SCIP* scip, /**< SCIP data structure */
319  SCIP_CUTPOOL* cutpool, /**< cut pool */
320  SCIP_ROW* row /**< cutting plane to add */
321  );
322 
323 /** adds row to a cut pool and captures it; doesn't check for multiple cuts
324  *
325  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
326  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
327  *
328  * @pre This method can be called if @p scip is in one of the following stages:
329  * - \ref SCIP_STAGE_INITSOLVE
330  * - \ref SCIP_STAGE_SOLVING
331  */
332 extern
334  SCIP* scip, /**< SCIP data structure */
335  SCIP_CUTPOOL* cutpool, /**< cut pool */
336  SCIP_ROW* row /**< cutting plane to add */
337  );
338 
339 /** removes the LP row from a cut pool
340  *
341  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
342  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
343  *
344  * @pre This method can be called if @p scip is in one of the following stages:
345  * - \ref SCIP_STAGE_INITSOLVE
346  * - \ref SCIP_STAGE_SOLVING
347  * - \ref SCIP_STAGE_SOLVED
348  */
349 extern
351  SCIP* scip, /**< SCIP data structure */
352  SCIP_CUTPOOL* cutpool, /**< cut pool */
353  SCIP_ROW* row /**< row to remove */
354  );
355 
356 /** separates cuts from a cut pool
357  *
358  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
359  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
360  *
361  * @pre This method can be called if @p scip is in one of the following stages:
362  * - \ref SCIP_STAGE_SOLVING
363  */
364 extern
366  SCIP* scip, /**< SCIP data structure */
367  SCIP_CUTPOOL* cutpool, /**< cut pool */
368  SCIP_RESULT* result /**< pointer to store the result of the separation call */
369  );
370 
371 /** separates cuts w.r.t. given solution from a cut pool
372  *
373  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
374  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
375  *
376  * @pre This method can be called if @p scip is in one of the following stages:
377  * - \ref SCIP_STAGE_SOLVING
378  */
379 extern
381  SCIP* scip, /**< SCIP data structure */
382  SCIP_CUTPOOL* cutpool, /**< cut pool */
383  SCIP_SOL* sol, /**< solution to be separated */
384  SCIP_RESULT* result /**< pointer to store the result of the separation call */
385  );
386 
387 /** if not already existing, adds row to the delayed global cut pool
388  *
389  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
390  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
391  *
392  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
393  */
394 extern
396  SCIP* scip, /**< SCIP data structure */
397  SCIP_ROW* row /**< cutting plane to add */
398  );
399 
400 /** removes the row from the delayed global cut pool
401  *
402  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
403  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
404  *
405  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
406  */
407 extern
409  SCIP* scip, /**< SCIP data structure */
410  SCIP_ROW* row /**< cutting plane to add */
411  );
412 
413 /** gets current cuts in the delayed global cut pool
414  *
415  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
416  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
417  *
418  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
419  */
420 extern
422  SCIP* scip /**< SCIP data structure */
423  );
424 
425 /** gets current number of rows in the delayed global cut pool
426  *
427  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
428  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
429  *
430  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
431  */
432 extern
434  SCIP* scip /**< SCIP data structure */
435  );
436 
437 /** gets the delayed global cut pool used by SCIP
438  *
439  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
440  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
441  *
442  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
443  */
444 extern
446  SCIP* scip /**< SCIP data structure */
447  );
448 
449 /** separates the given primal solution or the current LP solution by calling the separators and constraint handlers'
450  * separation methods;
451  * the generated cuts are stored in the separation storage and can be accessed with the methods SCIPgetCuts() and
452  * SCIPgetNCuts();
453  * after evaluating the cuts, you have to call SCIPclearCuts() in order to remove the cuts from the
454  * separation storage;
455  * it is possible to call SCIPseparateSol() multiple times with different solutions and evaluate the found cuts
456  * afterwards
457  *
458  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
459  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
460  *
461  * @pre This method can be called if @p scip is in one of the following stages:
462  * - \ref SCIP_STAGE_SOLVING
463  */
464 extern
466  SCIP* scip, /**< SCIP data structure */
467  SCIP_SOL* sol, /**< primal solution that should be separated, or NULL for LP solution */
468  SCIP_Bool pretendroot, /**< should the cut separators be called as if we are at the root node? */
469  SCIP_Bool allowlocal, /**< should the separator be asked to separate local cuts */
470  SCIP_Bool onlydelayed, /**< should only separators be called that were delayed in the previous round? */
471  SCIP_Bool* delayed, /**< pointer to store whether a separator was delayed */
472  SCIP_Bool* cutoff /**< pointer to store whether the node can be cut off */
473  );
474 
475 /** gets the array of cuts currently stored in the separation storage
476  *
477  * @return the array of cuts currently stored in the separation storage
478  *
479  * @pre This method can be called if @p scip is in one of the following stages:
480  * - \ref SCIP_STAGE_PRESOLVED
481  * - \ref SCIP_STAGE_SOLVING
482  * - \ref SCIP_STAGE_SOLVED
483  */
484 extern
486  SCIP* scip /**< SCIP data structure */
487  );
488 
489 /** get current number of cuts in the separation storage
490  *
491  * @return the current number of cuts in the separation storage
492  *
493  * @pre This method can be called if @p scip is in one of the following stages:
494  * - \ref SCIP_STAGE_PRESOLVED
495  * - \ref SCIP_STAGE_SOLVING
496  * - \ref SCIP_STAGE_SOLVED
497  */
498 extern
499 int SCIPgetNCuts(
500  SCIP* scip /**< SCIP data structure */
501  );
502 
503 /** clears the separation storage
504  *
505  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
506  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
507  *
508  * @pre This method can be called if @p scip is in one of the following stages:
509  * - \ref SCIP_STAGE_SOLVING
510  */
511 extern
513  SCIP* scip /**< SCIP data structure */
514  );
515 
516 /** removes cuts that are inefficacious w.r.t. the current LP solution from separation storage without adding the cuts to the LP
517  *
518  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
519  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
520  *
521  * @pre This method can be called if @p scip is in one of the following stages:
522  * - \ref SCIP_STAGE_SOLVING
523  */
524 extern
526  SCIP* scip /**< SCIP data structure */
527  );
528 
529 /**@} */
530 
531 #ifdef __cplusplus
532 }
533 #endif
534 
535 #endif
enum SCIP_Result SCIP_RESULT
Definition: type_result.h:52
SCIP_RETCODE SCIPclearCuts(SCIP *scip)
Definition: scip_cut.c:847
int SCIPgetNDelayedPoolCuts(SCIP *scip)
Definition: scip_cut.c:738
internal methods for branch and bound tree
SCIP_CUT ** SCIPgetDelayedPoolCuts(SCIP *scip)
Definition: scip_cut.c:722
SCIP_RETCODE SCIPaddNewRowCutpool(SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_ROW *row)
Definition: scip_cut.c:580
SCIP_RETCODE SCIPaddDelayedPoolCut(SCIP *scip, SCIP_ROW *row)
Definition: scip_cut.c:684
SCIP_RETCODE SCIPdelPoolCut(SCIP *scip, SCIP_ROW *row)
Definition: scip_cut.c:425
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:53
SCIP_Real SCIPgetVectorEfficacyNorm(SCIP *scip, SCIP_Real *vals, int nvals)
Definition: scip_cut.c:193
type definitions for return codes for SCIP methods
SCIP_CUT ** SCIPgetPoolCuts(SCIP *scip)
Definition: scip_cut.c:446
type definitions for LP management
SCIP_Bool SCIPisCutEfficacious(SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut)
Definition: scip_cut.c:161
SCIP_RETCODE SCIPdelRowCutpool(SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_ROW *row)
Definition: scip_cut.c:603
#define EXTERN
Definition: def.h:88
SCIP_RETCODE SCIPcreateCutpool(SCIP *scip, SCIP_CUTPOOL **cutpool, int agelimit)
Definition: scip_cut.c:506
SCIP_RETCODE SCIPfreeCutpool(SCIP *scip, SCIP_CUTPOOL **cutpool)
Definition: scip_cut.c:537
SCIP_RETCODE SCIPseparateCutpool(SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_RESULT *result)
Definition: scip_cut.c:624
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:179
EXTERN SCIP_DEPRECATED SCIP_RETCODE SCIPaddCut(SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut, SCIP_Bool forcecut, SCIP_Bool *infeasible)
Definition: scip_cut.c:271
internal miscellaneous methods
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:778
SCIP_CUTPOOL * SCIPgetDelayedGlobalCutpool(SCIP *scip)
Definition: scip_cut.c:754
internal methods for global SCIP settings
#define SCIP_DEPRECATED
Definition: def.h:416
SCIP main data structure.
SCIP_RETCODE SCIPremoveInefficaciousCuts(SCIP *scip)
Definition: scip_cut.c:866
SCIP_RETCODE SCIPaddRow(SCIP *scip, SCIP_ROW *row, SCIP_Bool forcecut, SCIP_Bool *infeasible)
Definition: scip_cut.c:294
internal methods for problem variables
#define SCIP_Bool
Definition: def.h:62
SCIP_RETCODE SCIPaddPoolCut(SCIP *scip, SCIP_ROW *row)
Definition: scip_cut.c:405
methods for debugging
SCIP_Real SCIPgetCutEfficacy(SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut)
Definition: scip_cut.c:138
datastructures for problem statistics
SCIP_Bool SCIPisCutApplicable(SCIP *scip, SCIP_ROW *cut)
Definition: scip_cut.c:251
SCIP_Bool SCIPisCutNew(SCIP *scip, SCIP_ROW *row)
Definition: scip_cut.c:387
type definitions for storing primal CIP solutions
SCIP_RETCODE SCIPdelDelayedPoolCut(SCIP *scip, SCIP_ROW *row)
Definition: scip_cut.c:703
SCIP_RETCODE SCIPaddRowCutpool(SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_ROW *row)
Definition: scip_cut.c:558
internal methods for main solving loop and node processing
int SCIPgetNCuts(SCIP *scip)
Definition: scip_cut.c:830
#define SCIP_Real
Definition: def.h:150
result codes for SCIP callback methods
int SCIPgetNPoolCuts(SCIP *scip)
Definition: scip_cut.c:464
internal methods for constraints and constraint handlers
common defines and data types used in all packages of SCIP
SCIP_CUTPOOL * SCIPgetGlobalCutpool(SCIP *scip)
Definition: scip_cut.c:482
SCIP_ROW ** SCIPgetCuts(SCIP *scip)
Definition: scip_cut.c:812
SCIP_RETCODE SCIPseparateSolCutpool(SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_SOL *sol, SCIP_RESULT *result)
Definition: scip_cut.c:654