Benchmark: simple Math.max vs ternary

Script Preparation code:

var a = Math.round(Math.random()*1000),b = Math.round(Math.random()*1000),c;

Tests:

ternary
c = a>b?a:b;
Math.max
c = Math.max(a,b);

Historical Performance Data aggregated from 38 community runs

Desktop Results:

Chrome 30 runs

ternary

7.1M/s

Math.max

5.9M/s

Fastest: ternary (1.2x faster)

View exact numbers

✓ ternary: 7,138,147 ops/sec
• Math.max: 5,854,490 ops/sec

Firefox 8 runs

Math.max

612.2M/s

ternary

447.3M/s

Fastest: Math.max (1.4x faster)

View exact numbers

✓ Math.max: 612,180,992 ops/sec
• ternary: 447,344,128 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
ternary
Math.max

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 7 months ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:146.0) Gecko/20100101 Firefox/146.0

Browser/OS: Firefox 146 on Windows

View result in a separate tab

Math.max

1990.2M/s

ternary

1319.3M/s

View exact numbers

Test name	Executions per second
✓ Math.max	1,990,186,624 Ops/sec
ternary	1,319,313,152 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll break down the benchmark and explain what's being tested.

**Benchmark Overview**

The benchmark compares the performance of two approaches: using a ternary operator (`c = a>b?a:b;`) versus using the `Math.max()` function (`c = Math.max(a,b);`).

**Options Compared**

* **Ternary Operator**: This approach uses a single expression to evaluate and assign a value to `c`. The syntax is `x ? y : z`, where `x` is evaluated as true or false, and `y` is executed if `x` is true, while `z` is executed if `x` is false.
* **Math.max()**: This approach uses the built-in `Math.max()` function to find the maximum value between `a` and `b`.

**Pros and Cons**

* **Ternary Operator**
	+ Pros:
		- Simple and concise syntax
		- Can be more readable for simple conditions
		- No additional library dependencies required
	+ Cons:
		- May not be as efficient due to the need to evaluate the condition
		- Can lead to longer execution times if the condition is complex or frequent
* **Math.max()**
	+ Pros:
		- More efficient, as it's implemented in native code and optimized for performance
		- Less prone to errors due to being a well-defined function
		- Supports more advanced comparison scenarios (e.g., finding the maximum of multiple values)
	+ Cons:
		- Requires importing the `Math` object or accessing its properties (`Math.max()`)
		- May have overhead due to function call and parameter passing

**Library: Math**

The `Math` library provides a set of mathematical functions, including `max()`. The `Math.max()` function takes one or more arguments and returns the largest value among them.

**Special JS Feature/Syntax: None mentioned in this benchmark.**

**Benchmark Preparation Code**

The script preparation code is:
```javascript
var a = Math.round(Math.random()*1000), b = Math.round(Math.random()*1000);
```
This code generates two random integers `a` and `b`, which are used as input for the comparisons.

**Individual Test Cases**

Each test case consists of a unique benchmark definition, which is executed to measure performance. In this case, there are only two test cases:

1. **Ternary**: Evaluates the ternary operator expression (`c = a>b?a:b;`)
2. **Math.max**: Evaluates the `Math.max()` function expression (`c = Math.max(a,b);`)

**Latest Benchmark Result**

The latest benchmark result shows that Chrome 129 on Windows Desktop achieved:

* Ternary: 2857204.25 executions per second
* Math.max: 2467943.75 executions per second

This suggests that the `Math.max()` approach is faster than the ternary operator approach in this specific test case.

**Other Alternatives**

For similar benchmarks, you might consider using other approaches or variations, such as:

* Using other comparison operators (e.g., `>=`, `<=`, etc.)
* Adding more complex logic to the comparisons
* Experimenting with different data distributions or input sizes
* Comparing performance on different browsers, devices, or platforms

Keep in mind that benchmark results can be highly dependent on specific use cases, hardware configurations, and optimization techniques.

simple Math.max vs ternary (version: 0)

Comparing performance of: `ternary vs Math.max`

Created: 6 years ago by: Guest

Go to the latest result

ternary

Math.max

Historical Performance Data aggregated from 38 community runs

Desktop Results:

Chrome 30 runs

Firefox 8 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

simple Math.max vs ternary (version: 0)

Comparing performance of: ternary vs Math.max

Created: 6 years ago by: Guest

Go to the latest result

ternary

Math.max

Historical Performance Data aggregated from 38 community runs

Desktop Results:

Chrome 30 runs

Firefox 8 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: `ternary vs Math.max`