Benchmark: Math.pow vs ** vs *, fixed so Chrome doesn't optimize away the whole thing

Script Preparation code:

var sum = 0

Tests:

pow
sum = Math.pow(6, 21);
**
sum = 6 ** 21;
*
sum = 6 * 6 * 6 * 6 * 6 * 6 * 6 * 6 * 6 * 6 * 6 * 6 * 6 * 6 * 6 * 6 * 6 * 6 * 6 * 6 * 6;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
pow
**
*

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 103 on Mac OS X 10.11.6

View result in a separate tab

Test name	Executions per second
pow	2179609.5 Ops/sec
**	5654084.0 Ops/sec
*	5647827.5 Ops/sec

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 on MeasureThat.net.

**Benchmark Definition**

The benchmark definition is provided as a JSON object, which defines the scope and behavior of the benchmark. In this case:

* The `Name` field specifies the name of the benchmark, which is "Math.pow vs ** vs *" with a note about Chrome optimizing away the whole expression.
* The `Script Preparation Code` section sets up an initial variable `sum` to 0, which will be used as the base for calculations in each test case. This ensures that all test cases start from the same point, making it easier to compare results.
* There is no HTML preparation code provided.

**Individual Test Cases**

The benchmark consists of three individual test cases:

1. `pow`: Calculates `Math.pow(6, 21)` and assigns the result to `sum`.
2. `**`: Uses exponentiation operator (`**`) to calculate `(6 ** 21)` and assigns the result to `sum`.
3. `*`: Uses repeated multiplication to calculate `6 * 6 * ... * 6` (21 times) and assigns the result to `sum`.

These test cases aim to compare the performance of different exponentiation methods in JavaScript.

**Exponentiation Methods**

Let's break down each method:

* `Math.pow(6, 21)` uses the built-in `Math.pow()` function, which is a standard part of the JavaScript language. This method is well-documented and widely supported.
* `(6 ** 21)` uses the exponentiation operator (`**`), introduced in ECMAScript 2016 (ES6). This operator is more concise and readable than the traditional `Math.pow()` method but may be optimized by browsers or engines to improve performance.
* Repeated multiplication (`6 * 6 * ...`) is a simple, naive approach that can lead to inefficiencies due to the overhead of repeated function calls and assignments.

**Pros and Cons**

Here's a brief overview of each approach:

* `Math.pow()`: Pros: widely supported, well-documented. Cons: might be optimized away by browsers or engines.
* `(6 ** 21)` (Exponentiation Operator): Pros: concise, readable. Cons: may be optimized, less portable across different JavaScript versions and implementations.
* Repeated Multiplication (`6 * ...`): Pros: simple, intuitive. Cons: inefficient due to repeated function calls and assignments.

**Library Usage**

There is no explicit library usage in these test cases. The `Math.pow()` method uses a built-in standard library function.

**Special JS Features/Syntax**

The exponentiation operator (`**`) introduced in ES6 (ECMAScript 2016) is the notable special feature used in this benchmark.

**Other Alternatives**

If you wanted to create similar benchmarks, you could consider using other methods for calculating exponentials, such as:

* Using a library like [exponent.js](https://github.com/gregm-hernandez/exponent.js) or [math-exponents](https://github.com/matt-bertsch/math-exponents)
* Implementing your own exponentiation function using iterative methods (e.g., binary exponentiation)

Keep in mind that the choice of method will depend on the specific requirements and constraints of your benchmark.

I hope this explanation helps you understand the JavaScript microbenchmark on MeasureThat.net!

Related benchmarks:

Math.pow vs ** vs *, fixed so Chrome doesn't optimize away the whole thing (version: 0)

Comparing performance of: pow vs ** vs *

Created: one year ago by: Guest

Jump to the latest result

pow

**

*

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):