private void AddToTree(IntervalTree<DateTimeRange> tree, List<DateTimeRange> list)
{
foreach (DateTimeRange s in list)
{
tree.Insert(s, s);
}
}
static void Test_IntervalTree()
{
var tree = new IntervalTree <Rational, double>(r => r.ToCents());
tree.Add(Rational.One);
tree.Add(new Rational(1, 2));
}
private bool TryProceedOrReportNullableImpactingSpans(TextSpan span, ImmutableArray <TextSpan>?nullableImpactingSpans)
{
if (Completed)
{
return(false);
}
lock (this)
{
if (Completed)
{
return(false);
}
if (IntervalTree.HasIntervalThatOverlapsWith(span.Start, span.End))
{
return(false);
}
if (nullableImpactingSpans is { } spans)
{
foreach (var nullableImpactingSpan in spans)
{
PossibleNullableImpactIntervalTree.AddIntervalInPlace(nullableImpactingSpan);
}
}
return(true);
}
}
public void Query_CreateTreeAndExecuteQuery_ExpectCorrectElementsToBeReturned()
{
var tree = new IntervalTree <int, string>()
{
{ 0, 10, "1" },
{ 20, 30, "2" },
{ 15, 17, "3" },
{ 25, 35, "4" },
};
var results1 = tree.Query(5).ToArray();
Assert.That(results1.Count, Is.EqualTo(1));
Assert.That(results1[0], Is.EqualTo("1"));
var results2 = tree.Query(10).ToArray();
Assert.That(results2.Count, Is.EqualTo(1));
Assert.That(results2[0], Is.EqualTo("1"));
var results3 = tree.Query(29).ToArray();
Assert.That(results3.Count, Is.EqualTo(2));
Assert.That(results3[0], Is.EqualTo("2"));
Assert.That(results3[1], Is.EqualTo("4"));
var results4 = tree.Query(5, 15).ToArray();
Assert.That(results4.Count, Is.EqualTo(2));
Assert.That(results4[0], Is.EqualTo("3"));
Assert.That(results4[1], Is.EqualTo("1"));
}
public void Adding_intervals()
{
var tree = new IntervalTree();
tree.Add(_intervalSetOne[0]);
Assert.Equal(15, tree.GetRange().Begin);
Assert.Equal(20, tree.GetRange().End);
tree.Add(_intervalSetOne[1]);
Assert.Equal(10, tree.GetRange().Begin);
Assert.Equal(30, tree.GetRange().End);
tree.Add(_intervalSetOne[2]);
Assert.Equal(5, tree.GetRange().Begin);
Assert.Equal(30, tree.GetRange().End);
tree.Add(_intervalSetOne[3]);
Assert.Equal(5, tree.GetRange().Begin);
Assert.Equal(30, tree.GetRange().End);
tree.Add(_intervalSetOne[4]);
Assert.Equal(5, tree.GetRange().Begin);
Assert.Equal(30, tree.GetRange().End);
tree.Add(_intervalSetOne[5]);
Assert.Equal(5, tree.GetRange().Begin);
Assert.Equal(40, tree.GetRange().End);
}
public DiagnosticsTagSource(AbstractAggregatedDiagnosticsTagSource <TTag> owner)
{
_owner = owner;
_workQueue = new AsynchronousSerialWorkQueue(_owner.Listener);
_lastDiagnostics = IntervalTree <Data> .Empty;
}
/// <summary>
/// Render the new highlights taking into consideration the old highlights
/// (this means that only the differences are actually rendered)
/// </summary>
private void RenderHighlightDiffs(IntervalTree <AtomicHighlight> atomicHighlights)
{
//System.Console.WriteLine("Rendering highlight diffs");
IList <AtomicHighlight> hl = atomicHighlights.GetValues();
foreach (AtomicHighlight h in hl)
{
//System.Console.WriteLine(" Checking {0}", h);
IList <AtomicHighlight> overlaps = prevAtomicHighlights.SearchOverlap(h);
foreach (AtomicHighlight overlap in overlaps)
{
AtomicHighlight hTmp = new AtomicHighlight(h);
hTmp.Intersect(overlap);
AtomicHighlight oTmp = new AtomicHighlight(overlap);
oTmp.Intersect(h);
//System.Console.WriteLine(" Overlaps with {0}", oTmp);
bool diffType = oTmp.Type != hTmp.Type;
Drawer.HighlightType left, right, oleft, oright;
hTmp.GetAbyssHighlights(out left, out right);
oTmp.GetAbyssHighlights(out oleft, out oright);
bool diffAbyss = (left != oleft) || (right != oright);
if (diffType || diffAbyss)
{
//System.Console.Write(diffType?" DiffType> ":" DiffFlags> ");
//System.Console.WriteLine(hTmp);
RenderHighlight(hTmp);
}
}
}
}
public void GlobalTest()
{
Interval interval = new Interval(0, 5);
Interval interval2 = new Interval(4, 6);
Interval interval3 = new Interval(8, 10);
List <Interval> list = new List <Interval>();
list.Add(interval);
list.Add(interval2);
list.Add(interval3);
IntervalTree tree = new IntervalTree(list);
List <Interval> ans1 = tree.Q(0, tree.root);
List <Interval> ans2 = tree.Q(1, tree.root);
List <Interval> ans3 = tree.Q(2, tree.root);
List <Interval> ans4 = tree.Q(3, tree.root);
List <Interval> ans5 = tree.Q(4, tree.root);
List <Interval> ans6 = tree.Q(5, tree.root);
List <Interval> ans7 = tree.Q(6, tree.root);
List <Interval> ans8 = tree.Q(8, tree.root);
List <Interval> ans9 = tree.Q(9, tree.root);
List <Interval> ans10 = tree.Q(10, tree.root);
Assert.AreEqual(0, ans1[0].start);
Assert.AreEqual(0, ans2[0].start);
Assert.AreEqual(0, ans3[0].start);
Assert.AreEqual(0, ans4[0].start);
Assert.AreEqual(2, ans5.Count);
Assert.AreEqual(2, ans6.Count);
Assert.AreEqual(4, ans7[0].start);
Assert.AreEqual(8, ans8[0].start);
Assert.AreEqual(8, ans9[0].start);
Assert.AreEqual(10, ans10[0].end);
}
public void TestSortedEnumerable1()
{
var tree = IntervalTree <int> .Create(new Int32Introspector(), new[] { 0, 0, 0 });
Assert.Equal(CreateIntTree(0, 0, 0), new[] { 0, 0, 0 });
Assert.Equal(CreateIntTree(0, 0, 1), new[] { 0, 0, 1 });
Assert.Equal(CreateIntTree(0, 0, 2), new[] { 0, 0, 2 });
Assert.Equal(CreateIntTree(0, 1, 0), new[] { 0, 0, 1 });
Assert.Equal(CreateIntTree(0, 1, 1), new[] { 0, 1, 1 });
Assert.Equal(CreateIntTree(0, 1, 2), new[] { 0, 1, 2 });
Assert.Equal(CreateIntTree(0, 2, 0), new[] { 0, 0, 2 });
Assert.Equal(CreateIntTree(0, 2, 1), new[] { 0, 1, 2 });
Assert.Equal(CreateIntTree(0, 2, 2), new[] { 0, 2, 2 });
Assert.Equal(CreateIntTree(1, 0, 0), new[] { 0, 0, 1 });
Assert.Equal(CreateIntTree(1, 0, 1), new[] { 0, 1, 1 });
Assert.Equal(CreateIntTree(1, 0, 2), new[] { 0, 1, 2 });
Assert.Equal(CreateIntTree(1, 1, 0), new[] { 0, 1, 1 });
Assert.Equal(CreateIntTree(1, 1, 1), new[] { 1, 1, 1 });
Assert.Equal(CreateIntTree(1, 1, 2), new[] { 1, 1, 2 });
Assert.Equal(CreateIntTree(1, 2, 0), new[] { 0, 1, 2 });
Assert.Equal(CreateIntTree(1, 2, 1), new[] { 1, 1, 2 });
Assert.Equal(CreateIntTree(1, 2, 2), new[] { 1, 2, 2 });
Assert.Equal(CreateIntTree(2, 0, 0), new[] { 0, 0, 2 });
Assert.Equal(CreateIntTree(2, 0, 1), new[] { 0, 1, 2 });
Assert.Equal(CreateIntTree(2, 0, 2), new[] { 0, 2, 2 });
Assert.Equal(CreateIntTree(2, 1, 0), new[] { 0, 1, 2 });
Assert.Equal(CreateIntTree(2, 1, 1), new[] { 1, 1, 2 });
Assert.Equal(CreateIntTree(2, 1, 2), new[] { 1, 2, 2 });
Assert.Equal(CreateIntTree(2, 2, 0), new[] { 0, 2, 2 });
Assert.Equal(CreateIntTree(2, 2, 1), new[] { 1, 2, 2 });
Assert.Equal(CreateIntTree(2, 2, 2), new[] { 2, 2, 2 });
}
public void Insert_Multiple()
{
// Arrange
IntervalTree tree = new IntervalTree();
tree.Insert(20, 36);
tree.Insert(3, 41);
tree.Insert(29, 99);
tree.Insert(0, 1);
tree.Insert(10, 15);
tree.Insert(25, 30);
tree.Insert(60, 72);
var expected = new List <Interval>()
{
new Interval(0, 1),
new Interval(3, 41),
new Interval(10, 15),
new Interval(20, 36),
new Interval(25, 30),
new Interval(29, 99),
new Interval(60, 72),
};
// Act
var actual = new List <Interval>();
tree.EachInOrder(actual.Add);
// Assert
CollectionAssert.AreEqual(expected, actual);
}
public void TestPertialOverlapIntervals_AssertIntersectionsContent()
{
IntervalTree <int, DateTime> tree = new IntervalTree <int, DateTime>();
tree.AddInterval(ZERO, ZERO.AddHours(10), 100);
tree.AddInterval(ZERO.AddHours(5), ZERO.AddHours(15), 200);
tree.AddInterval(ZERO.AddHours(10), ZERO.AddHours(20), 300);
var result = tree.GetIntersections().ToList();
for (int i = 0; i < 2; i++)
{
int[] expected;
if (i == 0)
{
expected = new int[] { 100, 200 };
}
else
{
expected = new int[] { 200, 300 };
}
CollectionAssert.AreEqual(expected, result[i].Select(x => x.Data).ToArray());
}
}
public void SearchAll_Hit_Multiple()
{
// Arrange
IntervalTree tree = new IntervalTree();
tree.Insert(20, 36);
tree.Insert(3, 41);
tree.Insert(29, 99);
tree.Insert(0, 1);
tree.Insert(10, 15);
tree.Insert(25, 30);
tree.Insert(60, 72);
var expected = new List <Interval>()
{
new Interval(3, 41),
new Interval(10, 15),
new Interval(20, 36),
new Interval(25, 30),
new Interval(29, 99),
};
// Act
var actual = new List <Interval>(tree.SearchAll(10, 50));
// Assert
CollectionAssert.AreEqual(expected, actual);
}
public void IntervalTreeTestCase2()
{
var intervals = new List <IntervalTree <DateTime> >()
{
new IntervalTree <DateTime>(new DateTime(2019, 01, 01), new DateTime(2019, 01, 03)),
new IntervalTree <DateTime>(new DateTime(2019, 01, 04), new DateTime(2019, 01, 06)),
new IntervalTree <DateTime>(new DateTime(2019, 01, 07), new DateTime(2019, 01, 07)),
new IntervalTree <DateTime>(new DateTime(2019, 01, 08), new DateTime(2019, 01, 08)),
new IntervalTree <DateTime>(new DateTime(2019, 01, 09), new DateTime(2019, 01, 11)),
new IntervalTree <DateTime>(new DateTime(2019, 01, 12), new DateTime(2019, 01, 13))
};
var expectedOutput = new IntervalTree <DateTime>(new DateTime(2019, 01, 01), new DateTime(2019, 01, 03));
IntervalTree <DateTime> parentNode = null;
for (int iterator = 0; iterator < intervals.Count; iterator++)
{
parentNode = IntervalTree <DateTime> .Insert(parentNode, intervals[iterator]);
}
var searchOperand = new IntervalTree <DateTime>(new DateTime(2019, 01, 02), new DateTime(2019, 01, 02));
var actualOutput = IntervalTree <DateTime> .Search(parentNode, searchOperand);
Assert.IsTrue(expectedOutput == actualOutput, "Expected and actual output differs");
}
public void ITSearchTest()
{
IntervalTree <Range> t = new IntervalTree <Range>();
for (int i = 0; i < 1000; i += 4)
{
t.Insert(new Range(i, i + 2));
}
for (int i = 0; i < 1000; i += 8)
{
IList <Range> result = t.SearchOverlap(new Range(i, i + 7));
Assert.AreEqual(2, result.Count, "#1." + i.ToString());
}
for (int i = 2; i < 1000; i += 4)
{
IList <Range> result = t.SearchOverlap(new Range(i + 1, i + 1));
Assert.AreEqual(0, result.Count, "#2." + i.ToString());
}
{
IList <Range> result = t.SearchOverlap(new Range(0, 1050));
Assert.AreEqual(250, result.Count, "#3");
}
}
/// <summary>
/// Given a sequence, applies our patterns over the sequence and returns
/// all non overlapping matches.
/// </summary>
/// <remarks>
/// Given a sequence, applies our patterns over the sequence and returns
/// all non overlapping matches. When multiple patterns overlaps,
/// matched patterns are selected by order specified by the comparator
/// </remarks>
/// <param name="elements">input sequence to match against</param>
/// <param name="cmp">comparator indicating order that overlapped sequences should be selected.</param>
/// <returns>list of match results that are non-overlapping</returns>
public virtual IList <ISequenceMatchResult <T> > FindNonOverlapping <_T0, _T1>(IList <_T0> elements, IComparator <_T1> cmp)
where _T0 : T
{
ICollection <SequencePattern <T> > triggered = GetTriggeredPatterns(elements);
IList <ISequenceMatchResult <T> > all = new List <ISequenceMatchResult <T> >();
int i = 0;
foreach (SequencePattern <T> p in triggered)
{
if (Thread.Interrupted())
{
// Allow interrupting
throw new RuntimeInterruptedException();
}
SequenceMatcher <T> m = p.GetMatcher(elements);
m.SetMatchWithResult(matchWithResult);
m.SetOrder(i);
while (m.Find())
{
all.Add(m.ToBasicSequenceMatchResult());
}
i++;
}
IList <ISequenceMatchResult <T> > res = IntervalTree.GetNonOverlapping(all, SequenceMatchResultConstants.ToInterval, cmp);
res.Sort(SequenceMatchResultConstants.OffsetComparator);
return(res);
}
public TimeTable(DateTime timeStamp, Class activeClass, IntervalTree <DateTime, Lesson> lessons, Dictionary <long, LessonInfo> infos)
{
TimeStamp = timeStamp;
ActiveClass = activeClass;
Lessons = lessons;
Infos = infos;
}
public void SimplestFailingTest()
{
var now = DateTime.Now;
//Arrange
var intervals = new List <Interval <DateTime> >();
//intervals.Add(ToDateTimeInterval(now, -300, -200));
//intervals.Add(ToDateTimeInterval(now, -3, -2));
intervals.Add(ToDateTimeInterval(now, 1, 2));
//intervals.Add(ToDateTimeInterval(now, 3, 6));
//intervals.Add(ToDateTimeInterval(now, 2, 4));
//intervals.Add(ToDateTimeInterval(now, 5, 7));
intervals.Add(ToDateTimeInterval(now, 1, 3));
//intervals.Add(ToDateTimeInterval(now, 4, 6));
//intervals.Add(ToDateTimeInterval(now, 8, 9));
//intervals.Add(ToDateTimeInterval(now, 15, 20));
//intervals.Add(ToDateTimeInterval(now, 40, 50));
//intervals.Add(ToDateTimeInterval(now, 49, 60));
var intervalTree = new IntervalTree <DateTime>();
intervals.ForEach(x => intervalTree.Add(x));
//Act
var overlaps = intervalTree.Query(ToDateTimeInterval(now, 0, 1));
//Assert
Assert.AreEqual(2, overlaps.Count());
}
public IntervalTree(IReadOnlyCollection <T> elements, Func <T, TKey> intervalStartSelector, Func <T, TKey> intervalEndSelector, Func <TKey, TKey, TKey> centerFromMinMaxSelector, IComparer <TKey>?comparer = null)
{
Comparer = (comparer ??= Comparer <TKey> .Default);
if (elements.Any(e => Comparer.Compare(intervalStartSelector(e), Center) > 0 && Comparer.Compare(intervalEndSelector(e), Center) < 0))
{
throw new InvalidOperationException();
}
Min = elements.Min(intervalStartSelector) ?? throw new InvalidOperationException();
Max = elements.Max(intervalEndSelector) ?? throw new InvalidOperationException();
Center = centerFromMinMaxSelector(Min, Max); //(Min + Max) / 2;
var leftElements = elements.Where(e => Comparer.Compare(intervalEndSelector(e), Center) < 0).ToArray();
if (leftElements.Length > 0)
{
LeftTree = new IntervalTree <T, TKey>(leftElements, intervalStartSelector, intervalEndSelector, centerFromMinMaxSelector, comparer);
}
var rightElements = elements.Where(e => Comparer.Compare(intervalStartSelector(e), Center) > 0).ToArray();
if (rightElements.Length > 0)
{
RightTree = new IntervalTree <T, TKey>(rightElements, intervalStartSelector, intervalEndSelector, centerFromMinMaxSelector, comparer);
}
var centerItems = elements.Where(e => Comparer.Compare(intervalEndSelector(e), Center) > 0 && Comparer.Compare(intervalStartSelector(e), Center) < 0).ToArray();
CenterItemsByBeginning = centerItems.OrderBy(intervalStartSelector).ToArray();
CenterItemsByEnd = centerItems.OrderBy(intervalEndSelector).ToArray();
IntervalStartSelector = intervalStartSelector;
IntervalEndSelector = intervalEndSelector;
}
public void SimplestFailingTest()
{
// Container: [-----] [------] [----------]
// [---] [----]
// Query: [---]
//Arrange
var intervals = new List <Interval <int> >();
intervals.Add(new Interval <int>(4, 10));
intervals.Add(new Interval <int>(21, 35));
intervals.Add(new Interval <int>(25, 31));
intervals.Add(new Interval <int>(42, 56));
intervals.Add(new Interval <int>(46, 52));
var intervalContainer = new IntervalTree <int>();
intervals.ForEach(intervalContainer.Add);
//Act
var intersections = intervalContainer.Query(new Interval <int>(49, 56));
//Assert
Assert.AreEqual(2, intersections.Count());
}
static void IntervalTreeTest()
{
IntervalTree <int> it = new IntervalTree <int>();
it.addInterval(0L, 10L, 1);
it.addInterval(20L, 30L, 2);
it.addInterval(15L, 17L, 3);
it.addInterval(25L, 35L, 4);
ArrayList <int> result1 = it.get(5L);
ArrayList <int> result2 = it.get(10L);
ArrayList <int> result3 = it.get(29L);
ArrayList <int> result4 = it.get(5L, 15L);
Console.WriteLine("Intervals that contain 5L:");
foreach (int r in result1)
{
Console.WriteLine(r);
}
Console.WriteLine("Intervals that contain 29L:");
foreach (int r in result3)
{
Console.WriteLine(r);
}
Console.WriteLine("Intervals that intersect (5L,15L):");
foreach (int r in result4)
{
Console.WriteLine(r);
}
}
public void GetOverlapping_PerformanceTest()
{
const int itemCount = 100000;
const int requestCount = 10000;
var random = new Random(42);
var items = Enumerable.Range(0, itemCount).Select(i =>
{
var start = random.Next(1000);
var end = start + random.Next(1, 50);
return(new TestInterval(start, end));
});
var collection = new IntervalTree <int>(items, IntervalTreeMedianComputations.IntMedian);
var stopwatch = Stopwatch.StartNew();
var selectedCount = 0;
for (var i = 0; i < requestCount; i++)
{
var start = random.Next(1000);
var end = start + random.Next(1, 50);
var result = collection.GetOverlapping(start, end).ToList();
selectedCount += result.Count;
}
stopwatch.Stop();
Assert.Inconclusive($"Executed {nameof(collection.GetOverlapping)}() {requestCount} times to select {selectedCount} results from {itemCount} items in {stopwatch.Elapsed}");
}
private IIntervalTree <Position, ILocalizableSymbol> ApplyLookupTreeChange(
IIntervalTree <Position, ILocalizableSymbol> previousLookupTree,
Range changeRange,
Position afterChangeEndOffset
)
{
var migratedLookupTree = new IntervalTree <Position, ILocalizableSymbol>();
foreach (var entry in previousLookupTree)
{
cancellationToken.ThrowIfCancellationRequested();
if (IsPositionBeforeChange(changeRange, entry.To))
{
migratedLookupTree.Add(entry.From, entry.To, entry.Value);
}
if (IsPositionAfterChange(changeRange, entry.From))
{
var beforeChangeEndOffset = changeRange.End;
var from = GetPositionWithOffset(entry.From, beforeChangeEndOffset, afterChangeEndOffset);
var to = GetPositionWithOffset(entry.To, beforeChangeEndOffset, afterChangeEndOffset);
migratedLookupTree.Add(from, to, entry.Value);
}
}
return(migratedLookupTree);
}
public void MixedAddDelete()
{
var tree = new IntervalTree <object>();
int i = 0;
tree.Add(1, 2, ++i);
Debug.Assert(tree.Contains(1));
tree.Remove(1, 2);
Debug.Assert(!tree.Contains(1));
Debug.Assert(!tree.Contains(2));
tree.Add(1, 2, ++i);
Debug.Assert(tree.Contains(1));
tree.Remove(1, 2);
Debug.Assert(!tree.Contains(1));
tree.Add(1, 2, ++i);
Debug.Assert(tree.Contains(1));
tree.Add(3, 4, ++i);
Debug.Assert(tree.Contains(3));
tree.Remove(1, 2);
Debug.Assert(!tree.Contains(1));
Debug.Assert(!tree.Contains(2));
tree.Remove(3, 4);
Debug.Assert(!tree.Contains(3));
}
public static void Main()
{
var intervalTree = new IntervalTree<int>();
intervalTree.Add(new Interval<int>(1, 10));
intervalTree.Add(new Interval<int>(11, 20));
intervalTree.Add(new Interval<int>(-10, 5));
intervalTree.Add(new Interval<int>(4, 30));
intervalTree.Add(new Interval<int>(100, 130));
intervalTree.Add(new Interval<int>(-20, 5));
intervalTree.Add(new Interval<int>(2, 7));
Console.Write("Enter interval START (integer) to search for in the tree: ");
int start = int.Parse(Console.ReadLine());
Console.Write("Enter interval END (integer) to search for in the tree: ");
int end = int.Parse(Console.ReadLine());
var result = intervalTree.Search(new Interval<int>(start, end));
Console.WriteLine(new string('-', 40));
Console.WriteLine("{0} overlapping intervals found:", result.Count);
Console.WriteLine(new string('-', 40));
foreach (Interval<int> interval in result)
{
Console.WriteLine("{0} - {1}", interval.Start, interval.End);
}
}
public void IntervalTreeTestCase1()
{
var intervals = new List <IntervalTree <int> >
{
new IntervalTree <int>(15, 20),
new IntervalTree <int>(10, 30),
new IntervalTree <int>(17, 19),
new IntervalTree <int>(5, 20),
new IntervalTree <int>(12, 15),
new IntervalTree <int>(30, 40)
};
var expectedOutput = new IntervalTree <int>(5, 20);
IntervalTree <int> parentNode = null;
for (int iterator = 0; iterator < intervals.Count; iterator++)
{
parentNode = IntervalTree <int> .Insert(parentNode, intervals[iterator]);
}
var searchOperand = new IntervalTree <int>(6, 7);
var actualOutput = IntervalTree <int> .Search(parentNode, searchOperand);
Assert.IsTrue(expectedOutput == actualOutput, "Expected and actual output differs");
}
/// <summary>
/// Returns a set of appointments from a GoogleApps Feed
/// </summary>
/// <param name="user">The exchange user to get apointments for</param>
/// <param name="srcTimeZone">The time zone to use</param>
/// <param name="googleAppsFeed">Source feed to create array from</param>
/// <returns></returns>
private IntervalTree <Appointment> CreateAppointments(
ExchangeUser user,
OlsonTimeZone srcTimeZone,
EventFeed googleAppsFeed)
{
IntervalTree <Appointment> result = new IntervalTree <Appointment>();
foreach (EventEntry eventEntry in googleAppsFeed.Entries)
{
try
{
CreateAppointment(result, user, srcTimeZone, eventEntry);
}
catch (GCalExchangeException ex)
{
if (ex.ErrorCode == GCalExchangeErrorCode.OlsonTZError)
{
log.Error("Error creating appointment (TimeZone issue)", ex);
}
else
{
throw;
}
}
}
return(result);
}
public void SimplestFailingTest()
{
var now = DateTime.Now;
//Arrange
var intervals = new List<Interval<DateTime>>();
//intervals.Add(ToDateTimeInterval(now, -300, -200));
//intervals.Add(ToDateTimeInterval(now, -3, -2));
intervals.Add(ToDateTimeInterval(now, 1, 2));
//intervals.Add(ToDateTimeInterval(now, 3, 6));
//intervals.Add(ToDateTimeInterval(now, 2, 4));
//intervals.Add(ToDateTimeInterval(now, 5, 7));
intervals.Add(ToDateTimeInterval(now, 1, 3));
//intervals.Add(ToDateTimeInterval(now, 4, 6));
//intervals.Add(ToDateTimeInterval(now, 8, 9));
//intervals.Add(ToDateTimeInterval(now, 15, 20));
//intervals.Add(ToDateTimeInterval(now, 40, 50));
//intervals.Add(ToDateTimeInterval(now, 49, 60));
var intervalTree = new IntervalTree<DateTime>();
intervals.ForEach(x => intervalTree.Add(x));
//Act
var overlaps = intervalTree.Query(ToDateTimeInterval(now, 0, 1));
//Assert
Assert.AreEqual(2, overlaps.Count());
}
public void ITDeleteTest()
{
IntervalTree <Range> t = new IntervalTree <Range>();
for (int i = 0; i < 1000; i += 4)
{
t.Insert(new Range(i, i + 2));
}
for (int i = 0; i < 1000; i += 8)
{
IList <Range> result = t.SearchOverlap(new Range(i, i + 7));
Assert.AreEqual(2, result.Count, "#1." + i.ToString());
t.Delete(new Range(i, i + 2));
result = t.SearchOverlap(new Range(i, i + 7));
Assert.AreEqual(1, result.Count, "#2." + i.ToString());
t.Delete(new Range(i + 2, i + 4));
result = t.SearchOverlap(new Range(i, i + 7));
Assert.AreEqual(1, result.Count, "#3." + i.ToString());
t.Delete(new Range(i + 4, i + 6));
result = t.SearchOverlap(new Range(i, i + 7));
Assert.AreEqual(0, result.Count, "#4." + i.ToString());
t.Delete(new Range(i + 6, i + 8));
result = t.SearchOverlap(new Range(i, i + 7));
Assert.AreEqual(0, result.Count, "#5." + i.ToString());
}
}
public void GetBetween_NoItems_ReturnsEmptyCollection()
{
var collection = new IntervalTree <int>(Array.Empty <IInterval <int> >(), IntervalTreeMedianComputations.IntMedian);
var result = collection.GetBetween(0, 8).ToList();
Assert.AreEqual(0, result.Count);
}
public void TestEmptyIntervalTree_AssertIntersectionsCount()
{
IntervalTree <int, DateTime> tree = new IntervalTree <int, DateTime>();
var result = tree.GetIntersections().ToList();
Assert.AreEqual(0, result.Count, "There should not be any intersections because the tree it empty");
}
public void AddingAnItem_FromIsLargerThanTo_ShouldThrowException()
{
var comparer = Comparer <int> .Create((x, y) => x - y);
var tree = new IntervalTree <int, string>(comparer);
Assert.That(() => tree.Add(2, 0, "FOO"), Throws.InstanceOf <ArgumentOutOfRangeException>());
}
public AreaGroup()
{
areas = new System.Collections.Generic.List <Area>();
highlights = new IntervalTree <Highlight>();
selection = new Highlight(Drawer.HighlightType.Selection);
prevAtomicHighlights = new IntervalTree <AtomicHighlight>();
bufferCache = new byte[0];
}
public void GetIntervalByExactStartTime()
{
IntervalTree<int, DateTime> tree = new IntervalTree<int, DateTime>();
tree.AddInterval(ZERO, ZERO.AddHours(1), 100);
var result = tree.Get(ZERO, StubMode.ContainsStart);
Assert.AreEqual(1, result.Count);
}
/// <summary>
/// Renders the area group based on the specified atomic highlights.
/// </summary>
private void RenderAtomicHighlights(IntervalTree <AtomicHighlight> atomicHighlights)
{
IList <AtomicHighlight> hl = atomicHighlights.GetValues();
foreach (AtomicHighlight h in hl)
{
RenderHighlight(h);
}
}
public void OverlapOnExactEndAndStart_AssertCount()
{
IntervalTree<int, DateTime> tree = new IntervalTree<int, DateTime>();
tree.AddInterval(ZERO, ZERO.AddHours(10), 100);
tree.AddInterval(ZERO.AddHours(10), ZERO.AddHours(15), 200);
tree.AddInterval(ZERO.AddHours(10), ZERO.AddHours(20), 200);
var result = tree.Get(ZERO.AddHours(10), StubMode.ContainsStart).ToList();
Assert.AreEqual(2, result.Count, "Expact only the two intervals start at 10");
}
private static IntervalTree<int> CreateTree(IEnumerable<Interval<int>> entries)
{
var tree = new IntervalTree<int>();
foreach(var interval in entries) {
tree.Add(interval);
}
return tree;
}
public static void CreateTree(List<SURFRecord1> imageList)
{
ImageList = imageList;
_imageTree = new IntervalTree<int, int>();
for(int i = 0; i < imageList.Count; i++)
{
var rec = imageList[i];
_imageTree.AddInterval(rec.IndexStart, rec.IndexEnd, i);
}
}
private static void DisplayTree(IntervalTree<int>.AANode node, string intend)
{
Console.WriteLine(intend + node.interval.ToString() + " (level:" + node.level + ")");
if (node.leftChild.level != 0)
{
DisplayTree(node.leftChild, intend + " ");
}
if (node.rightChild.level != 0)
{
DisplayTree(node.rightChild, intend + " ");
}
}
public void SpeedTestBuild100kIntervals()
{
IntervalTree<int, DateTime> tree = new IntervalTree<int, DateTime>();
for (int i = 0; i < 100 * 1000; i++)
{
tree.AddInterval(ZERO.AddHours(i), ZERO.AddHours(i + 200), i);
}
Stopwatch stopWatch = Stopwatch.StartNew();
tree.Build();
stopWatch.Stop();
Assert.IsTrue(stopWatch.ElapsedMilliseconds < 3 * 1000, "Build took more then 4s - it took " + stopWatch.Elapsed);
}
public static void Main()
{
var testIntervals = new IntervalTree<int>(new Interval<int>(1, 10));
testIntervals.Add(new Interval<int>(5, 7));
testIntervals.Add(new Interval<int>(11, 20));
testIntervals.Add(new Interval<int>(2, 8));
testIntervals.Add(new Interval<int>(-2, 5));
testIntervals.Add(new Interval<int>(7, 123));
testIntervals.Add(new Interval<int>(6, 12));
testIntervals.Add(new Interval<int>(23, 45));
var intersects = testIntervals.SearchIntersectingIntervals(new Interval<int>(6, 7));
foreach (var item in intersects)
{
Console.WriteLine("{0} - {1}", item.Start, item.End);
}
}
static void Main()
{
var intIntTree = new IntervalTree<int>();
intIntTree.Insert(new Interval<int>(-5, 20));
intIntTree.Insert(new Interval<int>(20, 30));
intIntTree.Insert(new Interval<int>(14, 40));
intIntTree.Insert(new Interval<int>(11, 20));
intIntTree.Insert(new Interval<int>(8, 15));
intIntTree.Insert(new Interval<int>(-3, 21));
intIntTree.Insert(new Interval<int>(111, 115));
intIntTree.Insert(new Interval<int>(-55, 5));
DisplayTree(intIntTree.Root, string.Empty);
var intervalInQuestion = new Interval<int>(12, 15);
var intervals = intIntTree.FindOverlappingIntervals(intervalInQuestion);
PrintOverlappedIntervals(intervals, intervalInQuestion);
}
public void SimplestFailingTest()
{
// Container: [-----] [------] [----------]
// [---] [----]
// Query: [---]
//Arrange
var intervals = new List<Interval<int>>();
intervals.Add(new Interval<int>(4, 10));
intervals.Add(new Interval<int>(21, 35));
intervals.Add(new Interval<int>(25, 31));
intervals.Add(new Interval<int>(42, 56));
intervals.Add(new Interval<int>(46, 52));
var intervalContainer = new IntervalTree<int>();
intervals.ForEach(intervalContainer.Add);
//Act
var intersections = intervalContainer.Query(new Interval<int>(49, 56));
//Assert
Assert.AreEqual(2, intersections.Count());
}
public void SpeedTestIntersectingIntervals_GetPoint()
{
IntervalTree<int, DateTime> tree = new IntervalTree<int, DateTime>();
for (int i = 0; i < 100 * 1000; i++)
{
tree.AddInterval(ZERO.AddHours(i), ZERO.AddHours(i + 200), i);
}
tree.Build();
Stopwatch stopWatch = Stopwatch.StartNew();
var result = tree.Get(ZERO.AddHours(50 * 1000));
stopWatch.Stop();
Assert.IsTrue(stopWatch.ElapsedMilliseconds < 100);
}
public void BuildEmptyIntervalTree()
{
IntervalTree<int, DateTime> emptyTree = new IntervalTree<int, DateTime>();
emptyTree.Build();
}
public void TestSeparateIntervals()
{
IntervalTree<int, DateTime> tree = new IntervalTree<int, DateTime>();
tree.AddInterval(ZERO, ZERO.AddHours(10), 100);
tree.AddInterval(ZERO.AddHours(20), ZERO.AddHours(30), 200);
var result = tree.Get(ZERO.AddHours(5));
Assert.AreEqual(1, result.Count);
Assert.AreEqual(100, result[0]);
}
public void TestStartEndOverlapIntervals_AssertIntersectionsContent()
{
IntervalTree<int, DateTime> tree = new IntervalTree<int, DateTime>();
tree.AddInterval(ZERO, ZERO.AddHours(1), 100);
tree.AddInterval(ZERO.AddHours(1), ZERO.AddHours(2), 200);
tree.AddInterval(ZERO.AddHours(2), ZERO.AddHours(3), 300);
tree.AddInterval(ZERO.AddHours(3), ZERO.AddHours(4), 400);
var result = tree.GetIntersections().ToList();
Assert.AreEqual(0, result.Count, "Each interval ends exactly at the start of the next interval so there is no intersection");
}
public void TestSeparateIntervalsIntersectionsList()
{
IntervalTree<int, DateTime> tree = new IntervalTree<int, DateTime>();
tree.AddInterval(ZERO, ZERO.AddHours(10), 100);
tree.AddInterval(ZERO.AddHours(20), ZERO.AddHours(30), 200);
var result = tree.GetIntersections().ToList();
Assert.AreEqual(0, result.Count, "Expect zero intersection because the interval do not overlaps");
}
public void TestEmptyIntervalTree_AssertIntersectionsCount()
{
IntervalTree<int, DateTime> tree = new IntervalTree<int, DateTime>();
var result = tree.GetIntersections().ToList();
Assert.AreEqual(0, result.Count, "There should not be any intersections because the tree it empty");
}
public void TwoIntersectingIntervals()
{
IntervalTree<int, DateTime> tree = new IntervalTree<int, DateTime>();
tree.AddInterval(ZERO, ZERO.AddHours(10), 100);
tree.AddInterval(ZERO.AddHours(3), ZERO.AddHours(30), 200);
var result = tree.Get(ZERO.AddHours(5));
Assert.AreEqual(2, result.Count);
Assert.AreEqual(100, result[0]);
Assert.AreEqual(200, result[1]);
}
static void ConsoleTest()
{
string line;
var tree = new IntervalTree<int>();
Console.WriteLine("Enter intervals as \"p q\" to add to tree, each on a new line, end with 0:");
line = Console.ReadLine();
while (line != "0") {
string[] bits = line.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
if (bits.Length != 2) {
break;
}
int start, end;
if (Int32.TryParse(bits[0], out start) && Int32.TryParse(bits[1], out end)) {
tree.Add(new Interval<int>(start, end));
} else {
break;
}
line = Console.ReadLine();
}
foreach (var n in tree) {
Console.Write("{0} ", n);
}
Console.WriteLine();
Console.WriteLine("Enter intervals as \"p q\" to delete from tree, each on a new line, end with 0:");
line = Console.ReadLine();
while (line != "0") {
string[] bits = line.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
if (bits.Length != 2) {
break;
}
int start, end;
if (Int32.TryParse(bits[0], out start) && Int32.TryParse(bits[1], out end)) {
tree.Remove(new Interval<int>(start, end));
} else {
break;
}
line = Console.ReadLine();
}
foreach (var n in tree) {
Console.Write("{0} ", n);
}
Console.WriteLine();
Console.WriteLine("Enter intervals as \"p q\", first overlapping interval will be found, end with 0:");
line = Console.ReadLine();
while (line != "0") {
string[] bits = line.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
if (bits.Length != 2) {
break;
}
int start, end;
if (Int32.TryParse(bits[0], out start) && Int32.TryParse(bits[1], out end)) {
try {
Console.WriteLine(tree.SearchFirstOverlapping(new Interval<int>(start, end)));
} catch (KeyNotFoundException e) {
Console.WriteLine("Not found");
}
} else {
break;
}
line = Console.ReadLine();
}
Console.ReadLine();
}
public void TestPertialOverlapIntervals_AssertIntersectionsCount()
{
IntervalTree<int, DateTime> tree = new IntervalTree<int, DateTime>();
tree.AddInterval(ZERO, ZERO.AddHours(10), 100);
tree.AddInterval(ZERO.AddHours(5), ZERO.AddHours(15), 200);
tree.AddInterval(ZERO.AddHours(10), ZERO.AddHours(20), 200);
var result = tree.GetIntersections().ToList();
Assert.AreEqual(2, result.Count);
}
public void CreateEmptyIntervalTree()
{
IntervalTree<int, DateTime> emptyTree = new IntervalTree<int, DateTime>();
Assert.IsNotNull(emptyTree);
}
/// <summary>
/// Returns a set of appointments from a GoogleApps Feed
/// </summary>
/// <param name="user">The exchange user to get apointments for</param>
/// <param name="srcTimeZone">The time zone to use</param>
/// <param name="googleAppsFeed">Source feed to create array from</param>
/// <returns></returns>
private IntervalTree<Appointment> CreateAppointments(
ExchangeUser user,
OlsonTimeZone srcTimeZone,
EventFeed googleAppsFeed)
{
IntervalTree<Appointment> result = new IntervalTree<Appointment>();
foreach ( EventEntry eventEntry in googleAppsFeed.Entries )
{
try
{
CreateAppointment(result, user, srcTimeZone, eventEntry);
}
catch ( GCalExchangeException ex )
{
if ( ex.ErrorCode == GCalExchangeErrorCode.OlsonTZError )
{
log.Error( "Error creating appointment (TimeZone issue)", ex );
}
else
{
throw;
}
}
}
return result;
}
private void CreateAppointment(
IntervalTree<Appointment> result,
ExchangeUser user,
OlsonTimeZone srcTimeZone,
EventEntry googleAppsEvent)
{
Appointment appt = new Appointment();
if ( googleAppsEvent.Times != null && googleAppsEvent.Times.Count > 0 )
{
When eventTime = googleAppsEvent.Times[0];
appt.StartDate = DateTime.SpecifyKind(eventTime.StartTime.ToUniversalTime(), DateTimeKind.Unspecified);
appt.EndDate = DateTime.SpecifyKind(eventTime.EndTime.ToUniversalTime(), DateTimeKind.Unspecified);
log.DebugFormat("Create - [{0}] {1}", appt.Range, appt.Range.Start.Kind);
appt.AllDayEvent = googleAppsEvent.Times[0].AllDay;
}
if (ConfigCache.SyncAppointmentDetails &&
googleAppsEvent.Locations != null &&
googleAppsEvent.Locations.Count > 0 )
{
appt.Location = googleAppsEvent.Locations[0].ValueString ?? string.Empty;
}
else
{
appt.Location = String.Empty;
}
string subject = ConfigCache.PlaceHolderMessage;
if (ConfigCache.SyncAppointmentDetails)
{
subject += ": " + ConversionsUtil.SafeGetText(googleAppsEvent.Title);
if (subject.Length > 255)
{
subject = subject.Remove(255);
}
}
appt.Subject = subject;
if (ConfigCache.SyncAppointmentDetails)
{
appt.Body = ConversionsUtil.SafeGetContent(googleAppsEvent.Content);
}
appt.MeetingStatus = ConversionsUtil.ConvertGoogleEventStatus(googleAppsEvent.Status);
appt.BusyStatus = ConversionsUtil.GetUserStatusForEvent(user, googleAppsEvent);
appt.Created = DateUtil.NowUtc;
appt.InstanceType = InstanceType.Single;
AssignOwnership( appt );
result.Insert(appt.Range, appt);
}
public void TestIntersectingIntervalsIntersectionsList()
{
IntervalTree<int, DateTime> tree = new IntervalTree<int, DateTime>();
tree.AddInterval(ZERO, ZERO.AddHours(10), 100);
tree.AddInterval(ZERO.AddHours(3), ZERO.AddHours(30), 200);
var result = tree.GetIntersections().ToList();
Assert.AreEqual(1, result.Count, "Expect one intersection because the intervals overlaps");
int totalIntervals = result.Select(x => x.Count).Sum();
Assert.AreEqual(2, totalIntervals, "Expect two intervals");
}
/// <summary>
/// Tree from Introduction to algorithms
/// </summary>
/// <returns></returns>
static IntervalTree<long> createCormenTree()
{
var tree = new IntervalTree<long>();
int[] starts = new int[] { 16, 8, 25, 0, 26, 17, 15, 6, 19, 5 };
int[] ends = new int[] { 21, 9, 30, 3, 26, 19, 23, 10, 20, 8 };
for (int i = 0; i < starts.Length; i++) {
tree.Add(new Interval<long>(starts[i], ends[i]));
}
return tree;
}
public void TestBigTree()
{
var it = new IntervalTree<float, int> ();
for (int i = 0; i < 100; i++)
{
it.Add (i, i + 1, 0);
Check.IsTrue (it.CheckInvariants ());
}
var ita = it.ToArray ();
for (int j = 0; j < 100; j += 2)
{
it.Remove (ita [j]);
Check.IsTrue (it.CheckInvariants ());
}
TestProgram.VConsole.ShowVisual (it.ToVisual ());
}
static void LargeDatasetTest(int n, int steps)
{
Random randGen = new Random();
int[] vals = new int[n];
int[] ends = new int[n];
for (int i = 0; i < n; i++) {
vals[i] = randGen.Next(1, n - 1);
ends[i] = randGen.Next(vals[i], n);
}
for (int i = 0; i < n; i += steps) {
var sw = new System.Diagnostics.Stopwatch();
sw.Start();
var tree = new IntervalTree<int>();
for (int j = 0; j < i; j++) {
tree.Add(new Interval<int>(vals[j], ends[j]));
}
Console.WriteLine("Insert\t{0}\t {1}", i, sw.ElapsedMilliseconds);
Console.WriteLine("Memory after insert\t{0}", GC.GetTotalMemory(true));
sw.Reset();
sw.Start();
// Delete half of the inserted
for (int k = 0; k < i; k++) {
int index = randGen.Next(0, i);
var xafu = new Interval<int>(vals[index], ends[index]);
tree.Remove(xafu);
//Console.WriteLine("Just delted {0}", xafu);
}
sw.Stop();
Console.WriteLine("Delete\t{0}\t {1}", i, sw.ElapsedMilliseconds);
// Does not seem to track memory correctly on Mono (as if no GC)
// On Windows, memory footprint is cca. 50% after delete, as expected
Console.WriteLine("Memory after delete\t{0}", GC.GetTotalMemory(true));
Console.Error.WriteLine("\nTesting {0}", i);
}
}
public void TestPertialOverlapIntervals_AssertIntersectionsContent()
{
IntervalTree<int, DateTime> tree = new IntervalTree<int, DateTime>();
tree.AddInterval(ZERO, ZERO.AddHours(10), 100);
tree.AddInterval(ZERO.AddHours(5), ZERO.AddHours(15), 200);
tree.AddInterval(ZERO.AddHours(10), ZERO.AddHours(20), 300);
var result = tree.GetIntersections().ToList();
for (int i = 0; i < 2; i++)
{
int[] expected;
if (i == 0)
{
expected = new[] { 100, 200 };
}
else
{
expected = new[] { 200, 300 };
}
CollectionAssert.AreEqual(expected, result[i].Select(x => x.Data).ToArray());
}
}
public void TestPertialOverlapIntervals_AssertIntersectionsContentCount()
{
IntervalTree<int, DateTime> tree = new IntervalTree<int, DateTime>();
tree.AddInterval(ZERO, ZERO.AddHours(10), 100);
tree.AddInterval(ZERO.AddHours(5), ZERO.AddHours(15), 200);
tree.AddInterval(ZERO.AddHours(10), ZERO.AddHours(20), 200);
var result = tree.GetIntersections().ToList();
var intersectionContentCount = result.Select(x => x.Count).ToList();
var expectedCount = new[] { 2, 2 };
CollectionAssert.AreEqual(expectedCount, intersectionContentCount);
}
