Benchmark: The fastest way to find the distance between two points

Script Preparation code:

var x1 = 10;
var y1 = 20;
var x2 = -10;
var y2 = -20;

function euclidian_a() {
	return Math.sqrt(x1 * x2 + y1 * y2);
}

function euclidian_b() {
	return x1 * x2 + y1 * y2;
}

function manhattan_a() {
	return Math.abs(x1 - x2) + Math.abs(y1 - y2);
}

function manhattan_b() {
	if (x1 < 0) {
		x1 *= -1;
	}
  	if (x2 < 0) {
		x1 *= -1;
	}
  	if (x1 < 0) {
		x1 *= -1;
	}
	if (y2 < 0) {
		y1 *= -1;
	}
	return x1 - x2 + y1 - y2;
}

function custom_a() {
  x1 = (x1 >= 0) ? x1 : -x1 ;
  x2 = (x2 >= 0) ? x2 : -x2 ;
  y1 = (y1 >= 0) ? y1 : -y1 ;
  y2 = (y2 >= 0) ? y2 : -y2 ;
  return x1 - x2 + y1 - y2;
}

Tests:

Euclidian A
euclidian_a();
Euclidian B
euclidian_b();
Manhattan A
manhattan_a();
Manhattan B
manhattan_b();
Custom A
custom_a();

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Euclidian A
Euclidian B
Manhattan A
Manhattan B
Custom A

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 117 on Windows

View result in a separate tab

Test name	Executions per second
Euclidian A	3175086.2 Ops/sec
Euclidian B	4714544.5 Ops/sec
Manhattan A	2704226.2 Ops/sec
Manhattan B	1443919.9 Ops/sec
Custom A	1262240.5 Ops/sec

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

LLMs can make mistakes. Check important info.

Measuring the performance of different distance calculation algorithms is crucial in various applications, including games, GPS navigation, and more.

**Benchmark Overview**

The provided JSON represents a benchmark test case that compares four different algorithms for calculating the Euclidean distance between two points:

1. `euclidian_a()`
2. `euclidian_b()`
3. `manhattan_a()`
4. `custom_a()`

Each algorithm is implemented as a separate function, and their performance is measured by executing each function a specified number of times (executions per second).

**Algorithm Comparison**

Here's a brief overview of each algorithm:

1. **Euclidean Distance**: The most common method for calculating the distance between two points in n-dimensional space. It involves using the Pythagorean theorem, which requires squaring and summing the differences between corresponding coordinates.
2. **Manhattan Distance (L1 Distance)**: This algorithm calculates the distance as the sum of the absolute differences between corresponding coordinates. It's often used for grid-based movement or navigation.
3. **Custom Algorithm**: This algorithm takes a different approach by using bitwise operations to negate negative coordinate values before performing the calculation.

**Pros and Cons**

Here are some pros and cons of each algorithm:

1. **Euclidean Distance**:
	* Pros: accurate, widely used
	* Cons: computationally expensive (O(n^2))
2. **Manhattan Distance**:
	* Pros: fast, efficient for grid-based movement
	* Cons: can produce incorrect results if not handled carefully
3. **Custom Algorithm**:
	* Pros: potentially faster due to bitwise operations
	* Cons: less accurate due to the transformation of negative coordinates

**Library and Purpose**

In this benchmark, the `Math` library is used extensively for its built-in mathematical functions, such as `sqrt()`.

**Special JS Feature or Syntax**

There are no special JavaScript features or syntax used in these algorithms. The focus is on the logic and implementation of each distance calculation method.

**Other Alternatives**

If you're interested in exploring alternative algorithms or variations, here are a few options:

1. **Chebyshev Distance**: A variation of Euclidean distance that considers the maximum difference between corresponding coordinates.
2. **Minkowski Distance**: A generalization of Manhattan and Euclidean distances that can be used for different norms (e.g., L1, L2, etc.).
3. **Octile Distance**: An alternative to Manhattan distance that uses a square root function to calculate the distance.

Keep in mind that these alternatives may have different trade-offs in terms of accuracy, speed, and applicability.

Related benchmarks:

The fastest way to find the distance between two points (version: 1)

Tested in php : http://www.emanueleferonato.com/2010/07/29/the-fastest-way-to-find-the-distance-between-two-points/

Comparing performance of: Euclidian A vs Euclidian B vs Manhattan A vs Manhattan B vs Custom A

Created: 6 years ago by: Registered User

Jump to the latest result

Euclidian A

Euclidian B

Manhattan A

Manhattan B

Custom A

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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