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