The pooled standard deviation is one combined estimate of spread built from two or more groups that are assumed to share the same true standard deviation.

You square each group's standard deviation, weight it by that group's degrees of freedom, add the weighted parts together, divide by the total degrees of freedom, and take the square root. For two groups of 12 with s₁ = 4.1960 and s₂ = 4.9013, the pooled variance is 20.8144 and the pooled standard deviation is 4.5623. It is the denominator of the two-sample t-test and of Cohen's d.

The pooled standard deviation is a single number that describes how spread out the observations are inside your groups, once every group has been combined into one estimate. It answers a narrow question: if all of these groups really do share the same underlying variability, and they only differ in where their centres sit, what is the best single estimate of that shared variability?

It is not the standard deviation of all the data thrown into one pile. That number would also contain the differences between the group means, which is exactly what you are usually trying to test. The pooled standard deviation strips those between-group differences out and keeps only the within-group scatter. That is why statisticians also call it the pooled within-group standard deviation or the pooled estimate of the common standard deviation.

How the pooling actually works, in four steps:

• Square each group's SD to get its variance. Variances add, standard deviations do not, so all pooling happens on the variance scale.
• Weight each variance by its degrees of freedom, nᵢ − 1. A group of 40 carries far more information about the common spread than a group of 5, and this weighting is what respects that.
• Add the weighted parts and divide by the total degrees of freedom, Σ(nᵢ − 1) = N − k. That gives the pooled variance, written s_p².
• Take the square root to return to the original units. That is s_p, the pooled SD.

A worked one-liner: two groups of 12 with standard deviations 4.1960 and 4.9013 have variances 17.6061 and 24.0227. Weighted by 11 degrees of freedom each, the pooled variance is (11 × 17.6061 + 11 × 24.0227) ÷ 22 = 20.8144, and the pooled standard deviation is 4.5623 with 22 degrees of freedom.

Who uses it: clinical trialists use it as the denominator of the two-sample t-test and of the standardised mean difference reported in every meta-analysis. Psychologists use it to build Cohen's d. Quality engineers use it to estimate short-term process variation across batches. Agronomists and ecologists meet it as the root mean square error in an ANOVA table, which is the same quantity under a different name. Anyone doing a power calculation needs it, because sample size formulas are written in units of the the pooled estimate.

4.1 What does the pooled standard deviation actually tell you?

The pooled standard deviation tells you how far a typical observation sits from its own group's mean, once every group has been combined into one estimate. It is measured in the units of your data. It carries no information about how far apart the group means are, which is exactly what makes it a fair yardstick.

The pooled standard deviation is your best single answer to the question "how much do individual observations vary around their own group's mean?" It is expressed in the units of your data, so if you measured blood pressure in mmHg then s_p is in mmHg, and you can read it the same way you read any standard deviation. A pooled SD of 4.56 mmHg means that within any group, a typical patient sits about 4.6 mmHg away from that group's mean.

What makes it different from an ordinary standard deviation is what it deliberately leaves out. It contains no information at all about how far apart the group means are. Two studies can share an identical pooled SD while one shows a huge treatment effect and the other shows none. That separation is the whole point: the pooled SD becomes the yardstick against which the difference between means is measured, and a yardstick must not itself depend on what you are measuring.

This is why almost every comparative statistic you meet has the pooled SD somewhere in its denominator. The t statistic divides the mean difference by a standard error built from s_p. Cohen's d divides the same mean difference by s_p itself. Sample size formulas are written in multiples of s_p. Get the pooled SD wrong and every one of those numbers is wrong with it.

4.2 Why do you pool variances instead of averaging standard deviations?

Standard deviations are square roots, and square roots do not add. Squared deviations do add, so all combining has to happen on the variance scale, with one square root taken at the very end. Averaging two standard deviations of 2 and 8 gives 5, when the correct pooled answer is 5.83.

This is the single most common mistake, and it is worth being blunt about. Standard deviations are square roots, and square roots do not add. If you take the plain average of two standard deviations you are computing something that has no statistical meaning, and it will differ from the correct answer by an amount that grows as the groups become more different in size or spread.

The correct route is always the same. Square each SD to get a variance. Variances live on a scale where the weighted sum makes sense, because a variance is an average squared deviation and squared deviations genuinely add up. Combine on that scale, then take one square root at the very end.

Here is the size of the error. Two groups with SDs of 2 and 8 and equal sample sizes have a simple average of 5. The correct pooled value is the square root of (4 + 64) / 2, which is 5.83. That is a 17% understatement of the spread, and it will inflate every t statistic and every effect size you compute from it. When the sample sizes also differ, the gap widens further.

4.3 Why are the weights degrees of freedom rather than sample sizes?

Each group contributes n minus 1 rather than n because estimating that group's mean already consumed one piece of information. A group of one therefore gets a weight of zero, which is correct: it tells you nothing about spread. Larger groups dominate, because they genuinely carry more information about the common variability.

Each group contributes nᵢ − 1 to the pooled estimate rather than nᵢ. The reason is that you had to estimate the group's own mean before you could measure deviations from it, and that estimation consumes exactly one piece of information. A group of one tells you nothing about spread, and n − 1 correctly gives it a weight of zero.

The practical consequence is that larger groups dominate. A group of 100 carries 99 units of weight while a group of 10 carries 9, so the larger group influences the pooled value roughly eleven times as much. This is right and desirable: the bigger sample really does contain more information about the common spread. It also means that a small group with a wild standard deviation will move the pooled answer less than people expect, which is a feature rather than a bug.

It follows that the the pooled estimate always lies between the smallest and the largest group SD, never outside that range. If your calculator returns a value outside it, something has gone wrong with the input, usually a group entered twice or a sample size typed incorrectly.

4.4 What are the degrees of freedom for a pooled standard deviation?

The pooled degrees of freedom are N minus k: total observations minus the number of groups. Two groups of 12 give 24 minus 2 = 22. Four groups of 10 give 40 minus 4 = 36. Every group costs one degree of freedom because each one contributed its own mean to the calculation.

The pooled degrees of freedom are N − k, the total number of observations minus the number of groups. With two groups of 12 that is 24 − 2 = 22. With four groups of 10 it is 40 − 4 = 36. Every group costs you one degree of freedom because each one contributed its own mean.

