コード例 #1
0
        private static void WriteHistogramToSheet(Worksheet sheet, IEnumerable<double> data)
        {
            // Throw delivery time into the histogram
            Histogram hist = new Histogram(data, 60);

            sheet[0, 0].Value = "Count";
            sheet[0, 1].Value = "Width";
            sheet[0, 2].Value = "LowerBound";
            sheet[0, 3].Value = "UpperBound";

            // Write the histogram data out to Excel
            for (int i = 1; i < hist.BucketCount; i++)
            {
                sheet[i, 0].Value = hist[i].Count;
                sheet[i, 1].Value = hist[i].Width;
                sheet[i, 2].Value = hist[i].LowerBound;
                sheet[i, 3].Value = hist[i].UpperBound;
            }

            // Plot the histogram data
            Charts charts = sheet.Charts;
            Anchor anchor = sheet.CreateAnchor(4, 6, 0, 0);
            Chart chart = charts.CreateChart(ChartType.Column.Clustered, anchor);
            SeriesCollection collection = chart.SeriesCollection;
            collection.CategoryData = String.Format("{0}!{1}:{2}", sheet.Name, sheet.Cells[1, 2].Name, sheet.Cells[50, 2].Name);
            Series series = collection.CreateSeries(String.Format("{0}!{1}:{2}", sheet.Name, sheet.Cells[1, 0].Name, sheet.Cells[50, 0].Name));
        }
コード例 #2
0
 public static MathNetHistogram AddBuckets(this MathNetHistogram histogram, IEnumerable <Bucket> buckets)
 {
     foreach (var bucket in buckets)
     {
         histogram.AddBucket(bucket);
     }
     return(histogram);
 }
コード例 #3
0
 private static IEnumerable<Bucket> Enumerate(Histogram histogram)
 {
     for (var i = 0; i < histogram.BucketCount; i++)
     {
         var bucket = histogram[i];
         yield return bucket;
     }
 }
コード例 #4
0
        public void CanCreateCategoricalFromHistogram()
        {
            double[] smallDataset = { 0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5 };
            Histogram hist = new Histogram(smallDataset, 10, 0.0, 10.0);
            var m = new Categorical(hist);

            for (int i = 0; i <= m.Maximum; i++)
            {
                AssertEx.AreEqual<double>(1.0/10.0, m.P[i]);
            }
        }
コード例 #5
0
        public void HistogramDataContractSerializationTest()
        {
            var expected = new Histogram(new[] { 1.0, 2.0, 3.0, 4.0 }, 2);

            var serializer = new DataContractSerializer(typeof(Histogram));
            var stream = new MemoryStream();
            serializer.WriteObject(stream, expected);

            stream.Position = 0;
            var actual = (Histogram)serializer.ReadObject(stream);

            Assert.That(actual.BucketCount, Is.EqualTo(expected.BucketCount));
            Assert.That(actual.DataCount, Is.EqualTo(expected.DataCount));
            Assert.That(actual.LowerBound, Is.EqualTo(expected.LowerBound));
            Assert.That(actual[0].Width, Is.EqualTo(expected[0].Width));
            Assert.That(actual[0].UpperBound, Is.EqualTo(expected[0].UpperBound));
        }
コード例 #6
0
ファイル: Form1.cs プロジェクト: tobira-code/Qiita
        public Form1()
        {
            InitializeComponent();

            // clear
            chart1.Series.Clear();
            chart1.ChartAreas.Clear();
            chart1.Titles.Clear();

            Title title1 = new Title("Histgram");

            // series
            Series seriesColumn = new Series();
            seriesColumn.LegendText = "Histgram";
            seriesColumn.ChartType = SeriesChartType.Column;

            // 正規乱数を作る
            mRand = new Random(DateTime.Now.Millisecond);
            int nData = 10000;
            double[] data = new double[nData];
            for (int i = 0; i < nData; i++)
            {
                // Box-Muller法で一様乱数から正規乱数を作る
                data[i] = boxmuller(mRand, 0 /* average */ , 10 /* sigma */);
            }

            // ヒストグラムを作る
            int nBuckets = 10;
            Histogram hist = new Histogram(data, nBuckets, -50 /* lower */, 50 /* upper */);

            for (int i = 0; i < nBuckets; i++)
            {
                double mid = Math.Round((hist[i].UpperBound+hist[i].LowerBound)/2, 1);
                seriesColumn.Points.Add(new DataPoint(mid, hist[i].Count));
            }

            // chartarea
            ChartArea area1 = new ChartArea();
            area1.AxisX.Title = "Value";
            area1.AxisY.Title = "Frequency";

            chart1.Titles.Add(title1);
            chart1.ChartAreas.Add(area1);
            chart1.Series.Add(seriesColumn);
        }
