示例#1
0
        public void TestCreateDistributionData()
        {
            IDistributionData distributionData =
                DistributionData.Create(7.7, 10, 1.1, 9.9, 32.2, new List <long>()
            {
                4L, 1L, 5L
            });

            Assert.InRange(distributionData.Mean, 7.7 - TOLERANCE, 7.7 + TOLERANCE);
            Assert.Equal(10, distributionData.Count);
            Assert.InRange(distributionData.Min, 1.1 - TOLERANCE, 1.1 + TOLERANCE);
            Assert.InRange(distributionData.Max, 9.9 - TOLERANCE, 9.9 + TOLERANCE);
            Assert.InRange(distributionData.SumOfSquaredDeviations, 32.2 - TOLERANCE, 32.2 + TOLERANCE);
            Assert.Equal(4, distributionData.BucketCounts[0]);
            Assert.Equal(1, distributionData.BucketCounts[1]);
            Assert.Equal(5, distributionData.BucketCounts[2]);
        }
示例#2
0
        public static Google.Api.Distribution CreateDistribution(
            IDistributionData distributionData,
            IBucketBoundaries bucketBoundaries)
        {
            var bucketOptions = bucketBoundaries.ToBucketOptions();
            var distribution  = new Google.Api.Distribution
            {
                BucketOptions         = bucketOptions,
                BucketCounts          = { CreateBucketCounts(distributionData.BucketCounts) },
                Count                 = distributionData.Count,
                Mean                  = distributionData.Mean,
                SumOfSquaredDeviation = distributionData.SumOfSquaredDeviations,
                Range                 = new Range {
                    Max = distributionData.Max, Min = distributionData.Min
                },
            };

            return(distribution);
        }
示例#3
0
        private static void AssertDistributionDataEquals(
            IDistributionData expected,
            IDistributionData actual,
            double tolerance)
        {
            Assert.InRange(actual.Mean, expected.Mean - tolerance, expected.Mean + tolerance);
            Assert.Equal(expected.Count, actual.Count);
            Assert.InRange(actual.SumOfSquaredDeviations, expected.SumOfSquaredDeviations - tolerance, expected.SumOfSquaredDeviations + tolerance);

            if (expected.Max == Double.NegativeInfinity &&
                expected.Min == Double.PositiveInfinity)
            {
                Assert.True(Double.IsNegativeInfinity(actual.Max));
                Assert.True(Double.IsPositiveInfinity(actual.Min));
            }
            else
            {
                Assert.InRange(actual.Max, expected.Max - tolerance, expected.Max + tolerance);
                Assert.InRange(actual.Min, expected.Min - tolerance, expected.Min + tolerance);
            }

            Assert.Equal(RemoveTrailingZeros(expected.BucketCounts), RemoveTrailingZeros((actual).BucketCounts));
        }