Degrees of freedom matter for two reasons. They decide which t distribution you look the p value up in, and they tell you how much you should trust the pooled SD itself. Below about 10 pooled degrees of freedom the estimate is genuinely unstable and will bounce around noticeably from sample to sample. Above about 30 it settles down. Above 100 the t distribution is close enough to the normal that the distinction stops mattering in practice.

The df figure is also the fastest way to check that the tool and your software agree. If R reports df = 22 and your hand calculation says 23, you have miscounted a group somewhere, and the p values will not match until you fix it.

4.5 How equal do the group variances have to be before you can pool?

As a working rule, a variance ratio below 2 is comfortable, 2 to 4 is acceptable when the group sizes are similar, and above 4 you should stop pooling. Unequal group sizes make everything worse: a balanced design survives a ratio of 4, while a badly unbalanced one can fail at 2.

Pooling assumes homogeneity of variance: every group is drawn from a population with the same true standard deviation. If that holds, the pooled estimate is more precise than any single group's estimate, because it uses all the data. If it fails badly, the pooled value describes an average of two different things and misrepresents both.

The calculator gives you three ways to judge this. The variance ratio divides the largest group variance by the smallest. As a working rule, a ratio below 2 is comfortable, between 2 and 4 is acceptable when the group sizes are similar, and above 4 is a warning. The Levene style test, computed here on absolute deviations from each group's median and described in the NIST/SEMATECH e-Handbook of Statistical Methods, gives a formal p value: a small p value means the variances differ more than chance would explain. The chart of group variances lets you see whether one group is responsible or whether the spread rises steadily across groups.

Two important caveats. First, unequal group sizes make everything worse. With equal n, pooling is remarkably robust and survives a variance ratio of 3 or 4 without much damage. With very unequal n it can fail at a ratio of 2, and the direction of the error depends on whether the larger group is the more variable one. Second, a non-significant Levene test is not proof of equal variance, especially with small samples where the test has very little power. Use the ratio and the plot alongside it, not the p value alone.

4.6 What should you do when the variances are not equal?

Do not pool. Use Welch's t-test for two groups, or Welch's ANOVA with Games-Howell for more. If the spread grows with the mean, a log transformation often equalises the variances and lets you pool honestly on the transformed scale. Glass's delta avoids the assumption entirely by using the control group's SD.

Do not pool. The standard replacement for a two-group comparison is Welch's t-test, which keeps the two variances separate and adjusts the degrees of freedom downwards using the Welch-Satterthwaite formula. It costs almost nothing when the variances happen to be equal and protects you properly when they are not, which is why it is the default in R and why many methodologists now recommend using it always.

For more than two groups, Welch's ANOVA plays the same role, with the Games-Howell post hoc test in place of Tukey. If the spread rises with the mean, which is extremely common with counts, times and concentrations, a log or square root transformation will often make the variances equal and let you pool honestly on the transformed scale. Report the transformation and interpret on the transformed scale, or back-transform carefully.

If you still need an effect size when the variances differ, use Glass's delta, which divides by the control group's standard deviation alone rather than by a pooled value. It sidesteps the assumption entirely at the cost of using less of the data.

4.7 How is the pooled standard deviation used in Cohen's d?

Cohen's d divides the difference between two means by the pooled standard deviation, so a d of 1 means the means sit one pooled SD apart. Because the units cancel, d compares across studies. Hedges' g multiplies d by a correction factor J that removes the upward bias present in small samples.

Cohen's d is the difference between two means expressed in pooled standard deviations: d = (x̄₁ − x̄₂) ÷ s_p. A d of 1 means the two means sit one pooled SD apart. Because it is unitless, it can be compared across studies that measured different things on different scales, which is exactly why meta-analysis depends on it.

The conventional bands are 0.2 small, 0.5 medium and 0.8 large, and they should be treated as very rough. Cohen himself proposed them reluctantly as a last resort for fields with no established benchmarks. In a well-controlled laboratory setting a d of 0.3 may be substantial; in a noisy field trial a d of 0.8 may be unremarkable. Where your discipline has typical effect sizes, use those instead.

Cohen's d is biased upward in small samples. Hedges' g applies a correction factor, J = 1 − 3 ÷ (4df − 1), which shrinks the estimate slightly. At df = 22 the correction is about 3.4%, at df = 10 it is about 7%, and above df = 50 it becomes negligible. Report g rather than d whenever your total sample is under about 20, and say which one you used either way, because reviewers cannot tell them apart from the number alone.

4.8 How does the pooled standard deviation build the two-sample t-test?

The standard error of the difference is the pooled SD multiplied by the square root of (1/n1 + 1/n2), and the t statistic is the mean difference divided by that standard error, on N minus 2 degrees of freedom. The same pieces build the confidence interval, so the two always agree.

The two-sample t-test with equal variances assumed uses the s_p directly. The standard error of the difference is s_p × √(1/n₁ + 1/n₂), and the t statistic is the mean difference divided by that. The degrees of freedom are the pooled df, n₁ + n₂ − 2.

The same pieces build the confidence interval for the difference: the mean difference plus or minus t_critical times that standard error. If the interval excludes zero, the test is significant at the matching alpha, and the two statements are guaranteed to agree because they are built from identical parts. Reporting the interval is more informative than reporting the p value alone, because it shows the range of differences your data are compatible with rather than just whether zero is in it.

Notice the role of the sample sizes here. The pooled SD describes the data and does not shrink as you collect more of it. The standard error does shrink, because of the 1/n terms. That distinction explains why a large study can find a tiny difference statistically significant while the pooled SD, and therefore the effect size, stays modest.

4.9 Is the pooled standard deviation the same as the root mean square error?

Yes, in one-way ANOVA. The mean square within groups is exactly the pooled variance, and its square root is exactly the pooled standard deviation. Software labels the same number root mean square error, residual standard error, or sigma. That means you can recover it from a published ANOVA table with no raw data.

In one-way ANOVA the mean square within groups, MS_within, is exactly the pooled variance, and its square root is exactly the pooled standard deviation. Statistical software often labels it the root mean square error, RMSE, or the residual standard error. These are four names for one number.

