Wolfram Language & System Documentation Center

Moment

Moment[data,r]

gives the order r moment of data.

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

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

Moment[dist,…]

gives the moment of the distribution dist.

Moment[r]

represents the order r formal moment.

Details

Moment is also known as a raw moment.
For scalar order r and data being an array :
sum of r powers »

columnwise sum of r powers »

$x in TemplateBox[{Arrays, paclet:ref/Arrays}, RefLink, BaseStyle -> {3ColumnTableMod}][{n_(1),...,n_(k)}]$ columnwise sum of r powers »
Moment[x,r] is equivalent to ArrayReduce[Moment[#,r]&,x,1].
For vector order {r₁,…,r_m} and data being array :
sum the r_j power in the j column

$x in TemplateBox[{Arrays, paclet:ref/Arrays}, RefLink, BaseStyle -> {3ColumnTableMod}][{n_(1),...,n_(k)}]$ sum the r_j power in the j column »
Moment[x,{r₁,…,r_m}] is equivalent to ArrayReduce[Moment[#, ${r_1,r_2,...,r_m}$ ]&,x,{{1},{2}}].
Moment 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 channels values or grayscale intensity value »
	Audio	amplitude values of all channels »

For a distribution dist, the r moment is given by Expectation[x^r,xdist]. »
For a multivariate distribution dist, the {r₁,…,r_m} moment is given by Expectation[x₁^r₁⋯ x_m^r_m,{x₁,…,x_m}dist]. »
For a random process proc, the moment function can be computed for slice distribution at time t, SliceDistribution[proc,t], as μ_r[t]=Moment[SliceDistribution[proc,t],r]. »
Moment[r] can be used in functions such as MomentConvert, MomentEvaluate, etc. »

Examples

open all close all

Basic Examples (2)

Compute moments from data:

Wolfram Language code: Moment[RandomVariate[NormalDistribution[], 10 ^ 4], 2]

Use symbolic data:

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

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

Compute the second moment of a univariate distribution:

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

The moment for a multivariate distribution:

Wolfram Language code: Moment[BinormalDistribution[ρ], {2, 2}]

Scope (22)

Basic Uses (6)

Exact input yields exact output:

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

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

Approximate input yields approximate output:

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

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

Find moments of WeightedData:

Wolfram Language code: Moment[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: Moment[WeightedData[data, weights], 2]

Find a moment 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: Moment[EventData[e, ci], 1]

Find a moment of TimeSeries:

Wolfram Language code:

Moment[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 moment depends only on the values:

Wolfram Language code:

Moment[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 moment for data involving quantities:

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

Wolfram Language code: Moment[data, 2]

Array Data (5)

For a matrix, Moment gives columnwise moments:

Wolfram Language code:

Moment[(⁠|       |       |
| ----- | ----- |
| a1, 1 | a1, 2 |
| a2, 1 | a2, 2 |⁠), 3]

For an array, Moment gives columnwise moments at the first level:

Wolfram Language code: Moment[Array[Subscript[a, ##]&, {2, 2, 2}], 3]//MatrixForm

Multivariate Moment for an array:

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

Works with large arrays:

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

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

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

Wolfram Language code:

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

Wolfram Language code: Moment[assoc, 3]

SparseArray data can be used just like dense arrays:

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

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

Find the moment of a QuantityArray:

Wolfram Language code: data = QuantityArray[RandomReal[1, 6], "Pounds"]

Wolfram Language code: Moment[data, 7]

Image and Audio Data (2)

Channelwise moment of an RGB image:

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

Wolfram Language code: RGBColor[%]

Moment intensity value of a grayscale image:

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

On audio objects, Moment works channelwise:

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

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

Wolfram Language code: Moment[a, 3]

Distribution and Process Moments (5)

Scalar moment for univariate distributions:

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

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

Scalar moment for multivariate distributions:

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

Wolfram Language code: Moment[DirichletDistribution[{a, b, c}], 2]

Joint moment for multivariate distributions:

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

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

Compute a moment for a symbolic order r:

Wolfram Language code: Moment[BetaDistribution[a, b], r]

A moment may only evaluate for specific orders:

Wolfram Language code: Moment[ExtremeValueDistribution[a, b], r]

Wolfram Language code: % /. r -> 3

A moment may only evaluate numerically:

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

Wolfram Language code: N[%]

Moments for derived distributions:

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

Wolfram Language code: Moment[ProbabilityDistribution[(Sqrt[2] / π) / (1 + (x - 2)^4), {x, -∞, ∞}], 1]

Data distribution:

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

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

Moment function for a random process:

Wolfram Language code: Moment[BrownianBridgeProcess[μ, σ][t], 4]

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

Find a moment of TemporalData at a time t=0.5:

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

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

Find the corresponding moment function together with all the simulations:

Wolfram Language code:

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

Formal Moments (4)

TraditionalForm formatting for formal moments:

Wolfram Language code: Moment[r]//TraditionalForm

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

Convert combinations of formal moments to an expression involving Moment:

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

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

Evaluate an expression involving formal moments μ₂+μ₃ for a distribution:

Wolfram Language code: MomentEvaluate[Moment[2] + Moment[3], PoissonDistribution[λ]]

Evaluate for data:

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

Wolfram Language code: MomentEvaluate[Moment[2] + Moment[3], data]

Find a sample estimator for an expression involving Moment:

Wolfram Language code: estimator = MomentConvert[Moment[2], "UnbiasedSampleEstimator"]

Evaluate the resulting estimator for data:

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

Wolfram Language code: MomentEvaluate[estimator, data]

Applications (10)

Moments for Data and Time Series (3)

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

Wolfram Language code:

Histogram[Table[Moment[RandomReal[1, {n, 10 ^ 3}], 2], {n, {10, 10^2, 10^3}}], 40, "ProbabilityDensity", ChartLegends -> {10, 10^2, 10^3}]

Visualize the convergence process:

Wolfram Language code: ListLinePlot[Accumulate[RandomReal[1, 10 ^ 4] ^ 2] / Range[10 ^ 4], PlotRange -> {0.2, 0.5}]

Compute a moving moment of a time series data:

Wolfram Language code:

data = TemporalData[TimeSeries, {{{0., -0.024510587716402032, -0.23697150976969208, -0.12178339223049947, 
    0.0356898098034821, 0.136151185542904, 0.0510713902440678, 0.28475806711161716, 
    0.25987506162754515, 0.2754574024933936, 0.2083480628921990 ... 1538234, -0.09713966281751486, 0.005118404645412064, 
    0.1288920274799618}}, {{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: md = MovingMap[Moment[#, 2]&, data, .1];

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

Compute moments 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: m = Map[{#, Moment[data[#], 4]}&, times];

Plot the fourth moments over these paths:

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

Method of Moments (3)

Estimate parameters of a distribution using the method of moments:

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

Wolfram Language code: meq = Table[Moment[data, k] == Moment[GammaDistribution[α, β], k], {k, 1, 2}]

Wolfram Language code: NSolve[meq, {α, β}]

Compare the data with the estimated parametric distribution:

Wolfram Language code:

Show[Histogram[data, Automatic, "PDF"], Plot[Evaluate[PDF[GammaDistribution[α, β], x] /. %], {x, 0, 100}, PlotStyle -> Thick]]

Find normal approximation to GammaDistribution using the method of moments:

Wolfram Language code: gdist = GammaDistribution[α, β];

Wolfram Language code: meq = Table[Moment[gdist, k] == Moment[NormalDistribution[μ, σ], k], {k, 1, 2}]

Show how and depend on and :

Wolfram Language code: Solve[(And@@meq)∧σ > 0, {μ, σ}, Reals]

Wolfram Language code: {ndist} = Refine[NormalDistribution[μ, σ] /. %, β > 0∧α > 0]

Compare the original and the approximated distributions:

Wolfram Language code: Plot[{PDF[gdist, x], PDF[ndist, x]} /. {α -> 13, β -> 3}, {x, 0, 80}, Evaluated -> True]

Moments of PearsonDistribution satisfy a three-term recurrence equation implied by the defining differential equation for the density function :

Wolfram Language code:

eq[r_] := r * Subscript[b, 0] * Moment[r - 1] + (r + 1) Subscript[b, 1] * Moment[r] + (r + 2) Subscript[b, 2] * Moment[r + 1] - Subscript[a, 1] * Moment[r + 1] - Subscript[a, 0] * Moment[r]

Wolfram Language code: meq = Table[eq[r], {r, 0, 3}]

Verify the moment equations:

Wolfram Language code:

MomentEvaluate[meq, PearsonDistribution[Subscript[a, 1], Subscript[a, 0], Subscript[b, 2], Subscript[b, 1], Subscript[b, 0]]]//FullSimplify

Use the recurrence equation to express parameters of PearsonDistribution in terms of its moments:

Wolfram Language code:

dist = PearsonDistribution[Subscript[a, 1], Subscript[a, 0], Subscript[b, 2], Subscript[b, 1], Subscript[b, 0]] /. Solve[meq == 0 /. Moment[0] -> 1, {Subscript[a, 1], Subscript[a, 0], Subscript[b, 2], Subscript[b, 1], Subscript[b, 0]}][[1]];

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

Fit PearsonDistribution to data:

Wolfram Language code: fdist = MomentEvaluate[dist, data] /. Subscript[a, 1] -> 1

Wolfram Language code: Show[Histogram[data, {-10, 10, 1}, "ProbabilityDensity"], Plot[PDF[fdist, x], {x, -10, 10}, PlotStyle -> Thick]]

Check that moments of the resulting distribution are equal to moments of data:

Wolfram Language code: MomentEvaluate[{Moment[1], Moment[2], Moment[3], Moment[4]}, fdist]

Wolfram Language code: MomentEvaluate[{Moment[1], Moment[2], Moment[3], Moment[4]}, data]

PDF Approximations from Moments (3)

Two different distributions can have the same sequence of moments:

Wolfram Language code: dist1 = ProbabilityDistribution[(1/4)Exp[-Abs[x]^1 / 2], {x, -Infinity, Infinity}];

Wolfram Language code: dist2 = ProbabilityDistribution[(1/4)Exp[-Abs[x]^1 / 2](1 + Cos[Sqrt[Abs[x]]]), {x, -Infinity, Infinity}];

Compare their densities on log-scale:

Wolfram Language code: LogPlot[{PDF[dist1, x], PDF[dist2, x]}, {x, -100, 100}, PlotRange -> All]

Compute their moments:

Wolfram Language code: Moment[dist1, k]

Wolfram Language code: Moment[dist2, k]

Prove them equal for all non-negative integer orders:

Wolfram Language code: FullSimplify[% == %%, k∈Integers && k ≥ 0]

Build type A Gram–Charlier expansion of order 6:

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

Wolfram Language code:

pdf = PDF[NormalDistribution[], z] * Sum[(Underoverscript[∑, k = 0, Floor[(r/2)]]((-1)^r - k Moment[data, r - 2 k]/(k! (r - 2 k)!) 2^k))(-(1/Sqrt[2]))^rHermiteH[r, (z/Sqrt[2])], {r, 0, 6}]

Wolfram Language code: Show[Histogram[data, 20, "ProbabilityDensity"], Plot[pdf, {z, -4, 4}]]

A monotone PDF with a positive domain is bounded by :

Wolfram Language code: 𝒟 = ExponentialDistribution[1];

Prove the identity for exponential distribution for the first few orders:

Wolfram Language code: Table[Reduce[PDF[𝒟, x] > (r + 1)Moment[𝒟, r] / x ^ (r + 1) && x > 0, x, Reals], {r, 1, 5}]

Wolfram Language code:

LogPlot[{PDF[𝒟, x], Table[(r + 1)Moment[𝒟, r] / x ^ (r + 1), {r, 5}]}//Evaluate, {x, 1, 15}, PlotStyle -> {Thick}~Join~Table[Dashed, 5]]

Expectation Approximation from Moments (1)

Find quadrature rule for approximating the expectation of a function of a random variable:

Wolfram Language code:

𝒩 = 6;
𝒟 = PoissonDistribution[5];

Find lowest-order orthogonal polynomials:

Wolfram Language code: mat = Table[Moment[𝒟, n + m], {n, 0, 𝒩}, {m, 0, 𝒩}];

Wolfram Language code: polys = (x ^ Range[0, 𝒩]).Inverse[CholeskyDecomposition[mat]]

Check their orthonormality:

Wolfram Language code: PadLeft[Table[NExpectation[polys[[i]] polys[[j]], x𝒟], {i, 𝒩}, {j, i, 𝒩}]]//Quiet//Chop

Find quadrature points:

Wolfram Language code: pts = x /. {ToRules[NRoots[Last[polys] == 0, x]]}

Find quadrature weights, requiring rule to be exact on polynomials of order up to :

Wolfram Language code: weights = LinearSolve[Transpose@Outer[Power, pts, Range[0, 𝒩]], Table[Moment[𝒟, r], {r, 0, 𝒩}]]

Compute approximation to expectation of :

Wolfram Language code: weights.(1 + pts ^ 2)^3 / 2

Check with NExpectation:

Wolfram Language code: NExpectation[(1 + x^2)^3 / 2, x𝒟]

Properties & Relations (8)

Moment of order r is equivalent to Expectation of the power r of the random variable:

Wolfram Language code: Expectation[x^4, xLogisticDistribution[0, 1]]

Wolfram Language code: Moment[LogisticDistribution[0, 1], 4]

A multivariate moment is equivalent to Expectation of a multivariate monomial:

Wolfram Language code: Expectation[x^4 y^2, {x, y}DirichletDistribution[{2, 3, 4}]]

Wolfram Language code: Moment[DirichletDistribution[{2, 3, 4}], {4, 2}]

For univariate distributions, Moment of order one is the Mean:

Wolfram Language code: Moment[NormalDistribution[μ, σ], 1] == Mean[NormalDistribution[μ, σ]]

The same is true for data:

Wolfram Language code:

Moment[{Subscript[x, 1], Subscript[x, 2], Subscript[x, 3], Subscript[x, 4], Subscript[x, 5]}, 1] == Mean[{Subscript[x, 1], Subscript[x, 2], Subscript[x, 3], Subscript[x, 4], Subscript[x, 5]}]

Mean of a multivariate distribution is a list of moments of its univariate marginal distributions:

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

Wolfram Language code: Mean[dist]

Wolfram Language code: {Mean[MarginalDistribution[dist, 1]], Mean[MarginalDistribution[dist, 2]]}

Alternatively, use Moment with orders given by unit vectors:

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

Moment of order is the same as when both exist:

Wolfram Language code: mgf = MomentGeneratingFunction[GammaDistribution[α, β], t]

Wolfram Language code: SeriesCoefficient[mgf, {t, 0, r}, Assumptions -> α > 0 && r ≥ 0]r!

Use Moment directly:

Wolfram Language code: Moment[GammaDistribution[α, β], r]

Wolfram Language code: FullSimplify[FunctionExpand[% == %%], α > 0∧β > 0∧r∈Integers∧r ≥ 0]

Find the moment-generating function by using GeneratingFunction:

Wolfram Language code: GeneratingFunction[Moment[RayleighDistribution[σ], r] / r!, r, t]

Compare with direct evaluation of MomentGeneratingFunction:

Wolfram Language code: MomentGeneratingFunction[RayleighDistribution[σ], t]

Wolfram Language code: Simplify[% == %%, σ > 0 && Im[t] == 0]

Moment can be expressed through CentralMoment, Cumulant or FactorialMoment:

Wolfram Language code: MomentConvert[Moment[4], CentralMoment]

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

Wolfram Language code: MomentConvert[Moment[6], FactorialMoment]

Sample moments are unbiased estimators of population moments:

Wolfram Language code: est = MomentConvert[Moment[{1, 2}], "SampleEstimator"]

Hence the sampling distribution expectation of the estimator equals the estimated moment:

Wolfram Language code: MomentConvert[est, Moment]

Verify this on a sample of fixed size; evaluate the estimator on the sample:

Wolfram Language code:

MomentEvaluate[est, {{Subscript[x, 1], Subscript[y, 1]}, {Subscript[x, 2], Subscript[y, 2]}, {Subscript[x, 3], Subscript[y, 3]}, {Subscript[x, 4], Subscript[y, 4]}, {Subscript[x, 5], Subscript[y, 5]}}]

Find its expectation assuming independent identically distributed random variables and :

Wolfram Language code: % /. (Subscript[x, i_] ^ n_. Subscript[y, j_] ^ m_.) :> Moment[{n, m}]

The multivariate moment of an array of depth has depth :

Wolfram Language code:

arr = Array[Subscript[a, Row@{##}]&, {n = 4, m = 3, 2, 3}];
rs = {2, 2, 2};
Length[rs] == m

Wolfram Language code:

Moment[arr, rs] == 
	 ArrayReduce[Mean, 
	ArrayReduce[Times@@Power[#, rs]&, arr, 2], 
	1]//Simplify

Possible Issues (2)

Heavy-tailed distributions may only have a few low-order moments defined:

Wolfram Language code: Moment[StudentTDistribution[5], r]

Some heavy-tailed distributions have no moments defined:

Wolfram Language code: Moment[CauchyDistribution[0, 1], r]

Often, quantiles can be used to characterize distributions:

Wolfram Language code: Quantile[CauchyDistribution[0, 1], p]

Neat Examples (2)

Find an unbiased estimator for a product of moments:

Wolfram Language code:

(est = MomentConvert[Moment[1]Moment[2]Moment[3], {"UnbiasedEstimator", n}, "PowerSymmetricPolynomial"])//TraditionalForm

Check unbiasedness for a special case of on a GammaDistribution:

Wolfram Language code:

𝒟 = GammaDistribution[α, β];
MomentEvaluate[est /. n -> 4, {x1, x2, x3, x4}]

Wolfram Language code: Expectation[%, {x1, x2, x3, x4}ProductDistribution[{𝒟, 4}]]

Wolfram Language code: % == MomentEvaluate[Moment[1]Moment[2]Moment[3], 𝒟]

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

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

Wolfram Language code:

SmoothHistogram[Table[Moment[RandomVariate[ExponentialDistribution[0.9], {s, 1000}], 2], {s, {20, 100, 300}}], Filling -> Axis, PlotLegends -> {20, 100, 300}, PlotRange -> {{0, 5}, 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

Moment

Details

Examples

Basic Examples (2)

Scope (22)

Basic Uses (6)

Array Data (5)

Image and Audio Data (2)

Distribution and Process Moments (5)

Formal Moments (4)

Applications (10)

Moments for Data and Time Series (3)

Method of Moments (3)

PDF Approximations from Moments (3)

Expectation Approximation from Moments (1)

Properties & Relations (8)

Possible Issues (2)

Neat Examples (2)

Text

CMS

APA

BibTeX

BibLaTeX

			sum of r powers »
			columnwise sum of r powers »
	$x in TemplateBox[{Arrays, paclet:ref/Arrays}, RefLink, BaseStyle -> {3ColumnTableMod}][{n_(1),...,n_(k)}]$		columnwise sum of r powers »

			sum the r_j power in the j column
	$x in TemplateBox[{Arrays, paclet:ref/Arrays}, RefLink, BaseStyle -> {3ColumnTableMod}][{n_(1),...,n_(k)}]$		sum the r_j power in the j column »

Moment

Details

Examples

Basic Examples (2)

Scope (22)

Basic Uses (6)

Array Data (5)

Image and Audio Data (2)

Distribution and Process Moments (5)

Formal Moments (4)

Applications (10)

Moments for Data and Time Series (3)

Method of Moments (3)

PDF Approximations from Moments (3)

Expectation Approximation from Moments (1)

Properties & Relations (8)

Possible Issues (2)

Neat Examples (2)

See Also

Related Guides

History

Text

CMS

APA

BibTeX

BibLaTeX