web-app | Dhafer Malouche

StatANOVA — One-way ANOVA & Tukey HSD Workbench

Sat, 02 May 2026 00:00:00 +0000

An interactive web application that fits a one-way analysis of variance and its standard post-hoc decomposition entirely in the student’s browser. StatANOVA extends the small family of teaching tools designed for undergraduate statistics at Qatar University: where StatTests answers which test do I run on these two groups and StatRegress asks given these data, what is the model, StatANOVA asks do these $k$ groups differ on average — and if so, which ones?

Why an ANOVA workbench?

The pedagogical gap StatANOVA targets is the step from the global $F$-test to a defensible per-pair conclusion. In a typical lecture, students are taught the $F$-statistic for the equality-of-means hypothesis $H_{0}: \mu_{1} = \cdots = \mu_{k}$, but the natural next question — which groups are responsible for the rejection? — is usually answered with a quick remark about Tukey’s honestly significant difference. StatANOVA closes that loop interactively: the student uploads a real dataset, reads the ANOVA decomposition, and immediately sees the Tukey HSD intervals, the family-wise adjusted $p$-values, and the resulting compact-letter-display (CLD) groupings on the same screen.

What the app does

Input. Upload a CSV (UTF-8, header row, comma-separated, dot decimal, $\le 10$ MB and $\le 50{,}000$ rows after dropping NAs). The app inspects the columns and proposes:

a factor variable — any column with between 2 and 6 distinct values, with at least 3 observations per level after listwise deletion;
one or more continuous response variables — numeric columns selectable in a checklist, capped at 50 active responses.

The student then chooses the significance level $\alpha$ and the post-hoc method (Tukey HSD by default).

Inferential output. For each selected response, the app reports:

the ANOVA summary table (sums of squares, degrees of freedom, mean squares, the $F$-statistic, and the corresponding $p$-value);
the compact-letter-display (CLD) table: each group is annotated with letters such that two groups share at least one letter if and only if their means are not significantly different at level $\alpha$ under the chosen multiple-comparison correction;
a forest plot of pairwise mean differences with simultaneous confidence intervals, ordered for readability, with intervals that exclude zero highlighted.

Because the workflow runs across many response variables in a single pass, StatANOVA is well suited to the kind of multivariate teaching dataset (Qatar Biobank-style, biomedical, or biodiversity) where a single grouping factor is to be screened against several outcomes.

Classroom workflow

In lectures, the instructor mirrors the app on the projector while writing the model on the board: the algebraic decomposition $\mathrm{SS}{\text{total}} = \mathrm{SS}{\text{between}} + \mathrm{SS}_{\text{within}}$ is read off the same table the students see. In practice sessions, students upload their assigned CSV, copy the ANOVA table, the CLD summary, and the forest plot into their report, and explain in one paragraph (i) whether the global $F$-test rejects, (ii) which pairs of groups differ once the family-wise error is controlled, and (iii) how the CLD letters and the forest plot tell the same story in two complementary forms.

Technical notes

The app is a single-page client-side application: all computation runs in the browser, with no server round-trip and no data leaving the device. The ANOVA decomposition is computed directly from the group means and pooled variance estimator; Tukey HSD intervals use the studentised-range distribution at the chosen family-wise level; the CLD is constructed by the standard insert-and-absorb algorithm on the matrix of adjusted $p$-values. The static bundle is deployed on Netlify; like its siblings, it works offline after first load and has no external run-time dependencies.

StatPCA — Principal Component Analysis Workbench

Thu, 30 Apr 2026 00:00:00 +0000

A browser-only teaching workbench for the most-used dimension-reduction technique in applied multivariate statistics: Principal Component Analysis. StatPCA completes the family of teaching tools developed for undergraduate and graduate statistics at Qatar University, alongside StatTables, StatTests, StatRegress, StatCI, StatPower, and StatCorr.

Why a PCA workbench?

Principal Component Analysis is often presented as a one-line recipe — “decompose the correlation matrix and keep the first few eigenvectors” — and the geometric, algebraic, and inferential layers of the method are collapsed into a single black-box call. StatPCA keeps the layers separate and visible: the data panel makes the centering and scaling step explicit, the eigen-decomposition panel reports eigenvalues and eigenvectors of the chosen matrix, the variance panel reports the scree plot and the cumulative proportion of variance explained, and the projection panel renders the score plot, the loading plot, and the biplot on coordinated axes.

What the app does