コード例 #7
0
        /// <summary>
        /// Initializes a new instance of the Categorical class from a histogram <paramref name="h"/>. The distribution 
        /// will not be automatically updated when the histogram changes. The categorical distribution will have
        /// one value for each bucket and a probability for that value proportional to the bucket count.
        /// </summary>
        /// <param name="histogram">The histogram from which to create the categorical variable.</param>
        public Categorical(Histogram histogram)
        {
            if (histogram == null)
            {
                throw new ArgumentNullException("Cannot create a categorical variable from a null histogram.");
            }

            // The probability distribution vector.
            double[] p = new double[histogram.BucketCount];

            // Fill in the distribution vector.
            for (int i = 0; i < histogram.BucketCount; i++)
            {
                p[i] = histogram[i].Count;
            }

            SetParameters(p);
            RandomSource = new System.Random();
        }
コード例 #8
0
ファイル: StatisticsController.cs プロジェクト: c0d3m0nky/mty
        public object NormalDistSample(int mean, int stddev, int size, int nbuckets)
        {
            var normal = new Normal(mean, stddev);

            var data = new double[size];
            for (var i = 0; i < data.Length; i++)
            {
                data[i] = normal.Sample();
            }

            var histogram = new Histogram(data, nbuckets);

            var buckets = new List<Bucket>();

            for (var i = 0; i < histogram.BucketCount; i++)
            {
                buckets.Add(histogram[i]);
            }

            return buckets.Select(x=> new {lowerBound = x.LowerBound, upperBound = x.UpperBound, count = x.Count}).ToList();
        }
コード例 #9
0
 public void CanCreateEqualSpacedHistogram()
 {
     var h = new Histogram(new double[] { 1.0, 5.0, 10.0 }, 2);
 }
コード例 #10
0
        /// <summary>
        /// Vapnik Chervonenkis test.
        /// </summary>
        /// <param name="epsilon">The error we are willing to tolerate.</param>
        /// <param name="delta">The error probability we are willing to tolerate.</param>
        /// <param name="s">The samples to use for testing.</param>
        /// <param name="dist">The distribution we are testing.</param>
        public static void VapnikChervonenkisTest(double epsilon, double delta, IEnumerable<double> s, IUnivariateDistribution dist)
        {
            // Using VC-dimension, we can bound the probability of making an error when estimating empirical probability
            // distributions. We are using Theorem 2.41 in "All Of Nonparametric Statistics".
            // http://books.google.com/books?id=MRFlzQfRg7UC&lpg=PP1&dq=all%20of%20nonparametric%20statistics&pg=PA22#v=onepage&q=%22shatter%20coe%EF%AC%83cients%20do%20not%22&f=false .</para>
            // For intervals on the real line the VC-dimension is 2.
            double n = s.Count();
            Assert.Greater(n, Math.Ceiling(32.0 * Math.Log(16.0 / delta) / epsilon / epsilon));

            var histogram = new Histogram(s, NumberOfBuckets);
            for (var i = 0; i < NumberOfBuckets; i++)
            {
                var p = dist.CumulativeDistribution(histogram[i].UpperBound) - dist.CumulativeDistribution(histogram[i].LowerBound);
                var pe = histogram[i].Count / n;
                Assert.Less(Math.Abs(p - pe), epsilon, dist.ToString());
            }
        }
