Benchmark: unique coordinates

Script Preparation code:

var coordinates = [];

for (var i=0; i< 500; i++) {
	coordinates.push(Math.round((Math.random()*360-180)*1e7)/1e7, Math.round((Math.random()*360-180)*1e7)/1e7)
}

Tests:

Array from - Set
var unique = Array.from(new Set(coordinates.reduce((r, a, i) => (i % 2 ? r[r.length - 1].push(a) : r.push([a]), r), []).map(a => a.join('|'))), s => s.split('|').map(Number));
For loops
var temp = []; var unique = []; for (var i = 0; i < coordinates.length; i += 2) { temp.push(coordinates[i] + '|' + coordinates[i + 1]); // create some strings } var map = new Set(temp); map.forEach( x => { unique.push( x.split('|').map(Number) ) });

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array from - Set
For loops

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON and benchmark preparation code to understand what's being tested.

**Benchmark Definition JSON**

The benchmark definition represents two test cases: "Array from - Set" and "For loops". These test cases are designed to compare the performance of two approaches:

1. **"Array from - Set"**: This approach uses the `Array.from()` method to create an array from a set, which is then converted into individual strings using the `join('|')` method.
2. **"For loops"**: This approach uses traditional `for` loops to iterate over the coordinates, creating strings and pushing them onto two separate arrays.

**Options Compared**

The benchmark compares these two approaches:

*   **`Array.from()` vs Traditional Loops**: This comparison tests the performance of using the `Array.from()` method versus traditional `for` loops.
*   **Memory Usage**: Another aspect being compared is memory usage between the two approaches, although this is not explicitly mentioned in the provided JSON.

**Pros and Cons**

Here are some pros and cons for each approach:

1.  **"Array from - Set"**
    *   Pros:
        *   More concise code.
        *   Can be more expressive and easier to read.
    *   Cons:
        *   May have performance overhead due to the creation of a new array.
2.  **"For loops"**
    *   Pros:
        *   May have better cache locality, potentially leading to faster execution times.
        *   No additional memory allocation is required for creating a new array.
    *   Cons:
        *   More verbose code can be harder to read and maintain.

**Library/JS Feature Usage**

In this benchmark, the `Array.from()` method is used, which is a built-in JavaScript function introduced in ECMAScript 2015 (ES6). It creates a new array from an iterable or an array-like object.

**Special JS Features/Syntax**

None of the provided test cases use any special JavaScript features or syntax beyond what's been discussed. However, some newer approaches might utilize modern JavaScript features like `async/await`, arrow functions, or template literals.

**Other Alternatives**

Some alternative approaches to these comparisons could be:

*   **Using a different data structure**: Instead of using arrays and sets, the benchmark could test performance with other data structures, such as linked lists or hash tables.
*   **Different iteration methods**: The comparison could also focus on various iteration methods like `forEach()`, `map()`, or even WebAssembly-based iterations for better performance.

**Benchmark Results**

The latest benchmark results show that:

*   Chrome 60 on Windows 7 achieved an execution rate of approximately 994.86 executions per second for the "For loops" test case.
*   The same browser and OS configuration resulted in a slightly lower execution rate (906.03 executions per second) for the "Array from - Set" test case.

Keep in mind that these results might not be representative for all systems or configurations, as different platforms may exhibit varying performance characteristics due to factors like hardware capabilities, system resources, and optimization strategies employed by browsers.

Related benchmarks:

unique coordinates (version: 0)

Comparing performance of: Array from - Set vs For loops

Created: 8 years ago by: Guest

Jump to the latest result

Array from - Set

For loops

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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