Input. Paste a CSV with $p \geq 2$ numeric variables, load one of the bundled teaching datasets (e.g., the classical decathlon, USArrests, or iris), or generate synthetic correlated data with a user-specified covariance structure. Categorical or grouping variables are kept aside and used only to colour the score plot.

Pre-processing options. Mean-centering is applied by default; the user toggles between PCA on the correlation matrix (each variable scaled to unit variance) and PCA on the covariance matrix (variables left on their original scale). Missing values are handled by listwise deletion or by mean-imputation, with both options reported next to the result.

Quantities reported. For every fit the app returns:

the eigenvalues $\lambda_{1} \geq \lambda_{2} \geq \cdots \geq \lambda_{p} \geq 0$ of the chosen matrix, with their proportion $\lambda_{k}/\sum_{j}\lambda_{j}$ and cumulative proportion;
the loadings matrix $\mathbf{V} = (v_{jk})$ with columns equal to the eigenvectors of the chosen matrix; loadings are reported on the unit-norm scale and on the correlation-with-component scale $v_{jk}\sqrt{\lambda_{k}}$, so that the user can read off the linear association between each original variable and each component;
the scores $z_{ik} = \sum_{j} v_{jk},(x_{ij}-\bar x_{j})/s_{j}$ of each observation on each component;
the communalities and the squared cosines $\cos^{2}_{ik}$, which quantify how well each observation is represented in the chosen low-dimensional subspace.

Visual output. The app renders three coordinated plots:

the scree plot with the broken-stick and Kaiser ($\lambda > 1$) reference lines superimposed, so that the choice of the number of retained components is grounded in an explicit rule rather than visual judgement alone;
the score plot of observations on $(\text{PC}{k}, \text{PC}{\ell})$, with optional colouring by a grouping variable and confidence ellipses per group;
the biplot, which overlays the loading vectors on the score plot using the standard scaling so that the cosine of the angle between two arrows approximates the correlation between the corresponding variables.

Pedagogical use

StatPCA is designed for the lecture in which PCA is introduced and for the practical that follows it. Three exercises map naturally to the app:

Standardisation matters. Run PCA on the covariance matrix of a dataset whose variables are on incompatible scales (e.g., heights in cm and weights in kg), then re-run on the correlation matrix and watch the dominant component swap. Discuss when each choice is appropriate.
How many components? Compare the Kaiser rule, the broken-stick rule, and the elbow-on-the-scree-plot rule on the same data. Show that they need not agree, and connect the disagreement to the eigenvalue spectrum.
Interpreting the axes. Use the loadings (on the correlation-with-component scale) to label the principal axes in substantive terms; use the squared cosines to flag observations that the two-dimensional summary represents poorly.

Technical notes

The app is a single-page client-side application built with React + Vite: all computation runs in the student’s browser, with no server round-trip and no data leaving the device. The eigen-decomposition is performed by a numerically stable QR-based routine on the symmetric correlation/covariance matrix; for the score plot the app uses the singular value decomposition of the centered (and optionally scaled) data matrix, which avoids forming and squaring the cross-product matrix when the number of variables is large. The static bundle is deployed on Netlify; like its siblings it works offline after first load and has no external run-time dependencies.

StatCorr — Correlation Workbench

Wed, 29 Apr 2026 00:00:00 +0000

A browser-only teaching workbench for the most-used dependence summary in applied statistics: the correlation coefficient. StatCorr completes the small family of teaching tools developed for undergraduate statistics at Qatar University, alongside StatTables, StatTests, StatRegress, StatCI, and StatPower.

Why a correlation workbench?

In introductory courses the Pearson coefficient $r$ is often introduced as a single number and then immediately overloaded with interpretations — strength, direction, linearity, predictive value, dependence. Students leave the lecture confusing the four. StatCorr keeps the four interpretations visually separate: the scatter plot makes the geometry of the association explicit, the coefficient panel reports its magnitude, the inference panel reports the evidence against $H_{0}: \rho = 0$, and the rank-based panel shows when the linear summary is misleading.

What the app does

Input. Paste a CSV with two numeric variables, load one of the bundled teaching datasets, or use the simulator to draw $n$ observations from a chosen joint distribution (bivariate normal with prescribed $\rho$, monotone-but-non-linear, or contaminated with outliers).

Coefficients reported. For every dataset the app reports three coefficients side by side:

