Wolfram Language & System Documentation Center

HistogramDistribution

HistogramDistribution[{x₁,x₂,…}]

represents the probability distribution corresponding to a histogram of the data values x_i.

HistogramDistribution[{{x₁,y₁,…},{x₂,y₂,…},…}]

represents a multivariate histogram distribution based on data values {x_i,y_i,…}.

HistogramDistribution[…,bspec]

represents a histogram distribution with bins specified by bspec.

Details

HistogramDistribution returns a DataDistribution object that can be used like any other probability distribution.
The probability density function for HistogramDistribution for a value is given by where is the number of data points in bin , is the width of bin , are bin delimiters, and is the total number of data points.
The width of each bin is computed according to the values x_i, the width according to the y_i, etc.
The following bin specifications bspec can be given:

	n	use n bins
	{w}	use bins of width w
	{min,max,w}	use bins of width w from min to max
	{{b₁,b₂,…}}	use bins [b₁,b₂),[b₂,b₃),…
	Automatic	determine bin widths automatically
	"name"	use a named binning method
	fw	apply fw to get an explicit bin specification {b₁,b₂,…}
	{xspec,yspec,…}	give different x, y, etc. specifications

Possible named binning methods include:

	"FreedmanDiaconis"	twice the interquartile range divided by the cube root of sample size
	"Knuth"	balance likelihood and prior probability of a piecewise uniform model
	"Scott"	asymptotically minimize the mean square error
	"Sturges"	compute the number of bins based on the length of data
	"Wand"	one-level recursive approximate Wand binning

The probability density for value in a histogram distribution is a piecewise constant function.
HistogramDistribution can be used with such functions as Mean, CDF, and RandomVariate.

Examples

open all close all

Basic Examples (2)

Create a histogram distribution of univariate data:

Wolfram Language code: 𝒟 = HistogramDistribution[RandomVariate[NormalDistribution[], 10 ^ 3]];

Use the resulting distribution to perform analysis, including visualizing distribution functions:

