mathjs, ndarray, and numeric are JavaScript libraries designed to support mathematical, scientific, and numerical computing in browser or Node.js environments. They provide capabilities beyond native JavaScript's limited math support, such as matrix operations, linear algebra, complex numbers, and array manipulation. While they share overlapping goals, their design philosophies, APIs, and target use cases differ significantly — especially in how they handle data structures, performance, and extensibility.
Scientific Computing in JavaScript: mathjs vs ndarray vs numeric
When you need to go beyond basic arithmetic in JavaScript — whether for data analysis, engineering calculations, or interactive visualizations — you’ll quickly hit the limits of native Math. That’s where specialized libraries come in. mathjs, ndarray, and numeric each aim to bring scientific computing to the browser, but they take very different approaches. Let’s break down how they compare in real-world usage.
⚠️ Maintenance Status: Don’t Start With a Dead End
Before diving into features, check if the project is alive.
numericis deprecated. Its GitHub repository states: "This library is no longer maintained." The last meaningful commit was years ago. Do not use it in new projects.mathjsis actively maintained, with regular releases and strong documentation.ndarrayis part of thescijsecosystem, which sees occasional updates and remains usable, though development pace is slower thanmathjs.
✅ Bottom line: Rule out
numericimmediately. The comparison below focuses onmathjsandndarrayfor practical decision-making.
🧮 Core Philosophy: Expressiveness vs Performance
mathjs: "Write Math Like Math"
mathjs prioritizes readability and expressiveness. You can write equations almost as you would on paper, including support for units, complex numbers, and symbolic expressions.
// mathjs: natural syntax for math
import { evaluate, unit, complex } from 'mathjs';
// Evaluate string expressions
const result1 = evaluate('sqrt(4 + 5^2)'); // 5.385...
// Work with units
const speed = unit('55 km/h').to('m/s'); // ~15.28 m/s
// Complex numbers
const z = complex(2, 3);
const w = z.pow(2); // -5 + 12i
It includes a full expression parser, so users can input formulas directly — great for calculators or config-driven computations.
ndarray: "Arrays First, Everything Else Later"
ndarray takes a low-level, performance-first approach inspired by NumPy. It provides a memory-efficient n-dimensional array structure but no built-in math functions. You must pair it with other scijs packages (like ndarray-ops, ndarray-linear-solve) for actual computation.
// ndarray: manual array creation and ops
import ndarray from 'ndarray';
import ops from 'ndarray-ops';
// Create a 2x2 matrix
const A = ndarray(new Float64Array([1, 2, 3, 4]), [2, 2]);
// Multiply every element by 2
ops.mulseq(A, 2); // A is modified in place
// No built-in .dot() or .inv() — need extra packages
This modularity keeps bundles small but shifts complexity to the developer.
🔢 Matrix and Array Operations
Creating and Manipulating Matrices
mathjs uses its own Matrix type with chainable methods:
// mathjs matrix
import { matrix, multiply, inv } from 'mathjs';
const A = matrix([[1, 2], [3, 4]]);
const B = matrix([[5], [6]]);
const x = multiply(inv(A), B); // Solve Ax = B
ndarray treats matrices as views over typed arrays:
// ndarray matrix
import ndarray from 'ndarray';
import solve from 'ndarray-linear-solve';
const A = ndarray(new Float64Array([1, 2, 3, 4]), [2, 2]);
const b = ndarray(new Float64Array([5, 6]), [2]);
const x = solve(A, b); // Returns new ndarray
Note: ndarray doesn’t include solve by default — you must install ndarray-linear-solve separately.
Element-wise Operations
mathjs handles broadcasting automatically:
// mathjs: add scalar to matrix
const M = matrix([[1, 2], [3, 4]]);
const result = M.add(10); // [[11, 12], [13, 14]]
ndarray requires explicit loops or ndarray-ops:
// ndarray: add scalar
import ops from 'ndarray-ops';
const M = ndarray(new Float32Array([1, 2, 3, 4]), [2, 2]);
ops.addeq(M, 10); // Modifies M in place
📐 Advanced Math Features
Units and Physical Quantities
Only mathjs supports units natively:
// mathjs units
import { unit } from 'mathjs';
const length = unit('5 km');
const time = unit('2 hours');
const speed = length.divide(time).to('m/s'); // ~0.694 m/s
ndarray has no concept of units — you’d need to track them manually.
Complex Numbers
mathjs has first-class complex number support:
// mathjs complex
import { complex, sqrt } from 'mathjs';
const z = complex(-1, 0);
const root = sqrt(z); // 0 + i
ndarray can store complex data using interleaved real/imaginary values, but you need cwise or custom code to operate on them — no built-in complex arithmetic.
Expression Parsing
mathjs includes a powerful expression evaluator:
// mathjs parsing
import { parse } from 'mathjs';
const node = parse('x^2 + y');
const code = node.compile();
const result = code.evaluate({ x: 3, y: 4 }); // 13
ndarray offers nothing in this space — it’s purely for array data structures.
⚙️ Performance Considerations
mathjsis not optimized for large-scale numerical workloads. Its focus on flexibility and safety means overhead per operation. Fine for small-to-medium datasets or user-facing calculations, but avoid for heavy simulation or real-time signal processing.ndarrayshines when you need raw speed on large arrays. By using typed arrays and in-place operations, it minimizes allocations. However, you pay for this with boilerplate and fragmented tooling.
Example: multiplying two 1000×1000 matrices
mathjs: convenient but slower due to object wrapping and bounds checking.ndarray+ndarray-blas: faster, but requires installing and wiring up BLAS bindings.
🧩 Ecosystem and Extensibility
mathjsis a batteries-included library. Most features you’d expect (statistics, probability, algebra) are built in or available via official extensions.ndarrayis a building block. You compose functionality from dozens of tinyscijspackages (ndarray-fill,ndarray-sort,ndarray-fourier, etc.). This avoids bloat but increases integration effort.
🛠️ Real-World Use Cases
Case 1: Web-Based Engineering Calculator
- Best choice:
mathjs - Why? Users enter formulas like
sin(30 deg) * 5 N; units and parsing are essential.
// User types: "force = mass * acceleration"
const expr = '5 kg * 9.81 m/s^2';
const force = evaluate(expr); // 49.05 N
Case 2: Real-Time Audio Spectrum Analyzer
- Best choice:
ndarray - Why? You’re processing large float32 arrays from Web Audio API; performance matters more than syntax sugar.
// Process audio buffer
const samples = ndarray(audioBuffer.getChannelData(0));
fft(samples); // using ndarray-fourier
Case 3: Financial Risk Simulation (Monte Carlo)
- Best choice:
mathjsfor prototyping; consider WebAssembly or Rust WASM for production scale. - Why? You need distributions, random sampling, and readable logic — but may outgrow JS entirely.
📌 Summary Table
| Feature | mathjs | ndarray | numeric |
|---|---|---|---|
| Status | ✅ Actively maintained | ⚠️ Low activity, usable | ❌ Deprecated |
| Syntax | High-level, expressive | Low-level, NumPy-like | Medium-level |
| Units | ✅ Built-in | ❌ None | ❌ None |
| Complex Numbers | ✅ First-class | ⚠️ Manual handling | ✅ Basic support |
| Expression Parser | ✅ Yes | ❌ No | ❌ No |
| Performance | ⚠️ Moderate (safe, not fast) | ✅ High (with right packages) | ⚠️ Outdated |
| Bundle Impact | ⚠️ Large (feature-rich) | ✅ Small (modular) | ✅ Small (but obsolete) |
| Best For | Calculators, education, scripting | Image/audio processing, simulation | Legacy projects only |
💡 Final Recommendation
- Need to compute
sqrt(16 m^2)or let users typedet([[a,b],[c,d]])? → Usemathjs. - Processing gigabytes of sensor data in the browser? → Use
ndarraywith targetedscijsmodules. - Considering
numericbecause it looks simple? → Don’t. Its age shows in API design and compatibility. Modern alternatives exist.
In most frontend scenarios — dashboards, interactive tools, educational apps — mathjs delivers the best balance of power and usability. Reserve ndarray for performance-critical numerical kernels where you’re willing to trade convenience for speed.
- mathjs:
Choose
mathjswhen you need a high-level, expressive math library that supports symbolic computation, units, complex numbers, and a flexible expression parser. It’s ideal for applications like calculators, educational tools, engineering simulations, or any scenario where readability and mathematical expressiveness matter more than raw speed. Its API is intuitive for developers without deep numerical computing backgrounds. - ndarray:
Choose
ndarraywhen you're building performance-sensitive applications that rely heavily on multidimensional array operations (e.g., image processing, signal analysis, or physics simulations) and you’re comfortable working with lower-level, NumPy-inspired APIs. It integrates well with the scijs ecosystem and gives fine-grained control over memory layout, but requires manual management of operations and lacks built-in high-level math functions. - numeric:
Avoid
numericin new projects. The library has been officially deprecated by its author and is no longer maintained. While it once provided a solid set of numerical routines (like linear solvers and optimization), its outdated codebase, lack of TypeScript support, and absence of modern JavaScript patterns make it unsuitable for production use today. Evaluatemathjsorndarrayinstead.
Math.js is an extensive math library for JavaScript and Node.js. It features a flexible expression parser with support for symbolic computation, comes with a large set of built-in functions and constants, and offers an integrated solution to work with different data types like numbers, big numbers, complex numbers, fractions, units, and matrices. Powerful and easy to use.
Features
- Supports numbers, bignumbers, bigints, complex numbers, fractions, units, strings, arrays, and matrices.
- Is compatible with JavaScript's built-in Math library.
- Contains a flexible expression parser.
- Does symbolic computation.
- Comes with a large set of built-in functions and constants.
- Can be used as a command line application as well.
- Runs on any JavaScript engine.
- Is easily extensible.
- Open source.
Usage
Math.js can be used in both node.js and in the browser.
Install math.js using npm:
npm install mathjs
Or download mathjs via one of the CDN's listed on the downloads page:
https://mathjs.org/download.html
Math.js can be used similar to JavaScript's built-in Math library. Besides that, math.js can evaluate expressions and supports chained operations.
import {
atan2, chain, derivative, e, evaluate, log, pi, pow, round, sqrt
} from 'mathjs'
// functions and constants
round(e, 3) // 2.718
atan2(3, -3) / pi // 0.75
log(10000, 10) // 4
sqrt(-4) // 2i
pow([[-1, 2], [3, 1]], 2) // [[7, 0], [0, 7]]
derivative('x^2 + x', 'x') // 2 * x + 1
// expressions
evaluate('12 / (2.3 + 0.7)') // 4
evaluate('12.7 cm to inch') // 5 inch
evaluate('sin(45 deg) ^ 2') // 0.5
evaluate('9 / 3 + 2i') // 3 + 2i
evaluate('det([-1, 2; 3, 1])') // -7
// chaining
chain(3)
.add(4)
.multiply(2)
.done() // 14
See the Getting Started for a more detailed tutorial.
Browser support
Math.js works on any ES2020 compatible JavaScript engine, including node.js, Chrome, Firefox, Safari, and Edge.
Documentation
Build
First clone the project from github:
git clone git@github.com:josdejong/mathjs.git
cd mathjs
Install the project dependencies:
npm install
Then, the project can be build by executing the build script via npm:
npm run build
This will build ESM output, CommonJS output, and the bundle math.js from the source files and put them in the folder lib.
Develop
When developing new features for mathjs, it is good to be aware of the following background information.
Code
The code of mathjs is written in ES modules, and requires all files to have a real, relative path, meaning the files must have a *.js extension. Please configure adding file extensions on auto import in your IDE.
Architecture
What mathjs tries to achieve is to offer an environment where you can do calculations with mixed data types,
like multiplying a regular number with a Complex number or a BigNumber, and work with all of those in matrices.
Mathjs also allows to add a new data type with little effort.
The solution that mathjs uses has two main ingredients:
-
Typed functions. All functions are created using
typed-function. This makes it easier to (dynamically) create and extend a single function with new data types, automatically do type conversions on function inputs, etc. So, if you create function multiply for twonumbers, you can extend it with support for multiplying your own data type, sayMyDecimal. If you define a conversion fromMyDecimaltonumber, the typed-function will automatically allow you to multiply aMyDecimalwith anumber. -
Dependency injection. When we have a function
multiplywith support forMyDecimal, thanks to the dependency injection, other functions usingmultiplyunder the hood, likeprod, will automatically supportMyDecimaltoo. This also works the other way around: if you don't need the heavyweightmultiply(which supports BigNumbers, matrices, etc), and you just need a plain and simple number support, you can use a lightweight implementation ofmultiplyjust for numbers, and inject that inprodand other functions.
At the lowest level, mathjs has immutable factory functions which create immutable functions. The core function math.create(...) creates a new instance having functions created from all passed factory functions. A mathjs instance is a collection of created functions. It contains a function like math.import to allow extending the instance with new functions, which can then be used in the expression parser.
Implementing a new function
A common case is to implement a new function. This involves the following steps:
- Implement the function in the right category, for example
./src/function/arithmetic/myNewFunction.js, where you can replacearithmeticwith the proper category, andmyNewFunctionwith the name of the new function. Add the new function to the index files./src/factoriesAny.jsand possibly./src/factoriesNumber.js. - Write documentation on the function in the source code comment of
myNewFunction.js. This documentation is used to auto generate documentation on the website. - Write embedded documentation for the new function in
./src/expression/embeddedDocs/function/arithmetic/myNewFunction.js. Add the new documentation to the index file./src/expression/embeddedDocs/embeddedDocs.js. - Write unit tests for the function in
./test/unit-tests/function/arithmetic/myNewFunction.test.js. - Write the necessary TypeScript definitions for the new function in
./types/index.d.ts, and write tests for it in./test/typescript-tests/testTypes.ts. This is described in ./types/EXPLANATION.md -- make sure to read that page, as Typescript definitions must be added in multiple places in the code. - Ensure the code style is ok by running
npm run lint(runnpm run formatto fix the code style automatically).
Build scripts
The build script currently generates two types of output:
- any, generate entry points to create full versions of all functions
- number: generating and entry points to create lightweight functions just supporting
number
For each function, an object is generated containing the factory functions of all dependencies of the function. This allows to just load a specific set of functions, and not load or bundle any other functionality. So for example, to just create function add you can do math.create(addDependencies).
Test
To execute tests for the library, install the project dependencies once:
npm install
Then, the tests can be executed:
npm test
To test the type definitions:
npm run test:types
Additionally, the tests can be run on FireFox using headless mode:
npm run test:browser
To run the tests remotely on LambdaTest, first set the environment variables LT_USERNAME and LT_ACCESS_KEY with your username and access key and then execute:
npm run test:lambdatest
You can separately run the code linter, though it is also executed with npm test:
npm run lint
To automatically fix linting issue, run:
npm run format
To test code coverage of the tests:
npm run coverage
To see the coverage results, open the generated report in your browser:
./coverage/lcov-report/index.html
Continuous integration testing
Continuous integration tests are run on Github Actions and LambdaTest every time a commit is pushed to github. Github Actions runs the tests for different versions of node.js, and LambdaTest runs the tests on all major browsers.
Thanks, GitHub Actions and LambdaTest for the generous free hosting of this open source project!
License
mathjs is published under the Apache 2.0 license:
Copyright (C) 2013-2025 Jos de Jong <wjosdejong@gmail.com>
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
https://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
mathjs contains a JavaScript port of the CSparse library, published under the LGPL-2.1+ license:
CSparse: a Concise Sparse matrix package.
Copyright (c) 2006, Timothy A. Davis.
http://www.suitesparse.com
--------------------------------------------------------------------------------
CSparse is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
CSparse is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this Module; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA