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 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 cuts.h
26  * @ingroup PUBLICCOREAPI
27  * @brief methods for the aggregation rows
28  * @author Jakob Witzig
29  * @author Leona Gottwald
30  *
31  */
32 
33 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
34 
35 #ifndef __SCIP_CUTS_H__
36 #define __SCIP_CUTS_H__
37 
38 #include "scip/def.h"
39 #include "scip/struct_cuts.h"
40 #include "scip/type_cuts.h"
41 #include "scip/type_lp.h"
42 #include "scip/type_misc.h"
43 #include "scip/type_retcode.h"
44 #include "scip/type_scip.h"
45 #include "scip/type_sol.h"
46 #include "scip/type_var.h"
47 
48 #ifdef __cplusplus
49 extern "C" {
50 #endif
51 
52 /**@addtogroup PublicCutMethods
53  *
54  * @{
55  */
56 
57 /** perform activity based coefficient tigthening on the given cut; returns TRUE if the cut was detected
58  * to be redundant due to acitivity bounds
59  *
60  * See also cons_linear.c:consdataTightenCoefs().
61  */
62 SCIP_EXPORT
64  SCIP* scip, /**< SCIP data structure */
65  SCIP_Bool cutislocal, /**< is the cut local? */
66  SCIP_Real* cutcoefs, /**< array of the non-zero coefficients in the cut */
67  SCIP_Real* cutrhs, /**< the right hand side of the cut */
68  int* cutinds, /**< array of the problem indices of variables with a non-zero coefficient in the cut */
69  int* cutnnz, /**< the number of non-zeros in the cut */
70  int* nchgcoefs /**< number of changed coefficients */
71  );
72 
73 /** create an empty the aggregation row */
74 SCIP_EXPORT
76  SCIP* scip, /**< SCIP data structure */
77  SCIP_AGGRROW** aggrrow /**< pointer to return the aggregation row */
78  );
79 
80 /** free a the aggregation row */
81 SCIP_EXPORT
82 void SCIPaggrRowFree(
83  SCIP* scip, /**< SCIP data structure */
84  SCIP_AGGRROW** aggrrow /**< pointer to the aggregation row that should be freed */
85  );
86 
87 /** output aggregation row to file stream */
88 SCIP_EXPORT
89 void SCIPaggrRowPrint(
90  SCIP* scip, /**< SCIP data structure */
91  SCIP_AGGRROW* aggrrow, /**< pointer to return aggregation row */
92  FILE* file /**< output file (or NULL for standard output) */
93  );
94 
95 /** copy the aggregation row */
96 SCIP_EXPORT
98  SCIP* scip, /**< SCIP data structure */
99  SCIP_AGGRROW** aggrrow, /**< pointer to return the aggregation row */
100  SCIP_AGGRROW* source /**< source the aggregation row */
101  );
102 
103 /** add weighted row to the aggregation row */
104 SCIP_EXPORT
106  SCIP* scip, /**< SCIP data structure */
107  SCIP_AGGRROW* aggrrow, /**< the aggregation row */
108  SCIP_ROW* row, /**< row to add to the aggregation row */
109  SCIP_Real weight, /**< scale for adding given row to the aggregation row */
110  int sidetype /**< specify row side type (-1 = lhs, 0 = automatic, 1 = rhs) */
111  );
112 
113 /** Removes a given variable @p var from position @p pos the aggregation row and updates the right-hand side according
114  * to sign of the coefficient, i.e., rhs -= coef * bound, where bound = lb if coef >= 0 and bound = ub, otherwise.
115  *
116  * @note: The choice of global or local bounds depend on the validity (global or local) of the aggregation row.
117  *
118  * @note: The list of non-zero indices will be updated by swapping the last non-zero index to @p pos.
119  */
120 SCIP_EXPORT
122  SCIP* scip, /**< SCIP data structure */
123  SCIP_AGGRROW* aggrrow, /**< the aggregation row */
124  SCIP_VAR* var, /**< variable that should be removed */
125  int pos, /**< position of the variable in the aggregation row */
126  SCIP_Bool* valid /**< pointer to return whether the aggregation row is still valid */
127  );
128 
129 /** add the objective function with right-hand side @p rhs and scaled by @p scale to the aggregation row */
130 SCIP_EXPORT
132  SCIP* scip, /**< SCIP data structure */
133  SCIP_AGGRROW* aggrrow, /**< the aggregation row */
134  SCIP_Real rhs, /**< right-hand side of the artificial row */
135  SCIP_Real scale /**< scalar */
136  );
137 
138 /** add weighted constraint to the aggregation row */
139 SCIP_EXPORT
141  SCIP* scip, /**< SCIP data structure */
142  SCIP_AGGRROW* aggrrow, /**< the aggregation row */
143  int* inds, /**< variable problem indices in constraint to add to the aggregation row */
144  SCIP_Real* vals, /**< values of constraint to add to the aggregation row */
145  int len, /**< length of constraint to add to the aggregation row */
146  SCIP_Real rhs, /**< right hand side of constraint to add to the aggregation row */
147  SCIP_Real weight, /**< (positive) scale for adding given constraint to the aggregation row */
148  int rank, /**< rank to use for given constraint */
149  SCIP_Bool local /**< is constraint only valid locally */
150  );
151 
152 /** calculates the efficacy norm of the given aggregation row, which depends on the "separating/efficacynorm" parameter
153  *
154  * @return the efficacy norm of the given aggregation row, which depends on the "separating/efficacynorm" parameter
155  */
156 SCIP_EXPORT
158  SCIP* scip, /**< SCIP data structure */
159  SCIP_AGGRROW* aggrrow /**< the aggregation row */
160  );
161 
162 /** clear all entries in the aggregation row but do not free the internal memory */
163 SCIP_EXPORT
164 void SCIPaggrRowClear(
165  SCIP_AGGRROW* aggrrow /**< the aggregation row */
166  );
167 
168 /** aggregate rows using the given weights; the current content of the aggregation
169  * row, \p aggrrow, gets overwritten
170  */
171 SCIP_EXPORT
173  SCIP* scip, /**< SCIP data structure */
174  SCIP_AGGRROW* aggrrow, /**< the aggregation row */
175  SCIP_Real* weights, /**< row weights in row summation */
176  int* rowinds, /**< array to store indices of non-zero entries of the weights array, or NULL */
177  int nrowinds, /**< number of non-zero entries in weights array, -1 if rowinds is NULL */
178  SCIP_Bool sidetypebasis, /**< choose sidetypes of row (lhs/rhs) based on basis information? */
179  SCIP_Bool allowlocal, /**< should local rows be used? */
180  int negslack, /**< should negative slack variables be used? (0: no, 1: only for integral rows, 2: yes) */
181  int maxaggrlen, /**< maximal number of non-zeros in the aggregation row */
182  SCIP_Bool* valid /**< is the aggregation valid */
183  );
184 
185 /** removes all (close enough to) zero entries in the aggregation row */
186 SCIP_EXPORT
188  SCIP* scip, /**< SCIP datastructure */
189  SCIP_AGGRROW* aggrrow, /**< the aggregation row */
190  SCIP_Bool useglbbounds, /**< consider global bound although the cut is local? */
191  SCIP_Bool* valid /**< pointer to return whether the aggregation row is still valid */
192  );
193 
194 /** get array with lp positions of aggregated rows */
195 SCIP_EXPORT
197  SCIP_AGGRROW* aggrrow /**< the aggregation row */
198  );
199 
200 /** get array with weights of aggregated rows */
201 SCIP_EXPORT
203  SCIP_AGGRROW* aggrrow /**< the aggregation row */
204  );
205 
206 /** checks whether a given row has been added to the aggregation row */
207 SCIP_EXPORT
209  SCIP_AGGRROW* aggrrow, /**< the aggregation row */
210  SCIP_ROW* row /**< row for which it is checked whether it has been added to the aggregation */
211  );
212 
213 /** gets the min and max absolute value of the weights used to aggregate the rows;
214  * must not be called for empty aggregation rows
215  */
216 SCIP_EXPORT
218  SCIP_AGGRROW* aggrrow, /**< the aggregation row */
219  SCIP_Real* minabsrowweight, /**< pointer to store smallest absolute value of weights used for aggregating rows */
220  SCIP_Real* maxabsrowweight /**< pointer to store largest absolute value of weights used for aggregating rows */
221  );
222 
223 /** gets the array of corresponding variable problem indices for each non-zero in the aggregation row */
224 SCIP_EXPORT
225 int* SCIPaggrRowGetInds(
226  SCIP_AGGRROW* aggrrow
227  );
228 
229 /** gets the number of non-zeros in the aggregation row */
230 SCIP_EXPORT
232  SCIP_AGGRROW* aggrrow /**< the aggregation row */
233  );
234 
235 /** gets the non-zero value for the given non-zero index */
236 static INLINE
238  SCIP_AGGRROW* aggrrow, /**< the aggregation row */
239  int i /**< non-zero index; must be between 0 and SCIPaggrRowGetNNz(aggrrow) - 1 */
240  )
241 {
242  SCIP_Real QUAD(val);
243 
244  QUAD_ARRAY_LOAD(val, aggrrow->vals, aggrrow->inds[i]);
245 
246  return QUAD_TO_DBL(val);
247 }
248 
249 /** gets the non-zero value for the given problem index of a variable */
250 static INLINE
252  SCIP_AGGRROW* aggrrow, /**< the aggregation row */
253  int probindex /**< problem index of variable; must be between 0 and SCIPgetNVars(scip) - 1 */
254  )
255 {
256  SCIP_Real QUAD(val);
257 
258  QUAD_ARRAY_LOAD(val, aggrrow->vals, probindex);
259 
260  return QUAD_TO_DBL(val);
261 }
262 
263 /** gets the rank of the aggregation row */
264 SCIP_EXPORT
266  SCIP_AGGRROW* aggrrow /**< the aggregation row */
267  );
268 
269 /** checks if the aggregation row is only valid locally */
270 SCIP_EXPORT
272  SCIP_AGGRROW* aggrrow /**< the aggregation row */
273  );
274 
275 /** gets the right hand side of the aggregation row */
276 SCIP_EXPORT
278  SCIP_AGGRROW* aggrrow /**< the aggregation row */
279  );
280 
281 /** gets the number of row aggregations */
282 SCIP_EXPORT
284  SCIP_AGGRROW* aggrrow /**< aggregation row */
285  );
286 
287 /** calculates an MIR cut out of the weighted sum of LP rows given by an aggregation row; the
288  * aggregation row must not contain non-zero weights for modifiable rows, because these rows cannot
289  * participate in an MIR cut.
290  *
291  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
292  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
293  *
294  * @pre This method can be called if @p scip is in one of the following stages:
295  * - \ref SCIP_STAGE_SOLVING
296  *
297  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
298  */
299 SCIP_EXPORT
301  SCIP* scip, /**< SCIP data structure */
302  SCIP_SOL* sol, /**< the solution that should be separated, or NULL for LP solution */
303  SCIP_Bool postprocess, /**< apply a post-processing step to the resulting cut? */
304  SCIP_Real boundswitch, /**< fraction of domain up to which lower bound is used in transformation */
305  SCIP_Bool usevbds, /**< should variable bounds be used in bound transformation? */
306  SCIP_Bool allowlocal, /**< should local information allowed to be used, resulting in a local cut? */
307  SCIP_Bool fixintegralrhs, /**< should complementation tried to be adjusted such that rhs gets fractional? */
308  int* boundsfortrans, /**< bounds that should be used for transformed variables: vlb_idx/vub_idx,
309  * -1 for global lb/ub, -2 for local lb/ub, or -3 for using closest bound;
310  * NULL for using closest bound for all variables */
311  SCIP_BOUNDTYPE* boundtypesfortrans, /**< type of bounds that should be used for transformed variables;
312  * NULL for using closest bound for all variables */
313  SCIP_Real minfrac, /**< minimal fractionality of rhs to produce MIR cut for */
314  SCIP_Real maxfrac, /**< maximal fractionality of rhs to produce MIR cut for */
315  SCIP_Real scale, /**< additional scaling factor multiplied to the aggrrow; must be positive */
316  SCIP_AGGRROW* aggrrow, /**< the aggregation row to compute an MIR cut for */
317  SCIP_Real* cutcoefs, /**< array to store the non-zero coefficients in the cut */
318  SCIP_Real* cutrhs, /**< pointer to store the right hand side of the cut */
319  int* cutinds, /**< array to store the problem indices of variables with a non-zero coefficient in the cut */
320  int* cutnnz, /**< pointer to store the number of non-zeros in the cut */
321  SCIP_Real* cutefficacy, /**< pointer to store the efficacy of the cut, or NULL */
322  int* cutrank, /**< pointer to return rank of generated cut */
323  SCIP_Bool* cutislocal, /**< pointer to store whether the generated cut is only valid locally */
324  SCIP_Bool* success /**< pointer to store whether the returned coefficients are a valid MIR cut */
325  );
326 
327 /** calculates an MIR cut out of the weighted sum of LP rows given by an aggregation row; the
328  * aggregation row must not contain non-zero weights for modifiable rows, because these rows cannot
329  * participate in an MIR cut. The function uses a cut generation heuristic which tries different scaling
330  * factors and complementations of the variables to improve the cut's efficacy.
331  * For further details we refer to:
332  *
333  * Marchand, H., & Wolsey, L. A. (2001). Aggregation and mixed integer rounding to solve MIPs.
334  * Operations research, 49(3), 363-371.
335  *
336  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
337  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
338  *
339  * @pre This method can be called if @p scip is in one of the following stages:
340  * - \ref SCIP_STAGE_SOLVING
341  *
342  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
343  */
344 SCIP_EXPORT
346  SCIP* scip, /**< SCIP data structure */
347  SCIP_SOL* sol, /**< the solution that should be separated, or NULL for LP solution */
348  SCIP_Bool postprocess, /**< apply a post-processing step to the resulting cut? */
349  SCIP_Real boundswitch, /**< fraction of domain up to which lower bound is used in transformation */
350  SCIP_Bool usevbds, /**< should variable bounds be used in bound transformation? */
351  SCIP_Bool allowlocal, /**< should local information allowed to be used, resulting in a local cut? */
352  int maxtestdelta, /**< maximum number of deltas to test */
353  int* boundsfortrans, /**< bounds that should be used for transformed variables: vlb_idx/vub_idx,
354  * -1 for global lb/ub, -2 for local lb/ub, or -3 for using closest bound;
355  * NULL for using closest bound for all variables */
356  SCIP_BOUNDTYPE* boundtypesfortrans, /**< type of bounds that should be used for transformed variables;
357  * NULL for using closest bound for all variables */
358  SCIP_Real minfrac, /**< minimal fractionality of rhs to produce MIR cut for */
359  SCIP_Real maxfrac, /**< maximal fractionality of rhs to produce MIR cut for */
360  SCIP_AGGRROW* aggrrow, /**< the aggregation row to compute MIR cut for */
361  SCIP_Real* cutcoefs, /**< array to store the non-zero coefficients in the cut */
362  SCIP_Real* cutrhs, /**< pointer to store the right hand side of the cut */
363  int* cutinds, /**< array to store the problem indices of variables with a non-zero coefficient in the cut */
364  int* cutnnz, /**< pointer to store the number of non-zeros in the cut */
365  SCIP_Real* cutefficacy, /**< pointer to store efficacy of best cut; only cuts that are strictly better than the value of
366  * this efficacy on input to this function are returned */
367  int* cutrank, /**< pointer to return rank of generated cut */
368  SCIP_Bool* cutislocal, /**< pointer to store whether the generated cut is only valid locally */
369  SCIP_Bool* success /**< pointer to store whether a valid and efficacious cut was returned */
370  );
371 
372 /** calculates a lifted simple generalized flow cover cut out of the weighted sum of LP rows given by an aggregation row; the
373  * aggregation row must not contain non-zero weights for modifiable rows, because these rows cannot
374  * participate in the cut.
375  * For further details we refer to:
376  *
377  * Gu, Z., Nemhauser, G. L., & Savelsbergh, M. W. (1999). Lifted flow cover inequalities for mixed 0-1 integer programs.
378  * Mathematical Programming, 85(3), 439-467.
379  *
380  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
381  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
382  *
383  * @pre This method can be called if @p scip is in one of the following stages:
384  * - \ref SCIP_STAGE_SOLVING
385  *
386  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
387  */
388 SCIP_EXPORT
390  SCIP* scip, /**< SCIP data structure */
391  SCIP_SOL* sol, /**< the solution that should be separated, or NULL for LP solution */
392  SCIP_Bool postprocess, /**< apply a post-processing step to the resulting cut? */
393  SCIP_Real boundswitch, /**< fraction of domain up to which lower bound is used in transformation */
394  SCIP_Bool allowlocal, /**< should local information allowed to be used, resulting in a local cut? */
395  SCIP_AGGRROW* aggrrow, /**< the aggregation row to compute flow cover cut for */
396  SCIP_Real* cutcoefs, /**< array to store the non-zero coefficients in the cut */
397  SCIP_Real* cutrhs, /**< pointer to store the right hand side of the cut */
398  int* cutinds, /**< array to store the problem indices of variables with a non-zero coefficient in the cut */
399  int* cutnnz, /**< pointer to store the number of non-zeros in the cut */
400  SCIP_Real* cutefficacy, /**< pointer to store the efficacy of the cut, or NULL */
401  int* cutrank, /**< pointer to return rank of generated cut */
402  SCIP_Bool* cutislocal, /**< pointer to store whether the generated cut is only valid locally */
403  SCIP_Bool* success /**< pointer to store whether a valid cut was returned */
404  );
405 
406 /** calculates a lifted knapsack cover cut out of the weighted sum of LP rows given by an aggregation row; the
407  * aggregation row must not contain non-zero weights for modifiable rows, because these rows cannot
408  * participate in the cut.
409  * For further details we refer to:
410  *
411  * Letchford, A. N., & Souli, G. (2019). On lifted cover inequalities: A new lifting procedure with unusual properties.
412  * Operations Research Letters, 47(2), 83-87.
413  *
414  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
415  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
416  *
417  * @pre This method can be called if @p scip is in one of the following stages:
418  * - \ref SCIP_STAGE_SOLVING
419  *
420  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
421  */
422 SCIP_EXPORT
424  SCIP* scip, /**< SCIP data structure */
425  SCIP_SOL* sol, /**< the solution that should be separated, or NULL for LP solution */
426  SCIP_Bool allowlocal, /**< should local information allowed to be used, resulting in a local cut? */
427  SCIP_AGGRROW* aggrrow, /**< the aggregation row to compute flow cover cut for */
428  SCIP_Real* cutcoefs, /**< array to store the non-zero coefficients in the cut */
429  SCIP_Real* cutrhs, /**< pointer to store the right hand side of the cut */
430  int* cutinds, /**< array to store the problem indices of variables with a non-zero coefficient in the cut */
431  int* cutnnz, /**< pointer to store the number of non-zeros in the cut */
432  SCIP_Real* cutefficacy, /**< pointer to store the efficacy of the cut, or NULL */
433  int* cutrank, /**< pointer to return rank of generated cut */
434  SCIP_Bool* cutislocal, /**< pointer to store whether the generated cut is only valid locally */
435  SCIP_Bool* success /**< pointer to store whether a valid cut was returned */
436  );
437 
438 /** calculates a strong CG cut out of the weighted sum of LP rows given by an aggregation row; the
439  * aggregation row must not contain non-zero weights for modifiable rows, because these rows cannot
440  * participate in a strongcg cut
441  *
442  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
443  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
444  *
445  * @pre This method can be called if @p scip is in one of the following stages:
446  * - \ref SCIP_STAGE_SOLVING
447  *
448  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
449  */
450 SCIP_EXPORT
452  SCIP* scip, /**< SCIP data structure */
453  SCIP_SOL* sol, /**< the solution that should be separated, or NULL for LP solution */
454  SCIP_Bool postprocess, /**< apply a post-processing step to the resulting cut? */
455  SCIP_Real boundswitch, /**< fraction of domain up to which lower bound is used in transformation */
456  SCIP_Bool usevbds, /**< should variable bounds be used in bound transformation? */
457  SCIP_Bool allowlocal, /**< should local information allowed to be used, resulting in a local cut? */
458  SCIP_Real minfrac, /**< minimal fractionality of rhs to produce strong CG cut for */
459  SCIP_Real maxfrac, /**< maximal fractionality of rhs to produce strong CG cut for */
460  SCIP_Real scale, /**< additional scaling factor multiplied to all rows */
461  SCIP_AGGRROW* aggrrow, /**< the aggregation row to compute a strong CG cut for */
462  SCIP_Real* cutcoefs, /**< array to store the non-zero coefficients in the cut */
463  SCIP_Real* cutrhs, /**< pointer to store the right hand side of the cut */
464  int* cutinds, /**< array to store the problem indices of variables with a non-zero coefficient in the cut */
465  int* cutnnz, /**< pointer to store the number of non-zeros in the cut */
466  SCIP_Real* cutefficacy, /**< pointer to store the efficacy of the cut, or NULL */
467  int* cutrank, /**< pointer to return rank of generated cut */
468  SCIP_Bool* cutislocal, /**< pointer to store whether the generated cut is only valid locally */
469  SCIP_Bool* success /**< pointer to store whether a valid cut was returned */
470  );
471 
472 /** @} */
473 
474 #ifdef __cplusplus
475 }
476 #endif
477 
478 #endif
enum SCIP_BoundType SCIP_BOUNDTYPE
Definition: type_lp.h:59
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:8875
void SCIPaggrRowFree(SCIP *scip, SCIP_AGGRROW **aggrrow)
Definition: cuts.c:1695
int SCIPaggrRowGetNRows(SCIP_AGGRROW *aggrrow)
Definition: cuts.c:2414
type definitions for miscellaneous datastructures
SCIP_RETCODE SCIPaggrRowAddRow(SCIP *scip, SCIP_AGGRROW *aggrrow, SCIP_ROW *row, SCIP_Real weight, int sidetype)
Definition: cuts.c:1799
void SCIPaggrRowCancelVarWithBound(SCIP *scip, SCIP_AGGRROW *aggrrow, SCIP_VAR *var, int pos, SCIP_Bool *valid)
Definition: cuts.c:1883
#define INLINE
Definition: def.h:132
SCIP_Bool SCIPaggrRowIsLocal(SCIP_AGGRROW *aggrrow)
Definition: cuts.c:2499
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:63
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:4133
type definitions for cuts
SCIP_RETCODE SCIPcalcKnapsackCover(SCIP *scip, SCIP_SOL *sol, 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:7964
int SCIPaggrRowGetNNz(SCIP_AGGRROW *aggrrow)
Definition: cuts.c:2479
SCIP_Real SCIPaggrRowGetRhs(SCIP_AGGRROW *aggrrow)
Definition: cuts.c:2509
type definitions for return codes for SCIP methods
void SCIPaggrRowPrint(SCIP *scip, SCIP_AGGRROW *aggrrow, FILE *file)
Definition: cuts.c:1716
#define QUAD_TO_DBL(x)
Definition: dbldblarith.h:49
SCIP_Bool SCIPaggrRowHasRowBeenAdded(SCIP_AGGRROW *aggrrow, SCIP_ROW *row)
Definition: cuts.c:2446
type definitions for LP management
SCIP_RETCODE SCIPaggrRowAddObjectiveFunction(SCIP *scip, SCIP_AGGRROW *aggrrow, SCIP_Real rhs, SCIP_Real scale)
Definition: cuts.c:1942
int * SCIPaggrRowGetRowInds(SCIP_AGGRROW *aggrrow)
Definition: cuts.c:2424
type definitions for SCIP&#39;s main datastructure
#define QUAD(x)
Definition: dbldblarith.h:47
int SCIPaggrRowGetRank(SCIP_AGGRROW *aggrrow)
Definition: cuts.c:2489
int * SCIPaggrRowGetInds(SCIP_AGGRROW *aggrrow)
Definition: cuts.c:2469
#define QUAD_ARRAY_LOAD(r, a, idx)
Definition: dbldblarith.h:54
void SCIPaggrRowRemoveZeros(SCIP *scip, SCIP_AGGRROW *aggrrow, SCIP_Bool useglbbounds, SCIP_Bool *valid)
Definition: cuts.c:2399
type definitions for problem variables
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:2013
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:3801
#define SCIP_Bool
Definition: def.h:93
SCIP_Real SCIPaggrRowCalcEfficacyNorm(SCIP *scip, SCIP_AGGRROW *aggrrow)
Definition: cuts.c:2088
SCIP_Bool SCIPcutsTightenCoefficients(SCIP *scip, SCIP_Bool cutislocal, SCIP_Real *cutcoefs, SCIP_Real *cutrhs, int *cutinds, int *cutnnz, int *nchgcoefs)
Definition: cuts.c:1471
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:7338
SCIP_Real * SCIPaggrRowGetRowWeights(SCIP_AGGRROW *aggrrow)
Definition: cuts.c:2435
SCIP_Real * vals
Definition: struct_cuts.h:42
type definitions for storing primal CIP solutions
SCIP_RETCODE SCIPaggrRowCopy(SCIP *scip, SCIP_AGGRROW **aggrrow, SCIP_AGGRROW *source)
Definition: cuts.c:1753
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:2207
#define SCIP_Real
Definition: def.h:186
SCIP_RETCODE SCIPaggrRowCreate(SCIP *scip, SCIP_AGGRROW **aggrrow)
Definition: cuts.c:1663
static INLINE SCIP_Real SCIPaggrRowGetProbvarValue(SCIP_AGGRROW *aggrrow, int probindex)
Definition: cuts.h:251
common defines and data types used in all packages of SCIP
void SCIPaggrRowClear(SCIP_AGGRROW *aggrrow)
Definition: cuts.c:2063
static INLINE SCIP_Real SCIPaggrRowGetValue(SCIP_AGGRROW *aggrrow, int i)
Definition: cuts.h:237
struct definitions for cuts