Statistical functions

STDEV.P

Matches all 1,334 recorded answers

Recorded: 1,221 in the answer bank and 113 workbook cells. How we measure this · See the Rust code

Local names in 40 languages

Language	Name in Excel
Arabic	`STDEV.P`
Bulgarian	`STDEV.P`
Czech	`STDEV.P`
Danish	`STDAFV.P`
German	`STDEV.P`
Greek	`STDEV.P`
English (Australia)	`STDEV.P`
English (United Kingdom)	`STDEV.P`
English (United States)	`STDEV.P`
Spanish	`DESVEST.P`
Estonian	`STDEV.P`
Finnish	`KESKIHAJONTA.P`
French	`ECARTYPE.PEARSON`
Hebrew	`STDEV.P`
Croatian	`STDEV.P`
Hungarian	`SZÓR.S`
Indonesian	`STDEV.P`
Italian	`STDEV.P`
Japanese	`STDEV.P`
Korean	`STDEV.P`
Lithuanian	`STDEV.P`
Latvian	`STDEV.P`
Norwegian	`STDEV.P`
Dutch	`STDEV.P`
Polish	`ODCH.STAND.POPUL`
Portuguese (Brazil)	`STDEV.P`
Portuguese (Portugal)	`DESVPAD.P`
Romanian	`STDEV.P`
Russian	`СТАНДОТКЛОН.Г`
Slovak	`STDEV.P`
Slovenian	`STDEV.P`
Serbian (Latin)	`STDEV.P`
Swedish	`STDAV.P`
Thai	`STDEV.P`
Turkish	`STDSAPMA.P`
Ukrainian	`STDEV.P`
Vietnamese	`STDEV.P`
Chinese (Simplified)	`STDEV.P`
Chinese (Hong Kong)	`STDEV.P`
Chinese (Traditional)	`STDEV.P`

Names from Microsoft's support site.

What it does

STDEV.P(number1, [number2], ...)

STDEV.P(number1, [number2], ...) measures population standard deviation. It reports spread in the original units by taking the square root of variance. The divisor is n: use this when the observations constitute the whole population.

Try it

=STDEV.P(-2,0,2) returns approximately 1.63299316185545. The mean is zero and the squared deviations total eight. Divide by three and then take the square root.

Quirks

Numbers in references and arrays count, including zero; referenced text, logical values and empty cells do not. Direct logical values and numeric text can count, so moving a constant into a cell can change the admitted data set. An empty numeric set gives #DIV/0!; a one-value population has zero spread. A centered mathematical formula alone does not reproduce the observed numerical path.

The variance family uses raw moments with stored steps, and two tests switch it to a centered sum

With RN(v) meaning v rounded to 64 bits on the x87 unit and then stored to binary64, S the running RN sum of the n values and Q the running RN sum of RN(x*x), the sample variance is RN(RN(Q - RN(RN(S*S)/n))/(n-1)) and the population variance RN(RN(RN(n*Q) - RN(S*S))/RN(n*n)). Excel then uses a centered sum instead, adding RN(d*d) with d = RN(x - mean) and dividing by n-1 or n, when either of two stored tests holds: RN(RN(RN(S*S)/n)/Q) > 0.99, or RN(variance*1000) <= |RN(S/n)|. The STDEV functions are the root of this, rounded to 64 bits and then stored. So the answer depends on which path a call takes: the first two VAR.S calls below differ by a few input steps in two arguments, the first passes the 0.99 test and is correctly rounded, and the second takes the raw moments and lands 76 units high. The next pair shows the size test: scaling the inputs by 4 leaves the first path.

Explanation (inferred): These tests were located with scalar arguments in separate cells; that the same edges hold for ranges and arrays is inferred, and their readings have not been taken. RN(variance*1000) <= |mean| is not separated from the rearrangement variance <= |mean|/1000. That a raw moment which overflows also takes the centered sum is inferred from recorded answers that stay finite.

