WitnessImprovement FCSimplexDecisionProcedure::primalImproveError(ArithVar errorVar){
bool useBlands = degeneratePivotsInARow() >= s_maxDegeneratePivotsBeforeBlandsOnLeaving;
UpdateInfo selected = selectUpdateForPrimal (errorVar, useBlands);
Assert(!selected.uninitialized());
WitnessImprovement w = selected.getWitness(useBlands);
Assert(debugCheckWitness(selected, w, useBlands));
updateAndSignal(selected, w);
logPivot(w);
return w;
}
WitnessImprovement FCSimplexDecisionProcedure::selectFocusImproving() {
Assert(d_focusErrorVar != ARITHVAR_SENTINEL);
Assert(d_focusSize >= 2);
LinearEqualityModule::UpdatePreferenceFunction upf =
&LinearEqualityModule::preferWitness<true>;
LinearEqualityModule::VarPreferenceFunction bpf =
&LinearEqualityModule::minRowLength;
UpdateInfo selected = selectPrimalUpdate(d_focusErrorVar, upf, bpf);
if(selected.uninitialized()){
Debug("selectFocusImproving") << "focus is optimum, but we don't have sat/conflict yet" << endl;
return focusDownToLastHalf();
}
Assert(!selected.uninitialized());
WitnessImprovement w = selected.getWitness(false);
Assert(debugCheckWitness(selected, w, false));
if(degenerate(w)){
Debug("selectFocusImproving") << "only degenerate" << endl;
if(d_prevWitnessImprovement == HeuristicDegenerate &&
d_witnessImprovementInARow >= s_focusThreshold){
Debug("selectFocusImproving") << "focus down been degenerate too long" << endl;
return focusDownToLastHalf();
}else{
Debug("selectFocusImproving") << "taking degenerate" << endl;
}
}
Debug("selectFocusImproving") << "selectFocusImproving did this " << selected << endl;
updateAndSignal(selected, w);
logPivot(w);
return w;
}
WitnessImprovement FCSimplexDecisionProcedure::dualLikeImproveError(ArithVar errorVar){
Assert(d_sgnDisagreements.empty());
Assert(d_focusSize > 1);
UpdateInfo selected = selectUpdateForDualLike(errorVar);
if(selected.uninitialized()){
// we found no proposals
// If this is empty, there must be an error on this variable!
// this should not be possible. It Should have been caught as a signal earlier
WitnessImprovement dropped = focusUsingSignDisagreements(errorVar);
Assert(d_sgnDisagreements.empty());
return dropped;
}else{
d_sgnDisagreements.clear();
}
Assert(d_sgnDisagreements.empty());
Assert(!selected.uninitialized());
if(selected.focusDirection() == 0 &&
d_prevWitnessImprovement == HeuristicDegenerate &&
d_witnessImprovementInARow >= s_focusThreshold){
Debug("focusDownToJust") << "focusDownToJust " << errorVar << endl;
return focusDownToJust(errorVar);
}else{
WitnessImprovement w = selected.getWitness(false);
Assert(debugCheckWitness(selected, w, false));
updateAndSignal(selected, w);
logPivot(w);
return w;
}
}
UpdateInfo FCSimplexDecisionProcedure::selectPrimalUpdate(ArithVar basic, LinearEqualityModule::UpdatePreferenceFunction upf, LinearEqualityModule::VarPreferenceFunction bpf) {
UpdateInfo selected;
static int instance = 0 ;
++instance;
Debug("arith::selectPrimalUpdate")
<< "selectPrimalUpdate " << instance << endl
<< basic << " " << d_tableau.basicRowLength(basic)
<< " " << d_linEq.debugBasicAtBoundCount(basic) << endl;
static const int s_maxCandidatesAfterImprove = 3;
bool isFocus = basic == d_focusErrorVar;
Assert(isFocus || d_errorSet.inError(basic));
int basicDir = isFocus? 1 : d_errorSet.getSgn(basic);
bool dualLike = !isFocus && d_focusSize > 1;
if(!isFocus){
loadFocusSigns();
}
decreasePenalties();
typedef std::vector<Cand> CandVector;
CandVector candidates;
for(Tableau::RowIterator ri = d_tableau.basicRowIterator(basic); !ri.atEnd(); ++ri){
const Tableau::Entry& e = *ri;
ArithVar curr = e.getColVar();
if(curr == basic){ continue; }
int sgn = e.getCoefficient().sgn();
int curr_movement = basicDir * sgn;
bool candidate =
(curr_movement > 0 && d_variables.cmpAssignmentUpperBound(curr) < 0) ||
(curr_movement < 0 && d_variables.cmpAssignmentLowerBound(curr) > 0);
Debug("arith::selectPrimalUpdate")
<< "storing " << basic
<< " " << curr
<< " " << candidate
<< " " << e.getCoefficient()
<< " " << curr_movement
<< " " << focusCoefficient(curr) << endl;
if(!candidate) { continue; }
if(!isFocus){
const Rational& focusC = focusCoefficient(curr);
Assert(dualLike || !focusC.isZero());
if(dualLike && curr_movement != focusC.sgn()){
Debug("arith::selectPrimalUpdate") << "sgn disagreement " << curr << endl;
d_sgnDisagreements.push_back(curr);
continue;
}else{
candidates.push_back(Cand(curr, penalty(curr), curr_movement, &focusC));
}
}else{
candidates.push_back(Cand(curr, penalty(curr), curr_movement, &e.getCoefficient()));
}
}
CompPenaltyColLength colCmp(&d_linEq);
CandVector::iterator i = candidates.begin();
CandVector::iterator end = candidates.end();
std::make_heap(i, end, colCmp);
bool checkEverything = d_pivots == 0;
int candidatesAfterFocusImprove = 0;
while(i != end && (checkEverything || candidatesAfterFocusImprove <= s_maxCandidatesAfterImprove)){
std::pop_heap(i, end, colCmp);
--end;
Cand& cand = (*end);
ArithVar curr = cand.d_nb;
const Rational& coeff = *cand.d_coeff;
LinearEqualityModule::UpdatePreferenceFunction leavingPrefFunc = selectLeavingFunction(curr);
UpdateInfo currProposal = d_linEq.speculativeUpdate(curr, coeff, leavingPrefFunc);
Debug("arith::selectPrimalUpdate")
<< "selected " << selected << endl
<< "currProp " << currProposal << endl
<< "coeff " << coeff << endl;
Assert(!currProposal.uninitialized());
if(candidatesAfterFocusImprove > 0){
candidatesAfterFocusImprove++;
}
if(selected.uninitialized() || (d_linEq.*upf)(selected, currProposal)){
selected = currProposal;
WitnessImprovement w = selected.getWitness(false);
Debug("arith::selectPrimalUpdate") << "selected " << w << endl;
setPenalty(curr, w);
if(improvement(w)){
bool exitEarly;
switch(w){
case ConflictFound: exitEarly = true; break;
case ErrorDropped:
if(checkEverything){
exitEarly = d_errorSize + selected.errorsChange() == 0;
Debug("arith::selectPrimalUpdate")
<< "ee " << d_errorSize << " "
<< selected.errorsChange() << " "
<< d_errorSize + selected.errorsChange() << endl;
}else{
exitEarly = true;
}
break;
case FocusImproved:
candidatesAfterFocusImprove = 1;
exitEarly = false;
break;
default:
exitEarly = false; break;
}
if(exitEarly){ break; }
}
}else{
Debug("arith::selectPrimalUpdate") << "dropped "<< endl;
}
}
if(!isFocus){
unloadFocusSigns();
}
return selected;
}
