ufunc performance considerations in NumPy - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of ufunc with broadcasting

What is the output of this code snippet using NumPy ufunc broadcasting?

NumPy

import numpy as np
arr1 = np.array([1, 2, 3])
arr2 = np.array([[10], [20], [30]])
result = np.add(arr1, arr2)
print(result)

A

[[11 12 13]
 [21 22 23]
 [31 32 33]]

B

[[10 11 12]
 [20 21 22]
 [30 31 32]]

C

[[11 21 31]
 [12 22 32]
 [13 23 33]]

D

[[1 2 3]
 [10 20 30]]

💡 Hint

Remember how broadcasting works when adding arrays of different shapes.

NumPy broadcasts arr1 shape (3,) to (1,3) and arr2 shape (3,1) to (3,3). Adding them results in a 3x3 array where each element is sum of corresponding broadcasted elements.

❓ data_output

intermediate

Number of elements processed by ufunc

Given a NumPy ufunc applied on arrays of shapes (4, 1, 3) and (1, 5, 3), how many elements does the ufunc process in total?

A 60

B 12

C 20

D 180

💡 Hint

Calculate the broadcasted shape first, then multiply dimensions.

Broadcasting shapes (4,1,3) and (1,5,3) results in (4,5,3). Total elements = 4*5*3 = 60.

🔧 Debug

advanced

Identify the cause of slow ufunc performance

Why does this NumPy ufunc operation run slower than expected? Code: import numpy as np large_array = np.arange(10**7) result = np.sin(large_array) Options:

NumPy

import numpy as np
large_array = np.arange(10**7)
result = np.sin(large_array)

A The array is too large for memory, causing swapping and slow performance.

B The array is not contiguous in memory, causing cache misses.

C The ufunc np.sin is not vectorized and runs element-wise in Python loop.

D Using np.sin on integers causes implicit type conversion slowing down the ufunc.

💡 Hint

Check the data type of the input array and how ufuncs handle types.

np.arange creates an integer array. np.sin expects floats, so it converts each element to float before computing, adding overhead.

🚀 Application

advanced

Optimizing ufunc calls for large data

You want to apply np.exp to a very large array efficiently. Which approach is best to improve performance?

A Convert the array to Python list and use a for loop with math.exp on each element.

B Split the array into smaller chunks and apply np.exp on each chunk sequentially.

C Use np.vectorize to create a vectorized version of math.exp and apply it.

D Apply np.exp directly on the large array without any changes.

💡 Hint

Consider memory usage and cache efficiency for large arrays.

Processing large arrays in smaller chunks fits better in cache and memory, improving performance and avoiding memory issues.

🧠 Conceptual

expert

Understanding ufunc inner loops and performance

Which statement best explains why NumPy ufuncs achieve high performance compared to Python loops?

A Ufuncs run Python loops faster by using multiple threads automatically.

B Ufuncs convert arrays to Python lists internally to speed up element-wise operations.

C Ufuncs use compiled C code with optimized inner loops that operate directly on memory buffers.

D Ufuncs use just-in-time compilation to convert Python code to machine code at runtime.

💡 Hint

Think about how NumPy is implemented under the hood.

NumPy ufuncs are implemented in C with tight loops that operate on raw memory, avoiding Python overhead and enabling vectorized operations.