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 = []; 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.

I'll break down the provided benchmark and its options, explaining the pros and cons of each approach.

**Benchmark Definition JSON**

The benchmark definition is a JSON object that contains information about the test case. In this case:

* `Name`: "unique coordinates"
* `Description`: null
* `Script Preparation Code`: generates an array of 500 unique coordinate pairs using `Math.random()` to create random angles between -180 and 180 degrees.
* `Html Preparation Code`: null (no HTML preparation is required for this benchmark)

**Individual Test Cases**

There are two test cases in the provided benchmark:

1. **"Array from - Set"**
	* The `Benchmark Definition` script uses `Array.from()` to create an array of unique strings, where each string represents a coordinate pair.
	* It then uses `Set` to remove duplicates and `map()` to convert each string back into an array with two elements (the x and y coordinates).
2. **"For loops"**
	* This test case uses a manual loop to create an array of unique strings, where each string represents a coordinate pair.
	* It then uses the `indexOf()` method to check if each string is already in the `unique` array. If not, it adds the string to the `unique` array and pushes a new array with the x and y coordinates into the `uniqueCoords` array.

**Comparison of Options**

The two test cases differ in their approach:

* **"Array from - Set"`:
	+ Pros: concise, uses built-in functions for data manipulation (e.g., `Array.from()`, `Set`), potentially faster since it leverages JavaScript's internal optimizations.
	+ Cons: may not be as efficient due to the overhead of creating and manipulating a `Set`.
* **"For loops"`:
	+ Pros: manual control over the loop, potentially more efficient since it avoids the overhead of built-in functions like `Array.from()` or `Set`. However, it's more verbose and error-prone.
	+ Cons: can be slower due to the repeated checks in the `indexOf()` method.

**Library Considerations**

In this benchmark, there is no explicit library mentioned. However, some libraries may provide optimizations for certain operations, such as:

* `Array.from()`: This function uses a V8-specific optimization under the hood, which might not be available in all JavaScript engines.
* `Set`: The `Set` data structure provides fast membership testing and insertion, but its implementation can vary between browsers.

**Special JS Feature or Syntax**

There is no special JavaScript feature or syntax used in this benchmark. However, some features like `const` and `let` are not explicitly mentioned either.

**Other Alternatives**

If you were to create a similar benchmark, you could consider other approaches:

* **Using `reduce()` instead of `Set`:** This would involve using the `reduce()` method to accumulate unique values in an array. While this approach can be more explicit, it might incur additional overhead due to the repeated function calls.
* **Using a different data structure:** You could experiment with alternative data structures like `Map` or a custom implementation of a set data structure to compare their performance.

Keep in mind that the choice of approach depends on your specific requirements and the characteristics of the data being processed.

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