NumPy divmod() Function

---

---

The NumPy divmod() function is used to return the element-wise quotient and remainder of division. It performs both division and modulo operations, returning two arrays: one for the quotient and one for the remainder.

This function handles broadcasting for arrays of different shapes and can operate with both arrays and scalars.

Syntax

Following is the syntax of the NumPy divmod() function −

numpy.divmod(x1, x2, /, out1=None, out2=None, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Parameters

This function accepts the following parameters −

• x1: The dividend input array. It is the array whose elements will be divided by the elements of x2.
• x2: The divisor input array. Like x1, it should have the same shape as x1, or be broadcastable to a common shape.
• out1 (optional): A location into which the quotient is stored. If provided, it must have a shape that the inputs broadcast to. If not provided or None, a freshly-allocated array is returned.
• out2 (optional): A location into which the remainder is stored. If provided, it must have a shape that the inputs broadcast to. If not provided or None, a freshly-allocated array is returned.
• where (optional): This condition is broadcast over the input. At locations where the condition is True, the out arrays will be set to the ufunc result. Otherwise, they will retain their original value.
• casting (optional): Controls what kind of data casting may occur. Defaults to 'same_kind'.
• order (optional): Controls the memory layout order of the result. 'C' means C-order, 'F' means Fortran-order, 'A' means 'F' if inputs are all F, 'C' otherwise, 'K' means match the layout of the inputs as closely as possible.
• dtype (optional): The type of the returned arrays and of the accumulator in which the division is performed. The dtype of x1 and x2 is used by default unless dtype is specified.
• subok (optional): If True, then sub-classes will be passed-through, otherwise the returned arrays will be forced to be base-class arrays.

Return Value

This function returns two arrays: one containing the element-wise quotient and the other containing the element-wise remainder of the division of x1 by x2. If out1 and out2 are provided, it returns references to these.

Example: Basic Usage of divmod() Function

In the following example, we create two 1-dimensional arrays and use the divmod() function to perform element-wise division and modulo operations −

import numpy as np
# Creating two 1-dimensional arrays
arr1 = np.array([5, 9, 11, 14])
arr2 = np.array([3, 4, 5, 6])

# Performing element-wise division and modulo
quotient, remainder = np.divmod(arr1, arr2)
print("Quotient:", quotient)
print("Remainder:", remainder)

Following is the output obtained −

Quotient: [1 2 2 2]
Remainder: [2 1 1 2] 

Example: divmod() Function with Broadcasting

In this example, we demonstrate the use of broadcasting with the divmod() function. We create a 2-dimensional array and calculate the quotient and remainder when it is divided by a 1-dimensional array −

import numpy as np

# Creating a 2-dimensional array
arr1 = np.array([[5, 9, 11], [14, 21, 29]])

# Creating a 1-dimensional array
arr2 = np.array([3, 4, 5])

# Performing element-wise division and modulo with broadcasting
quotient, remainder = np.divmod(arr1, arr2)
print("Quotient:\n", quotient)
print("Remainder:\n", remainder)

This will produce the following result −

Quotient:
 [[1 2 2]
  [4 5 5]]
Remainder:
 [[2 1 1]
  [2 1 4]]

Example: divmod() Function with Scalar

In this example, we divide all elements of an array by a scalar and calculate both the quotient and the remainder −

import numpy as np

# Creating a 1-dimensional array
arr = np.array([5, 9, 11, 14])

# Performing division and modulo with a scalar value 3
quotient, remainder = np.divmod(arr, 3)
print("Quotient:", quotient)
print("Remainder:", remainder)

Following is the output of the above code −

Quotient: [1 3 3 4]
Remainder: [2 0 2 2]

Example: divmod() Function with Negative Values

In this example, we calculate the quotient and remainder of division involving negative numbers −

import numpy as np

# Creating a 1-dimensional array with negative values
arr = np.array([-5, -9, -11, -14])

# Performing division and modulo with a scalar value 3
quotient, remainder = np.divmod(arr, 3)
print("Quotient:", quotient)
print("Remainder:", remainder)

The output obtained is as shown below −

Quotient: [-2 -3 -4 -5]
Remainder: [ 1  0  1  1]