the Pearson correlation $r = \dfrac{\sum (x_{i}-\bar x)(y_{i}-\bar y)}{\sqrt{\sum (x_{i}-\bar x)^{2}\sum (y_{i}-\bar y)^{2}}}$, with the Fisher-$z$ confidence interval $\tanh!\big(\operatorname{atanh}(r) \pm z_{1-\alpha/2}/\sqrt{n-3}\big)$ and the $t$-test for $H_{0}: \rho = 0$;
the Spearman rank correlation $\rho_{s}$ — robust to monotone transformations and to outliers — with its asymptotic test;
the Kendall $\tau$, reported with the exact small-sample distribution when feasible.

Visual output. A scatter plot with the regression line, the marginal histograms, and a $95%$ confidence ellipse for the joint distribution is drawn alongside the coefficient table. A drag-a-point interaction lets students pull a single observation and watch the three coefficients, the regression line, and the $p$-values update — making vivid the difference between a Pearson coefficient that collapses under one outlier and a Spearman coefficient that does not.

Pedagogical use

StatCorr is designed for the lecture in which correlation is introduced and for the practical that follows it. Three exercises map naturally to the app:

Linear vs. monotone vs. independent. Generate samples from a bivariate normal, from $Y = X^{3}+\varepsilon$, and from $Y = X^{2} + \varepsilon$ on $[-1,1]$. Compare Pearson, Spearman, and Kendall, and discuss why $r \approx 0$ does not imply independence.
Outlier sensitivity. Pin a Pearson coefficient near $0.9$, then drag a single point far from the cloud and watch $r$ collapse while $\rho_{s}$ and $\tau$ barely move.
Inference vs. magnitude. With $n = 5$ a sample correlation of $0.6$ is not significantly different from zero; with $n = 500$ a sample correlation of $0.1$ is. The Fisher-$z$ interval makes both statements explicit on a single graph.

Technical notes

The app is a single-page client-side application built with React + Vite: all computation runs in the student’s browser, with no server round-trip and no data leaving the device. Quantiles for the $t$ and standard normal distributions used for inference and for the Fisher-$z$ interval are computed with the jStat numerical library (MIT-licensed). Random samples for the simulator are produced from a high-quality PRNG seeded by the user, so that classroom demonstrations are reproducible across machines. The static bundle is deployed on Netlify; like its siblings it works offline after first load and has no external run-time dependencies.

StatCI — Confidence Interval Visualizer

Sat, 25 Apr 2026 00:00:00 +0000

A browser-only simulation tool for the single most misunderstood object in introductory statistics: the confidence interval. StatCI turns the frequentist definition into a visible, repeatable experiment, so that a student can see the long-run coverage statement instead of only reading it.

The misconception StatCI addresses

Surveys of statistics students consistently report the same wrong reading of “95% confidence”: the belief that a particular computed interval $[\hat\theta_{L},\hat\theta_{U}]$ contains the true parameter $\theta$ with probability $0.95$. The frequentist statement is in fact about the procedure, not about any single interval: across many independent samples from the same population, the proportion of CIs that cover $\theta$ converges to the nominal level $1-\alpha$. StatCI turns this abstract sentence into an animation.

What the app does

The user picks (i) a sampling distribution and the true parameter value $\theta$, (ii) a sample size $n$, (iii) a confidence level $1-\alpha$, and (iv) the type of interval (e.g., $z$- or $t$-interval for a mean, exact / Wilson / Wald interval for a proportion, $\chi^{2}$ interval for a variance). The app then:

draws $K$ independent samples from the chosen population;
computes the corresponding $K$ confidence intervals;
stacks them on a single horizontal axis, with the true parameter $\theta$ marked by a vertical reference line;
colours each interval according to whether it covers $\theta$ (navy) or misses it (coral);
reports the running empirical coverage $\hat{C}_K$ and compares it to the nominal $1-\alpha$.

The simulation can be advanced one sample at a time, or in batches of $50$/$500$/$5000$, so students can watch the empirical coverage stabilise at the nominal level as $K$ grows.

Pedagogical use

StatCI is designed for the lecture in which the definition of a confidence interval is introduced, and for the practical that follows. Three exercises map naturally to the app:

Coverage at the nominal level. Verify that for a $z$-interval on a normal mean, $\hat{C}_K \to 0.95$ as $K \to \infty$.
The cost of model misspecification. Build a Wald interval for a binomial proportion close to $0$ or $1$ and observe that the empirical coverage falls well below $0.95$ — motivating the Wilson and Clopper–Pearson alternatives.
The effect of $n$ and $\alpha$. Show that doubling $n$ halves the interval width while leaving coverage unchanged, and that lowering $\alpha$ raises coverage at the cost of width.