That gives you a useful shortcut. If you already have an ANOVA table, you do not need the raw data to get the pooled SD: take the square root of the within-groups mean square. Conversely, if you have group means, SDs and sample sizes from a published paper, this calculator reconstructs the pooled SD and therefore the ANOVA error term without the original data, which is how meta-analysts work.

It also explains why Tukey's post hoc test uses the pooled SD from every group rather than just the two being compared. Using all the data gives more degrees of freedom and more power, provided the equal variance assumption holds across all groups, not just the pair in front of you.

4.10 How do you use the pooled standard deviation to plan sample size?

Power formulas are written in pooled SD units, so you need an estimate before collecting data. For a two-sample t-test at 80% power and alpha 0.05, you need roughly 16 divided by d squared participants per group. A d of 0.5 needs about 64 per group; a d of 0.8 needs about 25.

Power calculations are written in units of the the pooled value, which is why estimating it is normally the first step of a study design. For a two-sample t-test with 80% power at alpha = 0.05, you need roughly 16 ÷ d² participants per group, where d is the effect size you want to be able to detect. A d of 0.5 needs about 64 per group, and a d of 0.8 needs about 25.

The practical difficulty is that you need s_p before you have collected the data. The usual sources are a pilot study, a published paper on a similar population, or a plausible range from which you compute sample size at the pessimistic end. Because s_p from a small pilot is itself imprecise, it is sensible to use the upper end of its confidence interval rather than the point estimate, otherwise you will systematically design studies that are slightly too small.

4.11 A decision guide

4.12 Common mistakes this calculator prevents

• Averaging the standard deviations. The tool always squares first, weights by df, then takes one root at the end.
• Weighting by n instead of n − 1. The weights are shown explicitly in the working, so you can see them.
• Pooling the whole dataset. Computing one SD over all values combined includes the between-group differences and inflates the answer. The tool never does this and reports the total SD separately so you can see the gap.
• Using the population SD. The default is the n − 1 sample version, which is what the pooled formula requires.
• Ignoring unequal variances. The equal-variance panel runs automatically and flags a ratio above 4 in red.
• Reporting d when g was needed. Both are given, with the correction factor shown, so the small sample choice is explicit.
• Miscounting degrees of freedom. N, k and N − k are all displayed rather than assumed.

▶ Run the analysis above to auto-fill all five examples with your own results.

A pooled standard deviation is almost never the headline of a results section. It is the supporting number that makes the headline believable, so it usually appears inside a sentence about a t-test, an effect size or an ANOVA rather than on its own line. The five templates below cover the styles you are most likely to need. Each one is filled with your numbers once you press Calculate, and each has its own Copy button.

1. Enter your data. The default tab takes comma-separated numbers, exactly as the placeholder shows: 52, 48, 55, 61, 47, .... Newlines, tabs, semicolons and spaces all work, so a column pasted straight from Excel is fine.
2. Name each group. The group name box above every textarea is editable. Type something meaningful such as Placebo or Batch 3, night shift and it flows into the results table, all four charts and the exported report.
3. Add or remove groups. Press Add group for a third, fourth or twelfth group. The pooled formula extends to any number of groups, and the degrees of freedom update to N − k automatically.
4. Or upload a file. On the Upload tab, choose a CSV or Excel file and click the column names you want. Every column you click becomes its own group, and the preview highlights and badges the columns you have selected before you load them.
5. Try a sample dataset. Ten built-in datasets cover the cases that matter: a clean clinical trial where pooling is exactly right, unequal group sizes, three and four group designs, a set where one group is far more variable than the others, and a case where a single outlier breaks the assumption.
6. Keep the sample standard deviation setting. The n − 1 version is what the pooled formula is defined on. Only switch to the population version if you are deliberately reproducing a population calculation.
7. Choose your confidence level and tails. These affect the confidence interval for the difference and the t-test p value when you have exactly two groups.
8. Press Calculate Pooled Standard Deviation. Nothing is computed until you do, and changing any input or setting clears the results, so you never read stale numbers.
9. Read the equal-variance panel before the headline number. The variance ratio and the Levene style test tell you whether pooling is defensible at all. A red flag there matters more than the pooled value itself.
10. Check the four charts and export. Chart 1 shows every group mean against the pooled band, which is usually the figure you want in a paper. Section 5 auto-fills five reporting styles, and the buttons export a text report or a print-ready PDF.

Worked example. Load sample dataset 1, press Calculate, and you should see a pooled standard deviation of 4.5623 on 22 degrees of freedom, with Cohen's d = 1.8814 and Hedges' g = 1.8165. Those are the same numbers the Excel, R and Python sections below produce.

Excel has no POOLEDSD function, which is why this is one of the most searched spreadsheet questions in statistics. You build it from three functions you already know: VAR.S, COUNT and SQRT. This section shows the step by step layout first, because that is what a marker or a reviewer wants to see, then collapses the whole thing into a single cell formula, then extends it to three or more groups. Every screenshot uses the same worked dataset as the R and Python sections below, so all three agree to four decimal places.

8.1 The functions you need

8.2 Step by step

8.3 Three or more groups, and other awkward cases

The two-group formula is a special case. For k groups the denominator is N minus k, not N minus 2, and forgetting to change it is the most common Excel error in this area.

Unequal group sizes need no special handling as long as each range is correct. Give each column its own COUNT rather than typing 12 three times, otherwise a change in one group silently corrupts the answer.

Long format data, where one column holds the value and another holds the group label, is more common in real files. Compute each group's sum of squares with a conditional variance built from AVERAGEIF and SUMPRODUCT, or simply sort by group and use separate ranges, which is faster and far easier to check.

That expression gives the sum of squares for one group directly from long format data. Divide the total of these by N minus k as usual.

If you only have published means, SDs and sample sizes, and no raw data at all, the pooled SD is still recoverable. Enter the SDs and the n values in two small columns and use =SQRT(SUMPRODUCT((B2:B4-1),(C2:C4)^2)/(SUM(B2:B4)-COUNT(B2:B4))), with n in column B and SD in column C. This is exactly how meta-analysts reconstruct effect sizes from papers.

8.4 Why your Excel answer might differ from R or Python

8.5 Charting the pooled standard deviation in Excel

