public void IntersectsWithDomain()
{
FltDomain a = new FltDomain(new double[] { 0, 10, 20, 30 });
FltDomain a1 = new FltDomain(new double[] { -10, Epsilon.Prev(0), Epsilon.Next(10), Epsilon.Prev(20), Epsilon.Next(30), 40 });
Assert.IsFalse(a.IntersectsWith(a1));
Assert.IsFalse(a1.IntersectsWith(a));
}
public override void Update()
{
double min0 = Math.Min(Var0.Min, Epsilon.Prev(Var1.Min));
double max0 = Math.Min(Var0.Max, Epsilon.Prev(Var1.Max));
double min1 = Math.Max(Epsilon.Next(Var0.Min), Var1.Min);
double max1 = Math.Max(Epsilon.Next(Var0.Max), Var1.Max);
Var0.Intersect(min0, max0);
Var1.Intersect(min1, max1);
}
public void IntersectsWith4()
{
FltDomain a = new FltDomain(new double[] { 0, 15, 48, 63 });
Assert.IsFalse(a.IntersectsWith(new FltInterval(-10, Epsilon.Prev(0))));
Assert.IsFalse(a.IntersectsWith(new FltInterval(Epsilon.Next(15), Epsilon.Prev(48))));
Assert.IsFalse(a.IntersectsWith(new FltInterval(Epsilon.Next(63), 80)));
Assert.IsTrue(a.IntersectsWith(new FltInterval(15, Epsilon.Prev(48))));
Assert.IsTrue(a.IntersectsWith(new FltInterval(Epsilon.Next(15), 48)));
}
public FltInterval Difference(FltInterval interval)
{
if (interval.IsEmpty())
{
return(this);
}
if (IsEmpty())
{
return(this);
}
// 4 : cannot divide into two intervals...
if ((interval.m_Min > m_Min) && (interval.m_Max < m_Max))
{
return(this);
}
// 1, 6 : completely before or after
if ((interval.m_Max < m_Min) || (interval.m_Min > m_Max))
{
return(this);
}
// 3 : completely remove interval => empty
if (interval.Contains(this))
{
return(m_Empty);
}
// 2 : left overlap
if (IntersectsWith(interval) &&
(interval.m_Max < m_Max))
{
double min = Epsilon.Next(interval.m_Max);
double max = m_Max;
return(new FltInterval(min, max));
}
// 5 : right overlap
if (IntersectsWith(interval) &&
(interval.m_Min > m_Min))
{
double min = m_Min;
double max = Epsilon.Prev(interval.m_Min);
return(new FltInterval(min, max));
}
return(m_Empty);
}
public void DifferenceInterval()
{
FltDomain a = new FltDomain(new double[] { 0, 10, 20, 30 });
FltDomain a1 = a.Difference(a.Interval); Assert.AreEqual(FltDomain.Empty, a1);
FltDomain a2 = a.Difference(new FltInterval(-10, Epsilon.Prev(0))); Assert.AreEqual(a, a2); // 6
FltDomain a3 = a.Difference(new FltInterval(Epsilon.Next(10), Epsilon.Prev(20))); Assert.AreEqual(a, a3); // 4
FltDomain a4 = a.Difference(new FltInterval(Epsilon.Next(30), 40)); Assert.AreEqual(a, a4); // 1
FltDomain a5 = a.Difference(new FltInterval(-10, 0)); AssertEqual(a5, new double[] { Epsilon.Next(0), 10, 20, 30 });
FltDomain b = new FltDomain(new double[] { 0, 30 });
FltDomain b1 = b.Difference(new FltInterval(10, 20)); AssertEqual(b1, new FltInterval[] { new FltInterval(0, Epsilon.Prev(10)), new FltInterval(Epsilon.Next(20), 30) });
FltDomain b2 = b.Difference(new FltInterval(-10, 10)); AssertEqual(b2, new FltInterval[] { new FltInterval(Epsilon.Next(10), 30) });
FltDomain b3 = b.Difference(new FltInterval(20, 40)); AssertEqual(b3, new FltInterval[] { new FltInterval(0, Epsilon.Prev(20)) });
}
public FltInterval Inflate()
{
if (IsEmpty())
{
return(m_Empty);
}
double min = m_Min;
double max = m_Max;
if (!double.IsNegativeInfinity(min))
{
min = Epsilon.Prev(min);
}
if (!double.IsPositiveInfinity(max))
{
max = Epsilon.Next(max);
}
return(new FltInterval(min, max));
}
public override void Update()
{
Var0.Intersect(double.MinValue, Epsilon.Prev(m_Value));
}
public FltDomain Difference(FltDomain domain)
{
if (ReferenceEquals(domain, this))
{
return(m_Empty);
}
if (domain.IsEmpty())
{
return(this);
}
if (domain.IsSimple())
{
return(Difference(domain.m_Interval));
}
//1, 6
if (!IntersectsWith(domain.m_Interval))
{
return(this);
}
// Need to be a bit smart, put our interval in a list, in case it gets chopped up.
List <FltInterval> intervalList;
if (IsSimple())
{
intervalList = new List <FltInterval>(1);
intervalList.Add(m_Interval);
}
else
{
intervalList = m_IntervalList;
}
FltDomain result = new FltDomain();
result.m_IntervalList = new List <FltInterval>(intervalList.Count + domain.m_IntervalList.Count);
int idx = 0;
int domIdx = 0;
while (idx < intervalList.Count ||
domIdx < domain.m_IntervalList.Count)
{
// 6
if (idx == intervalList.Count)
{
domIdx = domain.m_IntervalList.Count;
}
// 1
else if (domIdx == domain.m_IntervalList.Count)
{
idx = intervalList.Count;
}
else
{
FltInterval intv = intervalList[idx];
FltInterval domIntv = domain.m_IntervalList[domIdx];
// 1 : completely before
if (domIntv.Max < intv.Min)
{
++domIdx;
}
// 6 : completely after
else if (domIntv.Min > intv.Max)
{
result.m_IntervalList.Add(intv);
++idx;
}
// 3
else if (domIntv.Contains(intv))
{
++idx;
}
// 4 : divide into two intervals...
else if (I4_Divide(intv, domIntv))
{
while (domIdx < domain.m_IntervalList.Count &&
I4_Divide(intv, domIntv))
{
result.m_IntervalList.Add(new FltInterval(intv.Min, Epsilon.Prev(domIntv.Min)));
intv = new FltInterval(Epsilon.Next(domIntv.Max), intv.Max);
++domIdx;
if (domIdx < domain.m_IntervalList.Count)
{
domIntv = domain.m_IntervalList[domIdx];
}
}
result.m_IntervalList.Add(intv);
}
// 2
else if (I2_IntersectMin(intv, domIntv))
{
result.m_IntervalList.Add(intv.Difference(domIntv));
++domIdx;
}
// 5
else if (I5_IntersectMax(intv, domIntv))
{
result.m_IntervalList.Add(intv.Difference(domIntv));
++idx;
}
}
}
result.UpdateInterval();
return(result);
}
public FltDomain Difference(FltInterval interval)
{
if (interval.IsEmpty())
{
return(this);
}
// 1, 6
if (!IntersectsWith(interval))
{
return(this);
}
// 3 : completely remove interval => empty
if (interval.Contains(m_Interval))
{
return(m_Empty);
}
// Result domain
FltDomain result = new FltDomain();
result.m_Interval = m_Interval.Difference(interval);
if (IsSimple())
{
// 4 : divide into two intervals...
if (I4_Divide(interval, m_Interval))
{
result.m_IntervalList = new List <FltInterval>(2);
result.m_IntervalList.Add(new FltInterval(m_Interval.Min, Epsilon.Prev(interval.Min)));
result.m_IntervalList.Add(new FltInterval(Epsilon.Next(interval.Max), m_Interval.Max));
}
}
else
{
result.m_IntervalList = new List <FltInterval>(m_IntervalList.Count + 1);
int idx = 0;
// 6
for ( ; idx < m_IntervalList.Count && m_IntervalList[idx].Max < interval.Min; ++idx)
{
result.m_IntervalList.Add(m_IntervalList[idx]);
}
// 2
if (idx < m_IntervalList.Count &&
I2_IntersectMin(interval, m_IntervalList[idx]))
{
result.m_IntervalList.Add(m_IntervalList[idx].Difference(interval));
++idx;
}
// 4 : divide into two intervals...
if (idx < m_IntervalList.Count &&
I4_Divide(interval, m_IntervalList[idx]))
{
result.m_IntervalList.Add(new FltInterval(m_Interval.Min, Epsilon.Prev(interval.Min)));
result.m_IntervalList.Add(new FltInterval(Epsilon.Next(interval.Max), m_Interval.Max));
}
// 3
else
{
for ( ; idx < m_IntervalList.Count && interval.Contains(m_IntervalList[idx]); ++idx)
{
}
}
// 5
if (idx < m_IntervalList.Count &&
I5_IntersectMax(interval, m_IntervalList[idx]))
{
result.m_IntervalList.Add(m_IntervalList[idx].Difference(interval));
++idx;
}
// 1
for ( ; idx < m_IntervalList.Count; ++idx)
{
result.m_IntervalList.Add(m_IntervalList[idx]);
}
result.CheckSimple();
}
return(result);
}