private static List <int> CalculateLUT(HistogramData data) { List <int> result = new List <int>(new int[256]); double[] D = new double[256]; double sum = 0; foreach (var x in data.data) { sum += x; } for (int i = 0; i < 256; ++i) { for (int j = 0; j < i; ++j) { D[i] += data.data[j]; } D[i] = D[i] / sum; } for (int i = 0; i < 256; ++i) { result[i] = (int)Math.Ceiling(255 * D[i]); } return(result); }
private void DrawHistogram(StatisticsResults sr) { HistogramData histogram = new HistogramData(); histogram.Calculate(sr.Cycle); ICollection<HistogramData.IntervalData> intervals = histogram.Rows; const double targetProbabilityValue = (double)1/20; PlotModel tempPlotModel = new PlotModel("Histogram") { LegendPlacement = LegendPlacement.Outside, LegendPosition = LegendPosition.RightTop, LegendOrientation = LegendOrientation.Vertical }; ColumnSeries columnSeries = (ColumnSeries)HistogramPlot(intervals); tempPlotModel.Axes.Add(new LinearAxis(AxisPosition.Left, 0.0)); tempPlotModel.Axes.Add(new CategoryAxis { LabelField = "Value", IntervalLength = targetProbabilityValue, ItemsSource = columnSeries.ItemsSource, GapWidth = 0.0 }); tempPlotModel.Series.Add( columnSeries ); tempPlotModel.Series.Add(TargetProbabilityLine(targetProbabilityValue)); SamplePlot.Model = tempPlotModel; }
public ClientStats GetStats(bool reset) { var histogramData = new HistogramData(); foreach (var hist in threadLocalHistogram.Values) { hist.GetSnapshot(histogramData, reset); } var timeSnapshot = timeStats.GetSnapshot(reset); if (reset) { statsResetCount.Increment(); } GrpcEnvironment.Logger.Info("[ClientRunnerImpl.GetStats] GC collection counts: gen0 {0}, gen1 {1}, gen2 {2}, (histogram reset count:{3}, seconds since reset: {4})", GC.CollectionCount(0), GC.CollectionCount(1), GC.CollectionCount(2), statsResetCount.Count, timeSnapshot.WallClockTime.TotalSeconds); return(new ClientStats { Latencies = histogramData, TimeElapsed = timeSnapshot.WallClockTime.TotalSeconds, TimeUser = timeSnapshot.UserProcessorTime.TotalSeconds, TimeSystem = timeSnapshot.PrivilegedProcessorTime.TotalSeconds }); }
public void BuildHistogramData() { IRandomSource rng = RandomDefaults.CreateRandomSource(0); int iters = 10_000; double[] vals = new double[iters]; for (int i = 0; i < iters; i++) { vals[i] = 1000.0 + (rng.NextDouble() * 2.0) - 1.0; } // Construct a histogram on the array of values. HistogramData hist = NumericsUtils.BuildHistogramData(vals, 8); // We expect samples to be approximately evenly distributed over the histogram buckets. for (int i = 0; i < hist.FrequencyArray.Length; i++) { Assert.True(hist.FrequencyArray[i] > (iters / 8) * 0.8); } // We expect min and max to be close to 999 and 1001 respectively. Assert.True(hist.Max <= (1001) && hist.Max > (1001) - 0.1); Assert.True(hist.Min >= (999) && hist.Min < (999) + 0.1); }
public void TestGaussianDelta() { var strategy = DeltaWeightMutationStrategy.CreateGaussianDeltaStrategy( new SelectAllStrategy(), 1.0); IRandomSource rng = RandomDefaults.CreateRandomSource(0); int iters = 100_000; double[] weightArr = new double[iters]; for (int i = 0; i < iters; i++) { weightArr[i] = 1000.0; } strategy.Invoke(weightArr, rng); // Construct a histogram on the array of weights. HistogramData hist = NumericsUtils.BuildHistogramData(weightArr, 8); // We expect min and max to be close to be about -995.5 and +1004.5 respectively // (but they could be further from the mean of 1000, with no bound). Assert.IsTrue(hist.Max >= 1002.0); Assert.IsTrue(hist.Min <= 998.0); TestMean(weightArr, 1000.0); }
public void GaussianReset() { var strategy = ResetWeightMutationStrategy <double> .CreateGaussianResetStrategy( new SelectAllStrategy(), 1.0); IRandomSource rng = RandomDefaults.CreateRandomSource(0); int iters = 100_000; double[] weightArr = new double[iters]; for (int i = 0; i < iters; i++) { weightArr[i] = 123.0; } strategy.Invoke(weightArr, rng); // Construct a histogram on the array of weights. HistogramData hist = NumericsUtils.BuildHistogramData(weightArr, 8); // We expect min and max to be close to be about -4.5 and +4.5 respectively // (but they could be higher in magnitude, with no bound). Assert.True(hist.Max >= 3.8); Assert.True(hist.Min <= -3.8); TestMean(weightArr); TestStandardDeviation(weightArr); }
public void TestUniformDelta() { double weightScale = 5.0; var strategy = DeltaWeightMutationStrategy.CreateUniformDeltaStrategy( new SelectAllStrategy(), weightScale); IRandomSource rng = RandomDefaults.CreateRandomSource(0); int iters = 10_000; double[] weightArr = new double[iters]; for (int i = 0; i < iters; i++) { weightArr[i] = 1000.0; } strategy.Invoke(weightArr, rng); // Construct a histogram on the array of weights. HistogramData hist = NumericsUtils.BuildHistogramData(weightArr, 8); // We expect samples to be approximately evenly distributed over the histogram buckets. for (int i = 0; i < hist.FrequencyArray.Length; i++) { Assert.IsTrue(hist.FrequencyArray[i] > (iters / 8) * 0.8); } // We expect min and max to be close to 1000-weightScale and 1000+weightScale respectively. Assert.IsTrue(hist.Max <= (1000 + weightScale) && hist.Max > (1000 + weightScale) - 0.1); Assert.IsTrue(hist.Min >= (1000 - weightScale) && hist.Min < (1000 - weightScale) + 0.1); }
//Ładowanie fomratki private void Form2_Load(object sender, EventArgs e) { //Inicjalizacja obiektów niezbędnych do działania formatki pictureBox1.Image = ImageToShow; pictureBox1.SizeMode = PictureBoxSizeMode.AutoSize; pictureOriginal = (Bitmap)ImageToShow.Clone(); directBitmap = new DirectBitmap(pictureOriginal); directBitmapOrig = new DirectBitmap(directBitmap); directBitmapPost = new DirectBitmap(directBitmap); histogramDataLineRGB = new HistogramData(); directBitmapOrig.generateHSVBits(); formCaller.histogramDataRGBMainProp = directBitmap.generateHistogram(); formCaller.histogramDataHSVProp = directBitmap.generateHistogramHSV(); projectEngine = new ProjectEngine(); formCaller.ser1.IsVisibleInLegend = true; formCaller.ser2.IsVisibleInLegend = true; formCaller.ser3.IsVisibleInLegend = true; formCaller.seriesHExt.IsVisibleInLegend = true; formCaller.seriesSExt.IsVisibleInLegend = true; formCaller.seriesVExt.IsVisibleInLegend = true; }
public ClientStats GetStats(bool reset) { var histogramData = new HistogramData(); foreach (var hist in _threadLocalHistogram.Values) { hist.GetSnapshot(histogramData, reset); } var timeSnapshot = _timeStats.GetSnapshot(reset); if (reset) { _statsResetCount.Increment(); } _logger.LogInformation( $"[ClientRunnerImpl.GetStats] GC collection counts: gen0 {GC.CollectionCount(0)}, gen1 {GC.CollectionCount(1)}, gen2 {GC.CollectionCount(2)}, (histogram reset count:{_statsResetCount.Count}, seconds since reset: {timeSnapshot.WallClockTime.TotalSeconds})"); return(new ClientStats { Latencies = histogramData, TimeElapsed = timeSnapshot.WallClockTime.TotalSeconds, TimeUser = timeSnapshot.UserProcessorTime.TotalSeconds, TimeSystem = timeSnapshot.PrivilegedProcessorTime.TotalSeconds }); }
public ClientStats GetStats(bool reset) { var histogramData = new HistogramData(); foreach (var hist in threadLocalHistogram.Values) { hist.GetSnapshot(histogramData, reset); } var secondsElapsed = wallClockStopwatch.GetElapsedSnapshot(reset).TotalSeconds; if (reset) { statsResetCount.Increment(); } GrpcEnvironment.Logger.Info("[ClientRunnerImpl.GetStats] GC collection counts: gen0 {0}, gen1 {1}, gen2 {2}, (histogram reset count:{3}, seconds since reset: {4})", GC.CollectionCount(0), GC.CollectionCount(1), GC.CollectionCount(2), statsResetCount.Count, secondsElapsed); // TODO: populate user time and system time return(new ClientStats { Latencies = histogramData, TimeElapsed = secondsElapsed, TimeUser = 0, TimeSystem = 0 }); }
private static void InsertHistogram( HtmlRenderer htmlWriter, string title, string xAxisLabel, HistogramData data, int xAxisMaxValue, bool colllapsebyDefault = true, HtmlContentInserter content = null) { htmlWriter.InsertExpander(title, delegate() { htmlWriter.InsertLineGraph( title, "Turn", xAxisLabel, data.GetXAxis(xAxisMaxValue), data.GetYAxis(xAxisMaxValue) ); if (content != null) { content(); } }, collapseByDefault: colllapsebyDefault); }
public static void ShowHistogram(HistogramData stats) {//построение диаграммы при помощи библиотеки ZedGraph var chart = new ZedGraphControl { Dock = DockStyle.Fill }; chart.GraphPane.Title.Text = stats.Title; chart.GraphPane.XAxis.Title.Text = "X, время 25.02.2020"; chart.GraphPane.YAxis.Title.Text = "Y, бит"; chart.GraphPane.AddBar("", Enumerable.Range(0, stats.YValues.Length).Select(i => (double)i).ToArray(), stats.YValues, Color.Blue); chart.GraphPane.YAxis.Scale.MaxAuto = true; chart.GraphPane.YAxis.Scale.MinAuto = true; chart.GraphPane.XAxis.Type = AxisType.Text; chart.GraphPane.XAxis.Scale.TextLabels = stats.XLabels; chart.AxisChange(); var form = new Form { Text = stats.Title, Size = new Size(800, 600) }; form.Controls.Add(chart); form.ShowDialog(); }
private void Start() { _dataStats = GetComponent <HistogramData>(); if (_plotArea == null) { Debug.LogError("Plot area image object must be assigned"); return; } _plotAreaRect = _plotArea.GetComponent <RectTransform>(); _rect = GetComponent <RectTransform>(); _plotWidth = _rect.sizeDelta.x - Mathf.Abs(_plotAreaRect.offsetMin.x) - Mathf.Abs(_plotAreaRect.offsetMax.x); _plotHeight = _rect.sizeDelta.y - Mathf.Abs(_plotAreaRect.offsetMin.y) - Mathf.Abs(_plotAreaRect.offsetMax.y); CreatePlotElementParents(); CreateEmptyBars(); // precisions _yAxisPrecision = 5; _xAxisPrecision = 2f; CreateAxisTicks(); UpdateData(); // PERHAPS THIS SHOULD BE SOMEWHERE ELSE DOTween.SetTweensCapacity(500, 50); }
private void ReloadHistogram_InfoLabels(HistogramData fullData) { MostValue_Index.Text = " index: " + fullData.mostValueIndex; LeastValue_Index.Text = " index: " + fullData.leastValueIndex; MostValue_Quantity.Text = " quantity: " + fullData.mostValueCounter + " px"; LeastValue_Quantity.Text = " quantity: " + fullData.leastValueCounter + " px"; if (Histogram.BarColor == Color.White) { MostValue_Color.BackColor = Color.FromArgb(fullData.mostValueIndex, fullData.mostValueIndex, fullData.mostValueIndex); LeastValue_Color.BackColor = Color.FromArgb(fullData.leastValueIndex, fullData.leastValueIndex, fullData.leastValueIndex); } else if (Histogram.BarColor == Color.Red) { MostValue_Color.BackColor = Color.FromArgb(fullData.mostValueIndex, 0, 0); LeastValue_Color.BackColor = Color.FromArgb(fullData.leastValueIndex, 0, 0); } else if (Histogram.BarColor == Color.Green) { MostValue_Color.BackColor = Color.FromArgb(0, fullData.mostValueIndex, 0); LeastValue_Color.BackColor = Color.FromArgb(0, fullData.leastValueIndex, 0); } else if (Histogram.BarColor == Color.Blue) { MostValue_Color.BackColor = Color.FromArgb(0, 0, fullData.mostValueIndex); LeastValue_Color.BackColor = Color.FromArgb(0, 0, fullData.leastValueIndex); } MaxValue.Text = "Max Value: " + fullData.maxValue; MinValue.Text = "Min Value: " + fullData.minValue; }
/// <summary> /// Merges snapshot of stats into <c>mergeTo</c> and optionally resets the histogram. /// </summary> public void GetSnapshot(HistogramData mergeTo, bool reset) { lock (myLock) { GetSnapshotUnsafe(mergeTo, reset); } }
private Statistics CalculateStatistics() { Statistics result = new Statistics(); result.Diffs = GetDiffs(result); if (result.Diffs.Any()) { result.MaxValue = result.Diffs.Max(d => d.Value); result.MinValue = result.Diffs.Min(d => d.Value); result.Median = CalculateMedian(result.Diffs.Select(d => d.Value)); result.StdDeviation = CalculateStdDeviation(result.Diffs.Select(d => d.Value)); result.TotalCount = result.Diffs.Count; result.Sum = result.Diffs.Sum(d => d.Value); result.Average = result.Diffs.Average(d => d.Value); result.Frequencies = GetFrequencies(result.Diffs); HistogramData histogramData = CreateHistogram(result.Diffs); foreach (var percentile in histogramData.percentiles(5)) { PercentileRecord p = new PercentileRecord { Value = percentile.getValueIteratedTo(), Percentile = percentile.getPercentileLevelIteratedTo(), TotalCount = percentile.getTotalCountToThisValue(), Count = percentile.getCountAddedInThisIterationStep() }; result.Percentiles.Add(p); } } return(result); }
private void GetSnapshotUnsafe(HistogramData mergeTo, bool reset) { GrpcPreconditions.CheckArgument(mergeTo.Bucket.Count == 0 || mergeTo.Bucket.Count == buckets.Length); if (mergeTo.Count == 0) { mergeTo.MinSeen = min; mergeTo.MaxSeen = max; } else { mergeTo.MinSeen = Math.Min(mergeTo.MinSeen, min); mergeTo.MaxSeen = Math.Max(mergeTo.MaxSeen, max); } mergeTo.Count += count; mergeTo.Sum += sum; mergeTo.SumOfSquares += sumOfSquares; if (mergeTo.Bucket.Count == 0) { mergeTo.Bucket.AddRange(buckets); } else { for (int i = 0; i < buckets.Length; i++) { mergeTo.Bucket[i] += buckets[i]; } } if (reset) { ResetUnsafe(); } }
public static void ShowHistogram(this IImage <double> image) { Invoke(() => { var imgData = new HistogramData(image); Histogram v = new Histogram(imgData); v.Show(); }); }
public JsonResult DrawCasesBySpeciesAndYear(ADDB context, string year) { HistogramData histogramData = new HistogramData(); string[] months = { "Jan", "Feb", "Mar", "Apr", "May", "June", "July", "Aug", "Sep", "Oct", "Nov", "Dec" }; List <string> annotations = new List <string>(); histogramData.Arr = new List <List <string> >(); annotations.Add("Species"); List <string> species = context.Animals.OrderBy(x => x.Name).Select(x => x.Name).Distinct().ToList(); // very important that the order matches in both queries annotations.AddRange(species); for (int i = 0; i < months.Length; i++) { List <string> dataRow = new List <string>(); dataRow.Add(months[i]); const string rawSql = "SELECT DISTINCT Animals.Name AS Name, COUNT(Cases.PatientID) AS Dcount" + " FROM Animals, Patients, Cases " + "WHERE Patients.ID = Cases.PatientID AND " + "Patients.AnimalID = Animals.Id " + "AND " + "MONTH(Cases.DateOfCaseObserved) = @p0 " + "AND " + "YEAR(Cases.DateOfCaseObserved) = @p1 " + "GROUP BY Animals.Name " + "ORDER BY Animals.Name"; object[] p = { i + 1, year }; var query = context.Database.SqlQuery <CasesByMonth>(rawSql, p).ToList(); if (query.Count == 0) { foreach (var s in species) // if we have no results for this month set all results to 0 { dataRow.Add("0"); } } else { foreach (CasesByMonth cbm in query) // if we have results for the month populate with real data { dataRow.Add(cbm.DCount.ToString()); } } dataRow.Add(" "); //add the annotations padding histogramData.Arr.Add(dataRow); } // for loop histogramData.Annotations = annotations; return(Json(histogramData)); }
public void CalculateGcdBinaryShouldReturnTimeOfCalculation() { HistogramData gcdtime = new HistogramData(); TimeSpan time = new TimeSpan(); gcdtime.CalculateGcd(248, 364, ref time, new BinaryAlgorithm()); // The method should return the execution time of the algorithm Assert.AreNotEqual(new TimeSpan(0), time); }
/// <summary> /// Gets snapshot of stats and optionally resets the histogram. /// </summary> public HistogramData GetSnapshot(bool reset = false) { lock (myLock) { var histogramData = new HistogramData(); GetSnapshotUnsafe(histogramData, reset); return(histogramData); } }
private void ShowPostCharts_Click(object sender, EventArgs e) { HistogramData histogramData = imageProcessingEngine.hitogramsData; RedChannel.Series.Clear(); var seriesRed = new System.Windows.Forms.DataVisualization.Charting.Series { Name = isGrey ? "seriesGray" : "seriesRed", Color = isGrey ? Color.Gray : System.Drawing.Color.Red, IsVisibleInLegend = true, IsXValueIndexed = true, ChartType = SeriesChartType.Column }; var seriesGreen = new Series { Name = "seriesGreen", Color = System.Drawing.Color.Green, IsVisibleInLegend = true, IsXValueIndexed = true, ChartType = SeriesChartType.Column }; var seriesBlue = new Series { Name = "seriesBlue", Color = System.Drawing.Color.Blue, IsVisibleInLegend = true, IsXValueIndexed = true, ChartType = SeriesChartType.Column }; RedChannel.Series.Add(seriesRed); if (!isGrey) { RedChannel.Series.Add(seriesGreen); RedChannel.Series.Add(seriesBlue); } for (int i = 0; i < 256; i++) { seriesRed.Points.AddXY(i, histogramData.histoTransformed[i]); if (!isGrey) { seriesGreen.Points.AddXY(i, histogramData.greenHisto[i]); seriesBlue.Points.AddXY(i, histogramData.blueHisto[i]); } } ChartGroup.Visible = true; }
public static void ExportHistogramInCsv(HistogramData data, int depth) { StringBuilder sb = new StringBuilder(); sb.AppendLine($"Brightness;Count"); for (int i = 0; i < data.histogramData.Length; i++) { sb.AppendLine($"{i + 1};{data.histogramData[i]}"); } File.WriteAllText($"{Program.PathToTemp}/histogramData_{depth}Bands_{DateTime.Now.ToFileTime().ToString()}.csv", sb.ToString()); }
public void HistogramCalculationTimeShouldReturnTimes() { HistogramData histogramData = new HistogramData(); TimeSpan euclideanTime = new TimeSpan(); TimeSpan binaryTime = new TimeSpan(); histogramData.GetGcdCalculationTime(248, 364, ref euclideanTime, ref binaryTime); // The method should return the execution time of the algorithms Assert.AreNotEqual(new TimeSpan(0), euclideanTime); Assert.AreNotEqual(new TimeSpan(0), binaryTime); }
private HistogramData CreateHistogram(List <DiffRecord> diffs) { Histogram h = new Histogram(3600000000000L, 3); foreach (var diff in diffs) { h.recordValue((long)diff.Value); } HistogramData histogramData = h.getHistogramData(); return(histogramData); }
private static List <int> CalculateLUT(HistogramData data) { double a = 255.0 / (data.maxValue - data.minValue); List <int> result = new List <int>(new int[256]); for (int i = 0; i < 256; ++i) { result[i] = (int)(a * (i - data.minValue)); } return(result); }
private static List <int> CalculateLUT(HistogramData data, int size) { double minValue = data.minValue; List <int> result = new List <int>(new int[256]); double sum = 0; for (int i = 0; i < 256; i++) { sum += data.data[i]; result[i] = (int)(((sum - minValue) / (size - minValue)) * 255.0); } return(result); }
void updateCharts(HistogramData histogramData, Chart chartControl) { chartControl.Series.Clear(); var seriesRed = new System.Windows.Forms.DataVisualization.Charting.Series { Name = "seriesRed", Color = System.Drawing.Color.Red, IsVisibleInLegend = true, IsXValueIndexed = true, ChartType = SeriesChartType.Column }; var seriesGreen = new Series { Name = "seriesGreen", Color = System.Drawing.Color.Green, IsVisibleInLegend = true, IsXValueIndexed = true, ChartType = SeriesChartType.Column }; var seriesBlue = new Series { Name = "seriesBlue", Color = System.Drawing.Color.Blue, IsVisibleInLegend = true, IsXValueIndexed = true, ChartType = SeriesChartType.Column }; chartControl.Series.Add(seriesRed); chartControl.Series.Add(seriesGreen); chartControl.Series.Add(seriesBlue); for (int i = 0; i < 256; i++) { seriesRed.Points.AddXY(i, histogramData.redHisto[i]); seriesGreen.Points.AddXY(i, histogramData.greenHisto[i]); seriesBlue.Points.AddXY(i, histogramData.blueHisto[i]); } //ChartGroup.Visible = true; }
public HistogramData RenderHistogram(ref WriteableBitmap bmp) { var histData = new HistogramData(); int w = width, h = height, d = depth; var index = new Index3(w, h, d); var histIndex = new Index2(1000, 1000); var data = CalculationWrappers.GetHistogram(index, _datasetV.View, histIndex, histData); bmp = new WriteableBitmap(new Avalonia.PixelSize(histIndex.X, histIndex.Y), new Vector(1, 1), Avalonia.Platform.PixelFormat.Rgba8888); using (var buf = bmp.Lock()) { IntPtr ptr = buf.Address; Marshal.Copy((int[])(object)data, 0, ptr, data.Length); } return(histData); }
private static void InsertHistogramIntegrated( HtmlRenderer htmlWriter, string title, string xAxisLabel, HistogramData data, int xAxisMaxValue) { htmlWriter.InsertExpander(title, delegate() { htmlWriter.InsertLineGraph( title, "Turn", xAxisLabel, data.GetXAxis(xAxisMaxValue), data.GetYAxisIntegrated(xAxisMaxValue) ); }, collapseByDefault: true); }
private HistogramData GetSnapshotUnsafe(bool reset) { var data = new HistogramData { Count = count, Sum = sum, SumOfSquares = sumOfSquares, MinSeen = min, MaxSeen = max, Bucket = { buckets } }; if (reset) { ResetUnsafe(); } return(data); }
private HistogramData GetSnapshotUnsafe(bool reset) { var data = new HistogramData { Count = count, Sum = sum, SumOfSquares = sumOfSquares, MinSeen = min, MaxSeen = max, Bucket = { buckets } }; if (reset) { ResetUnsafe(); } return data; }
/// <summary> /// Calculates Data to draw in histogram /// </summary> private void CalculateHistogramData() { InitChartData(); for (int bar = 0; bar < Data.Bars; bar++) { int positions = StatsBuffer.Positions(bar); for (int pos = 0; pos < positions; pos++) { if (!IsTrade(StatsBuffer.PosTransaction(bar, pos))) continue; double result = GetProfit(bar, pos); var index = (int) Math.Round(result); bool isIndex = chartData.ContainsKey(index); int count = isIndex ? chartData[index].TradesCount + 1 : 1; double total = isIndex ? chartData[index].TotalResult + result : result; var data = new HistogramData {TradesCount = count, Result = result, TotalResult = total}; if (isIndex) chartData[index] = data; else chartData.Add(index, data); SetMinMaxValues(index, count, total); } } chartData.Sort(); }
private static IEnumerable<JsonProperty> ToJsonProperties(HistogramData histogram) { bool hasUserValues = histogram.LastUserValue != null || histogram.MinUserValue != null || histogram.MaxUserValue != null; yield return new JsonProperty("LastValue", histogram.LastValue); if (hasUserValues) { yield return new JsonProperty("LastUserValue", histogram.LastUserValue); } yield return new JsonProperty("Min", histogram.Min); if (hasUserValues) { yield return new JsonProperty("MinUserValue", histogram.MinUserValue); } yield return new JsonProperty("Mean", histogram.Mean); if (hasUserValues) { yield return new JsonProperty("MaxUserValue", histogram.MaxUserValue); } yield return new JsonProperty("StdDev", histogram.StdDev); yield return new JsonProperty("Median", histogram.Median); yield return new JsonProperty("Percentile75", histogram.Percentile75); yield return new JsonProperty("Percentile95", histogram.Percentile95); yield return new JsonProperty("Percentile98", histogram.Percentile98); yield return new JsonProperty("Percentile99", histogram.Percentile99); yield return new JsonProperty("Percentile999", histogram.Percentile999); yield return new JsonProperty("SampleSize", histogram.SampleSize); }