1. Select your group names and their means.
2. Insert → Charts → Clustered Column.
3. Click the chart, press the + button, tick Error Bars, then More Options → Custom → Specify Value and point at a column holding the pooled SD repeated once per group.
4. Using the pooled SD for every bar rather than each group's own SD is the honest choice when you have already assumed equal variances, and it makes the figure agree with the test you ran.
5. State in the caption that the bars are the pooled standard deviation. An unlabelled error bar is grounds for revision at most journals.
6. To show the assumption itself, plot each group's variance as a second chart. If one bar towers over the others, pooling was not appropriate and the figure says so at a glance.

Charts 1 and 2 in section 3 of this page draw both of these automatically, which is usually quicker than rebuilding them in Excel.

8.6 Excel errors you will probably hit

R has no single pooled.sd() function in base, which surprises people, but the calculation is three lines once you have the group variances. The script below is complete and runnable. It computes the pooled standard deviation for any number of groups, runs the equal-variance check, produces Cohen's d and Hedges' g when there are exactly two groups, prints a plain-English verdict, and saves one 300 dpi figure. It uses base R only, so there is nothing to install.

9.1 The complete script

R, base only, saves pooled_sd_plot.png

# ============================================================
# Pooled standard deviation, pooled variance, Cohen's d and
# the equal-variance t-test, with one publication-ready plot
# StatsUnlock - https://statsunlock.com/pooled-standard-deviation-calculator/
# Base R only. No packages to install.
# ============================================================

set.seed(42)   # only matters if you add simulation below

# ---- 1. Your data ------------------------------------------
# Replace with your own values, or read a CSV:
#   dat <- read.csv("data.csv")
#   groups <- split(dat$value, dat$group)
# Missing values are dropped below, so NAs are safe here.

groups <- list(
  "Placebo"   = c(52, 48, 55, 61, 47, 50, 58, 53, 49, 56, 51, 54),
  "Treatment" = c(44, 41, 50, 38, 47, 45, 52, 40, 43, 49, 36, 46)
)

units <- "mmHg"

# ---- 2. Per-group statistics -------------------------------
groups <- lapply(groups, function(v) v[!is.na(v)])

n_i    <- sapply(groups, length)
mean_i <- sapply(groups, mean)
sd_i   <- sapply(groups, sd)          # sd() always uses n - 1
var_i  <- sd_i^2
df_i   <- n_i - 1
ss_i   <- df_i * var_i                # sum of squares inside each group

# ---- 3. The pooled standard deviation ----------------------
# Pool the VARIANCES, weighted by degrees of freedom.
# Never average the standard deviations directly.

df_pooled <- sum(df_i)                # N - k
var_pooled <- sum(ss_i) / df_pooled
sd_pooled  <- sqrt(var_pooled)

N <- sum(n_i)
k <- length(groups)

cat("=== Per-group statistics ===\n")
print(data.frame(n = n_i, mean = round(mean_i, 4),
                 sd = round(sd_i, 4), variance = round(var_i, 4),
                 df = df_i, sum_sq = round(ss_i, 4)))

cat(sprintf("\nN = %d across k = %d groups\n", N, k))
cat(sprintf("Total sum of squares within groups = %.4f\n", sum(ss_i)))
cat(sprintf("Pooled degrees of freedom (N - k)  = %d\n", df_pooled))
cat(sprintf("Pooled variance                    = %.4f\n", var_pooled))
cat(sprintf("POOLED STANDARD DEVIATION          = %.4f %s\n", sd_pooled, units))

# ---- 4. Equal-variance check -------------------------------
ratio <- max(var_i) / min(var_i)
cat(sprintf("\nVariance ratio (largest / smallest) = %.4f\n", ratio))
cat(if (ratio < 2)      "Verdict: comfortable, pooling is safe\n"
    else if (ratio < 4) "Verdict: acceptable if group sizes are similar\n"
    else                "Verdict: STOP, variances differ too much to pool\n")

# Brown-Forsythe (median-centred Levene) test
z <- unlist(lapply(groups, function(v) abs(v - median(v))))
g <- factor(rep(names(groups), n_i))
lev <- summary(aov(z ~ g))[[1]]
cat(sprintf("Levene (Brown-Forsythe) F = %.4f, p = %.4f\n",
            lev$"F value"[1], lev$"Pr(>F)"[1]))

# ---- 5. Two-group extras: t-test, Cohen's d, Hedges' g -----
if (k == 2) {
  x <- groups[[1]]; y <- groups[[2]]
  diff_means <- mean_i[1] - mean_i[2]
  se_diff <- sd_pooled * sqrt(1/n_i[1] + 1/n_i[2])
  t_stat  <- diff_means / se_diff
  p_val   <- 2 * pt(-abs(t_stat), df_pooled)
  tcrit   <- qt(0.975, df_pooled)
  ci      <- diff_means + c(-1, 1) * tcrit * se_diff

  d <- diff_means / sd_pooled
  J <- 1 - 3 / (4 * df_pooled - 1)
  hedges_g <- d * J

  cat("\n=== Two-group comparison ===\n")
  cat(sprintf("Mean difference = %.4f %s\n", diff_means, units))
  cat(sprintf("SE of difference = %.4f\n", se_diff))
  cat(sprintf("t(%d) = %.4f, p = %.6f\n", df_pooled, t_stat, p_val))
  cat(sprintf("95%% CI for the difference: [%.4f, %.4f]\n", ci[1], ci[2]))
  cat(sprintf("Cohen's d = %.4f   Hedges' g = %.4f (J = %.4f)\n",
              d, hedges_g, J))

  # Cross-check against the built-in test.
  # NOTE: R defaults to Welch, so var.equal = TRUE is required
  # to reproduce the pooled result.
  print(t.test(x, y, var.equal = TRUE))

  size <- if (abs(d) < 0.2) "negligible" else
          if (abs(d) < 0.5) "small" else
          if (abs(d) < 0.8) "medium" else "large"
  cat(sprintf("\nPlain English: the groups differ by %.2f %s, which is %.2f pooled\n",
              abs(diff_means), units, abs(d)))
  cat(sprintf("standard deviations, a %s effect. %s\n", size,
      if (p_val < 0.05) "The difference is statistically significant."
      else "The difference is not statistically significant."))
}

