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-2024 Zuse Institute Berlin (ZIB) */
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
49extern "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 */
62SCIP_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 */
74SCIP_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 */
81SCIP_EXPORT
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 */
88SCIP_EXPORT
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 */
96SCIP_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 */
104SCIP_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 */
120SCIP_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 */
130SCIP_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 */
139SCIP_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 */
156SCIP_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 */
163SCIP_EXPORT
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 */
171SCIP_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 */
186SCIP_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 */
195SCIP_EXPORT
197 SCIP_AGGRROW* aggrrow /**< the aggregation row */
198 );
199
200/** get array with weights of aggregated rows */
201SCIP_EXPORT
203 SCIP_AGGRROW* aggrrow /**< the aggregation row */
204 );
205
206/** checks whether a given row has been added to the aggregation row */
207SCIP_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 */
216SCIP_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 */
224SCIP_EXPORT
226 SCIP_AGGRROW* aggrrow
227 );
228
229/** gets the number of non-zeros in the aggregation row */
230SCIP_EXPORT
232 SCIP_AGGRROW* aggrrow /**< the aggregation row */
233 );
234
235/** gets the non-zero value for the given non-zero index */
236static 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 */
250static 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 */
264SCIP_EXPORT
266 SCIP_AGGRROW* aggrrow /**< the aggregation row */
267 );
268
269/** checks if the aggregation row is only valid locally */
270SCIP_EXPORT
272 SCIP_AGGRROW* aggrrow /**< the aggregation row */
273 );
274
275/** gets the right hand side of the aggregation row */
276SCIP_EXPORT
278 SCIP_AGGRROW* aggrrow /**< the aggregation row */
279 );
280
281/** gets the number of row aggregations */
282SCIP_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 */
299SCIP_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 */
344SCIP_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 */
388SCIP_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 */
422SCIP_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 */
450SCIP_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
#define QUAD(x)
Definition: dbldblarith.h:47
#define QUAD_ARRAY_LOAD(r, a, idx)
Definition: dbldblarith.h:54
#define QUAD_TO_DBL(x)
Definition: dbldblarith.h:49
common defines and data types used in all packages of SCIP
#define INLINE
Definition: def.h:129
#define SCIP_Bool
Definition: def.h:91
#define SCIP_Real
Definition: def.h:173
void SCIPaggrRowGetAbsWeightRange(SCIP_AGGRROW *aggrrow, SCIP_Real *minabsrowweight, SCIP_Real *maxabsrowweight)
void SCIPaggrRowCancelVarWithBound(SCIP *scip, SCIP_AGGRROW *aggrrow, SCIP_VAR *var, int pos, SCIP_Bool *valid)
Definition: cuts.c:1945
SCIP_Bool SCIPaggrRowHasRowBeenAdded(SCIP_AGGRROW *aggrrow, SCIP_ROW *row)
Definition: cuts.c:2518
int SCIPaggrRowGetRank(SCIP_AGGRROW *aggrrow)
Definition: cuts.c:2561
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:4212
SCIP_Bool SCIPcutsTightenCoefficients(SCIP *scip, SCIP_Bool cutislocal, SCIP_Real *cutcoefs, SCIP_Real *cutrhs, int *cutinds, int *cutnnz, int *nchgcoefs)
Definition: cuts.c:1527
SCIP_RETCODE SCIPaggrRowCreate(SCIP *scip, SCIP_AGGRROW **aggrrow)
Definition: cuts.c:1723
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:8966
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:8047
void SCIPaggrRowClear(SCIP_AGGRROW *aggrrow)
Definition: cuts.c:2133
SCIP_RETCODE SCIPaggrRowCopy(SCIP *scip, SCIP_AGGRROW **aggrrow, SCIP_AGGRROW *source)
Definition: cuts.c:1813
SCIP_Bool SCIPaggrRowIsLocal(SCIP_AGGRROW *aggrrow)
Definition: cuts.c:2571
SCIP_Real SCIPaggrRowGetRhs(SCIP_AGGRROW *aggrrow)
Definition: cuts.c:2581
int SCIPaggrRowGetNRows(SCIP_AGGRROW *aggrrow)
Definition: cuts.c:2486
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:2080
static INLINE SCIP_Real SCIPaggrRowGetValue(SCIP_AGGRROW *aggrrow, int i)
Definition: cuts.h:237
void SCIPaggrRowFree(SCIP *scip, SCIP_AGGRROW **aggrrow)
Definition: cuts.c:1755
int * SCIPaggrRowGetInds(SCIP_AGGRROW *aggrrow)
Definition: cuts.c:2541
void SCIPaggrRowPrint(SCIP *scip, SCIP_AGGRROW *aggrrow, FILE *file)
Definition: cuts.c:1776
void SCIPaggrRowRemoveZeros(SCIP *scip, SCIP_AGGRROW *aggrrow, SCIP_Bool useglbbounds, SCIP_Bool *valid)
Definition: cuts.c:2471
SCIP_Real * SCIPaggrRowGetRowWeights(SCIP_AGGRROW *aggrrow)
Definition: cuts.c:2507
int SCIPaggrRowGetNNz(SCIP_AGGRROW *aggrrow)
Definition: cuts.c:2551
SCIP_RETCODE SCIPaggrRowAddRow(SCIP *scip, SCIP_AGGRROW *aggrrow, SCIP_ROW *row, SCIP_Real weight, int sidetype)
Definition: cuts.c:1859
static INLINE SCIP_Real SCIPaggrRowGetProbvarValue(SCIP_AGGRROW *aggrrow, int probindex)
Definition: cuts.h:251
int * SCIPaggrRowGetRowInds(SCIP_AGGRROW *aggrrow)
Definition: cuts.c:2496
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:2279
SCIP_RETCODE SCIPaggrRowAddObjectiveFunction(SCIP *scip, SCIP_AGGRROW *aggrrow, SCIP_Real rhs, SCIP_Real scale)
Definition: cuts.c:2004
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:7417
SCIP_Real SCIPaggrRowCalcEfficacyNorm(SCIP *scip, SCIP_AGGRROW *aggrrow)
Definition: cuts.c:2158
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:3873
SCIP_Real * vals
Definition: struct_cuts.h:42
struct definitions for cuts
type definitions for cuts
type definitions for LP management
enum SCIP_BoundType SCIP_BOUNDTYPE
Definition: type_lp.h:59
type definitions for miscellaneous datastructures
type definitions for return codes for SCIP methods
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:63
type definitions for SCIP's main datastructure
type definitions for storing primal CIP solutions
type definitions for problem variables