Technical notes

The app is a single-page client-side application built with React + Vite: all sampling and inference run in the student’s browser, with no server round-trip and no data leaving the device. Random samples are produced from a high-quality PRNG seeded by the user (so that classroom demonstrations are reproducible across machines). Quantiles for the $z$, $t$, $\chi^{2}$, and $F$ distributions are computed with the jStat numerical library (MIT-licensed). The static bundle is deployed on Netlify; like its siblings, it works offline after first load and has no external run-time dependencies.

StatPower — Power & Sample-Size Calculator

Sat, 25 Apr 2026 00:00:00 +0000

A browser-only calculator and visualiser for the four-quantity relationship that governs the design of a statistical study: effect size, sample size $n$, type-I error $\alpha$, and power $1-\beta$. StatPower treats these four quantities symmetrically — fix any three and the app solves for the fourth — and accompanies the numerical answer with the corresponding power curve, so that the student sees what a $5%$ change in $n$ or in $d$ does to the chance of a true rejection.

The four-quantity rule

For a fixed test, the relationship $\Pr(\text{reject } H_{0} \mid H_{1}) = 1 - \beta(d, n, \alpha)$ implicitly ties together $d$, $n$, $\alpha$, and the resulting power $1-\beta$. Any three of these determine the fourth. StatPower exposes this as a single interface: enter three of the four quantities and the app returns the fourth and draws the curve along which it sits.

Tests covered

Means. One-sample $t$-test ($d = (\mu - \mu_{0})/\sigma$), paired $t$-test (on differences), two-sample $t$-test (Cohen’s $d$, pooled SD), one-way ANOVA (Cohen’s $f$).

Proportions. One-proportion $z$-test, two-proportion $z$-test (Cohen’s $h$ or risk-difference parameterisation).

Correlation and association. Test of $\rho = 0$ (Fisher $z$-transform), $\chi^{2}$ test of independence (Cohen’s $w$).

Regression. Global $F$-test for $H_{0}: \beta_{1} = \cdots = \beta_{p} = 0$ (Cohen’s $f^{2}$), single-coefficient $t$-test in multiple regression.

For each test the app reports the non-centrality parameter (e.g., $\lambda = d\sqrt{n/2}$ for a two-sample $t$-test) so that students see the algebra behind the answer rather than receiving a black-box number.

What the user sees

Three coordinated panels respond to every change of inputs:

a scalar answer panel showing the solved quantity to four significant figures;
the power curve $1-\beta$ as a function of the chosen free axis (typically $n$ or $d$), with the operating point marked and the target power drawn as a horizontal reference;
a distribution panel with the null and alternative reference distributions overlaid, the rejection region shaded, and the geometric area corresponding to $\beta$ — the type-II error — highlighted, so that the tradeoff between $\alpha$ and $\beta$ is visible rather than merely stated.

Classroom workflow

In lectures, the instructor steps through the four-quantity rule by varying one input at a time and watching the curve and the geometry update. In assignments, students paste a target effect size and target power and report the required $n$, together with the non-centrality parameter and the curve they read it from — making grading deterministic and removing the ambiguity that surrounds the choice of effect-size convention. The app is a natural complement to the inferential procedures in StatTests: the design of the study and its analysis use the same reference distributions, displayed in the same shaded form.

Technical notes

The app is a single-page client-side application built with React + Vite and styled with Tailwind CSS: all computation runs in the student’s browser, with no server round-trip. The non-central $t$, $F$, and $\chi^{2}$ distributions used to evaluate power, and the central distributions used for critical values, are computed with the jStat numerical library (MIT-licensed); inverse problems (solving for $n$ or $d$) are obtained by safeguarded bisection on the monotone power function. The static bundle is deployed on Netlify; like its siblings, it works offline after first load and has no external run-time dependencies.

StatRegress — Linear Regression Workbench

Sat, 25 Apr 2026 00:00:00 +0000

An interactive web application that fits and diagnoses ordinary least-squares regression models entirely in the student’s browser. StatRegress completes a small family of teaching tools designed for undergraduate statistics at Qatar University: where StatTables answers what is the critical value and StatTests answers which test do I run, StatRegress asks given these data, what is the model — and is it any good?

Why a regression workbench?

