Benchmark: filter-map vs reduce (correct)

Script Preparation code:

a=[];
for(i=0;i<1000;i++) a.push(Number(i)/1000 + Math.random());
var filtering=x=>(x*114514)%1>0.5;
var mapping=x=>x+0.1919;
var reducing=(acc,x)=>{
  if((x*114514)%1>0.5) acc.push(x+0.1919);
  return acc;
}

Tests:

filter and map
a.filter(filtering).map(mapping)
reduce
a.reduce(reducing, [])

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
filter and map
reduce

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/93.0.4577.82 Safari/537.36

Browser/OS: Chrome 93 on Linux

View result in a separate tab

Test name	Executions per second
filter and map	22672.8 Ops/sec
reduce	32261.1 Ops/sec

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 JSON and explain what's being tested.

**Benchmark Definition JSON**

The benchmark definition represents a JavaScript microbenchmark that tests two different approaches:

1. **Filter-Map**: `a.filter(filtering).map(mapping)`
2. **Reduce**: `a.reduce(reducing, [])`

Both approaches are used to process an array `a` containing 1000 elements with random values.

**Filter-Map Approach**

In this approach, the filter function `filtering` is applied to each element of the array, and only elements that pass the filter are then mapped through another function `mapping`. The resulting values from the map operation are returned as an array.

The filter function uses a modulo operation (`(x*114514)%1>0.5`) to determine whether an element should be included in the filtered result. The mapping function adds 0.1919 to each element that passes the filter.

**Reduce Approach**

In this approach, the reduce function `reducing` is used to accumulate values from the array. The initial value of the accumulator is an empty array `[]`. For each element in the array, if the modulo operation `(x*114514)%1>0.5` returns true, the mapping function is applied to that element and its result is appended to the accumulator.

**Options Compared**

The two approaches are compared on the same input data: 1000 random elements with different values.

**Pros and Cons of Each Approach**

* **Filter-Map Approach**
	+ Pros:
		- Can be more efficient for small datasets or when only a subset of elements needs to be processed.
		- Often used in functional programming paradigms.
	+ Cons:
		- May have higher overhead due to the creation of an intermediate array during filtering.
* **Reduce Approach**
	+ Pros:
		- Can be more efficient for large datasets or when only a single accumulator value is needed.
		- Typically has lower overhead compared to filter-map approach.
	+ Cons:
		- Requires careful handling of edge cases, such as initial values and element processing.

**Library Used**

None explicitly mentioned in the provided benchmark JSON. However, it's likely that the JavaScript implementation used by MeasureThat.net is a standard ECMAScript compliant library or engine.

**Special JS Feature/Syntax**

The modulo operation `x*114514)%1>0.5` uses a bitwise shift and multiplication to achieve a pseudo-random effect. This syntax might not be immediately recognizable, but it's essentially a creative way to generate random numbers without using the `Math.random()` function directly.

**Other Alternatives**

If you want to explore other alternatives or variations on these approaches, consider:

1. Using `Array.prototype.forEach` instead of filtering and mapping.
2. Implementing a custom sorting algorithm for reduce approach.
3. Testing with different data distributions (e.g., random walks, Gaussian distribution).

Keep in mind that the MeasureThat.net benchmark is primarily focused on comparing the performance of these two approaches on the provided input data.

Related benchmarks:

filter-map vs reduce (correct) (version: 5)

Comparing performance of: filter and map vs reduce

Created: 3 years ago by: Registered User

Jump to the latest result

filter and map

reduce

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