# ---- 6. One figure, two stacked panels ---------------------
png("pooled_sd_plot.png", width = 2700, height = 1950, res = 300)
layout(matrix(c(1, 2), nrow = 2), heights = c(3, 2))
par(mar = c(4.2, 4.6, 3, 1.4))

cols <- c("#2563eb", "#ea580c", "#16a34a", "#9333ea",
          "#0d9488", "#c2410c")[seq_len(k)]

# Panel 1: group means with pooled SD bars
bp <- barplot(mean_i, names.arg = names(groups), col = cols,
              border = NA, ylim = c(0, max(mean_i + 2 * sd_pooled)),
              ylab = paste0("Mean (", units, ")"),
              main = sprintf("Group means with pooled SD bars (sp = %.4f)", sd_pooled))
arrows(bp, mean_i - sd_pooled, bp, mean_i + sd_pooled,
       angle = 90, code = 3, length = 0.06, lwd = 2)
text(bp, mean_i / 2, sprintf("%.2f", mean_i), col = "white", font = 2)

# Panel 2: each group's variance against the pooled variance
par(mar = c(4.2, 4.6, 3, 1.4))
barplot(var_i, names.arg = names(groups), col = "#cbd5e1", border = NA,
        ylab = "Variance", main = "Group variances vs pooled variance")
abline(h = var_pooled, col = "#dc2626", lwd = 2.5, lty = 2)
legend("topright", legend = sprintf("pooled variance = %.4f", var_pooled),
       col = "#dc2626", lty = 2, lwd = 2.5, bty = "n")

dev.off()
cat("\nFigure saved as pooled_sd_plot.png at 300 dpi\n")

9.2 What each part of the script does

9.3 What the figure shows

The saved pooled_sd_plot.png has two stacked panels. The upper panel plots each group mean as a bar with error bars set to the pooled standard deviation rather than each group's own, which is the consistent choice once you have assumed a common spread. The lower panel plots each group's variance as a grey bar with the pooled variance drawn across as a red dashed line. If one grey bar towers over the red line while another sits far below it, the equal-variance assumption has failed and the figure says so without a single number.

Read the two panels together. The upper panel answers "how far apart are the groups?" and the lower panel answers "was I allowed to ask that question this way?".

9.4 Problems and fixes in R

9.5 One-liners worth remembering

The sigma() one-liner is the quickest route of all. In one-way ANOVA the residual standard error is the pooled standard deviation, so fitting the model and reading sigma gives the same 4.5623 the long script produces.

Python has one trap that catches almost everyone: NumPy's var and std default to the population formula, dividing by n rather than n minus 1. Pass ddof=1 every time and your answers will match R, Excel and this calculator exactly. The script below is complete and runnable, handles any number of groups, and saves one 300 dpi figure.

10.1 The complete script

Python 3, saves pooled_sd_plot.png

# ============================================================
# Pooled standard deviation, pooled variance, Cohen's d and
# the equal-variance t-test, with one publication-ready plot
# StatsUnlock - https://statsunlock.com/pooled-standard-deviation-calculator/
# pip install numpy scipy matplotlib
# ============================================================

import numpy as np
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
from scipy import stats

np.random.seed(42)   # only matters if you add simulation below

# ---- 1. Your data ------------------------------------------
# Replace with your own values, or read a CSV:
#   import pandas as pd
#   df = pd.read_csv("data.csv")
#   groups = {g: sub["value"].dropna().to_numpy()
#             for g, sub in df.groupby("group")}

groups = {
    "Placebo":   np.array([52, 48, 55, 61, 47, 50, 58, 53, 49, 56, 51, 54], float),
    "Treatment": np.array([44, 41, 50, 38, 47, 45, 52, 40, 43, 49, 36, 46], float),
}

units = "mmHg"

# Drop missing values so NaNs never silently corrupt a variance.
groups = {g: v[~np.isnan(v)] for g, v in groups.items()}

# ---- 2. Per-group statistics -------------------------------
names = list(groups)
n_i    = np.array([len(groups[g]) for g in names])
mean_i = np.array([groups[g].mean() for g in names])
# ddof=1 is essential: NumPy defaults to the POPULATION formula.
var_i  = np.array([groups[g].var(ddof=1) for g in names])
sd_i   = np.sqrt(var_i)
df_i   = n_i - 1
ss_i   = df_i * var_i

# ---- 3. The pooled standard deviation ----------------------
# Pool the VARIANCES, weighted by degrees of freedom.
# Never average the standard deviations directly.

N, k = int(n_i.sum()), len(names)
df_pooled  = int(df_i.sum())          # N - k
var_pooled = ss_i.sum() / df_pooled
sd_pooled  = np.sqrt(var_pooled)

print("=== Per-group statistics ===")
print(f"{'group':<14}{'n':>5}{'mean':>12}{'sd':>12}{'variance':>12}{'df':>6}{'sum_sq':>12}")
for i, g in enumerate(names):
    print(f"{g:<14}{n_i[i]:>5}{mean_i[i]:>12.4f}{sd_i[i]:>12.4f}"
          f"{var_i[i]:>12.4f}{df_i[i]:>6}{ss_i[i]:>12.4f}")

print(f"\nN = {N} across k = {k} groups")
print(f"Total sum of squares within groups = {ss_i.sum():.4f}")
print(f"Pooled degrees of freedom (N - k)  = {df_pooled}")
print(f"Pooled variance                    = {var_pooled:.4f}")
print(f"POOLED STANDARD DEVIATION          = {sd_pooled:.4f} {units}")

# ---- 4. Equal-variance check -------------------------------
ratio = var_i.max() / var_i.min()
print(f"\nVariance ratio (largest / smallest) = {ratio:.4f}")
if ratio < 2:
    print("Verdict: comfortable, pooling is safe")
elif ratio < 4:
    print("Verdict: acceptable if group sizes are similar")
else:
    print("Verdict: STOP, variances differ too much to pool")

lev_F, lev_p = stats.levene(*[groups[g] for g in names], center="median")
print(f"Levene (Brown-Forsythe) F = {lev_F:.4f}, p = {lev_p:.4f}")

