/// <summary> /// Perform some rewritings to the boxed expressions, so that is is simplified, and it is nicer for a human reader /// </summary> public static BoxedExpression MakeItPrettier <Variable>(this BoxedExpression be, IExpressionDecoder <BoxedVariable <Variable>, BoxedExpression> decoder, IExpressionEncoder <BoxedVariable <Variable>, BoxedExpression> encoder) { Contract.Requires(encoder != null); var result = be; // 0. Do not do any work on MinValue <= exp, as -exp <= -MinValue is wrong BinaryOperator bop; BoxedExpression left, right; int maybeMinInt; long maybeMinLong; if (be.IsBinaryExpression(out bop, out left, out right) && (bop == BinaryOperator.Cle || bop == BinaryOperator.Clt || bop == BinaryOperator.Cle_Un || bop == BinaryOperator.Clt_Un) && ((left.IsConstantInt(out maybeMinInt) && maybeMinInt == Int32.MinValue) || (left.IsConstantInt64(out maybeMinLong) && maybeMinLong == Int64.MinValue)) ) { return(result); } // 1. If it is a polynomial, do some arithmetic simplification, puts all the variables on one side, etc. Polynomial <BoxedVariable <Variable>, BoxedExpression> pol; if (Polynomial <BoxedVariable <Variable>, BoxedExpression> .TryToPolynomialForm(be, decoder, out pol)) { if (pol.IsTautology) { return(encoder.ConstantFor(true)); } // m1 - m2 == 0 becomes m1 == m2 BoxedVariable <Variable> x, y; Rational k; if (pol.TryMatch_XMinusYEqualk3(out x, out y, out k) && k.IsZero) { var xExp = encoder.VariableFor(x); var yExp = encoder.VariableFor(y); return(encoder.CompoundExpressionFor(ExpressionType.Bool, ExpressionOperator.Equal, xExp, yExp)); } result = pol.ToPureExpression(encoder); } // To do: add some more pretty printing there result = MakeItPrettier(result, x => encoder.ConstantFor(x)); return(result); }
public override Expression Convert <Expression>(IExpressionEncoder <Variable, Expression> encoder) { return(encoder.CompoundExpressionFor(ExpressionType.Int32, ExpressionOperator.Addition, encoder.VariableFor(var), encoder.ConstantFor(value))); }
public static INumericalAbstractDomain <Variable, Expression> TestTrueEqual <Variable, Expression>( this INumericalAbstractDomain <Variable, Expression> aState, Expression exp, SetOfConstraints <Variable> equalities, IExpressionEncoder <Variable, Expression> encoder) { Contract.Requires(aState != null); Contract.Requires(exp != null); Contract.Requires(equalities != null); Contract.Requires(encoder != null); Contract.Ensures(Contract.Result <INumericalAbstractDomain <Variable, Expression> >() != null); if (equalities.IsNormal()) { var newSet = new Set <Expression>(); foreach (var v in equalities.Values) { newSet.Add(encoder.VariableFor(v)); } return(aState.TestTrueEqual(exp, newSet)); } else { return(aState); } }
/// <summary> /// Construct left - right, or left iff right == 0 /// </summary> public static Expression SmartSubtraction <Variable, Expression>(this IExpressionEncoder <Variable, Expression> encoder, Variable leftVar, Variable rightVar, IExpressionDecoder <Variable, Expression> decoder) { Contract.Requires(decoder != null); Contract.Requires(encoder != null); var right = encoder.VariableFor(rightVar); var left = encoder.VariableFor(leftVar); int value; if (decoder.IsConstantInt(right, out value) && value == 0) { return(left); } return(encoder.CompoundExpressionFor(ExpressionType.Int32, ExpressionOperator.Subtraction, left, right)); }
public static INumericalAbstractDomain <Variable, Expression> TestTrue <Variable, Expression>( this INumericalAbstractDomain <Variable, Expression> aState, Variable v, NonRelationalValueAbstraction <Variable, Expression> nonRelationalValue, IExpressionEncoder <Variable, Expression> encoder) { Contract.Requires(v != null); Contract.Requires(aState != null); Contract.Requires(nonRelationalValue != null); Contract.Requires(encoder != null); Contract.Ensures(Contract.Result <INumericalAbstractDomain <Variable, Expression> >() != null); if (nonRelationalValue.IsBottom) { Contract.Assume(aState.Bottom as INumericalAbstractDomain <Variable, Expression> != null); // F: Adding the assumption as we do not track types return(aState.Bottom as INumericalAbstractDomain <Variable, Expression>); } if (nonRelationalValue.IsTop) { return(aState); } var result = aState; // Assume the interval if (nonRelationalValue.Interval.IsNormal()) { result.AssumeInDisInterval(v, nonRelationalValue.Interval); } var vExp = encoder.VariableFor(v); // Assume the equalities if (nonRelationalValue.Equalities.IsNormal()) { result = result.TestTrueEqual(vExp, nonRelationalValue.Equalities, encoder); } // Assume the strict upper bounds if (nonRelationalValue.StrictUpperBounds.IsNormal()) { result = result.TestTrueLessThan(vExp, nonRelationalValue.StrictUpperBounds, encoder); } // Assume the weak upper bounds if (nonRelationalValue.WeakUpperBounds.IsNormal()) { result = result.TestTrueLessEqualThan(vExp, nonRelationalValue.WeakUpperBounds, encoder); } return(result); }
public static INumericalAbstractDomain <Variable, Expression> TestTrueLessThan <Variable, Expression>( this INumericalAbstractDomain <Variable, Expression> aState, Expression exp, Set <Variable> uppBounds, IExpressionEncoder <Variable, Expression> encoder) { Contract.Requires(aState != null); Contract.Requires(exp != null); Contract.Requires(uppBounds != null); Contract.Requires(encoder != null); Contract.Ensures(Contract.Result <INumericalAbstractDomain <Variable, Expression> >() != null); return(aState.TestTrueLessThan(exp, uppBounds.ConvertAll(v => encoder.VariableFor(v)))); }
public override Expression Convert <Expression>(IExpressionEncoder <Variable, Expression> encoder) { return(encoder.VariableFor(var)); }