Reduce(IntervalEnvironment < Rational, Expression> left, WeakUpperBounds <Expression, Rational> right)
{
ALog.BeginReduce("IntervalsWithSymbolicUpperBounds");
foreach (Expression x in left.Keys)
{
foreach (Expression y in left.Keys)
{
if (x.Equals(y))
{
continue;
}
FlatAbstractDomain <bool> b = left.CheckIfLessThan(x, y);
if (b.IsTop || b.IsBottom)
{
continue;
}
if (b.BoxedElement == true)
{
ALog.Message("Adding " + ExpressionPrinter <Expression> .ToString(x, this.decoder) + " < " + ExpressionPrinter <Expression> .ToString(y, this.decoder)
+ " as " + left.BoundsFor(x) + " < " + left.BoundsFor(y));
right.TestTrueLessThan(x, y); // Add the constraint x < y
}
}
}
ALog.EndReduce();
return(this.Factory(left, right));
}
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));
}
private Pentagons <Variable, Expression> FactoryOfPentagons(
IIntervalAbstraction <Variable, Expression> left, WeakUpperBounds <Variable, Expression> right)
{
Contract.Requires(left != null);
Contract.Requires(right != null);
Contract.Ensures(Contract.Result <Pentagons <Variable, Expression> >() != null);
return(new Pentagons <Variable, Expression>(left, right, this.expManager));
}
/// <summary>
/// Please note that the decoder MUST be already be set for the <code>left</code> and <code>right</code> abstract domains
/// </summary>
public Pentagons(
IIntervalAbstraction <Variable, Expression> left,
WeakUpperBounds <Variable, Expression> right,
ExpressionManagerWithEncoder <Variable, Expression> expManager)
: base(left, right)
{
Contract.Requires(left != null);
Contract.Requires(right != null);
Contract.Requires(expManager != null);
this.expManager = expManager;
}
private void AssignInParallel
(WeakUpperBoundsEqual <Variable, Expression> wubeq, WeakUpperBounds <Variable, Expression> wub,
Dictionary <Variable, FList <Variable> > sourcesToTargets, INumericalAbstractDomain <Variable, Expression> oracleDomain)
{
Contract.Requires(wubeq != null);
Contract.Requires(wub != null);
// adding the domain-generated variables to the map as identity
var oldToNewMap = new Dictionary <Variable, FList <Variable> >(sourcesToTargets);
if (!wubeq.IsTop)
{
foreach (var e in wubeq.SlackVariables)
{
oldToNewMap[e] = FList <Variable> .Cons(e, FList <Variable> .Empty);
}
}
if (!wub.IsTop)
{
foreach (var e in wub.SlackVariables)
{
oldToNewMap[e] = FList <Variable> .Cons(e, FList <Variable> .Empty);
}
}
// when x has several targets including itself, the canonical element shouldn't be itself
foreach (var sourceToTargets in sourcesToTargets)
{
var source = sourceToTargets.Key;
var targets = sourceToTargets.Value;
Contract.Assume(targets != null);
if (targets.Length() > 1 && targets.Head.Equals(source))
{
var tail = targets.Tail;
Contract.Assert(tail != null);
var newTargets = FList <Variable> .Cons(tail.Head, FList <Variable> .Cons(source, tail.Tail));
oldToNewMap[source] = newTargets;
}
}
AssignInParallelWUBSpecific(wub, oldToNewMap);
AssignInParallelWUBEQSpecific(wubeq, sourcesToTargets, oldToNewMap);
}
/// <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 Pentagons < Rational, Expression>, "Wrong type of the domain for the widening...");
Pentagons < Rational, Expression> asIntWSUB = (Pentagons < Rational, 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);
Pentagons < Rational, Expression> result = (Pentagons < Rational, Expression>) this.Factory(widenLeft, widenRight);
return(result);
}
Factory(IntervalEnvironment <Rational, Expression> left, WeakUpperBounds <Expression, Rational> right)
{
return(new ProductIntervalsWeakUpperBounds <Expression>(left, right, this.decoder));
}
private void AssignInParallelWUBSpecific(WeakUpperBounds <Variable, Expression> wub, Dictionary <Variable, FList <Variable> > oldToNewMap)
{
Contract.Requires(wub != null);
Contract.Requires(oldToNewMap != null);
var newMappings = new Dictionary <Variable, List <Variable> >(wub.Count);
foreach (var oldLeft_pair in wub.Elements)
{
if (!oldToNewMap.ContainsKey(oldLeft_pair.Key))
{
continue;
}
var target = oldToNewMap[oldLeft_pair.Key];
Contract.Assume(target != null);
var newLeft = target.Head; // our canonical element
var oldBounds = oldLeft_pair.Value;
if (!oldBounds.IsNormal())
{
continue;
}
foreach (var oldRight in oldBounds.Values)
{
FList <Variable> olds;
if (oldToNewMap.TryGetValue(oldRight, out olds))
{
Contract.Assume(olds != null);
// This case is so so common that we want to specialize it
if (olds.Length() == 1)
{
var newRight = olds.Head; // our canonical element
AddUpperBound(newLeft, newRight, newMappings);
}
else
{
foreach (var newRight in olds.GetEnumerable())
{
AddUpperBound(newLeft, newRight, newMappings);
}
}
}
}
// There are some more elements
for (var list = oldToNewMap[oldLeft_pair.Key].Tail; list != null; list = list.Tail)
{
List <Variable> targets;
if (newMappings.TryGetValue(newLeft, out targets))
{
Contract.Assume(targets != null);
foreach (var con in targets)
{
AddUpperBound(list.Head, con, newMappings);
}
}
}
}
// Update
var newConstraints = new Dictionary <Variable, SetOfConstraints <Variable> >(wub.Count);
foreach (var pair in newMappings)
{
Contract.Assume(pair.Value != null);
newConstraints.Add(pair.Key, new SetOfConstraints <Variable>(pair.Value));
}
wub.SetElements(newConstraints);
}
protected override ReducedCartesianAbstractDomain <IntervalEnvironment <Rational, Expression>, WeakUpperBounds <Expression, Rational> > Factory(IntervalEnvironment <Rational, Expression> left, WeakUpperBounds <Expression, Rational> right)
{
throw new Exception("The method or operation is not implemented.");
}
public ProductIntervalsWeakUpperBounds(IntervalEnvironment <Rational, Expression> left, WeakUpperBounds <Expression, Rational> right)
: base(left, right)
{
}
protected override ReducedCartesianAbstractDomain <IntervalEnvironment <Rational, Expression>, WeakUpperBounds <Expression, Rational> > Factory(IntervalEnvironment <Rational, Expression> left, WeakUpperBounds <Expression, Rational> right)
{
return(new IntervalsWithSymbolicBoundsOfRational32 <Expression>(left, right, this.Decoder));
}
public IntervalsWithSymbolicBoundsOfRational32(IntervalEnvironment <Rational, Expression> left, WeakUpperBounds <Expression, Rational> right, IExpressionDecoder <Expression> decoder)
: base(left, right, decoder)
{
}
Reduce(IIntervalAbstraction <Variable, Expression> left, WeakUpperBounds <Variable, Expression> right)
{
return(this.Factory(left, right));
}
Reduce(IntervalEnvironment <Rational, Expression> left, WeakUpperBounds <Expression, Rational> right)
{
return(this.Factory(left, right));
}
/// <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;
}
/// <summary>
/// Please note that the decoder MUST be already be set for the <code>left</code> and <code>right</code> abstract domains
/// </summary>
protected Pentagons(IntervalEnvironment < Rational, Expression> /*!*/ left, WeakUpperBounds <Expression, Rational> /*!*/ right, IExpressionDecoder <Expression> decoder)
: base(left, right)
{
this.decoder = decoder;
}
Factory(IntervalEnvironment < Rational, Expression> left, WeakUpperBounds <Expression, Rational> right);
