public void Assign(Expression x, Expression exp, INumericalAbstractDomainQuery <Variable, Expression> preState)
{
Interval intvForExp = preState.BoundsFor(exp).AsInterval;
Variable xVar = decoder.UnderlyingVariable(x);
AssumeInInterval(xVar, intvForExp);
}
public override Set <Expression> VisitShiftRight(Expression left, Expression right, Expression original, INumericalAbstractDomainQuery <Variable, Expression> data)
{
if (this.AreInfinities(left, right))
{
return(new Set <Expression>());
}
var bounds = data.BoundsFor(right).AsInterval;
int val;
Polynomial <Variable, Expression> pol;
if (bounds.IsFiniteAndInt32Singleton(out val) && val > 0 &&
Polynomial <Variable, Expression> .TryToPolynomialForm(left, this.Decoder, out pol) &&
pol.IsLinear && !pol.Relation.HasValue && pol.Left.Length <= (1 << val))
{
var ub = null as IEnumerable <Expression>;
foreach (var m in pol.Left)
{
Variable v;
if (m.IsVariable(out v) && data.BoundsFor(v).LowerBound >= 0)
{
var upperbounds = data.UpperBoundsFor(v, true);
ub = ub == null ? upperbounds : ub.Intersect(upperbounds);
if (ub.Any())
{
continue;
}
}
return(new Set <Expression>());
}
// If we reach this point, we have meaningful constraints
return(new Set <Expression>(ub.ApplyToAll(exp => expManager.Encoder.CompoundExpressionFor(ExpressionType.Bool, ExpressionOperator.LessThan, x, exp))));
}
return(new Set <Expression>());
}
public override Set <Expression> VisitSubtraction(Expression left, Expression right, Expression original, INumericalAbstractDomainQuery <Variable, Expression> data)
{
var result = new Set <Expression>();
if (this.AreInfinities(left, right))
{
return(result);
}
// It is x = left - right,
if (data.BoundsFor(right).LowerBound > 0)
{
result.Add(expManager.Encoder.CompoundExpressionFor(ExpressionType.Bool, ExpressionOperator.LessThan, x, left)); // Then assume x < left
}
// It is x = left - (- Abs(right))
else if (data.BoundsFor(right).UpperBound < 0)
{
result.Add(expManager.Encoder.CompoundExpressionFor(ExpressionType.Bool, ExpressionOperator.LessThan, left, x)); // Then assume left < x
}
return(result);
}
public override Set <Expression> VisitAddition(Expression left, Expression right, Expression original, INumericalAbstractDomainQuery <Variable, Expression> data)
{
var result = new Set <Expression>();
if (data == null)
{
return(result);
}
// x := left + right
if (data.BoundsFor(right).LowerBound >= 0)
{
result.Add(expManager.Encoder.CompoundExpressionFor(ExpressionType.Bool, ExpressionOperator.LessEqualThan, left, x)); // Then assume left <= x
}
if (data.BoundsFor(left).LowerBound >= 0)
{
result.Add(expManager.Encoder.CompoundExpressionFor(ExpressionType.Bool, ExpressionOperator.LessEqualThan, right, x)); // Then assume right <= x
}
return(result);
}
private void Helper_Match_kY(
Expression x, INumericalAbstractDomainQuery <Variable, Expression> oracleDomain, List <Expression> result, Expression y)
{
Contract.Requires(result != null);
Expression ltExp;
if (oracleDomain.BoundsFor(y).LowerBound >= 1)
{
ltExp = expManager.Encoder.CompoundExpressionFor(ExpressionType.Bool, ExpressionOperator.LessThan, y, x);
result.Add(ltExp);
result.AddRange(UpperBounds(y, oracleDomain.UpperBoundsFor(x, false)));
}
}
public override Set <Expression> VisitModulus(Expression left, Expression right, Expression original, INumericalAbstractDomainQuery <Variable, Expression> data)
{
var result = new Set <Expression>();
if (this.AreInfinities(left, right))
{
return(result);
}
if (data.BoundsFor(right).LowerBound >= 0)
{
result.Add(expManager.Encoder.CompoundExpressionFor(ExpressionType.Bool, ExpressionOperator.LessThan, x, right)); // Then assume x < right
}
return(result);
}
