Numpy eye() Function

---

---

The Numpy eye() function is used to create a 2D array with ones on the diagonal and zeros in all other positions. This means that all elements apart from the diagonal are zero. This function commonly used to generate identity matrices and similar structures in numerical computations.

A square matrix with ones on the diagonal is known as an identity matrix. The numpy.eye() function allows us to create a identity matrix with non-square matrices by specifying different values for rows and columns.

Syntax

Following is the syntax of the Numpy eye() function −

numpy.eye(N, M=None, k=0, dtype=float)

Parameters

Following are the parameters of the Numpy eye() function −

• N - This represents the number of rows in the output array.
• M - This represents the number of columns in the output array. If None, the output array will have the same number of columns as rows (i.e., a square matrix).
• k - This represents the index of the diagonal. Default value is 0 (the main diagonal). Positive values create diagonals above the main diagonal, and negative values create diagonals below the main diagonal.
• dtype - It is the desired data type for the array. By default value is float.

Return Values

This function returns a 2D NumPy array with ones on the specified diagonal and zeros in remaining positions.

Example

Following is a basic example to generate a 4x4 identity matrix using Numpy eye() function −

import numpy as np
identity_matrix = np.eye(4)
print("Identity Matrix:\n", identity_matrix)

Output

Following is the output of above code −

Identity Matrix:
 [[1. 0. 0. 0.]
 [0. 1. 0. 0.]
 [0. 0. 1. 0.]
 [0. 0. 0. 1.]]

Example : Specifying Number of Columns

Using the M parameter in numpy.eye(), we can specify a different number of columns than rows, allowing us to generate non-square matrices. This is useful in applications where we need a identity matrix with specified dimensions.

In the following example, we generate a 5x3 identity matrix using numpy.eye() −

import numpy as np
non_square_matrix = np.eye(5, 3)
print("Matrix with diagonal ones:\n", non_square_matrix)

Output

Following is the output of the above code −

Matrix with diagonal ones:
 [[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]
 [0. 0. 0.]
 [0. 0. 0.]]

Example : Shifting the Diagonal in 'numpy.eye()'

The k parameter in numpy.eye() allows us to shift the diagonal. By default, the diagonal with ones is the main diagonal (i.e., k=0), but we can specify positive or negative values for k to shift the diagonal up or down, respectively.

'k' with Positive Integer

If we set k to a positive value, the diagonal shifts up, placing the ones above the main diagonal. Here, we have generated a 4x4 matrix with the diagonal shifted up by one position (i.e., k=1) −

import numpy as np
shifted_diagonal_matrix = np.eye(4, k=1)
print("Matrix with diagonal shifted up:\n", shifted_diagonal_matrix)

Output

Following is the output of the above code −

Matrix with diagonal shifted up:
 [[0. 1. 0. 0.]
 [0. 0. 1. 0.]
 [0. 0. 0. 1.]
 [0. 0. 0. 0.]]

'k' with Negative Integer

If we set k to a negative value, the diagonal shifts down, placing the ones below the main diagonal. Here, we have generated a 5x5 matrix with the diagonal shifted down by -2 position (i.e., k=-2) −

import numpy as np
shifted_diagonal_matrix = np.eye(5, k=-2)
print("Matrix with diagonal shifted down : \n", shifted_diagonal_matrix)

Output

Following is the output of the above code −

Matrix with diagonal shifted down : 
 [[0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0.]
 [1. 0. 0. 0. 0.]
 [0. 1. 0. 0. 0.]
 [0. 0. 1. 0. 0.]]

Example : Specifying Data Type in 'eye()'

The numpy.eye() function allows us to specify the data type of the output array using the dtype parameter. We can change this to any valid data type, such as int, complex. By default, it returns an array of float data type.

In the following example, we have generated a 3x3 integer identity matrix by setting the dtype parameter to int −

import numpy as np
int_identity_matrix = np.eye(3, dtype=int)
print("Integer Identity Matrix:\n", int_identity_matrix)

Output

Following is the output of the above code −

Integer Identity Matrix:
 [[1 0 0]
  [0 1 0]
  [0 0 1]]

Example : Complex Identity Matrix with 'eye()'

We can also create complex identity matrices by specifying the dtype parameter as complex. This is useful in applications involving complex numbers, such as signal processing or quantum mechanics.

In the following example, we create a 3x3 complex identity matrix −

import numpy as np
complex_identity_matrix = np.eye(3, dtype=complex)
print("Complex Identity Matrix:\n", complex_identity_matrix)

Output

Following is the output of the above code −

Complex Identity Matrix:
 [[1.+0.j 0.+0.j 0.+0.j]
  [0.+0.j 1.+0.j 0.+0.j]
  [0.+0.j 0.+0.j 1.+0.j]]