NumPy conj() Function

---

---

The NumPy conj() function is used to compute the complex conjugate of each element in an array. The complex conjugate of a complex number is obtained by changing the sign of its imaginary part.

This function is useful in operations that involves complex numbers, such as in signal processing or solving certain types of equations. It ensures that calculations with complex numbers are handled accurately.

Syntax

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

numpy.conj(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True)

Parameters

This function accepts the following parameters −

• x: The input array containing complex numbers.
• out (optional): A location into which the result 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 array will be set to the ufunc result. Otherwise, it will retain its 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 array and of the accumulator in which the elements are summed. The dtype of x is used by default unless dtype is specified.
• subok (optional): If True, then sub-classes will be passed-through, otherwise the returned array will be forced to be a base-class array.

Return Value

This function returns an array containing the complex conjugates of each element in the input array x. If out is provided, it returns a reference to out.

Example: Basic Usage of conj() Function

In the following example, we create a 1-dimensional array of complex numbers and use the conj() function to compute their complex conjugates −

import numpy as np

# Creating a 1-dimensional array of complex numbers
arr = np.array([1+2j, 3+4j, -5-6j])

# Computing the complex conjugate of each element
result = np.conj(arr)
print(result)

Following is the output obtained −

[ 1.-2.j  3.-4.j -5.+6.j]

Example: conj() Function with Complex Numbers in a 2D Array

In this example, we create a 2-dimensional array of complex numbers and use the conj() function to find the complex conjugates of these numbers −

import numpy as np

# Creating a 2-dimensional array of complex numbers
arr = np.array([[1+2j, -3-4j], [5+6j, -7-8j]])

# Computing the complex conjugate of each element
result = np.conj(arr)
print(result)

This will produce the following result −

[[ 1.-2.j -3.+4.j]
 [ 5.-6.j -7.+8.j]]

Example: conj() Function with Broadcasting

In this example, we demonstrate the use of broadcasting with the conj() function. We create a 1-dimensional array of complex numbers and a scalar complex number, and use broadcasting to compute the conjugate −

import numpy as np

# Creating a 1-dimensional array of complex numbers
arr = np.array([1+1j, 2+2j, 3+3j])

# Scalar complex number
scalar = 4 + 5j

# Computing the complex conjugate of the array elements
result = np.conj(arr * scalar)
print(result)

Following is the output obtained −

[-1. -9.j -2.-18.j -3.-27.j]

Example: conj() Function with Real Numbers

In this example, we create a 1-dimensional array of real numbers and use the conj() function to demonstrate that the function leaves real numbers unchanged −

import numpy as np

# Creating a 1-dimensional array of real numbers
arr = np.array([1, -2, 3, -4])

# Computing the complex conjugate of each element
result = np.conj(arr)
print(result)

This will produce the following result −

[ 1 -2  3 -4]