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:

**arr1**: This is the input array that acts like a dividend.**arr2**: This is an input array that acts as a divisor.**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.