An extensive math library for JavaScript and Node.js. Includes an advanced expression parser. Supports numbers, complex numbers, units, strings, and matrices. Contains a large set of functions and constants.
mathjs is an extensive math library for JavaScript and Node.js. It features a flexible expression parser, a large set of built-in functions, and supports different data types such as numbers, big numbers, complex numbers, fractions, units, and matrices.
Basic Arithmetic
Perform basic arithmetic operations like addition, subtraction, multiplication, and division.
const math = require('mathjs');
const sum = math.add(2, 3); // 5
const product = math.multiply(4, 5); // 20Matrix Operations
Perform operations on matrices such as addition, multiplication, and inversion.
const math = require('mathjs');
const matrix1 = math.matrix([[1, 2], [3, 4]]);
const matrix2 = math.matrix([[5, 6], [7, 8]]);
const result = math.add(matrix1, matrix2); // [[6, 8], [10, 12]]Complex Numbers
Handle complex numbers and perform arithmetic operations on them.
const math = require('mathjs');
const complex1 = math.complex(2, 3);
const complex2 = math.complex(1, 4);
const sum = math.add(complex1, complex2); // 3 + 7iUnit Conversions
Convert between different units of measurement.
const math = require('mathjs');
const distance = math.unit(5, 'km');
const convertedDistance = distance.to('mile'); // 3.10685596 mileExpression Parsing
Parse and evaluate mathematical expressions from strings.
const math = require('mathjs');
const expr = '2 * (3 + 4)';
const result = math.evaluate(expr); // 14numeric is a library for numerical computations in JavaScript. It provides functions for matrix operations, solving linear systems, and performing numerical integration. Compared to mathjs, numeric is more focused on numerical methods and less on symbolic computation and unit conversions.
algebrite is a JavaScript library for symbolic mathematics. It can perform algebraic operations, calculus, and other symbolic computations. While mathjs also supports some symbolic computation, algebrite is more specialized in this area.
simple-statistics is a JavaScript library for statistical calculations. It provides functions for descriptive statistics, probability distributions, and regression analysis. Unlike mathjs, which covers a broad range of mathematical functions, simple-statistics is specialized in statistical methods.
Math.js is an extensive math library for JavaScript and Node.js, compatible with JavaScript's built-in Math library.
* Note: arrays and matrices are to be implemented.
Math.js can be installed with npm:
npm install mathjs
Alternatively, the latest stable version of math.js can be downloaded from github:
Math.js can be loaded in node.js using require, and similarly in the browser
using require.js.
var math = require('mathjs');
var a = math.sqrt(-4);
console.log('a = ' + a); // 'a = 2i'
Math.js can be loaded as a regular javascript file in the browser:
<!DOCTYPE HTML>
<html>
<head>
<script src="math.js" type="text/javascript"></script>
</head>
<body>
<script type="text/javascript">
var a = math.sqrt(-4);
document.write('a = ' + a); // 'a = 2i'
</script>
</body>
</html>
Math.js can be used similar to Javascript's built-in Math library.
var math = require('mathjs'),
Complex = math.Complex,
Unit = math.Unit;
// use methods and types available in the math object
var a = math.sin(math.pi / 4);
var b = math.pow(a, 2);
console.log('b = ' + math.round(b, 3)); // 'b = 0.5'
var c = new Complex(3, -4);
var d = math.sqrt(c);
console.log('d = ' + d); // 'd = 2 - i'
var e = math.sqrt(-4);
console.log('e = ' + e); // 'e = 2i'
var f = new Unit(60, 'deg');
var g = math.cos(f);
console.log('g = ' + math.round(g, 3)); // 'g = 0.5'
Math.js contains a flexible and easy to use expression parser.
The parser supports all data types, methods and constants available in math.js.
It has a method eval to evaluate expressions,
and parse to parse expressions and build a node tree from it.
The parser supports variable and function definitions.
Variables and functions can be manipulated using the methods get and put.
The following example code shows how to create and use a parser.
// load math.js
var math = require('mathjs');
// create a new parser
var parser = new math.parser.Parser();
// evaluate expressions
var a = parser.eval('sqrt(3^2 + 4^2)'); // 5
var b = parser.eval('sqrt(-4)'); // 2i
var c = parser.eval('2 inch in cm'); // 5.08 cm
var d = parser.eval('cos(45 deg)'); // 0.7071067811865476
// define variables and functions
parser.eval('x = 7 / 2'); // 3.5
parser.eval('x + 3'); // 6.5
parser.eval('function f(x, y) = x^y'); // f(x, y)
parser.eval('f(2, 3)'); // 8
// get and put variables and functions
var x = parser.get('x'); // 7
var f = parser.get('f'); // function
var g = f(3, 2); // 9
parser.put('h', 500);
var i = parser.eval('h / 2'); // 250
parser.put('hello', function (name) {
return 'hello, ' + name + '!';
});
parser.eval('hello("user")'); // "hello, user!"
// clear defined functions and variables
parser.clear();
Available methods:
var result = parser.eval(expr); // evaluate an expression
var value = parser.get(name); // retrieve a variable from the parser
parser.put(name, value); // put a variable in the parser
var node = parser.parse(expr); // parse an expression into a node tree
var result = node.eval(); // evaluate a node
Math.js features a workspace, which manages a set of expressions. Expressions can be added, replace, deleted, and inserted in the workspace. The workspace keeps track on the dependencies between the expressions, and automatically updates results of depending expressions when variables or function definitions are changed in the workspace.
// load math.js
var math = require('mathjs');
// create a new workspace
var workspace = new math.parser.Workspace();
// add expressions to the workspace
var id0 = workspace.append('a = 3/4');
var id1 = workspace.append('a + 2');
console.log('a + 2 = ' + workspace.getResult(id1));
// replace expressions in the workspace
workspace.replace('a=5/2', id0);
console.log('a + 2 = ' + workspace.getResult(id1));
Available methods:
var id = workspace.append(expr);
var id = workspace.insertBefore(expr, beforeId);
var id = workspace.insertAfter(expr, afterId);
workspace.replace(expr, id);
workspace.remove(id);
workspace.clear();
var expr = workspace.getExpr(id);
var result = workspace.getResult(id);
var deps = workspace.getDependencies(id);
var changes = workspace.getChanges(updateSeq);
Math.js supports both native data types like Number, String, and Array, as well as advanced data types like Complex and Unit.
The built-in type Number can be used in all methods.
var math = require('mathjs');
var a = math.subtract(7.1, 2.3); // 4.8
var b = math.round(math.pi, 3); // 3.142
var c = math.sqrt(new Number(4.41e2)); // 21
The built-in type String can be used in applicable methods.
var math = require('math.js');
var a = math.add('hello ', 'world'); // 'hello world'
var b = math.max('A', 'D', 'C'); // 'D'
Math.js supports complex numbers.
var math = require('math.js'),
Complex = math.Complex;
var a = new Complex(2, 3); // 2 + 3i
var b = new Complex('4 - 2i'); // 4 - 2i
var c = math.add(a, b); // 6 + i
var d = math.sqrt(-4); // 2i
Math.js supports units.
var math = require('math.js'),
Unit = math.Unit;
var a = new Unit(55, 'cm'); // 550 mm
var b = new Unit(0.1, 'm'); // 100 mm
var c = math.add(a, b); // 650 mm
var parser = new math.parser.Parser();
var d = parser.eval('2 inch in cm'); // 5.08 cm
Math.js has the following built-in constants.
Math.js contains the following methods. The methods support all available data types (Number, String, Complex, and Unit) where applicable.
The library can easily be extended with functions and variables using the
import method. The method import accepts a filename or an object with
functions and variables.
var math = require('mathjs');
// define new functions and variables
math.import({
myvalue: 42,
hello: function (name) {
return 'hello, ' + name + '!';
});
});
// defined methods can be used in both JavaScript as well as the parser
var a = math.myvalue * 2; // 84
var b = math.hello('user'); // 'hello, user!'
var parser = new math.parser.Parser();
parser.eval('myvalue + 10'); // 52
parser.eval('hello("user")'); // 'hello, user!'
To import functions from a math library like numbers.js, the library must be installed using npm:
npm install numbers
And next, the library can be imported into math.js:
var math = require('mathjs'),
parser = new math.parser.Parser();
// import the numbers.js library into math.js
math.import('numbers');
// use functions from numbers.js
math.fibonacci(7); // 7
parser.eval('fibonacci(7)'); // 7
First clone the project from github:
git clone git://github.com/josdejong/mathjs.git
The project uses jake as build tool, which must be installed globally. After jake is installed, the project dependencies can be downloaded using npm. Then the project can be build by executing jake in the root of the project.
cd mathjs
sudo npm install -g jake
npm install
jake
When jake is executed, it will generate the library math.js and math.min.js from the source files, and will test the library.
To execute tests for the library, run:
npm test
Copyright (C) 2013 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
http://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.
FAQs
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 dif
The npm package mathjs receives a total of 984,927 weekly downloads. As such, mathjs popularity was classified as popular.
We found that mathjs demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
Research
A malicious npm package disguised as a WhatsApp client is exploiting authentication flows with a remote kill switch to exfiltrate data and destroy files.
Security News
PyPI now supports digital attestations, enhancing security and trust by allowing package maintainers to verify the authenticity of Python packages.
Security News
GitHub removed 27 malicious pull requests attempting to inject harmful code across multiple open source repositories, in another round of low-effort attacks.