## Calculating Manhattan Distance: A Guide

Distances are an essential measure of spatial relationships in many fields, ranging from machine learning and data analysis to geography and urban planning. In particular, the Manhattan distance is a popular metric that measures the distance between two points as the sum of the absolute differences of their coordinates in each dimension.

In this article, we will explore how to calculate the Manhattan distance using a custom function and the `cityblock()`

function in Python. We will also provide an example calculation to help you understand how it works and confirm its correctness.

## 1. Custom Function and `cityblock()`

Function

### 1.1. Custom Function

To calculate the Manhattan distance between two points, we can define a custom function that takes their coordinates as arguments and applies the formula for the Manhattan distance. Here is an example implementation in Python:

```
def manhattan_distance(x1, y1, x2, y2):
return abs(x1 - x2) + abs(y1 - y2)
```

This function takes four arguments: the x and y coordinates of the first point (x1, y1) and the x and y coordinates of the second point (x2, y2).

It then calculates the Manhattan distance by subtracting the corresponding x and y coordinates, taking their absolute values, and summing them.

### 1.2. `cityblock()`

Function

Another way to calculate the Manhattan distance in Python is to use the `cityblock()`

function from the `scipy.spatial.distance`

module.

The `cityblock()`

function computes the distance between two points using the Manhattan distance, but it is vectorized and more efficient for large arrays of points. Here is an example usage of the `cityblock()`

function:

```
import numpy as np
from scipy.spatial.distance import cityblock
# Define two points as arrays
p1 = np.array([1, 2])
p2 = np.array([4, 5])
# Calculate the Manhattan distance using cityblock()
distance = cityblock(p1, p2)
print(distance) # Output: 6
```

In this example, we define two points as one-dimensional NumPy arrays with the x and y coordinates. We then call the `cityblock()`

function with these arrays as arguments and assign the result to the variable ‘distance’.

The function computes the Manhattan distance between the points as the sum of the absolute differences between their coordinates, which is 3 in the x dimension and 3 in the y dimension, resulting in a total distance of 6.

## 2. Calculation Example

To help you understand how to calculate the Manhattan distance, let’s consider the following example. Suppose we have two points A and B with the coordinates A=(2, 5) and B=(7, 9).

We want to calculate the Manhattan distance between them using both the custom function and the `cityblock()`

function.

### 2.1. Using the Custom Function

Using the custom function, we can call the ‘manhattan_distance’ function as follows:

```
distance = manhattan_distance(2, 5, 7, 9)
print(distance) # Output: 9
```

The function subtracts the x coordinates and the y coordinates, taking their absolute values and summing them, resulting in a distance of 9.

### 2.2. Using the `cityblock()`

Function

Using the `cityblock()`

function, we can define the points as NumPy arrays and call the function as follows:

```
import numpy as np
from scipy.spatial.distance import cityblock
# Define A and B as arrays
A = np.array([2, 5])
B = np.array([7, 9])
# Calculate the Manhattan distance using cityblock()
distance = cityblock(A, B)
print(distance) # Output: 9
```

The function computes the absolute differences between the x coordinates and the y coordinates, summing them up to a total distance of 9.

## 3. Confirming Correctness

To confirm that the Manhattan distance calculation is correct, we can use the Pythagorean theorem to calculate the Euclidean distance between the points. The Euclidean distance is the straight-line distance between the points and is a special case of the more general formula for the distance between two points in n-dimensional space.

The Euclidean distance between two points A=(2, 5) and B=(7, 9) is given by:

```
distance = ((7 - 2) ** 2 + (9 - 5) ** 2) ** 0.5
print(distance) # Output: 5.830951894845301
```

The function squares the differences between the x and y coordinates, adds them up, and takes the square root, resulting in a distance of approximately 5.83. The Euclidean distance is always shorter than or equal to the Manhattan distance, as it takes a direct path between the points, while the Manhattan distance follows the axes.

In this case, we see that the Euclidean distance is indeed shorter than the Manhattan distance, confirming that the calculation is correct.

## 4. Conclusion

Calculating the Manhattan distance between two points is a straightforward and efficient process that can be achieved using a custom function or the `cityblock()`

function in Python. This metric is useful in many applications that require measuring spatial relationships, and it provides a valuable complement to the Euclidean distance.

By understanding how to calculate the Manhattan distance, you can perform better data analysis, machine learning, and other computational tasks that rely on distances between points. Whether you are a professional or a student, this knowledge will benefit you in many ways.

The article explains how to calculate the Manhattan distance between two points using a custom function or the `cityblock()`

function in Python. The Manhattan distance is a popular metric used in many fields that measure the distance between two points as the sum of the absolute differences of their coordinates in each dimension.

The article provides a calculation example and confirms the correctness of the metric. Understanding how to calculate the Manhattan distance can help in data analysis, machine learning, and other computational tasks.

By employing the techniques described in the article, readers can enhance their problem-solving abilities and analyze spatial relationships more effectively.