コード例 #11
0
        public void SmallValuesManyBucketsHistogramWithBounds()
        {
           var hist = new Histogram(_smallValueDataset, 100, 0.0, 10e-22);

           Assert.AreEqual(100, hist.BucketCount);
           Assert.AreEqual(0.0, hist.LowerBound);
           Assert.AreEqual(10.0e-22, hist.UpperBound);
        }
コード例 #12
0
        public void SmallValuesHistogramWithBounds()
        {
           var hist = new Histogram(_smallValueDataset, 10, 0.0, 10e-22);

           Assert.AreEqual(10, hist.BucketCount);

           for (var i = 0; i < 10; i++)
           {
              Assert.AreEqual(1.0, hist[i].Count);
           }

           Assert.AreEqual(0.0, hist.LowerBound);
           Assert.AreEqual(10.0e-22, hist.UpperBound);
        }
コード例 #13
0
        /// <summary>
        /// Returns the optimal squared freedom histogram.
        /// </summary>
        public static Histogram OptimalSquaredFreedom(int histSize, ICollection <double> distribution)
        {
            if (distribution.Count < Math.Max(histSize, 2))
            {
                throw new ArgumentException(Properties.LocalStrings.InvalidOperationHistogramNotEnoughPoints);
            }

            // "values" contains the sorted distribution.
            double[] values = new double[distribution.Count];
            distribution.CopyTo(values, 0);
            Array.Sort(values);

            // 'optimalCost[i,k]' contains the optimal costs for an
            // histogram with the 'i+1' first values and 'k' buckets.
            double[,] optimalCost = new double[values.Length, histSize];

            // 'lastBucketIndex[i,k]' contains the index of the first
            // value of the last bucket for optimal histogram comprising
            // the 'i+1' first values and 'k' buckets.
            int[,] lastBucketIndex = new int[values.Length, histSize];

            // "One bucket" histograms initialization
            for (int i = 0; i < values.Length; i++)
            {
                optimalCost[i, 0] =
                    (values[i] - values[0]) * (values[i] - values[0]) * (i + 1);
            }

            // "One value per bucket" histograms initialization
            for (int k = 0; k < histSize; k++)
            {
                // optimalCost[k, k] = 0;
                lastBucketIndex[k, k] = k;
            }

            // ----- Dynamic programming part -----

            // Loop on the number of buckets
            // (note that there are 'k+1' buckets)
            for (int k = 1; k < histSize; k++)
            {
                // Loop on the number of considered values
                // (note that there are 'i+1' considered values)
                for (int i = k; i < values.Length; i++)
                {
                    optimalCost[i, k] = double.PositiveInfinity;

                    // Loop for finding the optimal boundary of the last bucket
                    // ('j+1' is the index of the first value in the last bucket)
                    for (int j = (k - 1); j < i; j++)
                    {
                        double currentCost =
                            optimalCost[j, k - 1]
                            + ((values[i] - values[j + 1]) * (values[i] - values[j + 1]) * (i - j));

                        if (currentCost < optimalCost[i, k])
                        {
                            optimalCost[i, k]     = currentCost;
                            lastBucketIndex[i, k] = j + 1;
                        }
                    }
                }
            }

            // ----- Reconstitution of the histogram -----
            Histogram histogram = new Histogram();
            int       index     = values.Length - 1;

            for (int k = (histSize - 1); k >= 0; k--)
            {
                histogram.Add(new Bucket(
                                  values[lastBucketIndex[index, k]],
                                  values[index],
                                  index - lastBucketIndex[index, k] + 1));

                index = lastBucketIndex[index, k] - 1;
            }

            return(histogram);
        }
