In PySpark, the hypot function is a mathematical function used to calculate the Euclidean distance or the square root of the sum of the squares of its arguments. The name hypot stands for “hypotenuse”, highlighting its utility in computing the length of the hypotenuse of a right-angled triangle.

The hypot function in PySpark is a versatile and efficient tool for calculating the Euclidean distance between points in a space, which is a common requirement in various domains including Physics, Computer Graphics, and Machine Learning. Its efficiency and numerical stability make it a preferable choice over manually squaring and finding the square root of numbers, especially when working with large datasets in a distributed computing environment like Spark. In this article, we will illustrate the utility of **hypot** with a simple example, computing the distance of points from the origin in a 2-dimensional space.

```
hypot(x, y) # Returns the sqrt(x^2 + y^2)
```

### When to use hypot?

The hypot function is particularly useful when:

**Calculating Distance:** It is often used in geometry and trigonometry to calculate the distance between two points in a 2-dimensional or 3-dimensional space.

**Ensuring Numerical Stability:** It’s more numerically stable when dealing with very large or very small numbers, as compared to manually squaring, adding, and then taking the square root of numbers.

**Physics Simulations:** It is also commonly used in physics for computing the resultant of two vector quantities.

### Advantages of using hypot

Numerical Stability: It avoids overflow and underflow that can occur when squaring large/small numbers.

Efficiency: It is computationally more efficient and can handle large datasets efficiently, leveraging the distributed computing capabilities of Spark.

Convenience and Readability: Provides a convenient and readable way to calculate Euclidean distance, improving code maintainability.

#### Sample code

Letâ€™s consider a simple example with hypothetical data. Suppose you have a DataFrame with two columns representing the coordinates (x, y) of points in a 2-dimensional space, and you want to calculate the Euclidean distance from the origin (0,0) for each point.

#### Sample Data:

```
+-----+-----+
| x| y|
+-----+-----+
| 3.0| 4.0|
| 6.0| 8.0|
| 5.0| 12.0|
| 9.0| 12.0|
| 12.0| 16.0|
+-----+-----+
```

#### PySpark Script:

```
from pyspark.sql import SparkSession
from pyspark.sql.functions import col, hypot
# Initialize a SparkSession
spark = SparkSession.builder.appName("Hypot Example").getOrCreate()
# Sample Data
data = [(3.0, 4.0), (6.0, 8.0), (5.0, 12.0), (9.0, 12.0), (12.0, 16.0)]
columns = ["x", "y"]
# Create DataFrame
df = spark.createDataFrame(data, schema=columns)
# Calculate Euclidean distance using hypot
df_with_distance = df.withColumn("distance_from_origin", hypot(col("x"), col("y")))
# Show the results
df_with_distance.show()
# Stop the SparkSession
spark.stop()
```

**ResultÂ **

```
+-----+-----+-------------------+
| x| y|distance_from_origin|
+-----+-----+-------------------+
| 3.0| 4.0| 5.0|
| 6.0| 8.0| 10.0 |
| 5.0| 12.0| 13.0 |
| 9.0| 12.0| 15.0 |
| 12.0| 16.0| 20.0 |
+-----+-----+-------------------+
```

Spark important urls to refer