Statistical and Mathematical Libraries Compared: jstat vs mathjs vs simple-statistics

When you need to do math or statistics in the browser — whether for data dashboards, scientific tools, or analytics features — picking the right library matters. jstat, mathjs, and simple-statistics each solve overlapping problems but with very different philosophies. Let’s compare them head-to-head on real-world tasks.

📊 Core Focus: What Each Library Is Built For

jstat is a statistics-focused library inspired by MATLAB and R. It excels at probability distributions, hypothesis tests, and vector/matrix operations. Think of it as a toolbox for inferential statistics.

mathjs is a general-purpose mathematics engine. It handles everything from basic arithmetic to symbolic algebra, units, matrices, and expression evaluation. It’s more like a programmable calculator with superpowers.

simple-statistics provides clean, functional implementations of common statistical methods — mean, median, regression, confidence intervals — with an emphasis on correctness and simplicity. No frills, no side effects.

🔢 Basic Statistics: Mean, Median, and Quantiles

All three can compute basic descriptive stats, but their APIs differ significantly.

jstat operates on arrays using static methods:

import jStat from 'jstat';

const data = [1, 2, 3, 4, 5];
const mean = jStat.mean(data); // 3
const median = jStat.median(data); // 3

mathjs uses a unified math.* namespace and supports both arrays and its own matrix type:

import { mean, median } from 'mathjs';

const data = [1, 2, 3, 4, 5];
const meanVal = mean(data); // 3
const medianVal = median(data); // 3

simple-statistics exports pure functions that take arrays and return values:

import { mean, median } from 'simple-statistics';

const data = [1, 2, 3, 4, 5];
const avg = mean(data); // 3
const med = median(data); // 3

💡 Note: simple-statistics and mathjs allow direct imports of only what you use, aiding tree-shaking. jstat typically imports the entire module.

📈 Probability Distributions: Working with Normal, T, and Chi-Square

This is where jstat shines. It includes PDF, CDF, inverse CDF, and random sampling for many distributions.

jstat example — find the 95th percentile of a standard normal distribution:

import jStat from 'jstat';

const z95 = jStat.normal.inv(0.95, 0, 1); // ≈ 1.64485

mathjs has limited built-in distribution support. You’d need to implement PDFs manually or use external formulas:

// mathjs does not include statistical distributions out of the box
// You'd have to write or import helpers

simple-statistics includes only a few distributions (normal, t) via helper functions:

import { epsilon } from 'simple-statistics';

// No direct .inv() method; uses approximation functions
// For example, to get z-score for 95%:
function ppf(p) {
  // Implementation required — not provided directly
}

✅ Verdict: For serious work with statistical distributions (e.g., p-values, critical values), jstat is the only one of the three with full coverage.

🧮 Matrix Operations: Linear Algebra in Practice

Need to multiply matrices or solve linear systems? Here’s how they compare.

jstat treats arrays as vectors/matrices and offers linear algebra methods:

import jStat from 'jstat';

const A = [[1, 2], [3, 4]];
const B = [[5], [6]];
const product = jStat.multiply(A, B); // [[17], [39]]

mathjs has first-class matrix support with rich operations:

import { matrix, multiply } from 'mathjs';

const A = matrix([[1, 2], [3, 4]]);
const B = matrix([[5], [6]]);
const result = multiply(A, B); // matrix([[17], [39]])

simple-statistics does not support matrix operations at all. It’s purely scalar and array-based.

// simple-statistics: no matrix functionality

✅ Verdict: For linear algebra, choose jstat for lightweight needs or mathjs for more advanced features (decompositions, eigenvalues, etc.).

🧪 Hypothesis Testing: T-Tests and Confidence Intervals

Running a t-test on two samples?

jstat includes common tests:

import jStat from 'jstat';

const sample1 = [1, 2, 3];
const sample2 = [2, 3, 4];
const tStat = jStat.studentttest(sample1, sample2).tstat;

mathjs does not include statistical tests. You’d need to implement them yourself.

// mathjs: no built-in t-test

simple-statistics provides a clean t-test implementation:

import { tTest } from 'simple-statistics';

const result = tTest([1, 2, 3], [2, 3, 4]);
// Returns { pValue: ..., testStatistic: ... }

Similarly, for confidence intervals:

// simple-statistics
import { confidenceInterval } from 'simple-statistics';
const ci = confidenceInterval([1,2,3,4,5], 0.95);

// jstat
const ci2 = jStat.confidence([1,2,3,4,5], 0.95);

// mathjs: not available

✅ Verdict: Both jstat and simple-statistics support inference; simple-statistics offers clearer return structures, while jstat covers more test types.

🧾 Expression Parsing and Dynamic Formulas

What if users enter "2 * sin(x) + 5" and you need to evaluate it?

Only mathjs supports this out of the box:

import { evaluate, parse } from 'mathjs';

const expr = parse('2 * sin(x) + 5');
const result = expr.evaluate({ x: Math.PI / 2 }); // 7

// Or simpler:
evaluate('2 * sin(pi / 2) + 5'); // 7

jstat and simple-statistics have no expression parsing capability.

✅ Verdict: If your app needs formula input from users, mathjs is the only viable choice here.

📏 Units and Physical Quantities

Converting meters to feet or adding time durations?

Only mathjs handles units:

import { unit } from 'mathjs';

const length = unit('5 m');
const inFeet = length.to('ft'); // ≈ 16.4 ft

The other two libraries treat numbers as dimensionless scalars.

📦 Bundle Size and Tree-Shaking Friendliness

While we won’t cite exact numbers, consider these architectural traits:

• simple-statistics: Exports individual functions. You only bundle what you import. Ideal for performance-sensitive apps.
• mathjs: Highly modular but large overall. Supports custom builds to reduce size, but default imports can be heavy.
• jstat: Typically imported as a single object. Harder to tree-shake; you often pull in the whole library even if you only use mean().

🔄 Mutability and Functional Style

simple-statistics is purely functional — no side effects, no mutation.

jstat sometimes mutates inputs (e.g., in-place sorting for quantiles), which can surprise developers.

mathjs generally avoids mutation but uses object-oriented wrappers (like Matrix) that encapsulate state.

🛑 Maintenance and Deprecation Status

As of 2024:

• jstat is actively maintained (latest release in 2023), with no deprecation notices.
• mathjs is under active development with regular releases and strong community support.
• simple-statistics is stable and maintained, with updates as recently as 2023. No deprecation warnings.

None of these packages are deprecated. All are safe for new projects.

🤝 Shared Strengths

Despite differences, all three share important qualities:

1. Browser and Node.js Support

All run in modern browsers and server environments without polyfills.

2. TypeScript Compatibility

Each provides or supports TypeScript definitions (via @types/ or built-in).

3. Deterministic Output

Given the same input, they produce consistent results — crucial for testing and reproducibility.

4. MIT or Similar Permissive Licenses

Safe for commercial use.

📊 Summary Table

💡 Final Guidance

• Building a data dashboard or analytics UI? → Start with simple-statistics. It’s small, clear, and covers 90% of common needs.
• Developing a scientific tool, A/B test analyzer, or stats-heavy app? → Use jstat for its distribution and test coverage.
• Creating a calculator, engineering simulator, or app with user-defined formulas? → Go with mathjs for its unmatched breadth.

Don’t over-engineer: if you only need mean() and median(), simple-statistics is likely the best fit. But if you’re computing p-values from F-distributions or solving linear systems, reach for jstat. And if your users type math into text boxes, mathjs is your only real option.

Choose based on the mathematical scope of your problem — not just today’s feature, but what you might need next month.