decimal.js vs big.js vs bignumber.js vs mathjs
JavaScript Arbitrary-Precision Libraries Comparison
Search packages..
1 Year
decimal.jsbig.jsbignumber.jsmathjsSimilar Packages:
What's JavaScript Arbitrary-Precision Libraries?

JavaScript arbitrary-precision libraries are designed to handle numerical calculations with high precision, avoiding the pitfalls of floating-point arithmetic in JavaScript. These libraries are essential for applications that require accurate financial calculations, scientific computations, or any domain where precision is critical. They provide various functionalities for arithmetic operations, rounding, and formatting, ensuring that developers can work with numbers accurately without losing precision due to JavaScript's inherent limitations with floating-point numbers.

Package Weekly Downloads Trend
Github Stars Ranking
Stat Detail
Package
Downloads
Stars
Size
Issues
Publish
License
decimal.js24,072,5906,711284 kB132 months agoMIT
big.js22,586,8175,01458.7 kB127 months agoMIT
bignumber.js15,553,7076,813350 kB224 days agoMIT
mathjs1,363,45714,6839.51 MB15011 days agoApache-2.0
Feature Comparison: decimal.js vs big.js vs bignumber.js vs mathjs

Precision Handling

  • decimal.js:

    decimal.js excels in handling decimal arithmetic with high precision. It supports various rounding modes and ensures that calculations remain accurate, making it ideal for financial applications where decimal representation is crucial.

  • big.js:

    big.js provides basic arbitrary-precision arithmetic, allowing for accurate calculations with large numbers. It is designed to handle numbers as strings to maintain precision, but it does not support advanced features like rounding modes or complex mathematical functions.

  • bignumber.js:

    bignumber.js offers arbitrary-precision arithmetic with a focus on performance. It allows for precise calculations with large numbers and includes features for rounding, formatting, and conversion, making it suitable for various applications.

  • mathjs:

    mathjs provides arbitrary-precision arithmetic along with a wide range of mathematical functions. It allows for precise calculations while also supporting complex numbers, matrices, and statistical functions, making it a versatile choice for mathematical applications.

Performance

  • decimal.js:

    decimal.js may have a slightly higher overhead due to its advanced features, but it provides excellent performance for decimal arithmetic. It is optimized for scenarios where precision is paramount, such as financial calculations.

  • big.js:

    big.js is lightweight and optimized for performance, making it suitable for applications where speed is essential. It has a smaller footprint compared to other libraries, which can be beneficial in performance-sensitive scenarios.

  • bignumber.js:

    bignumber.js is designed for high performance, especially in scenarios involving large numbers and complex calculations. It balances precision and speed, making it a good choice for applications that require extensive numerical operations.

  • mathjs:

    mathjs is more comprehensive and may be less performant than the others due to its extensive feature set. However, it is still efficient for most applications, especially those requiring a mix of precision and advanced mathematical capabilities.

Feature Set

  • decimal.js:

    decimal.js provides advanced decimal arithmetic features, including various rounding modes and precise control over decimal places. It is particularly useful for applications in finance and accounting.

  • big.js:

    big.js focuses on basic arithmetic operations and provides a simple API for handling large numbers. It is straightforward and easy to use, but lacks advanced mathematical functions.

  • bignumber.js:

    bignumber.js offers a rich set of features for arbitrary-precision arithmetic, including rounding, formatting, and conversion functions. It is suitable for applications that require a comprehensive arithmetic solution.

  • mathjs:

    mathjs is a full-featured mathematics library that includes arbitrary-precision arithmetic along with a wide range of mathematical functions, including algebra, calculus, and statistics. It is ideal for applications that require both precision and advanced mathematical capabilities.

Ease of Use

  • decimal.js:

    decimal.js may require a bit more understanding of its features due to its advanced capabilities, but it provides clear documentation to help users navigate its functionalities.

  • big.js:

    big.js is known for its simplicity and ease of use, making it a great choice for developers who need basic arbitrary-precision arithmetic without a steep learning curve.

  • bignumber.js:

    bignumber.js has a user-friendly API that is easy to understand, making it accessible for developers who need to perform precise calculations without extensive setup.

  • mathjs:

    mathjs has a steeper learning curve due to its extensive feature set, but it offers comprehensive documentation and examples, making it easier for developers to leverage its full potential.

Community and Support

  • decimal.js:

    decimal.js has a dedicated user base, especially in financial sectors, and offers good documentation and community support for its advanced features.

  • big.js:

    big.js has a smaller community compared to other libraries, but it is well-maintained and has sufficient documentation for basic use cases.

  • bignumber.js:

    bignumber.js has a moderate community and is widely used in various applications, providing a good amount of resources and support for developers.

  • mathjs:

    mathjs has a large and active community, with extensive documentation, tutorials, and examples available. It is well-supported and frequently updated, making it a reliable choice for complex mathematical applications.

