Benchmark: validate bignumber.js shiftedBy

HTML Preparation code:

<!--script src="https://raw.githubusercontent.com/iriscouch/bigdecimal.js/v0.6.1/lib/bigdecimal.js"></script-->
<script src="https://cdnjs.cloudflare.com/ajax/libs/bignumber.js/9.0.1/bignumber.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/big.js/6.0.3/big.min.js"></script>
<!--script src="https://raw.githubusercontent.com/infusion/Fraction.js/v4.0.12/fraction.min.js"></script-->

Tests:

bignumber 1
var a = new BigNumber("2.789654"); var b = a.times(new BigNumber(10).pow(18)).toFixed();
bignumber 2
var a = new BigNumber("2.789654"); var b = a.shiftedBy(18).toString();

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
bignumber 1
bignumber 2

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 2 years ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Safari/537.36

Browser/OS: Chrome 106 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
bignumber 1	531764.6 Ops/sec
bignumber 2	1129047.6 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 2 months ago):

LLMs can make mistakes. Check important info.

Let's break down the provided benchmarking scenario.

**Overview**

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks. The provided benchmark measures two approaches for working with large numbers in JavaScript: using BigNum.js (a library for arbitrary-precision arithmetic) and shifting the number by a specified amount.

**Benchmark Definition JSON**

The benchmark definition JSON contains information about the test, including:

* `Name`: "validate bignumber.js shiftedBy"
* `Description`: A link to the relevant GitHub repository
* `Script Preparation Code`: The HTML code required to include the necessary libraries (BigNum.js, BigNumber.js, and Big.js)
* `Html Preparation Code`: The actual HTML code that includes the libraries

**Individual Test Cases**

There are two test cases:

1. **Test Case 1: "bignumber 1"**
	* Benchmark Definition: `var a = new BigNumber("2.789654"); var b = a.times(new BigNumber(10).pow(18)).toFixed();`
	* Purpose: Measure the time it takes to multiply two large numbers using BigNum.js
2. **Test Case 2: "bignumber 2"**
	* Benchmark Definition: `var a = new BigNumber("2.789654"); var b = a.shiftedBy(18).toString();`
	* Purpose: Measure the time it takes to shift a large number by a specified amount using BigNum.js

**Options Compared**

The two test cases compare two approaches:

1. **BigNum.js multiplication**: Using the `times` method to multiply two large numbers.
2. **BigNum.js shifting**: Using the `shiftedBy` method to shift a large number by a specified amount.

**Pros and Cons of Each Approach**

* **BigNum.js Multiplication (Test Case 1)**:
	+ Pros: May be more efficient for certain types of arithmetic operations.
	+ Cons: Requires more CPU cycles due to the multiplication operation.
* **BigNum.js Shifting (Test Case 2)**:
	+ Pros: Typically faster than multiplication, as it involves fewer CPU cycles.
	+ Cons: May not be suitable for all types of arithmetic operations.

**Library Descriptions**

1. **BigNum.js**: A library for arbitrary-precision arithmetic. It provides a `BigNumber` class that can represent very large numbers without losing precision.
2. **Big.js**: Another library for arbitrary-precision arithmetic, used in conjunction with BigNumber.js.

**Special JS Feature or Syntax**

None of the benchmark tests explicitly use any special JavaScript features or syntax beyond what's typically available in modern browsers.

**Alternatives**

If you wanted to write a similar benchmark, you could consider using other libraries or approaches, such as:

1. **Google's Arithmetic Library**: A lightweight library for arbitrary-precision arithmetic.
2. **Decimal.js**: Another library for decimal arithmetic that can be used for large numbers.
3. **Using built-in arithmetic operations**: Depending on the specific use case, it might be possible to optimize arithmetic operations using built-in methods like `BigInt` in modern browsers.

Keep in mind that benchmarking is all about measuring performance under different conditions, so the choice of library or approach ultimately depends on your specific requirements and goals.

Related benchmarks:

validate bignumber.js shiftedBy (version: 0)

- https://github.com/MikeMcl/bignumber.js/tree/v9.0.0

Comparing performance of: bignumber 1 vs bignumber 2

Created: 2 years ago by: Guest

Jump to the latest result

bignumber 1

bignumber 2

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 2 months ago):