public void Calculate_Should_Return_Zero_Medians_On_No_results() { // Arrange var currentDate = new DateTime(2020, 2, 2); var benchMarkResults = new List <BenchMarkResult>() { }; // Act var benchMarkData = MedianCalculator.Calculate(currentDate, benchMarkResults); // Assert Assert.NotNull(benchMarkData); Assert.Equal(0, benchMarkData.CurrentDay); Assert.Equal(0, benchMarkData.PreviousDay); Assert.Equal(0, benchMarkData.DifferencePercentage); // for the difference an divide by currentday exists so make so it doesnt crash ;) }
public void DoesFindMedianInSortedArray() { var data = new double[] { 1, 2, 3 }; var median = MedianCalculator.median(data); Assert.Equal(2, median); }
public void Calculate_Should_Return_Zero_Medians_On_No_results_of_GivenDate_Or_DateBefore_GivenDate() { // Arrange var currentDate = new DateTime(2020, 2, 12); var benchMarkResults = new List <BenchMarkResult>() { new BenchMarkResult() { RequestDuration = 11, CreatedAt = new DateTimeOffset(new DateTime(2020, 2, 13)), // tomorrow }, new BenchMarkResult() { RequestDuration = 200, CreatedAt = new DateTimeOffset(new DateTime(2020, 2, 10)), // not yesterday but before }, }; // Act var benchMarkData = MedianCalculator.Calculate(currentDate, benchMarkResults); // Assert Assert.NotNull(benchMarkData); Assert.Equal(0, benchMarkData.CurrentDay); Assert.Equal(0, benchMarkData.PreviousDay); Assert.Equal(0, benchMarkData.DifferencePercentage); // for the difference an divide by currentday exists so make so it doesnt crash ;) }
public void TestGetMedianDoubleArray() { int[] a = { 1, 2, 3, 4 }; int[] b = { 5, 6, 7, 8 }; double result = MedianCalculator.GetMedianValueHighPerformance(a, b); double expected = 4.5; Assert.AreEqual(expected, result); a = new int[] { 1, 2 }; b = new int[] { 1, 2, 3 }; result = MedianCalculator.GetMedianValueHighPerformance(a, b); expected = 2; Assert.AreEqual(expected, result); a = new int[] { 1, 1, 1 }; b = new int[] { 1, 1, 3 }; result = MedianCalculator.GetMedianValueHighPerformance(a, b); expected = 1; Assert.AreEqual(expected, result); a = new int[] { 1, 1, 1 }; b = new int[] { 1, 1, 1, 1, 1, 3 }; result = MedianCalculator.GetMedianValueHighPerformance(a, b); expected = 1; Assert.AreEqual(expected, result); a = new int[] { 1, 1, 1, 1, 1, 3 }; b = new int[] { 1, 1, 1 }; result = MedianCalculator.GetMedianValueHighPerformance(a, b); expected = 1; Assert.AreEqual(expected, result); }
public void ForumTest1() { List <int> data = new[] { 1, 666, 10, 667, 100, 2, 3 }.ToList(); int result = MedianCalculator.SumMedians(data); Assert.AreEqual(142, result); }
public void AveragesOutMiddleNumbers() { var data = new double[] { 1, 2, 3, 4 }; var median = MedianCalculator.median(data); Assert.Equal(2.5, median); }
public void ReturnsTheOnlyElementAsMedian() { var data = new double[] { 5.5 }; var median = MedianCalculator.median(data); Assert.Equal(5.5, median); }
public void TestGetMedianSingleArray() { int[] a = { 2, 1, 3 }; double result = MedianCalculator.GetMedianValue(a); double expected = 2; Assert.AreEqual(expected, result); //even array a = new int[] { 2, 1, 3, 4, 5, 5 }; result = MedianCalculator.GetMedianValue(a); expected = 3.5; Assert.AreEqual(expected, result); //odd array a = new int[] { 1, 2, 3, 4, 4, 5, 5 }; result = MedianCalculator.GetMedianValue(a); expected = 4; Assert.AreEqual(expected, result); //even array a = new int[] { 1, 1, 1, 2, 1, 1, 1, 1 }; result = MedianCalculator.GetMedianValue(a); expected = 1; Assert.AreEqual(expected, result); }
public void DoesFindMedianInTwoElementArray() { var data = new double[] { 10, 20 }; var median = MedianCalculator.median(data); Assert.Equal(15, median); }
public void ForumTest4() { List <int> data = new[] { 23, 9, 35, 4, 13, 24, 2, 5, 27, 1, 34, 8 }.ToList(); int result = MedianCalculator.SumMedians(data); Assert.AreEqual(156, result); }
public void ForumTest3() { List <int> data = new[] { 23, 9, 35, 4, 13, 24, 2, 5, 27, 1, 34, 8, 15, 39, 32, 22, 29, 21, 19, 20, 36, 33, 7, 31, 14, 17, 26, 16, 38, 6, 30, 40, 25, 28, 11, 37, 3, 10, 18, 12 }.ToList(); int result = MedianCalculator.SumMedians(data); Assert.AreEqual(717, result); }
public void ForumTest2() { List <int> data = new[] { 6331, 2793, 1640, 9290, 225, 625, 6195, 2303, 5685, 1354 }.ToList(); int result = MedianCalculator.SumMedians(data); Assert.AreEqual(9335, result); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testDistribution() public virtual void testDistribution() { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.function.Function<double[], double> meanCalculator = new com.opengamma.strata.math.impl.statistics.descriptive.MeanCalculator(); System.Func <double[], double> meanCalculator = new MeanCalculator(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.function.Function<double[], double> medianCalculator = new com.opengamma.strata.math.impl.statistics.descriptive.MedianCalculator(); System.Func <double[], double> medianCalculator = new MedianCalculator(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.function.Function<double[], double> varianceCalculator = new com.opengamma.strata.math.impl.statistics.descriptive.PopulationVarianceCalculator(); System.Func <double[], double> varianceCalculator = new PopulationVarianceCalculator(); const int n = 1000000; const double eps = 0.1; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final double[] data = new double[n]; double[] data = new double[n]; for (int i = 0; i < n; i++) { data[i] = DIST.nextRandom(); } //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final double mean = MU + SIGMA / (1 - KSI); double mean = MU + SIGMA / (1 - KSI); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final double median = MU + SIGMA * (Math.pow(2, KSI) - 1) / KSI; double median = MU + SIGMA * (Math.Pow(2, KSI) - 1) / KSI; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final double variance = SIGMA * SIGMA / ((1 - KSI) * (1 - KSI) * (1 - 2 * KSI)); double variance = SIGMA * SIGMA / ((1 - KSI) * (1 - KSI) * (1 - 2 * KSI)); assertEquals(meanCalculator(data), mean, eps); assertEquals(medianCalculator(data), median, eps); assertEquals(varianceCalculator(data), variance, eps); }
public BenchMarkData ConvertToBenchMarkData(List <BenchMarkResult> resultDataPoints) { var benchmarkData = new BenchMarkData() { CloudProvider = Enum.ToObject(typeof(CloudProvider), resultDataPoints.First().CloudProvider).ToString(), HostingEnvironment = Enum.ToObject(typeof(HostingEnvironment), resultDataPoints.First().HostingEnvironment).ToString(), Runtime = Enum.ToObject(typeof(Runtime), resultDataPoints.First().Runtime).ToString() }; var currentDate = resultDataPoints.OrderByDescending(c => c.CreatedAt).First().CreatedAt.Date; var coldMedians = MedianCalculator.Calculate(currentDate, resultDataPoints, true); benchmarkData.ColdMedianExecutionTime = coldMedians.currentDay; var coldDifference = Math.Round( ((coldMedians.currentDay - coldMedians.previousDay) / Math.Abs(coldMedians.currentDay)) * 100, 2); benchmarkData.ColdPreviousDayDifference = coldDifference; benchmarkData.ColdPreviousDayPositive = benchmarkData.ColdPreviousDayDifference < 0; var warmMedians = MedianCalculator.Calculate(currentDate, resultDataPoints, false); benchmarkData.WarmMedianExecutionTime = warmMedians.currentDay; var warmDifference = Math.Round( ((warmMedians.currentDay - warmMedians.previousDay) / Math.Abs(warmMedians.currentDay)) * 100, 2); benchmarkData.WarmPreviousDayDifference = warmDifference; benchmarkData.WarmPreviousDayPositive = benchmarkData.WarmPreviousDayDifference < 0; var dates = new List <DateTime>(); for (var i = 0; i < Convert.ToInt32(Environment.GetEnvironmentVariable("dayRange")); i++) { dates.Add(currentDate - TimeSpan.FromDays(i)); } dates = dates.OrderBy(c => c.Date).ToList(); foreach (var date in dates) { benchmarkData.ColdDataPoints.Add(new DataPoint(date.ToString("yyyy MMMM dd"), resultDataPoints.Where(c => c.CreatedAt.Date == date.Date && c.IsColdRequest) .Select(c => c.RequestDuration).ToList())); benchmarkData.WarmDataPoints.Add(new DataPoint(date.ToString("yyyy MMMM dd"), resultDataPoints.Where(c => c.CreatedAt.Date == date.Date && !c.IsColdRequest) .Select(c => c.RequestDuration).ToList())); } return(benchmarkData); }
static void Main(string[] args) { var data = DataLoader.LoadData("medianData.txt"); var rollingMedian = MedianCalculator.SumMedians(data); Console.WriteLine(rollingMedian); Console.ReadLine(); }
public void CalculateMedian_WithEvenNumberOfItemsInList_GivesCorrectValue() { var calculator = new MedianCalculator(); var mockList = new List <decimal> { 1.78m, 6.09m, 0.007m, 1.4m, 2.78m, 8.9m }; var actualValue = calculator.CalculateMedian(mockList); Assert.AreEqual(2.28m, actualValue); }
public void Test_AverageByMedian_WithInterface() { Calculator calculator = new Calculator(); ICalculator medianCalculator = new MedianCalculator(); double expected = 8.0; double actual = calculator.CalculateAverage(values, medianCalculator); Assert.AreEqual(expected, actual, 0.000001); }
public void TestVeryLargeSourceData() { Random randNumber = new Random(); int[] a = CreateRandomDataSet(randNumber.Next(3, 10000000)); int[] b = CreateRandomDataSet(randNumber.Next(3, 10000000)); double result = MedianCalculator.GetMedianValueHighPerformance(a, b); // TODO: validate correct result is given // TODO: measure and report on memory and performance of the algorithm // what is the scaling factor when the data set is doubled in size? }
public void CorrectRollingMedian(string inputFile, string outputFile) { List <int> data = DataLoader.LoadData(inputFile); int result = MedianCalculator.SumMedians(data); int expected = File.ReadAllLines(outputFile) .First() .Split('\t', ' ', ',') .Where(n => !string.IsNullOrWhiteSpace(n)) .Select(int.Parse) .First(); Assert.AreEqual(expected, result); }
public void TestVeryLargeSourceData3() { Random randNumber = new Random(); int[] a = CreateRandomDataSet(randNumber.Next(3, 10000000)); int[] b = { }; double result = MedianCalculator.GetMedianValueHighPerformance(a, b); int[] combined = a.Concat(b).ToArray(); double expected = MedianCalculator.GetMedianValue(combined); Assert.AreEqual(expected, result); }
public void TestGetMedianSingleArray1() { int[] a = { 2, 1, 3 }; double result = MedianCalculator.GetMedianValue(a); double expected = 2; Assert.AreEqual(expected, result); a = new int[] { 1, 2, 3, 4 }; int[] b = { 5, 6, 7 }; result = MedianCalculator.GetMedianValueHighPerformance(a, b); expected = 4; Assert.AreEqual(expected, result); }
public BenchMarkData ConvertToBenchMarkData(List <BenchMarkResult> resultDataPoints) { var firstResult = resultDataPoints.OrderByDescending(c => c.CreatedAt).First(); var benchmarkData = new BenchMarkData() { CloudProvider = firstResult.CloudProvider.ToString(), HostingEnvironment = firstResult.HostingEnvironment.ToString(), Runtime = firstResult.Runtime.ToString() }; var currentDate = firstResult.CreatedAt.Date; var coldDataPoints = resultDataPoints.Where(c => c.IsColdRequest).ToList(); var coldMedians = MedianCalculator.Calculate(currentDate, coldDataPoints); benchmarkData.ColdMedianExecutionTime = coldMedians.CurrentDay; benchmarkData.ColdPreviousDayDifference = coldMedians.DifferencePercentage; benchmarkData.ColdPreviousDayPositive = benchmarkData.ColdPreviousDayDifference < 0; var warmDataPoints = resultDataPoints.Where(c => !c.IsColdRequest).ToList(); var warmMedians = MedianCalculator.Calculate(currentDate, warmDataPoints); benchmarkData.WarmMedianExecutionTime = warmMedians.CurrentDay; benchmarkData.WarmPreviousDayDifference = warmMedians.DifferencePercentage; benchmarkData.WarmPreviousDayPositive = benchmarkData.WarmPreviousDayDifference < 0; var dates = new List <DateTime>(); for (var i = 0; i < Convert.ToInt32(Environment.GetEnvironmentVariable("dayRange")); i++) { dates.Add(currentDate - TimeSpan.FromDays(i)); } dates = dates.OrderBy(c => c.Date).ToList(); foreach (var date in dates) { benchmarkData.ColdDataPoints.Add(new DataPoint(date.ToString("yyyy MMMM dd"), coldDataPoints.Where(c => c.CreatedAt.Date == date.Date) .Select(c => c.RequestDuration).ToList())); benchmarkData.WarmDataPoints.Add(new DataPoint(date.ToString("yyyy MMMM dd"), warmDataPoints.Where(c => c.CreatedAt.Date == date.Date) .Select(c => c.RequestDuration).ToList())); } return(benchmarkData); }
public void GetMedianOfSortedArrays_ShouldReturn_MedianOfTwoSortedArrays( int[] nums1, int[] nums2, double expectedMedian) { // Arrange var medianCalculator = new MedianCalculator(); // Act var median = medianCalculator.GetMedianOfSortedArrays(nums1, nums2); // Assert median.Should().Be(expectedMedian); }
public void TestVeryLargeSourceData() { Random randNumber = new Random(); int[] a = CreateRandomDataSet(randNumber.Next(3, 10000000)); int[] b = CreateRandomDataSet(randNumber.Next(3, 10000000)); //my best guess at how to validate the median, using the previous method and a simple concat. //I suppose this doesnt have to be efficient if its a test. double result = MedianCalculator.GetMedianValueHighPerformance(a, b); int[] combined = a.Concat(b).ToArray(); double expected = MedianCalculator.GetMedianValue(combined); Assert.AreEqual(expected, result); }
public void Calculate_Should_Return_Calculated_Medians_From_Results_By_Dates_() { // Arrange var currentDate = new DateTime(2020, 2, 11); var benchMarkResults = new List <BenchMarkResult>() { new BenchMarkResult() { RequestDuration = 80, CreatedAt = new DateTimeOffset(new DateTime(2020, 2, 11)), // today }, new BenchMarkResult() { RequestDuration = 20, CreatedAt = new DateTimeOffset(new DateTime(2020, 2, 11)), // today }, new BenchMarkResult() { RequestDuration = 11, CreatedAt = new DateTimeOffset(new DateTime(2020, 2, 10)), // yesterday }, new BenchMarkResult() { RequestDuration = 33, CreatedAt = new DateTimeOffset(new DateTime(2020, 2, 10)), // yesterday }, }; // Act var benchMarkData = MedianCalculator.Calculate(currentDate, benchMarkResults); // Assert Assert.NotNull(benchMarkData); Assert.Equal(50, benchMarkData.CurrentDay); Assert.Equal(22, benchMarkData.PreviousDay); Assert.Equal(56, benchMarkData.DifferencePercentage); }
public void Calculate_Should_Return_Calculated_CurrentMedian_From_Results_By_Dates_Matching_Given() { // Arrange var currentDate = new DateTime(2020, 2, 11); var benchMarkResults = new List <BenchMarkResult>() { new BenchMarkResult() { RequestDuration = 11, CreatedAt = new DateTimeOffset(new DateTime(2020, 2, 11)), // today }, new BenchMarkResult() { RequestDuration = 33, CreatedAt = new DateTimeOffset(new DateTime(2020, 2, 11)), // today }, new BenchMarkResult() { RequestDuration = 200, CreatedAt = new DateTimeOffset(new DateTime(2020, 2, 10)), // yesterday }, }; // Act var benchMarkData = MedianCalculator.Calculate(currentDate, benchMarkResults); // Assert Assert.NotNull(benchMarkData); Assert.Equal(22, benchMarkData.CurrentDay); }
/// <summary> /// Calculates the median of the given numbers. /// </summary> /// <param name="numbers">The numbers whose median is to be calculated.</param> /// <returns>The median of the given numbers.</returns> /// <exception cref="System.ArgumentNullException"> /// The specified collection must not be null. /// </exception> /// <exception cref="System.InvalidOperationException"> /// The arguments must not be empty. /// </exception> public static double Median(this IEnumerable <double> numbers) { return(MedianCalculator.Median(numbers)); }