Benchmark: npm:fast-cartesian product vs native .reduce()

Script Preparation code:

var data = [[1,2,3,4,5,6,7,8,9,10],[1,2,3,4,5,6,7,8,9,10],[1,2,3,4,5,6,7,8,9,10],[1,2,3,4,5,6,7,8,9,10]]

Tests:

npm:fast-cartesian
// Does a cartesian product on several arrays. // Returns an array with the results. // Optimized to be the fastest implementation in JavaScript. function fastCartesian(arrays) { if (arrays.length === 0) { return [] } const loopFunc = getLoopFunc(arrays.length) const result = [] loopFunc(arrays, result) return result } const getLoopFunc = function (length) { const cachedLoopFunc = cache[length] if (cachedLoopFunc !== undefined) { return cachedLoopFunc } const loopFunc = mGetLoopFunc(length) // eslint-disable-next-line fp/no-mutation cache[length] = loopFunc return loopFunc } const cache = {} // Create a function with `new Function()` that does: // function(arrays, results) { // for (const value0 of arrays[0]) { // for (const value1 of arrays[1]) { // // and so on // results.push([value0, value1]) // } // } // } const mGetLoopFunc = function (length) { const indexes = Array.from({ length }, getIndex) const start = indexes .map((index) => `for (const value${index} of arrays[${index}]) {`) .join('\n') const middle = indexes.map((index) => `value${index}`).join(', ') const end = '}\n'.repeat(length) // eslint-disable-next-line no-new-func return new Function( 'arrays', 'result', `${start}\nresult.push([${middle}])\n${end}`, ) } const getIndex = function (value, index) { return String(index) } const product = fastCartesian(data)
native .reduce() with flatmap, concat
const cartesianProduct = (...allEntries) => allEntries.reduce( (subsetsSoFar, entries) => [ ...subsetsSoFar.flatMap((result) => entries.map((entry) => result.concat([entry]))), ], [[]] ) const product2 = cartesianProduct(data)
native .reduce() with map, spread
function cartesianProductWithSpread(...allEntries) { return allEntries.reduce( (results, entries) => results .map(result => entries.map(entry => [...result, entry] )) .reduce((subResults, result) => [...subResults, ...result] , []), [[]] ) } const product3 = cartesianProductWithSpread(data)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
npm:fast-cartesian
native .reduce() with flatmap, concat
native .reduce() with map, spread

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:127.0) Gecko/20100101 Firefox/127.0

Browser/OS: Firefox 127 on Mac OS X 10.15

View result in a separate tab

Test name	Executions per second
npm:fast-cartesian	3513.1 Ops/sec
native .reduce() with flatmap, concat	5111044.0 Ops/sec
native .reduce() with map, spread	9411447.0 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll explain the benchmark and its options.

**Benchmark Overview**

The benchmark is designed to compare three different approaches to calculate the Cartesian product of multiple arrays in JavaScript. The test cases are:

1. `npm:fast-cartesian` - This approach uses an optimized implementation that generates a function at compile-time using a technique called "compile-time metaprogramming". The generated function is then executed directly by the browser.
2. `native .reduce() with flatmap, concat` - This approach uses the built-in `Array.prototype.reduce()` method and the `flatMap()` and `concat()` methods to calculate the Cartesian product.
3. `native .reduce() with map, spread` - This approach uses the built-in `Array.prototype.map()` method and the spread operator (`...`) to calculate the Cartesian product.

**Options Compared**

The three approaches are compared in terms of their execution speed, which is measured as the number of executions per second.

* **Compile-time metaprogramming**: The `npm:fast-cartesian` approach uses a technique called "compile-time metaprogramming" where the generated function is executed directly by the browser. This approach has a one-time overhead to generate the function but then executes very fast.
* **Built-in methods**: The other two approaches use built-in methods (`reduce()`, `flatMap()`, and `concat()` for the first approach, and `map()` and spread operator for the second approach). These methods are generally faster than custom implementations because they are optimized by the browser engine.

**Pros and Cons**

Here's a summary of the pros and cons of each approach:

* **Compile-time metaprogramming (npm:fast-cartesian)**:
	+ Pros:
		- Very fast execution speed due to direct execution by the browser.
		- Can be more efficient than built-in methods for large arrays.
	+ Cons:
		- Requires a one-time overhead to generate the function.
		- May not work well with smaller arrays or slower browsers.
* **Built-in methods (native .reduce() with flatmap, concat)**:
	+ Pros:
		- Faster execution speed than custom implementation due to optimization by the browser engine.
		- Works well with smaller arrays and slower browsers.
	+ Cons:
		- May not be as efficient as compile-time metaprogramming for large arrays.
* **Built-in methods (native .reduce() with map, spread)**:
	+ Pros:
		- Fast execution speed due to optimization by the browser engine.
		- Works well with smaller arrays and slower browsers.
	+ Cons:
		- May not be as efficient as compile-time metaprogramming for large arrays.

**Library**

None of the benchmark definitions use any external libraries.

**Special JS Feature/Syntax**

The `npm:fast-cartesian` approach uses a technique called "compile-time metaprogramming" which is a advanced JavaScript feature that allows generating functions at compile-time. This requires a good understanding of JavaScript and its syntax.

Overall, the benchmark provides a useful comparison of different approaches to calculating the Cartesian product in JavaScript, and can help developers choose the most efficient approach for their specific use case.

Related benchmarks:

npm:fast-cartesian product vs native .reduce() (version: 0)

Comparing performance of: npm:fast-cartesian vs native .reduce() with flatmap, concat vs native .reduce() with map, spread

Created: 4 years ago by: Registered User

Jump to the latest result

npm:fast-cartesian

native .reduce() with flatmap, concat

native .reduce() with map, spread

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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