コード例 #14
0
        /// <summary>
        /// Returns the optimal dispersion histogram.
        /// </summary>
        public static Histogram OptimalDispersion(int bucketCount, ICollection <double> distribution)
        {
            if (distribution.Count < Math.Max(bucketCount, 2))
            {
                throw new ArgumentException(Properties.LocalStrings.InvalidOperationHistogramNotEnoughPoints);
            }

            // "values" contains the sorted distribution.
            double[] values = new double[distribution.Count];
            distribution.CopyTo(values, 0);
            Array.Sort(values);

            // 'optimalCost[i,k]' contains the optimal costs for an
            // histogram with the 'i+1' first values and 'k' buckets.
            double[,] optimalCost = new double[values.Length, bucketCount];

            // 'lastBucketIndex[i,k]' contains the index of the first
            // value of the last bucket for optimal histogram comprising
            // the 'i+1' first values and 'k' buckets.
            int[,] lastBucketIndex = new int[values.Length, bucketCount];

            // 'prefixSum[i]' contains the sum of the 'i-1' first values.
            double[] prefixSum = new double[values.Length + 1];

            // Initialization of the prefix sums
            for (int i = 0; i < values.Length; i++)
            {
                prefixSum[i + 1] = prefixSum[i] + values[i];
            }

            // "One bucket" histograms initialization
            for (int i = 0, avg = 0; i < values.Length; i++)
            {
                while ((avg + 1) < values.Length &&
                       values[avg + 1] < prefixSum[i + 1] / (i + 1))
                {
                    avg++;
                }

                optimalCost[i, 0] =
                    prefixSum[i + 1]
                    - (2 * prefixSum[avg + 1])
                    + (((2 * avg) - i + 1) * (prefixSum[i + 1] / (i + 1)));
            }

            // "One value per bucket" histograms initialization
            for (int k = 0; k < bucketCount; k++)
            {
                // optimalCost[k, k] = 0;
                lastBucketIndex[k, k] = k;
            }

            // ----- Dynamic programming part -----

            // Loop on the number of buckets
            // (note that there are 'k+1' buckets)
            for (int k = 1; k < bucketCount; k++)
            {
                // Loop on the number of considered values
                // (note that there are 'i+1' considered values)
                for (int i = k; i < values.Length; i++)
                {
                    optimalCost[i, k] = double.PositiveInfinity;

                    // Loop for finding the optimal boundary of the last bucket
                    // ('j+1' is the index of the first value in the last bucket)
                    for (int j = (k - 1), avg = (k - 1); j < i; j++)
                    {
                        while ((avg + 1) < values.Length &&
                               values[avg + 1] < (prefixSum[i + 1] - prefixSum[j + 1]) / (i - j))
                        {
                            avg++;
                        }

                        double currentCost =
                            optimalCost[j, k - 1]
                            + prefixSum[i + 1]
                            + prefixSum[j + 1]
                            - (2 * prefixSum[avg + 1])
                            + (((2 * avg) - i - j) * (prefixSum[i + 1] - prefixSum[j + 1]) / (i - j));

                        if (currentCost < optimalCost[i, k])
                        {
                            optimalCost[i, k]     = currentCost;
                            lastBucketIndex[i, k] = j + 1;
                        }
                    }
                }
            }

            // ----- Reconstitution of the histogram -----
            Histogram histogram = new Histogram();
            int       index     = values.Length - 1;

            for (int k = (bucketCount - 1); k >= 0; k--)
            {
                histogram.Add(new Bucket(
                                  values[lastBucketIndex[index, k]],
                                  values[index],
                                  index - lastBucketIndex[index, k] + 1));

                index = lastBucketIndex[index, k] - 1;
            }

            return(histogram);
        }
コード例 #15
0
ファイル: Histogram.cs プロジェクト: maxbruecken/Usus.NET
 private void FillHistogram()
 {
     _histogram = new MathNetHistogram();
     _histogram.AddBuckets(For(Numbers)).AddData(Numbers);
 }
コード例 #16
0
 public void CanCreateEqualSpacedHistogramWithGivenLowerAndUpperBound()
 {
     var h = new Histogram(new double[] { 1.0, 5.0, 10.0 }, 2, 0.0, 20.0);
 }
