Benchmark: Max of Mins: Data Blocks

HTML Preparation code:

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

Script Preparation code:

//-- must be var to scope globally
var data = [2, 5, 4, 6, 3, 7, 8, 4, 6, 1, 6, 2, 8, 8, 7, 6];
var blockLength = 3;

Tests:

Lodash Map
const numBlocks = data.length - blockLength + 1; const minPerBlock = _.range(0, numBlocks).map((i) => Math.min(...data.slice(i, i + blockLength)) ); const maxOfMins = Math.max(...minPerBlock); console.log(minPerBlock); console.log(maxOfMins);
For Loop to Block Array
const numBlocks = data.length - blockLength + 1; const minPerBlock = []; for (let i = 0; i < numBlocks; ++i) { const block = data.slice(i, i + blockLength); minPerBlock.push(Math.min(...block)); } const maxOfMins = Math.max(...minPerBlock); console.log( minPerBlock ) console.log( maxOfMins )
Maps
const minPerBlock = [...data].map((v, idx, self) => { return self.length > idx+(blockLength-1) ? self.slice(idx, idx + blockLength) : [0]; }).map((group)=> Math.min(...group) ); const maxOfMins = Math.max(...minPerBlock); console.log( minPerBlock ) console.log( maxOfMins )

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash Map
For Loop to Block Array
Maps

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 24 days ago):

LLMs can make mistakes. Check important info.

I'll provide an in-depth explanation of the provided benchmark and its test cases.

**Overview**

The given JSON represents a JavaScript microbenchmarking tool called MeasureThat.net. The goal is to compare the performance of different approaches for finding the maximum of minimum values within blocks of data. The benchmark uses a sample dataset with 18 elements, divided into blocks of length 3.

**Script Preparation Code**

The script preparation code defines the `data` variable as an array of numbers and sets a global scope variable named `blockLength` to 3. This is done to provide a consistent starting point for all test cases.

**Html Preparation Code**

The HTML preparation code includes a reference to the Lodash library, which provides utility functions for data manipulation, including the `range`, `map`, and `min` functions used in the benchmark test cases.

**Test Cases**

There are three individual test cases:

1. **Lodash Map**
This test case uses the `_.range`, `_.map`, and `_.min` functions from Lodash to process the data. The code:
	* Calculates the number of blocks using `data.length - blockLength + 1`.
	* Creates an array of minimum values for each block using `_.range` and `_.map`.
	* Finds the maximum of these minimum values using `Math.max`.
2. **For Loop to Block Array**
This test case uses a traditional for loop to process the data. The code:
	* Calculates the number of blocks using `data.length - blockLength + 1`.
	* Creates an array to store the minimum values for each block.
	* Iterates through the data, slicing it into blocks and calculating the minimum value for each block using `Math.min`.
	* Finds the maximum of these minimum values using `Math.max`.
3. **Maps**
This test case uses the Array.prototype.map() method to process the data. The code:
	* Calculates the number of blocks using `data.length - blockLength + 1`.
	* Creates a new array with mapped values for each element in the original data.
	* Maps over this new array, returning an array of minimum values for each block using a lambda expression.
	* Finds the maximum of these minimum values using `Math.max`.

**Pros and Cons**

Here's a brief analysis of each approach:

1. **Lodash Map**
	* Pros: concise, efficient use of Lodash functions, easy to read and maintain.
	* Cons: depends on external library (Lodash), may not be familiar to all developers.
2. **For Loop to Block Array**
	* Pros: explicit control over loop iteration, no external dependencies.
	* Cons: more verbose, may lead to errors due to manual index calculation.
3. **Maps**
	* Pros: concise, efficient use of Array.prototype.map(), easy to read and maintain.
	* Cons: relies on a modern JavaScript feature (Array.prototype.map()), may not be compatible with older browsers.

**Library and Special Features**

The Lodash library is used in the first test case, providing utility functions for data manipulation. The `_.range`, `_.map`, and `_.min` functions are used to process the data.

There are no special JavaScript features or syntax mentioned in the benchmark code.

**Other Alternatives**

If you're interested in exploring alternative approaches, consider the following:

1. **Arrow Functions**: You can use arrow functions (`() => { ... }`) instead of traditional function expressions for more concise and modern code.
2. **Spread Operator**: The spread operator (`...`) can be used to extract subsets from arrays, reducing the need for explicit slicing or indexing.
3. **Generator Functions**: Generator functions (e.g., `function* generator() { ... }`) can be used to iterate over data in a more functional programming style.

Keep in mind that these alternatives may require adjustments to your code and understanding of the underlying syntax and libraries being used.

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Safari/537.36

Browser/OS: Chrome 106 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Lodash Map	42789.7 Ops/sec
For Loop to Block Array	44539.5 Ops/sec
Maps	41148.8 Ops/sec

Related benchmarks:

Max of Mins: Data Blocks (version: 0)

Comparing performance of: Lodash Map vs For Loop to Block Array vs Maps

Created: 2 years ago by: Registered User

Jump to the latest result

Lodash Map

For Loop to Block Array

Maps

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 24 days ago):