Benchmark: Math.pow vs ** vs * forcing floats vs bigint

Tests:

pow int
var tmp = Math.pow(6, 21);
** int
var tmp = 6 ** 21;
* int
var tmp = 6 * 6 * 6 * 6 * 6 * 6 * 6 * 6 * 6 * 6 * 6 * 6 * 6 * 6 * 6 * 6 * 6 * 6 * 6 * 6 * 6;
pow float
var tmp = Math.pow(6.1, 21.1);
** float
var tmp = 6.1 ** 21.1;
* float
var tmp = 6.1 * 6.1 * 6.1 * 6.1 * 6.1 * 6.1 * 6.1 * 6.1 * 6.1 * 6.1 * 6.1 * 6.1 * 6.1 * 6.1 * 6.1 * 6.1 * 6.1 * 6.1 * 6.1 * 6.1 * 6.1;
** bigint
var tmp = 6n ** 21n;
* bigint
var tmp = 6n * 6n * 6n * 6n * 6n * 6n * 6n * 6n * 6n * 6n * 6n * 6n * 6n * 6n * 6n * 6n * 6n * 6n * 6n * 6n * 6n;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
pow int
** int
* int
pow float
** float
* float
** bigint
* bigint

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks.

**What is tested?**

The provided JSON represents a benchmark that tests four different ways to calculate the power of a number:

1. `Math.pow` (using the built-in exponentiation function)
2. `**` (the exponentiation operator, introduced in ECMAScript 2016)
3. Multiplication (`*`) with repeated multiplication to achieve the same result
4. `BigInt` arithmetic (using the `BigInt` type and its operations)

The benchmark is designed to compare the performance of these four approaches for different types of inputs: integers (`int`) and floating-point numbers (`float`).

**Options compared**

The options being compared are:

* `Math.pow`: using the built-in exponentiation function
* `**`: the exponentiation operator (ECMAScript 2016)
* Multiplication (`*`): repeated multiplication to achieve the same result

For each option, there are two variations: one for integers (`int`) and another for floating-point numbers (`float`).

**Pros and cons of each approach**

1. `Math.pow`:
	* Pros: widely supported, efficient, and stable.
	* Cons: can be slower than other methods due to its implementation details (e.g., using a lookup table or intermediate results).
2. `**`:
	* Pros: concise, expressive, and fast (in modern browsers).
	* Cons: not as widely supported as `Math.pow`, may have performance variations depending on the browser.
3. Multiplication (`*`):
	* Pros: simple, easy to implement, and can be optimized for performance.
	* Cons: slower than other methods due to repeated multiplication, may lead to overflow issues for large inputs.

**Special features or syntax**

The benchmark uses `BigInt` arithmetic, which is a relatively new feature in JavaScript (introduced in ECMAScript 2020). `BigInt` provides support for arbitrary-precision integers, allowing calculations with larger values than what can be represented by regular numbers. The `n` suffix (e.g., `6n`) indicates that the number is a `BigInt`.

**Other considerations**

* **Browser and platform variations**: The benchmark results may vary depending on the browser, operating system, and device used to run the test.
* **Optimization opportunities**: Depending on the specific implementation details and compiler optimizations, there might be opportunities to improve performance for certain approaches.

**What do the benchmark results mean?**

The provided benchmark results show the performance of each approach for different types of inputs. The fastest execution time is usually associated with the `**` operator (exponentiation operator), which is fast in modern browsers. However, it's essential to note that these results may not be representative of all scenarios or use cases.

In conclusion, this benchmark provides a comprehensive comparison of four approaches for calculating powers in JavaScript, highlighting the strengths and weaknesses of each method. The `**` exponentiation operator appears to be a strong contender for performance, but the results should be interpreted with caution considering browser and platform variations.

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36

Browser/OS: Chrome 118 on Windows

View result in a separate tab

Test name	Executions per second
pow int	3036649.5 Ops/sec
** int	387686144.0 Ops/sec
* int	390524128.0 Ops/sec
pow float	3052499.0 Ops/sec
** float	392365792.0 Ops/sec
* float	390319840.0 Ops/sec
** bigint	1042951.6 Ops/sec
* bigint	391726048.0 Ops/sec

Related benchmarks:

Math.pow vs ** vs * forcing floats vs bigint (version: 0)

A minor update to see if forced floats perform differently than ints and also see how BigInts compare (note: Math.pow does not work on BigInts).

Comparing performance of: pow int vs ** int vs * int vs pow float vs ** float vs * float vs ** bigint vs * bigint

Created: 3 years ago by: Guest

Jump to the latest result

pow int

** int

* int

pow float

** float

* float

** bigint

* bigint

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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