Scippy

SCIP

Solving Constraint Integer Programs

presol_milp.cpp
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-2025 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 presol_milp.cpp
26 * @brief MILP presolver
27 * @author Leona Gottwald
28 * @author Alexander Hoen
29 *
30 * Calls the presolve library and communicates (multi-)aggregations, fixings, and bound
31 * changes to SCIP by utilizing the postsolve information. Constraint changes can currently
32 * only be communicated by deleting all constraints and adding new ones.
33 *
34 * @todo add infrastructure to SCIP for handling parallel columns
35 * @todo better communication of constraint changes by adding more information to the postsolve structure
36 * @todo allow to pass additional external locks to the presolve library that are considered when doing reductions
37 *
38 */
39
40/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
41#include "scip/presol_milp.h"
42
43#ifndef SCIP_WITH_PAPILO
44
45/** creates the MILP presolver and includes it in SCIP */
46SCIP_RETCODE SCIPincludePresolMILP(
47 SCIP* scip /**< SCIP data structure */
48 )
49{
50 assert(scip != NULL);
51 return SCIP_OKAY;
52}
53
54#else
55
56/* disable some warnings that come up in header files of PAPILOs dependencies */
57#ifdef __GNUC__
58#pragma GCC diagnostic ignored "-Wshadow"
59#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
60#pragma GCC diagnostic ignored "-Wredundant-decls"
61
62/* disable false warning, !3076, https://gcc.gnu.org/bugzilla/show_bug.cgi?id=106199 */
63#if __GNUC__ == 12 && __GNUC__MINOR__ <= 2
64#pragma GCC diagnostic ignored "-Wstringop-overflow"
65#endif
66#endif
67
68#include <assert.h>
69#include "scip/cons_linear.h"
70#include "scip/cons_exactlinear.h"
71#include "scip/pub_matrix.h"
72#include "scip/pub_presol.h"
73#include "scip/pub_var.h"
74#include "scip/pub_cons.h"
75#include "scip/pub_message.h"
76#include "scip/scip_exact.h"
77#include "scip/scip_general.h"
78#include "scip/scip_presol.h"
79#include "scip/scip_var.h"
80#include "scip/scip_mem.h"
81#include "scip/scip_prob.h"
82#include "scip/scip_param.h"
83#include "scip/scip_cons.h"
84#include "scip/scip_numerics.h"
85#include "scip/scip_timing.h"
86#include "scip/scip_message.h"
87#include "scip/scip_randnumgen.h"
88#if defined(SCIP_WITH_EXACTSOLVE)
89#include "scip/struct_rational.h"
90#endif
91#include "scip/rational.h"
92#include "papilo/core/Presolve.hpp"
93#include "papilo/core/ProblemBuilder.hpp"
94#include "papilo/Config.hpp"
95
96/* API since PaPILO 2.3.0 */
97#if !defined(PAPILO_API_VERSION)
98#define PAPILO_APIVERSION 0
99#elif !(PAPILO_API_VERSION + 0)
100#define PAPILO_APIVERSION 1
101#else
102#define PAPILO_APIVERSION PAPILO_API_VERSION
103#endif
104
105#if defined(SCIP_WITH_GMP) && defined(SCIP_WITH_EXACTSOLVE) && !defined(PAPILO_HAVE_GMP)
106#warning SCIP built with GMP and exact solving, but PaPILO without GMP disables exact presolving.
107#endif
108
109#if defined(SCIP_WITH_GMP) && defined(SCIP_WITH_EXACTSOLVE) && defined(PAPILO_HAVE_GMP)
110#define PAPILO_WITH_EXACTPRESOLVE
111#endif
112
113#define PRESOL_NAME "milp"
114#define PRESOL_DESC "MILP specific presolving methods"
115#define PRESOL_PRIORITY 9999999 /**< priority of the presolver (>= 0: before, < 0: after constraint handlers); combined with propagators */
116#define PRESOL_MAXROUNDS (-1) /**< maximal number of presolving rounds the presolver participates in (-1: no limit) */
117#define PRESOL_TIMING SCIP_PRESOLTIMING_MEDIUM /* timing of the presolver (fast, medium, or exhaustive) */
118
119/** general settings for PaPILO */
120#define DEFAULT_THREADS 1 /**< maximum number of threads presolving may use (0: automatic) */
121#define DEFAULT_ABORTFAC_EXHAUSTIVE 0.0008 /**< the abort factor for exhaustive presolving in PAPILO */
122#define DEFAULT_ABORTFAC_MEDIUM 0.0008 /**< the abort factor for medium presolving in PAPILO */
123#define DEFAULT_ABORTFAC_FAST 0.0008 /**< the abort factor for fast presolving in PAPILO */
124#define DEFAULT_DETECTLINDEP 0 /**< should linear dependent equations and free columns be removed? (0: never, 1: for LPs, 2: always) */
125#define DEFAULT_INTERNAL_MAXROUNDS (-1) /**< internal max rounds in PaPILO (-1: no limit, 0: model cleanup) */
126#define DEFAULT_MODIFYCONSFAC 0.8 /**< modify SCIP constraints when the number of nonzeros or rows is at most this
127 * factor times the number of nonzeros or rows before presolving */
128#define DEFAULT_RANDOMSEED 0 /**< the random seed used for randomization of tie breaking */
129
130/** numerics in PaPILO */
131#define DEFAULT_HUGEBOUND 1e8 /**< absolute bound value that is considered too huge for activitity based calculations */
132
133/** presolvers in PaPILO */
134#define DEFAULT_ENABLEDOMCOL TRUE /**< should the dominated column presolver be enabled within the presolve library? */
135#define DEFAULT_ENABLEDUALINFER TRUE /**< should the dualinfer presolver be enabled within the presolve library? */
136#define DEFAULT_ENABLEMULTIAGGR TRUE /**< should the multi-aggregation/substitution presolver be enabled within the presolve library? */
137#define DEFAULT_ENABLEPARALLELROWS TRUE /**< should the parallel rows presolver be enabled within the presolve library? */
138#define DEFAULT_ENABLEPROBING TRUE /**< should the probing presolver be enabled within the presolve library? */
139#define DEFAULT_ENABLESPARSIFY FALSE /**< should the sparsify presolver be enabled within the presolve library? */
140#define DEFAULT_ENABLECLIQUEMERGE FALSE /**< should the clique merging presolver be enabled within the presolve library? */
141
142/** parameters tied to a certain presolve technique in PaPILO */
143#define DEFAULT_MAXBADGESIZE_SEQ 15000 /**< the max badge size in Probing if PaPILO is executed in sequential mode */
144#define DEFAULT_MAXBADGESIZE_PAR (-1) /**< the max badge size in Probing if PaPILO is executed in parallel mode */
145#define DEFAULT_MARKOWITZTOLERANCE 0.01 /**< the markowitz tolerance used for substitutions */
146#define DEFAULT_MAXFILLINPERSUBST 3 /**< maximal possible fillin for substitutions to be considered */
147#define DEFAULT_MAXSHIFTPERROW 10 /**< maximal amount of nonzeros allowed to be shifted to make space for substitutions */
148#define DEFAULT_MAXEDGESPARALLEL 1000000 /**< maximal amount of edges in the parallel clique merging graph */
149#define DEFAULT_MAXEDGESSEQUENTIAL 100000 /**< maximal amount of edges in the sequential clique merging graph */
150#define DEFAULT_MAXCLIQUESIZE 100 /**< maximal size of clique considered for clique merging */
151#define DEFAULT_MAXGREEDYCALLS 10000 /**< maximal number of greedy max clique calls in a single thread */
152
153/** debug options for PaPILO */
154#define DEFAULT_FILENAME_PROBLEM "-" /**< default filename to store the instance before presolving */
155#define DEFAULT_VERBOSITY 0
156
157
158/*
159 * Data structures
160 */
161
162/** presolver data */
163struct SCIP_PresolMilpData
164{
165 int lastncols; /**< the number of columns from the last call */
166 int lastnrows; /**< the number of rows from the last call */
167 int threads; /**< maximum number of threads presolving may use (0: automatic) */
168 int maxfillinpersubstitution; /**< maximal possible fillin for substitutions to be considered */
169 int maxbadgesizeseq; /**< the max badge size in Probing if PaPILO is called in sequential mode */
170 int maxbadgesizepar; /**< the max badge size in Probing if PaPILO is called in parallel mode */
171 int internalmaxrounds; /**< internal max rounds in PaPILO (-1: no limit, 0: model cleanup) */
172 int maxshiftperrow; /**< maximal amount of nonzeros allowed to be shifted to make space for substitutions */
173 int detectlineardependency; /**< should linear dependent equations and free columns be removed? (0: never, 1: for LPs, 2: always) */
174#if PAPILO_APIVERSION >= 6
175 int maxedgesparallel; /**< maximal amount of edges in the parallel clique merging graph */
176 int maxedgessequential; /**< maximal amount of edges in the sequential clique merging graph */
177 int maxcliquesize; /**< maximal size of clique considered for clique merging */
178 int maxgreedycalls; /**< maximal number of greedy max clique calls in a single thread */
179#endif
180 int randomseed; /**< the random seed used for randomization of tie breaking */
181 int verbosity;
182
183 SCIP_Bool enablesparsify; /**< should the sparsify presolver be enabled within the presolve library? */
184 SCIP_Bool enabledomcol; /**< should the dominated column presolver be enabled within the presolve library? */
185 SCIP_Bool enableprobing; /**< should the probing presolver be enabled within the presolve library? */
186 SCIP_Bool enabledualinfer; /**< should the dualinfer presolver be enabled within the presolve library? */
187 SCIP_Bool enablemultiaggr; /**< should the multi-aggregation presolver be enabled within the presolve library? */
188 SCIP_Bool enableparallelrows; /**< should the parallel rows presolver be enabled within the presolve library? */
189#if PAPILO_APIVERSION >= 6
190 SCIP_Bool enablecliquemerging; /**< should the clique merging presolver be enabled within the presolve library? */
191#endif
192 SCIP_Real modifyconsfac; /**< modify SCIP constraints when the number of nonzeros or rows is at most this
193 * factor times the number of nonzeros or rows before presolving */
194 SCIP_Real markowitztolerance; /**< the markowitz tolerance used for substitutions */
195 SCIP_Real hugebound; /**< absolute bound value that is considered too huge for activitity based calculations */
196 SCIP_Real abortfacexhaustive; /**< abort factor for exhaustive presolving in PAPILO */
197 SCIP_Real abortfacmedium; /**< abort factor for medium presolving in PAPILO */
198 SCIP_Real abortfacfast; /**< abort factor for fast presolving in PAPILO */
199
200 char* filename = NULL; /**< filename to store the instance before presolving */
201};
202typedef struct SCIP_PresolMilpData SCIP_PRESOLMILPDATA;
203
204using namespace papilo;
205
206/*
207 * Local methods
208 */
209
210#if defined(PAPILO_WITH_EXACTPRESOLVE)
211/** casts rational value from PaPILO to SCIP */
212static
213void setRational(
214 SCIP* scip, /**< SCIP data structure */
215 SCIP_RATIONAL* res, /**< pointer to SCIP' rational to set */
216 papilo::Rational papiloval /**< rational value from PaPILO */
217 )
218{
219 assert(scip != NULL);
220 assert(res != NULL);
221
222 res->val = papilo::Rational(papiloval.backend().data());
223 res->isfprepresentable = SCIP_ISFPREPRESENTABLE_UNKNOWN;
224 if( SCIPisInfinity(scip, REALABS(SCIPrationalGetReal(res))) )
225 {
226 res->val > 0 ? SCIPrationalSetInfinity(res) : SCIPrationalSetNegInfinity(res);
227 }
228}
229
230/** builds PaPILO problem from SCIP matrix */
231static
232Problem<papilo::Rational> buildProblemRational(
233 SCIP* scip, /**< SCIP data structure */
234 SCIP_MATRIX* matrix /**< initialized SCIP_MATRIX data structure */
235 )
236{
237 ProblemBuilder<papilo::Rational> builder;
238
239 /* build problem from matrix */
240 int nnz = SCIPmatrixGetNNonzs(matrix);
241 int ncols = SCIPmatrixGetNColumns(matrix);
242 int nrows = SCIPmatrixGetNRows(matrix);
243 builder.reserve(nnz, nrows, ncols);
244
245 /* set up columns */
246 builder.setNumCols(ncols);
247 for( int i = 0; i != ncols; ++i )
248 {
249 SCIP_VAR* var = SCIPmatrixGetVar(matrix, i);
250 SCIP_RATIONAL* lb = SCIPvarGetLbGlobalExact(var);
251 SCIP_RATIONAL* ub = SCIPvarGetUbGlobalExact(var);
252 builder.setColLb(i, lb->val);
253 builder.setColUb(i, ub->val);
254 builder.setColLbInf(i, SCIPrationalIsNegInfinity(lb));
255 builder.setColUbInf(i, SCIPrationalIsInfinity(ub));
256
257 builder.setColIntegral(i, SCIPvarIsIntegral(var));
258 builder.setObj(i, SCIPvarGetObjExact(var)->val);
259 }
260
261 /* set up rows */
262 builder.setNumRows(nrows);
263 for( int i = 0; i != nrows; ++i )
264 {
265 int* rowcols = SCIPmatrixGetRowIdxPtr(matrix, i);
266 SCIP_RATIONAL** rowvalsscip = SCIPmatrixGetRowValPtrExact(matrix, i);
267 Vec<papilo::Rational> rowvals;
268 int rowlen = SCIPmatrixGetRowNNonzs(matrix, i);
269 for( int j = 0; j < rowlen; ++j )
270 rowvals.emplace_back(rowvalsscip[j]->val);
271 builder.addRowEntries(i, rowlen, rowcols, rowvals.data());
272
273 SCIP_RATIONAL* lhs = SCIPmatrixGetRowLhsExact(matrix, i);
274 SCIP_RATIONAL* rhs = SCIPmatrixGetRowRhsExact(matrix, i);
275 builder.setRowLhs(i, lhs->val);
276 builder.setRowRhs(i, rhs->val);
277 builder.setRowLhsInf(i, SCIPrationalIsNegInfinity(lhs));
278 builder.setRowRhsInf(i, SCIPrationalIsInfinity(rhs));
279 }
280
281 builder.setObjOffset(0);
282
283 return builder.build();
284}
285#endif
286
287/** builds PaPILO problem from SCIP matrix */
288static
289Problem<SCIP_Real> buildProblemReal(
290 SCIP* scip, /**< SCIP data structure */
291 SCIP_MATRIX* matrix /**< initialized SCIP_MATRIX data structure */
292 )
293{
294 ProblemBuilder<SCIP_Real> builder;
295
296 /* build problem from matrix */
297 int nnz = SCIPmatrixGetNNonzs(matrix);
298 int ncols = SCIPmatrixGetNColumns(matrix);
299 int nrows = SCIPmatrixGetNRows(matrix);
300 builder.reserve(nnz, nrows, ncols);
301
302 /* set up columns */
303 builder.setNumCols(ncols);
304 for( int i = 0; i != ncols; ++i )
305 {
306 SCIP_VAR* var = SCIPmatrixGetVar(matrix, i);
307 SCIP_Real lb = SCIPvarGetLbGlobal(var);
308 SCIP_Real ub = SCIPvarGetUbGlobal(var);
309 builder.setColLb(i, lb);
310 builder.setColUb(i, ub);
311 builder.setColLbInf(i, SCIPisInfinity(scip, -lb));
312 builder.setColUbInf(i, SCIPisInfinity(scip, ub));
313 builder.setColIntegral(i, SCIPvarGetType(var) != SCIP_VARTYPE_CONTINUOUS);
314#if PAPILO_VERSION_MAJOR > 2 || (PAPILO_VERSION_MAJOR == 2 && PAPILO_VERSION_MINOR >= 1)
315 builder.setColImplInt(i, SCIPvarIsImpliedIntegral(var));
316#endif
317 builder.setObj(i, SCIPvarGetObj(var));
318 }
319
320 /* set up rows */
321 builder.setNumRows(nrows);
322 for( int i = 0; i != nrows; ++i )
323 {
324 int* rowcols = SCIPmatrixGetRowIdxPtr(matrix, i);
325 SCIP_Real* rowvals = SCIPmatrixGetRowValPtr(matrix, i);
326 int rowlen = SCIPmatrixGetRowNNonzs(matrix, i);
327 builder.addRowEntries(i, rowlen, rowcols, rowvals);
328
329 SCIP_Real lhs = SCIPmatrixGetRowLhs(matrix, i);
330 SCIP_Real rhs = SCIPmatrixGetRowRhs(matrix, i);
331 builder.setRowLhs(i, lhs);
332 builder.setRowRhs(i, rhs);
333 builder.setRowLhsInf(i, SCIPisInfinity(scip, -lhs));
334 builder.setRowRhsInf(i, SCIPisInfinity(scip, rhs));
335 }
336
337 /* init objective offset - the value itself is irrelevant */
338 builder.setObjOffset(0);
339
340#ifdef SCIP_PRESOLLIB_ENABLE_OUTPUT
341 /* show problem name */
342 builder.setProblemName(SCIPgetProbName(scip));
343#endif
344
345 return builder.build();
346}
347
348/** sets up PaPILO's presolve object from the data */
349template <typename T>
350static
351SCIP_RETCODE setupPresolve(
352 SCIP* scip, /**< SCIP data structure */
353 Presolve<T>& presolve, /**< PaPILO's presolve object */
354 SCIP_PRESOLMILPDATA* data, /**< presolver data structure */
355 SCIP_Bool allowconsmodification /**< whether constraint modifications are allowed */
356 )
357{
358 SCIP_Real timelimit;
359
360 /* important so that SCIP does not throw an error, e.g. when an integer variable is substituted
361 * into a knapsack constraint */
362 presolve.getPresolveOptions().substitutebinarieswithints = false;
363
364 /* currently these changes cannot be communicated to SCIP correctly since a constraint needs
365 * to be modified in the cases where slackvariables are removed from constraints but for the
366 * presolve library those look like normal substitution on the postsolve stack */
367 presolve.getPresolveOptions().removeslackvars = false;
368
369 /* communicate the SCIP parameters to the presolve library */
370 presolve.getPresolveOptions().maxfillinpersubstitution = data->maxfillinpersubstitution;
371 presolve.getPresolveOptions().markowitz_tolerance = data->markowitztolerance;
372 presolve.getPresolveOptions().maxshiftperrow = data->maxshiftperrow;
373 presolve.getPresolveOptions().hugeval = data->hugebound;
374
375 /* removal of linear dependent equations has only an effect when constraint modifications are communicated */
376 presolve.getPresolveOptions().detectlindep = allowconsmodification ? data->detectlineardependency : 0;
377
378 /* communicate the random seed */
379 presolve.getPresolveOptions().randomseed = SCIPinitializeRandomSeed(scip, (unsigned int)data->randomseed);
380
381 /* set number of threads to be used for presolve */
382 presolve.getPresolveOptions().threads = data->threads;
383
384#if PAPILO_VERSION_MAJOR > 2 || (PAPILO_VERSION_MAJOR == 2 && PAPILO_VERSION_MINOR >= 3)
385 presolve.getPresolveOptions().maxrounds = data->internalmaxrounds;
386#endif
387
388 /* disable dual reductions that are not permitted */
389 if( SCIPallowStrongDualReds(scip) )
390 presolve.getPresolveOptions().dualreds = 2;
391 else if( SCIPallowWeakDualReds(scip) )
392 presolve.getPresolveOptions().dualreds = 1;
393 else
394 presolve.getPresolveOptions().dualreds = 0;
395
396 /* set up the presolvers that shall participate */
397 using uptr = std::unique_ptr<PresolveMethod<T>>;
398
399 /* fast presolvers*/
400 presolve.addPresolveMethod( uptr( new SingletonCols<T>() ) );
401 presolve.addPresolveMethod( uptr( new CoefficientStrengthening<T>() ) );
402 presolve.addPresolveMethod( uptr( new ConstraintPropagation<T>() ) );
403
404 /* medium presolver */
405 presolve.addPresolveMethod( uptr( new SimpleProbing<T>() ) );
406 if( data->enableparallelrows )
407 presolve.addPresolveMethod( uptr( new ParallelRowDetection<T>() ) );
408 /* todo: parallel cols cannot be handled by SCIP currently
409 * addPresolveMethod( uptr( new ParallelColDetection<SCIP_Real>() ) ); */
410 presolve.addPresolveMethod( uptr( new SingletonStuffing<T>() ) );
411#if PAPILO_VERSION_MAJOR > 2 || (PAPILO_VERSION_MAJOR == 2 && PAPILO_VERSION_MINOR >= 1)
412 DualFix<T> *dualfix = new DualFix<T>();
413 dualfix->set_fix_to_infinity_allowed(false);
414 presolve.addPresolveMethod( uptr( dualfix ) );
415#else
416 presolve.addPresolveMethod( uptr( new DualFix<SCIP_Real>() ) );
417#endif
418 presolve.addPresolveMethod( uptr( new FixContinuous<T>() ) );
419 presolve.addPresolveMethod( uptr( new SimplifyInequalities<T>() ) );
420 presolve.addPresolveMethod( uptr( new SimpleSubstitution<T>() ) );
421#if PAPILO_APIVERSION >= 6
422 if( data->enablecliquemerging )
423 {
424 CliqueMerging<T>* cliquemerging = new CliqueMerging<T>();
425 cliquemerging->setParameters( data->maxedgesparallel, data->maxedgessequential,
426 data->maxcliquesize, data->maxgreedycalls );
427 presolve.addPresolveMethod( uptr( cliquemerging ) );
428 }
429#endif
430
431 /* exhaustive presolvers*/
432 presolve.addPresolveMethod( uptr( new ImplIntDetection<T>() ) );
433 if( data->enabledualinfer )
434 presolve.addPresolveMethod( uptr( new DualInfer<T>() ) );
435 if( data->enableprobing )
436 {
437#if PAPILO_VERSION_MAJOR > 2 || (PAPILO_VERSION_MAJOR == 2 && PAPILO_VERSION_MINOR >= 1)
438 Probing<T> *probing = new Probing<T>();
439 if( presolve.getPresolveOptions().runs_sequential() )
440 {
441 probing->set_max_badge_size( data->maxbadgesizeseq );
442 }
443 else
444 {
445 probing->set_max_badge_size( data->maxbadgesizepar );
446 }
447 presolve.addPresolveMethod( uptr( probing ) );
448#else
449 presolve.addPresolveMethod( uptr( new Probing<T>() ) );
450 if( data->maxbadgesizeseq != DEFAULT_MAXBADGESIZE_SEQ )
451 SCIPverbMessage(scip, SCIP_VERBLEVEL_HIGH, NULL,
452 " The parameter 'presolving/milp/maxbadgesizeseq' can only be used with PaPILO 2.1.0 or later versions.\n");
453
454 if( data->maxbadgesizepar != DEFAULT_MAXBADGESIZE_PAR )
455 SCIPverbMessage(scip, SCIP_VERBLEVEL_HIGH, NULL,
456 " The parameter 'presolving/milp/maxbadgesizepar' can only be used with PaPILO 2.1.0 or later versions.\n");
457#endif
458 }
459 if( data->enabledomcol )
460 presolve.addPresolveMethod( uptr( new DominatedCols<T>() ) );
461 if( data->enablemultiaggr )
462 presolve.addPresolveMethod( uptr( new Substitution<T>() ) );
463 if( data->enablesparsify )
464 presolve.addPresolveMethod( uptr( new Sparsify<T>() ) );
465
466 /* set numerical tolerances */
467#if PAPILO_APIVERSION >= 3
468 presolve.getPresolveOptions().useabsfeas = false;
469#endif
470 if( SCIPisExact(scip) )
471 {
472 presolve.getPresolveOptions().epsilon = 0.0;
473 presolve.getPresolveOptions().feastol = 0.0;
474 }
475 else
476 {
477 presolve.getPresolveOptions().epsilon = SCIPepsilon(scip);
478 presolve.getPresolveOptions().feastol = SCIPfeastol(scip);
479 }
480
481#ifndef SCIP_PRESOLLIB_ENABLE_OUTPUT
482 /* adjust output settings of presolve library */
483 presolve.setVerbosityLevel((VerbosityLevel) data->verbosity);
484#endif
485
486#if PAPILO_APIVERSION >= 2
487 presolve.getPresolveOptions().abortfac = data->abortfacexhaustive;
488 presolve.getPresolveOptions().abortfacmedium = data->abortfacmedium;
489 presolve.getPresolveOptions().abortfacfast = data->abortfacfast;
490#endif
491
492 /* communicate the time limit */
493 SCIPgetRealParam(scip, "limits/time", &timelimit);
494 if( !SCIPisInfinity(scip, timelimit) )
495 presolve.getPresolveOptions().tlim = timelimit - SCIPgetSolvingTime(scip);
496
497 return SCIP_OKAY;
498}
499
500
501#if defined(PAPILO_WITH_EXACTPRESOLVE)
502/** calls PaPILO presolving in rational arithmetic*/
503static
504SCIP_RETCODE performRationalPresolving(
505 SCIP* scip, /**< SCIP data structure */
506 SCIP_MATRIX* matrix, /**< initialized SCIP_MATRIX data structure */
507 SCIP_PRESOLMILPDATA* data, /**< plugin specific presol data */
508 SCIP_Bool initialized, /**< was the matrix initialized */
509 int* nfixedvars, /**< store number of fixed variables */
510 int* naggrvars, /**< store number of aggregated variables */
511 int* nchgvartypes, /**< store number of changed variable types */
512 int* nchgbds, /**< store number of changed bounds */
513 int* naddholes, /**< store number of added holes */
514 int* ndelconss, /**< store the number of deleted cons */
515 int* naddconss, /**< store the number of added cons */
516 int* nupgdconss, /**< store the number of upgraded cons */
517 int* nchgcoefs, /**< store the number of changed coefficients */
518 int* nchgsides, /**< store the number of changed sides */
519 SCIP_RESULT* result /**< result pointer */
520 )
521{
522 int nvars = SCIPgetNVars(scip);
523 int nconss = SCIPgetNConss(scip);
524
525 SCIP_CONSHDLR* linconshdlr = SCIPfindConshdlr(scip, "exactlinear");
526 assert(linconshdlr != NULL);
527 bool allowconsmodification = (SCIPconshdlrGetNCheckConss(linconshdlr) == SCIPmatrixGetNRows(matrix));
528
529 /* store current numbers of aggregations, fixings, and changed bounds for statistics */
530 int oldnaggrvars = *naggrvars;
531 int oldnfixedvars = *nfixedvars;
532 int oldnchgbds = *nchgbds;
533
534 Problem<papilo::Rational> problem = buildProblemRational(scip, matrix);
535 Presolve<papilo::Rational> presolve;
536 setupPresolve(scip, presolve, data, allowconsmodification);
537
538 /* call presolving (without storing information for dual postsolve) */
539 SCIPverbMessage(scip, SCIP_VERBLEVEL_HIGH, NULL,
540 " (%.1fs) running MILP presolver%s\n", SCIPgetSolvingTime(scip),
541 presolve.getPresolveOptions().threads == 1 ? "" : " on multiple threads");
542
543 int oldnnz = problem.getConstraintMatrix().getNnz();
544
545#if (PAPILO_VERSION_MAJOR >= 2)
546 PresolveResult<papilo::Rational> res = presolve.apply(problem, false);
547#else
548 PresolveResult<papilo::Rational> res = presolve.apply(problem);
549#endif
550 data->lastncols = problem.getNCols();
551 data->lastnrows = problem.getNRows();
552
553 /* evaluate the result */
554 switch( res.status )
555 {
556 case PresolveStatus::kInfeasible:
557 *result = SCIP_CUTOFF;
558 SCIPverbMessage(scip, SCIP_VERBLEVEL_HIGH, NULL,
559 " (%.1fs) MILP presolver detected infeasibility\n",
560 SCIPgetSolvingTime(scip));
561 SCIPmatrixFree(scip, &matrix);
562 return SCIP_OKAY;
563 case PresolveStatus::kUnbndOrInfeas:
564 case PresolveStatus::kUnbounded:
565 *result = SCIP_UNBOUNDED;
566 SCIPverbMessage(scip, SCIP_VERBLEVEL_HIGH, NULL,
567 " (%.1fs) MILP presolver detected unboundedness\n",
568 SCIPgetSolvingTime(scip));
569 SCIPmatrixFree(scip, &matrix);
570 return SCIP_OKAY;
571 case PresolveStatus::kUnchanged:
572 *result = SCIP_DIDNOTFIND;
573 data->lastncols = nvars;
574 data->lastnrows = nconss;
575 SCIPverbMessage(scip, SCIP_VERBLEVEL_HIGH, NULL,
576 " (%.1fs) MILP presolver found nothing\n",
577 SCIPgetSolvingTime(scip));
578 SCIPmatrixFree(scip, &matrix);
579 return SCIP_OKAY;
580 case PresolveStatus::kReduced:
581 data->lastncols = problem.getNCols();
582 data->lastnrows = problem.getNRows();
583 *result = SCIP_SUCCESS;
584 }
585
586 /* result indicated success, now populate the changes into the SCIP structures */
587 Vec<SCIP_VAR*> tmpvars;
588 Vec<SCIP_Real> tmpvalsreal;
589
590 /* if the number of nonzeros decreased by a sufficient factor, rather create all constraints from scratch */
591 int newnnz = problem.getConstraintMatrix().getNnz();
592 bool constraintsReplaced = false;
593 if( newnnz == 0 || (allowconsmodification &&
594 (problem.getNRows() <= data->modifyconsfac * data->lastnrows ||
595 newnnz <= data->modifyconsfac * oldnnz)) )
596 {
597 int oldnrows = SCIPmatrixGetNRows(matrix);
598 int newnrows = problem.getNRows();
599
600 constraintsReplaced = true;
601
602 /* capture constraints that are still present in the problem after presolve */
603 for( int i = 0; i < newnrows; ++i )
604 {
605 SCIP_CONS* c = SCIPmatrixGetCons(matrix, res.postsolve.origrow_mapping[i]);
606 SCIP_CALL( SCIPcaptureCons(scip, c) );
607 }
608
609 /* delete all constraints */
610 *ndelconss += oldnrows;
611 *naddconss += newnrows;
612
613 for( int i = 0; i < oldnrows; ++i )
614 {
615 SCIP_CALL( SCIPdelCons(scip, SCIPmatrixGetCons(matrix, i)) );
616 }
617
618 /* now loop over rows of presolved problem and create them as new linear constraints,
619 * then release the old constraint after its name was passed to the new constraint
620 */
621 const Vec<RowFlags>& rflags = problem.getRowFlags();
622 const auto& consmatrix = problem.getConstraintMatrix();
623 for( int i = 0; i < newnrows; ++i )
624 {
625 auto rowvec = consmatrix.getRowCoefficients(i);
626 const int* rowcols = rowvec.getIndices();
627 /* SCIPcreateConsBasicLinear() requires a non const pointer */
628 papilo::Rational* rowvals = const_cast<papilo::Rational*>(rowvec.getValues());
629 int rowlen = rowvec.getLength();
630
631 /* retrieve SCIP compatible left and right hand sides */
632 papilo::Rational lhs = rflags[i].test(RowFlag::kLhsInf) ? - SCIPinfinity(scip) : consmatrix.getLeftHandSides()[i];
633 papilo::Rational rhs = rflags[i].test(RowFlag::kRhsInf) ? SCIPinfinity(scip) : consmatrix.getRightHandSides()[i];
634
635 /* create variable array matching the value array */
636 tmpvars.clear();
637 tmpvars.reserve(rowlen);
638 for( int j = 0; j < rowlen; ++j )
639 tmpvars.push_back(SCIPmatrixGetVar(matrix, res.postsolve.origcol_mapping[rowcols[j]]));
640
641 /* create and add new constraint with name of old constraint */
642 SCIP_CONS* oldcons = SCIPmatrixGetCons(matrix, res.postsolve.origrow_mapping[i]);
643 SCIP_CONS* cons;
644 SCIP_RATIONAL** tmpvals;
645 SCIP_RATIONAL* tmplhs;
646 SCIP_RATIONAL* tmprhs;
647
648 SCIP_CALL( SCIPrationalCreateBufferArray(SCIPbuffer(scip), &tmpvals, rowlen) );
649 SCIP_CALL( SCIPrationalCreateBuffer(SCIPbuffer(scip), &tmprhs) );
650 SCIP_CALL( SCIPrationalCreateBuffer(SCIPbuffer(scip), &tmplhs) );
651
652 for( int j = 0; j < rowlen; j++ )
653 setRational(scip, tmpvals[j], rowvals[j]);
654
655 setRational(scip, tmprhs, rhs);
656 setRational(scip, tmplhs, lhs);
657 if( rflags[i].test(RowFlag::kLhsInf) )
658 SCIPrationalSetNegInfinity(tmplhs);
659 if( rflags[i].test(RowFlag::kRhsInf) )
660 SCIPrationalSetInfinity(tmprhs);
661
662 SCIP_CALL( SCIPcreateConsBasicExactLinear(scip, &cons, SCIPconsGetName(oldcons), rowlen, tmpvars.data(), tmpvals, tmplhs, tmprhs) );
663 SCIP_CALL( SCIPaddCons(scip, cons) );
664
665 /* release old and new constraint */
666 SCIP_CALL( SCIPreleaseCons(scip, &oldcons) );
667 SCIP_CALL( SCIPreleaseCons(scip, &cons) );
668
669 SCIPrationalFreeBuffer(SCIPbuffer(scip), &tmprhs);
670 SCIPrationalFreeBuffer(SCIPbuffer(scip), &tmplhs);
671 SCIPrationalFreeBufferArray(SCIPbuffer(scip), &tmpvals, rowlen);
672 }
673 }
674
675 /* loop over res.postsolve and add all fixed variables and aggregations to scip */
676 for( std::size_t i = 0; i != res.postsolve.types.size(); ++i )
677 {
678 ReductionType type =
679 res.postsolve.types[i];
680 int first = res.postsolve.start[i];
681 int last = res.postsolve.start[i + 1];
682
683 switch( type )
684 {
685 case ReductionType::kFixedCol:
686 {
687 SCIP_RATIONAL* tmpval;
688 SCIP_Bool infeas;
689 SCIP_Bool fixed;
690 int col = res.postsolve.indices[first];
691
692 SCIP_VAR* var = SCIPmatrixGetVar(matrix, col);
693
694 papilo::Rational value = res.postsolve.values[first];
695
696 SCIP_CALL( SCIPrationalCreateBuffer(SCIPbuffer(scip), &tmpval) );
697 setRational(scip, tmpval, value);
698
699 SCIPrationalDebugMessage("Papilo fix var %s to %q \n", SCIPvarGetName(var), tmpval);
700
701 /* SCIP has different rules for aggregation than PaPILO
702 * As a result, SCIP might have aggregated and replaced the variable that PaPILO now wants to fix
703 */
704 if( SCIPvarGetStatusExact(var) == SCIP_VARSTATUS_AGGREGATED )
705 {
706 SCIP_RATIONAL* aggregatedScalar;
707 SCIP_RATIONAL* aggregatedConst;
708
709 aggregatedScalar = SCIPvarGetAggrScalarExact(var);
710 aggregatedConst = SCIPvarGetAggrConstantExact(var);
711
712 /* fix aggregation variable y in x = a*y + c, instead of fixing x directly */
713 assert( SCIPrationalIsZero(SCIPvarGetObjExact(var)) );
714 assert( !SCIPrationalIsZero(aggregatedScalar));
715 if( SCIPrationalIsAbsInfinity(tmpval) )
716 SCIPrationalMultReal(tmpval, tmpval, SCIPrationalIsNegative(aggregatedScalar) ? -1 : 1);
717 else
718 {
719 SCIPrationalDiff(tmpval, tmpval, aggregatedConst);
720 SCIPrationalDiv(tmpval, tmpval, aggregatedScalar);
721 }
722 var = SCIPvarGetAggrVar(var);
723 }
724
725 /* SCIP might also have fixed the variable during aggregation */
726 if( SCIPvarGetStatus(var) == SCIP_VARSTATUS_FIXED )
727 break;
728
729 SCIP_CALL( SCIPfixVarExact(scip, var, tmpval, &infeas, &fixed) );
730
731 *nfixedvars += 1;
732
733 SCIPrationalFreeBuffer(SCIPbuffer(scip), &tmpval);
734
735 assert(!infeas);
736 assert(fixed || SCIPvarGetStatus(var) == SCIP_VARSTATUS_AGGREGATED ||
737 SCIPvarGetStatus(var) == SCIP_VARSTATUS_FIXED || SCIPvarGetStatus(var) == SCIP_VARSTATUS_NEGATED);
738 break;
739 }
740 /*
741 * Dual-postsolving in PaPILO required introducing a postsolve-type for substitution with additional information.
742 * Further, the different Substitution-postsolving types store the required postsolving data differently (in different order) in the postsolving stack.
743 * Therefore, we need to distinguish how to parse the required data (rowLength, col, side, startRowCoefficients, lastRowCoefficients) from the postsolving stack.
744 * If these values are accessed, the procedure is the same for both.
745 */
746#if (PAPILO_VERSION_MAJOR >= 2)
747 case ReductionType::kSubstitutedColWithDual:
748#endif
749 case ReductionType::kSubstitutedCol:
750 {
751 int col = 0;
752 papilo::Rational side = 0;
753
754 int rowlen = 0;
755 int startRowCoefficients = 0;
756 int lastRowCoefficients = 0;
757
758 if( type == ReductionType::kSubstitutedCol )
759 {
760 rowlen = last - first - 1;
761 col = res.postsolve.indices[first];
762 side = res.postsolve.values[first];
763
764 startRowCoefficients = first + 1;
765 lastRowCoefficients = last;
766 }
767#if (PAPILO_VERSION_MAJOR >= 2)
768 if( type == ReductionType::kSubstitutedColWithDual )
769 {
770 rowlen = (int) res.postsolve.values[first];
771 col = res.postsolve.indices[first + 3 + rowlen];
772 side = res.postsolve.values[first + 1];
773
774 startRowCoefficients = first + 3;
775 lastRowCoefficients = first + 3 + rowlen;
776
777 assert(side == res.postsolve.values[first + 2]);
778 assert(res.postsolve.indices[first + 1] == 0);
779 assert(res.postsolve.indices[first + 2] == 0);
780 }
781 assert( type == ReductionType::kSubstitutedCol || type == ReductionType::kSubstitutedColWithDual );
782#else
783 assert( type == ReductionType::kSubstitutedCol );
784#endif
785 SCIP_Bool infeas;
786 SCIP_Bool aggregated;
787 SCIP_Bool redundant = FALSE;
788 SCIP_RATIONAL* constant;
789 if( rowlen == 2 )
790 {
791 SCIP_VAR* varx = SCIPmatrixGetVar(matrix, res.postsolve.indices[startRowCoefficients]);
792 SCIP_VAR* vary = SCIPmatrixGetVar(matrix, res.postsolve.indices[startRowCoefficients + 1]);
793 papilo::Rational scalarx = res.postsolve.values[startRowCoefficients];
794 papilo::Rational scalary = res.postsolve.values[startRowCoefficients + 1];
795
796 SCIP_RATIONAL* tmpscalarx;
797 SCIP_RATIONAL* tmpscalary;
798 SCIP_RATIONAL* tmpside;
799 SCIP_CALL( SCIPrationalCreateBuffer(SCIPbuffer(scip), &constant) );
800 SCIP_CALL( SCIPrationalCreateBuffer(SCIPbuffer(scip), &tmpscalarx) );
801 SCIP_CALL( SCIPrationalCreateBuffer(SCIPbuffer(scip), &tmpscalary) );
802 SCIP_CALL( SCIPrationalCreateBuffer(SCIPbuffer(scip), &tmpside) );
803
804 setRational(scip, tmpscalarx, scalarx);
805 setRational(scip, tmpscalary, scalary);
806
807 SCIP_CALL( SCIPgetProbvarSumExact(scip, &varx, tmpscalarx, constant) );
808 assert(SCIPvarGetStatus(varx) != SCIP_VARSTATUS_MULTAGGR);
809
810 SCIP_CALL( SCIPgetProbvarSumExact(scip, &vary, tmpscalary, constant) );
811 assert(SCIPvarGetStatus(vary) != SCIP_VARSTATUS_MULTAGGR);
812
813 setRational(scip, tmpside, side);
814 SCIPrationalDiff(tmpside, tmpside, constant);
815
816 SCIPrationalDebugMessage("Papilo aggregate vars %s, %s with scalars %q, %q and constant %q \n", SCIPvarGetName(varx), SCIPvarGetName(vary),
817 tmpscalarx, tmpscalary, constant);
818
819 SCIP_CALL( SCIPaggregateVarsExact(scip, varx, vary, tmpscalarx, tmpscalary, tmpside, &infeas, &redundant, &aggregated) );
820
821 SCIPrationalFreeBuffer(SCIPbuffer(scip), &tmpside);
822 SCIPrationalFreeBuffer(SCIPbuffer(scip), &tmpscalary);
823 SCIPrationalFreeBuffer(SCIPbuffer(scip), &tmpscalarx);
824 SCIPrationalFreeBuffer(SCIPbuffer(scip), &constant);
825 }
826 else
827 {
828 SCIP_RATIONAL* colCoef;
829 SCIP_RATIONAL* updatedSide;
830 SCIP_RATIONAL** tmpvals;
831 int c = 0;
832
833 SCIP_CALL( SCIPrationalCreateBuffer(SCIPbuffer(scip), &constant) );
834 SCIP_CALL( SCIPrationalCreateBuffer(SCIPbuffer(scip), &colCoef) );
835 SCIP_CALL( SCIPrationalCreateBuffer(SCIPbuffer(scip), &updatedSide) );
836 SCIP_CALL( SCIPrationalCreateBufferArray(SCIPbuffer(scip), &tmpvals, rowlen) );
837
838 for( int j = startRowCoefficients; j < lastRowCoefficients; ++j )
839 {
840 if( res.postsolve.indices[j] == col )
841 {
842 setRational(scip, colCoef, res.postsolve.values[j]);
843 break;
844 }
845 }
846
847 tmpvars.clear();
848 tmpvars.reserve(rowlen);
849
850 assert(!SCIPrationalIsZero(colCoef));
851 SCIP_VAR* aggrvar = SCIPmatrixGetVar(matrix, col);
852
853 SCIP_CALL( SCIPgetProbvarSumExact(scip, &aggrvar, colCoef, constant) );
854 assert(SCIPvarGetStatus(aggrvar) != SCIP_VARSTATUS_MULTAGGR);
855
856 for( int j = startRowCoefficients; j < lastRowCoefficients; ++j )
857 {
858 if( res.postsolve.indices[j] == col )
859 continue;
860
861 tmpvars.push_back(SCIPmatrixGetVar(matrix, res.postsolve.indices[j]));
862 setRational(scip, tmpvals[c], -res.postsolve.values[j] / colCoef->val);
863 c++;
864 }
865 setRational(scip, updatedSide, side);
866 SCIPrationalDiff(updatedSide, updatedSide, constant);
867 SCIPrationalDiv(updatedSide, updatedSide, colCoef);
868
869 SCIPrationalDebugMessage("Papilo multiaggregate var %s, constant %q \n", SCIPvarGetName(aggrvar), updatedSide);
870
871 SCIP_CALL( SCIPmultiaggregateVarExact(scip, aggrvar, tmpvars.size(),
872 tmpvars.data(), tmpvals, updatedSide, &infeas, &aggregated) );
873
874 SCIPrationalFreeBufferArray(SCIPbuffer(scip), &tmpvals, rowlen);
875 SCIPrationalFreeBuffer(SCIPbuffer(scip), &updatedSide);
876 SCIPrationalFreeBuffer(SCIPbuffer(scip), &colCoef);
877 SCIPrationalFreeBuffer(SCIPbuffer(scip), &constant);
878 }
879
880 if( aggregated )
881 *naggrvars += 1;
882 else if( constraintsReplaced && !redundant )
883 {
884 /* if the constraints where replaced, we need to add the failed substitution as an equality to SCIP */
885 SCIP_RATIONAL** tmpvals;
886 SCIP_RATIONAL* tmpside;
887
888 SCIP_CALL( SCIPrationalCreateBufferArray(SCIPbuffer(scip), &tmpvals, rowlen) );
889 SCIP_CALL( SCIPrationalCreateBuffer(SCIPbuffer(scip), &tmpside) );
890
891 setRational(scip, tmpside, side);
892
893 tmpvars.clear();
894 for( int j = startRowCoefficients; j < lastRowCoefficients; ++j )
895 {
896 int idx = j - startRowCoefficients;
897 tmpvars.push_back(SCIPmatrixGetVar(matrix, res.postsolve.indices[j]));
898 setRational(scip, tmpvals[idx], res.postsolve.values[j]);
899 }
900
901 SCIP_CONS* cons;
902 String name = fmt::format("{}_failed_aggregation_equality", SCIPvarGetName(SCIPmatrixGetVar(matrix, col)));
903 SCIP_CALL( SCIPcreateConsBasicExactLinear(scip, &cons, name.c_str(),
904 tmpvars.size(), tmpvars.data(), tmpvals, tmpside, tmpside ) );
905
906 SCIPdebugMessage("Papilo adding failed aggregation equality: \n");
907 SCIPdebug(SCIPprintCons(scip, cons, NULL));
908 SCIP_CALL( SCIPaddCons(scip, cons) );
909 SCIP_CALL( SCIPreleaseCons(scip, &cons) );
910 *naddconss += 1;
911
912 SCIPrationalFreeBuffer(SCIPbuffer(scip), &tmpside);
913 SCIPrationalFreeBufferArray(SCIPbuffer(scip), &tmpvals, rowlen);
914 }
915
916 if( infeas )
917 {
918 *result = SCIP_CUTOFF;
919 break;
920 }
921
922 break;
923 }
924 case ReductionType::kParallelCol:
925 return SCIP_INVALIDRESULT;
926#if (PAPILO_VERSION_MAJOR <= 1 && PAPILO_VERSION_MINOR==0)
927#else
928 case ReductionType::kFixedInfCol: {
929 if(!constraintsReplaced)
930 continue;
931 SCIP_Bool infeas;
932 SCIP_Bool fixed;
933 SCIP_RATIONAL* value;
934
935 SCIP_CALL( SCIPrationalCreateBuffer(SCIPbuffer(scip), &value) );
936 SCIPrationalSetInfinity(value);
937
938 int column = res.postsolve.indices[first];
939 bool is_negative_infinity = res.postsolve.values[first] < 0;
940 SCIP_VAR* column_variable = SCIPmatrixGetVar(matrix, column);
941
942 if( is_negative_infinity )
943 {
944 SCIPrationalSetNegInfinity(value);
945 }
946
947 SCIP_CALL( SCIPfixVarExact(scip, column_variable, value, &infeas, &fixed) );
948 *nfixedvars += 1;
949
950 assert(!infeas);
951 assert(fixed);
952
953 SCIPrationalFreeBuffer(SCIPbuffer(scip), &value);
954
955 break;
956 }
957#endif
958#if (PAPILO_VERSION_MAJOR >= 2)
959 case ReductionType::kVarBoundChange :
960 case ReductionType::kRedundantRow :
961 case ReductionType::kRowBoundChange :
962 case ReductionType::kReasonForRowBoundChangeForcedByRow :
963 case ReductionType::kRowBoundChangeForcedByRow :
964 case ReductionType::kSaveRow :
965 case ReductionType::kReducedBoundsCost :
966 case ReductionType::kColumnDualValue :
967 case ReductionType::kRowDualValue :
968 case ReductionType::kCoefficientChange :
969 /* dual ReductionTypes should be only calculated for dual reductions and should not appear for MIP */
970 SCIPerrorMessage("PaPILO: PaPILO should not return dual postsolving reductions in SCIP!!\n");
971 SCIPABORT(); /*lint --e{527}*/
972 break;
973#endif
974 default:
975 SCIPdebugMsg(scip, "PaPILO returned unknown data type: \n" );
976 continue;
977 }
978 }
979
980 /* tighten bounds of variables that are still present after presolving */
981 if( *result != SCIP_CUTOFF )
982 {
983 VariableDomains<papilo::Rational>& varDomains = problem.getVariableDomains();
984 SCIP_RATIONAL* varbound;
985 SCIP_CALL( SCIPrationalCreateBuffer(SCIPbuffer(scip), &varbound) );
986 varbound->isfprepresentable = SCIP_ISFPREPRESENTABLE_UNKNOWN;
987
988 for( int i = 0; i != problem.getNCols(); ++i )
989 {
990 SCIP_VAR* var = SCIPmatrixGetVar(matrix, res.postsolve.origcol_mapping[i]);
991 if( !varDomains.flags[i].test(ColFlag::kLbInf) )
992 {
993 SCIP_Bool infeas;
994 SCIP_Bool tightened;
995
996 setRational(scip, varbound, varDomains.lower_bounds[i]);
997
998 SCIP_CALL( SCIPtightenVarLbExact(scip, var, varbound, &infeas, &tightened) );
999
1000 if( tightened )
1001 {
1002 *nchgbds += 1;
1003 SCIPrationalDebugMessage("Papilo tightened lb of variable %s \n", SCIPvarGetName(var));
1004 }
1005
1006 if( infeas )
1007 {
1008 *result = SCIP_CUTOFF;
1009 break;
1010 }
1011 }
1012
1013 if( !varDomains.flags[i].test(ColFlag::kUbInf) )
1014 {
1015 SCIP_Bool infeas;
1016 SCIP_Bool tightened;
1017 setRational(scip, varbound, varDomains.upper_bounds[i]);
1018
1019 SCIP_CALL( SCIPtightenVarUbExact(scip, var, varbound, &infeas, &tightened) );
1020
1021 if( tightened )
1022 {
1023 *nchgbds += 1;
1024 SCIPrationalDebugMessage("Papilo tightened ub of variable %s \n", SCIPvarGetName(var));
1025 }
1026
1027 if( infeas )
1028 {
1029 *result = SCIP_CUTOFF;
1030 break;
1031 }
1032 }
1033 }
1034
1035 SCIPrationalFreeBuffer(SCIPbuffer(scip), &varbound);
1036 }
1037
1038 /* finish with a final verb message and return */
1039 SCIPverbMessage(scip, SCIP_VERBLEVEL_HIGH, NULL,
1040 " (%.1fs) MILP presolver (%d rounds): %d aggregations, %d fixings, %d bound changes\n",
1041 SCIPgetSolvingTime(scip), presolve.getStatistics().nrounds, *naggrvars - oldnaggrvars,
1042 *nfixedvars - oldnfixedvars, *nchgbds - oldnchgbds);
1043
1044 /* free the matrix */
1045 assert(initialized);
1046 SCIPmatrixFree(scip, &matrix);
1047
1048 return SCIP_OKAY;
1049}
1050#endif
1051
1052/** calls PaPILO presolving in floating-point arithmetic */
1053static
1054SCIP_RETCODE performRealPresolving(
1055 SCIP* scip, /**< SCIP data structure */
1056 SCIP_MATRIX* matrix, /**< initialized SCIP_MATRIX data structure */
1057 SCIP_PRESOLMILPDATA* data, /**< plugin specific presol data */
1058 SCIP_Bool initialized, /**< was the matrix initialized */
1059 int* nfixedvars, /**< store number of fixed variables */
1060 int* naggrvars, /**< store number of aggregated variables */
1061 int* nchgvartypes, /**< store number of changed variable types */
1062 int* nchgbds, /**< store number of changed bounds */
1063 int* naddholes, /**< store number of added holes */
1064 int* ndelconss, /**< store the number of deleted cons */
1065 int* naddconss, /**< store the number of added cons */
1066 int* nupgdconss, /**< store the number of upgraded cons */
1067 int* nchgcoefs, /**< store the number of changed coefficients */
1068 int* nchgsides, /**< store the number of changed sides */
1069 SCIP_RESULT* result /**< result pointer */
1070 )
1071{
1072 int nvars = SCIPgetNVars(scip);
1073 int nconss = SCIPgetNConss(scip);
1074
1075 /* only allow communication of constraint modifications by deleting all constraints when some already have been upgraded */
1076 SCIP_CONSHDLR* linconshdlr = SCIPfindConshdlr(scip, "linear");
1077 assert(linconshdlr != NULL);
1078 SCIP_Bool allowconsmodification = (SCIPconshdlrGetNCheckConss(linconshdlr) == SCIPmatrixGetNRows(matrix));
1079
1080 /* store current numbers of aggregations, fixings, and changed bounds for statistics */
1081 int oldnaggrvars = *naggrvars;
1082 int oldnfixedvars = *nfixedvars;
1083 int oldnchgbds = *nchgbds;
1084
1085 /* create presolving objects */
1086 Problem<SCIP_Real> problem = buildProblemReal(scip, matrix);
1087 int oldnnz = problem.getConstraintMatrix().getNnz();
1088 Presolve<SCIP_Real> presolve;
1089 setupPresolve(scip, presolve, data, allowconsmodification);
1090
1091 /* call the presolving */
1092 SCIPverbMessage(scip, SCIP_VERBLEVEL_HIGH, NULL,
1093 " (%.1fs) running MILP presolver%s\n", SCIPgetSolvingTime(scip),
1094 presolve.getPresolveOptions().threads == 1 ? "" : " on multiple threads");
1095
1096 /* call presolving without storing information for dual postsolve */
1097#if (PAPILO_VERSION_MAJOR >= 2)
1098 PresolveResult<SCIP_Real> res = presolve.apply(problem, false);
1099#else
1100 PresolveResult<SCIP_Real> res = presolve.apply(problem);
1101#endif
1102 data->lastncols = problem.getNCols();
1103 data->lastnrows = problem.getNRows();
1104
1105 /* evaluate the result */
1106 switch( res.status )
1107 {
1108 case PresolveStatus::kInfeasible:
1109 *result = SCIP_CUTOFF;
1110 SCIPverbMessage(scip, SCIP_VERBLEVEL_HIGH, NULL,
1111 " (%.1fs) MILP presolver detected infeasibility\n",
1112 SCIPgetSolvingTime(scip));
1113 SCIPmatrixFree(scip, &matrix);
1114 return SCIP_OKAY;
1115 case PresolveStatus::kUnbndOrInfeas:
1116 case PresolveStatus::kUnbounded:
1117 *result = SCIP_UNBOUNDED;
1118 SCIPverbMessage(scip, SCIP_VERBLEVEL_HIGH, NULL,
1119 " (%.1fs) MILP presolver detected unboundedness\n",
1120 SCIPgetSolvingTime(scip));
1121 SCIPmatrixFree(scip, &matrix);
1122 return SCIP_OKAY;
1123 case PresolveStatus::kUnchanged:
1124 *result = SCIP_DIDNOTFIND;
1125 data->lastncols = nvars;
1126 data->lastnrows = nconss;
1127 SCIPverbMessage(scip, SCIP_VERBLEVEL_HIGH, NULL,
1128 " (%.1fs) MILP presolver found nothing\n",
1129 SCIPgetSolvingTime(scip));
1130 SCIPmatrixFree(scip, &matrix);
1131 return SCIP_OKAY;
1132 case PresolveStatus::kReduced:
1133 data->lastncols = problem.getNCols();
1134 data->lastnrows = problem.getNRows();
1135 *result = SCIP_SUCCESS;
1136 }
1137
1138 /* result indicated success, now populate the changes into the SCIP structures */
1139
1140 /* tighten bounds of variables that are still present after presolving */
1141 VariableDomains<SCIP_Real>& varDomains = problem.getVariableDomains();
1142 for( int i = 0; i != problem.getNCols(); ++i )
1143 {
1144 assert( ! varDomains.flags[i].test(ColFlag::kInactive) );
1145 SCIP_VAR* var = SCIPmatrixGetVar(matrix, res.postsolve.origcol_mapping[i]);
1146 if( !varDomains.flags[i].test(ColFlag::kLbInf) )
1147 {
1148 SCIP_Bool infeas;
1149 SCIP_Bool tightened;
1150 SCIP_CALL( SCIPtightenVarLb(scip, var, varDomains.lower_bounds[i], TRUE, &infeas, &tightened) );
1151
1152 if( tightened )
1153 *nchgbds += 1;
1154
1155 if( infeas )
1156 {
1157 *result = SCIP_CUTOFF;
1158 break;
1159 }
1160 }
1161
1162 if( !varDomains.flags[i].test(ColFlag::kUbInf) )
1163 {
1164 SCIP_Bool infeas;
1165 SCIP_Bool tightened;
1166 SCIP_CALL( SCIPtightenVarUb(scip, var, varDomains.upper_bounds[i], TRUE, &infeas, &tightened) );
1167
1168 if( tightened )
1169 *nchgbds += 1;
1170
1171 if( infeas )
1172 {
1173 *result = SCIP_CUTOFF;
1174 break;
1175 }
1176 }
1177 }
1178
1179 if( *result == SCIP_CUTOFF )
1180 {
1181 SCIPverbMessage(scip, SCIP_VERBLEVEL_HIGH, NULL,
1182 " (%.1fs) MILP presolver detected infeasibility\n",
1183 SCIPgetSolvingTime(scip));
1184 SCIPmatrixFree(scip, &matrix);
1185 return SCIP_OKAY;
1186 }
1187
1188 /* transfer variable fixings and aggregations */
1189 Vec<SCIP_VAR*> tmpvars;
1190 Vec<SCIP_Real> tmpvals;
1191
1192 /* if the size of the problem decreased by a sufficient factor, create all constraints from scratch if allowed */
1193 int newnnz = problem.getConstraintMatrix().getNnz();
1194 bool constraintsReplaced = false;
1195 if( newnnz == 0 || (allowconsmodification &&
1196 (problem.getNCols() <= data->modifyconsfac * SCIPmatrixGetNColumns(matrix) ||
1197 problem.getNRows() <= data->modifyconsfac * SCIPmatrixGetNRows(matrix) ||
1198 newnnz <= data->modifyconsfac * oldnnz)) )
1199 {
1200 int oldnrows = SCIPmatrixGetNRows(matrix);
1201 int newnrows = problem.getNRows();
1202
1203 constraintsReplaced = true;
1204
1205 /* capture constraints that are still present in the problem after presolve */
1206 for( int i = 0; i < newnrows; ++i )
1207 {
1208 SCIP_CONS* c = SCIPmatrixGetCons(matrix, res.postsolve.origrow_mapping[i]);
1209 SCIP_CALL( SCIPcaptureCons(scip, c) );
1210 }
1211
1212 /* delete all constraints */
1213 *ndelconss += oldnrows;
1214 *naddconss += newnrows;
1215
1216 for( int i = 0; i < oldnrows; ++i )
1217 {
1218 SCIP_CALL( SCIPdelCons(scip, SCIPmatrixGetCons(matrix, i)) );
1219 }
1220
1221 /* now loop over rows of presolved problem and create them as new linear constraints,
1222 * then release the old constraint after its name was passed to the new constraint */
1223 const Vec<RowFlags>& rflags = problem.getRowFlags();
1224 const auto& consmatrix = problem.getConstraintMatrix();
1225 for( int i = 0; i < newnrows; ++i )
1226 {
1227 auto rowvec = consmatrix.getRowCoefficients(i);
1228 const int* rowcols = rowvec.getIndices();
1229 /* SCIPcreateConsBasicLinear() requires a non const pointer */
1230 SCIP_Real* rowvals = const_cast<SCIP_Real*>(rowvec.getValues());
1231 int rowlen = rowvec.getLength();
1232
1233 /* retrieve SCIP compatible left and right hand sides */
1234 SCIP_Real lhs = rflags[i].test(RowFlag::kLhsInf) ? - SCIPinfinity(scip) : consmatrix.getLeftHandSides()[i];
1235 SCIP_Real rhs = rflags[i].test(RowFlag::kRhsInf) ? SCIPinfinity(scip) : consmatrix.getRightHandSides()[i];
1236
1237 /* create variable array matching the value array */
1238 tmpvars.clear();
1239 tmpvars.reserve(rowlen);
1240 for( int j = 0; j < rowlen; ++j )
1241 tmpvars.push_back(SCIPmatrixGetVar(matrix, res.postsolve.origcol_mapping[rowcols[j]]));
1242
1243 /* create and add new constraint with name of old constraint */
1244 SCIP_CONS* oldcons = SCIPmatrixGetCons(matrix, res.postsolve.origrow_mapping[i]);
1245 SCIP_CONS* cons;
1246 SCIP_CALL( SCIPcreateConsBasicLinear(scip, &cons, SCIPconsGetName(oldcons), rowlen, tmpvars.data(), rowvals, lhs, rhs) );
1247 SCIP_CALL( SCIPaddCons(scip, cons) );
1248
1249 /* release old and new constraint */
1250 SCIP_CALL( SCIPreleaseCons(scip, &oldcons) );
1251 SCIP_CALL( SCIPreleaseCons(scip, &cons) );
1252 }
1253 }
1254
1255 /* PaPILO's aggregations are valid regarding the constraints as they were presolved by PaPILO.
1256 * If coefficients were changed, but constraints in SCIP are not replaced by those from PaPILO,
1257 * then it can not be guaranteed that the bounds of multiaggregated variables will be enforced,
1258 * i.e., will be implied by the constraints in SCIP (see also #3704).
1259 * Only for variable aggregations, SCIP will ensure this by tightening the bounds on the aggregation
1260 * variable as part of SCIPaggregateVars(). For multiaggregations, we will only accept those
1261 * where we can be sure with a simple check that the bounds on the aggregated variable are implied.
1262 */
1263 bool checkmultaggr =
1264#if PAPILO_APIVERSION >= 1
1265 presolve.getStatistics().single_matrix_coefficient_changes > 0
1266#else
1267 presolve.getStatistics().ncoefchgs > 0
1268#endif
1269 && !constraintsReplaced;
1270
1271 /* loop over res.postsolve and add all fixed variables and aggregations to scip */
1272 for( std::size_t i = 0; i != res.postsolve.types.size(); ++i )
1273 {
1274 ReductionType type = res.postsolve.types[i];
1275 int first = res.postsolve.start[i];
1276 int last = res.postsolve.start[i + 1];
1277
1278 switch( type )
1279 {
1280 case ReductionType::kFixedCol:
1281 {
1282 SCIP_Bool infeas;
1283 SCIP_Bool fixed;
1284 int col = res.postsolve.indices[first];
1285
1286 SCIP_VAR* var = SCIPmatrixGetVar(matrix, col);
1287
1288 SCIP_Real value = res.postsolve.values[first];
1289
1290 SCIP_CALL( SCIPfixVar(scip, var, value, &infeas, &fixed) );
1291 *nfixedvars += 1;
1292
1293 assert(!infeas);
1294 /* SCIP has different rules for aggregating variables than PaPILO: therefore the variable PaPILO
1295 * tries to fix now may have been aggregated by SCIP before. Additionally, after aggregation SCIP
1296 * sometimes performs bound tightening resulting in possible fixings. These cases need to be excluded. */
1297 assert(fixed || SCIPvarGetStatus(var) == SCIP_VARSTATUS_AGGREGATED ||
1298 SCIPvarGetStatus(var) == SCIP_VARSTATUS_FIXED || SCIPvarGetStatus(var) == SCIP_VARSTATUS_NEGATED);
1299 break;
1300 }
1301 /*
1302 * Dual-postsolving in PaPILO required introducing a postsolve-type for substitution with additional information.
1303 * Further, the different Substitution-postsolving types store the required postsolving data differently (in different order) in the postsolving stack.
1304 * Therefore, we need to distinguish how to parse the required data (rowLength, col, side, startRowCoefficients, lastRowCoefficients) from the postsolving stack.
1305 * If these values are accessed, the procedure is the same for both.
1306 */
1307#if (PAPILO_VERSION_MAJOR >= 2)
1308 case ReductionType::kSubstitutedColWithDual:
1309#endif
1310 case ReductionType::kSubstitutedCol:
1311 {
1312 int col = 0;
1313 SCIP_Real side = 0;
1314
1315 int rowlen = 0;
1316 int startRowCoefficients = 0;
1317 int lastRowCoefficients = 0;
1318
1319 if( type == ReductionType::kSubstitutedCol )
1320 {
1321 rowlen = last - first - 1;
1322 col = res.postsolve.indices[first];
1323 side = res.postsolve.values[first];
1324
1325 startRowCoefficients = first + 1;
1326 lastRowCoefficients = last;
1327 }
1328#if (PAPILO_VERSION_MAJOR >= 2)
1329 if( type == ReductionType::kSubstitutedColWithDual )
1330 {
1331 rowlen = (int) res.postsolve.values[first];
1332 col = res.postsolve.indices[first + 3 + rowlen];
1333 side = res.postsolve.values[first + 1];
1334
1335 startRowCoefficients = first + 3;
1336 lastRowCoefficients = first + 3 + rowlen;
1337
1338 assert(side == res.postsolve.values[first + 2]);
1339 assert(res.postsolve.indices[first + 1] == 0);
1340 assert(res.postsolve.indices[first + 2] == 0);
1341 }
1342 assert( type == ReductionType::kSubstitutedCol || type == ReductionType::kSubstitutedColWithDual );
1343#else
1344 assert( type == ReductionType::kSubstitutedCol );
1345#endif
1346 SCIP_Bool infeas;
1347 SCIP_Bool aggregated;
1348 SCIP_Bool redundant = FALSE;
1349 SCIP_Real constant = 0.0;
1350 if( rowlen == 2 )
1351 {
1352 SCIP_Real updatedSide;
1353 SCIP_VAR* varx = SCIPmatrixGetVar(matrix, res.postsolve.indices[startRowCoefficients]);
1354 SCIP_VAR* vary = SCIPmatrixGetVar(matrix, res.postsolve.indices[startRowCoefficients + 1]);
1355 SCIP_Real scalarx = res.postsolve.values[startRowCoefficients];
1356 SCIP_Real scalary = res.postsolve.values[startRowCoefficients + 1];
1357
1358 SCIP_CALL( SCIPgetProbvarSum(scip, &varx, &scalarx, &constant) );
1359 assert(SCIPvarGetStatus(varx) != SCIP_VARSTATUS_MULTAGGR);
1360
1361 SCIP_CALL( SCIPgetProbvarSum(scip, &vary, &scalary, &constant) );
1362 assert(SCIPvarGetStatus(vary) != SCIP_VARSTATUS_MULTAGGR);
1363
1364 /* If PaPILO tries to aggregate fixed variables then it missed some obvious fixings.
1365 * This might happen if another aggregation leads to fixings which are not applied immediately by PaPILO.
1366 * With the latest version of PaPILO, this should not occur.
1367 */
1368 if( SCIPvarGetStatus(varx) == SCIP_VARSTATUS_FIXED && SCIPvarGetStatus(vary) == SCIP_VARSTATUS_FIXED )
1369 {
1370 SCIPdebugMsg(scip, "Aggregation of <%s> and <%s> rejected because they are already fixed.\n",
1371 SCIPvarGetName(varx), SCIPvarGetName(vary));
1372
1373 break;
1374 }
1375
1376 updatedSide = side - constant;
1377
1378 SCIP_CALL( SCIPaggregateVars(scip, varx, vary, scalarx, scalary, updatedSide, &infeas, &redundant, &aggregated) );
1379 }
1380 else
1381 {
1382 SCIP_Real colCoef = 0.0;
1383 SCIP_Real updatedSide;
1384 SCIP_Bool checklbimplied;
1385 SCIP_Bool checkubimplied;
1386 SCIP_Real impliedlb;
1387 SCIP_Real impliedub;
1388 int j;
1389
1390 for( j = startRowCoefficients; j < lastRowCoefficients; ++j )
1391 {
1392 if( res.postsolve.indices[j] == col )
1393 {
1394 colCoef = res.postsolve.values[j];
1395 break;
1396 }
1397 }
1398
1399 tmpvars.clear();
1400 tmpvals.clear();
1401 tmpvars.reserve(rowlen);
1402 tmpvals.reserve(rowlen);
1403
1404 assert(colCoef != 0.0);
1405 SCIP_VAR* aggrvar = SCIPmatrixGetVar(matrix, col);
1406
1407 SCIP_CALL( SCIPgetProbvarSum(scip, &aggrvar, &colCoef, &constant) );
1408 assert(SCIPvarGetStatus(aggrvar) != SCIP_VARSTATUS_MULTAGGR);
1409
1410 /* If PaPILO tries to multi-aggregate a fixed variable, then it missed some obvious fixings.
1411 * This might happen if another aggregation leads to fixings which are not applied immediately by PaPILO.
1412 * With the latest version of PaPILO, this should not occur.
1413 */
1414 if( SCIPvarGetStatus(aggrvar) == SCIP_VARSTATUS_FIXED )
1415 {
1416 SCIPdebugMsg(scip, "Multi-aggregation of <%s> rejected because it is already fixed.\n",
1417 SCIPvarGetName(aggrvar));
1418
1419 break;
1420 }
1421
1422 updatedSide = side - constant;
1423
1424 /* we need to check whether lb/ub on aggrvar is implied by bounds of other variables in multiaggregation
1425 * if checkmultaggr is TRUE and the lb/ub is finite
1426 * it should be sufficient to ensure global bounds on aggrvar (and as we are in presolve, local=global anyway)
1427 */
1428 checklbimplied = checkmultaggr && !SCIPisInfinity(scip, -SCIPvarGetLbGlobal(aggrvar));
1429 checkubimplied = checkmultaggr && !SCIPisInfinity(scip, SCIPvarGetUbGlobal(aggrvar));
1430 impliedlb = impliedub = updatedSide / colCoef;
1431
1432 for( j = startRowCoefficients; j < lastRowCoefficients; ++j )
1433 {
1434 SCIP_Real coef;
1435 SCIP_VAR* var;
1436
1437 if( res.postsolve.indices[j] == col )
1438 continue;
1439
1440 coef = - res.postsolve.values[j] / colCoef;
1441 var = SCIPmatrixGetVar(matrix, res.postsolve.indices[j]);
1442
1443 if( checklbimplied )
1444 {
1445 if( coef > 0.0 )
1446 {
1447 /* if impliedlb will be -infinity, then we can give up: we cannot use this mutiaggregation */
1448 if( SCIPisInfinity(scip, -SCIPvarGetLbLocal(var)) )
1449 break;
1450 else
1451 impliedlb += coef * SCIPvarGetLbLocal(var);
1452 }
1453 else
1454 {
1455 if( SCIPisInfinity(scip, SCIPvarGetUbLocal(var)) )
1456 break;
1457 else
1458 impliedlb += coef * SCIPvarGetUbLocal(var);
1459 }
1460 }
1461
1462 if( checkubimplied )
1463 {
1464 if( coef > 0.0 )
1465 {
1466 if( SCIPisInfinity(scip, SCIPvarGetUbLocal(var)) )
1467 break;
1468 else
1469 impliedub += coef * SCIPvarGetUbLocal(var);
1470 }
1471 else
1472 {
1473 if( SCIPisInfinity(scip, -SCIPvarGetLbLocal(var)) )
1474 break;
1475 else
1476 impliedub += coef * SCIPvarGetLbLocal(var);
1477 }
1478 }
1479
1480 tmpvals.push_back(coef);
1481 tmpvars.push_back(var);
1482 }
1483
1484 /* if implied bounds are not sufficient to ensure bounds on aggrvar, then we cannot use the multiaggregation */
1485 if( j < lastRowCoefficients )
1486 break;
1487
1488 if( checklbimplied && SCIPisGT(scip, SCIPvarGetLbGlobal(aggrvar), impliedlb) )
1489 break;
1490
1491 if( checkubimplied && SCIPisLT(scip, SCIPvarGetUbGlobal(aggrvar), impliedub) )
1492 break;
1493
1494 SCIP_CALL( SCIPmultiaggregateVar(scip, aggrvar, tmpvars.size(),
1495 tmpvars.data(), tmpvals.data(), updatedSide / colCoef, &infeas, &aggregated) );
1496 }
1497
1498 if( aggregated )
1499 *naggrvars += 1;
1500 else if( constraintsReplaced && !redundant )
1501 {
1502 /* if the constraints where replaced, we need to add the failed substitution as an equality to SCIP */
1503 tmpvars.clear();
1504 tmpvals.clear();
1505 for( int j = startRowCoefficients; j < lastRowCoefficients; ++j )
1506 {
1507 tmpvars.push_back(SCIPmatrixGetVar(matrix, res.postsolve.indices[j]));
1508 tmpvals.push_back(res.postsolve.values[j]);
1509 }
1510
1511 SCIP_CONS* cons;
1512 String name = fmt::format("{}_failed_aggregation_equality", SCIPvarGetName(SCIPmatrixGetVar(matrix, col)));
1513 SCIP_CALL( SCIPcreateConsBasicLinear(scip, &cons, name.c_str(),
1514 tmpvars.size(), tmpvars.data(), tmpvals.data(), side, side ) );
1515 SCIP_CALL( SCIPaddCons(scip, cons) );
1516 SCIP_CALL( SCIPreleaseCons(scip, &cons) );
1517 *naddconss += 1;
1518 }
1519
1520 if( infeas )
1521 {
1522 *result = SCIP_CUTOFF;
1523 break;
1524 }
1525
1526 break;
1527 }
1528 case ReductionType::kParallelCol:
1529 return SCIP_INVALIDRESULT;
1530#if PAPILO_VERSION_MAJOR > 1 || (PAPILO_VERSION_MAJOR == 1 && PAPILO_VERSION_MINOR >= 1)
1531 case ReductionType::kFixedInfCol: {
1532 /* todo: currently SCIP can not handle this kind of reduction (see issue #3391) */
1533 assert(false);
1534 if(!constraintsReplaced)
1535 continue;
1536 SCIP_Bool infeas;
1537 SCIP_Bool fixed;
1538 SCIP_Real value = SCIPinfinity(scip);
1539
1540 int column = res.postsolve.indices[first];
1541 bool is_negative_infinity = res.postsolve.values[first] < 0;
1542 SCIP_VAR* column_variable = SCIPmatrixGetVar(matrix, column);
1543
1544 if( is_negative_infinity )
1545 {
1546 value = -SCIPinfinity(scip);
1547 }
1548
1549 SCIP_CALL( SCIPfixVar(scip, column_variable, value, &infeas, &fixed) );
1550 *nfixedvars += 1;
1551
1552 assert(!infeas);
1553 assert(fixed);
1554 break;
1555 }
1556#endif
1557#if (PAPILO_VERSION_MAJOR >= 2)
1558 case ReductionType::kVarBoundChange :
1559 case ReductionType::kRedundantRow :
1560 case ReductionType::kRowBoundChange :
1561 case ReductionType::kReasonForRowBoundChangeForcedByRow :
1562 case ReductionType::kRowBoundChangeForcedByRow :
1563 case ReductionType::kSaveRow :
1564 case ReductionType::kReducedBoundsCost :
1565 case ReductionType::kColumnDualValue :
1566 case ReductionType::kRowDualValue :
1567 case ReductionType::kCoefficientChange :
1568 /* dual ReductionTypes should be only calculated for dual reductions and should not appear for MIP */
1569 SCIPerrorMessage("PaPILO: PaPILO should not return dual postsolving reductions in SCIP!!\n");
1570 SCIPABORT(); /*lint --e{527}*/
1571 break;
1572#endif
1573 default:
1574 SCIPdebugMsg(scip, "PaPILO returned unknown data type: \n" );
1575 continue;
1576 }
1577 }
1578
1579 /* finish with a final verb message and return */
1580 SCIPverbMessage(scip, SCIP_VERBLEVEL_HIGH, NULL,
1581 " (%.1fs) MILP presolver (%d rounds): %d aggregations, %d fixings, %d bound changes\n",
1582 SCIPgetSolvingTime(scip), presolve.getStatistics().nrounds, *naggrvars - oldnaggrvars,
1583 *nfixedvars - oldnfixedvars, *nchgbds - oldnchgbds);
1584
1585 /* free the matrix */
1586 assert(initialized);
1587 SCIPmatrixFree(scip, &matrix);
1588
1589 return SCIP_OKAY;
1590}
1591
1592
1593/*
1594 * Callback methods of presolver
1595 */
1596
1597/** copy method for constraint handler plugins (called when SCIP copies plugins) */
1598static
1599SCIP_DECL_PRESOLCOPY(presolCopyMILP)
1600{ /*lint --e{715}*/
1601 SCIP_CALL( SCIPincludePresolMILP(scip) );
1602
1603 return SCIP_OKAY;
1604}
1605
1606/** destructor of presolver to free user data (called when SCIP is exiting) */
1607static
1608SCIP_DECL_PRESOLFREE(presolFreeMILP)
1609{ /*lint --e{715}*/
1610 SCIP_PRESOLMILPDATA* data = (SCIP_PRESOLMILPDATA*)SCIPpresolGetData(presol);
1611 assert(data != NULL);
1612
1613 SCIPpresolSetData(presol, NULL);
1614 SCIPfreeBlockMemory(scip, &data);
1615 return SCIP_OKAY;
1616}
1617
1618/** initialization method of presolver (called after problem was transformed) */
1619static
1620SCIP_DECL_PRESOLINIT(presolInitMILP)
1621{ /*lint --e{715}*/
1622 SCIP_PRESOLMILPDATA* data = (SCIP_PRESOLMILPDATA*)SCIPpresolGetData(presol);
1623 assert(data != NULL);
1624
1625 data->lastncols = -1;
1626 data->lastnrows = -1;
1627
1628 return SCIP_OKAY;
1629}
1630
1631
1632/** execution method of presolver */
1633static
1634SCIP_DECL_PRESOLEXEC(presolExecMILP)
1635{ /*lint --e{715}*/
1636 SCIP_MATRIX* matrix;
1637 SCIP_PRESOLMILPDATA* data;
1638 SCIP_Bool initialized;
1639 SCIP_Bool complete;
1640 SCIP_Bool infeasible;
1641
1642 *result = SCIP_DIDNOTRUN;
1643
1644 data = (SCIP_PRESOLMILPDATA*)SCIPpresolGetData(presol);
1645
1646 int nvars = SCIPgetNVars(scip);
1647 int nconss = SCIPgetNConss(scip);
1648
1649 /* run only if the problem size reduced by some amount since the last call or if it is the first call */
1650 if( data->lastncols != -1 && data->lastnrows != -1 &&
1651 nvars > data->lastncols * 0.85 &&
1652 nconss > data->lastnrows * 0.85 )
1653 return SCIP_OKAY;
1654
1655 SCIP_CALL( SCIPmatrixCreate(scip, &matrix, TRUE, &initialized, &complete, &infeasible,
1656 naddconss, ndelconss, nchgcoefs, nchgbds, nfixedvars) );
1657
1658 /* if infeasibility was detected during matrix creation, return here */
1659 if( infeasible )
1660 {
1661 if( initialized )
1662 SCIPmatrixFree(scip, &matrix);
1663
1664 *result = SCIP_CUTOFF;
1665 return SCIP_OKAY;
1666 }
1667
1668 /* we only work on pure MIPs, also disable to try building the matrix again if it failed once */
1669 if( !initialized || !complete )
1670 {
1671 data->lastncols = 0;
1672 data->lastnrows = 0;
1673
1674 if( initialized )
1675 SCIPmatrixFree(scip, &matrix);
1676
1677 return SCIP_OKAY;
1678 }
1679
1680 if( 0 != strncmp(data->filename, DEFAULT_FILENAME_PROBLEM, strlen(DEFAULT_FILENAME_PROBLEM)) )
1681 {
1682 SCIPverbMessage(scip, SCIP_VERBLEVEL_HIGH, NULL,
1683 " writing transformed problem to %s (only enforced constraints)\n", data->filename);
1684 SCIP_CALL( SCIPwriteTransProblem(scip, data->filename, NULL, FALSE) );
1685 }
1686
1687 if( !SCIPisExact(scip) )
1688 return performRealPresolving(scip, matrix, data, initialized, nfixedvars, naggrvars, nchgvartypes, nchgbds,
1689 naddholes, ndelconss, naddconss, nupgdconss, nchgcoefs, nchgsides, result);
1690#if defined(PAPILO_WITH_EXACTPRESOLVE)
1691 else
1692 return performRationalPresolving(scip, matrix, data, initialized, nfixedvars, naggrvars, nchgvartypes, nchgbds,
1693 naddholes, ndelconss, naddconss, nupgdconss, nchgcoefs, nchgsides, result);
1694#endif
1695
1696 return SCIP_OKAY;
1697}
1698
1699
1700/*
1701 * presolver specific interface methods
1702 */
1703
1704/** creates the MILP presolver and includes it in SCIP */
1705SCIP_RETCODE SCIPincludePresolMILP(
1706 SCIP* scip /**< SCIP data structure */
1707 )
1708{
1709 SCIP_PRESOLMILPDATA* presoldata;
1710 SCIP_PRESOL* presol;
1711
1712#if defined(PAPILO_VERSION_TWEAK) && PAPILO_VERSION_TWEAK != 0
1713 String name = fmt::format("PaPILO {}.{}.{}.{}", PAPILO_VERSION_MAJOR, PAPILO_VERSION_MINOR, PAPILO_VERSION_PATCH, PAPILO_VERSION_TWEAK);
1714#else
1715 String name = fmt::format("PaPILO {}.{}.{}", PAPILO_VERSION_MAJOR, PAPILO_VERSION_MINOR, PAPILO_VERSION_PATCH);
1716#endif
1717
1718#if defined(PAPILO_GITHASH_AVAILABLE) && defined(PAPILO_TBB)
1719 String desc = fmt::format("parallel presolve for integer and linear optimization (github.com/scipopt/papilo) (built with TBB) [GitHash: {}]", PAPILO_GITHASH);
1720#elif !defined(PAPILO_GITHASH_AVAILABLE) && !defined(PAPILO_TBB)
1721 String desc("parallel presolve for integer and linear optimization (github.com/scipopt/papilo)");
1722#elif defined(PAPILO_GITHASH_AVAILABLE) && !defined(PAPILO_TBB)
1723 String desc = fmt::format("parallel presolve for integer and linear optimization (github.com/scipopt/papilo) [GitHash: {}]", PAPILO_GITHASH);
1724#elif !defined(PAPILO_GITHASH_AVAILABLE) && defined(PAPILO_TBB)
1725 String desc = fmt::format("parallel presolve for integer and linear optimization (github.com/scipopt/papilo) (built with TBB)");
1726#endif
1727
1728 /* add external code info for the presolve library */
1729 SCIP_CALL( SCIPincludeExternalCodeInformation(scip, name.c_str(), desc.c_str()) );
1730
1731 /* create MILP presolver data */
1732 presoldata = NULL;
1733 SCIP_CALL( SCIPallocBlockMemory(scip, &presoldata) );
1734 BMSclearMemory(presoldata);
1735
1736 presol = NULL;
1737
1738 /* include presolver */
1739 SCIP_CALL( SCIPincludePresolBasic(scip, &presol, PRESOL_NAME, PRESOL_DESC, PRESOL_PRIORITY, PRESOL_MAXROUNDS, PRESOL_TIMING,
1740 presolExecMILP,
1741 (SCIP_PRESOLDATA*)presoldata) );
1742
1743 assert(presol != NULL);
1744
1745 /* set non fundamental callbacks via setter functions */
1746 SCIP_CALL( SCIPsetPresolCopy(scip, presol, presolCopyMILP) );
1747 SCIP_CALL( SCIPsetPresolFree(scip, presol, presolFreeMILP) );
1748 SCIP_CALL( SCIPsetPresolInit(scip, presol, presolInitMILP) );
1749
1750#if defined(PAPILO_WITH_EXACTPRESOLVE)
1751 /* mark presolver as exact */
1752 SCIPpresolMarkExact(presol);
1753#endif
1754
1755 /* add MILP presolver parameters */
1756#ifdef PAPILO_TBB
1757 SCIP_CALL( SCIPaddIntParam(scip,
1758 "presolving/" PRESOL_NAME "/threads",
1759 "maximum number of threads presolving may use (0: automatic)",
1760 &presoldata->threads, FALSE, DEFAULT_THREADS, 0, INT_MAX, NULL, NULL) );
1761#else
1762 presoldata->threads = 1;
1763#endif
1764
1765 SCIP_CALL( SCIPaddIntParam(scip,
1766 "presolving/" PRESOL_NAME "/maxfillinpersubstitution",
1767 "maximal possible fillin for substitutions to be considered",
1768 &presoldata->maxfillinpersubstitution, FALSE, DEFAULT_MAXFILLINPERSUBST, INT_MIN, INT_MAX, NULL, NULL) );
1769
1770 SCIP_CALL( SCIPaddIntParam(scip,
1771 "presolving/" PRESOL_NAME "/maxshiftperrow",
1772 "maximal amount of nonzeros allowed to be shifted to make space for substitutions",
1773 &presoldata->maxshiftperrow, TRUE, DEFAULT_MAXSHIFTPERROW, 0, INT_MAX, NULL, NULL) );
1774
1775 SCIP_CALL( SCIPaddIntParam(scip,
1776 "presolving/" PRESOL_NAME "/randomseed",
1777 "the random seed used for randomization of tie breaking",
1778 &presoldata->randomseed, FALSE, DEFAULT_RANDOMSEED, INT_MIN, INT_MAX, NULL, NULL) );
1779
1780 if( DependentRows<double>::Enabled )
1781 {
1782 SCIP_CALL( SCIPaddIntParam(scip,
1783 "presolving/" PRESOL_NAME "/detectlineardependency",
1784 "should linear dependent equations and free columns be removed? (0: never, 1: for LPs, 2: always)",
1785 &presoldata->detectlineardependency, TRUE, DEFAULT_DETECTLINDEP, 0, 2, NULL, NULL) );
1786 }
1787 else
1788 presoldata->detectlineardependency = DEFAULT_DETECTLINDEP;
1789
1790 SCIP_CALL( SCIPaddRealParam(scip,
1791 "presolving/" PRESOL_NAME "/modifyconsfac",
1792 "modify SCIP constraints when the number of nonzeros or rows is at most this factor "
1793 "times the number of nonzeros or rows before presolving",
1794 &presoldata->modifyconsfac, FALSE, DEFAULT_MODIFYCONSFAC, 0.0, 1.0, NULL, NULL) );
1795
1796 SCIP_CALL( SCIPaddRealParam(scip,
1797 "presolving/" PRESOL_NAME "/markowitztolerance",
1798 "the markowitz tolerance used for substitutions",
1799 &presoldata->markowitztolerance, FALSE, DEFAULT_MARKOWITZTOLERANCE, 0.0, 1.0, NULL, NULL) );
1800
1801 SCIP_CALL( SCIPaddRealParam(scip,
1802 "presolving/" PRESOL_NAME "/hugebound",
1803 "absolute bound value that is considered too huge for activity based calculations",
1804 &presoldata->hugebound, FALSE, DEFAULT_HUGEBOUND, 0.0, SCIP_REAL_MAX, NULL, NULL) );
1805
1806#if PAPILO_APIVERSION >= 2
1807 SCIP_CALL( SCIPaddRealParam(scip, "presolving/" PRESOL_NAME "/abortfacexhaustive",
1808 "abort threshold for exhaustive presolving in PAPILO",
1809 &presoldata->abortfacexhaustive, TRUE, DEFAULT_ABORTFAC_EXHAUSTIVE, 0.0, 1.0, NULL, NULL) );
1810 SCIP_CALL( SCIPaddRealParam(scip, "presolving/" PRESOL_NAME "/abortfacmedium",
1811 "abort threshold for medium presolving in PAPILO",
1812 &presoldata->abortfacmedium, TRUE, DEFAULT_ABORTFAC_MEDIUM, 0.0, 1.0, NULL, NULL) );
1813 SCIP_CALL( SCIPaddRealParam(scip, "presolving/" PRESOL_NAME "/abortfacfast",
1814 "abort threshold for fast presolving in PAPILO",
1815 &presoldata->abortfacfast, TRUE, DEFAULT_ABORTFAC_FAST, 0.0, 1.0, NULL, NULL) );
1816#else
1817 presoldata->abortfacexhaustive = DEFAULT_ABORTFAC_EXHAUSTIVE;
1818 presoldata->abortfacmedium = DEFAULT_ABORTFAC_MEDIUM;
1819 presoldata->abortfacfast = DEFAULT_ABORTFAC_FAST;
1820#endif
1821
1822#if PAPILO_VERSION_MAJOR > 2 || (PAPILO_VERSION_MAJOR == 2 && PAPILO_VERSION_MINOR >= 1)
1823 SCIP_CALL( SCIPaddIntParam(scip, "presolving/" PRESOL_NAME "/maxbadgesizeseq",
1824 "maximal badge size in Probing in PaPILO if PaPILO is executed in sequential mode",
1825 &presoldata->maxbadgesizeseq, FALSE, DEFAULT_MAXBADGESIZE_SEQ, -1, INT_MAX, NULL, NULL) );
1826
1827 SCIP_CALL( SCIPaddIntParam(scip, "presolving/" PRESOL_NAME "/maxbadgesizepar",
1828 "maximal badge size in Probing in PaPILO if PaPILO is executed in parallel mode",
1829 &presoldata->maxbadgesizepar, FALSE, DEFAULT_MAXBADGESIZE_PAR, -1, INT_MAX, NULL, NULL) );
1830#else
1831 presoldata->maxbadgesizeseq = DEFAULT_MAXBADGESIZE_SEQ;
1832 presoldata->maxbadgesizepar = DEFAULT_MAXBADGESIZE_PAR;
1833#endif
1834
1835#if PAPILO_VERSION_MAJOR > 2 || (PAPILO_VERSION_MAJOR == 2 && PAPILO_VERSION_MINOR >= 3)
1836 SCIP_CALL( SCIPaddIntParam(scip, "presolving/" PRESOL_NAME "/internalmaxrounds",
1837 "internal maxrounds for each milp presolving (-1: no limit, 0: model cleanup)",
1838 &presoldata->internalmaxrounds, TRUE, DEFAULT_INTERNAL_MAXROUNDS, -1, INT_MAX, NULL, NULL) );
1839#else
1840 presoldata->internalmaxrounds = DEFAULT_INTERNAL_MAXROUNDS;
1841#endif
1842
1843 SCIP_CALL( SCIPaddBoolParam(scip,
1844 "presolving/" PRESOL_NAME "/enableparallelrows",
1845 "should the parallel rows presolver be enabled within the presolve library?",
1846 &presoldata->enableparallelrows, TRUE, DEFAULT_ENABLEPARALLELROWS, NULL, NULL) );
1847
1848 SCIP_CALL( SCIPaddBoolParam(scip,
1849 "presolving/" PRESOL_NAME "/enabledomcol",
1850 "should the dominated column presolver be enabled within the presolve library?",
1851 &presoldata->enabledomcol, TRUE, DEFAULT_ENABLEDOMCOL, NULL, NULL) );
1852
1853 SCIP_CALL( SCIPaddBoolParam(scip,
1854 "presolving/" PRESOL_NAME "/enabledualinfer",
1855 "should the dualinfer presolver be enabled within the presolve library?",
1856 &presoldata->enabledualinfer, TRUE, DEFAULT_ENABLEDUALINFER, NULL, NULL) );
1857
1858 SCIP_CALL( SCIPaddBoolParam(scip,
1859 "presolving/" PRESOL_NAME "/enablemultiaggr",
1860 "should the multi-aggregation presolver be enabled within the presolve library?",
1861 &presoldata->enablemultiaggr, TRUE, DEFAULT_ENABLEMULTIAGGR, NULL, NULL) );
1862
1863 SCIP_CALL( SCIPaddBoolParam(scip,
1864 "presolving/" PRESOL_NAME "/enableprobing",
1865 "should the probing presolver be enabled within the presolve library?",
1866 &presoldata->enableprobing, TRUE, DEFAULT_ENABLEPROBING, NULL, NULL) );
1867
1868 SCIP_CALL( SCIPaddBoolParam(scip,
1869 "presolving/" PRESOL_NAME "/enablesparsify",
1870 "should the sparsify presolver be enabled within the presolve library?",
1871 &presoldata->enablesparsify, TRUE, DEFAULT_ENABLESPARSIFY, NULL, NULL) );
1872
1873 SCIP_CALL( SCIPaddStringParam(scip, "presolving/" PRESOL_NAME "/probfilename",
1874 "filename to store the problem before MILP presolving starts (only enforced constraints)",
1875 &presoldata->filename, TRUE, DEFAULT_FILENAME_PROBLEM, NULL, NULL) );
1876
1877 SCIP_CALL( SCIPaddIntParam(scip, "presolving/" PRESOL_NAME "/verbosity",
1878 "verbosity level of PaPILO (0: quiet, 1: errors, 2: warnings, 3: normal, 4: detailed)",
1879 &presoldata->verbosity, FALSE, DEFAULT_VERBOSITY, 0, 4, NULL, NULL) );
1880#if PAPILO_APIVERSION >= 6
1881 SCIP_CALL( SCIPaddBoolParam(scip,
1882 "presolving/" PRESOL_NAME "/enablecliquemerging",
1883 "should the clique merging presolver be enabled within the presolve library?",
1884 &presoldata->enablecliquemerging, TRUE, DEFAULT_ENABLESPARSIFY, NULL, NULL) );
1885 SCIP_CALL( SCIPaddIntParam(scip,
1886 "presolving/" PRESOL_NAME "/maxedgesparallel",
1887 "maximal amount of edges in the parallel clique merging graph",
1888 &presoldata->maxedgesparallel, FALSE, DEFAULT_MAXEDGESPARALLEL, -1, INT_MAX, NULL, NULL) );
1889 SCIP_CALL( SCIPaddIntParam(scip,
1890 "presolving/" PRESOL_NAME "/maxedgessequential",
1891 "maximal amount of edges in the sequential clique merging graph",
1892 &presoldata->maxedgessequential, FALSE, DEFAULT_MAXEDGESSEQUENTIAL, -1, INT_MAX, NULL, NULL) );
1893 SCIP_CALL( SCIPaddIntParam(scip,
1894 "presolving/" PRESOL_NAME "/maxcliquesize",
1895 "maximal size of clique considered for clique merging",
1896 &presoldata->maxcliquesize, FALSE, DEFAULT_MAXCLIQUESIZE, -1, INT_MAX, NULL, NULL) );
1897 SCIP_CALL( SCIPaddIntParam(scip,
1898 "presolving/" PRESOL_NAME "/maxgreedycalls",
1899 "maximal number of greedy max clique calls in a single thread",
1900 &presoldata->maxgreedycalls, FALSE, DEFAULT_MAXGREEDYCALLS, -1, INT_MAX, NULL, NULL) );
1901#endif
1902
1903 return SCIP_OKAY;
1904}
1905
1906#endif
cons_exactlinear.h
Constraint handler for linear constraints in their most general form, .
cons_linear.h
Constraint handler for linear constraints in their most general form, .
NULL
#define NULL
Definition: def.h:248
SCIP_REAL_MAX
#define SCIP_REAL_MAX
Definition: def.h:158
SCIP_Bool
#define SCIP_Bool
Definition: def.h:91
SCIP_Real
#define SCIP_Real
Definition: def.h:156
TRUE
#define TRUE
Definition: def.h:93
FALSE
#define FALSE
Definition: def.h:94
SCIPABORT
#define SCIPABORT()
Definition: def.h:327
REALABS
#define REALABS(x)
Definition: def.h:182
SCIP_CALL
#define SCIP_CALL(x)
Definition: def.h:355
SCIPcreateConsBasicLinear
SCIP_RETCODE SCIPcreateConsBasicLinear(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs)
Definition: cons_linear.c:17912
SCIPcreateConsBasicExactLinear
SCIP_RETCODE SCIPcreateConsBasicExactLinear(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_RATIONAL **vals, SCIP_RATIONAL *lhs, SCIP_RATIONAL *rhs)
Definition: cons_exactlinear.c:6762
SCIPgetProbName
const char * SCIPgetProbName(SCIP *scip)
Definition: scip_prob.c:1242
SCIPgetNVars
int SCIPgetNVars(SCIP *scip)
Definition: scip_prob.c:2246
SCIPaddCons
SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)
Definition: scip_prob.c:3274
SCIPdelCons
SCIP_RETCODE SCIPdelCons(SCIP *scip, SCIP_CONS *cons)
Definition: scip_prob.c:3420
SCIPgetNConss
int SCIPgetNConss(SCIP *scip)
Definition: scip_prob.c:3620
SCIPwriteTransProblem
SCIP_RETCODE SCIPwriteTransProblem(SCIP *scip, const char *filename, const char *extension, SCIP_Bool genericnames)
Definition: scip_prob.c:789
SCIPverbMessage
void SCIPverbMessage(SCIP *scip, SCIP_VERBLEVEL msgverblevel, FILE *file, const char *formatstr,...)
Definition: scip_message.c:225
SCIPdebugMsg
#define SCIPdebugMsg
Definition: scip_message.h:78
SCIPaddIntParam
SCIP_RETCODE SCIPaddIntParam(SCIP *scip, const char *name, const char *desc, int *valueptr, SCIP_Bool isadvanced, int defaultvalue, int minvalue, int maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: scip_param.c:83
SCIPaddStringParam
SCIP_RETCODE SCIPaddStringParam(SCIP *scip, const char *name, const char *desc, char **valueptr, SCIP_Bool isadvanced, const char *defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: scip_param.c:194
SCIPaddRealParam
SCIP_RETCODE SCIPaddRealParam(SCIP *scip, const char *name, const char *desc, SCIP_Real *valueptr, SCIP_Bool isadvanced, SCIP_Real defaultvalue, SCIP_Real minvalue, SCIP_Real maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: scip_param.c:139
SCIPgetRealParam
SCIP_RETCODE SCIPgetRealParam(SCIP *scip, const char *name, SCIP_Real *value)
Definition: scip_param.c:307
SCIPaddBoolParam
SCIP_RETCODE SCIPaddBoolParam(SCIP *scip, const char *name, const char *desc, SCIP_Bool *valueptr, SCIP_Bool isadvanced, SCIP_Bool defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: scip_param.c:57
SCIPincludePresolMILP
SCIP_RETCODE SCIPincludePresolMILP(SCIP *scip)
Definition: presol_milp.cpp:46
SCIPconshdlrGetNCheckConss
int SCIPconshdlrGetNCheckConss(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4798
SCIPfindConshdlr
SCIP_CONSHDLR * SCIPfindConshdlr(SCIP *scip, const char *name)
Definition: scip_cons.c:940
SCIPprintCons
SCIP_RETCODE SCIPprintCons(SCIP *scip, SCIP_CONS *cons, FILE *file)
Definition: scip_cons.c:2536
SCIPconsGetName
const char * SCIPconsGetName(SCIP_CONS *cons)
Definition: cons.c:8389
SCIPreleaseCons
SCIP_RETCODE SCIPreleaseCons(SCIP *scip, SCIP_CONS **cons)
Definition: scip_cons.c:1173
SCIPcaptureCons
SCIP_RETCODE SCIPcaptureCons(SCIP *scip, SCIP_CONS *cons)
Definition: scip_cons.c:1138
SCIPisExact
SCIP_Bool SCIPisExact(SCIP *scip)
Definition: scip_exact.c:193
SCIPincludeExternalCodeInformation
SCIP_RETCODE SCIPincludeExternalCodeInformation(SCIP *scip, const char *name, const char *description)
Definition: scip_general.c:769
SCIPbuffer
BMS_BUFMEM * SCIPbuffer(SCIP *scip)
Definition: scip_mem.c:72
SCIPfreeBlockMemory
#define SCIPfreeBlockMemory(scip, ptr)
Definition: scip_mem.h:108
SCIPallocBlockMemory
#define SCIPallocBlockMemory(scip, ptr)
Definition: scip_mem.h:89
SCIPpresolMarkExact
void SCIPpresolMarkExact(SCIP_PRESOL *presol)
Definition: presol.c:615
SCIPpresolSetData
void SCIPpresolSetData(SCIP_PRESOL *presol, SCIP_PRESOLDATA *presoldata)
Definition: presol.c:538
SCIPpresolGetData
SCIP_PRESOLDATA * SCIPpresolGetData(SCIP_PRESOL *presol)
Definition: presol.c:528
SCIPsetPresolInit
SCIP_RETCODE SCIPsetPresolInit(SCIP *scip, SCIP_PRESOL *presol, SCIP_DECL_PRESOLINIT((*presolinit)))
Definition: scip_presol.c:180
SCIPsetPresolFree
SCIP_RETCODE SCIPsetPresolFree(SCIP *scip, SCIP_PRESOL *presol, SCIP_DECL_PRESOLFREE((*presolfree)))
Definition: scip_presol.c:164
SCIPsetPresolCopy
SCIP_RETCODE SCIPsetPresolCopy(SCIP *scip, SCIP_PRESOL *presol, SCIP_DECL_PRESOLCOPY((*presolcopy)))
Definition: scip_presol.c:148
SCIPincludePresolBasic
SCIP_RETCODE SCIPincludePresolBasic(SCIP *scip, SCIP_PRESOL **presolptr, const char *name, const char *desc, int priority, int maxrounds, SCIP_PRESOLTIMING timing, SCIP_DECL_PRESOLEXEC((*presolexec)), SCIP_PRESOLDATA *presoldata)
Definition: scip_presol.c:113
SCIPrationalSetInfinity
void SCIPrationalSetInfinity(SCIP_RATIONAL *res)
Definition: rational.cpp:618
SCIPrationalGetReal
SCIP_Real SCIPrationalGetReal(SCIP_RATIONAL *rational)
Definition: rational.cpp:2085
SCIPrationalDebugMessage
#define SCIPrationalDebugMessage
Definition: rational.h:641
SCIPrationalDiv
void SCIPrationalDiv(SCIP_RATIONAL *res, SCIP_RATIONAL *op1, SCIP_RATIONAL *op2)
Definition: rational.cpp:1132
SCIPrationalIsAbsInfinity
SCIP_Bool SCIPrationalIsAbsInfinity(SCIP_RATIONAL *rational)
Definition: rational.cpp:1680
SCIPrationalFreeBuffer
void SCIPrationalFreeBuffer(BMS_BUFMEM *bufmem, SCIP_RATIONAL **rational)
Definition: rational.cpp:473
SCIPrationalDiff
void SCIPrationalDiff(SCIP_RATIONAL *res, SCIP_RATIONAL *op1, SCIP_RATIONAL *op2)
Definition: rational.cpp:983
SCIPrationalCreateBuffer
SCIP_RETCODE SCIPrationalCreateBuffer(BMS_BUFMEM *bufmem, SCIP_RATIONAL **rational)
Definition: rational.cpp:123
SCIPrationalIsZero
SCIP_Bool SCIPrationalIsZero(SCIP_RATIONAL *rational)
Definition: rational.cpp:1624
SCIPrationalSetNegInfinity
void SCIPrationalSetNegInfinity(SCIP_RATIONAL *res)
Definition: rational.cpp:630
SCIPrationalIsNegative
SCIP_Bool SCIPrationalIsNegative(SCIP_RATIONAL *rational)
Definition: rational.cpp:1650
SCIPrationalIsInfinity
SCIP_Bool SCIPrationalIsInfinity(SCIP_RATIONAL *rational)
Definition: rational.cpp:1660
SCIPrationalCreateBufferArray
SCIP_RETCODE SCIPrationalCreateBufferArray(BMS_BUFMEM *mem, SCIP_RATIONAL ***rational, int size)
Definition: rational.cpp:214
SCIPrationalIsNegInfinity
SCIP_Bool SCIPrationalIsNegInfinity(SCIP_RATIONAL *rational)
Definition: rational.cpp:1670
SCIPrationalMultReal
void SCIPrationalMultReal(SCIP_RATIONAL *res, SCIP_RATIONAL *op1, SCIP_Real op2)
Definition: rational.cpp:1097
SCIPrationalFreeBufferArray
void SCIPrationalFreeBufferArray(BMS_BUFMEM *mem, SCIP_RATIONAL ***ratbufarray, int size)
Definition: rational.cpp:518
SCIPgetSolvingTime
SCIP_Real SCIPgetSolvingTime(SCIP *scip)
Definition: scip_timing.c:378
SCIPinfinity
SCIP_Real SCIPinfinity(SCIP *scip)
Definition: scip_numerics.c:501
SCIPisInfinity
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
Definition: scip_numerics.c:512
SCIPfeastol
SCIP_Real SCIPfeastol(SCIP *scip)
Definition: scip_numerics.c:168
SCIPisGT
SCIP_Bool SCIPisGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip_numerics.c:475
SCIPepsilon
SCIP_Real SCIPepsilon(SCIP *scip)
Definition: scip_numerics.c:140
SCIPisLT
SCIP_Bool SCIPisLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip_numerics.c:449
SCIPtightenVarLb
SCIP_RETCODE SCIPtightenVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:6401
SCIPtightenVarUbExact
SCIP_RETCODE SCIPtightenVarUbExact(SCIP *scip, SCIP_VAR *var, SCIP_RATIONAL *newbound, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:6768
SCIPvarGetAggrScalarExact
SCIP_RATIONAL * SCIPvarGetAggrScalarExact(SCIP_VAR *var)
Definition: var.c:23760
SCIPvarGetStatus
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
Definition: var.c:23386
SCIPvarIsImpliedIntegral
SCIP_Bool SCIPvarIsImpliedIntegral(SCIP_VAR *var)
Definition: var.c:23498
SCIPvarGetUbLocal
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
Definition: var.c:24268
SCIPaggregateVarsExact
SCIP_RETCODE SCIPaggregateVarsExact(SCIP *scip, SCIP_VAR *varx, SCIP_VAR *vary, SCIP_RATIONAL *scalarx, SCIP_RATIONAL *scalary, SCIP_RATIONAL *rhs, SCIP_Bool *infeasible, SCIP_Bool *redundant, SCIP_Bool *aggregated)
Definition: scip_var.c:10692
SCIPvarGetAggrConstantExact
SCIP_RATIONAL * SCIPvarGetAggrConstantExact(SCIP_VAR *var)
Definition: var.c:23783
SCIPaggregateVars
SCIP_RETCODE SCIPaggregateVars(SCIP *scip, SCIP_VAR *varx, SCIP_VAR *vary, SCIP_Real scalarx, SCIP_Real scalary, SCIP_Real rhs, SCIP_Bool *infeasible, SCIP_Bool *redundant, SCIP_Bool *aggregated)
Definition: scip_var.c:10550
SCIPvarGetObj
SCIP_Real SCIPvarGetObj(SCIP_VAR *var)
Definition: var.c:23900
SCIPtightenVarUb
SCIP_RETCODE SCIPtightenVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:6651
SCIPvarGetType
SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)
Definition: var.c:23453
SCIPgetProbvarSum
SCIP_RETCODE SCIPgetProbvarSum(SCIP *scip, SCIP_VAR **var, SCIP_Real *scalar, SCIP_Real *constant)
Definition: scip_var.c:2499
SCIPvarGetUbGlobal
SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)
Definition: var.c:24142
SCIPvarGetStatusExact
SCIP_VARSTATUS SCIPvarGetStatusExact(SCIP_VAR *var)
Definition: var.c:23396
SCIPvarGetName
const char * SCIPvarGetName(SCIP_VAR *var)
Definition: var.c:23267
SCIPmultiaggregateVar
SCIP_RETCODE SCIPmultiaggregateVar(SCIP *scip, SCIP_VAR *var, int naggvars, SCIP_VAR **aggvars, SCIP_Real *scalars, SCIP_Real constant, SCIP_Bool *infeasible, SCIP_Bool *aggregated)
Definition: scip_var.c:10834
SCIPvarIsIntegral
SCIP_Bool SCIPvarIsIntegral(SCIP_VAR *var)
Definition: var.c:23490
SCIPvarGetLbLocal
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
Definition: var.c:24234
SCIPvarGetLbGlobalExact
SCIP_RATIONAL * SCIPvarGetLbGlobalExact(SCIP_VAR *var)
Definition: var.c:24130
SCIPvarGetLbGlobal
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
Definition: var.c:24120
SCIPfixVar
SCIP_RETCODE SCIPfixVar(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval, SCIP_Bool *infeasible, SCIP_Bool *fixed)
Definition: scip_var.c:10318
SCIPgetProbvarSumExact
SCIP_RETCODE SCIPgetProbvarSumExact(SCIP *scip, SCIP_VAR **var, SCIP_RATIONAL *scalar, SCIP_RATIONAL *constant)
Definition: scip_var.c:2538
SCIPvarGetObjExact
SCIP_RATIONAL * SCIPvarGetObjExact(SCIP_VAR *var)
Definition: var.c:23910
SCIPallowWeakDualReds
SCIP_Bool SCIPallowWeakDualReds(SCIP *scip)
Definition: scip_var.c:10998
SCIPmultiaggregateVarExact
SCIP_RETCODE SCIPmultiaggregateVarExact(SCIP *scip, SCIP_VAR *var, int naggvars, SCIP_VAR **aggvars, SCIP_RATIONAL **scalars, SCIP_RATIONAL *constant, SCIP_Bool *infeasible, SCIP_Bool *aggregated)
Definition: scip_var.c:10879
SCIPtightenVarLbExact
SCIP_RETCODE SCIPtightenVarLbExact(SCIP *scip, SCIP_VAR *var, SCIP_RATIONAL *newbound, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:6518
SCIPallowStrongDualReds
SCIP_Bool SCIPallowStrongDualReds(SCIP *scip)
Definition: scip_var.c:10984
SCIPvarGetUbGlobalExact
SCIP_RATIONAL * SCIPvarGetUbGlobalExact(SCIP_VAR *var)
Definition: var.c:24152
SCIPfixVarExact
SCIP_RETCODE SCIPfixVarExact(SCIP *scip, SCIP_VAR *var, SCIP_RATIONAL *fixedval, SCIP_Bool *infeasible, SCIP_Bool *fixed)
Definition: scip_var.c:10420
SCIPvarGetAggrVar
SCIP_VAR * SCIPvarGetAggrVar(SCIP_VAR *var)
Definition: var.c:23736
SCIPinitializeRandomSeed
unsigned int SCIPinitializeRandomSeed(SCIP *scip, unsigned int initialseedvalue)
Definition: scip_randnumgen.c:111
SCIPmatrixGetNNonzs
int SCIPmatrixGetNNonzs(SCIP_MATRIX *matrix)
Definition: matrix.c:2107
SCIPmatrixGetRowLhsExact
SCIP_RATIONAL * SCIPmatrixGetRowLhsExact(SCIP_MATRIX *matrix, int row)
Definition: matrix.c:2071
SCIPmatrixGetRowNNonzs
int SCIPmatrixGetRowNNonzs(SCIP_MATRIX *matrix, int row)
Definition: matrix.c:2013
SCIPmatrixGetRowLhs
SCIP_Real SCIPmatrixGetRowLhs(SCIP_MATRIX *matrix, int row)
Definition: matrix.c:2047
SCIPmatrixGetRowValPtr
SCIP_Real * SCIPmatrixGetRowValPtr(SCIP_MATRIX *matrix, int row)
Definition: matrix.c:1977
SCIPmatrixGetRowValPtrExact
SCIP_RATIONAL ** SCIPmatrixGetRowValPtrExact(SCIP_MATRIX *matrix, int row)
Definition: matrix.c:1989
SCIPmatrixGetRowRhs
SCIP_Real SCIPmatrixGetRowRhs(SCIP_MATRIX *matrix, int row)
Definition: matrix.c:2059
SCIPmatrixCreate
SCIP_RETCODE SCIPmatrixCreate(SCIP *scip, SCIP_MATRIX **matrixptr, SCIP_Bool onlyifcomplete, SCIP_Bool *initialized, SCIP_Bool *complete, SCIP_Bool *infeasible, int *naddconss, int *ndelconss, int *nchgcoefs, int *nchgbds, int *nfixedvars)
Definition: matrix.c:703
SCIPmatrixGetNColumns
int SCIPmatrixGetNColumns(SCIP_MATRIX *matrix)
Definition: matrix.c:1897
SCIPmatrixGetCons
SCIP_CONS * SCIPmatrixGetCons(SCIP_MATRIX *matrix, int row)
Definition: matrix.c:2189
SCIPmatrixFree
void SCIPmatrixFree(SCIP *scip, SCIP_MATRIX **matrix)
Definition: matrix.c:1348
SCIPmatrixGetVar
SCIP_VAR * SCIPmatrixGetVar(SCIP_MATRIX *matrix, int col)
Definition: matrix.c:1953
SCIPmatrixGetRowRhsExact
SCIP_RATIONAL * SCIPmatrixGetRowRhsExact(SCIP_MATRIX *matrix, int row)
Definition: matrix.c:2083
SCIPmatrixGetRowIdxPtr
int * SCIPmatrixGetRowIdxPtr(SCIP_MATRIX *matrix, int row)
Definition: matrix.c:2001
SCIPmatrixGetNRows
int SCIPmatrixGetNRows(SCIP_MATRIX *matrix)
Definition: matrix.c:2037
BMSclearMemory
#define BMSclearMemory(ptr)
Definition: memory.h:129
PRESOL_NAME
#define PRESOL_NAME
Definition: presol_boundshift.c:52
PRESOL_PRIORITY
#define PRESOL_PRIORITY
Definition: presol_boundshift.c:54
PRESOL_MAXROUNDS
#define PRESOL_MAXROUNDS
Definition: presol_boundshift.c:55
PRESOL_TIMING
#define PRESOL_TIMING
Definition: presol_boundshift.c:56
PRESOL_DESC
#define PRESOL_DESC
Definition: presol_boundshift.c:53
presol_milp.h
MILP presolver that calls the presolve library on the constraint matrix.
pub_cons.h
public methods for managing constraints
pub_matrix.h
public methods for matrix
pub_message.h
public methods for message output
SCIPerrorMessage
#define SCIPerrorMessage
Definition: pub_message.h:64
SCIPdebug
#define SCIPdebug(x)
Definition: pub_message.h:93
SCIPdebugMessage
#define SCIPdebugMessage
Definition: pub_message.h:96
pub_presol.h
public methods for presolvers
pub_var.h
public methods for problem variables
rational.h
wrapper for rational number arithmetic
DEFAULT_RANDOMSEED
#define DEFAULT_RANDOMSEED
Definition: reader_scflp.c:116
scip_cons.h
public methods for constraint handler plugins and constraints
scip_exact.h
public methods for exact solving
scip_general.h
general public methods
scip_mem.h
public methods for memory management
scip_message.h
public methods for message handling
scip_numerics.h
public methods for numerical tolerances
scip_param.h
public methods for SCIP parameter handling
scip_presol.h
public methods for presolving plugins
scip_prob.h
public methods for global and local (sub)problems
scip_randnumgen.h
public methods for random numbers
presolve
static SCIP_RETCODE presolve(SCIP *scip, SCIP_Bool *unbounded, SCIP_Bool *infeasible, SCIP_Bool *vanished)
Definition: scip_solve.c:1138
scip_timing.h
public methods for timing
scip_var.h
public methods for SCIP variables
SCIP_Cons
Definition: struct_cons.h:47
SCIP_Conshdlr
Definition: struct_cons.h:128
SCIP_Matrix
Definition: struct_matrix.h:62
SCIP_Presol
Definition: struct_presol.h:47
SCIP_Rational
Definition: struct_rational.h:47
SCIP_Rational::val
scip::Rational val
Definition: struct_rational.h:48
SCIP_Rational::isfprepresentable
unsigned int isfprepresentable
Definition: struct_rational.h:50
SCIP_Var
Definition: struct_var.h:262
struct_rational.h
definition of wrapper class for rational numbers
SCIP_VERBLEVEL_HIGH
@ SCIP_VERBLEVEL_HIGH
Definition: type_message.h:61
SCIP_DECL_PRESOLCOPY
#define SCIP_DECL_PRESOLCOPY(x)
Definition: type_presol.h:60
SCIP_PRESOLDATA
struct SCIP_PresolData SCIP_PRESOLDATA
Definition: type_presol.h:51
SCIP_DECL_PRESOLFREE
#define SCIP_DECL_PRESOLFREE(x)
Definition: type_presol.h:68
SCIP_DECL_PRESOLINIT
#define SCIP_DECL_PRESOLINIT(x)
Definition: type_presol.h:76
SCIP_DECL_PRESOLEXEC
#define SCIP_DECL_PRESOLEXEC(x)
Definition: type_presol.h:167
SCIP_ISFPREPRESENTABLE_UNKNOWN
@ SCIP_ISFPREPRESENTABLE_UNKNOWN
Definition: type_rational.h:48
SCIP_DIDNOTRUN
@ SCIP_DIDNOTRUN
Definition: type_result.h:42
SCIP_CUTOFF
@ SCIP_CUTOFF
Definition: type_result.h:48
SCIP_DIDNOTFIND
@ SCIP_DIDNOTFIND
Definition: type_result.h:44
SCIP_UNBOUNDED
@ SCIP_UNBOUNDED
Definition: type_result.h:47
SCIP_SUCCESS
@ SCIP_SUCCESS
Definition: type_result.h:58
SCIP_RESULT
enum SCIP_Result SCIP_RESULT
Definition: type_result.h:61
SCIP_INVALIDRESULT
@ SCIP_INVALIDRESULT
Definition: type_retcode.h:53
SCIP_OKAY
@ SCIP_OKAY
Definition: type_retcode.h:42
SCIP_RETCODE
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:63
SCIP_VARTYPE_CONTINUOUS
@ SCIP_VARTYPE_CONTINUOUS
Definition: type_var.h:71
SCIP_VARSTATUS_FIXED
@ SCIP_VARSTATUS_FIXED
Definition: type_var.h:54
SCIP_VARSTATUS_MULTAGGR
@ SCIP_VARSTATUS_MULTAGGR
Definition: type_var.h:56
SCIP_VARSTATUS_NEGATED
@ SCIP_VARSTATUS_NEGATED
Definition: type_var.h:57
SCIP_VARSTATUS_AGGREGATED
@ SCIP_VARSTATUS_AGGREGATED
Definition: type_var.h:55