Most introductory regression instruction is split between (i) computing $\hat{\beta}$, $\mathrm{SE}(\hat{\beta})$, $t$- and $F$-statistics by hand on toy data and (ii) demonstrating the same calculations in R or Python with lm()/statsmodels. Both have pedagogical limits: hand calculations don’t scale beyond $n \approx 10$, while a full statistical environment hides the geometry of the fit behind a console output. StatRegress sits between the two — students paste a real dataset, see the regression line drawn directly on the scatter, and read the standard coefficient table and diagnostic plots in the same view, with no installation and no server round-trip.

What the app does

Input. Paste a CSV (or load one of the bundled teaching datasets), choose the response and the predictor(s), and select the assumed model (simple linear regression, multiple regression with up to a small handful of predictors, or polynomial extension).

Estimation output. A regression report formatted as in a textbook:

the coefficient table with $\hat{\beta}{j}$, $\mathrm{SE}(\hat{\beta}{j})$, $t_{j} = \hat{\beta}{j}/\mathrm{SE}(\hat{\beta}{j})$, the two-sided $p$-value, and the $95%$ confidence interval;
the model summary: residual standard error $\hat{\sigma}$, multiple $R^{2}$, adjusted $R^{2}$, and the global $F$-test for $H_{0}: \beta_{1} = \cdots = \beta_{p} = 0$;
the ANOVA decomposition of the total sum of squares.

Diagnostic output. The four classical residual plots — residuals vs.\ fitted values, normal Q–Q plot of standardised residuals, scale–location ($\sqrt{|r_{i}|}$ vs.\ $\hat{y}_{i}$), and residuals vs.\ leverage with Cook’s distance contours — together with a flag for influential or high-leverage observations.

Drag-a-point mode

For simple linear regression the app exposes a drag-a-point interaction: students grab a single observation in the scatter, move it, and the fitted line, $R^{2}$, the coefficient table, and the residuals all update in real time. This makes intuitive what an algebraic discussion of leverage and influence usually fails to convey — that a single high-leverage point can rotate the line, that an outlier in the middle of the design space barely moves the slope, and that Cook’s distance is geometric in nature.

Classroom workflow

In lectures, the instructor mirrors the app on the projector while building the model on the board: each new term in the algebra has its counterpart in the live coefficient table. In practice sessions, students paste their assigned dataset, copy the coefficient table and diagnostic plots into their solution, and report which assumptions look satisfied, which look suspicious, and which observations they would investigate further. Because the app produces a deterministic report from a deterministic input, grading is reproducible.

Technical notes

The app is a single-page client-side application built with React: all computation runs in the student’s browser, with no server round-trip and no data leaving the device. The OLS estimator is computed via the QR decomposition for numerical stability; standard errors and inference are obtained from the corresponding $(X^{\top}X)^{-1}$ block. Distributional quantiles for the $t$ and $F$ tables are computed with the jStat numerical library (MIT-licensed). The static bundle is deployed on Netlify; like its siblings, it works offline after first load and has no external run-time dependencies.

StatTables — Interactive Statistical Distribution Tables & Calculators

Sat, 25 Apr 2026 00:00:00 +0000

An interactive web application that replaces the printed statistical tables traditionally found at the back of introductory statistics textbooks. The app is designed for undergraduate courses in statistical inference, probability, and applied statistics at Qatar University, and is freely available to students and instructors elsewhere.

Why not the printed tables?

Classical textbook tables are fixed to a handful of significance levels (typically $\alpha \in {0.10, 0.05, 0.025, 0.01, 0.005}$) and to a limited grid of degrees of freedom or parameter values. In practice, students need critical values and tail probabilities at arbitrary points — and instructors want them reproducible, shareable, and visually annotated. StatTables returns exact values for any query, simultaneously displays the corresponding shaded region on the density curve, and shows the formula being applied — so the numerical answer is always paired with both geometric intuition and analytical rigor.

Distributions covered

Continuous:

Standard normal $Z \sim \mathcal{N}(0,1)$ — critical values $z_{\alpha}$, two-sided cutoffs $z_{\alpha/2}$, and tail probabilities $P(Z > z)$.
Student $t$ — $t_{\alpha,\nu}$ for any degrees of freedom $\nu$; $t$-tests and confidence intervals for the mean under unknown variance.
Chi-square $\chi^{2}$ — lower and upper critical values $\chi^{2}_{\alpha,\nu}$ for variance tests, goodness-of-fit, and tests of independence.
Fisher $F$ — $F_{\alpha, \nu_{1}, \nu_{2}}$ for analysis of variance, regression overall-significance tests, and variance-ratio comparisons.
Exponential — survival, hazard, and waiting-time problems.