# ---- 5. Two-group extras: t-test, Cohen's d, Hedges' g -----
if k == 2:
    x, y = groups[names[0]], groups[names[1]]
    diff = mean_i[0] - mean_i[1]
    se_diff = sd_pooled * np.sqrt(1 / n_i[0] + 1 / n_i[1])
    t_stat = diff / se_diff
    p_val = 2 * stats.t.sf(abs(t_stat), df_pooled)
    tcrit = stats.t.ppf(0.975, df_pooled)
    ci = (diff - tcrit * se_diff, diff + tcrit * se_diff)

    d = diff / sd_pooled
    J = 1 - 3 / (4 * df_pooled - 1)
    g_hedges = d * J

    print("\n=== Two-group comparison ===")
    print(f"Mean difference  = {diff:.4f} {units}")
    print(f"SE of difference = {se_diff:.4f}")
    print(f"t({df_pooled}) = {t_stat:.4f}, p = {p_val:.6f}")
    print(f"95% CI for the difference: [{ci[0]:.4f}, {ci[1]:.4f}]")
    print(f"Cohen's d = {d:.4f}   Hedges' g = {g_hedges:.4f} (J = {J:.4f})")

    # Cross-check. NOTE: SciPy DEFAULTS to the pooled Student test,
    # the opposite default to R. Pass equal_var=False for Welch.
    print("SciPy check:", stats.ttest_ind(x, y, equal_var=True))

    size = ("negligible" if abs(d) < 0.2 else "small" if abs(d) < 0.5
            else "medium" if abs(d) < 0.8 else "large")
    verdict = ("statistically significant" if p_val < 0.05
               else "not statistically significant")
    print(f"\nPlain English: the groups differ by {abs(diff):.2f} {units}, which is "
          f"{abs(d):.2f} pooled standard deviations, a {size} effect. "
          f"The difference is {verdict}.")

# ---- 6. One figure, two stacked panels ---------------------
palette = ["#2563eb", "#ea580c", "#16a34a", "#9333ea", "#0d9488", "#c2410c"]
cols = [palette[i % len(palette)] for i in range(k)]

fig, ax = plt.subplots(2, 1, figsize=(9, 6.5), height_ratios=[3, 2])

ax[0].bar(names, mean_i, color=cols, yerr=sd_pooled, capsize=6,
          error_kw={"elinewidth": 2, "ecolor": "#334155"})
ax[0].set_ylabel(f"Mean ({units})")
ax[0].set_title(f"Group means with pooled SD bars (sp = {sd_pooled:.4f})")
for i, m in enumerate(mean_i):
    ax[0].text(i, m / 2, f"{m:.2f}", ha="center", color="white", fontweight="bold")

ax[1].bar(names, var_i, color="#cbd5e1")
ax[1].axhline(var_pooled, color="#dc2626", lw=2.5, ls="--",
              label=f"pooled variance = {var_pooled:.4f}")
ax[1].set_ylabel("Variance")
ax[1].set_title("Group variances vs pooled variance")
ax[1].legend(frameon=False)

for a in ax:
    a.spines[["top", "right"]].set_visible(False)

fig.tight_layout()
fig.savefig("pooled_sd_plot.png", dpi=300)
print("\nFigure saved as pooled_sd_plot.png at 300 dpi")

10.2 What each part of the script does

10.3 What the figure shows

The same two panels as the R script, so the two outputs can be compared side by side. The upper panel shows the group means with pooled SD error bars, and the lower panel shows each group's variance against the pooled variance as a red dashed line. Matplotlib's capsize=6 puts caps on the error bars so they read clearly in print, and the top and right spines are removed because most journals prefer that style.

If you want each group's own SD on the error bars instead of the pooled value, replace yerr=sd_pooled with yerr=sd_i. Whichever you choose, say which one in the caption.

10.4 Problems and fixes in Python

10.5 One-liners worth remembering

That last line is the Python mirror of R's sigma(): the residual mean square from a one-way model is the pooled variance, so its square root is the pooled standard deviation, 4.5623 for the worked dataset.

11.1 Degrees of freedom for common designs

Conclusion: subtract one degree of freedom per group, never a fixed 2. Check this figure against your software before comparing any p value.

11.2 t critical values at the pooled degrees of freedom

Conclusion: multiply the standard error by the value in the 95% column to build a confidence interval for the difference between means. Note how little changes above df = 30.

11.3 Variance ratio, and whether you may pool

Conclusion: balanced designs are far more forgiving than unbalanced ones. If you can choose your group sizes, make them equal, because that single decision buys you most of the robustness.

11.4 The Hedges' g correction factor J at each df

Conclusion: below about 20 degrees of freedom the correction is large enough to change how a result reads, so report Hedges' g. Above 100 it is invisible and the choice does not matter, but you should still say which one you used.

11.5 Effect size bands and what they mean in pooled SD units

Conclusion: these bands are conventions, not laws. In a field with typical effect sizes of 0.15, a d of 0.4 is remarkable. Use your own literature as the benchmark where you can.

11.6 Sample size per group for a two-sample t-test

Conclusion: two-tailed test at alpha = 0.05. Because d is the raw difference divided by the pooled standard deviation, you must estimate s_p before you can use this table. A pilot study or a published paper on a similar population is the usual source.

11.7 Names for the same quantity across software and textbooks

Conclusion: if a table gives you MS_within you already have the pooled variance, and one square root gives the pooled standard deviation with no raw data needed.

11.8 Quick pooled SD lookup for two equal-sized groups

Conclusion: averaging standard deviations always understates the pooled value, and the error grows quickly as the two SDs diverge. With equal group sizes the correct shortcut is √[(s₁² + s₂²) ÷ 2].

Eight worked cases, each with the full arithmetic and a figure. Together they cover the situations you are most likely to meet: the clean textbook case, identical spreads, unequal group sizes, three and four groups, a tiny pilot sample, a genuine null result, and an outright assumption failure. Every number below was computed with the same formulas the calculator uses.

Design statement. Collect independent measurements from two or more clearly defined groups, using the same instrument, the same protocol and the same measurement conditions in every group, so that any difference in spread between groups reflects the populations rather than the procedure. Aim for equal group sizes wherever you can, because balanced designs make the pooled standard deviation far more robust to unequal variances.

