Benchmark: Lodash clamp vs Math.min(Math.max) vs Bitwiseyrooneyh

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.7.11/lodash.min.js'></script>

Script Preparation code:

function CLAMP_INT( x, min, max ) {
  x = x - ((x - max) & ((max - x) >> 31));
  return x - ((x - min) & ((x - min) >> 31));
  //return ( n > max ) ? max : ( n < min ) ? n : min;
}

function branchClamp(num, min, max) {
  return num <= min 
    ? min 
    : num >= max 
      ? max 
      : num
}

Tests:

Lodash clamp
_.clamp(150, 10, 100);
Manual Math.min Math.max
Math.min(Math.max(150, 10), 100);
CLAMP_INT
CLAMP_INT(150, 10, 100);
branchClamp
branchClamp(150, 10, 100);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash clamp
Manual Math.min Math.max
CLAMP_INT
branchClamp

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what's being tested.

**Benchmark Overview**

The benchmark measures the performance of three different implementations to clamp a value within a specified range:

1. Lodash `clamp` function
2. Manual implementation using `Math.min` and `Math.max`
3. Custom implementation using bitwise operations (`CLAMP_INT`)
4. Another custom implementation with branching (`branchClamp`)

**Options Compared**

The benchmark compares the performance of these four options on a single test case: clamping the value 150 to the range [10, 100].

* **Lodash `clamp` function**: A popular utility function in Lodash that provides a simple way to clamp values.
* **Manual implementation using `Math.min` and `Math.max`**: This implementation uses two built-in functions to achieve the clamping effect.
* **Custom implementation using bitwise operations (`CLAMP_INT`)**: This implementation uses bitwise shifts and masking to achieve the same effect as Lodash's `clamp`.
* **Custom implementation with branching (`branchClamp`)**: This implementation uses a conditional statement to determine which value to return based on the input.

**Pros and Cons of Each Approach**

1. **Lodash `clamp` function**:
	* Pros: Easy to use, well-tested, and optimized.
	* Cons: May introduce additional overhead due to the Lodash library.
2. **Manual implementation using `Math.min` and `Math.max`**:
	* Pros: Lightweight, easy to understand, and doesn't require any external libraries.
	* Cons: May be slower than optimized implementations like Lodash's `clamp`.
3. **Custom implementation using bitwise operations (`CLAMP_INT`)**:
	* Pros: Can be highly optimized for specific use cases, reducing overhead compared to Lodash's `clamp`.
	* Cons: May require more code and expertise to implement correctly.
4. **Custom implementation with branching (`branchClamp`)**:
	* Pros: Simple to understand and can be optimized for performance.
	* Cons: May introduce branch prediction penalties or other optimization challenges.

**Library: Lodash**

Lodash is a popular JavaScript utility library that provides a wide range of functions, including `clamp`. The `clamp` function takes three arguments: the value to clamp, and two bounds (minimum and maximum values). It returns the value if it's within the specified range; otherwise, it returns one of the bounds.

**Special JS Feature or Syntax**

None mentioned in this benchmark.

**Benchmark Results**

The latest benchmark results show that `branchClamp` is the fastest implementation, followed closely by `CLAMP_INT`. Lodash's `clamp` and the manual implementation using `Math.min` and `Math.max` are slower. The performance differences may be due to various factors such as optimization techniques, caching, or branch prediction.

**Other Alternatives**

If you need more control over the clamping operation or want to explore alternative implementations, consider the following options:

* Use a different library, such as `lodash-es` or `ramda`, which offer optimized clamping functions.
* Implement your own clamping function using a different approach, such as using arithmetic operations or lookup tables.
* Explore alternative programming paradigms, like functional programming, that may provide more efficient solutions for certain use cases.

Latest run results:

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

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

Browser/OS: Chrome 97 on Windows

View result in a separate tab

Test name	Executions per second
Lodash clamp	4970829.5 Ops/sec
Manual Math.min Math.max	2711311.2 Ops/sec
CLAMP_INT	7044672.5 Ops/sec
branchClamp	7078505.5 Ops/sec

Related benchmarks:

Lodash clamp vs Math.min(Math.max) vs Bitwiseyrooneyh (version: 0)

Comparing performance of: Lodash clamp vs Manual Math.min Math.max vs CLAMP_INT vs branchClamp

Created: 2 years ago by: Guest

Jump to the latest result

Lodash clamp

Manual Math.min Math.max

CLAMP_INT

branchClamp

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