How to Choose: decimal.js vs big.js vs bignumber.js vs mathjs
  • decimal.js:

    Select decimal.js if your application requires advanced decimal arithmetic and features like rounding modes and precision control. It is particularly useful for financial applications where decimal representation is crucial, providing a robust set of features for precise calculations.

  • big.js:

    Choose big.js for its simplicity and lightweight nature when you need basic arbitrary-precision arithmetic without additional features. It is ideal for straightforward applications where performance is key and complex mathematical operations are not required.

  • bignumber.js:

    Opt for bignumber.js if you need a comprehensive solution for arbitrary-precision arithmetic with a focus on performance and flexibility. It supports a wide range of mathematical operations and is suitable for applications requiring extensive calculations, such as financial applications.

  • mathjs:

    Use mathjs when you need a full-featured mathematics library that includes arbitrary-precision arithmetic along with a wide array of mathematical functions. It is perfect for applications that require both numerical precision and advanced mathematical capabilities, such as algebra, calculus, and statistics.

Similar Npm Packages to decimal.js

decimal.js is a library for arbitrary-precision decimal arithmetic in JavaScript. It provides a way to perform calculations with decimal numbers without the pitfalls of floating-point precision errors that are common in JavaScript. This makes it particularly useful for applications that require high precision, such as financial calculations, scientific computations, or any domain where accuracy is critical. The library supports a wide range of mathematical operations, including addition, subtraction, multiplication, division, and more, all while maintaining precision.

While decimal.js is a robust choice for handling decimal arithmetic, there are several alternatives available that also cater to similar needs. Here are a few notable options:

  • big.js is a lightweight library for arbitrary-precision decimal arithmetic. It is designed to be simple and efficient, providing basic arithmetic operations while avoiding the complexities of floating-point math. If you need a straightforward solution for handling large numbers or precise decimal calculations without the overhead of a more extensive library, big.js is an excellent choice.
  • bignumber.js is another library that provides arbitrary-precision arithmetic for JavaScript. It focuses on performance and ease of use, allowing developers to work with large numbers and perform mathematical operations without losing precision. bignumber.js is particularly useful for applications that require handling large integers or precise decimal values, making it a popular choice among developers who need reliable number handling.
  • mathjs is a comprehensive mathematics library for JavaScript that includes support for arbitrary-precision arithmetic, among many other features. It offers a wide range of mathematical functions, constants, and utilities, making it suitable for both simple calculations and complex mathematical operations. If your application requires not only decimal arithmetic but also a broader set of mathematical capabilities, mathjs is a powerful option that can fulfill those needs.

To see how decimal.js compares with big.js, bignumber.js, and mathjs, check out the comparison: Comparing big.js vs bignumber.js vs decimal.js vs mathjs.

Similar Npm Packages to big.js

big.js is a JavaScript library designed for arbitrary-precision decimal arithmetic. It provides a simple and efficient way to perform calculations with numbers that require high precision, making it particularly useful in financial applications or any scenario where rounding errors can lead to significant issues. With its straightforward API, big.js allows developers to create and manipulate large numbers without losing precision.

While big.js is a solid choice for handling big numbers, there are several alternatives that also provide similar functionality. Here are a few noteworthy options:

  • bignumber.js is a popular library for arbitrary-precision decimal and non-decimal arithmetic. It is designed to be easy to use and provides a comprehensive set of features for mathematical operations. bignumber.js is particularly well-suited for applications that require precise calculations, such as financial software or scientific computations. Its extensive documentation and wide adoption make it a reliable choice for developers looking to handle large numbers with precision.

  • decimal.js is another library focused on arbitrary-precision decimal arithmetic. It offers a rich set of mathematical functions and supports various numeric formats, making it versatile for different applications. decimal.js is particularly useful for scenarios where you need to perform complex calculations while maintaining precision. Its performance and flexibility make it a great alternative to big.js, especially for applications that require extensive mathematical operations.

  • mathjs is a comprehensive mathematics library for JavaScript that includes support for arbitrary-precision arithmetic, among many other features. It provides a wide range of mathematical functions, including algebra, calculus, and statistics, making it suitable for applications that require advanced mathematical computations. While it may be more extensive than big.js, its versatility and rich feature set make it a strong contender for projects that need both precision and a variety of mathematical capabilities.

To explore how these libraries compare, check out the comparison: Comparing big.js vs bignumber.js vs decimal.js vs mathjs.

Similar Npm Packages to bignumber.js

