Benchmark: unique coordinates

Script Preparation code:

var coordinates = [];

for (var i=0; i< 1000; 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 = []; var uniqueCoords = []; for (var i = 0; i < coordinates.length; i += 2) { temp.push(coordinates[i] + '|' + coordinates[i + 1]); // create some strings } for (var i = 0; i < temp.length; i++) { if (unique.indexOf(temp[i]) === -1) { unique.push(temp[i]); uniqueCoords.push(temp[i].split('|')) } }

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.

The provided JSON represents a JavaScript microbenchmarking test case on the MeasureThat.net website.

**Benchmark Definition Overview**

The benchmark measures the performance of two different approaches to convert an array of unique coordinates into a set and then extract the values from the set as numbers. The coordinates are generated randomly and represent points on a 2D plane (latitude and longitude).

**Approaches Compared**

There are two test cases:

1. **Array.from - Set**: This approach uses the `Array.from()` method to create a new array from an iterable, followed by reducing it with a set to eliminate duplicates. The resulting values are then extracted using the `split()` method.
2. **For Loops**: This approach iterates over the coordinates in pairs, concatenating them into strings, and then adds these strings to a temporary array. It then checks for duplicate strings using the `indexOf()` method and adds unique ones to the `unique` array.

**Pros and Cons of Each Approach**

1. **Array.from - Set**: This approach is concise and efficient, as it uses built-in methods optimized for performance.
	* Pros: Fast, easy to read, and maintainable.
	* Cons: May have overhead due to the creation of a new array and set.
2. **For Loops**: This approach is more explicit and may be familiar to developers who are not comfortable with modern JavaScript features.
	* Pros: Easy to understand, no dependency on built-in methods.
	* Cons: More verbose, slower due to the overhead of string concatenation and `indexOf()` checks.

**Library and Special JS Features**

In this benchmark, there is no explicit use of a library. However, it's worth noting that the `Set` data structure was introduced in ECMAScript 2015 (ES6) as part of the standard language specification. The `Array.from()` method was also introduced in ES6.

**Other Considerations**

* **Random Data Generation**: The benchmark uses random coordinates to generate unique input data, which helps eliminate any bias towards specific algorithms or optimizations.
* **Performance Measurement**: MeasureThat.net measures the performance by executing the test code repeatedly (every second) and reporting the average number of executions per second.
* **Device Platform**: The benchmark runs on a Windows 7 platform with Chrome 60 as the browser.

**Alternatives**

Other approaches to convert an array of unique coordinates into a set and extract values from it might include:

1. Using `Map` instead of `Set`: A `Map` is an object that stores key-value pairs, where each key is unique. You could use `Map` to store the coordinates and then access them using their keys.
2. Using `Spread Operator` with `Set`: The spread operator (`...`) can be used with a set to create a new set from an iterable.
3. Implementing a custom algorithm using recursion or iteration: Depending on your specific requirements, you might need to implement a custom algorithm that suits your use case.

Keep in mind that these alternatives may have different performance characteristics and trade-offs compared to the approaches tested in this benchmark.

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