Wolfram Language code: DiscretePlot[#[𝒟, x], {x, -4, 4, .01}, PlotLabel -> #]& /@ {PDF, CDF}

Compute moments and quantiles:

Wolfram Language code: Moment[𝒟, 2]

Wolfram Language code: Quantile[𝒟, 0.95]

Create a histogram distribution of bivariate data:

Wolfram Language code: 𝒟 = HistogramDistribution[RandomVariate[BinormalDistribution[.75], 10 ^ 3]];

Visualize the PDF and CDF:

Wolfram Language code:

Table[DiscretePlot3D[Evaluate[f[𝒟, {x, y}]], {x, -3, 3, .5}, {y, -3, 3, .5}, ExtentSize -> 1 / 2, PlotLabel -> f], {f, {PDF, CDF}}]

Compute covariance and general moments:

Wolfram Language code: Covariance[𝒟]//MatrixForm

Wolfram Language code: Moment[𝒟, {1, 2}]

Scope (29)

Basic Uses (5)

Create a distribution from a histogram of some data:

Wolfram Language code: data = RandomVariate[NormalDistribution[], 10^4];

Wolfram Language code: 𝒟 = HistogramDistribution[data];

Wolfram Language code: Show[Histogram[data, Automatic, "PDF"], Plot[PDF[𝒟, x], {x, -4, 4}, PlotStyle -> Thick]]

Compute probabilities from the distribution:

Wolfram Language code: Probability[x > 3, x𝒟]

Create histogram distributions from quantity data:

Wolfram Language code: qa = RandomVariate[GammaDistribution[2, Quantity[3, "Grams"]], 10 ^ 3]

Wolfram Language code: 𝒟 = HistogramDistribution[qa]

Find select descriptive statistics:

Wolfram Language code: #[𝒟]& /@ {Mean, Variance, Skewness, Kurtosis}

Decrease the number of bins to decrease local sensitivity:

Wolfram Language code: data = RandomVariate[NormalDistribution[], 100];

Wolfram Language code: bc = {100, 50, 10, 5};

Wolfram Language code:

Table[Plot[PDF[HistogramDistribution[data, i], x]//Evaluate, {x, -4, 4}, PlotRange -> All, PlotLabel -> i, Filling -> Axis, Exclusions -> None, PlotPoints -> 500], {i, bc}]

Increase the bin width to decrease local sensitivity:

Wolfram Language code: data = RandomVariate[NormalDistribution[], 100];

Wolfram Language code: bw = {{.05}, {.1}, {.25}, {.75}};

Wolfram Language code:

Table[Plot[PDF[HistogramDistribution[data, i], x]//Evaluate, {x, -4, 4}, PlotRange -> All, PlotLabel -> i, Filling -> Axis, Exclusions -> None, PlotPoints -> 500], {i, bw}]

Create distributions from histograms in higher dimensions:

Wolfram Language code: 𝒟 = HistogramDistribution[RandomVariate[NormalDistribution[], {10, 3}]];

Plot the univariate marginal PDFs:

Wolfram Language code:

Table[Plot[PDF[MarginalDistribution[𝒟, i], x]//Evaluate, {x, -4, 4}, Filling -> Axis, PlotLabel -> i, Exclusions -> None], {i, {1, 2, 3}}]

Plot the bivariate marginal PDFs:

Wolfram Language code:

Table[DiscretePlot3D[PDF[MarginalDistribution[𝒟, i], {x, y}]//Evaluate, {x, -4, 4, .5}, {y, -4, 4, .5}, PlotLabel -> i, ExtentSize -> 1 / 2], {i, Subsets[{1, 2, 3}, {2}]}]

Distribution Properties (10)

Estimate distribution functions:

Wolfram Language code: 𝒟 = HistogramDistribution[RandomVariate[NormalDistribution[], 1000]];

Wolfram Language code:

Partition[Table[Plot[f[𝒟, x], {x, -4, 4}, PlotLabel -> f, Exclusions -> None], {f, {PDF, CDF, HazardFunction, SurvivalFunction}}], 2, 2]//Grid

Compute moments of the distribution:

Wolfram Language code: 𝒟 = HistogramDistribution[RandomReal[NormalDistribution[], 1000]];

Special moments:

Wolfram Language code: {Mean[𝒟], Variance[𝒟], Skewness[𝒟], Kurtosis[𝒟]}

General moments:

Wolfram Language code: Table[Moment[𝒟, k], {k, 4}]

Wolfram Language code: Table[CentralMoment[𝒟, k], {k, 4}]

Wolfram Language code: Table[Cumulant[𝒟, k], {k, 4}]

Wolfram Language code: Table[FactorialMoment[𝒟, k], {k, 4}]

Quantile function:

Wolfram Language code: 𝒟 = HistogramDistribution[RandomReal[NormalDistribution[], 1000]];

Wolfram Language code: DiscretePlot[Quantile[𝒟, p], {p, 0, 1, .005}]

Special quantile values:

Wolfram Language code: Quartiles[𝒟]

Wolfram Language code: InterquartileRange[𝒟]

Wolfram Language code: Quantile[𝒟, {0.05, 0.95}]

Wolfram Language code: Median[𝒟]

Generate random numbers:

Wolfram Language code: 𝒟 = HistogramDistribution[RandomReal[NormalDistribution[], 1000], {-4, 4, 0.5}];

Wolfram Language code: RandomVariate[𝒟, 10]

Compare with HistogramDistribution:

Wolfram Language code:

Show[Histogram[RandomVariate[𝒟, 10^3], {-4, 4, 0.5}, "PDF"], 
	DiscretePlot[PDF[𝒟, x], {x, -4, 4, .01}, PlotStyle -> Thick]]

Compute probabilities and expectations:

Wolfram Language code: 𝒟 = HistogramDistribution[RandomReal[NormalDistribution[], 1000]];

Wolfram Language code: NProbability[-1 < x ≤ 2, x𝒟]

Wolfram Language code: NExpectation[x^2, x𝒟]

Generating functions:

Wolfram Language code: 𝒟 = HistogramDistribution[RandomReal[NormalDistribution[], 1000], 3]

Wolfram Language code: MomentGeneratingFunction[𝒟, t]

Wolfram Language code: CharacteristicFunction[𝒟, t]

Estimate distribution functions for bivariate data:

Wolfram Language code: 𝒟 = HistogramDistribution[RandomVariate[BinormalDistribution[.75], 1000]];

Wolfram Language code:

Partition[Table[DiscretePlot3D[f[𝒟, {x, y}]//Evaluate, {x, -4, 4, .5}, {y, -4, 4, .5}, PlotLabel -> f, ExtentSize -> 1 / 2, PlotRange -> {0, 1}], {f, {PDF, CDF, HazardFunction, SurvivalFunction}}], 2, 2]//Grid

Compute moments of a bivariate distribution:

Wolfram Language code: 𝒟 = HistogramDistribution[RandomReal[BinormalDistribution[.75], 1000]];

Special moments:

Wolfram Language code: {Mean[𝒟], Variance[𝒟]}

Wolfram Language code: Covariance[𝒟]//MatrixForm

Wolfram Language code: Correlation[𝒟]//MatrixForm

General moments:

Wolfram Language code: Moment[𝒟, {1, 2}]

Wolfram Language code: CentralMoment[𝒟, {1, 2}]

Wolfram Language code: Cumulant[𝒟, {1, 2}]

Wolfram Language code: FactorialMoment[𝒟, {1, 2}]

Generate random numbers:

Wolfram Language code: 𝒟 = HistogramDistribution[RandomReal[BinormalDistribution[.5], 10 ^ 4]];

Wolfram Language code: RandomVariate[𝒟, 6]

Show the point distribution:

Wolfram Language code: ListPlot[RandomVariate[𝒟, 10^4], PlotStyle -> PointSize[Tiny], PlotRange -> {{-4, 4}, {-4, 4}}]

Having fewer bins yields a coarser approximation to the underlying distribution:

Wolfram Language code: 𝒟c = HistogramDistribution[RandomReal[BinormalDistribution[.5], 10 ^ 4], 8];

Wolfram Language code: ListPlot[RandomVariate[𝒟c, 10^4], PlotStyle -> PointSize[Tiny], PlotRange -> {{-4, 4}, {-4, 4}}]

Generating functions:

Wolfram Language code: 𝒟 = HistogramDistribution[RandomReal[NormalDistribution[], {100, 2}], {2, 2}]

Wolfram Language code: MomentGeneratingFunction[𝒟, {Subscript[t, 1], Subscript[t, 2]}]

Binning (14)

Automatically compute the number of bins:

Wolfram Language code:

𝒟1 = HistogramDistribution[RandomVariate[NormalDistribution[], 100]];
𝒟2 = HistogramDistribution[RandomVariate[NormalDistribution[], 1000]];

More data yields smaller bins:

Wolfram Language code: Table[DiscretePlot[PDF[𝒟, x], {x, -4, 4, .01}], {𝒟, {𝒟1, 𝒟2}}]

Explicitly specify the number of bins to use:

Wolfram Language code: data = RandomVariate[NormalDistribution[], 10 ^ 4];

Specify 5 and 50 bins, respectively:

Wolfram Language code:

𝒟1 = HistogramDistribution[data, 5];
𝒟2 = HistogramDistribution[data, 50];

Wolfram Language code: Table[DiscretePlot[PDF[𝒟, x], {x, -4, 4, .01}], {𝒟, {𝒟1, 𝒟2}}]

Explicitly specify bin width:

Wolfram Language code: data = RandomVariate[NormalDistribution[], 10 ^ 4];

Use bin widths 1. and 0.1:

Wolfram Language code:

𝒟1 = HistogramDistribution[data, {1.0}];
𝒟2 = HistogramDistribution[data, {0.1}];

Wolfram Language code: Table[DiscretePlot[PDF[𝒟, x], {x, -4, 4, .01}], {𝒟, {𝒟1, 𝒟2}}]

Specify bin range and bin width:

Wolfram Language code: data = RandomVariate[NormalDistribution[], 10 ^ 4];

Use bin widths of 1.5 and .15 respectively over fixed interval:

Wolfram Language code:

𝒟1 = HistogramDistribution[data, {-4, 4, 1.5}];
𝒟2 = HistogramDistribution[data, {-4, 4, .15}];

Wolfram Language code: Table[DiscretePlot[PDF[𝒟, x], {x, -4, 4, .01}], {𝒟, {𝒟1, 𝒟2}}]

Provide explicit bin delimiters:

Wolfram Language code: data = RandomVariate[NormalDistribution[], 10 ^ 4];

Wolfram Language code:

𝒟1 = HistogramDistribution[data, {{-4, -1, 0, 2, 4}}];
𝒟2 = HistogramDistribution[data, {{-3, 0, 2, 3}}];

Wolfram Language code: Table[DiscretePlot[PDF[𝒟, x], {x, -4, 4, .01}], {𝒟, {𝒟1, 𝒟2}}]

Use different automatic binning methods:

Wolfram Language code: data = RandomVariate[NormalDistribution[], 5 10 ^ 3];

Wolfram Language code:

Table[DiscretePlot[PDF[HistogramDistribution[data, name], x]//Evaluate, {x, -4, 4, .01}, PlotLabel -> name], {name, {"Sturges", "Scott", "FreedmanDiaconis", "Wand"}}]

Delimit bins on integer boundaries using a binning function:

Wolfram Language code: integerBins[list_] := Union[IntegerPart[list]]

Wolfram Language code: 𝒟 = HistogramDistribution[RandomReal[NormalDistribution[], 100], integerBins];

Wolfram Language code: DiscretePlot[PDF[𝒟, x], {x, -4, 4, .01}]

Automatically compute the number of bins for bivariate data:

Wolfram Language code:

𝒟1 = HistogramDistribution[RandomVariate[BinormalDistribution[.5], 100]];
𝒟2 = HistogramDistribution[RandomVariate[BinormalDistribution[.5], 1000]];

More data yields smaller bins:

Wolfram Language code:

Table[DiscretePlot3D[PDF[𝒟, {x, y}]//Evaluate, {x, -4, 4, .5}, {y, -4, 4, .5}, ExtentSize -> 1 / 2, PlotRange -> All], {𝒟, {𝒟1, 𝒟2}}]

Explicitly specify the number of bins to use:

Wolfram Language code: data = RandomVariate[BinormalDistribution[.5], 10 ^ 4];

Wolfram Language code:

𝒟1 = HistogramDistribution[data, 5];
𝒟2 = HistogramDistribution[data, 10];

Wolfram Language code:

Table[DiscretePlot3D[PDF[𝒟, {x, y}]//Evaluate, {x, -4, 4, .5}, {y, -4, 4, .5}, ExtentSize -> 1 / 2, PlotRange -> All], {𝒟, {𝒟1, 𝒟2}}]

Explicitly specify bin width:

Wolfram Language code: data = RandomVariate[BinormalDistribution[.5], 10 ^ 4];

Wolfram Language code:

𝒟1 = HistogramDistribution[data, {1.0}];
𝒟2 = HistogramDistribution[data, {2.0}];

Wolfram Language code:

Table[DiscretePlot3D[PDF[𝒟, {x, y}]//Evaluate, {x, -4, 4, .5}, {y, -4, 4, .5}, ExtentSize -> 1 / 2, PlotRange -> All], {𝒟, {𝒟1, 𝒟2}}]

Specify bin range and bin width:

Wolfram Language code: data = RandomVariate[BinormalDistribution[.5], 10 ^ 4];

Wolfram Language code:

𝒟1 = HistogramDistribution[data, {{-4, 4, 1.0}}];
𝒟2 = HistogramDistribution[data, {{-4, 4, 2.0}}];

Wolfram Language code:

Table[DiscretePlot3D[PDF[𝒟, {x, y}]//Evaluate, {x, -4, 4, .5}, {y, -4, 4, .5}, ExtentSize -> 1 / 2, PlotRange -> All], {𝒟, {𝒟1, 𝒟2}}]

Explicitly give bin delimiters:

Wolfram Language code: data = RandomVariate[BinormalDistribution[.5], 10 ^ 4];

Wolfram Language code:

𝒟1 = HistogramDistribution[data, {{{-4, -1, 0, 1, 4}}}];
𝒟2 = HistogramDistribution[data, {{{-4, -1, 0, 2, 4}}}];

Wolfram Language code:

Table[DiscretePlot3D[PDF[𝒟, {x, y}]//Evaluate, {x, -4, 4, .5}, {y, -4, 4, .5}, ExtentSize -> 1 / 2, PlotRange -> All], {𝒟, {𝒟1, 𝒟2}}]

Use different automatic binning methods:

Wolfram Language code: data = RandomVariate[BinormalDistribution[.5], 1000];

Wolfram Language code:

Table[DiscretePlot3D[PDF[HistogramDistribution[data, name], {x, y}]//Evaluate, {x, -4, 4, .5}, {y, -4, 4, .5}, ExtentSize -> 1 / 2, PlotRange -> All, PlotLabel -> name], {name, {"Sturges", "Scott", "FreedmanDiaconis", "Wand"}}]

Use different bin specifications in each dimension:

Wolfram Language code: data = RandomVariate[BinormalDistribution[.5], 10 ^ 4];

Specify 3 bins in the row dimension and bin width 0.5 in the column dimension:

Wolfram Language code: 𝒟 = HistogramDistribution[data, {3, {0.5}}];

Wolfram Language code: DiscretePlot3D[PDF[𝒟, {x, y}]//Evaluate, {x, -4, 4, .5}, {y, -4, 4, .5}, ExtentSize -> 1 / 2]

Applications (6)

Compare an estimated density to a theoretical model:

Wolfram Language code:

𝒹 = MixtureDistribution[{1 / 2, 1 / 10, 1 / 10, 1 / 10, 1 / 10, 1 / 10}, Join[{NormalDistribution[]}, Table[NormalDistribution[i / 2 - 1, 1 / 10], {i, 0, 4}]]];

Wolfram Language code: dist = HistogramDistribution[RandomVariate[𝒹, 10 ^ 5]];

Wolfram Language code:

Show[Plot[PDF[𝒹, x], {x, -4, 4}], DiscretePlot[PDF[dist, x], {x, -4, 4, .01}, PlotStyle -> RGBColor[0.880722, 0.611041, 0.142051]]]

Distribution of lengths of human chromosomes:

Wolfram Language code: 𝒟 = HistogramDistribution[ Log[Table[GenomeData[i, "SequenceLength"], {i, 41}] ], "Sturges"];

Wolfram Language code: DiscretePlot[PDF[𝒟, x], {x, 0, 30, .01}, PlotRange -> All]

Compute the probability that the sequence length is greater than 15:

Wolfram Language code: Probability[gLen > 15, gLen𝒟]

Compare the distributions of word length for some of the parts of speech:

Wolfram Language code: partOfSpeech = WordData[All, "PartsOfSpeech"][[1 ;; 6]];

Wolfram Language code: data = Table[StringLength /@ w, {w, (WordData[All, #]& /@ partOfSpeech)}];

Wolfram Language code:

Table[DiscretePlot[PDF[HistogramDistribution[data[[i]]], x]//Evaluate, {x, 0, 30, .01}, PlotLabel -> partOfSpeech[[i]], PlotRange -> All], {i, Length[partOfSpeech]}]

The expected number of characters for a randomly chosen English noun:

Wolfram Language code: Expectation[len, lenHistogramDistribution[data[[1]]]]//N

Estimate the distribution of day-to-day point changes in the S&P 500 index:

Wolfram Language code: sp500 = FinancialData["SP500", All]

Wolfram Language code: sp500Ratio = Log[Ratios[sp500]];

Wolfram Language code: 𝒟 = HistogramDistribution[sp500Ratio];

Wolfram Language code: Plot[PDF[𝒟, x], {x, -.05, .05}, Exclusions -> None, Filling -> Axis, Axes -> {True, False}]

Compute the probability of a 1% point change or more on a given day:

Wolfram Language code: Probability[x ≥ Log[1.01], x𝒟]

Determine the number of bins to use for bimodal data by Knuth's Bayesian method:

Wolfram Language code: ExampleData[{"Statistics", "OldFaithful"}, "ColumnDescriptions"]

Wolfram Language code: data = ExampleData[{"Statistics", "OldFaithful"}][[All, 1]];

Wolfram Language code:

optBins[data_, M_Integer] := Block[{nn = Length[data], n, p1, p2, min, max}, {min, max} = Through[{Min, Max}[data]];
	n = N[HistogramList[data, {min, max + (max - min) / M, (max - min) / M}][[2]]];
	p1 = nn Log[M] + LogGamma[M / 2] - LogGamma[nn + M / 2];
	p2 = -M LogGamma[1 / 2] + Total[LogGamma[n + 1 / 2]];p1 + p2]

The optimal number of bins maximizes the log of the posterior density:

Wolfram Language code: oBins = Table[{nbin, optBins[data, nbin]}, {nbin, Length[data] / 6}];

Wolfram Language code: ListLinePlot[oBins, Filling -> Axis, AxesOrigin -> {0, -300}]

Wolfram Language code: opt = SortBy[oBins, Last][[-1, 1]]

Density estimates using Knuth's method, Scott's rule, and the Freedman–Diaconis rule:

Wolfram Language code:

rules = {"Knuth", "Scott", "FreedmanDiaconis"};
Table[Plot[PDF[𝒟[i] = HistogramDistribution[data, rules[[i]] /. "Knuth" -> opt], x]//Evaluate, {x, 1, 7}, PlotRange -> All, Exclusions -> None, Filling -> Axis, PlotLabel -> rules[[i]]], {i, 1, 3}]

Knuth's method outperforms the other two in terms of LogLikelihood:

Wolfram Language code: Table[LogLikelihood[𝒟, data], {𝒟, {𝒟[1], 𝒟[2], 𝒟[3]}}]

Construct a continuous version of the empirical cumulative distribution function:

Wolfram Language code: data = RandomVariate[NormalDistribution[], 12]

Wolfram Language code:

ed = EmpiricalDistribution[data];
hd = HistogramDistribution[data, {Sort[data]}];

Cumulative distribution function for HistogramDistribution is piecewise linear:

Wolfram Language code:

Plot[{CDF[hd, x], CDF[ed, x]}, {x, 1.1 Min[data], 1.1 Max[data]}, Filling -> {1 -> {2}, 2 -> Axis}, PlotLegends -> {"Piecewise-linear", "Piecewise-constant"}]

Compute Cramer–von Mises distance between the two distributions:

Wolfram Language code: Expectation[(CDF[ed, x] - CDF[hd, x]) ^ 2, xhd]

Properties & Relations (10)

The PDF of HistogramDistribution is equivalent to a probability density Histogram:

Wolfram Language code: data = RandomVariate[NormalDistribution[], 1000];

Wolfram Language code:

Show[Histogram[data, Automatic, "PDF"], DiscretePlot[PDF[HistogramDistribution[data], x], {x, -4, 4, .01}, PlotStyle -> Thick]]

The resulting density estimate integrates to unity:

Wolfram Language code: 𝒟 = HistogramDistribution[RandomVariate[NormalDistribution[], 10 ^ 3]];

Wolfram Language code: Integrate[PDF[𝒟, x], {x, -Infinity, Infinity}]

The precision of the output matches the precision of the data:

Wolfram Language code: dist = HistogramDistribution[{1, 2, 3, 4, 5}]

Wolfram Language code: Precision[dist]

The PDF is piecewise constant:

Wolfram Language code: 𝒟 = HistogramDistribution[RandomVariate[NormalDistribution[], 10 ^ 3], 4];

Wolfram Language code: PDF[𝒟, x]//PiecewiseExpand

The CDF and SurvivalFunction are piecewise linear:

Wolfram Language code: 𝒟 = HistogramDistribution[RandomVariate[NormalDistribution[], 10 ^ 3], 4];

Wolfram Language code: CDF[𝒟, x]//PiecewiseExpand

Wolfram Language code: SurvivalFunction[𝒟, x]//PiecewiseExpand

The HazardFunction is linear fractional:

Wolfram Language code: 𝒟 = HistogramDistribution[RandomVariate[NormalDistribution[], 10 ^ 3], 4];

Wolfram Language code: HazardFunction[𝒟, x]//PiecewiseExpand//Quiet

HistogramDistribution is a MixtureDistribution of uniform distributions:

Wolfram Language code: data = RandomVariate[NormalDistribution[], 10 ^ 3];

Wolfram Language code: {bl, cl} = HistogramList[data]

Wolfram Language code: dist1 = HistogramDistribution[data, {bl}];

Wolfram Language code: dist2 = MixtureDistribution[cl, Table[UniformDistribution[{bl[[i]], bl[[i + 1]]}], {i, Length[bl] - 1}]];

Wolfram Language code: Plot[PDF[#, x], {x, -5, 5}, Exclusions -> None, Filling -> Axis]& /@ {dist1, dist2}

HistogramDistribution is a consistent estimator of the underlying distribution:

Wolfram Language code: data = Table[RandomVariate[NormalDistribution[], 10^i], {i, Range[2, 5]}];

Wolfram Language code: 𝒟 = Table[HistogramDistribution[i], {i, data}];

Wolfram Language code:

Table[Plot[{PDF[𝒟[[i]], x], PDF[NormalDistribution[], x]}, {x, -4, 4}, Exclusions -> None, PlotRange -> All, PlotLabel -> Row[{"n = ", Superscript[10, i]}]], {i, Range[4]}]

HistogramDistribution works with the values only when the input is a TimeSeries:

Wolfram Language code:

ts = TemporalData[TimeSeries, {{{-0.3841368896539435, -0.16640803451480843, 0.6929948737894751, 
    -2.1004098132785964, -0.7124674029060342, -0.7258319411964131, 0.2993123552236552, 
    -0.9152583472870652, 1.599389522268598, 0.12404249808714003, -1. ... 188032153989, 1.656237325151233, 
     1.6805126287994852, 1.7971439853604791, 1.899216338440769, 2.0739211140534186}}}, 1, 
  {"Continuous", 1}, {"Discrete", 1}, 1, 
  {ResamplingMethod -> {"Interpolation", InterpolationOrder -> 1}}}, False, 10.];

Wolfram Language code: hd = HistogramDistribution[ts]

Wolfram Language code: Plot[PDF[hd, x], {x, -3, 3}, Exclusions -> None]

Compare to the histogram distribution of the values:

Wolfram Language code: hdv = HistogramDistribution[ts["Values"]]

Wolfram Language code: hd == hdv

HistogramDistribution works with all the values together when the input is a TemporalData:

Wolfram Language code:

td = TemporalData[Automatic, {{{0.364191284336665, 0.23842337219863016, -0.8316476833544613, 
    1.544053351825183, -2.0166147243047767, 0.2614665355347544, -1.2454913547771056, 
    -0.6317633950902457, 0.2838937206716775, 1.6668310901871626, -0.72049 ... .5921612088884451, 1.654275735349441, 1.7430161272580262, 1.7890579608064174, 
     1.8395626018554865, 1.932148707754712, 2.0248106606311564, 2.055974115570984, 
     2.4794187314021934}}}, 4, {"Discrete", 4}, {"Discrete", 1}, 1, {}}, False, 10.];

Wolfram Language code: hd = HistogramDistribution[td]

Wolfram Language code: Plot[PDF[hd, x], {x, -3, 3}, Exclusions -> None]

Compare to the histogram distribution calculated with the values from all the paths:

Wolfram Language code: hdv = HistogramDistribution[td["ValueList"]//Flatten]

Wolfram Language code: hd == hdv

Possible Issues (1)

It is possible to drop data from the estimation by specifying a binning range:

Wolfram Language code: data = RandomVariate[NormalDistribution[0, 1], 1000];

Wolfram Language code: HistogramDistribution[data, {-1, 1, .25}]

Wolfram Language code: Plot[PDF[%, x], {x, -4, 4}, Exclusions -> None]

Specifying a width alone uses all the data:

Wolfram Language code: HistogramDistribution[data, {.25}]

Wolfram Language code: Plot[PDF[%, x], {x, -4, 4}, Exclusions -> None]

Neat Examples (1)

Random pop art with HistogramDistribution:

Wolfram Language code: data = RandomVariate[BinormalDistribution[.5], 2500];

Wolfram Language code: bspecs = Table[{{RandomVariate[NormalDistribution[], 4]//Sort}, {RandomVariate[NormalDistribution[], 5]//Sort}}, {12}];

Wolfram Language code: 𝒟 = Table[HistogramDistribution[data, i], {i, bspecs}];

Wolfram Language code:

Table[ContourPlot[PDF[𝒟[[i]], {x, y}]//Evaluate, {x, Min[bspecs[[i]][[1]]], Max[bspecs[[i]][[1]]]}, {y, Min[bspecs[[i]][[2]]], Max[bspecs[[i]][[2]]]}, PlotRange -> All, ColorFunction -> "BrightBands", Exclusions -> None, PlotPoints -> 50, FrameTicks -> None], {i, Length[bspecs]}]

Top

More Learning

Tech Support

Wolfram Solutions

Wolfram Solutions For Education

Get Started

Grow Your Skills

Work with Us

Educational Programs for Adults

Educational Programs for Youth

Read

HistogramDistribution

Details

Examples

Basic Examples (2)

Scope (29)

Basic Uses (5)

Distribution Properties (10)

Binning (14)

Applications (6)

Properties & Relations (10)

Possible Issues (1)

Neat Examples (1)

Text

CMS

APA

BibTeX

BibLaTeX

HistogramDistribution

Details

Examples

Basic Examples (2)

Scope (29)

Basic Uses (5)

Distribution Properties (10)

Binning (14)

Applications (6)

Properties & Relations (10)

Possible Issues (1)

Neat Examples (1)

See Also

Related Guides

History

Text

CMS

APA

BibTeX

BibLaTeX