public static ISortedEnumerable <TResult> SelectSorted <TSource, TResult>(this ISortedEnumerable <TSource> sequence, Func <TSource, TResult> selector, Func <TResult, TResult, int> resultComparer = null) { Contract.Requires <ArgumentNullException>(sequence != null); Contract.Requires <ArgumentNullException>(selector != null); return(new SortedEnumerable <TResult>(((IEnumerable <TSource>)sequence).Select(selector), resultComparer)); }
public static void EnsureSingleEnumerationDEBUGSorted <T>(ref ISortedEnumerable <T> sequence) { if (sequence != null) { sequence = new SortedList <T>(sequence.ToList(), sequence.Comparer); } }
/// <summary> /// Filters the specified sorted sequence on the specified predicate. /// </summary> public static ISortedEnumerable <TSource> WhereSorted <TSource>(this ISortedEnumerable <TSource> sequence, Func <TSource, bool> predicate) { Contract.Requires(sequence != null); Contract.Requires(predicate != null); return(new SortedEnumerable <TSource>(sequence.Where(predicate), sequence.Comparer)); }
/// <summary> Yields all elements that are between the elements in the specified sorted sequence. So basically, this is exclusion of the sequence from the range of the sequence. </summary> /// <typeparam name="T"> The type of the elements. </typeparam> /// <param name="sequence"> The sequence of the elements that are not yielded. </param> /// <param name="increment"> A function specifying the next element given one. </param> /// <param name="start"> The start of the range of all elements to yield. </param> /// <param name="end"> The end of the range of all elements to yield. </param> /// <param name="equalityComparer"> The equality comparer used for determining whether an element in the specified sequence matches that in the range. </param> public static IEnumerable <T> RangeExcept <T>(this ISortedEnumerable <T> sequence, Func <T, T> increment, T start, T end, IEqualityComparer <T> equalityComparer = null) { Contract.Requires(sequence != null); Contract.Requires(increment != null); Contract.Requires(sequence.IsSorted(sequence.Comparer)); equalityComparer = equalityComparer ?? EqualityComparer <T> .Default; T previouslyExcludedElement = start; bool first = true; foreach (var excludedElement in sequence.Concat(end)) { foreach (var elementBelowExcludedElement in Range(previouslyExcludedElement, increment, excludedElement, equalityComparer, first)) { if (equalityComparer.Equals(end, elementBelowExcludedElement)) { yield break; } yield return(elementBelowExcludedElement); } if (equalityComparer.Equals(end, excludedElement)) { yield break; } previouslyExcludedElement = excludedElement; first = false; } }
public void SortedEnumerable_RepeatWithDelegate_EnumeratesRepeatedItem() { int source = 13; ISortedEnumerable <int> result = SortedEnumerableSource.Repeat(source, (x, y) => Comparer <int> .Default.Compare(y, x), 3); Assert.IsTrue(result.SequenceEqual(new[] { 13, 13, 13 }), "Item should be repeated."); }
public void SortedEnumerable_Repeat_EnumeratesRepeatedItem() { int source = 13; ISortedEnumerable <int> result = SortedEnumerableSource.Repeat(source, 3); Assert.IsTrue(result.SequenceEqual(new[] { 13, 13, 13 }), "Item should be repeated."); }
public void SortedEnumerable_ReturnWithComparer_EnumeratesSingleItem() { int source = 13; ISortedEnumerable <int> result = SortedEnumerableSource.Return(source, Comparer <int> .Default); Assert.IsTrue(result.SequenceEqual(new[] { 13 }), "Item should be enumerated."); }
/// <summary> Returns whether the specified intervals are disjoint. </summary> /// <param name="intervals"> The intervals to inspect, ordered by interval start. </param> /// <returns> an empty specified enumerable is considered disjoint. </returns> public static bool AreDisjoint(this ISortedEnumerable <Interval> intervals) { Contract.Requires(intervals != null); Contract.RequiresForAll(intervals, interval => !interval.IsEmpty); Contract.Requires(intervals.IsSorted(comparer: Compare)); Interval previous = default(Interval); bool first = true; foreach (Interval interval in intervals) { if (first) { first = false; } else { if (!previous.DisjointFrom(interval)) { return(false); } } previous = interval; } return(true); }
public void SortedEnumerable_LastIndexOf_WithInvalidItem_DoesNotFindItem() { IEnumerable <string> source = new[] { "a", "a", "c" }; ISortedEnumerable <string> sorted = source.AsSorted(); int result = sorted.LastIndexOf(x => StringComparer.InvariantCultureIgnoreCase.Compare("d", x)); Assert.AreEqual(-1, result, "Item should not be found."); }
public void SortedEnumerable_UpperBound_ItemNotFoundPastSequence_ReturnsBitwiseComplement() { IEnumerable <int> source = new[] { 1, 2, 2, 4 }; ISortedEnumerable <int> sorted = source.AsSorted(); int result = sorted.UpperBound(5); Assert.AreEqual(~4, result, "LowerBound should return the bitwise complement if not found."); }
public void SortedEnumerable_UpperBound_ItemNotFoundInEmptySequence_ReturnsBitwiseComplementOf0() { IEnumerable <int> source = new int[] { }; ISortedEnumerable <int> sorted = source.AsSorted(); int result = sorted.UpperBound(3); Assert.AreEqual(~0, result, "LowerBound should return the bitwise complement if not found."); }
public void SortedEnumerable_UpperBound_ItemFound_ReturnsUpperBound() { IEnumerable <int> source = new[] { 1, 2, 2, 4 }; ISortedEnumerable <int> sorted = source.AsSorted(); int result = sorted.UpperBound(2); Assert.AreEqual(3, result, "UpperBound should return the upper bound."); }
public void SortedEnumerable_RepeatWithComparer_RemembersComparer() { var comparer = Comparer <int> .Default; int source = 13; ISortedEnumerable <int> result = SortedEnumerableSource.Repeat(source, comparer, 3); Assert.AreEqual(comparer, result.Comparer, "Comparer should be remembered."); }
public void SortedEnumerable_IndexOf_WithValidItemValue_FindsItem() { IEnumerable <string> source = new[] { "a", "a", "c" }; ISortedEnumerable <string> sorted = source.AsSorted(); int result = sorted.IndexOf("a"); Assert.AreEqual(0, result, "Item should be found."); }
public void SortedEnumerable_LastIndexOf_WithInvalidItemValue_DoesNotFindItem() { IEnumerable <string> source = new[] { "a", "a", "c" }; ISortedEnumerable <string> sorted = source.AsSorted(); int result = sorted.LastIndexOf("A"); Assert.AreEqual(-1, result, "Item should not be found."); }
public void SortedEnumerable_IndexOf_WithValidItem_FindsItem() { IEnumerable <string> source = new[] { "a", "a", "c" }; ISortedEnumerable <string> sorted = source.AsSorted(); int result = sorted.IndexOf(x => StringComparer.InvariantCultureIgnoreCase.Compare("a", x)); Assert.AreEqual(0, result, "Item should be found."); }
public void SortedEnumerable_Contains_WithInvalidItem_DoesNotFindItem() { IEnumerable <string> source = new[] { "a", "b", "c" }; ISortedEnumerable <string> sorted = source.AsSorted(); bool result = sorted.Contains(x => StringComparer.InvariantCultureIgnoreCase.Compare("0", x)); Assert.IsFalse(result, "Item should not be found."); }
public void SortedEnumerable_Contains_WithInvalidItemValue_DoesNotFindItem() { IEnumerable <string> source = new[] { "a", "b", "c" }; ISortedEnumerable <string> sorted = source.AsSorted(); bool result = sorted.Contains("0"); Assert.IsFalse(result, "Item should not be found."); }
public void SortedEnumerable_Contains_WithValidItemValue_FindsItem() { IEnumerable <string> source = new[] { "a", "b", "c" }; ISortedEnumerable <string> sorted = source.AsSorted(); bool result = sorted.Contains("b"); Assert.IsTrue(result, "Item should be found."); }
public void SortedEnumerable_EqualRange_RunOf1_InSecondMiddle() { IEnumerable <int> source = new[] { 1, 3, 5, 7 }; ISortedEnumerable <int> sorted = source.AsSorted(); int begin; int end; sorted.EqualRange(5, out begin, out end); Assert.AreEqual(2, begin); Assert.AreEqual(3, end); }
public void SortedEnumerable_EqualRange_RunOf0_InMiddle() { IEnumerable <int> source = new[] { 1, 3 }; ISortedEnumerable <int> sorted = source.AsSorted(); int begin; int end; sorted.EqualRange(2, out begin, out end); Assert.AreEqual(1, begin); Assert.AreEqual(1, end); }
public void SortedEnumerable_EqualRange_RunOf3_AtBeginning() { IEnumerable <int> source = new[] { 1, 1, 1, 4 }; ISortedEnumerable <int> sorted = source.AsSorted(); int begin; int end; sorted.EqualRange(1, out begin, out end); Assert.AreEqual(0, begin); Assert.AreEqual(3, end); }
public void SortedEnumerable_EqualRange_RunOf2_AtEnd() { IEnumerable <int> source = new[] { 1, 2, 3, 3 }; ISortedEnumerable <int> sorted = source.AsSorted(); int begin; int end; sorted.EqualRange(3, out begin, out end); Assert.AreEqual(2, begin); Assert.AreEqual(4, end); }
public void SortedEnumerable_EqualRange_RunOf3_AtEnd() { IEnumerable <int> source = new[] { 0, 1, 1, 4, 4, 4 }; ISortedEnumerable <int> sorted = source.AsSorted(); int begin; int end; sorted.EqualRange(4, out begin, out end); Assert.AreEqual(3, begin); Assert.AreEqual(6, end); }
public void SortedEnumerable_EqualRange_RunOf3_AtSecondMiddle() { IEnumerable <int> source = new[] { 0, 1, 4, 4, 4, 7 }; ISortedEnumerable <int> sorted = source.AsSorted(); int begin; int end; sorted.EqualRange(4, out begin, out end); Assert.AreEqual(2, begin); Assert.AreEqual(5, end); }
public void SortedDictionary_AsSorted_EnumeratesIdenticalSequence() { SortedDictionary <int, string> source = new SortedDictionary <int, string>(); source.Add(0, "a"); source.Add(1, "c"); source.Add(2, "b"); ISortedEnumerable <KeyValuePair <int, string> > result = source.AsSorted(); Assert.IsTrue(result.SequenceEqual(new[] { new KeyValuePair <int, string>(0, "a"), new KeyValuePair <int, string>(1, "c"), new KeyValuePair <int, string>(2, "b") }), "AsSorted should not change the sequence."); Assert.AreEqual(0, result.IndexOf(new KeyValuePair <int, string>(0, "a")), "Could not find item in sorted dictionary."); }
private static IEnumerable <Gap> findGaps(ISortedEnumerable <int> filledPositionIndices, Interval toFill) { int previousPresentIndex = toFill.Start - 1; foreach (int presentIndex in filledPositionIndices.ConcatIfNotLastElement(toFill.End)) { if (presentIndex != previousPresentIndex + 1) { yield return(new Gap(previousPresentIndex + 1, presentIndex)); } previousPresentIndex = presentIndex; } }
public static ISortedEnumerable <T> ThenBy <T, U>(this ISortedEnumerable <T> seq, Func <T, U> criterium) where U : IComparable <U> { SortedEnumerable <T> s = (SortedEnumerable <T>)seq; return(new SortedEnumerable <T>(seq, (t1, t2) => { int res = s.Criteria(t1, t2); if (res != 0) { return res; } else { return criterium(t1).CompareTo(criterium(t2)); } } )); }
public static IEnumerable <int> RangeExcept(this ISortedEnumerable <int> sequence, int start, int end) { return(RangeExcept(sequence, i => i + 1, start, end)); }
/// <summary> Caches the specified sorted sequence in a sorted list. </summary> public static SortedList <T> ToSortedList <T>(this ISortedEnumerable <T> sequence) { return(new SortedList <T>(sequence.ToList(), sequence.Comparer)); }