Benchmark: Math.max/min vs function ternary vs inline ternary

Script Preparation code:

var number = Math.random() * 1000;
var min = Math.random() * 300;
var max = Math.random() * 1200;

function ternaryClamp(number, min, max) {
  return number > max ? max : (number < min ? min : number);
}
function ternaryMin(number, min) {
  return number < min ? number: min;
}
function ternaryMax(number, max) {
  return number > max ? number: max;
}

Tests:

Math.min/max
Math.min(Math.max(number, min), max)
Math.min
Math.min(number, min)
Math.max
Math.max(number, max)
Ternary clamp
ternaryClamp(number, min, max);
Ternary min
ternaryMin(number, min)
Ternary max
ternaryMax(number, max)
Ternary clamp inlined
number > max ? max : (number < min ? min : number)
Ternary min inlined
number < min ? number: min
Ternary max inlined
number > max ? number: max

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Math.min/max
Math.min
Math.max
Ternary clamp
Ternary min
Ternary max
Ternary clamp inlined
Ternary min inlined
Ternary max inlined

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 93 on Windows

View result in a separate tab

Test name	Executions per second
Math.min/max	2820374.2 Ops/sec
Math.min	4849891.0 Ops/sec
Math.max	4886591.5 Ops/sec
Ternary clamp	4533224.5 Ops/sec
Ternary min	6113265.5 Ops/sec
Ternary max	6119923.5 Ops/sec
Ternary clamp inlined	3624690.8 Ops/sec
Ternary min inlined	6142225.0 Ops/sec
Ternary max inlined	6156567.5 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 benchmark and explain what's being tested, compared, and their pros and cons.

**Benchmark Definition:**

The benchmark is comparing different ways to clamp numbers within a specified range using JavaScript.

**Options Being Compared:**

1. **Math.max/min**: Using the built-in `Math.max` and `Math.min` functions.
2. **Ternary Clamp Functions**: Three custom functions that perform similar operations:
	* `ternaryClamp(number, min, max)`: Returns the minimum of the number and the maximum value if it's outside the range.
	* `ternaryMin(number, min)`: Returns the smaller of the two values (number and minimum).
	* `ternaryMax(number, max)`: Returns the larger of the two values (number and maximum).
3. **Inline Ternary Expressions**: Two inline expressions that perform the same operations as the ternary clamp functions:
	* `number > max ? max : (number < min ? min : number)`
	* `number < min ? number: min`
	* `number > max ? number: max`

**Pros and Cons of Each Approach:**

1. **Math.max/min**: Fast and efficient, but may not be as intuitive or flexible.
2. **Ternary Clamp Functions**:
	* Pros: More readable, flexible, and reusable code.
	* Cons: May have performance overhead due to function calls.
3. **Inline Ternary Expressions**:
	* Pros: Compact, fast, and efficient.
	* Cons: Less readable and less maintainable.

**Library Used:**

None explicitly mentioned in the benchmark definition. However, the `Math.max` and `Math.min` functions are part of the JavaScript standard library.

**Special JS Features or Syntax:**

Not explicitly used in this benchmark. The focus is on comparing different coding approaches rather than showcasing specific features.

**Other Considerations:**

* Performance: Measuring execution speed can help determine which approach is faster.
* Code Readability and Maintainability: Evaluating the ease of understanding and modifying the code can inform decisions about which approach to use.
* Reusability: Considering how easily the functions or expressions can be reused in different contexts can influence choices.

**Alternative Approaches:**

Other ways to clamp numbers within a range might include:

* Using bitwise operators (e.g., `number & 0xFF` to get the last byte of an integer)
* Employing a simple arithmetic approach (e.g., `Math.floor((number + max) / step) * step`)
* Utilizing a library or framework's built-in functions for number manipulation

However, these alternatives are not being tested in this specific benchmark.

Related benchmarks:

Math.max/min vs function ternary vs inline ternary (version: 1)

Comparing performance of: Math.min/max vs Math.min vs Math.max vs Ternary clamp vs Ternary min vs Ternary max vs Ternary clamp inlined vs Ternary min inlined vs Ternary max inlined

Created: 3 years ago by: Registered User

Jump to the latest result

Math.min/max

Math.min

Math.max

Ternary clamp

Ternary min

Ternary max

Ternary clamp inlined

Ternary min inlined

Ternary max inlined

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