Benchmark: Math.min and Math.max vs reduce vs apply

HTML Preparation code:

<!--your preparation HTML code goes here-->

Script Preparation code:

var data = [];
for (var i = 0; i < 10000; ++i) data.push(Math.random());

Tests:

Math.min
Math.min(...data);
Array.reduce min
data.reduce((min, cur) => min > cur ? cur : min, data[0]);
Math.min.apply
Math.min.apply(Math, data)
Math.max
Math.max(...data);
Array.reduce max
data.reduce((max, cur) => max < cur ? cur : max, data[0]);
Math.max.apply
Math.max.apply(Math, data)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Math.min
Array.reduce min
Math.min.apply
Math.max
Array.reduce max
Math.max.apply

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 131 on Windows

View result in a separate tab

Test name	Executions per second
Math.min	18996.3 Ops/sec
Array.reduce min	9310.9 Ops/sec
Math.min.apply	298572.6 Ops/sec
Math.max	18437.1 Ops/sec
Array.reduce max	9463.4 Ops/sec
Math.max.apply	253943.4 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 3 months ago):

LLMs can make mistakes. Check important info.

The benchmark defined in the JSON is testing the performance of six different approaches to finding the minimum and maximum values in a randomly generated array of numbers. Specifically, the benchmark compares the following methods:

1. **Math.min with Spread Operator**
   ```javascript
   Math.min(...data);
   ```
   - **Test Name:** `Math.min`
   - **Description:** This method uses the `Math.min()` function combined with the spread operator (`...`) to pass all elements of the `data` array as individual arguments.

2. **Array.reduce for Minimum**
   ```javascript
   data.reduce((min, cur) => min > cur ? cur : min, data[0]);
   ```
   - **Test Name:** `Array.reduce min`
   - **Description:** This approach utilizes the `Array.reduce()` method to iterate through the `data` array, comparing the current value (`cur`) with the minimum value found so far and returning the minimum.

3. **Math.min with apply**
   ```javascript
   Math.min.apply(Math, data);
   ```
   - **Test Name:** `Math.min.apply`
   - **Description:** Similar to the first method, this uses `Math.min()`, but instead of the spread operator, it uses `.apply()` to invoke `Math.min` with the `data` array as arguments.

4. **Math.max with Spread Operator**
   ```javascript
   Math.max(...data);
   ```
   - **Test Name:** `Math.max`
   - **Description:** This functions similarly to `Math.min`, but it returns the maximum value of the array elements.

5. **Array.reduce for Maximum**
   ```javascript
   data.reduce((max, cur) => max < cur ? cur : max, data[0]);
   ```
   - **Test Name:** `Array.reduce max`
   - **Description:** As with the minimum calculation, this method uses the `Array.reduce()` function to find the maximum value in the `data` array through comparisons.

6. **Math.max with apply**
   ```javascript
   Math.max.apply(Math, data);
   ```
   - **Test Name:** `Math.max.apply`
   - **Description:** This method is similar to using `Math.min.apply()` but focuses on finding the maximum value.

### Pros and Cons of Each Approach

#### Math.min and Math.max with Spread Operator
- **Pros:** 
  - Simple and readable.
  - Efficient for smaller arrays.
- **Cons:** 
  - Limited by maximum argument length in JavaScript (often around 65536).
  - Can lead to performance issues with very large arrays.

#### Array.reduce
- **Pros:** 
  - Works on any size of the array without argument limits.
  - Functional programming style may enhance readability for some developers.
- **Cons:** 
  - Slightly more complex syntax may reduce readability.
  - Potentially slower performance due to recursive function calls and comparisons on every iteration.

#### Math.min.apply() and Math.max.apply()
- **Pros:** 
  - Overcomes the argument length limitation of the spread operator.
  - Can handle larger arrays effectively.
- **Cons:** 
  - Slightly less readable than using the spread operator.

### Benchmark Results
Based on the performance results:
- `Math.min.apply` and `Math.max.apply` performed the best, suggesting that using `apply()` is an optimal choice for finding min/max in larger datasets.
- The standard `Math.min` and `Math.max` with the spread operator showed lower performance, reflecting the limitations of handling large arrays.
- Both `Array.reduce` methods resulted in significantly lower execution speeds compared to the others, indicating performance overhead associated with the iterative comparison process.

### Alternative Approaches
Other potential alternatives for finding minimum or maximum values in a dataset could include:
- **Loop-based methods:** Using a simple `for` loop to keep track of the min and max values can often be more efficient than any of the functional approaches, particularly for large datasets.
- **Typed Arrays:** For numerical data, using Typed Arrays (`Float32Array`, `Float64Array`, etc.) might yield performance benefits due to the lower-level optimizations available in JavaScript engines.
- **Third-party libraries:** Utilizing libraries like Lodash or Underscore can provide robust methods for finding mins and maxes, though they may introduce additional overhead compared to straightforward JavaScript solutions.

In conclusion, the choice of method for calculating min/max will depend heavily on context: array size, code readability, and particular application needs should all influence the decision.

Related benchmarks:

Math.min and Math.max vs reduce vs apply (version: 1)

Comparing performance of: Math.min vs Array.reduce min vs Math.min.apply vs Math.max vs Array.reduce max vs Math.max.apply

Created: 3 months ago by: Guest

Jump to the latest result

Math.min

Array.reduce min

Math.min.apply

Math.max

Array.reduce max

Math.max.apply

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 3 months ago):