Skip to content

Commit 6689ae9

Browse files
svigerskesvigerske
committed
Merge branch 'merge-minor-after-farkas-update' into 'master'
Merge v9-minor into master after farkas update See merge request integer/scip!3803
2 parents ee6f88a + b7c2abe commit 6689ae9

File tree

7 files changed

+75
-42
lines changed

7 files changed

+75
-42
lines changed

‎CHANGELOG

+1
Original file line numberDiff line numberDiff line change
@@ -312,6 +312,7 @@ Fixed bugs
312312
- allocate memory for all integral variables to avoid segmentation faults in applyCliqueFixings() of heur_clique.c
313313
- fix conflict resolution for one particular case in cons_indicator
314314
- make interface to nauty thread safe
315+
- use relative epsilon tolerance to check farkas row in SCIPlpGetDualfarkas() to avoid invalid cutoff
315316

316317
Build system
317318
------------

‎src/scip/lp.c

+52-24
Original file line numberDiff line numberDiff line change
@@ -61,6 +61,7 @@
6161
#include "scip/sol.h"
6262
#include "scip/solve.h"
6363
#include "scip/stat.h"
64+
#include "scip/struct_scip.h"
6465
#include "scip/struct_event.h"
6566
#include "scip/struct_lp.h"
6667
#include "scip/struct_lpexact.h"
@@ -12658,6 +12659,7 @@ SCIP_RETCODE SCIPlpSolveAndEval(
1265812659
* (limit is computed within the method w.r.t. the average LP iterations) */
1265912660
SCIP_Bool aging, /**< should aging and removal of obsolete cols/rows be applied? */
1266012661
SCIP_Bool keepsol, /**< should the old LP solution be kept if no iterations were performed? */
12662+
SCIP_Bool forcedlpsolve, /**< would SCIP abort if the LP is not solved? */
1266112663
SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred */
1266212664
)
1266312665
{
@@ -12757,7 +12759,7 @@ SCIP_RETCODE SCIPlpSolveAndEval(
1275712759
if( lp->solved && set->exact_enable && SCIPlpGetSolstat(lp) != SCIP_LPSOLSTAT_TIMELIMIT && SCIPlpGetSolstat(lp) != SCIP_LPSOLSTAT_ITERLIMIT )
1275812760
{
1275912761
if( SCIPlpGetSolstat(lp) == SCIP_LPSOLSTAT_INFEASIBLE )
12760-
SCIP_CALL( SCIPlpGetDualfarkas(lp, set, stat, &farkasvalid) );
12762+
SCIP_CALL( SCIPlpGetDualfarkas(lp, set, stat, FALSE, &farkasvalid) );
1276112763
else
1276212764
SCIP_CALL( SCIPlpGetSol(lp, set, stat, &primalfeasible, &dualfeasible) );
1276312765

@@ -12901,13 +12903,13 @@ SCIP_RETCODE SCIPlpSolveAndEval(
1290112903

1290212904
case SCIP_LPSOLSTAT_INFEASIBLE:
1290312905
SCIPsetDebugMsg(set, " -> LP infeasible\n");
12904-
if( set->lp_checkfarkas || set->exact_enable || set->lp_alwaysgetduals || !SCIPprobAllColsInLP(prob, set, lp) )
12906+
if( set->lp_checkfarkas || set->lp_alwaysgetduals || set->exact_enable || !SCIPprobAllColsInLP(prob, set, lp) )
1290512907
{
1290612908
if( set->exact_enable && SCIPlpiExactHasDualRay(lp->lpexact->lpiexact) )
1290712909
farkasvalid = TRUE;
1290812910
else if( SCIPlpiHasDualRay(lp->lpi) )
1290912911
{
12910-
SCIP_CALL( SCIPlpGetDualfarkas(lp, set, stat, &farkasvalid) );
12912+
SCIP_CALL( SCIPlpGetDualfarkas(lp, set, stat, forcedlpsolve, &farkasvalid) );
1291112913
}
1291212914
/* it might happen that we have no infeasibility proof for the current LP (e.g. if the LP was always solved
1291312915
* with the primal simplex due to numerical problems) - treat this case like an LP error
@@ -13229,7 +13231,7 @@ SCIP_RETCODE SCIPlpSolveAndEval(
1322913231
{
1323013232
if( SCIPlpiHasDualRay(lp->lpi) )
1323113233
{
13232-
SCIP_CALL( SCIPlpGetDualfarkas(lp, set, stat, &farkasvalid) );
13234+
SCIP_CALL( SCIPlpGetDualfarkas(lp, set, stat, forcedlpsolve, &farkasvalid) );
1323313235
}
1323413236
/* it might happen that we have no infeasibility proof for the current LP (e.g. if the LP was always solved
1323513237
* with the primal simplex due to numerical problems) - treat this case like an LP error
@@ -15379,6 +15381,7 @@ SCIP_RETCODE SCIPlpGetDualfarkas(
1537915381
SCIP_LP* lp, /**< current LP data */
1538015382
SCIP_SET* set, /**< global SCIP settings */
1538115383
SCIP_STAT* stat, /**< problem statistics */
15384+
SCIP_Bool forcedlpsolve, /**< would SCIP abort if the LP is not solved? */
1538215385
SCIP_Bool* valid /**< pointer to store whether the Farkas proof is valid or NULL */
1538315386
)
1538415387
{
@@ -15413,8 +15416,7 @@ SCIP_RETCODE SCIPlpGetDualfarkas(
1541315416
farkascoefs = NULL;
1541415417
maxactivity = 0.0;
1541515418
farkaslhs = 0.0;
15416-
15417-
checkfarkas = (set->lp_checkfarkas && valid != NULL);
15419+
checkfarkas = set->lp_checkfarkas && valid != NULL;
1541815420

1541915421
/* get temporary memory */
1542015422
SCIP_CALL( SCIPsetAllocBufferArray(set, &dualfarkas, lp->nlpirows) );
@@ -15444,8 +15446,9 @@ SCIP_RETCODE SCIPlpGetDualfarkas(
1544415446
lpirows[r]->validactivitylp = -1L;
1544515447
lpirows[r]->basisstatus = (unsigned int) SCIP_BASESTAT_BASIC;
1544615448

15447-
if( checkfarkas )
15449+
if( checkfarkas && dualfarkas[r] != 0.0 ) /*lint !e777*/
1544815450
{
15451+
assert(valid != NULL);
1544915452
assert(farkascoefs != NULL);
1545015453

1545115454
/* the infeasibility proof would be invalid if
@@ -15457,11 +15460,9 @@ SCIP_RETCODE SCIPlpGetDualfarkas(
1545715460
|| (SCIPsetIsDualfeasLT(set, dualfarkas[r], 0.0) && SCIPsetIsInfinity(set, lpirows[r]->rhs)) )
1545815461
{
1545915462
SCIPsetDebugMsg(set, "farkas proof is invalid: row <%s>[lhs=%g,rhs=%g,c=%g] has multiplier %g\n",
15460-
SCIProwGetName(lpirows[r]), lpirows[r]->lhs, lpirows[r]->rhs, lpirows[r]->constant, dualfarkas[r]);
15461-
15462-
if( valid != NULL )
15463-
*valid = FALSE;
15463+
SCIProwGetName(lpirows[r]), lpirows[r]->lhs, lpirows[r]->rhs, lpirows[r]->constant, dualfarkas[r]);
1546415464

15465+
*valid = FALSE;
1546515466
goto TERMINATE;
1546615467
}
1546715468

@@ -15490,15 +15491,17 @@ SCIP_RETCODE SCIPlpGetDualfarkas(
1549015491
{
1549115492
assert(!SCIPsetIsInfinity(set, -lpirows[r]->lhs));
1549215493

15493-
farkaslhs += dualfarkas[r] * (lpirows[r]->lhs - lpirows[r]->constant);
15494+
farkaslhs += dualfarkas[r] * lpirows[r]->lhs;
1549415495
}
1549515496
/* the row contributes with its right-hand side to the proof */
1549615497
else if( dualfarkas[r] < 0.0 )
1549715498
{
1549815499
assert(!SCIPsetIsInfinity(set, lpirows[r]->rhs));
1549915500

15500-
farkaslhs += dualfarkas[r] * (lpirows[r]->rhs - lpirows[r]->constant);
15501+
farkaslhs += dualfarkas[r] * lpirows[r]->rhs;
1550115502
}
15503+
15504+
maxactivity += dualfarkas[r] * lpirows[r]->constant;
1550215505
}
1550315506
}
1550415507

@@ -15512,30 +15515,55 @@ SCIP_RETCODE SCIPlpGetDualfarkas(
1551215515

1551315516
if( checkfarkas )
1551415517
{
15518+
assert(valid != NULL);
1551515519
assert(farkascoefs != NULL);
1551615520
assert(SCIPcolGetLPPos(lpicols[c]) == c);
1551715521

1551815522
/* skip coefficients that are too close to zero */
15519-
if( SCIPsetIsFeasZero(set, farkascoefs[c]) )
15523+
if( SCIPsetIsDualfeasZero(set, farkascoefs[c]) )
1552015524
continue;
1552115525

1552215526
/* calculate the maximal activity */
1552315527
if( farkascoefs[c] > 0.0 )
15524-
maxactivity += farkascoefs[c] * SCIPcolGetUb(lpicols[c]);
15528+
{
15529+
maxactivity += farkascoefs[c] * lpicols[c]->ub;
15530+
15531+
if( SCIPsetIsInfinity(set, lpicols[c]->ub) )
15532+
{
15533+
SCIPsetDebugMsg(set, "farkas proof is invalid: col <%s>[lb=%g,ub=%g] has coefficient %g\n",
15534+
SCIPvarGetName(SCIPcolGetVar(lpicols[c])), lpicols[c]->lb, lpicols[c]->ub, farkascoefs[c]);
15535+
15536+
*valid = FALSE;
15537+
goto TERMINATE;
15538+
}
15539+
}
1552515540
else
15526-
maxactivity += farkascoefs[c] * SCIPcolGetLb(lpicols[c]);
15541+
{
15542+
maxactivity += farkascoefs[c] * lpicols[c]->lb;
15543+
15544+
if( SCIPsetIsInfinity(set, -lpicols[c]->lb) )
15545+
{
15546+
SCIPsetDebugMsg(set, "farkas proof is invalid: col <%s>[lb=%g,ub=%g] has coefficient %g\n",
15547+
SCIPvarGetName(SCIPcolGetVar(lpicols[c])), lpicols[c]->lb, lpicols[c]->ub, farkascoefs[c]);
15548+
15549+
*valid = FALSE;
15550+
goto TERMINATE;
15551+
}
15552+
}
1552715553
}
1552815554
}
1552915555

15530-
/* check whether the farkasproof is valid
15531-
* due to numerics, it might happen that the left-hand side of the aggregation is larger/smaller or equal than +/- infinity.
15532-
* in that case, we declare the Farkas proof to be invalid.
15533-
*/
15534-
if( checkfarkas && (SCIPsetIsInfinity(set, REALABS(farkaslhs)) || SCIPsetIsGE(set, maxactivity, farkaslhs)) )
15556+
/* check whether the farkasproof is valid for relative epsilon tolerance to allow feasibility tightening */
15557+
if( checkfarkas
15558+
&& ( SCIPsetIsInfinity(set, maxactivity) || SCIPsetIsInfinity(set, -farkaslhs) || SCIPsetIsRelGE(set, maxactivity, farkaslhs) ) )
1553515559
{
15560+
assert(valid != NULL);
15561+
1553615562
SCIPsetDebugMsg(set, "farkas proof is invalid: maxactivity=%.12f, lhs=%.12f\n", maxactivity, farkaslhs);
1553715563

15538-
if( valid != NULL )
15564+
if( forcedlpsolve && SCIPsetIsLT(set, maxactivity, farkaslhs) )
15565+
SCIPmessagePrintWarning(set->scip->messagehdlr, "Unreliable farkas proof forced valid, result might not be optimal.\n");
15566+
else
1553915567
*valid = FALSE;
1554015568
}
1554115569

@@ -16395,7 +16423,7 @@ SCIP_RETCODE SCIPlpStartDive(
1639516423
assert(lp->validsollp == stat->lpcount);
1639616424
break;
1639716425
case SCIP_LPSOLSTAT_INFEASIBLE:
16398-
SCIP_CALL( SCIPlpGetDualfarkas(lp, set, stat, NULL) );
16426+
SCIP_CALL( SCIPlpGetDualfarkas(lp, set, stat, FALSE, NULL) );
1639916427
break;
1640016428
case SCIP_LPSOLSTAT_NOTSOLVED:
1640116429
case SCIP_LPSOLSTAT_ERROR:
@@ -16524,7 +16552,7 @@ SCIP_RETCODE SCIPlpEndDive(
1652416552
{
1652516553
SCIP_Bool lperror;
1652616554

16527-
SCIP_CALL( SCIPlpSolveAndEval(lp, set, messagehdlr, blkmem, stat, eventqueue, eventfilter, prob, -1LL, FALSE, FALSE, FALSE, &lperror) );
16555+
SCIP_CALL( SCIPlpSolveAndEval(lp, set, messagehdlr, blkmem, stat, eventqueue, eventfilter, prob, -1LL, FALSE, FALSE, FALSE, FALSE, &lperror) );
1652816556
if( lperror )
1652916557
{
1653016558
lpNumericalTroubleMessage(messagehdlr, set, stat, SCIP_VERBLEVEL_FULL, "unresolved when resolving LP after diving");

‎src/scip/lp.h

+2
Original file line numberDiff line numberDiff line change
@@ -1045,6 +1045,7 @@ SCIP_RETCODE SCIPlpSolveAndEval(
10451045
* (limit is computed within the method w.r.t. the average LP iterations) */
10461046
SCIP_Bool aging, /**< should aging and removal of obsolete cols/rows be applied? */
10471047
SCIP_Bool keepsol, /**< should the old LP solution be kept if no iterations were performed? */
1048+
SCIP_Bool forcedlpsolve, /**< would SCIP abort if the LP is not solved? */
10481049
SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred */
10491050
);
10501051

@@ -1250,6 +1251,7 @@ SCIP_RETCODE SCIPlpGetDualfarkas(
12501251
SCIP_LP* lp, /**< current LP data */
12511252
SCIP_SET* set, /**< global SCIP settings */
12521253
SCIP_STAT* stat, /**< problem statistics */
1254+
SCIP_Bool forcedlpsolve, /**< would SCIP abort if the LP is not solved? */
12531255
SCIP_Bool* valid /**< pointer to store whether the Farkas proof is valid or NULL */
12541256
);
12551257

‎src/scip/scip_lp.c

+1-1
Original file line numberDiff line numberDiff line change
@@ -2704,7 +2704,7 @@ SCIP_RETCODE SCIPsolveDiveLP(
27042704

27052705
/* solve diving LP */
27062706
SCIP_CALL( SCIPlpSolveAndEval(scip->lp, scip->set, scip->messagehdlr, scip->mem->probmem, scip->stat,
2707-
scip->eventqueue, scip->eventfilter, scip->transprob, (SCIP_Longint)itlim, FALSE, FALSE, FALSE, lperror) );
2707+
scip->eventqueue, scip->eventfilter, scip->transprob, (SCIP_Longint)itlim, FALSE, FALSE, FALSE, FALSE, lperror) );
27082708

27092709
/* the LP is infeasible or the objective limit was reached */
27102710
if( SCIPlpGetSolstat(scip->lp) == SCIP_LPSOLSTAT_INFEASIBLE || SCIPlpGetSolstat(scip->lp) == SCIP_LPSOLSTAT_OBJLIMIT

‎src/scip/scip_probing.c

+1-1
Original file line numberDiff line numberDiff line change
@@ -755,7 +755,7 @@ SCIP_RETCODE solveProbingLP(
755755

756756
/* solve probing LP */
757757
SCIP_CALL( SCIPlpSolveAndEval(scip->lp, scip->set, scip->messagehdlr, scip->mem->probmem, scip->stat,
758-
scip->eventqueue, scip->eventfilter, scip->transprob, (SCIP_Longint)itlim, FALSE, FALSE, FALSE, lperror) );
758+
scip->eventqueue, scip->eventfilter, scip->transprob, (SCIP_Longint)itlim, FALSE, FALSE, FALSE, FALSE, lperror) );
759759

760760
assert((*lperror) || SCIPlpGetSolstat(scip->lp) != SCIP_LPSOLSTAT_NOTSOLVED);
761761

‎src/scip/solve.c

+14-12
Original file line numberDiff line numberDiff line change
@@ -1623,7 +1623,7 @@ SCIP_RETCODE solveNodeInitialLP(
16231623
/* solve initial LP */
16241624
SCIPsetDebugMsg(set, "node: solve initial LP\n");
16251625
SCIP_CALL( SCIPlpSolveAndEval(lp, set, messagehdlr, blkmem, stat, eventqueue, eventfilter, transprob,
1626-
SCIPnodeGetDepth(SCIPtreeGetFocusNode(tree)) == 0 ? set->lp_rootiterlim : set->lp_iterlim, TRUE, TRUE, FALSE, lperror) );
1626+
SCIPnodeGetDepth(SCIPtreeGetFocusNode(tree)) == 0 ? set->lp_rootiterlim : set->lp_iterlim, TRUE, TRUE, FALSE, FALSE, lperror) );
16271627
assert(lp->flushed);
16281628
assert(lp->solved || *lperror);
16291629

@@ -1706,7 +1706,7 @@ SCIP_RETCODE separationRoundResolveLP(
17061706
{
17071707
/* solve LP (with dual simplex) */
17081708
SCIPsetDebugMsg(set, "separation: resolve LP\n");
1709-
SCIP_CALL( SCIPlpSolveAndEval(lp, set, messagehdlr, blkmem, stat, eventqueue, eventfilter, prob, set->lp_iterlim, FALSE, TRUE, FALSE, lperror) );
1709+
SCIP_CALL( SCIPlpSolveAndEval(lp, set, messagehdlr, blkmem, stat, eventqueue, eventfilter, prob, set->lp_iterlim, FALSE, TRUE, FALSE, FALSE, lperror) );
17101710
assert(lp->flushed);
17111711
assert(lp->solved || *lperror);
17121712
*mustsepa = TRUE;
@@ -2353,7 +2353,7 @@ SCIP_RETCODE SCIPpriceLoop(
23532353
* if LP was infeasible, we have to use dual simplex
23542354
*/
23552355
SCIPsetDebugMsg(set, "pricing: solve LP\n");
2356-
SCIP_CALL( SCIPlpSolveAndEval(lp, set, messagehdlr, blkmem, stat, eventqueue, eventfilter, transprob, -1LL, FALSE, TRUE, FALSE, lperror) );
2356+
SCIP_CALL( SCIPlpSolveAndEval(lp, set, messagehdlr, blkmem, stat, eventqueue, eventfilter, transprob, -1LL, FALSE, TRUE, FALSE, FALSE, lperror) );
23572357
assert(lp->flushed);
23582358
assert(lp->solved || *lperror);
23592359

@@ -2382,7 +2382,7 @@ SCIP_RETCODE SCIPpriceLoop(
23822382

23832383
/* solve LP again after resetting bounds and adding new initial constraints (with dual simplex) */
23842384
SCIPsetDebugMsg(set, "pricing: solve LP after resetting bounds and adding new initial constraints\n");
2385-
SCIP_CALL( SCIPlpSolveAndEval(lp, set, messagehdlr, blkmem, stat, eventqueue, eventfilter, transprob, -1LL, FALSE, FALSE, FALSE, lperror) );
2385+
SCIP_CALL( SCIPlpSolveAndEval(lp, set, messagehdlr, blkmem, stat, eventqueue, eventfilter, transprob, -1LL, FALSE, FALSE, FALSE, FALSE, lperror) );
23862386
assert(lp->flushed);
23872387
assert(lp->solved || *lperror);
23882388

@@ -2489,6 +2489,7 @@ SCIP_RETCODE priceAndCutLoop(
24892489
SCIP_EVENTFILTER* eventfilter, /**< global event filter */
24902490
SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
24912491
SCIP_Bool fullseparation, /**< are we in the first prop-and-cut-and-price loop? */
2492+
SCIP_Bool forcedlpsolve, /**< would SCIP abort if the LP is not solved? */
24922493
SCIP_Bool* propagateagain, /**< pointer to store whether we want to propagate again */
24932494
SCIP_Bool* cutoff, /**< pointer to store whether the node can be cut off */
24942495
SCIP_Bool* unbounded, /**< pointer to store whether an unbounded ray was found in the LP */
@@ -2568,7 +2569,7 @@ SCIP_RETCODE priceAndCutLoop(
25682569
/* solve initial LP of price-and-cut loop */
25692570
SCIPsetDebugMsg(set, "node: solve LP with price and cut\n");
25702571
SCIP_CALL( SCIPlpSolveAndEval(lp, set, messagehdlr, blkmem, stat, eventqueue, eventfilter, transprob,
2571-
set->lp_iterlim, FALSE, TRUE, FALSE, lperror) );
2572+
set->lp_iterlim, FALSE, TRUE, FALSE, forcedlpsolve, lperror) );
25722573
assert(lp->flushed);
25732574
assert(lp->solved || *lperror);
25742575

@@ -2672,7 +2673,7 @@ SCIP_RETCODE priceAndCutLoop(
26722673

26732674
/* resolve LP */
26742675
SCIP_CALL( SCIPlpSolveAndEval(lp, set, messagehdlr, blkmem, stat, eventqueue, eventfilter, transprob,
2675-
set->lp_iterlim, FALSE, TRUE, FALSE, lperror) );
2676+
set->lp_iterlim, FALSE, TRUE, FALSE, FALSE, lperror) );
26762677
assert(lp->flushed);
26772678
assert(lp->solved || *lperror);
26782679

@@ -2908,7 +2909,7 @@ SCIP_RETCODE priceAndCutLoop(
29082909
/* solve LP (with dual simplex) */
29092910
SCIPsetDebugMsg(set, "separation: solve LP\n");
29102911
SCIP_CALL( SCIPlpSolveAndEval(lp, set, messagehdlr, blkmem, stat, eventqueue, eventfilter, transprob,
2911-
set->lp_iterlim, FALSE, TRUE, FALSE, lperror) );
2912+
set->lp_iterlim, FALSE, TRUE, FALSE, FALSE, lperror) );
29122913
assert(lp->flushed);
29132914
assert(lp->solved || *lperror);
29142915

@@ -3007,7 +3008,7 @@ SCIP_RETCODE priceAndCutLoop(
30073008
lp->solved = FALSE;
30083009
SCIPlpExactAllowExactSolve(lp->lpexact, set, TRUE);
30093010
SCIP_CALL( SCIPlpSolveAndEval(lp, set, messagehdlr, blkmem, stat, eventqueue, eventfilter, transprob,
3010-
set->lp_iterlim, FALSE, FALSE, FALSE, lperror) );
3011+
set->lp_iterlim, FALSE, FALSE, FALSE, FALSE, lperror) );
30113012
if( !(*lperror) )
30123013
SCIPtreeSetFocusNodeLP(tree, TRUE);
30133014
}
@@ -3206,6 +3207,7 @@ SCIP_RETCODE solveNodeLP(
32063207
SCIP_Bool initiallpsolved, /**< was the initial LP already solved? */
32073208
SCIP_Bool fullseparation, /**< are we in the first prop-and-cut-and-price loop? */
32083209
SCIP_Bool newinitconss, /**< do we have to add new initial constraints? */
3210+
SCIP_Bool forcedlpsolve, /**< would SCIP abort if the LP is not solved? */
32093211
SCIP_Bool* propagateagain, /**< pointer to store whether we want to propagate again */
32103212
SCIP_Bool* solverelaxagain, /**< pointer to store TRUE, if the external relaxators should be called again */
32113213
SCIP_Bool* cutoff, /**< pointer to store TRUE, if the node can be cut off */
@@ -3361,7 +3363,7 @@ SCIP_RETCODE solveNodeLP(
33613363
/* solve the LP with price-and-cut*/
33623364
SCIP_CALL( priceAndCutLoop(blkmem, set, messagehdlr, stat, mem, transprob, origprob, primal, tree, reopt, lp,
33633365
pricestore, sepastore, cutpool, delayedcutpool, branchcand, conflict, conflictstore, eventqueue,
3364-
eventfilter, cliquetable, fullseparation, propagateagain, cutoff, unbounded, lperror, pricingaborted) );
3366+
eventfilter, cliquetable, fullseparation, forcedlpsolve, propagateagain, cutoff, unbounded, lperror, pricingaborted) );
33653367

33663368
/* check if the problem was changed and the relaxation needs to be resolved */
33673369
if( (transprob->ncolvars != oldnpricedvars) || (stat->ninitconssadded != oldninitconssadded) ||
@@ -3392,7 +3394,7 @@ SCIP_RETCODE solveNodeLP(
33923394
lp->cutoffbound = SCIPlpiInfinity(SCIPlpGetLPI(lp));
33933395

33943396
lp->solved = FALSE;
3395-
SCIP_CALL( SCIPlpSolveAndEval(lp, set, messagehdlr, blkmem, stat, eventqueue, eventfilter, transprob, -1LL, FALSE, FALSE, FALSE, lperror) );
3397+
SCIP_CALL( SCIPlpSolveAndEval(lp, set, messagehdlr, blkmem, stat, eventqueue, eventfilter, transprob, -1LL, FALSE, FALSE, FALSE, forcedlpsolve, lperror) );
33963398

33973399
/* reinstall old cutoff bound */
33983400
lp->cutoffbound = tmpcutoff;
@@ -3954,7 +3956,7 @@ SCIP_RETCODE propAndSolve(
39543956
SCIP_Bool propagate, /**< should we propagate */
39553957
SCIP_Bool solvelp, /**< should we solve the lp */
39563958
SCIP_Bool solverelax, /**< should we solve the relaxation */
3957-
SCIP_Bool forcedlpsolve, /**< is there a need for a solve lp */
3959+
SCIP_Bool forcedlpsolve, /**< would SCIP abort if the LP is not solved? */
39583960
SCIP_Bool initiallpsolved, /**< was the initial LP already solved? */
39593961
SCIP_Bool fullseparation, /**< are we in the first prop-and-cut-and-price loop? */
39603962
SCIP_Longint* afterlpproplps, /**< pointer to store the last LP count for which AFTERLP propagation was performed */
@@ -4170,7 +4172,7 @@ SCIP_RETCODE propAndSolve(
41704172
/* solve the node's LP */
41714173
SCIP_CALL( solveNodeLP(blkmem, set, messagehdlr, stat, mem, origprob, transprob, primal, tree, reopt, lp, relaxation, pricestore,
41724174
sepastore, cutpool, delayedcutpool, branchcand, conflict, conflictstore, eventqueue, eventfilter, cliquetable,
4173-
initiallpsolved, fullseparation, newinitconss, propagateagain, solverelaxagain, cutoff, unbounded, lperror, pricingaborted) );
4175+
initiallpsolved, fullseparation, newinitconss, forcedlpsolve, propagateagain, solverelaxagain, cutoff, unbounded, lperror, pricingaborted) );
41744176

41754177
if( focusnode->parent == NULL )
41764178
{

0 commit comments

Comments
 (0)