public static bool TryMatchVarPlusConst <Variable, Expression>(this IExpressionDecoder <Variable, Expression> decoder,
Expression exp, out Variable var, out int k)
{
Contract.Requires(decoder != null);
if (decoder.IsBinaryExpression(exp) && decoder.OperatorFor(exp) == ExpressionOperator.Addition)
{
var left = decoder.LeftExpressionFor(exp);
var right = decoder.RightExpressionFor(exp);
if (decoder.IsConstantInt(left, out k) && decoder.IsVariable(right))
{
var = decoder.UnderlyingVariable(right);
return(true);
}
if (decoder.IsConstantInt(right, out k) && decoder.IsVariable(left))
{
var = decoder.UnderlyingVariable(left);
return(true);
}
}
var = default(Variable);
k = default(int);
return(false);
}
static bool IsVariableEqConstant(Expression guard, IExpressionDecoder <Variable, Expression> decoder)
{
switch (decoder.OperatorFor(guard))
{
case ExpressionOperator.Equal:
case ExpressionOperator.Equal_Obj:
Expression left = decoder.LeftExpressionFor(guard);
Expression right = decoder.RightExpressionFor(guard);
return((decoder.IsVariable(left) && decoder.IsConstant(right)) || (decoder.IsVariable(right) && decoder.IsConstant(right)));
default:
return(false);
}
}
public static IDictionary <TVar, Sequence <TInterval> > GreaterEqualThanZero <TEnv, TVar, TExpr, TInterval>
(TExpr expr, IExpressionDecoder <TVar, TExpr> decoder, TEnv env)
where TEnv : IIntervalEnvironment <TVar, TExpr, TInterval, Rational>
where TVar : IEquatable <TVar>
where TInterval : IntervalBase <TInterval, Rational>
{
var result = new Dictionary <TVar, Sequence <TInterval> > ();
var variable = decoder.UnderlyingVariable(expr);
AddToResult(result, variable, env.Eval(expr).Meet(env.Context.Positive));
if (!decoder.IsVariable(expr))
{
Polynomial <TVar, TExpr> zeroPoly; // poly(0)
if (!Polynomial <TVar, TExpr> .TryToPolynomial(new[] { Monomial <TVar> .From(Rational.Zero) }, out zeroPoly))
{
throw new AbstractInterpretationException(
"It can never be the case that the conversion of a list of monomials into a polynomial fails.");
}
Polynomial <TVar, TExpr> exprPoly; // poly(expr)
Polynomial <TVar, TExpr> fullPoly; // '0 <= poly(expr)' polynome
if (Polynomial <TVar, TExpr> .TryBuildFrom(expr, decoder, out exprPoly) &&
Polynomial <TVar, TExpr> .TryToPolynomial(ExpressionOperator.LessEqualThan, zeroPoly, exprPoly, out fullPoly) &&
fullPoly.IsIntervalForm)
{
var k = fullPoly.Left[0].Coeff; // k != 0
TVar x;
fullPoly.Left[0].IsSingleVariable(out x);
Rational constraint;
if (Rational.TryDivide(fullPoly.Right[0].Coeff, k, out constraint))
{
TInterval interval;
if (k > 0L) // +x <= constraint
{
interval = env.Eval(x).Meet(env.Context.For(Rational.MinusInfinity, constraint));
}
else // -x <= -constraint ==> x >= constraint
{
interval = env.Eval(x).Meet(env.Context.For(constraint, Rational.PlusInfinity));
}
AddToResult(result, x, interval);
}
}
}
return(result);
}
static public Exp <E> Box <E>(E exp, IExpressionDecoder <E> decoder)
{
if (decoder.IsVariable(exp))
{
return(new Var <E>(exp, decoder));
}
else
{
switch (decoder.OperatorFor(exp))
{
case ExpressionOperator.ConvertToInt32:
case ExpressionOperator.ConvertToUInt16:
case ExpressionOperator.ConvertToUInt32:
case ExpressionOperator.ConvertToUInt8:
return(Box(decoder.LeftExpressionFor(exp), decoder));
}
return(new Exp <E>(exp, decoder));
}
}
public static bool IsAtomicExpression <Variable, Expression>(this IExpressionDecoder <Variable, Expression> decoder, Expression exp)
{
Contract.Requires(decoder != null);
return(decoder.IsConstant(exp) || decoder.IsVariable(exp));
}
/// <summary>
/// Infer exp \in [0, +oo], and if exp is a compound expression also some other constraints
/// </summary>
static public List <Pair <Variable, IType> > InferConstraints_GeqZero <Variable, Expression, IType>(
Expression exp, IExpressionDecoder <Variable, Expression> decoder,
ISetOfNumbersAbstraction <Variable, Expression, Rational, IType> iquery)
where IType : IntervalBase <IType, Rational>
{
Contract.Requires(decoder != null);
Contract.Requires(iquery != null);
Contract.Ensures(Contract.Result <List <Pair <Variable, IType> > >() != null);
var result = new List <Pair <Variable, IType> >();
var expVar = decoder.UnderlyingVariable(exp);
result.Add(expVar, iquery.Eval(exp).Meet(iquery.Interval_Positive));
if (!decoder.IsVariable(exp))
{
Polynomial <Variable, Expression> zero; // = 0
if (!Polynomial <Variable, Expression> .TryToPolynomialForm(new Monomial <Variable>[] { new Monomial <Variable>(0) }, out zero))
{
throw new AbstractInterpretationException("It can never be the case that the conversion of a list of monomials into a polynomial fails");
}
Polynomial <Variable, Expression> expAsPolynomial, newPolynomial;
if (Polynomial <Variable, Expression> .TryToPolynomialForm(exp, decoder, out expAsPolynomial) &&
Polynomial <Variable, Expression> .TryToPolynomialForm(ExpressionOperator.LessEqualThan, zero, expAsPolynomial, out newPolynomial)) // 0 <= exp
{
if (newPolynomial.IsIntervalForm)
{ // if it is in the form of k1 * x <= k2
var k1 = newPolynomial.Left[0].K;
var x = newPolynomial.Left[0].VariableAt(0);
var k2 = newPolynomial.Right[0].K;
Rational bound;
if (Rational.TryDiv(k2, k1, out bound)) //var bound = k2 / k1;
{
if (k1 > 0)
{
var intv = iquery.Eval(x).Meet(iquery.IntervalLeftOpen(bound));
result.Add(x, intv);
}
else if (k1 < 0)
{
var intv = iquery.Eval(x).Meet(iquery.IntervalRightOpen(bound));
result.Add(x, intv);
}
else
{
throw new AbstractInterpretationException("Impossible case");
}
}
}
}
}
return(result);
}
