New Version 6.0!

Try it for free with our fully functional 60-day trial version.

Download now!

QuickStart Samples

Continuous Distributions QuickStart Sample (C#)

Illustrates how to use the classes that represent continuous probability distributions in the Extreme.Statistics.Distributions namespace in C#.

Visual Basic code F# code IronPython code Back to QuickStart Samples

using System;

using Extreme.Mathematics.Random;
using Extreme.Statistics;
using Extreme.Statistics.Distributions;

namespace Extreme.Statistics.Quickstart.CSharp
{
    /// <summary>
    /// Demonstrates how to use classes that implement
    /// continuous probabililty distributions.
    /// </summary>
    class ContinuousDistributions
    {
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        [STAThread]
        static void Main(string[] args)
        {
            // This QuickStart Sample demonstrates the capabilities of
            // the classes that implement continuous probability distributions.
            // These classes inherit from the ContinuousDistribution class.
            //
            // For an illustration of classes that implement discrete probability
            // distributions, see the DiscreteDistributions QuickStart Sample.
            // 
            // We illustrate the properties and methods of continuous distribution
            // using a Weibull distribution. The same properties and methods
            // apply to all other continuous distributions.

            // 
            // Constructing distributions
            //

            // Most distributions have one or more parameters with different definitions.
            //
            // The location parameter is always related to the mean of the distribution.
            // When omitted, its default value is zero.
            //
            // The scale parameter is always directly related to the standard deviation.
            // A larger scale parameter means that the distribution is wider.
            // When omitted, its default value is one.

            // The Weibull distribution has three constructors. The most complete
            // constructor takes a location, scale, and shape parameter.
            WeibullDistribution weibull = new WeibullDistribution(3, 2, 3);

            //
            // Basic statistics
            //

            // The Mean property returns the mean of the distribution:
            Console.WriteLine("Mean:                 {0:F5}", weibull.Mean);

            // The Variance and StandardDeviation are also available:
            Console.WriteLine("Variance:             {0:F5}", weibull.Variance);
            Console.WriteLine("Standard deviation:   {0:F5}", weibull.StandardDeviation);
            // The inter-quartile range is another measure of scale:
            Console.WriteLine("Inter-quartile range: {0:F5}", weibull.InterQuartileRange);

            // As are the skewness:
            Console.WriteLine("Skewness:             {0:F5}", weibull.Skewness);

            // The Kurtosis property returns the kurtosis supplement.
            // The Kurtosis property for the normal distribution returns zero.
            Console.WriteLine("Kurtosis:             {0:F5}", weibull.Kurtosis);
            Console.WriteLine();

            //
            // Distribution functions
            //

            // The (cumulative) distribution function (CDF) is implemented by the
            // DistributionFunction method:
            Console.WriteLine("CDF(4.5) =            {0:F5}", weibull.DistributionFunction(4.5));

            // Its complement is the survivor function:
            Console.WriteLine("SDF(4.5) =            {0:F5}", weibull.SurvivorDistributionFunction(4.5));

            // While its inverse is given by the InverseDistributionFunction method:
            Console.WriteLine("Inverse CDF(0.4) =    {0:F5}", weibull.InverseDistributionFunction(0.4));

            // The probability density function (PDF) is also available:
            Console.WriteLine("PDF(4.5) =            {0:F5}", weibull.ProbabilityDensityFunction(4.5));
            
            // The Probability method returns the probability that a variate lies between two values:
            Console.WriteLine("Probability(4.5, 5.5) = {0:F5}", weibull.Probability(4.5, 5.5));
            Console.WriteLine();

            //
            // Random variates
            //

            // The Sample method returns a single random variate 
            // using the specified random number generator:
            System.Random rng = new MersenneTwister();
            double x = weibull.Sample(rng);
            // The SampleInto method fills an array or vector with
            // random variates. It has several overloads:
            double[] xArray = new double[100];
            // 1. Fill all values:
            weibull.SampleInto(rng, xArray);
            // 2. Fill only a range (start index and length are supplied)
            weibull.SampleInto(rng, xArray, 20, 50);
            // The same two options are available with a DenseVector
            // instead of a double array.

            // The GetExpectedHistogram method returns a Histogram that contains the
            // expected number of samples in each bin, given the total number of samples.
            // The bins are specified by lower and upper bounds and number of bins:
            var h = weibull.GetExpectedHistogram(3.0, 10.0, 5, 100);
            Console.WriteLine("Expected distribution of 100 samples:");
            Console.WriteLine(h.ToString());
            Console.WriteLine();

            // or by supplying an array of boundaries:
            h = weibull.GetExpectedHistogram(new double[] {3.0, 5.2, 7.4, 9.6, 11.8}, 100);
            Console.WriteLine("Expected distribution of 100 samples:");
            Console.WriteLine(h.ToString());

            Console.Write("Press any key to exit.");
            Console.ReadLine();
        }
    }
}