1. Define the groups before you collect anything. A group must be a real, pre-specified category such as treatment arm, site, batch or cohort. Groups invented after looking at the data invalidate every p value that follows.
2. Decide the group sizes in advance using a power calculation. Section 11.6 gives the numbers once you have an estimate of the pooled SD from a pilot or the published literature.
3. Aim for equal n per group. Balanced designs tolerate a variance ratio of 3 or 4 without much damage. Unbalanced designs can fail at a ratio of 2.
4. Randomise assignment where the design allows it, and record the randomisation method. If assignment is observational, say so, because unequal variances are then much more likely.
5. Use one instrument and one calibration for all groups. Measuring the control group on Monday with instrument A and the treated group on Friday with instrument B guarantees a difference in spread that has nothing to do with the treatment.
6. Record the raw values, not summaries. Keep every observation. You cannot recover the pooled SD from group means alone, and reviewers increasingly ask for the raw data.
7. Record measurement precision and units for every variable, and keep them consistent. A group recorded to the nearest whole number and another to two decimals will show artificially different variances.
8. Blind the measurement where possible. An assessor who knows the group can produce systematically tighter or looser readings in one arm.
9. Log every exclusion at the moment it happens, with the reason. Removing a value after seeing that it inflates one group's variance is not a data-cleaning decision, it is a result-changing one.
10. Check each group's spread as you go. If one group is visibly more variable after half the data are in, you still have time to find the cause. After the study closes you only have Welch's t-test.
11. Store the data in long format, one row per observation with a group label column. It is easier to check, easier to plot and it is what R and Python expect.
12. Pre-register the analysis plan, including exactly what you will do if the equal-variance assumption fails. Deciding after seeing the data is where most inflated false positive rates come from.

13.1 How to lay out your data

Minimum sample. Every group needs at least 2 observations to contribute any degrees of freedom, at least 5 for the group SD to mean much, and ideally 12 or more per group so that the pooled estimate has 20 or more degrees of freedom. Below 10 pooled degrees of freedom, report the pooled SD with a confidence interval and treat any effect size built on it as provisional.

Pre-registration line you can copy. "The the pooled estimate will be computed as the square root of the degrees of freedom weighted mean of the group variances. Homogeneity of variance will be assessed with the Brown-Forsythe test and the largest to smallest variance ratio. If the ratio exceeds 4, or Brown-Forsythe returns p below 0.05, Welch's t-test will be used and no pooled standard deviation will be reported."

13.2 Common mistakes at the collection stage

• Letting group sizes drift far apart because recruitment was easier in one arm.
• Changing instrument, operator or protocol partway through, so that spread differs by time rather than by group.
• Rounding one group more coarsely than another.
• Recording only group means and SDs and discarding the raw values.
• Collecting repeated measures on the same subject and treating them as independent observations, which understates the true spread.
• Defining groups after inspecting the data, which turns an assumption check into a fishing expedition.

14.1 Use it when

• You are running a two-sample t-test with equal variances assumed, or a one-way ANOVA.
• You need Cohen's d or Hedges' g, both of which are defined with s_p in the denominator.
• You are planning a study and need an estimate of the common spread for a power calculation.
• You are doing a meta-analysis and need a standardised mean difference from published means, SDs and sample sizes.
• You are running a Tukey or Bonferroni post hoc test after ANOVA, which use the pooled error term rather than the two groups being compared.
• You want a more precise estimate of within-group spread than any single small group can give you on its own.
• You are monitoring a process across batches and want short-term variation with the between-batch shifts removed.

14.2 Do not use it when

• The group variances clearly differ, with a ratio above 4 or a small Brown-Forsythe p value.
• The group sizes are very unequal and the variances differ even modestly.
• Your groups are not independent, for example repeated measures on the same subjects. Use a paired or mixed model instead.
• You only want to describe the whole sample. The ordinary standard deviation of all the data is the right number there.
• The spread rises with the mean, as it does for counts, times and concentrations. Transform first, then reconsider.
• One group has n = 1, since it contributes no degrees of freedom and cannot inform the estimate.
• The data are so skewed that a standard deviation is not a sensible summary of either group.

14.3 Four worked situations

14.4 Decision tree

16.1 Assumptions

16.2 Limitations

• It says nothing about whether the groups differ. The pooled SD measures within-group spread only. Pair it with a mean difference, a test and an effect size, or it answers no question on its own. If you want the between-group signal, that is what ANOVA's MS_between or a t statistic gives you.
• It is not robust. Variance squares every deviation, so a single wild point moves it a long way. When outliers are a real concern, use a robust scale estimate such as the median absolute deviation, or a trimmed variance, and say which you used.
• It hides heterogeneity by design. Two groups with SDs of 1 and 25 give a pooled SD near 18, which describes neither. Always look at the group SDs and the variance ratio before quoting the pooled value. Where they differ, report each group's SD instead and use Welch.
• It is itself an estimate with uncertainty. At 4 degrees of freedom the pooled SD would vary enormously if the study were repeated. Below about 10 pooled df, quote a confidence interval for it using the chi-square distribution rather than presenting it as a fixed number.
• It assumes the same measurement scale across groups. If one group was recorded to the nearest unit and another to two decimals, the difference in spread is an artefact of recording, not of biology. Fix the data collection, since no statistic can repair it.
• It does not extend to repeated measures. Where the same subjects appear in more than one condition, the correct spread depends on the within-subject correlation. Use a paired design, a mixed model, or Cohen's d_z in place of the pooled version.
• Unbalanced designs weaken it sharply. Everything written about robustness to unequal variance assumes similar group sizes. With a 5 to 1 imbalance, even a modest variance ratio can distort the error rate, and Welch is the safer default.

The pooled standard deviation is one of those quantities that looks like bookkeeping and turns out to be load bearing. It is the yardstick against which every difference between group means gets measured. The t statistic, the confidence interval, Cohen's d, Hedges' g, the sample size you need for your next study and the effect size that goes into a meta-analysis all sit on top of it. If s_p is wrong, none of those numbers can be right, and nothing about the output will look wrong on the surface.

The arithmetic itself is short, but there are exactly three places people go astray, and they account for almost every incorrect pooled standard deviation you will ever meet. The first is averaging the standard deviations instead of pooling the variances. Squaring first is not a technicality: it is the difference between a defined statistical quantity and a number with no meaning. The second is weighting by n rather than n minus 1, which quietly gives too much say to small groups. The third is carrying the two-group denominator across to a design with three or more groups, where it must be N minus k rather than N minus 2. This calculator shows all three quantities on screen so none of them can slip past unnoticed.

