# What is np.floor_divide() Function in Python

The np.floor_divide() function divides two arrays of the same size. The floor_divide() function returns the largest integer smaller or equal to the division of the inputs. It is equivalent to the division operator( // ) and pairs with Python.

For example, if we have two arrays, arr1 and arr2, then floor_divide will divide the values of arr2 by the values of arr1, but we will get a floor result.

This floor is equal to the python // operator pair with the remainder operator (%). The simplified equation is b = a % b + b * (a // b) up to round off. We can divide array elements by any scalar also.

### Syntax

```numpy.floor_divide(arr1, arr2, out=None)
```

### Parameters

This function takes mainly two parameters:

1. arr1: This is the input array that acts like a dividend.
2. arr2: This is an input array that acts as a divisor.
3. out: This is an optional field. A place the result will be stored in. If given, the shape to which the inputs broadcast must be in. If a freshly-allocated array is returned unless received or None. A tuple (possible as a keyword argument only) must have a length equal to the output number.

### Return Value

The floor_divide() function returns the floor(x1/x2) where x1 and x2 are scalar.

## Programming Example

Program to show the working of floor_divide() when both inputs are array.

```# importing the numpy module
import numpy as np

# First Parameter
arr_A = np.array([8, 18, 28, 34])
# Shape of first array, arr_A is:
print("Shape of first array, arr_A is: ", arr_A.shape)

# Second Parameter
arr_B = np.array([2, 4, 5, 4])
# Shape of second array, arr_B is:
print("Shape of second array, arr_B is:", arr_B.shape)

out = np.floor_divide(arr_A, arr_B)
print("Output obtained is: ", out)
# Shape of output array, out is:
print("Shape of output array, out is: ", out.shape)
```

### Output

```Shape of first array, arr_A is:  (4,)
Shape of second array, arr_B is: (4,)
Output obtained is:  [4 4 5 8]
Shape of output array, out is:  (4,)```

### Explanation

In this program, we have taken two numpy arrays named arr_A and arr_B consisting of different array elements; we have passed these two arrays as parameters inside the np.floor_divide() method; first parameter, arr_A acts as the dividend whose elements need to be divided and arr_B acts as the divisor.

The elements of arr_A are divided into element-wise fashion by the elements of arr_B.

The result of the floor_division() function is stored in a variable named out, which is the numpy array of the same shape as the input arrays and contains the quotient values obtained after division.

## When the divisor is a scalar

```# importing the numpy module
import numpy as np

# First Parameter
arr_A = np.array([8, 18, 28, 34])
print("Elements in arr_A are: ", arr_A)

# Second Parameter is a scalar value
scal_val = 6
print("Scalar value is: ", scal_val)

out = np.floor_divide(arr_A, scal_val)
print("Output obtained is: ", out)```

### Output

```Elements in arr_A are:  [ 8 18 28 34]
Scalar value is:  6
Output obtained is:  [1 3 4 5]
```

### Explanation

In the program, we have taken a numpy input array named arr_A, which performs the function of dividend and a scalar value, i.e., 6, which will act as the divisor; we have passed arr_A as the first parameter and the scalar value as the second parameter inside np.floor_divide() method, the scalar value will be broadcasted into an array of the same shape as arr_A.

Then the division is performed element-wise as usual.

The result of the division is stored in the variable named out, which is a numpy array of the same shape as an input array and contains the quotient values obtained after division.

That’s it for this tutorial.

This site uses Akismet to reduce spam. Learn how your comment data is processed.