コード例 #17
0
        /// <summary>
        /// Initializes a new instance of the Categorical class from a <paramref name="histogram"/>. The distribution
        /// will not be automatically updated when the histogram changes. The categorical distribution will have
        /// one value for each bucket and a probability for that value proportional to the bucket count.
        /// </summary>
        /// <param name="histogram">The histogram from which to create the categorical variable.</param>
        public Categorical(Histogram histogram)
        {
            if (histogram == null)
            {
                throw new ArgumentNullException("histogram");
            }

            // The probability distribution vector.
            var p = new double[histogram.BucketCount];

            // Fill in the distribution vector.
            for (var i = 0; i < histogram.BucketCount; i++)
            {
                p[i] = histogram[i].Count;
            }

            _random = SystemRandomSource.Default;

            if (Control.CheckDistributionParameters && !IsValidProbabilityMass(p))
            {
                throw new ArgumentException(Resources.InvalidDistributionParameters);
            }

            // Extract unnormalized cumulative distribution
            _cdfUnnormalized = new double[p.Length];
            _cdfUnnormalized[0] = p[0];
            for (int i1 = 1; i1 < p.Length; i1++)
            {
                _cdfUnnormalized[i1] = _cdfUnnormalized[i1 - 1] + p[i1];
            }

            // Extract normalized probability mass
            var sum = _cdfUnnormalized[_cdfUnnormalized.Length - 1];
            _pmfNormalized = new double[p.Length];
            for (int i2 = 0; i2 < p.Length; i2++)
            {
                _pmfNormalized[i2] = p[i2]/sum;
            }
        }
コード例 #18
0
 public void CanCreateEmptyHistogram()
 {
     var h = new Histogram();
 }
コード例 #19
0
        /// <summary>
        /// Initializes a new instance of the Multinomial class from histogram <paramref name="h"/>. The distribution will
        /// not be automatically updated when the histogram changes.
        /// </summary>
        /// <param name="h">Histogram instance</param>
        /// <param name="n">The number of trials.</param>
        /// <exception cref="ArgumentOutOfRangeException">If any of the probabilities are negative or do not sum to one.</exception>
        /// <exception cref="ArgumentOutOfRangeException">If <paramref name="n"/> is negative.</exception>
        public Multinomial(Histogram h, int n)
        {
            if (h == null)
            {
                throw new ArgumentNullException("h");
            }

            // The probability distribution vector.
            var p = new double[h.BucketCount];

            // Fill in the distribution vector.
            for (var i = 0; i < h.BucketCount; i++)
            {
                p[i] = h[i].Count;
            }

            SetParameters(p, n);
            RandomSource = MersenneTwister.Default;
        }
コード例 #20
0
 public void CanAddDataList()
 {
     var h = new Histogram(new double[] { 1.0, 5.0, 10.0 }, 2);
     h.AddData(new double[] { 7.0, 8.0} );
     Assert.AreEqual(3, h[1].Count);
 }
コード例 #21
0
 public void CanAddDataSingle()
 {
     var h = new Histogram(new double[] { 1.0, 5.0, 10.0 }, 2);
     h.AddData(7.0);
     Assert.AreEqual(2, h[1].Count);
 }
コード例 #22
0
 public void AddDataIncreasesUpperBound()
 {
     var h = new Histogram(new double[] { 1.0, 5.0, 10.0 }, 2);
     h.AddData(20.0);
     Assert.AreEqual(2, h[1].Count);
 }
コード例 #23
0
 public void CanAddBucket()
 {
     var h = new Histogram();
     h.AddBucket(new Bucket(0.0, 1.0));
 }
コード例 #24
0
        public void ValidateItem()
        {
            var h = new Histogram();
            var b = new Bucket(0.0, 1.0);
            var c = new Bucket(3.0, 20.0);
            h.AddBucket(b);
            h.AddBucket(c);
            h.AddBucket(new Bucket(1.0, 2.0));
            h.AddBucket(new Bucket(2.0, 3.0));
            h.AddBucket(new Bucket(20.0, Double.PositiveInfinity));

            Assert.AreEqual(b, h[0]);
            Assert.AreEqual(c, h[3]);
        }
コード例 #25
0
 public void CanGetBucketIndexOf(double x, double i)
 {
     var h = new Histogram();
     h.AddBucket(new Bucket(0.0, 1.0));
     h.AddBucket(new Bucket(1.0, 2.0));
     h.AddBucket(new Bucket(2.0, 3.0));
     h.AddBucket(new Bucket(3.0, 20.0));
     h.AddBucket(new Bucket(20.0, Double.PositiveInfinity));
     Assert.AreEqual(i, h.GetBucketIndexOf(x));
 }
