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.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 Random.MersenneTwister();
			double x = weibull.Sample(rng);
			// The Sample method fills an array or vector with
			// random variates. It has several overloads:
			double[] xArray = new double[100];
			// 1. Fill all values:
			weibull.Sample(rng, xArray);
			// 2. Fill only a range (start index and length are supplied)
			weibull.Sample(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:
			Histogram h = weibull.GetExpectedHistogram(3.0, 10.0, 5, 100);
			Console.WriteLine("Expected distribution of 100 samples:");
			foreach(HistogramBin bin in h.Bins)
				Console.WriteLine("Between {0} and {1} -> {2}", bin.LowerBound, bin.UpperBound, bin.Value);
			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:");
			foreach(HistogramBin bin in h.Bins)
				Console.WriteLine("Between {0} and {1} -> {2}", bin.LowerBound, bin.UpperBound, bin.Value);

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