bignumber.js is a popular JavaScript library for arbitrary-precision arithmetic. It allows developers to handle large numbers and perform precise calculations without the pitfalls of JavaScript's native number type, which can lead to inaccuracies in floating-point arithmetic. This library is particularly useful in financial applications, scientific computations, and any scenario where precision is critical. While bignumber.js is a robust choice for handling large numbers, there are several alternatives in the JavaScript ecosystem that also provide similar functionalities. Here are a few notable ones:

  • big.js is a lightweight library for arbitrary-precision decimal arithmetic. It focuses on performance and simplicity, making it an excellent choice for applications that require basic arithmetic operations with large numbers. With a smaller footprint compared to bignumber.js, big.js is ideal for projects where minimizing bundle size is a priority while still needing reliable precision in calculations.

  • decimal.js is another library designed for arbitrary-precision decimal arithmetic. It offers a comprehensive set of features, including support for various mathematical functions, rounding modes, and conversion methods. Decimal.js is particularly suited for applications that require extensive mathematical operations, making it a strong alternative to bignumber.js for more complex calculations.

  • mathjs is a powerful and flexible mathematics library for JavaScript and Node.js. It provides a wide range of mathematical functions, including support for complex numbers, matrices, and units, in addition to arbitrary-precision arithmetic. If your application requires not only precise number handling but also advanced mathematical capabilities, mathjs is an excellent choice that combines both functionalities in one package.

To see how bignumber.js compares with big.js, decimal.js, and mathjs, check out the comparison: Comparing big.js vs bignumber.js vs decimal.js vs mathjs.

Similar Npm Packages to mathjs

mathjs is a comprehensive mathematics library for JavaScript and Node.js. It provides a wide range of mathematical functions, constants, and tools for working with numbers, matrices, units, and more. With its flexible API, mathjs is suitable for both simple calculations and complex mathematical operations, making it a popular choice among developers who need robust mathematical capabilities in their applications.

While mathjs is a powerful tool, there are alternatives that cater to specific mathematical needs:

  • decimal.js is a library that provides arbitrary-precision decimal arithmetic. It is particularly useful for applications that require high precision in calculations, such as financial applications where rounding errors can lead to significant issues. Decimal.js allows developers to perform calculations without losing precision, making it a great choice for scenarios where accuracy is paramount.
  • numeric is a library focused on numerical analysis and linear algebra. It provides tools for numerical computations, including matrix operations, solving equations, and performing optimizations. If your work involves heavy numerical computations or linear algebra, numeric can be a valuable alternative to mathjs, offering specialized functions for these tasks.

To see how mathjs compares with decimal.js and numeric, check out the comparison: Comparing decimal.js vs mathjs vs numeric.

README for decimal.js

decimal.js

An arbitrary-precision Decimal type for JavaScript.

npm version npm downloads CDNJS


Features

  • Integers and floats
  • Simple but full-featured API
  • Replicates many of the methods of JavaScript's Number.prototype and Math objects
  • Also handles hexadecimal, binary and octal values
  • Faster, smaller, and perhaps easier to use than JavaScript versions of Java's BigDecimal
  • No dependencies
  • Wide platform compatibility: uses JavaScript 1.5 (ECMAScript 3) features only
  • Comprehensive documentation and test set
  • Used under the hood by math.js
  • Includes a TypeScript declaration file: decimal.d.ts

API

