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 = []; for (var i = 0; i < coordinates.length; i += 2) { var val = coordinates[i] + '|' + coordinates[i + 1]; if (temp.indexOf(val) === -1) { temp.push(val); unique = unique.concat( val.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.

I'll break down the explanation of the provided benchmark JSON, test cases, and latest benchmark results.

**Benchmark Definition JSON**

The provided JSON represents a JavaScript microbenchmark that tests two different approaches for processing an array of unique coordinates.

* **Script Preparation Code**: This code generates an array of 1000 random coordinates in the format `(longitude, latitude)`, where longitude and latitude are rounded to the nearest integer. The script preparation code is identical for both test cases.
* **Html Preparation Code**: This field is empty, indicating that no HTML-related setup is required for the benchmark.

**Test Cases**

There are two individual test cases:

1. **Array from - Set**
This test case uses the `Array.from()` method to create a new array from an iterable (in this case, a set of unique coordinates). The code then maps each coordinate to its string representation by joining them with the '|' character. Finally, it splits each string into individual numbers using the `split()` method.
2. **For loops**
This test case uses two nested for loops to process the array of coordinates. The outer loop iterates over the coordinates in steps of 2 (since every other coordinate is processed). For each pair of coordinates, it checks if the value is not already present in an internal `temp` array using `indexOf()`. If not, it adds the value to the `temp` array and concatenates the individual numbers of the current pair using `split()`.

**Options Compared**

The two test cases compare the performance of:

* Using `Array.from()` with a set vs. iterating over an array with two nested for loops.
* Splitting strings by '|' character vs. splitting each coordinate individually.

**Pros and Cons**

Here are some pros and cons of each approach:

1. **Array from - Set**
	* Pros:
		+ More concise code
		+ Potentially faster due to optimized implementation
	* Cons:
		+ May be less intuitive for developers unfamiliar with `Set` or `Array.from()`
2. **For loops**
	* Pros:
		+ Can be more readable for developers familiar with traditional iteration patterns
	* Cons:
		+ More verbose code
		+ Potentially slower due to the overhead of nested loops and string concatenation

**Libraries Used**

There is no library explicitly used in these benchmark cases. However, `Set` is a built-in JavaScript object that provides efficient set operations.

**Special JS Features/Syntax**

The test cases do not use any special JavaScript features or syntax beyond what's covered in the standard specification (ECMAScript).

**Alternatives**

If you're interested in exploring alternative approaches, here are some options:

1. **Using `Map` instead of `Set`:** You could replace the `Set` with a `Map`, which might offer better performance for this specific use case.
2. **Caching intermediate results:** If you anticipate repeating these computations multiple times, consider caching intermediate results to avoid redundant computations.
3. **Parallelizing computations:** Depending on your hardware and JavaScript engine, you might be able to take advantage of parallel computing to speed up the benchmark.

Keep in mind that each alternative will likely change the performance characteristics of the benchmark, so it's essential to verify the results for each new approach.

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