The larger point is that the pooled SD is only meaningful when the assumption behind it holds. Pooling asserts that every group is drawn from a population with the same true spread and that the groups differ only in where their centres sit. When that is roughly true, pooling buys you precision, because all the data contribute to one estimate with more degrees of freedom than any group has alone. When it is badly false, the pooled value is an average of two different things and describes neither of them. That is why the equal variance panel sits above the headline number rather than below it, and why a variance ratio above four is drawn in red.

If the assumption does fail, the fix is neither difficult nor embarrassing. Welch's t-test keeps the two variances separate, costs almost nothing when they happen to be equal, and is the default in R for exactly that reason. For more than two groups Welch's ANOVA with the Games-Howell post hoc test does the same job. Where the spread grows with the mean, as it does for counts, times and concentrations, a log transformation will often make the variances comparable and let you pool honestly on the transformed scale. Glass's delta sidesteps the issue completely by using the control group's standard deviation alone.

Two habits will keep you out of trouble. Always look at the group standard deviations before you look at the pooled one, because the pooled value hides exactly the information you need to judge whether pooling was appropriate. And always report the pooled standard deviation alongside the group sizes and the degrees of freedom, so a reader can reproduce your effect size and see how much the estimate is worth. A pooled SD on 4 degrees of freedom and one on 400 look identical on the page and deserve very different levels of trust.

Paste your groups into the calculator above, read the equal-variance panel before the headline, and check chart 2 to see whether one group is doing something the others are not. Then come back to this pooled standard deviation calculator whenever you need a t-test, an effect size or a sample size, because getting this single number right is what makes every statistic built on top of it believable.

Every tool above is published and live on statsunlock.com.

The following peer-reviewed references support the methods used in this pooled standard deviation calculator, covering the pooled variance estimator, homogeneity of variance and its tests, the Welch alternative, and the effect sizes built on the pooled standard deviation.

1. Student. (1908). The probable error of a mean. Biometrika, 6(1), 1–25. https://doi.org/10.2307/2331554
2. Welch, B. L. (1947). The generalization of Student's problem when several different population variances are involved. Biometrika, 34(1–2), 28–35. https://doi.org/10.1093/biomet/34.1-2.28
3. Satterthwaite, F. E. (1946). An approximate distribution of estimates of variance components. Biometrics Bulletin, 2(6), 110–114. https://doi.org/10.2307/3002019
4. Bartlett, M. S. (1937). Properties of sufficiency and statistical tests. Proceedings of the Royal Society A, 160(901), 268–282. https://doi.org/10.1098/rspa.1937.0109
5. Brown, M. B., & Forsythe, A. B. (1974). Robust tests for the equality of variances. Journal of the American Statistical Association, 69(346), 364–367. https://doi.org/10.1080/01621459.1974.10482955
6. Box, G. E. P. (1954). Some theorems on quadratic forms applied in the study of analysis of variance problems, I. Effect of inequality of variance in the one-way classification. The Annals of Mathematical Statistics, 25(2), 290–302. https://doi.org/10.1214/aoms/1177728786
7. Boneau, C. A. (1960). The effects of violations of assumptions underlying the t test. Psychological Bulletin, 57(1), 49–64. https://doi.org/10.1037/h0041412
8. Glass, G. V., Peckham, P. D., & Sanders, J. R. (1972). Consequences of failure to meet assumptions underlying the fixed effects analyses of variance and covariance. Review of Educational Research, 42(3), 237–288. https://doi.org/10.3102/00346543042003237
9. Lix, L. M., Keselman, J. C., & Keselman, H. J. (1996). Consequences of assumption violations revisited: A quantitative review of alternatives to the one-way analysis of variance F test. Review of Educational Research, 66(4), 579–619. https://doi.org/10.3102/00346543066004579
10. Zimmerman, D. W. (2004). A note on preliminary tests of equality of variances. British Journal of Mathematical and Statistical Psychology, 57(1), 173–181. https://doi.org/10.1348/000711004849222
11. Ruxton, G. D. (2006). The unequal variance t-test is an underused alternative to Student's t-test and the Mann-Whitney U test. Behavioral Ecology, 17(4), 688–690. https://doi.org/10.1093/beheco/ark016
12. Delacre, M., Lakens, D., & Leys, C. (2017). Why psychologists should by default use Welch's t-test instead of Student's t-test. International Review of Social Psychology, 30(1), 92–101. https://doi.org/10.5334/irsp.82
13. Hedges, L. V. (1981). Distribution theory for Glass's estimator of effect size and related estimators. Journal of Educational Statistics, 6(2), 107–128. https://doi.org/10.3102/10769986006002107
14. Hedges, L. V., & Olkin, I. (1985). Statistical methods for meta-analysis. Academic Press. https://doi.org/10.1016/C2009-0-03396-0
15. Lakens, D. (2013). Calculating and reporting effect sizes to facilitate cumulative science: A practical primer for t-tests and ANOVAs. Frontiers in Psychology, 4, 863. https://doi.org/10.3389/fpsyg.2013.00863
16. Nakagawa, S., & Cuthill, I. C. (2007). Effect size, confidence interval and statistical significance: A practical guide for biologists. Biological Reviews, 82(4), 591–605. https://doi.org/10.1111/j.1469-185X.2007.00027.x
17. Fritz, C. O., Morris, P. E., & Richler, J. J. (2012). Effect size estimates: Current use, calculations, and interpretation. Journal of Experimental Psychology: General, 141(1), 2–18. https://doi.org/10.1037/a0024338
18. Cumming, G. (2014). The new statistics: Why and how. Psychological Science, 25(1), 7–29. https://doi.org/10.1177/0956797613504966
19. Altman, D. G., & Bland, J. M. (2005). Standard deviations and standard errors. BMJ, 331(7521), 903. https://doi.org/10.1136/bmj.331.7521.903
20. Wan, X., Wang, W., Liu, J., & Tong, T. (2014). Estimating the sample mean and standard deviation from the sample size, median, range and/or interquartile range. BMC Medical Research Methodology, 14, 135. https://doi.org/10.1186/1471-2288-14-135