Benchmark: Math.pow vs ** vs *

Tests:

pow
var tmp = Math.pow(6, 21);
**
var tmp = 6 ** 21;
*
var tmp = 6 * 6 * 6 * 6 * 6 * 6 * 6 * 6 * 6 * 6 * 6 * 6 * 6 * 6 * 6 * 6 * 6 * 6 * 6 * 6 * 6;

Historical Performance Data aggregated from 300 community runs

Desktop Results:

Chrome 242 runs

166.2M/s

164.9M/s

pow

14.7M/s

pHqghUme

1/s

Fastest: ** (166189728.0x faster)

View exact numbers

✓ **: 166,189,728 ops/sec
• *: 164,885,792 ops/sec
• pow: 14,654,251 ops/sec
• pHqghUme: 1 ops/sec

Firefox 28 runs

1030.6M/s

992.9M/s

pow

973.1M/s

View exact numbers

✓ **: 1,030,572,992 ops/sec
• *: 992,852,864 ops/sec
• pow: 973,103,680 ops/sec

Safari 14 runs

452.7M/s

436.3M/s

pow

19.3M/s

Fastest: * (23.5x faster)

View exact numbers

✓ *: 452,701,088 ops/sec
• **: 436,332,256 ops/sec
• pow: 19,274,888 ops/sec

Mobile Results:

Chrome 16 runs

94.6M/s

93.3M/s

pow

10.7M/s

Fastest: * (8.8x faster)

View exact numbers

✓ *: 94,579,712 ops/sec
• **: 93,261,776 ops/sec
• pow: 10,728,634 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

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: 4 months ago)

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

Browser/OS: Chrome 146 on Windows

View result in a separate tab

108.3M/s

pow

101.3M/s

100.3M/s

View exact numbers

Test name	Executions per second
✓ **	108,290,104 Ops/sec
pow	101,304,544 Ops/sec
*	100,266,800 Ops/sec

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

LLMs can make mistakes. Check important info.

Measuring the performance of different mathematical operations in JavaScript can be an interesting exercise.

**Benchmark Definition JSON**

The provided Benchmark Definition JSON defines three tests:

1.  `Math.pow vs ** vs *`: This test compares the performance of three different methods to calculate the power of a number: `Math.pow()`, exponentiation using two asterisks (`**`), and multiplication using one or more asterisks (`*`).

**Options Compared**

The options compared in this benchmark are:

1.  `Math.pow()`: The built-in JavaScript function for calculating the power of a number.
2.  `**`: Exponentiation using two asterisks, which is equivalent to `Math.pow()` but is often faster due to its implementation in native code.
3.  `\*`: Multiplication using one or more asterisks, which can be slower than `Math.pow()` and `**` because it involves multiple iterations of multiplication.

**Pros and Cons**

Here are some pros and cons for each option:

1.  `Math.pow()`: Pros:
    *   Wide support across different browsers and JavaScript engines.
    *   Well-documented and stable.
    *   Suitable for most use cases.
2.  `**`: Pros:
    *   Often faster than `Math.pow()` due to its native implementation.
    *   More concise syntax.
    *   Widely supported in modern browsers.
3.  `\*`: Pros:
    *   Can be useful when working with large numbers or requiring precise control over intermediate results.

Cons:

1.  `Math.pow()`: Cons:
    *   May have performance limitations due to its recursive nature.
2.  `**`: Cons:
    *   Limited support in older browsers and JavaScript engines.
3.  `\*`: Cons:
    *   Can be slower than `Math.pow()` and `**` due to the need for multiple multiplications.

**Library**

There is no library explicitly used in this benchmark, but some libraries like `mathjs` or `numjs` can provide alternative implementations of mathematical operations like exponentiation.

**Special JS Feature/Syntax**

This benchmark does not use any special JavaScript features or syntax. It only utilizes built-in functions and operators (`Math.pow()`, `**`, `\*`) that are widely supported in modern JavaScript engines.

**Alternative Implementations**

If you need more control over the implementation of mathematical operations, you can consider using specialized libraries like:

1.  `mathjs`: Provides a high-level interface for mathematical operations, including exponentiation.
2.  `numjs`: Offers an array-based numerical computation library that can be used to implement custom mathematical functions.

Here's a sample code in JavaScript that demonstrates the three options:
```javascript
// Math.pow()
var result = Math.pow(6, 21);
console.log(result);

// ** (exponentiation)
result = 6 ** 21;
console.log(result);

// \* (multiplication)
var temp = 6;
for (var i = 0; i < 21; i++) {
    temp *= 6;
}
console.log(temp);
```
Keep in mind that this is a basic example and may not reflect the actual performance differences between these methods in real-world scenarios.

Math.pow vs ** vs * (version: 0)

Comparing performance of: `pow vs ** vs *`

Created: 6 years ago by: Guest

Go to the latest result

pow

**

*

Historical Performance Data aggregated from 300 community runs

Desktop Results:

Chrome 242 runs

Firefox 28 runs

Safari 14 runs

Mobile Results:

Chrome 16 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Math.pow vs ** vs * (version: 0)

Comparing performance of: pow vs ** vs *

Created: 6 years ago by: Guest

Go to the latest result

pow

**

*

Historical Performance Data aggregated from 300 community runs

Desktop Results:

Chrome 242 runs

Firefox 28 runs

Safari 14 runs

Mobile Results:

Chrome 16 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `pow vs ** vs *`