Benchmark: Math.max/min vs if vs ternary vs bitwise - 4 numbers

Script Preparation code:

var x = Math.random() * 1000;
var clientX = Math.random() * 1000;
var px = Math.random() * 1000;
var maxWidth = Math.random() * 1000;
function MAX_INT(a, b) {
  return a - ((a - b) & ((a - b) >> 31));
}

function MIN_INT(a, b) {
  return a - ((a - b) & ((b - a) >> 31));
}

Tests:

Math.max/min
Math.min(Math.max(x + clientX - px, 0), maxWidth) - x
if
if(x + clientX - px < 0) return 0; if(x + clientX - px > 750) return maxWidth; return x + clientX - px;
ternary
return x + clientX - px < 0 ? 0 : (x + clientX - px > maxWidth ? maxWidth : x + clientX - px) - x;
bitwise
MIN_INT(MAX_INT(x + clientX - px, 0), maxWidth)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Math.max/min
if
ternary
bitwise

Fastest: N/A

Slowest: N/A

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/133.0.0.0 Safari/537.36 Edg/133.0.0.0

Browser/OS: Chrome 133 on Windows

View result in a separate tab

Test name	Executions per second
Math.max/min	135129616.0 Ops/sec
if	132669888.0 Ops/sec
ternary	121584368.0 Ops/sec
bitwise	142278688.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the benchmark.

**Benchmark Purpose**

The provided benchmark measures performance differences between various approaches for calculating the minimum value of an expression involving multiple variables (`x`, `clientX`, and `px`) with a maximum limit (`maxWidth`). The goal is to determine which approach is the fastest.

**Test Cases**

There are four test cases:

1. **Math.max/min**: Uses built-in `Math.min` and `Math.max` functions.
2. **if**: Uses an if-else statement to evaluate the condition.
3. **ternary**: Uses a ternary operator (condition ? expression1 : expression2) to simplify the logic.
4. **bitwise**: Uses bitwise operations (`MIN_INT` function) to minimize the number of calculations.

**Pros and Cons**

* **Math.max/min**: Fastest in most cases, but may have higher overhead due to function calls.
	+ Pros: Easy to read and maintain, widely supported.
	+ Cons: May incur additional overhead due to function calls.
* **if**: More straightforward to understand, but can be slower due to branching.
	+ Pros: Easier to read and debug, no additional overhead.
	+ Cons: Slower due to conditional branches.
* **ternary**: Can simplify logic and reduce branching, making it faster in some cases.
	+ Pros: Simplifies code, reduces branching, potentially faster.
	+ Cons: May be harder to understand for beginners or those unfamiliar with ternary operators.
* **bitwise**: Uses bitwise operations to minimize calculations, but may require additional expertise.
	+ Pros: Potentially fastest due to reduced number of calculations, can simplify logic.
	+ Cons: Requires expertise in bitwise operations and may lead to more complex code.

**Library: MIN_INT**

The `MIN_INT` function is a custom library used for bitwise operations. It's likely implemented using bitwise AND (`&`) and right shift (`>> 31`) operators to simulate the behavior of unsigned integer comparison.

**Special JS Feature/Syntax: None**

This benchmark does not utilize any specific JavaScript features or syntax beyond basic arithmetic, conditional statements, and ternary operators.

**Alternatives**

To measure performance differences in similar scenarios, you could consider using other benchmarks that focus on different aspects, such as:

* **Micro-Benchmarking**: Other libraries like `benchmark.js` or `micro-benchmark` offer more extensive benchmarking capabilities.
* **Performance Comparison**: Tools like `jsperf` (now archived) or `jsperf2.0` allowed for performance comparisons, but are no longer maintained.

Keep in mind that each benchmark has its strengths and weaknesses, and the choice of benchmark ultimately depends on your specific use case and requirements.

Related benchmarks:

Math.max/min vs if vs ternary vs bitwise - 4 numbers (version: 0)

Comparing performance of: Math.max/min vs if vs ternary vs bitwise

Created: 5 years ago by: Guest

Jump to the latest result

Math.max/min

if

ternary

bitwise

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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