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

Autogenerated LLM Summary (model llama3.2:3b, generated 27 days 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.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/60.0.3112.113 Safari/537.36

Browser/OS: Chrome 60 on Windows 7

View result in a separate tab

Test name	Executions per second
Array from - Set	903.5 Ops/sec
For loops	578.3 Ops/sec

Related benchmarks:

unique coordinates (version: 0)

Comparing performance of: Array from - Set vs For loops

Created: 7 years ago by: Guest

Jump to the latest result

Array from - Set

For loops

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 27 days ago):