# Streamlining Numerical Operations with NumPy fmin

## NumPy fmin: Finding the Element-Wise Minimum

When working with numerical data in Python, the NumPy library is an essential tool. NumPy provides a vast collection of functions for manipulating arrays and performing mathematical operations on them.

One particularly useful function provided by NumPy is `fmin()`. This function, short for “minimum”, is designed to compare two input arrays element-wise and return a new array containing the minimum value of each corresponding pair of elements.

In this article, we’ll delve into the NumPy `fmin` function, exploring its definition, syntax, and purpose. We’ll also walk through examples of its application, including how to handle NaN values.

## Defining NumPy fmin

NumPy `fmin` is a function that compares two arrays element-wise, returning an output array containing the minimum value of each corresponding element pair. The syntax of NumPy `fmin` is as follows:

``numpy.fmin(x1, x2, out=None, where=True, **kwargs)``

The `fmin()` function takes two input arrays (`x1` and `x2`) and by default, returns a new array containing the element-wise minimum values for each corresponding pair of elements in the input arrays.

NumPy `fmin` can also accept a third argument (`out`), providing an alternative output array for the result. Additionally, it can accept the optional parameter ‘`where`‘ to specify alternate values to fill.

## Examples of NumPy fmin

### Scalar Input Arrays

Let’s consider a simple example where we have two scalar input arrays `x1` and `x2`.

``````import numpy as np

x1 = np.array([1, 3, 5, 7])
x2 = np.array([9, 8, 6, 4])

print(np.fmin(x1, x2))``````

The output for this code will be an array `[1, 3, 5, 4]`, which represents the minimum value of each corresponding element.

### One-Dimensional Arrays

NumPy `fmin` is also useful for comparing the element-wise minimum of two one-dimensional arrays.

``````x1 = np.array([0.1, 0.2, 0.3, 0.4])
x2 = np.array([1.0, 2.0, 3.0, 4.0])

print(np.fmin(x1, x2))``````

The output for this code will be an array `[0.1, 0.2, 0.3, 0.4]`, which is the minimum value of each corresponding element.

### Two-Dimensional Arrays

Similar to one-dimensional arrays, NumPy `fmin` can also be applied to two-dimensional arrays. In this example, we will compare two arrays of the same size.

``````x1 = np.array([[5, 6],
[7, 8]])
x2 = np.array([[3, 2],
[1, 0]])

print(np.fmin(x1, x2))``````

The output for this code will be a two-dimensional array containing the element-wise minimums of each corresponding pair of elements in the arrays. The resulting array would be `[[3, 2], [1, 0]]`, representing the minimum value for each pair of corresponding elements in the two arrays.

### Handling NaNs

Handling NaNs (Not a Number) when dealing with arrays is a common problem in numerical data. NumPy `fmin` provides a way to handle NaNs by replacing them with non-NaN values when comparing arrays.

``````x1 = np.array([1, np.nan, 3, np.nan])
x2 = np.array([np.nan, 2, np.nan, 4])
out = np.array([0, 0, 0, 0])

np.fmin(x1, x2, where=~np.isnan(x1), out=out)``````

The `where` option is used to select elements based on a Boolean condition. Here, `~np.isnan(x1)` means only non-NaN values in `x1` will overwrite the values of `out`.

The output for this code will be an array `[1., 2., 3., 4.]`, which represents the element-wise minimum of the corresponding values. The NaNs have been removed from the calculation, and non-NaN values have been used to calculate the minimums.

## Conclusion

In this article, we’ve explored the NumPy `fmin` function across different scenarios. NumPy `fmin` is a valuable tool for comparing arrays element-wise and calculating the minimal value in each corresponding pair of elements. Its syntax is straightforward, and it can handle the complexities of NaN values within arrays. By utilizing this function, we can streamline mathematical operations on arrays, making them more efficient.

To recap, the NumPy `fmin` method is a powerful tool for finding the element-wise minimum values between two arrays. Its flexibility in handling various array types and NaN values makes it an indispensable function for numerical operations in Python.