decimal.js vs bignumber.js vs big.js vs decimal.js-light
JavaScript Arbitrary-Precision Decimal Libraries
Search packages..
decimal.jsbignumber.jsbig.jsdecimal.js-lightSimilar Packages:
JavaScript Arbitrary-Precision Decimal Libraries

These libraries provide solutions for handling arbitrary-precision decimal arithmetic in JavaScript, which is crucial for applications requiring high precision in financial calculations, scientific computations, or any domain where floating-point arithmetic can lead to inaccuracies. Each library has its own design principles, performance characteristics, and features that cater to different use cases and developer preferences.

Npm Package Weekly Downloads Trend
3 Years
Github Stars Ranking
Stat Detail
Package
Downloads
Stars
Size
Issues
Publish
License
decimal.js42,998,7637,131284 kB187 months agoMIT
bignumber.js29,210,3716,971352 kB257 months agoMIT
big.js26,876,2365,15858.9 kB910 months agoMIT
decimal.js-light13,061,046404-65 years agoMIT
Feature Comparison: decimal.js vs bignumber.js vs big.js vs decimal.js-light

Precision and Accuracy

  • decimal.js:

    decimal.js excels in precision and accuracy, supporting arbitrary-precision decimal arithmetic with customizable rounding modes. It is ideal for applications that demand rigorous numerical accuracy, such as financial calculations.

  • bignumber.js:

    bignumber.js offers high precision and accuracy for mathematical operations, supporting a wide range of numerical calculations. It is well-suited for applications that require extensive numerical manipulation and guarantees precision in results.

  • big.js:

    big.js provides arbitrary precision for decimal arithmetic, ensuring that calculations are accurate and free from floating-point errors. It is designed for performance and is particularly effective for basic arithmetic operations without sacrificing precision.

  • decimal.js-light:

    decimal.js-light maintains high precision while being a more lightweight alternative to decimal.js, focusing on essential features for accurate decimal arithmetic without the additional complexity.

Performance

  • decimal.js:

    decimal.js is designed for performance with a focus on speed in arbitrary-precision calculations. It is efficient for both simple and complex mathematical operations, making it suitable for high-performance applications.

  • bignumber.js:

    bignumber.js offers a balance between performance and functionality. While it may not be as fast as big.js for basic operations, it provides a comprehensive set of features that may justify any performance trade-offs in complex calculations.

  • big.js:

    big.js is optimized for performance, making it suitable for applications where speed is critical. Its lightweight nature allows for fast calculations with minimal overhead, making it a good choice for performance-sensitive scenarios.

  • decimal.js-light:

    decimal.js-light is the most performance-oriented option among the decimal libraries, providing essential features with minimal overhead, making it ideal for lightweight applications that still require precision.

API and Usability

  • decimal.js:

    decimal.js offers a rich API with extensive mathematical functions and options for rounding and precision control, making it suitable for developers who require advanced features and flexibility in their calculations.

  • bignumber.js:

    bignumber.js features a comprehensive API that supports a wide range of mathematical functions, making it user-friendly for developers needing extensive numerical capabilities. It may have a steeper learning curve due to its richness in features.

  • big.js:

    big.js has a straightforward and intuitive API, making it easy to use for developers who need basic decimal arithmetic without complex configurations. Its simplicity is a key advantage for quick implementations.

  • decimal.js-light:

    decimal.js-light provides a simplified API that retains essential functionalities, making it easy to use while being lightweight. It is designed for developers who want a straightforward approach to decimal arithmetic.

Community and Maintenance

  • decimal.js:

    decimal.js is actively maintained and has a strong community backing, offering extensive documentation and support for developers. Its feature-rich nature makes it a reliable choice for complex applications.

  • bignumber.js:

    bignumber.js has a large user base and is actively maintained, providing a wealth of resources and community support for developers. Its comprehensive features make it a popular choice for various applications.

  • big.js:

    big.js is well-maintained with a growing community, ensuring that it receives regular updates and support. Its simplicity contributes to its ease of use and adoption among developers.

  • decimal.js-light:

    decimal.js-light is a lightweight alternative that is also well-maintained, ensuring that it remains relevant and useful for developers looking for a minimalistic approach to decimal arithmetic.

Use Cases

  • decimal.js:

    decimal.js is best for complex applications that demand high precision and a wide range of mathematical functions, making it suitable for financial systems, scientific computing, and data analysis.

  • bignumber.js:

    bignumber.js is suitable for applications needing comprehensive numerical capabilities, such as financial software, scientific calculations, or any domain where precision is critical.

  • big.js:

    big.js is ideal for applications requiring basic decimal arithmetic, such as simple financial calculations or scenarios where performance is prioritized over extensive features.

  • decimal.js-light:

    decimal.js-light is perfect for lightweight applications that still require accurate decimal arithmetic, making it suitable for mobile apps or projects with strict size constraints.

How to Choose: decimal.js vs bignumber.js vs big.js vs decimal.js-light
  • decimal.js:

    Select decimal.js for its rich feature set, including support for arbitrary precision, rounding modes, and advanced mathematical functions, making it suitable for complex calculations.

  • bignumber.js:

    Opt for bignumber.js if you require a comprehensive solution with extensive support for various mathematical operations and a robust API for handling large numbers and precision.

  • big.js:

    Choose big.js if you need a lightweight library focused on performance and simplicity for basic decimal operations without the overhead of additional features.

  • decimal.js-light:

    Consider decimal.js-light if you want a minimalistic version of decimal.js that retains essential features while being more lightweight, ideal for projects with limited size constraints.

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 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 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 decimal.js-light

decimal.js-light is a lightweight JavaScript library for arbitrary-precision decimal arithmetic. It is designed to handle decimal numbers with high precision, making it ideal for applications that require accurate calculations, such as financial applications, scientific computations, and any scenario where floating-point arithmetic can lead to rounding errors. With its simple API and efficient performance, decimal.js-light allows developers to perform mathematical operations without the pitfalls of JavaScript's native number type.

While decimal.js-light is a great choice for precise decimal calculations, there are other libraries that also provide similar functionality. Here are a couple of alternatives:

  • big.js is a small and fast library for arbitrary-precision decimal arithmetic. It offers a straightforward API for performing arithmetic operations, comparisons, and conversions. big.js is particularly useful for applications that require precision without the overhead of larger libraries. Its performance and simplicity make it a popular choice among developers who need to handle decimal numbers accurately without unnecessary complexity.
  • bignumber.js is another library that provides arbitrary-precision decimal arithmetic. It is designed to handle very large and very small numbers while maintaining precision. bignumber.js offers a comprehensive set of features, including support for various mathematical operations, rounding, and formatting. If your application requires extensive numerical computations with a focus on precision, bignumber.js is a robust option to consider.

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

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, the official website for the npm registry. Note that npm is a registered trademark of npm, Inc. Please share your feedback via our GitHub repository. For more details, please refer to our Terms & Privacy.