void SimplexDecisionProcedure::shrinkInfeasFunc(TimerStat& timer, ArithVar inf, const ArithVarVec& dropped){
TimerStat::CodeTimer codeTimer(timer);
for(ArithVarVec::const_iterator i=dropped.begin(), i_end = dropped.end(); i != i_end; ++i){
ArithVar back = *i;
int focusSgn = d_errorSet.focusSgn(back);
Rational chg(-focusSgn);
d_linEq.substitutePlusTimesConstant(inf, back, chg);
}
}
WitnessImprovement FCSimplexDecisionProcedure::focusDownToLastHalf(){
Assert(d_focusSize >= 2);
Debug("focusDownToLastHalf") << "focusDownToLastHalf "
<< d_errorSet.errorSize() << " "
<< d_errorSet.focusSize() << " ";
uint32_t half = d_focusSize/2;
ArithVarVec buf;
for(ErrorSet::focus_iterator i = d_errorSet.focusBegin(),
i_end = d_errorSet.focusEnd(); i != i_end; ++i){
if(half > 0){
--half;
} else{
buf.push_back(*i);
}
}
WitnessImprovement w = adjustFocusShrank(buf);
Debug("focusDownToLastHalf") << "-> " << d_errorSet.focusSize() << endl;
return w;
}
WitnessImprovement FCSimplexDecisionProcedure::focusUsingSignDisagreements(ArithVar basic){
Assert(!d_sgnDisagreements.empty());
Assert(d_errorSet.focusSize() >= 2);
if(Debug.isOn("arith::focus")){
d_errorSet.debugPrint(Debug("arith::focus"));
}
ArithVar nb = d_linEq.minBy(d_sgnDisagreements, &LinearEqualityModule::minColLength);
const Tableau::Entry& e_evar_nb = d_tableau.basicFindEntry(basic, nb);
int oppositeSgn = - (e_evar_nb.getCoefficient().sgn());
Debug("arith::focus") << "focusUsingSignDisagreements " << basic << " " << oppositeSgn << endl;
ArithVarVec dropped;
Tableau::ColIterator colIter = d_tableau.colIterator(nb);
for(; !colIter.atEnd(); ++colIter){
const Tableau::Entry& entry = *colIter;
Assert(entry.getColVar() == nb);
int sgn = entry.getCoefficient().sgn();
Debug("arith::focus")
<< "on row "
<< d_tableau.rowIndexToBasic(entry.getRowIndex())
<< " "
<< entry.getCoefficient() << endl;
ArithVar currRow = d_tableau.rowIndexToBasic(entry.getRowIndex());
if(d_errorSet.inError(currRow) && d_errorSet.inFocus(currRow)){
int errSgn = d_errorSet.getSgn(currRow);
if(errSgn * sgn == oppositeSgn){
dropped.push_back(currRow);
Debug("arith::focus") << "dropping from focus " << currRow << endl;
}
}
}
d_sgnDisagreements.clear();
return adjustFocusShrank(dropped);
}
ArithVar SimplexDecisionProcedure::constructInfeasiblityFunction(TimerStat& timer, const ArithVarVec& set){
Debug("constructInfeasiblityFunction") << "constructInfeasiblityFunction start" << endl;
TimerStat::CodeTimer codeTimer(timer);
Assert(!d_errorSet.focusEmpty());
Assert(debugIsASet(set));
ArithVar inf = requestVariable();
Assert(inf != ARITHVAR_SENTINEL);
std::vector<Rational> coeffs;
std::vector<ArithVar> variables;
for(ArithVarVec::const_iterator iter = set.begin(), iend = set.end(); iter != iend; ++iter){
ArithVar e = *iter;
Assert(d_tableau.isBasic(e));
Assert(!d_variables.assignmentIsConsistent(e));
int sgn = d_errorSet.getSgn(e);
Assert(sgn == -1 || sgn == 1);
const Rational& violatedCoeff = sgn < 0 ? d_negOne : d_posOne;
coeffs.push_back(violatedCoeff);
variables.push_back(e);
Debug("constructInfeasiblityFunction") << violatedCoeff << " " << e << endl;
}
d_tableau.addRow(inf, coeffs, variables);
DeltaRational newAssignment = d_linEq.computeRowValue(inf, false);
d_variables.setAssignment(inf, newAssignment);
//d_linEq.trackVariable(inf);
d_linEq.trackRowIndex(d_tableau.basicToRowIndex(inf));
Debug("constructInfeasiblityFunction") << inf << " " << newAssignment << endl;
Debug("constructInfeasiblityFunction") << "constructInfeasiblityFunction done" << endl;
return inf;
}
ArithVar SimplexDecisionProcedure::constructInfeasiblityFunction(TimerStat& timer, ArithVar e){
ArithVarVec justE;
justE.push_back(e);
return constructInfeasiblityFunction(timer, justE);
}