Precision and Power: decimal.js vs mathjs vs numeric

JavaScript's native Number type uses IEEE 754 double-precision floating-point format. This works for most UI logic, but it fails in scenarios requiring exact decimal representation or advanced linear algebra. For example, 0.1 + 0.2 equals 0.30000000000000004 in native JavaScript. To solve this, developers turn to libraries like decimal.js, mathjs, and numeric. Each takes a different approach to math in the browser and Node.js.

🎯 Core Purpose: Precision vs Breadth vs Legacy

decimal.js is a single-purpose tool.

• It focuses entirely on arbitrary-precision decimal arithmetic.
• It ensures calculations like currency addition are exact.
• It does not handle matrices, complex numbers, or units.

// decimal.js: Exact decimal math
import Decimal from 'decimal.js';

const x = new Decimal(0.1);
const y = new Decimal(0.2);
const sum = x.plus(y);

console.log(sum.toString()); // "0.3" exactly

mathjs is a comprehensive math engine.

• It supports expressions, matrices, complex numbers, and units.
• It can parse string formulas like '12.3 cm to inch'.
• It uses decimal.js or similar logic internally for some precision but prioritizes feature breadth.

// mathjs: Expression parsing and units
import { evaluate, unit } from 'mathjs';

const result = evaluate('0.1 + 0.2'); 
console.log(result); // 0.3 (handled via configuration)

const distance = unit('12.3 cm').to('inch');
console.log(distance.toString()); // "4.84251968503937 inch"

numeric is a legacy numerical analysis library.

• It was built for linear algebra, optimization, and solving differential equations.
• It does not focus on decimal precision; it uses native numbers.
• It is no longer actively maintained, making it risky for new systems.

// numeric: Linear algebra (legacy)
import numeric from 'numeric';

const A = [[1, 2], [3, 4]];
const B = [[5, 6], [7, 8]];
const product = numeric.dot(A, B);

console.log(product); // [[19, 22], [43, 50]] using native floats

🔢 Handling Floating-Point Errors

The most common reason to adopt a math library is fixing floating-point drift.

decimal.js treats every number as a decimal object.

• You must wrap inputs in new Decimal().
• It guarantees precision up to 1 billion decimal places (configurable).
• This is the gold standard for money.

// decimal.js: Financial calculation
const price = new Decimal('19.99');
const tax = new Decimal('0.15');
const total = price.times(1.plus(tax));

console.log(total.toFixed(2)); // "22.99"

mathjs can handle precision but requires setup.

• By default, it uses native numbers for speed.
• You can configure it to use BigNumber (similar to decimal.js) for better accuracy.
• This adds overhead but gives flexibility.

// mathjs: Configuring precision
import { create, all, config } from 'mathjs';

const math = create(all, { 
  number: 'BigNumber', 
  precision: 64 
});

const result = math.add(0.1, 0.2);
console.log(result.toString()); // "0.3"

numeric does not solve floating-point errors.

• It relies on JavaScript's native Number.
• 0.1 + 0.2 will still result in 0.30000000000000004.
• It is unsuitable for financial logic.

// numeric: Native float behavior
import numeric from 'numeric';

const sum = numeric.add(0.1, 0.2);
console.log(sum); // 0.30000000000000004

🧮 Matrix and Linear Algebra Support

Scientific and graphics applications often need matrix operations.

decimal.js has no matrix support.

• You would need to build your own matrix logic on top of Decimals.
• This is tedious and error-prone for complex linear algebra.
• Stick to scalar math with this library.

// decimal.js: No native matrix support
// You must manually map operations
const row = [new Decimal(1), new Decimal(2)];
const scaled = row.map(val => val.times(2)); 
// [[2, 4]] - Manual implementation required

mathjs has robust matrix support built-in.

• It supports dense and sparse matrices.
• Functions like inv(), det(), and eigs() are ready to use.
• It feels like MATLAB or Python's NumPy for JavaScript.

// mathjs: Matrix operations
import { matrix, inv, det } from 'mathjs';

const A = matrix([[1, 2], [3, 4]]);
const inverse = inv(A);
const determinant = det(A);

console.log(determinant); // -2

numeric was designed specifically for this.

• It offers a wide range of linear algebra functions.
• It includes solvers for ODEs (ordinary differential equations).
• However, the API feels dated compared to modern standards.

// numeric: Advanced solvers
import numeric from 'numeric';

// Solving a linear system Ax = B
const A = [[1, 2], [3, 4]];
const B = [5, 6];
const x = numeric.solve(A, B);

console.log(x); // Solution vector using native floats

📦 API Style and Developer Experience

How you write code differs significantly between these tools.

decimal.js uses a chainable, object-oriented API.

• Methods like .plus(), .minus(), .toPrecision() are explicit.
• It is verbose but very clear what is happening.
• TypeScript support is excellent.

// decimal.js: Chainable API
const result = new Decimal(10)
  .dividedBy(3)
  .toDecimalPlaces(2);

console.log(result.toString()); // "3.33"

mathjs offers both functional and expression-based styles.

• You can call math.add(a, b) or evaluate 'a + b'.
• The expression parser is powerful but introduces security risks if using user input.
• It has a steeper learning curve due to its size.

// mathjs: Functional vs Expression
import { add, evaluate } from 'mathjs';

// Functional
const a = add(2, 3); 

// Expression
const b = evaluate('2 + 3'); 

console.log(a, b); // 5 5

numeric uses a simple, global functional API.

• Functions are attached to the main numeric object.
• It lacks modern module ergonomics (ESM support is limited or requires shims).
• Documentation is sparse compared to the others.

// numeric: Global functional API
import numeric from 'numeric';

const mag = numeric.norm2([3, 4]);
console.log(mag); // 5

⚠️ Maintenance and Future-Proofing

Long-term support is critical for architectural decisions.

decimal.js is actively maintained.

• It receives updates for bugs and performance.
• It is a standard dependency in many financial tech stacks.
• Safe for long-term production use.

mathjs is also actively maintained.

• It has a large community and frequent releases.
• It adapts to new JavaScript standards.
• Safe for long-term production use.

numeric is effectively deprecated.

• The last significant updates were years ago.
• It does not support modern ES modules well without configuration.
• Do not use for new projects; migrate to mathjs or ndarray.

📊 Summary: Key Differences

💡 The Big Picture

decimal.js is the specialist 🎯. Use it when correctness matters more than features. If you are building a checkout cart, a ledger, or anything involving money, this is the only safe choice among the three.

mathjs is the generalist 🛠️. Use it when you need a calculator in your app. It handles units, matrices, and expressions beautifully. It is perfect for educational tools, engineering dashboards, or scientific simulations.

numeric is the legacy tool 🕰️. It solved hard problems in the past, but it has been surpassed. Unless you are maintaining an old codebase, skip it. For linear algebra in new projects, mathjs or specialized modern libraries are better paths.

Final Thought: Precision and features are often trade-offs. decimal.js gives you accuracy but no matrices. mathjs gives you everything but requires more setup for strict precision. numeric gives you neither accuracy nor maintenance. Choose based on whether you need exact numbers or advanced math.