private DisInterval(List <Interval> intervals)
: base(Rational.MinusInfinity, Rational.PlusInfinity)
{
Contract.Requires(intervals != null);
bool isBottom;
this.intervals = Normalize(intervals, out isBottom);
if (isBottom)
{
this.joinInterval = Interval.UnreachedInterval;
this.state = State.Bottom;
}
else
{
this.joinInterval = JoinAll(intervals);
if (this.joinInterval.IsBottom)
{
this.state = State.Bottom;
}
else if (this.joinInterval.IsTop)
{
this.state = this.intervals.Count <= 1 ? State.Top : State.Normal;
}
else
{
this.lowerBound = this.joinInterval.LowerBound;
this.upperBound = this.joinInterval.UpperBound;
this.state = State.Normal;
}
}
}
private string ToString(ReadOnlyIntervalList roCollection)
{
if (roCollection == null)
{
return("null");
}
var result = new StringBuilder();
var count = 0;
foreach (var itv in roCollection)
{
if (count != roCollection.Count - 1)
{
result.Append(itv + " ");
}
else
{
result.Append(itv.ToString());
}
count++;
}
return(result.ToString());
}
static private List <Interval> Meet(ReadOnlyIntervalList left, ReadOnlyIntervalList right, out bool isBottom)
{
Contract.Requires(left != null);
Contract.Requires(right != null);
Contract.Ensures(Contract.Result <List <Interval> >() != null);
isBottom = true;
var result = new List <Interval>();
for (var i = 0; i < left.Count; i++)
{
var leftIntv = left[i];
for (var j = 0; j < right.Count; j++)
{
var meet = leftIntv.Meet(right[j]);
if (meet.IsNormal)
{
isBottom = false;
result.Add(meet);
}
}
}
return(result);
}
private DisInterval(State state)
: base(Rational.MinusInfinity, Rational.PlusInfinity)
{
Contract.Requires(state != State.Normal);
this.state = state;
this.joinInterval = this.state == State.Bottom ? Interval.UnreachedInterval : Interval.UnknownInterval;
this.intervals = EmptyReadOnlyList;
}
private DisInterval(DisInterval original)
: base(original.lowerBound, original.upperBound)
{
Contract.Requires(original != null);
this.intervals = original.intervals;
this.joinInterval = original.joinInterval.DuplicateMe();
this.state = original.state;
}
private static bool HaveSameIntervals(ReadOnlyIntervalList left, ReadOnlyIntervalList right)
{
Contract.Requires(left != null);
Contract.Requires(right != null);
if (left.Count != right.Count)
{
return(false);
}
for (var i = 0; i < left.Count; i++)
{
if (!left[i].Equals(right[i]))
{
return(false);
}
}
return(true);
}
private DisInterval(Interval intv)
: base(intv.LowerBound, intv.UpperBound)
{
Contract.Requires(intv != null);
var list = new List <Interval>();
if (intv.IsTop)
{
this.state = State.Top;
}
else if (intv.IsBottom)
{
this.state = State.Bottom;
}
else
{
this.state = State.Normal;
list.Add(intv);
}
this.intervals = AsReadOnly(list);
this.joinInterval = intv;
}
static private List <Interval> Join(ReadOnlyIntervalList left, ReadOnlyIntervalList right)
{
Contract.Requires(left != null);
Contract.Requires(right != null);
Contract.Ensures(Contract.Result <List <Interval> >() != null);
var result = new List <Interval>(left.Count + right.Count);
var i = 0;
var j = 0;
while (i < left.Count && j < right.Count)
{
var leftIntv = left[i];
var rigthIntv = right[j];
if (leftIntv.IsTop || rigthIntv.IsTop)
{
return(new List <Interval>()); // Top
}
// Consume bottoms
if (leftIntv.IsBottom)
{
i++;
continue;
}
if (rigthIntv.IsBottom)
{
j++;
continue;
}
// Check for inclusion
if (leftIntv.LessEqual(rigthIntv))
{
result.Add(rigthIntv);
i++; j++;
continue;
}
if (rigthIntv.LessEqual(leftIntv))
{
result.Add(leftIntv);
i++; j++;
continue;
}
// Check if the intervals overlap or touch
if (rigthIntv.OverlapsWith(leftIntv))
{
result.Add(rigthIntv.Join(leftIntv));
i++; j++;
continue;
}
// Add the leftmost interval
if (leftIntv.OnTheLeftOf(rigthIntv))
{
result.Add(leftIntv);
i++;
continue;
}
if (rigthIntv.OnTheLeftOf(leftIntv)) // F: should always be the case at this point
{
result.Add(rigthIntv);
j++;
continue;
}
}
while (i < left.Count)
{
result.Add(left[i]);
i++;
}
while (j < right.Count)
{
result.Add(right[j]);
j++;
}
return(result);
}
static private List <Interval> Widening(ReadOnlyIntervalList next, ReadOnlyIntervalList prev)
{
Contract.Requires(next != null);
Contract.Requires(prev != null);
Contract.Ensures(Contract.Result <List <Interval> >() != null);
// One of the two is top
if (next.Count == 0 || prev.Count == 0)
{
return(new List <Interval>());
}
// Boths are one interval
if (next.Count == 1 && prev.Count == 1)
{
var intv = next[0].Widening(prev[0]);
return(new List <Interval>()
{
intv
});
}
// One of the two contains just one interval
if (next.Count == 1 && prev.Count > 1)
{
if (next[0].LessEqual(prev))
{
return(new List <Interval>(prev));
}
var intv = next[0].Widening(prev[0].Join(prev[prev.Count - 1]));
return(new List <Interval>()
{
intv
});
}
if (next.Count > 1 && prev.Count == 1)
{
var intv = (next[0].Join(next[next.Count - 1]).Widening(prev[0]));
return(new List <Interval>()
{
intv
});
}
Contract.Assert(next.Count >= 2);
Contract.Assert(prev.Count >= 2);
// We widen the extremes, and keep the internal intervals which are stable among two iterations
var leftMostInterval = next[0].Widening(prev[0]);
var rightMostInterval = next[next.Count - 1].Widening(prev[prev.Count - 1]);
var result = new List <Interval>();
result.Add(leftMostInterval);
for (var j = 1; j < prev.Count - 1; j++)
{
for (var i = 1; i < next.Count - 1; i++)
{
if (next[i].LessEqual(prev[j]))
{
result.Add(prev[j]);
break;
}
}
}
result.Add(rightMostInterval);
return(result);
}
