Scippy

SCIP

Solving Constraint Integer Programs

cuts.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-2017 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 email to scip@zib.de. */
13 /* */
14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15 
16 /**@file cuts.h
17  * @ingroup PUBLICCOREAPI
18  * @brief methods for the aggregation rows
19  * @author Jakob Witzig
20  * @author Robert Lion Gottwald
21  *
22  */
23 
24 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
25 
26 #ifndef __SCIP_CUTS_H__
27 #define __SCIP_CUTS_H__
28 
29 #include "scip/def.h"
30 #include "scip/set.h"
31 #include "scip/type_cuts.h"
32 #include "scip/struct_cuts.h"
33 
34 #ifdef __cplusplus
35 extern "C" {
36 #endif
37 
38 /**@addtogroup PublicCutMethods
39  *
40  * @{
41  */
42 
43 /** perform activity based coefficient tigthening on the given cut; returns TRUE if the cut was detected
44  * to be redundant due to acitvity bounds
45  */
46 extern
48  SCIP* scip, /**< SCIP data structure */
49  SCIP_Bool cutislocal, /**< is the cut local? */
50  SCIP_Real* cutcoefs, /**< array of the non-zero coefficients in the cut */
51  SCIP_Real* cutrhs, /**< the right hand side of the cut */
52  int* cutinds, /**< array of the problem indices of variables with a non-zero coefficient in the cut */
53  int* cutnnz, /**< the number of non-zeros in the cut */
54  int* nchgcoefs /**< number of changed coefficients */
55  );
56 
57 /** create an empty the aggregation row */
58 extern
60  SCIP* scip, /**< SCIP data structure */
61  SCIP_AGGRROW** aggrrow /**< pointer to return the aggregation row */
62  );
63 
64 /** free a the aggregation row */
65 extern
66 void SCIPaggrRowFree(
67  SCIP* scip, /**< SCIP data structure */
68  SCIP_AGGRROW** aggrrow /**< pointer to the aggregation row that should be freed */
69  );
70 
71 /** output aggregation row to file stream */
72 extern
73 void SCIPaggrRowPrint(
74  SCIP* scip, /**< SCIP data structure */
75  SCIP_AGGRROW* aggrrow, /**< pointer to return aggregation row */
76  FILE* file /**< output file (or NULL for standard output) */
77  );
78 
79 /** copy the aggregation row */
80 extern
82  SCIP* scip, /**< SCIP data structure */
83  SCIP_AGGRROW** aggrrow, /**< pointer to return the aggregation row */
84  SCIP_AGGRROW* source /**< source the aggregation row */
85  );
86 
87 /** add weighted row to the aggregation row */
88 extern
90  SCIP* scip, /**< SCIP data structure */
91  SCIP_AGGRROW* aggrrow, /**< the aggregation row */
92  SCIP_ROW* row, /**< row to add to the aggregation row */
93  SCIP_Real weight, /**< scale for adding given row to the aggregation row */
94  int sidetype /**< specify row side type (-1 = lhs, 0 = automatic, 1 = rhs) */
95  );
96 
97 /** Removes a given variable @p var from position @p pos the aggregation row and updates the right-hand side according
98  * to sign of the coefficient, i.e., rhs -= coef * bound, where bound = lb if coef >= 0 and bound = ub, otherwise.
99  *
100  * @note: The choice of global or local bounds depend on the validity (global or local) of the aggregation row.
101  *
102  * @note: The list of non-zero indices will be updated by swapping the last non-zero index to @p pos.
103  */
104 extern
106  SCIP* scip, /**< SCIP data structure */
107  SCIP_AGGRROW* aggrrow, /**< the aggregation row */
108  SCIP_VAR* var, /**< variable that should be removed */
109  int pos, /**< position of the variable in the aggregation row */
110  SCIP_Bool* valid /**< pointer to return whether the aggregation row is still valid */
111  );
112 
113 /** add the objective function with right-hand side @p rhs and scaled by @p scale to the aggregation row */
114 extern
116  SCIP* scip, /**< SCIP data structure */
117  SCIP_AGGRROW* aggrrow, /**< the aggregation row */
118  SCIP_Real rhs, /**< right-hand side of the artificial row */
119  SCIP_Real scale /**< scalar */
120  );
121 
122 /** add weighted constraint to the aggregation row */
123 extern
125  SCIP* scip, /**< SCIP data structure */
126  SCIP_AGGRROW* aggrrow, /**< the aggregation row */
127  int* inds, /**< variable problem indices in constraint to add to the aggregation row */
128  SCIP_Real* vals, /**< values of constraint to add to the aggregation row */
129  int len, /**< length of constraint to add to the aggregation row */
130  SCIP_Real rhs, /**< right hand side of constraint to add to the aggregation row */
131  SCIP_Real weight, /**< (positive) scale for adding given constraint to the aggregation row */
132  int rank, /**< rank to use for given constraint */
133  SCIP_Bool local /**< is constraint only valid locally */
134  );
135 
136 /** calculates the efficacy norm of the given aggregation row, which depends on the "separating/efficacynorm" parameter
137  *
138  * @return the efficacy norm of the given aggregation row, which depends on the "separating/efficacynorm" parameter
139  */
140 extern
142  SCIP* scip, /**< SCIP data structure */
143  SCIP_AGGRROW* aggrrow /**< the aggregation row */
144  );
145 
146 /** clear all entries in the aggregation row but do not free the internal memory */
147 extern
148 void SCIPaggrRowClear(
149  SCIP_AGGRROW* aggrrow /**< the aggregation row */
150  );
151 
152 /** aggregate rows using the given weights; the current content of the aggregation
153  * row, \p aggrrow, gets overwritten
154  */
155 extern
157  SCIP* scip, /**< SCIP data structure */
158  SCIP_AGGRROW* aggrrow, /**< the aggregation row */
159  SCIP_Real* weights, /**< row weights in row summation */
160  int* rowinds, /**< array to store indices of non-zero entries of the weights array, or NULL */
161  int nrowinds, /**< number of non-zero entries in weights array, -1 if rowinds is NULL */
162  SCIP_Bool sidetypebasis, /**< choose sidetypes of row (lhs/rhs) based on basis information? */
163  SCIP_Bool allowlocal, /**< should local rows be used? */
164  int negslack, /**< should negative slack variables be used? (0: no, 1: only for integral rows, 2: yes) */
165  int maxaggrlen, /**< maximal number of non-zeros in the aggregation row */
166  SCIP_Bool* valid /**< is the aggregation valid */
167  );
168 
169 /** removes all (close enough to) zero entries in the aggregation row */
170 extern
172  SCIP* scip, /**< SCIP datastructure */
173  SCIP_AGGRROW* aggrrow, /**< the aggregation row */
174  SCIP_Bool* valid /**< pointer to return whether the aggregation row is still valid */
175  );
176 
177 /** get array with lp positions of aggregated rows */
178 extern
180  SCIP_AGGRROW* aggrrow /**< the aggregation row */
181  );
182 
183 /** get array with weights of aggregated rows */
184 extern
186  SCIP_AGGRROW* aggrrow /**< the aggregation row */
187  );
188 
189 /** checks whether a given row has been added to the aggregation row */
190 extern
192  SCIP_AGGRROW* aggrrow, /**< the aggregation row */
193  SCIP_ROW* row /**< row for which it is checked whether it has been added to the aggregation */
194  );
195 
196 /** gets the min and max absolute value of the weights used to aggregate the rows;
197  * must not be called for empty aggregation rows
198  */
199 extern
201  SCIP_AGGRROW* aggrrow, /**< the aggregation row */
202  SCIP_Real* minabsrowweight, /**< pointer to store smallest absolute value of weights used for aggregating rows */
203  SCIP_Real* maxabsrowweight /**< pointer to store largest absolute value of weights used for aggregating rows */
204  );
205 
206 /** gets the array of corresponding variable problem indices for each non-zero in the aggregation row */
207 extern
208 int* SCIPaggrRowGetInds(
209  SCIP_AGGRROW* aggrrow
210  );
211 
212 /** gets the number of non-zeros in the aggregation row */
213 extern
215  SCIP_AGGRROW* aggrrow /**< the aggregation row */
216  );
217 
218 /** gets the non-zero value for the given non-zero index */
219 static INLINE
221  SCIP_AGGRROW* aggrrow, /**< the aggregation row */
222  int i /**< non-zero index; must be between 0 and SCIPaggrRowGetNNz(aggrrow) - 1 */
223  )
224 {
225  SCIP_Real QUAD(val);
226 
227  QUAD_ARRAY_LOAD(val, aggrrow->vals, aggrrow->inds[i]);
228 
229  return QUAD_TO_DBL(val);
230 }
231 
232 /** gets the non-zero value for the given problem index of a variable */
233 static INLINE
235  SCIP_AGGRROW* aggrrow, /**< the aggregation row */
236  int probindex /**< problem index of variable; must be between 0 and SCIPgetNVars(scip) - 1 */
237  )
238 {
239  SCIP_Real QUAD(val);
240 
241  QUAD_ARRAY_LOAD(val, aggrrow->vals, probindex);
242 
243  return QUAD_TO_DBL(val);
244 }
245 
246 /** gets the rank of the aggregation row */
247 extern
249  SCIP_AGGRROW* aggrrow /**< the aggregation row */
250  );
251 
252 /** checks if the aggregation row is only valid locally */
253 extern
255  SCIP_AGGRROW* aggrrow /**< the aggregation row */
256  );
257 
258 /** gets the right hand side of the aggregation row */
259 extern
261  SCIP_AGGRROW* aggrrow /**< the aggregation row */
262  );
263 
264 /** gets the number of row aggregations */
265 extern
267  SCIP_AGGRROW* aggrrow /**< aggregation row */
268  );
269 
270 /** calculates an MIR cut out of the weighted sum of LP rows given by an aggregation row; the
271  * aggregation row must not contain non-zero weights for modifiable rows, because these rows cannot
272  * participate in an MIR cut.
273  *
274  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
275  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
276  *
277  * @pre This method can be called if @p scip is in one of the following stages:
278  * - \ref SCIP_STAGE_SOLVING
279  *
280  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
281  */
282 extern
284  SCIP* scip, /**< SCIP data structure */
285  SCIP_SOL* sol, /**< the solution that should be separated, or NULL for LP solution */
286  SCIP_Bool postprocess, /**< apply a post-processing step to the resulting cut? */
287  SCIP_Real boundswitch, /**< fraction of domain up to which lower bound is used in transformation */
288  SCIP_Bool usevbds, /**< should variable bounds be used in bound transformation? */
289  SCIP_Bool allowlocal, /**< should local information allowed to be used, resulting in a local cut? */
290  SCIP_Bool fixintegralrhs, /**< should complementation tried to be adjusted such that rhs gets fractional? */
291  int* boundsfortrans, /**< bounds that should be used for transformed variables: vlb_idx/vub_idx,
292  * -1 for global lb/ub, -2 for local lb/ub, or -3 for using closest bound;
293  * NULL for using closest bound for all variables */
294  SCIP_BOUNDTYPE* boundtypesfortrans, /**< type of bounds that should be used for transformed variables;
295  * NULL for using closest bound for all variables */
296  SCIP_Real minfrac, /**< minimal fractionality of rhs to produce MIR cut for */
297  SCIP_Real maxfrac, /**< maximal fractionality of rhs to produce MIR cut for */
298  SCIP_Real scale, /**< additional scaling factor multiplied to the aggrrow; must be positive */
299  SCIP_AGGRROW* aggrrow, /**< the aggregation row to compute an MIR cut for */
300  SCIP_Real* cutcoefs, /**< array to store the non-zero coefficients in the cut */
301  SCIP_Real* cutrhs, /**< pointer to store the right hand side of the cut */
302  int* cutinds, /**< array to store the problem indices of variables with a non-zero coefficient in the cut */
303  int* cutnnz, /**< pointer to store the number of non-zeros in the cut */
304  SCIP_Real* cutefficacy, /**< pointer to store the efficacy of the cut, or NULL */
305  int* cutrank, /**< pointer to return rank of generated cut */
306  SCIP_Bool* cutislocal, /**< pointer to store whether the generated cut is only valid locally */
307  SCIP_Bool* success /**< pointer to store whether the returned coefficients are a valid MIR cut */
308  );
309 
310 /** calculates an MIR cut out of the weighted sum of LP rows given by an aggregation row; the
311  * aggregation row must not contain non-zero weights for modifiable rows, because these rows cannot
312  * participate in an MIR cut. The function uses a cut generation heuristic which tries different scaling
313  * factors and complementations of the variables to improve the cut's efficacy.
314  * For further details we refer to:
315  *
316  * Marchand, H., & Wolsey, L. A. (2001). Aggregation and mixed integer rounding to solve MIPs.
317  * Operations research, 49(3), 363-371.
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_SOLVING
324  *
325  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
326  */
327 extern
329  SCIP* scip, /**< SCIP data structure */
330  SCIP_SOL* sol, /**< the solution that should be separated, or NULL for LP solution */
331  SCIP_Bool postprocess, /**< apply a post-processing step to the resulting cut? */
332  SCIP_Real boundswitch, /**< fraction of domain up to which lower bound is used in transformation */
333  SCIP_Bool usevbds, /**< should variable bounds be used in bound transformation? */
334  SCIP_Bool allowlocal, /**< should local information allowed to be used, resulting in a local cut? */
335  int maxtestdelta, /**< maximum number of deltas to test */
336  int* boundsfortrans, /**< bounds that should be used for transformed variables: vlb_idx/vub_idx,
337  * -1 for global lb/ub, -2 for local lb/ub, or -3 for using closest bound;
338  * NULL for using closest bound for all variables */
339  SCIP_BOUNDTYPE* boundtypesfortrans, /**< type of bounds that should be used for transformed variables;
340  * NULL for using closest bound for all variables */
341  SCIP_Real minfrac, /**< minimal fractionality of rhs to produce MIR cut for */
342  SCIP_Real maxfrac, /**< maximal fractionality of rhs to produce MIR cut for */
343  SCIP_AGGRROW* aggrrow, /**< the aggregation row to compute MIR cut for */
344  SCIP_Real* cutcoefs, /**< array to store the non-zero coefficients in the cut */
345  SCIP_Real* cutrhs, /**< pointer to store the right hand side of the cut */
346  int* cutinds, /**< array to store the problem indices of variables with a non-zero coefficient in the cut */
347  int* cutnnz, /**< pointer to store the number of non-zeros in the cut */
348  SCIP_Real* cutefficacy, /**< pointer to store efficacy of best cut; only cuts that are strictly better than the value of
349  * this efficacy on input to this function are returned */
350  int* cutrank, /**< pointer to return rank of generated cut */
351  SCIP_Bool* cutislocal, /**< pointer to store whether the generated cut is only valid locally */
352  SCIP_Bool* success /**< pointer to store whether a valid and efficacious cut was returned */
353  );
354 
355 /** calculates a lifted simple generalized flow cover cut out of the weighted sum of LP rows given by an aggregation row; the
356  * aggregation row must not contain non-zero weights for modifiable rows, because these rows cannot
357  * participate in an MIR cut.
358  * For further details we refer to:
359  *
360  * Gu, Z., Nemhauser, G. L., & Savelsbergh, M. W. (1999). Lifted flow cover inequalities for mixed 0-1 integer programs.
361  * Mathematical Programming, 85(3), 439-467.
362  *
363  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
364  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
365  *
366  * @pre This method can be called if @p scip is in one of the following stages:
367  * - \ref SCIP_STAGE_SOLVING
368  *
369  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
370  */
371 extern
373  SCIP* scip, /**< SCIP data structure */
374  SCIP_SOL* sol, /**< the solution that should be separated, or NULL for LP solution */
375  SCIP_Bool postprocess, /**< apply a post-processing step to the resulting cut? */
376  SCIP_Real boundswitch, /**< fraction of domain up to which lower bound is used in transformation */
377  SCIP_Bool allowlocal, /**< should local information allowed to be used, resulting in a local cut? */
378  SCIP_AGGRROW* aggrrow, /**< the aggregation row to compute flow cover cut for */
379  SCIP_Real* cutcoefs, /**< array to store the non-zero coefficients in the cut */
380  SCIP_Real* cutrhs, /**< pointer to store the right hand side of the cut */
381  int* cutinds, /**< array to store the problem indices of variables with a non-zero coefficient in the cut */
382  int* cutnnz, /**< pointer to store the number of non-zeros in the cut */
383  SCIP_Real* cutefficacy, /**< pointer to store the efficacy of the cut, or NULL */
384  int* cutrank, /**< pointer to return rank of generated cut */
385  SCIP_Bool* cutislocal, /**< pointer to store whether the generated cut is only valid locally */
386  SCIP_Bool* success /**< pointer to store whether a valid cut was returned */
387  );
388 
389 /** calculates a strong CG cut out of the weighted sum of LP rows given by an aggregation row; the
390  * aggregation row must not contain non-zero weights for modifiable rows, because these rows cannot
391  * participate in a strongcg cut
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 in one of the following stages:
397  * - \ref SCIP_STAGE_SOLVING
398  *
399  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
400  */
401 extern
403  SCIP* scip, /**< SCIP data structure */
404  SCIP_SOL* sol, /**< the solution that should be separated, or NULL for LP solution */
405  SCIP_Bool postprocess, /**< apply a post-processing step to the resulting cut? */
406  SCIP_Real boundswitch, /**< fraction of domain up to which lower bound is used in transformation */
407  SCIP_Bool usevbds, /**< should variable bounds be used in bound transformation? */
408  SCIP_Bool allowlocal, /**< should local information allowed to be used, resulting in a local cut? */
409  SCIP_Real minfrac, /**< minimal fractionality of rhs to produce strong CG cut for */
410  SCIP_Real maxfrac, /**< maximal fractionality of rhs to produce strong CG cut for */
411  SCIP_Real scale, /**< additional scaling factor multiplied to all rows */
412  SCIP_AGGRROW* aggrrow, /**< the aggregation row to compute a strong CG cut for */
413  SCIP_Real* cutcoefs, /**< array to store the non-zero coefficients in the cut */
414  SCIP_Real* cutrhs, /**< pointer to store the right hand side of the cut */
415  int* cutinds, /**< array to store the problem indices of variables with a non-zero coefficient in the cut */
416  int* cutnnz, /**< pointer to store the number of non-zeros in the cut */
417  SCIP_Real* cutefficacy, /**< pointer to store the efficacy of the cut, or NULL */
418  int* cutrank, /**< pointer to return rank of generated cut */
419  SCIP_Bool* cutislocal, /**< pointer to store whether the generated cut is only valid locally */
420  SCIP_Bool* success /**< pointer to store whether a valid cut was returned */
421  );
422 
423 /* @} */
424 
425 #ifdef __cplusplus
426 }
427 #endif
428 
429 #endif
enum SCIP_BoundType SCIP_BOUNDTYPE
Definition: type_lp.h:50
SCIP_RETCODE SCIPcalcStrongCG(SCIP *scip, SCIP_SOL *sol, SCIP_Bool postprocess, SCIP_Real boundswitch, SCIP_Bool usevbds, SCIP_Bool allowlocal, SCIP_Real minfrac, SCIP_Real maxfrac, SCIP_Real scale, SCIP_AGGRROW *aggrrow, SCIP_Real *cutcoefs, SCIP_Real *cutrhs, int *cutinds, int *cutnnz, SCIP_Real *cutefficacy, int *cutrank, SCIP_Bool *cutislocal, SCIP_Bool *success)
Definition: cuts.c:7891
void SCIPaggrRowFree(SCIP *scip, SCIP_AGGRROW **aggrrow)
Definition: cuts.c:1567
int SCIPaggrRowGetNRows(SCIP_AGGRROW *aggrrow)
Definition: cuts.c:2278
SCIP_RETCODE SCIPaggrRowAddRow(SCIP *scip, SCIP_AGGRROW *aggrrow, SCIP_ROW *row, SCIP_Real weight, int sidetype)
Definition: cuts.c:1670
void SCIPaggrRowCancelVarWithBound(SCIP *scip, SCIP_AGGRROW *aggrrow, SCIP_VAR *var, int pos, SCIP_Bool *valid)
Definition: cuts.c:1757
#define INLINE
Definition: def.h:96
SCIP_Bool SCIPaggrRowIsLocal(SCIP_AGGRROW *aggrrow)
Definition: cuts.c:2361
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:53
SCIP_RETCODE SCIPcutGenerationHeuristicCMIR(SCIP *scip, SCIP_SOL *sol, SCIP_Bool postprocess, SCIP_Real boundswitch, SCIP_Bool usevbds, SCIP_Bool allowlocal, int maxtestdelta, int *boundsfortrans, SCIP_BOUNDTYPE *boundtypesfortrans, SCIP_Real minfrac, SCIP_Real maxfrac, SCIP_AGGRROW *aggrrow, SCIP_Real *cutcoefs, SCIP_Real *cutrhs, int *cutinds, int *cutnnz, SCIP_Real *cutefficacy, int *cutrank, SCIP_Bool *cutislocal, SCIP_Bool *success)
Definition: cuts.c:3951
type definitions for cuts
int SCIPaggrRowGetNNz(SCIP_AGGRROW *aggrrow)
Definition: cuts.c:2341
SCIP_Real SCIPaggrRowGetRhs(SCIP_AGGRROW *aggrrow)
Definition: cuts.c:2371
void SCIPaggrRowPrint(SCIP *scip, SCIP_AGGRROW *aggrrow, FILE *file)
Definition: cuts.c:1587
#define QUAD_TO_DBL(x)
Definition: dbldblarith.h:40
SCIP_Bool SCIPaggrRowHasRowBeenAdded(SCIP_AGGRROW *aggrrow, SCIP_ROW *row)
Definition: cuts.c:2310
SCIP_RETCODE SCIPaggrRowAddObjectiveFunction(SCIP *scip, SCIP_AGGRROW *aggrrow, SCIP_Real rhs, SCIP_Real scale)
Definition: cuts.c:1814
int * SCIPaggrRowGetRowInds(SCIP_AGGRROW *aggrrow)
Definition: cuts.c:2288
#define QUAD(x)
Definition: dbldblarith.h:38
int SCIPaggrRowGetRank(SCIP_AGGRROW *aggrrow)
Definition: cuts.c:2351
int * SCIPaggrRowGetInds(SCIP_AGGRROW *aggrrow)
Definition: cuts.c:2331
void SCIPaggrRowRemoveZeros(SCIP *scip, SCIP_AGGRROW *aggrrow, SCIP_Bool *valid)
Definition: cuts.c:2266
#define QUAD_ARRAY_LOAD(r, a, idx)
Definition: dbldblarith.h:45
internal methods for global SCIP settings
SCIP_RETCODE SCIPaggrRowAddCustomCons(SCIP *scip, SCIP_AGGRROW *aggrrow, int *inds, SCIP_Real *vals, int len, SCIP_Real rhs, SCIP_Real weight, int rank, SCIP_Bool local)
Definition: cuts.c:1885
SCIP_RETCODE SCIPcalcMIR(SCIP *scip, SCIP_SOL *sol, SCIP_Bool postprocess, SCIP_Real boundswitch, SCIP_Bool usevbds, SCIP_Bool allowlocal, SCIP_Bool fixintegralrhs, int *boundsfortrans, SCIP_BOUNDTYPE *boundtypesfortrans, SCIP_Real minfrac, SCIP_Real maxfrac, SCIP_Real scale, SCIP_AGGRROW *aggrrow, SCIP_Real *cutcoefs, SCIP_Real *cutrhs, int *cutinds, int *cutnnz, SCIP_Real *cutefficacy, int *cutrank, SCIP_Bool *cutislocal, SCIP_Bool *success)
Definition: cuts.c:3634
#define SCIP_Bool
Definition: def.h:61
SCIP_Real SCIPaggrRowCalcEfficacyNorm(SCIP *scip, SCIP_AGGRROW *aggrrow)
Definition: cuts.c:1960
SCIP_Bool SCIPcutsTightenCoefficients(SCIP *scip, SCIP_Bool cutislocal, SCIP_Real *cutcoefs, SCIP_Real *cutrhs, int *cutinds, int *cutnnz, int *nchgcoefs)
Definition: cuts.c:1334
SCIP_RETCODE SCIPcalcFlowCover(SCIP *scip, SCIP_SOL *sol, SCIP_Bool postprocess, SCIP_Real boundswitch, SCIP_Bool allowlocal, SCIP_AGGRROW *aggrrow, SCIP_Real *cutcoefs, SCIP_Real *cutrhs, int *cutinds, int *cutnnz, SCIP_Real *cutefficacy, int *cutrank, SCIP_Bool *cutislocal, SCIP_Bool *success)
Definition: cuts.c:7084
SCIP_Real * SCIPaggrRowGetRowWeights(SCIP_AGGRROW *aggrrow)
Definition: cuts.c:2299
SCIP_Real * vals
Definition: struct_cuts.h:33
SCIP_RETCODE SCIPaggrRowCopy(SCIP *scip, SCIP_AGGRROW **aggrrow, SCIP_AGGRROW *source)
Definition: cuts.c:1624
void SCIPaggrRowGetAbsWeightRange(SCIP_AGGRROW *aggrrow, SCIP_Real *minabsrowweight, SCIP_Real *maxabsrowweight)
SCIP_RETCODE SCIPaggrRowSumRows(SCIP *scip, SCIP_AGGRROW *aggrrow, SCIP_Real *weights, int *rowinds, int nrowinds, SCIP_Bool sidetypebasis, SCIP_Bool allowlocal, int negslack, int maxaggrlen, SCIP_Bool *valid)
Definition: cuts.c:2087
#define SCIP_Real
Definition: def.h:149
SCIP_RETCODE SCIPaggrRowCreate(SCIP *scip, SCIP_AGGRROW **aggrrow)
Definition: cuts.c:1535
static INLINE SCIP_Real SCIPaggrRowGetProbvarValue(SCIP_AGGRROW *aggrrow, int probindex)
Definition: cuts.h:234
common defines and data types used in all packages of SCIP
void SCIPaggrRowClear(SCIP_AGGRROW *aggrrow)
Definition: cuts.c:1935
static INLINE SCIP_Real SCIPaggrRowGetValue(SCIP_AGGRROW *aggrrow, int i)
Definition: cuts.h:220
struct definitions for cuts