Benchmark: Benchmark Clamp 2221134b-d084-4650-87ae-9a71a46875a0

Script Preparation code:

function branchingClamp(min, max, x) {
  if (x < min) return min;
  if (x > max) return max;
  return x;
}

function lodashClamp(number, lower, upper) {
  number = +number
  lower = +lower
  upper = +upper
  lower = lower === lower ? lower : 0
  upper = upper === upper ? upper : 0
  if (number === number) {
    number = number <= upper ? number : upper
    number = number >= lower ? number : lower
  }
  return number
}

function branchlessMulClamp(min, max, x) {
  const isLow = +(x < min);
  const isHigh = +(x > max);
  return (
    (isLow * min) |
    (isHigh * max) |
    (+!(isLow ^ isHigh) * x)
  );
}

function ternaryClamp(min, max, x) {
  return x < min ? min : x > max ? max : x;
}

function minmaxClamp(min, max, x) {
  return Math.min(max, Math.max(min, x));
}

Tests:

branching if
for (let i = 0; i <= 100; i++) { branchingClamp(0, 100, i); }
lodash
for (let i = 0; i <= 100; i++) { lodashClamp(0, 100, i); }
Branchless multiply
for (let i = 0; i <= 100; i++) { branchlessMulClamp(0, 100, i); }
Ternary clamp
for (let i = 0; i <= 100; i++) { ternaryClamp(0, 100, i); }
min max clamp
for (let i = 0; i <= 100; i++) { minmaxClamp(0, 100, i); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
branching if
lodash
Branchless multiply
Ternary clamp
min max clamp

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'll break down the provided JSON for you.

**Benchmark Definition**

The benchmark measures the performance of four different clamp functions in JavaScript:

1. `branchingClamp`: A traditional if-else approach to clamping values within a range.
2. `lodashClamp` (from the Lodash library): A more complex, function-based approach that uses explicit type conversions and conditional statements.
3. `branchlessMulClamp`: An optimized, branchless implementation using bitwise operations to clamp values.
4. `ternaryClamp`: A simple, ternary operator-based approach to clamping values.

**Options Compared**

The benchmark compares the performance of these four approaches on a uniform range of input values (`i` from 0 to 100).

**Pros and Cons**

1. **Branching Clamp (traditional)**:
	* Pros: Easy to understand and implement.
	* Cons: Can be slower due to branch prediction errors.
2. **Lodash Clamp (complex)**:
	* Pros: More robust and maintainable, thanks to the Lodash library's validation and type checking features.
	* Cons: May be slower due to unnecessary overhead from explicit type conversions.
3. **Branchless Mul Clamp**:
	* Pros: Optimized for performance using bitwise operations, which can reduce branch prediction errors.
	* Cons: Requires a good understanding of bitwise operations and might be harder to implement.
4. **Ternary Clamp (simple)**:
	* Pros: Easy to understand and implement, with minimal overhead.
	* Cons: Might not be as efficient as the branchless implementation.

**Library and Special JS Features**

The benchmark uses the Lodash library for its `lodashClamp` function. Lodash is a popular JavaScript utility library that provides various functions for common tasks, such as array manipulation, data formatting, and more.

There are no special JavaScript features or syntax used in this benchmark.

**Alternatives**

If you're interested in exploring alternative clamp implementations or optimizing the performance of your own clamping functions, consider the following:

* Other optimized clamp implementations, like `Math.min` and `Math.max`, which can be faster but might not provide the same level of control as custom implementations.
* More advanced optimization techniques, such as using SIMD instructions or compiler-specific optimizations.

Keep in mind that the best approach will depend on your specific use case and performance requirements.

Latest run results:

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

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

Browser/OS: Firefox 113 on Windows

View result in a separate tab

Test name	Executions per second
branching if	9099643.0 Ops/sec
lodash	812850.1 Ops/sec
Branchless multiply	7307012.5 Ops/sec
Ternary clamp	8204142.5 Ops/sec
min max clamp	7151854.5 Ops/sec

Related benchmarks:

Benchmark Clamp 2221134b-d084-4650-87ae-9a71a46875a0 (version: 0)

Benchmark multiple clamp implementations

Comparing performance of: branching if vs lodash vs Branchless multiply vs Ternary clamp vs min max clamp

Created: one year ago by: Guest

Jump to the latest result

branching if

lodash

Branchless multiply

Ternary clamp

min max clamp

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