The library is similar to bignumber.js, but here precision is specified in terms of significant digits rather than decimal places, and all calculations are rounded to the precision (similar to Python's decimal module) rather than just those involving division.

This library also adds the trigonometric functions, among others, and supports non-integer powers, which makes it a significantly larger library than bignumber.js and the even smaller big.js.

For a lighter version of this library without the trigonometric functions see decimal.js-light.

Load

The library is the single JavaScript file decimal.js or ES module decimal.mjs.

Browser:

<script src='path/to/decimal.js'></script>

<script type="module">
  import Decimal from './path/to/decimal.mjs';
  ...
</script>

Node.js:

npm install decimal.js

const Decimal = require('decimal.js');

import Decimal from 'decimal.js';

import {Decimal} from 'decimal.js';

Use

In all examples below, semicolons and toString calls are not shown. If a commented-out value is in quotes it means toString has been called on the preceding expression.

The library exports a single constructor function, Decimal, which expects a single argument that is a number, string or Decimal instance.

x = new Decimal(123.4567)
y = new Decimal('123456.7e-3')
z = new Decimal(x)
x.equals(y) && y.equals(z) && x.equals(z)        // true

If using values with more than a few digits, it is recommended to pass strings rather than numbers to avoid a potential loss of precision.

// Precision loss from using numeric literals with more than 15 significant digits.
new Decimal(1.0000000000000001)         // '1'
new Decimal(88259496234518.57)          // '88259496234518.56'
new Decimal(99999999999999999999)       // '100000000000000000000'

// Precision loss from using numeric literals outside the range of Number values.
new Decimal(2e+308)                     // 'Infinity'
new Decimal(1e-324)                     // '0'

// Precision loss from the unexpected result of arithmetic with Number values.
new Decimal(0.7 + 0.1)                  // '0.7999999999999999'

As with JavaScript numbers, strings can contain underscores as separators to improve readability.

x = new Decimal('2_147_483_647')

String values in binary, hexadecimal or octal notation are also accepted if the appropriate prefix is included.

x = new Decimal('0xff.f')            // '255.9375'
y = new Decimal('0b10101100')        // '172'
z = x.plus(y)                        // '427.9375'

z.toBinary()                         // '0b110101011.1111'
z.toBinary(13)                       // '0b1.101010111111p+8'

// Using binary exponential notation to create a Decimal with the value of `Number.MAX_VALUE`.
x = new Decimal('0b1.1111111111111111111111111111111111111111111111111111p+1023')
// '1.7976931348623157081e+308'

Decimal instances are immutable in the sense that they are not changed by their methods.

0.3 - 0.1                     // 0.19999999999999998
x = new Decimal(0.3)
x.minus(0.1)                  // '0.2'
x                             // '0.3'

The methods that return a Decimal can be chained.

x.dividedBy(y).plus(z).times(9).floor()
x.times('1.23456780123456789e+9').plus(9876.5432321).dividedBy('4444562598.111772').ceil()

Many method names have a shorter alias.

x.squareRoot().dividedBy(y).toPower(3).equals(x.sqrt().div(y).pow(3))     // true
x.comparedTo(y.modulo(z).negated() === x.cmp(y.mod(z).neg())              // true

Most of the methods of JavaScript's Number.prototype and Math objects are replicated.

x = new Decimal(255.5)
x.toExponential(5)                       // '2.55500e+2'
x.toFixed(5)                             // '255.50000'
x.toPrecision(5)                         // '255.50'

Decimal.sqrt('6.98372465832e+9823')      // '8.3568682281821340204e+4911'
Decimal.pow(2, 0.0979843)                // '1.0702770511687781839'

// Using `toFixed()` to avoid exponential notation:
x = new Decimal('0.0000001')
x.toString()                             // '1e-7'
x.toFixed()                              // '0.0000001'

And there are isNaN and isFinite methods, as NaN and Infinity are valid Decimal values.

x = new Decimal(NaN)                                           // 'NaN'
y = new Decimal(Infinity)                                      // 'Infinity'
x.isNaN() && !y.isNaN() && !x.isFinite() && !y.isFinite()      // true

There is also a toFraction method with an optional maximum denominator argument.

z = new Decimal(355)
pi = z.dividedBy(113)        // '3.1415929204'
pi.toFraction()              // [ '7853982301', '2500000000' ]
pi.toFraction(1000)          // [ '355', '113' ]

All calculations are rounded according to the number of significant digits and rounding mode specified by the precision and rounding properties of the Decimal constructor.

For advanced usage, multiple Decimal constructors can be created, each with their own independent configuration which applies to all Decimal numbers created from it.

// Set the precision and rounding of the default Decimal constructor
Decimal.set({ precision: 5, rounding: 4 })

// Create another Decimal constructor, optionally passing in a configuration object
Dec = Decimal.clone({ precision: 9, rounding: 1 })

x = new Decimal(5)
y = new Dec(5)

x.div(3)                           // '1.6667'
y.div(3)                           // '1.66666666'

The value of a Decimal is stored in a floating point format in terms of its digits, exponent and sign, but these properties should be considered read-only.

x = new Decimal(-12345.67);
x.d                            // [ 12345, 6700000 ]    digits (base 10000000)
x.e                            // 4                     exponent (base 10)
x.s                            // -1                    sign

For further information see the API reference in the doc directory.

Test

To run the tests using Node.js from the root directory:

npm test

Each separate test module can also be executed individually, for example:

node test/modules/toFraction

To run the tests in a browser, open test/test.html.

Minify

Two minification examples:

Using uglify-js to minify the decimal.js file:

npm install uglify-js -g
uglifyjs decimal.js --source-map url=decimal.min.js.map -c -m -o decimal.min.js

Using terser to minify the ES module version, decimal.mjs:

npm install terser -g
terser decimal.mjs --source-map url=decimal.min.mjs.map -c -m --toplevel -o decimal.min.mjs

import Decimal from './decimal.min.mjs';

Licence

The MIT Licence

npm-compare.com is an independent website designed to help developers choose the most suitable npm packages. We are not affiliated with npm, Inc or npmjs.com, the official website for the npm registry. Please note that npm is a registered trademark of npm, Inc. For more details, please refer to our Terms & Privacy.