/**
* Compute a compound state representing possible results of adding the given summand compound
* states up. This method provides a much weaker implementation of compound state addition than
* {@link CompoundInterval#add(CompoundInterval)} and will thus usually return a much larger
* result range.
*
* @param a the first summand.
* @param b the second summand.
* @return a state representing possible results of adding the given summand compound states up.
*/
private CompoundInterval weakAdd(CompoundInterval pA, CompoundInterval pB) {
if (pA.isSingleton() && pA.containsZero()) {
return pB;
}
if (pB.isSingleton() && pB.containsZero()) {
return pA;
}
return abstractionOf(pA.add(pB));
}
@Override
public CompoundInterval visit(
ShiftLeft<CompoundInterval> pShiftLeft,
Map<? extends String, ? extends InvariantsFormula<CompoundInterval>> pEnvironment) {
CompoundInterval toShift = pShiftLeft.getShifted().accept(this, pEnvironment);
CompoundInterval shiftDistance = pShiftLeft.getShiftDistance().accept(this, pEnvironment);
CompoundInterval evaluation = toShift.shiftLeft(shiftDistance);
if (!shiftDistance.containsPositive()) {
return evaluation;
}
return abstractionOf(evaluation);
}
/**
* Compute a compound state representing possible results of multiplying the given factor compound
* states. This method provides a much weaker implementation of compound state addition than
* {@link CompoundInterval#multiply(CompoundInterval)} and will thus usually return a much larger
* result range.
*
* @param a the first factor.
* @param b the second factor.
* @return a state representing possible results of multiplying the given factor compound states.
*/
private CompoundInterval weakMultiply(CompoundInterval a, CompoundInterval b) {
if (a.isSingleton() && a.containsZero()) {
return a;
}
if (b.isSingleton() && b.containsZero()) {
return b;
}
if (a.isSingleton() && a.contains(1)) {
return b;
}
if (b.isSingleton() && b.contains(1)) {
return a;
}
return abstractionOf(a.multiply(b));
}
@Override
public CompoundInterval visit(
Variable<CompoundInterval> pVariable,
Map<? extends String, ? extends InvariantsFormula<CompoundInterval>> pEnvironment) {
InvariantsFormula<CompoundInterval> varState = pEnvironment.get(pVariable.getName());
if (varState == null) {
return CompoundInterval.top();
}
return varState.accept(this, pEnvironment);
}
private static CompoundInterval abstractionOf(CompoundInterval pValue) {
if (pValue.isBottom() || pValue.isTop()) {
return pValue;
}
CompoundInterval result = pValue.signum();
boolean extendToNeg = false;
if (!pValue.lessThan(result).isDefinitelyFalse()) {
extendToNeg = true;
}
if (!pValue.greaterThan(result).isDefinitelyFalse()) {
result = result.extendToPositiveInfinity();
}
if (extendToNeg) {
result = result.extendToNegativeInfinity();
}
assert result.unionWith(pValue).equals(result);
return result;
}