コード例 #26
0
        public void SmallDatasetHistogramWithBounds()
        {
            Histogram hist = new Histogram(smallDataset, 10, 0.0, 10.0);

            Assert.AreEqual(10, hist.BucketCount);

            for (int i = 0; i < 10; i++)
            {
                Assert.AreEqual(1.0, hist[i].Count);
            }

            Assert.AreEqual(0.0, hist.LowerBound);
            Assert.AreEqual(10.0, hist.UpperBound);
        }
コード例 #27
0
        public void SmallDatasetHistogramWithoutBounds()
        {
            Histogram hist = new Histogram(smallDataset, 9);

            Assert.AreEqual(9, hist.BucketCount);

            Console.WriteLine("{0}", hist);

            for (int i = 0; i < 8; i++)
            {
                Console.WriteLine("{0} : {1}", i, hist[i].Count);
                Assert.AreEqual(1.0, hist[i].Count);
            }
            Assert.AreEqual(2.0, hist[8].Count);

            Assert.AreEqual(0.5, hist.LowerBound);
            Assert.AreEqual(9.5.Increment(), hist.UpperBound);
        }
コード例 #28
0
 public void FailCreateEqualSpacedHistogramWithNoData()
 {
     var h = new Histogram(new List<double>(), 10);
 }
コード例 #29
0
        public void CanGetTotalCount()
        {
            var h = new Histogram();
            h.AddBucket(new Bucket(0.0, 1.0, 1));
            h.AddBucket(new Bucket(1.0, 2.0, 1));
            h.AddBucket(new Bucket(2.0, 3.0, 1));
            h.AddBucket(new Bucket(3.0, 20.0, 1));
            h.AddBucket(new Bucket(20.0, Double.PositiveInfinity, 1));

            Assert.AreEqual(5, h.DataCount);
        }
コード例 #30
0
        public void CanGetBucketOf()
        {
            var h = new Histogram();
            var b = new Bucket(0.0, 1.0);
            h.AddBucket(b);
            h.AddBucket(new Bucket(1.0, 2.0));
            h.AddBucket(new Bucket(2.0, 3.0));
            h.AddBucket(new Bucket(3.0, 20.0));
            h.AddBucket(new Bucket(20.0, Double.PositiveInfinity));

            Assert.AreEqual(b, h.GetBucketOf(0.1));
        }
コード例 #31
0
        /// <summary>
        /// Initializes a new instance of the Categorical class from a <paramref name="histogram"/>. The distribution 
        /// will not be automatically updated when the histogram changes. The categorical distribution will have
        /// one value for each bucket and a probability for that value proportional to the bucket count.
        /// </summary>
        /// <param name="histogram">The histogram from which to create the categorical variable.</param>
        public Categorical(Histogram histogram)
        {
            if (histogram == null)
            {
                throw new ArgumentNullException("histogram");
            }

            // The probability distribution vector.
            var p = new double[histogram.BucketCount];

            // Fill in the distribution vector.
            for (var i = 0; i < histogram.BucketCount; i++)
            {
                p[i] = histogram[i].Count;
            }

            _random = new System.Random();
            SetParameters(p);
        }
コード例 #32
0
 public void AddDataDecreasesLowerBound()
 {
     var h = new Histogram(new double[] { 1.0, 5.0, 10.0 }, 2);
     h.AddData(0.0);
     Assert.AreEqual(3, h[0].Count);
 }
コード例 #33
0
        public void CanGetBucketCountInHistogram()
        {
            var h = new Histogram();
            h.AddBucket(new Bucket(0.0, 1.0));
            h.AddBucket(new Bucket(1.0, 2.0));
            h.AddBucket(new Bucket(2.0, 3.0));
            h.AddBucket(new Bucket(3.0, 20.0));
            h.AddBucket(new Bucket(20.0, Double.PositiveInfinity));

            Assert.AreEqual(5, h.BucketCount);
        }
コード例 #34
-1
ファイル: Histogram.cs プロジェクト: cessor/MTSS12
 private void FillHistogram()
 {
     _histogram = new Hist();
     _histogram
         .AddBuckets(For(Numbers))
         .AddData(Numbers);
 }