NumPy - Creating Universal Functions (ufunc)

Creating Universal Functions

You can create ufuncs using the numpy.frompyfunc() function, which takes a Python function and converts it into a ufunc that can operate on NumPy arrays.

Creating a Custom ufunc

A custom ufunc in NumPy is a user-defined universal function that you create to perform element-wise operations on arrays, just like built-in ufuncs (e.g., addition, multiplication). Custom ufuncs allow you to extend NumPy's functionality with your own specialized operations.

To create a custom ufunc, you need to define a standard Python function that performs the desired operation. Then, you can use the numpy.frompyfunc function to convert it into a ufunc.

The numpy.frompyfunc() function requires three arguments: the Python function, the number of input arguments, and the number of output arguments.

Example: Creating a Simple Custom ufunc

In this example, we create a custom ufunc to perform element-wise multiplication of two arrays −

import numpy as np

# Define a Python function for multiplication
def multiply(x, y):
   return x * y

# Create a custom ufunc from the Python function
multiply_ufunc = np.frompyfunc(multiply, 2, 1)

# Define two arrays
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

# Use the custom ufunc to multiply the arrays
result = multiply_ufunc(a, b)

print(result)

Following is the output obtained −

[4 10 18]

Example: Custom ufunc for String Concatenation

In this example, we create a custom ufunc to perform element-wise string concatenation in NumPy −

import numpy as np

# Define a Python function for string concatenation
def concatenate_strings(x, y):
   return x + y

# Create a custom ufunc from the Python function
concatenate_ufunc = np.frompyfunc(concatenate_strings, 2, 1)

# Define two arrays of strings
a = np.array(["Hello", "Good"])
b = np.array([" World", " Morning"])

# Use the custom ufunc to concatenate the strings
result = concatenate_ufunc(a, b)

print(result)

This will produce the following result −

['Hello World' 'Good Morning']

Advantages of Custom ufuncs

Creating custom ufuncs provides various advantages, such as −

• Performance: Custom ufuncs are optimized for element-wise operations, providing performance benefits over standard Python loops.
• Reusability: Once created, custom ufuncs can be reused across different projects and applications.
• Flexibility: Custom ufuncs allow you to implement specialized operations that are not available in NumPy's built-in functions.
• Integration: Custom ufuncs can be easily integrated with existing NumPy arrays and operations.

Handling Multiple Outputs in Custom ufuncs

Custom ufuncs can also handle multiple outputs. To create a ufunc with multiple outputs, you need to specify the number of output arguments when using the numpy.frompyfunc() function.

Example

In this example, we create a custom ufunc that returns the quotient and remainder of division −

import numpy as np

# Define a Python function for division that returns quotient and remainder
def divide_and_remainder(x, y):
   return x // y, x % y

# Create a custom ufunc from the Python function
divide_ufunc = np.frompyfunc(divide_and_remainder, 2, 2)

# Define two arrays
a = np.array([10, 20, 30])
b = np.array([3, 5, 7])

# Use the custom ufunc to get quotient and remainder
quotient, remainder = divide_ufunc(a, b)

print("Quotient:", quotient)
print("Remainder:", remainder)

Following is the output of the above code −

Quotient: [3 4 4]
Remainder: [1 0 2]