public IAbstractDomainWithTransferFunctions <Expression> TestFalse(Expression guard)
{
IntervalEnvironment <Rational, Expression> resultLeft = (IntervalEnvironment <Rational, Expression>)left.TestFalse(guard);
WeakUpperBounds <Expression, Rational> resultRight = (WeakUpperBounds <Expression, Rational>)right.TestFalse(guard);
return((IAbstractDomainWithTransferFunctions <Expression>)Factory(resultLeft, resultRight));
}
public SubPoly(IExpressionDecoder <Expression> decoder, IExpressionEncoder <Expression> encoder)
{
IntervalEnvironment <Expression> intv = new IntervalEnvironment <Expression>(decoder, encoder);
LinearEqualitiesEnvironment <Expression> lineq = new LinearEqualitiesEnvironment <Expression>(decoder, encoder, true, false);
this.subpoly = new SubPolyhedra <Expression>(lineq, intv, decoder, encoder);
}
public INumericalAbstractDomain <Variable, Expression> RemoveRedundanciesWith(INumericalAbstractDomain <Variable, Expression> oracle)
{
IntervalEnvironment <Variable, Expression> resultLeft = (IntervalEnvironment <Variable, Expression>) this.Left.RemoveRedundanciesWith(oracle);
StripeWithIntervals <Variable, Expression, MetaDataDecoder> resultRight = (StripeWithIntervals <Variable, Expression, MetaDataDecoder>) this.Right.RemoveRedundanciesWith(oracle);
return((INumericalAbstractDomain <Variable, Expression>)Factory(resultLeft, resultRight));
}
public INumericalAbstractDomain <Variable, Expression> TestTrueEqual(Expression /*!*/ exp1, Expression /*!*/ exp2)
{
IntervalEnvironment <Variable, Expression> resultLeft = this.Left.TestTrueEqual(exp1, exp2);
StripeWithIntervals <Variable, Expression, MetaDataDecoder> resultRight = (StripeWithIntervals <Variable, Expression, MetaDataDecoder>) this.Right.TestTrueEqual(exp1, exp2);
return((INumericalAbstractDomain <Variable, Expression>)Factory(resultLeft, resultRight));
}
public virtual IAbstractDomainForEnvironments <Variable, Expression> TestFalse(Expression guard)
{
IntervalEnvironment <Variable, Expression> resultLeft = this.Left.TestFalse(guard);
StripeWithIntervals <Variable, Expression, MetaDataDecoder> resultRight = (StripeWithIntervals <Variable, Expression, MetaDataDecoder>) this.Right.TestFalse(guard);
return((IAbstractDomainForEnvironments <Variable, Expression>)Factory(resultLeft, resultRight));
}
private PolyhedraEnvironment(IExpressionDecoder <Variable, Expression> decoder, IExpressionEncoder <Variable, Expression> encoder, AI.PolyhedraLattice.Element value, IntervalEnvironment <Variable, Expression> intv)
{
this.decoder = decoder;
this.encoder = encoder;
embedded = value;
this.intv = intv;
testTrueVisitor = new PolyhedraEnvironment <Expression> .PolyhedraTestTrueVisitor(decoder);
testFalseVisitor = new PolyhedraEnvironment <Expression> .PolyhedraTestFalseVisitor(decoder);
testTrueVisitor.FalseVisitor = testFalseVisitor;
testFalseVisitor.TrueVisitor = testTrueVisitor;
}
public PolyhedraEnvironment(IExpressionDecoder <Variable, Expression> decoder, IExpressionEncoder <Variable, Expression> encoder)
{
this.decoder = decoder;
this.encoder = encoder;
embedded = UnderlyingPolyhedra.Top;
intv = new IntervalEnvironment <Variable, Expression>(decoder, encoder);
testTrueVisitor = new PolyhedraEnvironment <Expression> .PolyhedraTestTrueVisitor(decoder);
testFalseVisitor = new PolyhedraEnvironment <Expression> .PolyhedraTestFalseVisitor(decoder);
testTrueVisitor.FalseVisitor = testFalseVisitor;
testFalseVisitor.TrueVisitor = testTrueVisitor;
}
public IntervalEnvironment <Variable, Expression> AbstractsAwayTooLargeBounds(long min, long max)
{
Contract.Requires(min <= max);
Contract.Ensures(Contract.Result <IntervalEnvironment <Variable, Expression> >() != null);
if (this.IsBottom || this.IsTop)
{
return(this);
}
var buff = new IntervalEnvironment <Variable, Expression>(this.ExpressionManager);
foreach (var pair in this.Elements)
{
// Is lower bound small enough?
if (min <= pair.Value.LowerBound)
{
// Is upper bound small enough?
if (pair.Value.UpperBound <= max)
{
buff[pair.Key] = pair.Value;
}
else
{ // Abstract upper bound
buff[pair.Key] = Interval.For(pair.Value.LowerBound, Rational.PlusInfinity);
}
}
else
{ // We know lower bound is too large
if (pair.Value.UpperBound <= max)
{
buff[pair.Key] = Interval.For(Rational.MinusInfinity, pair.Value.UpperBound);
}
else
{
// Interval too large, let's forget it!
}
}
}
return(buff);
}
public static bool TryEvalWithCache(
IntervalEnvironment <Variable, Expression> env, Variable exp, Dictionary <Variable, Interval> cache, out Interval valueIfNormal)
{
Contract.Requires(env != null);
Contract.Requires(cache != null);
Contract.Ensures(!Contract.Result <bool>() || Contract.ValueAtReturn(out valueIfNormal) != null);
if (!cache.TryGetValue(exp, out valueIfNormal))
{
valueIfNormal = env.Eval(exp);
cache[exp] = valueIfNormal;
}
else
{
Contract.Assume(valueIfNormal != null);
}
return(valueIfNormal.IsNormal);
}
/// <summary>
/// The pairwise widening
/// </summary>
public override IAbstractDomain Widening(IAbstractDomain prev)
{
if (this.IsBottom)
{
return(prev);
}
if (prev.IsBottom)
{
return(this);
}
Debug.Assert(prev is ProductIntervalsWeakUpperBounds <Expression>, "Wrong type of the domain for the widening...");
ProductIntervalsWeakUpperBounds <Expression> asIntWSUB = (ProductIntervalsWeakUpperBounds <Expression>)prev;
IntervalEnvironment <Rational, Expression> widenLeft = (IntervalEnvironment <Rational, Expression>) this.Left.Widening(asIntWSUB.Left);
WeakUpperBounds <Expression, Rational> widenRight = (WeakUpperBounds <Expression, Rational>) this.Right.Widening(asIntWSUB.Right);
ProductIntervalsWeakUpperBounds <Expression> result = (ProductIntervalsWeakUpperBounds <Expression>) this.Factory(widenLeft, widenRight);
return(result);
}
public StripeWithIntervals(IntervalEnvironment <Variable, Expression> /*!*/ left, StripeWithIntervals <Variable, Expression, MetaDataDecoder> /*!*/ right, IExpressionDecoder <Variable, Expression> decoder, Logger Log)
: base(left, right, Log)
{
this.decoder = decoder;
}
Reduce(IntervalEnvironment <Rational, Expression> left, WeakUpperBounds <Expression, Rational> right)
{
return(this.Factory(left, right));
}
Factory(IntervalEnvironment <Rational, Expression> left, WeakUpperBounds <Expression, Rational> right)
{
return(new ProductIntervalsWeakUpperBounds <Expression>(left, right, this.decoder));
}
private IntervalEnvironment(IntervalEnvironment <Variable, Expression> original)
: base(original)
{
}
private PolyhedraEnvironment(PolyhedraEnvironment <Expression> pe, AI.PolyhedraLattice.Element value, IntervalEnvironment <Variable, Expression> intv)
: this(pe.decoder, pe.encoder, value, intv)
{
testTrueVisitor = pe.testTrueVisitor;
testFalseVisitor = pe.testFalseVisitor;
}
Factory(IntervalEnvironment <Variable, Expression> left, StripeWithIntervals <Variable, Expression, MetaDataDecoder> right)
{
return(new StripeWithIntervals <Variable, Expression, MetaDataDecoder>(left, right, this.decoder, this.Log));
}
/// <summary>
/// Please note that the decoder MUST be already be set for the <code>left</code> and <code>right</code> abstract domains
/// </summary>
public ProductIntervalsWeakUpperBounds(IntervalEnvironment <Rational, Expression> /*!*/ left, WeakUpperBounds <Expression, Rational> /*!*/ right, IExpressionDecoder <Expression> decoder)
: base(left, right)
{
this.decoder = decoder;
}
Reduce(IntervalEnvironment <Variable, Expression> left, StripeWithIntervals <Variable, Expression, MetaDataDecoder> right)
{
return(this.Factory(left, right));
}
[ContractVerification(false)] // The analysis of this method takes forever. Should consider refactoring
internal Set <Polynomial <Variable, Expression> > ConvexHullHelper(
IntervalEnvironment <Variable, Expression> other, Variable slack, SubPolyhedra.JoinConstraintInference inference)
{
Contract.Requires(other != null);
var result = new Set <Polynomial <Variable, Expression> >();
var commonVariables = this.VariablesNonSlack.SetIntersection(other.VariablesNonSlack);
var oct = false;
if (commonVariables.Count <= SubPolyhedra.MaxVariablesInOctagonsConstraintInference)
{
oct = true;
}
else if (inference == SubPolyhedra.JoinConstraintInference.Standard)
{
return(result);
}
bool CH =
inference == SubPolyhedra.JoinConstraintInference.CHOct ||
inference == SubPolyhedra.JoinConstraintInference.ConvexHull2D;
oct =
oct ||
inference == SubPolyhedra.JoinConstraintInference.CHOct ||
inference == SubPolyhedra.JoinConstraintInference.Octagons;
int i = 0, j = 0;
var this_Bounds = new Dictionary <Variable, Interval>();
var other_Bounds = new Dictionary <Variable, Interval>();
foreach (var e1 in commonVariables)
{
i++;
Interval e1Left, e1Right;
if (
!TryEvalWithCache(this, e1, this_Bounds, out e1Left) ||
!TryEvalWithCache(other, e1, other_Bounds, out e1Right))
{
continue;
}
j = 0;
foreach (var e2 in commonVariables)
{
j++;
// either e1 == e2 or we already have relations between e1 and e2
if (e1.Equals(e2) || j <= i)
{
continue;
}
Interval e2Left, e2Right;
if (
!TryEvalWithCache(this, e2, this_Bounds, out e2Left) ||
!TryEvalWithCache(other, e2, other_Bounds, out e2Right))
{
continue;
}
if (oct)
{
#region Adding octogonal constraints to get at least as much precision as octagons
var monomials = new Monomial <Variable>[] { new Monomial <Variable>(e1), new Monomial <Variable>(-1, e2), new Monomial <Variable>(slack) };
Polynomial <Variable, Expression> pol;
if (!Polynomial <Variable, Expression> .TryToPolynomialForm(true, monomials, out pol))
{
throw new AbstractInterpretationException("Impossible case");
}
result.Add(pol);
#endregion
}
if (CH)
{
#region Convex Hull
// adaptation of the Monotone Chain algorithm
var vertices = new PairNonNull <Rational, Rational>[8]
{
new PairNonNull <Rational, Rational>(e1Left.LowerBound, e2Left.LowerBound),
new PairNonNull <Rational, Rational>(e1Left.LowerBound, e2Left.UpperBound),
new PairNonNull <Rational, Rational>(e1Left.UpperBound, e2Left.LowerBound),
new PairNonNull <Rational, Rational>(e1Left.UpperBound, e2Left.UpperBound),
new PairNonNull <Rational, Rational>(e1Right.LowerBound, e2Right.LowerBound),
new PairNonNull <Rational, Rational>(e1Right.LowerBound, e2Right.UpperBound),
new PairNonNull <Rational, Rational>(e1Right.UpperBound, e2Right.LowerBound),
new PairNonNull <Rational, Rational>(e1Right.UpperBound, e2Right.UpperBound)
};
try
{
Array.Sort(vertices,
delegate(PairNonNull <Rational, Rational> x, PairNonNull <Rational, Rational> y)
{
if ((x.One - y.One).Sign == 0)
{
return((x.Two - y.Two).Sign);
}
else
{
return((x.One - y.One).Sign);
}
});
}
catch (InvalidOperationException)
{
return(result);
}
var IsInHull = new bool[8];
try
{
Polynomial <Variable, Expression> pol;
#region Computation of the Lower Hull
IsInHull[0] = IsFinite(vertices[0]);
IsInHull[2] = IsFinite(vertices[2]);
IsInHull[4] = IsFinite(vertices[4]);
if (IsInHull[0] && IsInHull[2] && IsInHull[4] &&
(vertices[2].One - vertices[0].One) * (vertices[4].Two - vertices[0].Two) <= (vertices[4].One - vertices[0].One) * (vertices[2].Two - vertices[0].Two))
{
IsInHull[2] = false;
}
IsInHull[6] = IsFinite(vertices[6]);
if (IsInHull[2] && IsInHull[4] && IsInHull[6] &&
(vertices[4].One - vertices[2].One) * (vertices[6].Two - vertices[2].Two) <= (vertices[6].One - vertices[2].One) * (vertices[4].Two - vertices[2].Two))
{
IsInHull[4] = false;
}
if (IsInHull[0] && IsInHull[4] && IsInHull[6] &&
(vertices[4].One - vertices[0].One) * (vertices[6].Two - vertices[0].Two) <= (vertices[6].One - vertices[0].One) * (vertices[4].Two - vertices[0].Two))
{
IsInHull[4] = false;
}
if (IsInHull[0] && IsInHull[2] && IsInHull[6] &&
(vertices[2].One - vertices[0].One) * (vertices[6].Two - vertices[0].Two) <= (vertices[6].One - vertices[0].One) * (vertices[2].Two - vertices[0].Two))
{
IsInHull[2] = false;
}
#endregion
#region Computation of the Upper Hull
IsInHull[1] = IsFinite(vertices[1]);
IsInHull[3] = IsFinite(vertices[3]);
IsInHull[5] = IsFinite(vertices[5]);
if (IsInHull[1] && IsInHull[3] && IsInHull[5] &&
(vertices[3].One - vertices[1].One) * (vertices[5].Two - vertices[1].Two) >= (vertices[5].One - vertices[1].One) * (vertices[3].Two - vertices[1].Two))
{
IsInHull[3] = false;
}
IsInHull[7] = IsFinite(vertices[7]);
if (IsInHull[3] && IsInHull[5] && IsInHull[7] &&
(vertices[5].One - vertices[3].One) * (vertices[7].Two - vertices[3].Two) >= (vertices[7].One - vertices[3].One) * (vertices[5].Two - vertices[3].Two))
{
IsInHull[5] = false;
}
if (IsInHull[1] && IsInHull[5] && IsInHull[7] &&
(vertices[5].One - vertices[1].One) * (vertices[7].Two - vertices[1].Two) >= (vertices[7].One - vertices[1].One) * (vertices[5].Two - vertices[1].Two))
{
IsInHull[5] = false;
}
if (IsInHull[1] && IsInHull[3] && IsInHull[7] &&
(vertices[3].One - vertices[1].One) * (vertices[7].Two - vertices[1].Two) >= (vertices[7].One - vertices[1].One) * (vertices[3].Two - vertices[1].Two))
{
IsInHull[3] = false;
}
#endregion
#region Removing points that are in the hull of the subset of finite points but not in the hull due to infinite extreme points
int index = 0;
var value = Rational.For(0);
if (vertices[0].One.IsInfinity)
{
index = 2;
value = vertices[2].Two;
for (int n = 4; n < 8; n += 2)
{
if (vertices[n].Two <= value)
{
for (int m = index; m < n; m += 2)
{
IsInHull[m] = false;
}
index = n;
value = vertices[n].Two;
}
}
}
if (vertices[6].One.IsInfinity)
{
index = 4;
value = vertices[4].Two;
for (int n = 2; n >= 0; n -= 2)
{
if (vertices[n].Two <= value)
{
for (int m = index; m > n; m -= 2)
{
IsInHull[m] = false;
}
index = n;
value = vertices[n].Two;
}
}
}
if (vertices[1].One.IsInfinity)
{
index = 3;
value = vertices[3].Two;
for (int n = 5; n < 8; n += 2)
{
if (vertices[n].Two >= value)
{
for (int m = index; m < n; m += 2)
{
IsInHull[m] = false;
}
index = n;
value = vertices[n].Two;
}
}
}
if (vertices[7].One.IsInfinity)
{
index = 5;
value = vertices[5].Two;
for (int n = 3; n >= 0; n -= 2)
{
if (vertices[n].Two >= value)
{
for (int m = index; m > n; m -= 2)
{
IsInHull[m] = false;
}
index = n;
value = vertices[n].Two;
}
}
}
#endregion
#region Adding to the result the Polynomials for the edges that are in the hull and neither horizontal nor vertical
var point = new PairNonNull <Rational, Rational>();
Rational c;
int numberOfPointsInHull = 0;
for (int k = 0; k < 8; k += 2)
{
if (IsInHull[k])
{
if (numberOfPointsInHull > 0 && point.One != vertices[k].One && point.Two != vertices[k].Two)
{
try
{
c = (vertices[k].One - point.One) / (point.Two - vertices[k].Two);
}
catch (ArithmeticExceptionRational)
{
continue;
}
var list = new Monomial <Variable>[] { new Monomial <Variable>(e1), new Monomial <Variable>(c, e2), new Monomial <Variable>(slack) };
if (!Polynomial <Variable, Expression> .TryToPolynomialForm(true, list, out pol))
{
throw new AbstractInterpretationException("Impossible case");
}
result.Add(pol);
}
point = vertices[k];
numberOfPointsInHull++;
}
}
for (int k = 1; k < 8; k += 2)
{
if (IsInHull[k])
{
if (numberOfPointsInHull > 0 && point.One != vertices[k].One && point.Two != vertices[k].Two)
{
try
{
c = (vertices[k].One - point.One) / (point.Two - vertices[k].Two);
}
catch (ArithmeticExceptionRational)
{
continue;
}
var list = new Monomial <Variable>[] { new Monomial <Variable>(e1), new Monomial <Variable>(c, e2), new Monomial <Variable>(slack) };
if (!Polynomial <Variable, Expression> .TryToPolynomialForm(true, list, out pol))
{
throw new AbstractInterpretationException("Impossible case");
}
result.Add(pol);
}
point = vertices[k];
numberOfPointsInHull++;
}
}
#endregion
}
catch (ArithmeticExceptionRational)
{
// Ignore the constraint
}
#endregion
}
}
}
return(result);
}
