## Understanding Complex Numbers

Complex numbers are a fundamental concept of mathematics. They consist of the sum of a real part and an imaginary part.

The real part is usually denoted by *a*, and the imaginary part by *b*, then a complex number can be defined as *z = a + ib*. The *i* here represents the imaginary unit, which is equal to sqrt(-1).

Together, the real and imaginary parts form a two-dimensional coordinate system called the complex plane, where the real axis is the x-axis, and the imaginary axis is the y-axis.

## NumPy Real Function

The NumPy Real function returns the real part of a complex number. The syntax is `np.real(z)`

, where `np`

is the import statement for NumPy, and `z`

is the complex number.

An important thing to note is that if the input to the function is not a complex number, it will be returned as is, and not be converted to a complex number.

### Syntax of the NumPy Real Function

The syntax for the NumPy Real function is straightforward: `np.real(z)`

. Here, `z`

can be a single complex number, an array of complex numbers, or a multi-dimensional array.

### Working with the NumPy Real Function

### Following is an example code that demonstrates the NumPy Real function in action:

```
import numpy as np
#example of a complex number. z= 4 + 3j
#Returning the real part of the complex number
print(np.real(z))
```

Output: 4.0

In the example, the NumPy Real function returned the real part of the complex number (`z`

), which is 4.0. We are also allowed to use the NumPy Real function with arrays of complex numbers, and the output can be an array of real numbers.

## NumPy Imag Function

The NumPy Imag function, just like NumPy Real, only returns a different part of the complex number – the imaginary part.

The NumPy Imag function is a mathematical function allowing for the extraction of the imaginary part of a complex number (be it one element or an array). The syntax for the NumPy Imag function is `np.imag(z)`

, where `np`

is the import statement for NumPy, and `z`

is the complex number.

Just like the case of NumPy Real, if the input to the function is not a complex number, it will be returned as is, and not be converted to a complex number.

### Syntax of the NumPy Imag Function

The syntax for the NumPy Imag function is as follows: `np.imag(z)`

, where `z`

can be a single complex number, an array of complex numbers, or a multi-dimensional array.

### Working with the NumPy Imag Function

### Following is an example code that demonstrates the NumPy Imag function in action:

```
import numpy as np
#example of a complex number. z= 4 + 3j
#Returning the imaginary part of the complex number
print(np.imag(z))
```

Output: 3.0

As the output suggests, the NumPy Imag function returns 3.0, representing the imaginary part of the input complex number.

## Conclusion

The NumPy Real and Imag functions are vital features of the NumPy package for Python. Both these functions allow for efficient handling and manipulation of complex numbers for applications in science, physics, engineering, and many other fields where numerical computation is necessary.

By understanding the syntax and usage of these functions, researchers and practitioners can quickly analyze, perform mathematical operations, and extract the desired information from sets of complex numbers.

## Working with NumPy Real and NumPy Imag

### Comparison of Functions

NumPy Real and NumPy Imag are two mathematical functions of NumPy that operate on complex numbers. While NumPy Real returns a complex number’s real part, NumPy Imag functions return its imaginary part.

Both functions share a common syntax: `np.real(z)`

and `np.imag(z)`

. They produce a scalar or an array, respectively, depending on the input parameter.

The major difference between these two functions is that NumPy Real returns a float or an array of floats containing the real component of the complex number, while NumPy Imag returns the value of the imaginary component of the complex number.

### Examples of Using Both Functions with Different Inputs and Data Types

The code examples in this section demonstrate how to use NumPy Real and NumPy Imag for various input parameters and data types.

#### Example 1: Using the NumPy real function with a single complex number

```
import numpy as np
z = 5 + 3j
print(np.real(z))
```

Output: 5.0

In this code example, we pass in a single complex number, which is `z = 5 + 3j`

. NumPy Real returns the real part of the complex number, which is 5.0.

#### Example 2: Using the NumPy imag function with a single complex number

```
import numpy as np
z = 5 + 3j
print(np.imag(z))
```

Output: 3.0

In this code example, we pass in a single complex number `z = 5 + 3j`

. NumPy Imag returns the imaginary part of the complex number, which is 3.0.

#### Example 3: Using the NumPy real function with an array of complex numbers

```
import numpy as np
z = np.array([2+3j, 4+5j, 6+7j])
print(np.real(z))
```

Output: [2. 4. 6.]

In this code example, we pass in an array of complex numbers `z`

containing three complex numbers. The NumPy Real function returns an array containing the real part of each element in the array.

#### Example 4: Using the NumPy imag function with an array of complex numbers

```
import numpy as np
z = np.array([2+3j, 4+5j, 6+7j])
print(np.imag(z))
```

Output: [3. 5. 7.]

In this code example, we pass in an array of complex numbers `z`

containing three complex numbers. The NumPy Imag function returns an array containing the imaginary part of each element in the array.

#### Example 5: Using the NumPy real and imag functions with non-complex numbers

```
import numpy as np
z = np.array([-1.5, 2, 3.5, 4.2])
print(np.real(z))
print(np.imag(z))
```

Output: [-1.5 2. 3.5 4.2]

Output: [0. 0. 0. 0.]

In this code example, we pass in an array of non-complex numbers. Since the input is not a complex number, NumPy Real and NumPy Imag functions return the array of non-complex numbers as is.

### Summary

NumPy is a powerful package for scientific computing in Python, which can handle both real and complex numbers. The NumPy Real and NumPy Imag functions are two key features of NumPy that operate on complex numbers.

NumPy Real returns the real part of a complex number, while NumPy Imag returns the imaginary part of a complex number. Both functions have a common syntax, `np.real(z)`

and `np.imag(z)`

, respectively, producing a scalar or an array, depending on the input parameter.

When the input to these functions is non-complex numbers, they return the array as is. These functions are important tools for solving scientific and mathematical problems, and their usefulness is derived from their ability to extract essential data from complex numbers.

In this article, we explored two key features of NumPy, namely NumPy Real and NumPy Imag functions, and discussed how they work with complex numbers. The NumPy Real function returns the real part of a complex number, while NumPy Imag returns its imaginary part.

Both functions share a common syntax, and produce a scalar or an array, depending on the input parameter. These functions are critical tools for scientific and mathematical computations, and their usefulness is derived from their ability to extract essential data from complex numbers.

By understanding their syntax and applications, we can perform efficient analysis, computation, and mathematical operations on datasets involving complex numbers.