Wolfram Language & System Documentation Center

Cumulant

Cumulant[data,r]

gives the r cumulant of data.

Cumulant[data,{r₁,…,r_m} ]

gives the multivariate cumulant of order {r₁,…,r_m} of data.

Cumulant[dist,r]

gives the r cumulant of the distribution dist.

Cumulant[r]

represents the r formal cumulant.

Details

Formally, the r cumulant is defined as the coefficient of the Taylor series of the CumulantGeneratingFunction.
The first few cumulants expressed in terms of moments:
In general, MomentConvert[Cumulant[r],"Moment"] gives the in terms of moments.
Cumulant[data,r] effectively uses MomentConvert to compute it in terms of other moments for data.
For x∈Arrays[{n₁,n₂,… ,n_k}], Cumulant[x,r] is equivalent to ArrayReduce[Cumulant[#,r]&,data,1]. »
For x∈Arrays[{n₁,n₂,… ,n_k}], Cumulant[x,{r₁,…,r_m}] is equivalent to ArrayReduce[Cumulant[#,{r₁,…,r_m}]&,x,{{1},{2}}]. »
Cumulant handles both numerical and symbolic data.
The data can have the following additional forms and interpretations:

	Association	the values (the keys are ignored) »
	WeightedData	weighted mean, based on the underlying EmpiricalDistribution »
	EventData	based on the underlying SurvivalDistribution »
	TimeSeries, TemporalData, …	vector or array of values (the time stamps ignored) »
	Image,Image3D	RGB channel's values or grayscale intensity value »
	Audio	amplitude values of all channels »
	DateObject, TimeObject	list of dates or list of times »

For a distribution dist with G=CumulantGeneratingFunction[,…]:
Cumulant[,r] »

Cumulant[dist,{r₁,…,r_m}] »
For a random process proc, the cumulant function can be computed for slice distribution at time t, SliceDistribution[proc,t], as [t]=Cumulant[SliceDistribution[proc,t],r]. »
Cumulant[r] can be used in such functions as MomentConvert and MomentEvaluate, etc. »

Examples

open all close all

Basic Examples (3)

Compute cumulants from data:

Wolfram Language code: data = RandomVariate[LogisticDistribution[0, 1], 10 ^ 5];

Wolfram Language code: Cumulant[data, 2]

For symbolic data:

Wolfram Language code: Cumulant[{Subscript[x, 1], Subscript[x, 2], Subscript[x, 3]}, 2]

Cumulant of a list of dates:

Wolfram Language code: Cumulant[{Yesterday, Today, Tomorrow}, 4]

Compute the second cumulant of a continuous univariate distribution:

Wolfram Language code: Cumulant[GammaDistribution[α, β], 2]

The cumulant for a multivariate distribution:

Wolfram Language code: Cumulant[DirichletDistribution[{α, β, γ}], {1, 2}]

Scope (26)

Basic Uses (6)

Exact input yields exact output:

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

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

Approximate input yields approximate output:

Wolfram Language code: Cumulant[{1., 2., 3., 4.}, 2]

Wolfram Language code: Cumulant[N[{1, 2, 3, 4}, 30], 2]

Find cumulants of WeightedData:

Wolfram Language code: Cumulant[WeightedData[{1, 2, 3}, {Subscript[w, 1], Subscript[w, 2], Subscript[w, 3]}], 1]

Wolfram Language code:

data = {8, 3, 5, 4, 9, 0, 4, 2, 2, 3};
weights = {0.15, 0.09, 0.12, 0.10, 0.16, 0., 0.11, 0.08, 0.08, 0.09};

Wolfram Language code: Cumulant[WeightedData[data, weights], 2]

Find a cumulant of EventData:

Wolfram Language code:

e = {1.0, 2.1, 3.2, 4.5, 5.7};
ci = {0, 0, 0, 1, 0};

Wolfram Language code: Cumulant[EventData[e, ci], 1]

Find a cumulant of TimeSeries:

Wolfram Language code:

Cumulant[TemporalData[TimeSeries, {{{2.3, 1.2, 6.7, 5.8, 7.1, 4.6}}, {{0, 5, 1}}, 1, {"Discrete", 1}, 
  {"Discrete", 1}, 1, {}}, False, 10.], 2]

The cumulant depends only on the values:

Wolfram Language code:

Cumulant[TemporalData[TimeSeries, {{{2.3, 1.2, 6.7, 5.8, 7.1, 4.6}}, {{0, 5, 1}}, 1, {"Discrete", 1}, 
  {"Discrete", 1}, 1, {}}, False, 10.]["Values"], 2]

Find a cumulant for data involving quantities:

Wolfram Language code: data = Quantity[RandomReal[1, 6], "Meters"]

Wolfram Language code: Cumulant[data, 2]

Array Data (5)

For a matrix, Cumulant gives columnwise cumulants:

Wolfram Language code:

Cumulant[(⁠|       |       |
| ----- | ----- |
| a1, 1 | a1, 2 |
| a2, 1 | a2, 2 |⁠), 4]//Simplify

For an array, Cumulant gives columnwise cumulants at the first level:

Wolfram Language code: Cumulant[Array[Subscript[a, ##]&, {2, 2, 2}], 4]//Simplify//MatrixForm

Wolfram Language code: Cumulant[Array[Subscript[a, ##]&, {2, 2, 2}], {4, 4}]//Simplify

Works with large arrays:

Wolfram Language code: Cumulant[RandomReal[1, 10 ^ 7], 2]

Wolfram Language code: Cumulant[RandomReal[1, {10 ^ 6, 5}], 2]

When the input is an Association, Cumulant works on its values:

Wolfram Language code:

mat = RandomReal[1, {3, 2}];
assoc = AssociationThread[Range[3], mat]

Wolfram Language code: Cumulant[assoc, 3]

SparseArray data can be used just like dense arrays:

Wolfram Language code: Cumulant[SparseArray[{{1} -> 1, {100} -> 1}], 4]

Wolfram Language code: Cumulant[SparseArray[{{1, 1} -> 1, {2, 2} -> 2, {3, 3} -> 3, {1, 3} -> 4}], 2]

Compute the multivariate cumulant of an array in terms of its raw moments:

Wolfram Language code: (f = MomentConvert[Cumulant[{3, 3}], Moment])//Simplify//TraditionalForm//Short

Wolfram Language code: arr = RandomReal[1, {2, 2, 2}, WorkingPrecision -> 50];

Wolfram Language code: c1 = Cumulant[arr, {3, 3}]

Wolfram Language code: c2 = (f /. Moment[l_] :> Moment[arr, l])

Wolfram Language code: c1 == c2

Image and Audio Data (2)

Channelwise cumulant of an RGB image:

Wolfram Language code: Cumulant[[image], 5]

Wolfram Language code: RGBColor[%]

Cumulant intensity value of a grayscale image:

Wolfram Language code: Cumulant[[image], 4]

On audio objects, Cumulant works channelwise:

Wolfram Language code: a = ExampleData[{"Audio", "Bee"}]

Wolfram Language code: AudioMeasurements[a, "Channels"]

Wolfram Language code: Cumulant[a, 3]

Date and Time (4)

Compute cumulant of dates:

Wolfram Language code: dates = WolframLanguageData[All, "DateIntroduced"];

Wolfram Language code: DateHistogram[dates]

Wolfram Language code: Cumulant[dates, 4]

Wolfram Language code: UnitConvert[%, "Decades" ^ 4]

Compute the weighted cumulant of dates:

Wolfram Language code: dates = RandomDate[4]

Wolfram Language code: weights = {1, 1, 1, 3};

Wolfram Language code: Cumulant[WeightedData[dates, weights], 3]

Wolfram Language code: UnitConvert[%, "Months" ^ 3]

Compare with simple cumulant:

Wolfram Language code: Cumulant[dates, 3]

Wolfram Language code: UnitConvert[%, "Months" ^ 3]

Compute the cumulant of dates given in different calendars:

Wolfram Language code:

dates = {DateObject[{2024, 2, 29}, CalendarType -> "Julian"], DateObject[{1524, 1, 1}, CalendarType -> "Islamic"], DateObject[{6024, 1, 15}, CalendarType -> "Jewish"]}

Wolfram Language code: Cumulant[dates, 3]

Wolfram Language code: UnitConvert[%, "Centuries" ^ 3]

Compute the cumulant of times:

Wolfram Language code: RandomTime[3]

Wolfram Language code: Cumulant[%, 4]

List of times with different time zone specifications:

Wolfram Language code: {TimeObject[{12}, TimeZone -> 0], TimeObject[{12}, TimeZone -> 2], TimeObject[{12}, TimeZone -> "Asia/Tokyo"]}

Wolfram Language code: Cumulant[%, 3]

Distribution and Process Cumulants (5)

Scalar cumulant for univariate distributions:

Wolfram Language code: Cumulant[BinomialDistribution[n, p], 1]

Wolfram Language code: Cumulant[NormalDistribution[μ, σ], 2]

Scalar cumulant for multivariate distributions:

Wolfram Language code: Cumulant[BinormalDistribution[{Subscript[μ, 1], Subscript[μ, 2]}, {σ1, σ2}, ρ], 2]

Wolfram Language code: Cumulant[DirichletDistribution[{a, b, c}], 2]//Simplify

Joint cumulant for multivariate distributions:

Wolfram Language code: Cumulant[MultivariateHypergeometricDistribution[n, {Subscript[m, 1], Subscript[m, 2]}], {1, 1}]

Wolfram Language code: Cumulant[BinormalDistribution[{Subscript[μ, 1], Subscript[μ, 2]}, {σ1, σ2}, ρ], {1, 1}]

Compute a cumulant for a symbolic order r:

Wolfram Language code: Cumulant[PoissonDistribution[μ], r]

A cumulant may only evaluate for specific orders:

Wolfram Language code: Cumulant[BetaDistribution[α, β], r]

Wolfram Language code: % /. r -> 2

A cumulant may only evaluate numerically:

Wolfram Language code: Cumulant[VonMisesDistribution[Pi / 2, 2], 4]

Wolfram Language code: N[%]

Cumulants for derived distributions:

Wolfram Language code: Cumulant[TransformedDistribution[x^2, xNormalDistribution[μ, σ]], 2]

Wolfram Language code: Cumulant[ProbabilityDistribution[(Exp[1 - x] x (1 - x)/3 - E), {x, 0, 1}], 3]

Data distribution:

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

Wolfram Language code: Cumulant[HistogramDistribution[data], 1]

Cumulant function for a random process:

Wolfram Language code: Cumulant[QueueingProcess[λ, μ, ∞][t], 2]

Wolfram Language code: Plot[Evaluate[% /. {λ -> 1, μ -> 3}], {t, 0, 1}, PlotRange -> All]

Find a cumulant of TemporalData at time t=0.5:

Wolfram Language code: td = RandomFunction[WienerProcess[1, 1], {0, 10, 0.05}, 100]

Wolfram Language code: Cumulant[td[0.5], 1]

Find the corresponding cumulant function together with all the simulations:

Wolfram Language code:

Show[ListLinePlot[td, PlotStyle -> Directive[Opacity[0.7], Thin]], Plot[Cumulant[td[t], 1], {t, 0, 10}, PlotStyle -> Thick]]

Formal Cumulants (4)

TraditionalForm formatting for formal cumulants:

Wolfram Language code: Cumulant[r]//TraditionalForm

Wolfram Language code: Cumulant[{p, q, r}]//TraditionalForm

Convert combinations of formal moments to an expression involving Cumulant:

Wolfram Language code: MomentConvert[Moment[4], Cumulant]//TraditionalForm

Wolfram Language code: MomentConvert[CentralMoment[2]Moment[2], Cumulant]//TraditionalForm

Evaluate an expression involving formal cumulants for a distribution:

Wolfram Language code: MomentEvaluate[Cumulant[1] + Cumulant[2], BetaDistribution[α, β]]

Evaluate for data:

Wolfram Language code: data = RandomVariate[BetaDistribution[2, 3], 10^4];

Wolfram Language code: MomentEvaluate[Cumulant[1] + Cumulant[2], data]

Find a sample estimator for an expression involving Cumulant:

Wolfram Language code: estimator = MomentConvert[Cumulant[1], "UnbiasedSampleEstimator"]

Evaluate the resulting estimator for data:

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

Wolfram Language code: MomentEvaluate[estimator, data]

Applications (5)

Estimate parameters of a distribution using the method of cumulants:

Wolfram Language code: data = RandomVariate[BetaDistribution[3, 6], 10 ^ 4];

Wolfram Language code: NSolve[Table[Cumulant[data, k] == Cumulant[BetaDistribution[a, b], k], {k, 1, 2}], {a, b}]

The law of large numbers states that a sample moment approaches the population moment as the sample size increases. Use Histogram to show the probability distribution of sample cumulant of standard normal random variates for different sample sizes:

Wolfram Language code:

Histogram[Table[Cumulant[RandomReal[NormalDistribution[], {n, 10 ^ 3}], 3], {n, {10, 10^2, 10^4}}], 50, "ProbabilityDensity", ChartLegends -> {10, 10^2, 10^4}]

Edgeworth's expansion of order :

Wolfram Language code:

EdgeworthSeries[p_ /; p ≥ 2, y_] := With[{z = (y - Cumulant[1]), σ = Sqrt[Cumulant[2]]}, PDF[NormalDistribution[0, σ], z](1 + Sum[(σ^s/2^(s/2) + rs!)HermiteH[s + 2r, (z/Sqrt[2]σ)]BellY[s, r, Table[(Cumulant[k]/(k - 1)k σ^2k - 2), {k, 3, p}]], {s, p - 2}, {r, s}])]

Approximate SechDistribution:

Wolfram Language code: dist = SechDistribution[1, 2];

Wolfram Language code: pdf = MomentEvaluate[EdgeworthSeries[4, y], dist]

Wolfram Language code: Plot[{pdf, PDF[dist, y]}, {y, -5, 5}, PlotRange -> All]

Compute a moving cumulant for some data:

Wolfram Language code:

data = TemporalData[TimeSeries, {{{0., 0.06114665305643561, 0.23896662440972682, 0.30268800326923, 
    0.35534116766660545, 0.42472631677502126, 0.3966448861155263, 0.41578142003045876, 
    0.3468861633239847, 0.3381046650827597, 0.38002782955469216, 0. ... 208767424126402, 2.118103218029293, 2.18195782653722, 
    2.087973123089836}}, {{0, 1., 0.01}}, 1, {"Continuous", 1}, {"Continuous", 1}, 1, 
  {ValueDimensions -> 1, ResamplingMethod -> {"Interpolation", InterpolationOrder -> 1}}}, False, 
 10.1];

Use the window of length .1:

Wolfram Language code: mc = MovingMap[Cumulant[#, 2]&, data, .1];

Wolfram Language code: ListLinePlot[mc, PlotRange -> All]

Compute cumulants for slices of a collection of paths of a random process:

Wolfram Language code: data = RandomFunction[WienerProcess[], {0, 1, .01}, 10 ^ 3];

Choose a few slice times:

Wolfram Language code: times = Range[0, 1, .1];

Wolfram Language code: cm = Map[{#, Cumulant[data[#], 2]}&, times];

Plot cumulants over these paths:

Wolfram Language code: Show[ListPlot[data], ListLinePlot[cm, PlotStyle -> Green]]

Properties & Relations (5)

First cumulant is equivalent to the first moment :

Wolfram Language code: MomentConvert[Cumulant[1], Moment]

Second cumulant is equivalent to the second central moment :

Wolfram Language code: MomentConvert[Cumulant[2], CentralMoment]

Third cumulant is equivalent to the third central moment :

Wolfram Language code: MomentConvert[Cumulant[3], CentralMoment]

Cumulant is equal to the derivative of the cumulant-generating function at zero :

Wolfram Language code: cgf = CumulantGeneratingFunction[ExponentialDistribution[λ], t]

Wolfram Language code: SeriesCoefficient[cgf r!, {t, 0, r}]

Use Cumulant directly:

Wolfram Language code: Cumulant[ExponentialDistribution[λ], r]

Find the cumulant-generating function using GeneratingFunction:

Wolfram Language code: Cumulant[PoissonDistribution[μ], r]

Wolfram Language code: cgf = GeneratingFunction[% / r!, r, t]

Check using CumulantGeneratingFunction:

Wolfram Language code: CumulantGeneratingFunction[PoissonDistribution[μ], t]

Formally, cumulants can be computed using the fact that CumulantGeneratingFunction[dist,t] is given by Log[MomentGeneratingFunction[dist,t]]:

Wolfram Language code:

Clear[mgf];
Series[Log@mgf[x], {x, 0, 3}]
coeff = SeriesCoefficient[%, 3]3!

Plug in the definition for the moments in terms of their generating function:

Wolfram Language code: rep = {mgf[0] -> 1, Derivative[n_][mgf][0] :> Moment[n]};

Wolfram Language code: (coeff /. rep) == MomentConvert[Cumulant[3], Moment]

Sample estimator of Cumulant on data is biased:

Wolfram Language code: (se = MomentConvert[Cumulant[4], "SampleEstimator"])//TraditionalForm

Find a sampling population expectation, assuming size :

Wolfram Language code: see = MomentConvert[se, {Cumulant, n}]

Construct an unbiased sample estimator using PowerSymmetricPolynomial:

Wolfram Language code: (ue = MomentConvert[Cumulant[4], "UnbiasedSampleEstimator", PowerSymmetricPolynomial])//TraditionalForm

Verify unbiasedness on a small sample size:

Wolfram Language code:

Expand[MomentEvaluate[ue, {Subscript[x, 1], Subscript[x, 2], Subscript[x, 3], Subscript[x, 4], Subscript[x, 5]}]] /. Subscript[x, i_]^r_. :> Moment[r]

Wolfram Language code: MomentConvert[%, Cumulant]

The sample estimator is biased:

Wolfram Language code:

MomentConvert[Expand[Cumulant[{Subscript[x, 1], Subscript[x, 2], Subscript[x, 3], Subscript[x, 4], Subscript[x, 5]}, 4]] /. Subscript[x, i_]^r_. :> Moment[r], Cumulant]

Compare with the sampling population expectation of the sample estimator:

Wolfram Language code: see /. n -> 5

Possible Issues (1)

For some distributions with long tails, cumulants of only several low orders are defined:

Wolfram Language code: Table[Cumulant[ParetoDistribution[k, 5], r], {r, 5}]

Neat Examples (2)

Find an unbiased estimator for a product of cumulants:

Wolfram Language code:

MomentConvert[Cumulant[1]Cumulant[2]Cumulant[3], {"UnbiasedEstimator", n}, "PowerSymmetricPolynomial"]//FullSimplify//TraditionalForm

Check the sampling population expectation:

Wolfram Language code: MomentConvert[%, {Cumulant, n}]

The distribution of Cumulant estimates for 20, 100, and 300 samples:

Wolfram Language code: Cumulant[ExponentialDistribution[0.9], 2]

Wolfram Language code:

SmoothHistogram[Table[Cumulant[RandomVariate[ExponentialDistribution[0.9], {s, 1000}], 2], {s, {20, 100, 300}}], Filling -> Axis, PlotLegends -> {20, 100, 300}, PlotRange -> {{0, 4}, Automatic}]

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

Cumulant

Details

Examples

Basic Examples (3)

Scope (26)

Basic Uses (6)

Array Data (5)

Image and Audio Data (2)

Date and Time (4)

Distribution and Process Cumulants (5)

Formal Cumulants (4)

Applications (5)

Properties & Relations (5)

Possible Issues (1)

Neat Examples (2)

Text

CMS

APA

BibTeX

BibLaTeX

	Cumulant[,r]	»
	Cumulant[dist,{r₁,…,r_m}]	»

Cumulant

Details

Examples

Basic Examples (3)

Scope (26)

Basic Uses (6)

Array Data (5)

Image and Audio Data (2)

Date and Time (4)

Distribution and Process Cumulants (5)

Formal Cumulants (4)

Applications (5)

Properties & Relations (5)

Possible Issues (1)

Neat Examples (2)

See Also

Related Guides

Related Workflows

History

Text

CMS

APA

BibTeX

BibLaTeX