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 2002-2022 Zuse Institute Berlin */
7 /* */
8 /* Licensed under the Apache License, Version 2.0 (the "License"); */
9 /* you may not use this file except in compliance with the License. */
10 /* You may obtain a copy of the License at */
11 /* */
12 /* http://www.apache.org/licenses/LICENSE-2.0 */
13 /* */
14 /* Unless required by applicable law or agreed to in writing, software */
15 /* distributed under the License is distributed on an "AS IS" BASIS, */
16 /* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */
17 /* See the License for the specific language governing permissions and */
18 /* limitations under the License. */
19 /* */
20 /* You should have received a copy of the Apache-2.0 license */
21 /* along with SCIP; see the file LICENSE. If not visit scipopt.org. */
22 /* */
23 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
24 
25 /**@file scip_cut.h
26  * @ingroup PUBLICCOREAPI
27  * @brief public methods for cuts and aggregation rows
28  * @author Tobias Achterberg
29  * @author Timo Berthold
30  * @author Thorsten Koch
31  * @author Alexander Martin
32  * @author Marc Pfetsch
33  * @author Kati Wolter
34  * @author Gregor Hendel
35  * @author Leona Gottwald
36  */
37 
38 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
39 
40 #ifndef __SCIP_SCIP_CUT_H__
41 #define __SCIP_SCIP_CUT_H__
42 
43 
44 #include "scip/def.h"
45 #include "scip/type_cutpool.h"
46 #include "scip/type_lp.h"
47 #include "scip/type_result.h"
48 #include "scip/type_retcode.h"
49 #include "scip/type_scip.h"
50 #include "scip/type_sol.h"
51 
52 #ifdef __cplusplus
53 extern "C" {
54 #endif
55 
56 /**@addtogroup PublicCutMethods
57  *
58  * @{
59  */
60 
61 /** returns row's cutoff distance in the direction of the given primal solution
62  *
63  * @return the cutoff distance of the cut with respect to the LP solution in the direction of the given primal solution
64  *
65  * @pre This method can be called if @p scip is in one of the following stages:
66  * - \ref SCIP_STAGE_SOLVING
67  */
68 SCIP_EXPORT
70  SCIP* scip, /**< SCIP data structure */
71  SCIP_SOL* sol, /**< solution to compute direction for cutoff distance; must not be NULL */
72  SCIP_ROW* cut /**< separated cut */
73  );
74 
75 /** returns efficacy of the cut with respect to the given primal solution or the current LP solution:
76  * e = -feasibility/norm
77  *
78  * @return the efficacy of the cut with respect to the given primal solution or the current LP solution:
79  * e = -feasibility/norm
80  *
81  * @pre This method can be called if @p scip is in one of the following stages:
82  * - \ref SCIP_STAGE_SOLVING
83  */
84 SCIP_EXPORT
86  SCIP* scip, /**< SCIP data structure */
87  SCIP_SOL* sol, /**< primal CIP solution, or NULL for current LP solution */
88  SCIP_ROW* cut /**< separated cut */
89  );
90 
91 /** returns whether the cut's efficacy with respect to the given primal solution or the current LP solution is greater
92  * than the minimal cut efficacy
93  *
94  * @return TRUE if the cut's efficacy with respect to the given primal solution or the current LP solution is greater
95  * than the minimal cut efficacy, otherwise FALSE
96  *
97  * @pre This method can be called if @p scip is in one of the following stages:
98  * - \ref SCIP_STAGE_SOLVING
99  */
100 SCIP_EXPORT
102  SCIP* scip, /**< SCIP data structure */
103  SCIP_SOL* sol, /**< primal CIP solution, or NULL for current LP solution */
104  SCIP_ROW* cut /**< separated cut */
105  );
106 
107 /** checks, if the given cut's efficacy is larger than the minimal cut efficacy
108  *
109  * @return TRUE if the given cut's efficacy is larger than the minimal cut efficacy, otherwise FALSE
110  */
111 SCIP_EXPORT
113  SCIP* scip, /**< SCIP data structure */
114  SCIP_Real efficacy /**< efficacy of the cut */
115  );
116 
117 /** calculates the efficacy norm of the given vector, which depends on the "separating/efficacynorm" parameter
118  *
119  * @return the efficacy norm of the given vector, which depends on the "separating/efficacynorm" parameter
120  */
121 SCIP_EXPORT
123  SCIP* scip, /**< SCIP data structure */
124  SCIP_Real* vals, /**< array of values */
125  int nvals /**< number of values */
126  );
127 
128 /** indicates whether a cut is applicable
129  *
130  * If the cut has only one variable and this method returns FALSE, it may
131  * still be possible that the cut can be added to the LP (as a row instead
132  * of a boundchange), but it will be a very weak cut. The user is asked
133  * to avoid such cuts.
134  *
135  * @pre This method can be called if @p scip is in one of the following stages:
136  * - \ref SCIP_STAGE_SOLVING
137  *
138  * @return whether the cut is modifiable, not a bound change, or a bound change that changes bounds by at least epsilon
139  */
140 SCIP_EXPORT
142  SCIP* scip, /**< SCIP data structure */
143  SCIP_ROW* cut /**< separated cut */
144  );
145 
146 /** adds cut to separation storage
147  *
148  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
149  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
150  *
151  * @pre This method can be called if @p scip is in one of the following stages:
152  * - \ref SCIP_STAGE_SOLVING
153  *
154  * @deprecated Please use SCIPaddRow() instead, or, if the row is a global cut and it might be useful to keep it for future use,
155  * consider adding it to the global cutpool with SCIPaddPoolCut().
156  */
158  SCIP* scip, /**< SCIP data structure */
159  SCIP_SOL* sol, /**< primal solution that was separated, or NULL for LP solution */
160  SCIP_ROW* cut, /**< separated cut */
161  SCIP_Bool forcecut, /**< should the cut be forced to enter the LP? */
162  SCIP_Bool* infeasible /**< pointer to store whether cut has been detected to be infeasible for local bounds */
163  );
164 
165 /** adds row to separation storage
166  *
167  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
168  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
169  *
170  * @pre This method can be called if @p scip is in one of the following stages:
171  * - \ref SCIP_STAGE_SOLVING
172  */
173 SCIP_EXPORT
175  SCIP* scip, /**< SCIP data structure */
176  SCIP_ROW* row, /**< row */
177  SCIP_Bool forcecut, /**< should the row be forced to enter the LP? */
178  SCIP_Bool* infeasible /**< pointer to store whether row has been detected to be infeasible for local bounds */
179  );
180 
181 /** checks if cut is already existing in global cutpool
182  *
183  * @return TRUE is returned if the cut is not already existing in the global cutpool, FALSE otherwise
184  *
185  * @pre This method can be called if @p scip is in one of the following stages:
186  * - \ref SCIP_STAGE_SOLVING
187  */
188 SCIP_EXPORT
190  SCIP* scip, /**< SCIP data structure */
191  SCIP_ROW* row /**< cutting plane to add */
192  );
193 
194 /** if not already existing, adds row to global cut pool
195  *
196  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
197  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
198  *
199  * @pre This method can be called if @p scip is in one of the following stages:
200  * - \ref SCIP_STAGE_SOLVING
201  */
202 SCIP_EXPORT
204  SCIP* scip, /**< SCIP data structure */
205  SCIP_ROW* row /**< cutting plane to add */
206  );
207 
208 /** removes the row from the global cut pool
209  *
210  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
211  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
212  *
213  * @pre This method can be called if @p scip is in one of the following stages:
214  * - \ref SCIP_STAGE_SOLVING
215  */
216 SCIP_EXPORT
218  SCIP* scip, /**< SCIP data structure */
219  SCIP_ROW* row /**< row to remove */
220  );
221 
222 /** gets current cuts in the global cut pool
223  *
224  * @return the current cuts in the global cut pool
225  *
226  * @pre This method can be called if @p scip is in one of the following stages:
227  * - \ref SCIP_STAGE_SOLVING
228  * - \ref SCIP_STAGE_SOLVED
229  * - \ref SCIP_STAGE_EXITSOLVE
230  */
231 SCIP_EXPORT
233  SCIP* scip /**< SCIP data structure */
234  );
235 
236 /** gets current number of rows in the global cut pool
237  *
238  * @return the current number of rows in the global cut pool
239  *
240  * @pre This method can be called if @p scip is in one of the following stages:
241  * - \ref SCIP_STAGE_SOLVING
242  * - \ref SCIP_STAGE_SOLVED
243  * - \ref SCIP_STAGE_EXITSOLVE
244  */
245 SCIP_EXPORT
246 int SCIPgetNPoolCuts(
247  SCIP* scip /**< SCIP data structure */
248  );
249 
250 /** gets the global cut pool used by SCIP
251  *
252  * @return the global cut pool used by SCIP
253  *
254  * @pre This method can be called if @p scip is in one of the following stages:
255  * - \ref SCIP_STAGE_SOLVING
256  * - \ref SCIP_STAGE_SOLVED
257  * - \ref SCIP_STAGE_EXITSOLVE
258  */
259 SCIP_EXPORT
261  SCIP* scip /**< SCIP data structure */
262  );
263 
264 /** creates a cut pool
265  *
266  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
267  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
268  *
269  * @pre This method can be called if @p scip is in one of the following stages:
270  * - \ref SCIP_STAGE_TRANSFORMING
271  * - \ref SCIP_STAGE_TRANSFORMED
272  * - \ref SCIP_STAGE_INITPRESOLVE
273  * - \ref SCIP_STAGE_PRESOLVING
274  * - \ref SCIP_STAGE_EXITPRESOLVE
275  * - \ref SCIP_STAGE_PRESOLVED
276  * - \ref SCIP_STAGE_INITSOLVE
277  * - \ref SCIP_STAGE_SOLVING
278  */
279 SCIP_EXPORT
281  SCIP* scip, /**< SCIP data structure */
282  SCIP_CUTPOOL** cutpool, /**< pointer to store cut pool */
283  int agelimit /**< maximum age a cut can reach before it is deleted from the pool */
284  );
285 
286 /** frees a cut pool
287  *
288  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
289  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
290  *
291  * @pre This method can be called if @p scip is in one of the following stages:
292  * - \ref SCIP_STAGE_TRANSFORMING
293  * - \ref SCIP_STAGE_TRANSFORMED
294  * - \ref SCIP_STAGE_INITPRESOLVE
295  * - \ref SCIP_STAGE_PRESOLVING
296  * - \ref SCIP_STAGE_EXITPRESOLVE
297  * - \ref SCIP_STAGE_PRESOLVED
298  * - \ref SCIP_STAGE_INITSOLVE
299  * - \ref SCIP_STAGE_SOLVING
300  * - \ref SCIP_STAGE_SOLVED
301  * - \ref SCIP_STAGE_EXITSOLVE
302  * - \ref SCIP_STAGE_FREETRANS
303  */
304 SCIP_EXPORT
306  SCIP* scip, /**< SCIP data structure */
307  SCIP_CUTPOOL** cutpool /**< pointer to store cut pool */
308  );
309 
310 /** if not already existing, adds row to a cut pool and captures it
311  *
312  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
313  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
314  *
315  * @pre This method can be called if @p scip is in one of the following stages:
316  * - \ref SCIP_STAGE_INITSOLVE
317  * - \ref SCIP_STAGE_SOLVING
318  */
319 SCIP_EXPORT
321  SCIP* scip, /**< SCIP data structure */
322  SCIP_CUTPOOL* cutpool, /**< cut pool */
323  SCIP_ROW* row /**< cutting plane to add */
324  );
325 
326 /** adds row to a cut pool and captures it; doesn't check for multiple cuts
327  *
328  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
329  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
330  *
331  * @pre This method can be called if @p scip is in one of the following stages:
332  * - \ref SCIP_STAGE_INITSOLVE
333  * - \ref SCIP_STAGE_SOLVING
334  */
335 SCIP_EXPORT
337  SCIP* scip, /**< SCIP data structure */
338  SCIP_CUTPOOL* cutpool, /**< cut pool */
339  SCIP_ROW* row /**< cutting plane to add */
340  );
341 
342 /** removes the LP row from a cut pool
343  *
344  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
345  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
346  *
347  * @pre This method can be called if @p scip is in one of the following stages:
348  * - \ref SCIP_STAGE_INITSOLVE
349  * - \ref SCIP_STAGE_SOLVING
350  * - \ref SCIP_STAGE_SOLVED
351  */
352 SCIP_EXPORT
354  SCIP* scip, /**< SCIP data structure */
355  SCIP_CUTPOOL* cutpool, /**< cut pool */
356  SCIP_ROW* row /**< row to remove */
357  );
358 
359 /** separates cuts from a cut pool
360  *
361  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
362  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
363  *
364  * @pre This method can be called if @p scip is in one of the following stages:
365  * - \ref SCIP_STAGE_SOLVING
366  */
367 SCIP_EXPORT
369  SCIP* scip, /**< SCIP data structure */
370  SCIP_CUTPOOL* cutpool, /**< cut pool */
371  SCIP_RESULT* result /**< pointer to store the result of the separation call */
372  );
373 
374 /** separates cuts w.r.t. given solution from a cut pool
375  *
376  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
377  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
378  *
379  * @pre This method can be called if @p scip is in one of the following stages:
380  * - \ref SCIP_STAGE_SOLVING
381  */
382 SCIP_EXPORT
384  SCIP* scip, /**< SCIP data structure */
385  SCIP_CUTPOOL* cutpool, /**< cut pool */
386  SCIP_SOL* sol, /**< solution to be separated */
387  SCIP_Bool pretendroot, /**< should the cut separators be called as if we are at the root node? */
388  SCIP_RESULT* result /**< pointer to store the result of the separation call */
389  );
390 
391 /** if not already existing, adds row to the delayed global cut pool
392  *
393  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
394  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
395  *
396  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
397  */
398 SCIP_EXPORT
400  SCIP* scip, /**< SCIP data structure */
401  SCIP_ROW* row /**< cutting plane to add */
402  );
403 
404 /** removes the row from the delayed global cut pool
405  *
406  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
407  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
408  *
409  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
410  */
411 SCIP_EXPORT
413  SCIP* scip, /**< SCIP data structure */
414  SCIP_ROW* row /**< cutting plane to add */
415  );
416 
417 /** gets current cuts in the delayed global cut pool
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  */
424 SCIP_EXPORT
426  SCIP* scip /**< SCIP data structure */
427  );
428 
429 /** gets current number of rows in the delayed global cut pool
430  *
431  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
432  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
433  *
434  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
435  */
436 SCIP_EXPORT
438  SCIP* scip /**< SCIP data structure */
439  );
440 
441 /** gets the delayed global cut pool used by SCIP
442  *
443  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
444  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
445  *
446  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
447  */
448 SCIP_EXPORT
450  SCIP* scip /**< SCIP data structure */
451  );
452 
453 /** separates the given primal solution or the current LP solution by calling the separators and constraint handlers'
454  * separation methods;
455  * the generated cuts are stored in the separation storage and can be accessed with the methods SCIPgetCuts() and
456  * SCIPgetNCuts();
457  * after evaluating the cuts, you have to call SCIPclearCuts() in order to remove the cuts from the
458  * separation storage;
459  * it is possible to call SCIPseparateSol() multiple times with different solutions and evaluate the found cuts
460  * afterwards
461  *
462  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
463  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
464  *
465  * @pre This method can be called if @p scip is in one of the following stages:
466  * - \ref SCIP_STAGE_SOLVING
467  */
468 SCIP_EXPORT
470  SCIP* scip, /**< SCIP data structure */
471  SCIP_SOL* sol, /**< primal solution that should be separated, or NULL for LP solution */
472  SCIP_Bool pretendroot, /**< should the cut separators be called as if we are at the root node? */
473  SCIP_Bool allowlocal, /**< should the separator be asked to separate local cuts */
474  SCIP_Bool onlydelayed, /**< should only separators be called that were delayed in the previous round? */
475  SCIP_Bool* delayed, /**< pointer to store whether a separator was delayed */
476  SCIP_Bool* cutoff /**< pointer to store whether the node can be cut off */
477  );
478 
479 /** gets the array of cuts currently stored in the separation storage
480  *
481  * @return the array of cuts currently stored in the separation storage
482  *
483  * @pre This method can be called if @p scip is in one of the following stages:
484  * - \ref SCIP_STAGE_PRESOLVED
485  * - \ref SCIP_STAGE_SOLVING
486  * - \ref SCIP_STAGE_SOLVED
487  */
488 SCIP_EXPORT
490  SCIP* scip /**< SCIP data structure */
491  );
492 
493 /** get current number of cuts in the separation storage
494  *
495  * @return the current number of cuts in the separation storage
496  *
497  * @pre This method can be called if @p scip is in one of the following stages:
498  * - \ref SCIP_STAGE_PRESOLVED
499  * - \ref SCIP_STAGE_SOLVING
500  * - \ref SCIP_STAGE_SOLVED
501  */
502 SCIP_EXPORT
503 int SCIPgetNCuts(
504  SCIP* scip /**< SCIP data structure */
505  );
506 
507 /** clears the separation storage
508  *
509  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
510  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
511  *
512  * @pre This method can be called if @p scip is in one of the following stages:
513  * - \ref SCIP_STAGE_SOLVING
514  */
515 SCIP_EXPORT
517  SCIP* scip /**< SCIP data structure */
518  );
519 
520 /** removes cuts that are inefficacious w.r.t. the current LP solution from separation storage without adding the cuts to the LP
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_SOLVING
527  */
528 SCIP_EXPORT
530  SCIP* scip /**< SCIP data structure */
531  );
532 
533 /**@} */
534 
535 #ifdef __cplusplus
536 }
537 #endif
538 
539 #endif
enum SCIP_Result SCIP_RESULT
Definition: type_result.h:61
SCIP_RETCODE SCIPclearCuts(SCIP *scip)
Definition: scip_cut.c:804
int SCIPgetNDelayedPoolCuts(SCIP *scip)
Definition: scip_cut.c:695
SCIP_RETCODE SCIPseparateSolCutpool(SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_SOL *sol, SCIP_Bool pretendroot, SCIP_RESULT *result)
Definition: scip_cut.c:610
SCIP_CUT ** SCIPgetDelayedPoolCuts(SCIP *scip)
Definition: scip_cut.c:679
SCIP_RETCODE SCIPaddNewRowCutpool(SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_ROW *row)
Definition: scip_cut.c:536
SCIP_RETCODE SCIPaddDelayedPoolCut(SCIP *scip, SCIP_ROW *row)
Definition: scip_cut.c:641
SCIP_RETCODE SCIPdelPoolCut(SCIP *scip, SCIP_ROW *row)
Definition: scip_cut.c:381
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:63
SCIP_Real SCIPgetVectorEfficacyNorm(SCIP *scip, SCIP_Real *vals, int nvals)
Definition: scip_cut.c:149
SCIP_Real SCIPgetCutLPSolCutoffDistance(SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut)
Definition: scip_cut.c:72
type definitions for return codes for SCIP methods
SCIP_CUT ** SCIPgetPoolCuts(SCIP *scip)
Definition: scip_cut.c:402
type definitions for LP management
SCIP_Bool SCIPisCutEfficacious(SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut)
Definition: scip_cut.c:117
SCIP_RETCODE SCIPdelRowCutpool(SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_ROW *row)
Definition: scip_cut.c:559
SCIP_RETCODE SCIPcreateCutpool(SCIP *scip, SCIP_CUTPOOL **cutpool, int agelimit)
Definition: scip_cut.c:462
SCIP_RETCODE SCIPfreeCutpool(SCIP *scip, SCIP_CUTPOOL **cutpool)
Definition: scip_cut.c:493
SCIP_RETCODE SCIPseparateCutpool(SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_RESULT *result)
Definition: scip_cut.c:580
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:135
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:735
SCIP_CUTPOOL * SCIPgetDelayedGlobalCutpool(SCIP *scip)
Definition: scip_cut.c:711
SCIP_RETCODE SCIPremoveInefficaciousCuts(SCIP *scip)
Definition: scip_cut.c:823
SCIP_RETCODE SCIPaddRow(SCIP *scip, SCIP_ROW *row, SCIP_Bool forcecut, SCIP_Bool *infeasible)
Definition: scip_cut.c:250
SCIP_RETCODE SCIPaddCut(SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut, SCIP_Bool forcecut, SCIP_Bool *infeasible)
Definition: scip_cut.c:227
#define SCIP_Bool
Definition: def.h:93
SCIP_RETCODE SCIPaddPoolCut(SCIP *scip, SCIP_ROW *row)
Definition: scip_cut.c:361
SCIP_Real SCIPgetCutEfficacy(SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut)
Definition: scip_cut.c:94
SCIP_Bool SCIPisCutApplicable(SCIP *scip, SCIP_ROW *cut)
Definition: scip_cut.c:207
SCIP_Bool SCIPisCutNew(SCIP *scip, SCIP_ROW *row)
Definition: scip_cut.c:343
type definitions for storing primal CIP solutions
SCIP_RETCODE SCIPdelDelayedPoolCut(SCIP *scip, SCIP_ROW *row)
Definition: scip_cut.c:660
SCIP_RETCODE SCIPaddRowCutpool(SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_ROW *row)
Definition: scip_cut.c:514
int SCIPgetNCuts(SCIP *scip)
Definition: scip_cut.c:787
#define SCIP_Real
Definition: def.h:186
result codes for SCIP callback methods
int SCIPgetNPoolCuts(SCIP *scip)
Definition: scip_cut.c:420
common defines and data types used in all packages of SCIP
SCIP_CUTPOOL * SCIPgetGlobalCutpool(SCIP *scip)
Definition: scip_cut.c:438
SCIP_ROW ** SCIPgetCuts(SCIP *scip)
Definition: scip_cut.c:769