Element wise Operations More Complex Examples

Element-wise operations in NumPy provide a powerful and efficient way to perform mathematical and logical operations on arrays without needing explicit loops. By utilizing NumPy’s vectorized operations, you can operate on entire arrays at once, speeding up your code and simplifying complex mathematical or logical tasks.

In this post, we will dive deeper into more complex element-wise operations, including:

1. Applying Mathematical Functions: Using built-in mathematical functions to perform calculations element-wise.
2. Logical Element-wise Operations: Using logical comparisons and operations to perform condition-based array manipulations.
3. Conditional Operations: Performing operations that depend on conditions, such as selecting values based on a threshold.
4. Combining Mathematical and Logical Operations: Combining both mathematical and logical operations to achieve more advanced manipulations.

We’ll explore these concepts using practical examples to see how you can efficiently manipulate arrays in NumPy.

1. Applying Mathematical Functions to Arrays

NumPy provides a wide array of mathematical functions that can be applied to arrays element-wise. These functions allow you to perform operations such as square roots, trigonometric functions, exponential functions, and many more.

Example: Square Root

Let’s start by applying a mathematical function to an array. Here, we will compute the square root of each element in the array using the np.sqrt() function.

import numpy as np

arr = np.array([1, 4, 9, 16])

# Square root of each element
sqrt_arr = np.sqrt(arr)
print(sqrt_arr)

Output:

[1. 2. 3. 4.]

In this example, we have used np.sqrt() to calculate the square root of each element in the array. Notice how the operation is applied to each individual element of the array, and the result is another array of the same shape.

Example: Exponentiation

Another common mathematical operation is exponentiation. In NumPy, you can use np.exp() to calculate the exponent of each element in an array.

arr = np.array([1, 2, 3, 4])

# Apply the exponential function to each element
exp_arr = np.exp(arr)
print(exp_arr)

Output:

[ 2.71828183  7.3890561  20.08553692 54.59815003]

In this example, we have applied the exponential function to each element, resulting in a new array where each element is the exponential of the corresponding element in the original array.

Example: Trigonometric Functions

You can also apply trigonometric functions like np.sin(), np.cos(), and np.tan() element-wise. Let’s calculate the sine of each element in an array.

arr = np.array([0, np.pi/2, np.pi])

# Calculate the sine of each element
sin_arr = np.sin(arr)
print(sin_arr)

Output:

[0. 1. 0.]

In this example, the sine of each element (which represents angles in radians) is calculated.

Example: Logarithmic Functions

Another example of a mathematical operation is taking the natural logarithm of each element using np.log().

arr = np.array([1, np.e, np.e**2])

# Calculate the natural logarithm of each element
log_arr = np.log(arr)
print(log_arr)

Output:

[0. 1. 2.]

Here, the natural logarithm is calculated for each element of the array. Notice that the logarithm of 1 is 0, the logarithm of e is 1, and the logarithm of e^2 is 2.

---

2. Logical Element-wise Operations

Element-wise logical operations can be performed using NumPy’s comparison operators and logical functions. These operations allow you to perform conditional checks across the entire array.

Example: Comparing Arrays Element-wise

Let’s take two arrays and compare them element-wise to see which elements in the first array are less than the corresponding elements in the second array.

arr1 = np.array([10, 20, 30])
arr2 = np.array([15, 25, 20])

# Compare arr1 and arr2 element-wise
result = arr1 < arr2
print(result)

Output:

[ True  True False]

In this case:

• The first comparison is 10 < 15, which is True.
• The second comparison is 20 < 25, which is True.
• The third comparison is 30 < 20, which is False.

The result is a boolean array where each element is the result of the comparison.

Example: Using Logical AND and OR

NumPy also provides logical operations such as logical AND (np.logical_and()) and logical OR (np.logical_or()) that can be applied element-wise across arrays.

arr1 = np.array([True, False, True])
arr2 = np.array([False, False, True])

# Logical AND
result_and = np.logical_and(arr1, arr2)
print(result_and)

# Logical OR
result_or = np.logical_or(arr1, arr2)
print(result_or)

Output:

Logical AND: [False False  True]
Logical OR:  [ True False  True]

In this example:

• The logical AND between the first and second arrays is True only when both elements are True.
• The logical OR is True when at least one of the elements is True.

These logical operations are useful when you need to apply multiple conditions across an array.

---

3. Conditional Operations

In some cases, you might want to perform an operation on an array based on a specific condition, such as replacing values that meet a certain threshold.

Example: Conditional Replacement Using np.where()

The np.where() function allows you to replace values in an array based on a condition. For instance, let’s replace all values in an array that are less than 10 with 0.

arr = np.array([5, 12, 7, 20, 9])

# Replace values less than 10 with 0
result = np.where(arr < 10, 0, arr)
print(result)

Output:

[ 0 12  0 20  0]

In this example, the condition arr < 10 is checked element-wise. Wherever the condition is True, the corresponding element is replaced with 0. Otherwise, the original value is retained.

Example: Applying Multiple Conditions

You can also apply multiple conditions using logical operators and np.where(). Let’s replace values in an array based on two conditions.

arr = np.array([5, 12, 7, 20, 9])

# Replace values less than 10 with -1, and values greater than or equal to 10 with 1
result = np.where(arr < 10, -1, 1)
print(result)

Output:

[-1  1 -1  1 -1]

In this case, values less than 10 are replaced with -1, and values greater than or equal to 10 are replaced with 1.

---

4. Combining Mathematical and Logical Operations

Often, you will need to combine both mathematical and logical operations to solve more complex problems. This allows you to create advanced filters, transformations, or conditions in your data.

Example: Finding Elements Based on a Condition and Performing an Operation

Let’s combine a mathematical operation with a condition. For instance, we can square the elements of an array that are greater than 10 and keep the others as they are.

arr = np.array([5, 12, 7, 20, 9])

# Square elements greater than 10, keep others as they are
result = np.where(arr > 10, arr**2, arr)
print(result)

Output:

[  5 144   7 400   9]

In this example:

• The values greater than 10 (12 and 20) are squared.
• The rest of the values are left unchanged.

Example: Applying Conditional Math Operations Based on Multiple Criteria

Let’s say we want to apply a conditional operation that checks whether elements are divisible by 2, and if they are, squares them. Otherwise, we subtract 5 from the element.

arr = np.array([5, 12, 7, 20, 9])

# If element is divisible by 2, square it. Otherwise, subtract 5.
result = np.where(arr % 2 == 0, arr**2, arr - 5)
print(result)

Output:

[  0 144   2 400   4]

In this example:

• For even numbers (divisible by 2), we squared the number (12 becomes 144, 20 becomes 400).
• For odd numbers, we subtracted 5 from the number (5 becomes 0, 7 becomes 2, 9 becomes 4).