Formula	Excel	Mathematical value
`VAR.S(0.8769085090206681, 1, 1.123091490979332)` Excel 16.0 build 20527, Windows; bitness and CPU not recorded in this reading Inputs and reference value Number supplied through a cell. number1: `0.8769085090206681` `0x3fec0fa26efa7e14` number2: `1` `0x3ff0000000000000` number3: `1.123091490979332` `0x3ff1f82ec882c0f6`	`0.01515151515151495` `0x3f8f07c1f07c1e94`	—
`VAR.S(0.8769085090206679, 1, 1.1230914909793321)` Excel 16.0 build 20527, Windows; bitness and CPU not recorded in this reading Inputs and reference value Number supplied through a cell. number1: `0.8769085090206679` `0x3fec0fa26efa7e12` number2: `1` `0x3ff0000000000000` number3: `1.1230914909793321` `0x3ff1f82ec882c0f7` Exact rational variance of the binary64 inputs, correctly rounded.	`0.015151515151515138` `0x3f8f07c1f07c1f00`	`0.015151515151515006` `0x3f8f07c1f07c1eb4`
`VAR.S(3.244042371786199e-10, 0.00034050419142641947)` Excel 16.0 build 20527, Windows; bitness and CPU not recorded in this reading Inputs and reference value Number supplied through a cell. number1: `3.244042371786199e-10` `0x3df64afacd3a935a` number2: `0.00034050419142641947` `0x3f3650b65dc7a1d6`	`5.797144172853e-08` `0x3e6f1f88c6bbc51a`	—
`VAR.S(1.2976169487144796e-09, 0.0013620167657056779)` Excel 16.0 build 20527, Windows; bitness and CPU not recorded in this reading Inputs and reference value Number supplied through a cell. number1: `1.2976169487144796e-09` `0x3e164afacd3a935a` number2: `0.0013620167657056779` `0x3f5650b65dc7a1d6` Exact rational variance of the binary64 inputs, correctly rounded.	`9.275430676564799e-07` `0x3eaf1f88c6bbc519`	`9.2754306765648e-07` `0x3eaf1f88c6bbc51a`
`=VAR.S({157,376.82,189.207,12.38,12.473,483,306.24,324.1852,482.235,78})` Excel 16.0.20527.20088 Current Channel, Windows 64-bit (NT 10.0.26200), x86-64, AMD Ryzen 7 4800H, en-ZA Inputs and reference value Typed formula. Exact rational variance of the binary64 inputs, correctly rounded.	`31907.480453381795` `0x40df28debfbf8a84`	`31907.480453381777` `0x40df28debfbf8a7f`
`STDEV.S(0, 1, 1.031052478719249)` Excel 16.0 build 20527, Windows; bitness and CPU not recorded in this reading Inputs and reference value Number supplied through a cell. number1: `0` `0x0000000000000000` number2: `1` `0x3ff0000000000000` number3: `1.031052478719249` `0x3ff07f30e248f14c`	`0.5865198874587454` `0x3fe2c4c55ae2d85e`	—

Inputs, build details and evidence

How to implement

Apply the collection rules above, then use the stored variance recipe. This function uses the population branch, with final divisor n and the staged square root.

For the three values -2,0,2, the stored totals are S=0, Q=8, T=0. The population numerator is 3*8-0=24 and the stored divisor is 3*3=9. Take the staged square root of the resulting variance. Do not replace the population operation tree by the sample tree with a changed final divisor.

The same two guards can redirect this call to the centered pass. For 1000,1001,1002, that pass sums 1+0+1=2 and divides by 3. The result then takes the staged square root. The exact scalar guard edges are measured; their transfer to references and arrays remains open. Nonfinite raw-moment fallback is inferred. No Handbook vector suite is published for this function.

Rust code

Show the CalcFunc source of this function

Quoted from the public repository DnaCalc/DnaCalc, crates calc-func and calc-fml, at commit 9e1884369a67. Comments are the source's own. A kernel shared with other functions appears once, on its module page.

STDEV.P · 3 lines · calc-func/src/catalogue/statistics.rs on GitHub

25 stdev_p "STDEV.P" (1, 255) [R "number1", R "number2"] |s, a, sv| {
    variance(s, a, sv, Held::Numbers, VarianceDivisor::Population, true)
}

Kernels shared with other functions

all catalogue/statistics
variance catalogue/statistics
excel_sqrt_staged ported/excel_numeric
variance_from_values ported/variance_common
stdev_from_values ported/variance_common

Argument and result plumbing

numbers catalogue/kit
out catalogue/kit

No implementation has been published with a Handbook test suite for this function.

Version differences

The recorded environments below distinguish a reading from a same-input comparison. Counts describe captured inputs in each environment; overlapping captures and comparisons are not totals of unique worksheet calls.

Excel 16.0 build	Platform and CPU	Captured inputs
20430	Windows, 64-bit, CPU not recorded	1,211

The record contains no same-input comparison between these environments. Reading different inputs on different builds does not establish either a version change or cross-build agreement.

Recorded environments and comparison details.

Retained controls from the indexed captures:

Build and recorded CPU	Captured call or arguments	Excel result
20430, CPU not recorded	`STDEV.P(1,2)`	`0.5` (`0x3fe0000000000000`)

These are earlier recorded answers, not new Excel runs or an additional cross-build comparison. The function JSON retains each source locator, exact argument bits where available, and input-route status. Call notation does not imply that captured binary64 values were entered as decimal formula literals.

Excel 16.0 build 20430

Windows, 64-bit, CPU not recorded

1,211 captured inputs are indexed for this environment. Capture dates: 2026-09-29 to 2026-09-29. This is a reading count, not a comparison with another build. Retained control STDEV.P(1,2) returned 0.5 (0x3fe0000000000000). The capture specifies exact-double bulk Value2 cell input.

Observed formulas and results

STDEV.P(1,2) → 0.5
0x3fe0000000000000 (cell-value2)

Alternatives

Use STDEV.S when the observations are a sample. VAR.P keeps the population variance in squared units. STDEVPA includes logical values and referenced text.

Named variants

No named variants are recorded yet.

Suggest a correction or contribute an implementation · For agents