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); }