Benchmark: npm:fast-cartesian product vs native .reduce() vs cartesian from https://stackoverflow.com/a/43053803

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)
cartesian from https://stackoverflow.com/a/43053803
const cartesian = (...a) => { console.log(a) return a.reduce((a, b) => a.flatMap(d => { // console.log(b) return b.map(e => [d, e].flat()) }))}

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
cartesian from https://stackoverflow.com/a/43053803

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Firefox 115 on Windows 8.1

View result in a separate tab

Test name	Executions per second
npm:fast-cartesian	1118.0 Ops/sec
native .reduce() with flatmap, concat	1603977.5 Ops/sec
native .reduce() with map, spread	2631697.8 Ops/sec
cartesian from https://stackoverflow.com/a/43053803	1009096512.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Measuring the performance of different approaches to implement Cartesian product in JavaScript is an interesting task.

**What is being tested?**

The provided JSON represents four benchmark test cases:

1. `npm:fast-cartesian`: This test case uses a custom implementation of Cartesian product, which is optimized for speed.
2. `native .reduce() with map, spread`: This test case uses the built-in `Array.prototype.reduce()` method in conjunction with `map` and `spread` operators to implement Cartesian product.
3. `native .reduce() with flatmap, concat`: Similar to the previous one, but using `flatMap` and `concat` methods instead of `map` and `spread`.
4. `cartesian from https://stackoverflow.com/a/43053803`: This test case uses a code snippet from a Stack Overflow answer that implements Cartesian product using a custom function.

**Options compared**

The four test cases compare the performance of different approaches to implement Cartesian product:

* Optimized custom implementation (`npm:fast-cartesian`)
* Built-in `Array.prototype.reduce()` with `map` and `spread` operators (`native .reduce() with map, spread`)
* Built-in `Array.prototype.reduce()` with `flatMap` and `concat` methods (`native .reduce() with flatmap, concat`)
* A code snippet from a Stack Overflow answer that uses a custom function (`cartesian from https://stackoverflow.com/a/43053803`)

**Pros and cons of each approach**

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

1. `npm:fast-cartesian`:
	* Pros: Optimized for speed, should be the fastest implementation.
	* Cons: Custom implementation, might not be as readable or maintainable as other approaches.
2. `native .reduce() with map, spread`:
	* Pros: Uses built-in methods, easy to understand and implement.
	* Cons: Might be slower than optimized custom implementations due to overhead of method calls.
3. `native .reduce() with flatmap, concat`:
	* Similar pros and cons as the previous one.
4. `cartesian from https://stackoverflow.com/a/43053803`:
	* Pros: Uses a well-known code snippet, might be optimized for performance.
	* Cons: Custom implementation, might not be as readable or maintainable as other approaches.

**Browser-specific results**

The latest benchmark result shows that the test cases are run on Chrome 112 on a Mac OS X 10.15.7 desktop environment. The execution times vary between tests:

* `cartesian from https://stackoverflow.com/a/43053803`: 944554624 executions per second
* `native .reduce() with map, spread`: 5404996.5 executions per second
* `native .reduce() with flatmap, concat`: 1939000.875 executions per second
* `npm:fast-cartesian`: 11623.71484375 executions per second

Overall, the optimized custom implementation (`npm:fast-cartesian`) is still the fastest one, but the built-in `Array.prototype.reduce()` methods are relatively close in performance. The code snippet from the Stack Overflow answer is slower due to its custom implementation.

Please note that these results might vary depending on the specific use case and environment.

Related benchmarks:

npm:fast-cartesian product vs native .reduce() vs cartesian from https://stackoverflow.com/a/43053803 (version: 1)

Comparing performance of: npm:fast-cartesian vs native .reduce() with flatmap, concat vs native .reduce() with map, spread vs cartesian from https://stackoverflow.com/a/43053803

Created: 3 years ago by: Registered User

Jump to the latest result

npm:fast-cartesian

native .reduce() with flatmap, concat

native .reduce() with map, spread

cartesian from https://stackoverflow.com/a/43053803

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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