public void Sort_intintIComparer_NegativeRange_ThrowsArgumentOutOfRangeException(int count) { SegmentedList <T> list = GenericListFactory(count); Tuple <int, int>[] InvalidParameters = new Tuple <int, int>[] { Tuple.Create(-1, -1), Tuple.Create(-1, 0), Tuple.Create(-1, 1), Tuple.Create(-1, 2), Tuple.Create(-2, 0), Tuple.Create(int.MinValue, 0), Tuple.Create(0, -1), Tuple.Create(0, -2), Tuple.Create(0, int.MinValue), Tuple.Create(1, -1), Tuple.Create(2, -1), }; Assert.All( InvalidParameters, invalidSet => { Assert.Throws <ArgumentOutOfRangeException>( () => list.Sort(invalidSet.Item1, invalidSet.Item2, GetIComparer()) ); } ); }
public void Sort_IComparer_WithoutDuplicates(int count) { SegmentedList <T> list = GenericListFactory(count); IComparer <T> comparer = GetIComparer(); list.Sort(comparer); Assert.All(Enumerable.Range(0, count - 2), i => { Assert.True(comparer.Compare(list[i], list[i + 1]) < 0); }); }
public void BinarySearch_Validations(int count) { SegmentedList <T> list = GenericListFactory(count); list.Sort(); T element = CreateT(3215); Assert.Throws <ArgumentException>(null, () => list.BinarySearch(0, count + 1, element, GetIComparer())); //"Finding items longer than array should throw ArgumentException" Assert.Throws <ArgumentOutOfRangeException>(() => list.BinarySearch(-1, count, element, GetIComparer())); //"ArgumentOutOfRangeException should be thrown on negative index." Assert.Throws <ArgumentOutOfRangeException>(() => list.BinarySearch(0, -1, element, GetIComparer())); //"ArgumentOutOfRangeException should be thrown on negative count." Assert.Throws <ArgumentException>(null, () => list.BinarySearch(count + 1, count, element, GetIComparer())); //"ArgumentException should be thrown on index greater than length of array." }
public void Sort_Comparison_WithoutDuplicates(int count) { SegmentedList <T> list = GenericListFactory(count); IComparer <T> iComparer = GetIComparer(); Comparison <T> comparer = ((T first, T second) => { return(iComparer.Compare(first, second)); }); list.Sort(comparer); Assert.All(Enumerable.Range(0, count - 2), i => { Assert.True(iComparer.Compare(list[i], list[i + 1]) < 0); }); }
public void Sort_WithDuplicates(int count) { SegmentedList <T> list = GenericListFactory(count); list.Add(list[0]); IComparer <T> comparer = Comparer <T> .Default; list.Sort(); Assert.All(Enumerable.Range(0, count - 2), i => { Assert.True(comparer.Compare(list[i], list[i + 1]) <= 0); }); }
public void Sort_intintIComparer_InvalidRange_ThrowsArgumentException(int count) { SegmentedList <T> list = GenericListFactory(count); Tuple <int, int>[] InvalidParameters = new Tuple <int, int>[] { Tuple.Create(count, 1), Tuple.Create(count + 1, 0), Tuple.Create(int.MaxValue, 0), }; Assert.All(InvalidParameters, invalidSet => { Assert.Throws <ArgumentException>(null, () => list.Sort(invalidSet.Item1, invalidSet.Item2, GetIComparer())); }); }
public void BinarySearch_ForEveryItemWithDuplicates(int count) { if (count > 0) { SegmentedList <T> list = GenericListFactory(count); list.Add(list[0]); list.Sort(); SegmentedList <T> beforeList = list.ToSegmentedList(); Assert.All(Enumerable.Range(0, list.Count), index => { Assert.True(list.BinarySearch(beforeList[index]) >= 0); Assert.True(list.BinarySearch(beforeList[index], GetIComparer()) >= 0); Assert.Equal(beforeList[index], list[index]); }); } }
public void Sort_intintIComparer_WithoutDuplicates(int count) { SegmentedList <T> unsortedList = GenericListFactory(count); IComparer <T> comparer = GetIComparer(); for (int startIndex = 0; startIndex < count - 2; startIndex++) { for (int sortCount = 1; sortCount < count - startIndex; sortCount++) { SegmentedList <T> list = new SegmentedList <T>(unsortedList); list.Sort(startIndex, sortCount + 1, comparer); for (int i = startIndex; i < sortCount; i++) { Assert.InRange(comparer.Compare(list[i], list[i + 1]), int.MinValue, 0); } } } }
public void BinarySearch_ForEveryItemWithoutDuplicates(int count) { SegmentedList <T> list = GenericListFactory(count); foreach (T item in list) { while (list.Count((value) => value.Equals(item)) > 1) { list.Remove(item); } } list.Sort(); SegmentedList <T> beforeList = list.ToSegmentedList(); Assert.All(Enumerable.Range(0, list.Count), index => { Assert.Equal(index, list.BinarySearch(beforeList[index])); Assert.Equal(index, list.BinarySearch(beforeList[index], GetIComparer())); Assert.Equal(beforeList[index], list[index]); }); }
public Statistics(IEnumerable <double> values) { var sortedValues = new SegmentedList <double>(values.Where(d => !double.IsNaN(d))); sortedValues.Sort(); if (sortedValues.Count < 1) { return; } var quartiles = Quartiles.FromSorted(sortedValues); Min = quartiles.Min; Q1 = quartiles.Q1; Median = quartiles.Median; Q3 = quartiles.Q3; Max = quartiles.Max; Mean = sortedValues.Average(); var tukey = TukeyOutlierDetector.FromQuartiles(quartiles); LowerFence = tukey.LowerFence; UpperFence = tukey.UpperFence; P0 = SimpleQuantileEstimator.Instance.GetQuantileFromSorted(sortedValues, 0.0); P25 = SimpleQuantileEstimator.Instance.GetQuantileFromSorted(sortedValues, 0.25); P50 = SimpleQuantileEstimator.Instance.GetQuantileFromSorted(sortedValues, 0.50); P67 = SimpleQuantileEstimator.Instance.GetQuantileFromSorted(sortedValues, 0.67); P80 = SimpleQuantileEstimator.Instance.GetQuantileFromSorted(sortedValues, 0.80); P85 = SimpleQuantileEstimator.Instance.GetQuantileFromSorted(sortedValues, 0.85); P90 = SimpleQuantileEstimator.Instance.GetQuantileFromSorted(sortedValues, 0.90); P95 = SimpleQuantileEstimator.Instance.GetQuantileFromSorted(sortedValues, 0.95); P99 = SimpleQuantileEstimator.Instance.GetQuantileFromSorted(sortedValues, 0.99); P100 = SimpleQuantileEstimator.Instance.GetQuantileFromSorted(sortedValues, 1.00); }