numpy.exp2: Computing Powers of Two in Python

Welcome, coders! In our NumPy series, we have brought a useful function for you: numpy.exp2, which helps us compute the powers of two in Python. We will discuss it in detail, so keep following along.

Why Compute Powers of Two?

Computing Powers of Two” is like figuring out how many times you can double a number. You start with 1, then double it to get 2, double that to get 4, and so on.

This is important in computers because they work with 0s and 1s, which we call binary. Let’s say you have a computer with 4 slots for 0s and 1s, called bits. Each bit can either be 0 or 1, just like flipping a coin.

Now, if you have 4 of these bits, you can make different combinations of 0s and 1s. How many? Well, each bit gives you two choices (0 or 1), and you multiply those choices together for each bit. So, it’s like 2 multiplied by itself 4 times: 2^4=16.

Powers of Two

Knowing the powers of two helps us understand how much information computers can handle and how they store data efficiently. It is the foundation of computer memory and storage.

numpy.exp2() in Python

The NumPy library offers us a numpy.exp2() function, which allows us to easily compute powers of two. Let’s discuss its syntax and parameters.

Syntax:

The basic syntax of the given function is:

numpy.exp2(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Here is what these parameters mean:

  • x: It’s the input values. It can be both an array or a single value.
  • out: This is where the result is stored. If you provide it, it must match the inputs. If not provided, a new array is created.
  • where: It’s a condition applied to the input. Where the condition is true, the result will be set. Otherwise, the original value is kept.
  • dtype: This specifies the type of the output array. If you don’t give it, the type is guessed from the input.
  • casting: It controls what kind of data casting is allowed. The default is to keep it the same.
  • order: This determines how the array is laid out in memory. ‘C’ means row-major (last index varies fastest), ‘F’ means column-major (first index varies fastest), and ‘A’ (default) means any order.

Working:

  • The numpy.exp2() function returns 2 raised to the power of the elements of the input array.
  • If the input is scalar, the result will be scalar too.
  • The function supports broadcasting, meaning it can operate on arrays of different shapes and sizes.
  • You can control the data type of the output array using the dtype parameter.
  • The where parameter allows you to conditionally operate.

Using numpy.exp2() in Python

It will never be so clear until we see some real coding examples. Let’s see how we can use this function in Python with different inputs like scalar, 1D array, 2D array, where parameter, etc.

Example 1: Here we will compute the power of two for a scalar value.

import numpy as np

result = np.exp2(4)
print("2 raised to the power of 4:", result)

Output:

Example 1 Output

Example 2: When we work with arrays, the function returns powers of two for each element in an array.

import numpy as np

input_array = np.array([0, 3, 5, 7])
result = np.exp2(input_array)
print("Powers of two:", result)

Output:

Example 2 Output

Example 3: We can apply conditions to computations using the ‘where‘ parameter.

import numpy as np

input_array = np.array([0, 1, 2, 3])
condition = input_array < 2
result_array = np.exp2(input_array, where=condition)
print("Powers of two with condition:", result_array)

Output:

Example 3 Output

Example 4: Let’s see how we can use broadcasting with this function.

import numpy as np

scalar_value = 3
array_1d = np.array([0, 2, 4, 6])
array_2d = np.array([[1, 3], [5, 7]])
result_1d = np.exp2(scalar_value + array_1d)
print("Broadcasting scalar with 1D array:")
print(result_1d)
result_2d = np.exp2(scalar_value + array_2d)
print("\nBroadcasting scalar with 2D array:")
print(result_2d)

Output:

Example 4 Output

Conclusion

And that’s it for this one! We have learned about new things such as the importance of powers of two in computer memory organization. We have also seen the method in NumPy to calculate powers of two and discussed its syntax, parameters, and use cases.

If you enjoyed this one, don’t forget to check out:

Reference

https://numpy.org/doc/stable/reference/generated/numpy.exp2.html

Snigdha Keshariya
Snigdha Keshariya
Articles: 71