Discrete:

Binomial $X \sim \mathcal{B}(n,p)$ — pmf, cdf, and tail probabilities for finite Bernoulli experiments.
Poisson $X \sim \mathcal{P}(\lambda)$ — counts of rare events over fixed exposure.

How students use it

For every distribution the app supports both directions:

Cutoff $\rightarrow$ probability. Given a value of the test statistic, obtain the one- or two-tailed $p$-value.
Probability $\rightarrow$ cutoff. Given a significance level $\alpha$, obtain the corresponding critical value.

Each query is rendered in three coordinated panels:

a classical book-style lookup table, with the cell matching the current query highlighted;
a shaded density plot indicating the region the reported probability refers to, removing the ambiguity that often surrounds one- vs. two-tailed procedures;
a step-by-step formula breakdown, so the student can see the integral or summation being evaluated.

Classroom workflow

The app is intended as an in-class replacement for the printed appendix tables. During exercises, students paste the query parameters they used into their solution; during exams the app’s screen can be mirrored on the instructor’s display so the class works from a shared source of truth. The accompanying solution sheets indicate the exact query, not a table row, making grading deterministic and self-checkable.

Technical notes

The app is a single-page client-side application built with React + Vite and styled with Tailwind CSS: all computation runs in the student’s browser, with no server round-trip. Quantiles, cdf, and pmf values are computed with the jStat numerical library (MIT-licensed). Density curves are rendered on an HTML canvas so that shaded regions and critical-value markers stay crisp on high-DPI displays. The bundle is fully static and is deployed on Netlify, which means it works offline after first load and has no external dependencies at run time.

StatTests — Hypothesis Testing Hub

Sat, 25 Apr 2026 00:00:00 +0000

An interactive web application that performs the hypothesis tests covered in a standard one- or two-semester course in statistical inference, with a uniform interface, fully visible formulas, and automatic checking of the assumptions on which each procedure depends. The app is the natural complement to StatTables: where StatTables answers what is the critical value and what is the tail probability, StatTests answers which test do I run, and what does the conclusion look like.

Why a unified hub?

Most introductory textbooks present each test as a self-contained recipe — formula for the test statistic, sampling distribution under $H_{0}$, decision rule, and example. In practice, students confuse the recipes, mis-identify the appropriate distribution, and forget to verify the assumptions. StatTests unifies all the standard procedures behind a single interface: pick the inference problem (one mean, two means, proportion, variance ratio, ANOVA, association, location shift, …), enter the data or the summary statistics, and the app returns a complete inference report consisting of:

the explicit hypotheses $H_{0}$ vs.\ $H_{1}$ in the chosen direction (left, right, two-sided);
the test statistic and its formula, with all values substituted;
the reference distribution, displayed with the rejection region(s) shaded;
the $p$-value, the critical value(s), and the decision at the user-selected $\alpha$;
a checklist of the parametric assumptions, marked as satisfied, suspicious, or violated when checkable from the data.

Tests covered

The current release implements 14 procedures grouped by inferential goal:

Means. One-sample $t$-test, paired $t$-test, two-sample $t$-test (pooled and Welch), one-way ANOVA.

Proportions. One-proportion $z$-test, two-proportion $z$-test.

Variances. Chi-square test for a single variance, $F$-test for the ratio of two variances, Bartlett / Levene-style homogeneity check feeding into ANOVA.

Categorical. $\chi^{2}$ goodness-of-fit, $\chi^{2}$ test of independence in a contingency table.

Non-parametric. Wilcoxon signed-rank (one-sample and paired), Mann–Whitney $U$ (two-sample location), Kruskal–Wallis (one-way location across $k > 2$ groups).

Classroom workflow

In lectures, the instructor mirrors the app on the projector and walks through a worked example: the formula panel shows exactly the algebra the instructor would write on the board, while the shaded density panel makes the geometry of the decision rule explicit. In practice sessions and exams, students paste the inputs they used together with the resulting $p$-value, which makes grading deterministic and removes ambiguity around one- vs. two-tailed conventions. The accompanying solution sheets cite the exact query rather than a row in a table.

Technical notes

The app is a single-page client-side application built with React: all computation runs in the student’s browser, with no server round-trip. Distributional computations rely on the jStat numerical library (MIT-licensed). The static bundle is deployed on Netlify, which means it works offline after first load and has no external dependencies at run time.