Python - Universal Functions (ufuncs)

Universal Functions (ufuncs) in Python

Introduction

Universal functions, or ufuncs, are a core feature of NumPy. They are fast, element-wise operations implemented in compiled C code that provide high-performance function application over NumPy arrays. Ufuncs are used for a wide range of mathematical, logical, and bitwise operations.

This guide explores the depth and flexibility of ufuncs, including:

• Understanding what ufuncs are
• Types of ufuncs (unary, binary)
• Common built-in ufuncs
• Advanced usage with broadcasting
• Creating custom ufuncs
• Looping and type signatures
• Using ufunc methods
• Real-world examples and performance comparisons

What is a Universal Function (ufunc)?

A ufunc is a function that operates on ndarrays in an element-by-element fashion, supporting array broadcasting, type casting, and many other standard features.

Basic Concept

import numpy as np

x = np.array([1, 2, 3])
y = np.array([4, 5, 6])

result = np.add(x, y)
print(result)

Behind the Scenes

Functions like np.add(), np.multiply(), np.sin() are ufuncs. These are much faster than Python for-loops and support vectorization.

Types of ufuncs

Unary ufuncs (Single Input)

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

print(np.sin(x))
print(np.sqrt([1, 4, 9]))
print(np.absolute([-1, -2, 3]))

Binary ufuncs (Two Inputs)

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

print(np.add(a, b))
print(np.subtract(a, b))
print(np.multiply(a, b))
print(np.divide(a, b))

Ufuncs vs Regular Functions

Performance Comparison

import time

arr = np.arange(1e6)

# Using list comprehension
start = time.time()
squared_list = [x**2 for x in arr]
print("List time:", time.time() - start)

# Using ufunc
start = time.time()
squared_ufunc = np.square(arr)
print("Ufunc time:", time.time() - start)

Common Mathematical Ufuncs

Arithmetic

np.add(x, y)
np.subtract(x, y)
np.multiply(x, y)
np.divide(x, y)
np.floor_divide(x, y)
np.mod(x, y)
np.power(x, y)

Trigonometric

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

print(np.sin(x))
print(np.cos(x))
print(np.tan(x))

Exponents and Logarithms

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

print(np.exp([0, 1, 2]))
print(np.log(x))
print(np.log10(x))
print(np.log2(x))

Rounding

x = np.array([1.2, 2.5, 3.7])

print(np.floor(x))
print(np.ceil(x))
print(np.rint(x))

Comparison Ufuncs

x = np.array([1, 2, 3])
y = np.array([3, 2, 1])

print(np.greater(x, y))
print(np.less(x, y))
print(np.equal(x, y))
print(np.not_equal(x, y))

Logical Ufuncs

a = np.array([True, False, True])
b = np.array([False, False, True])

print(np.logical_and(a, b))
print(np.logical_or(a, b))
print(np.logical_not(a))

Bitwise Ufuncs

x = np.array([0, 1, 2])
y = np.array([2, 2, 2])

print(np.bitwise_and(x, y))
print(np.bitwise_or(x, y))
print(np.bitwise_xor(x, y))

Broadcasting with Ufuncs

Broadcasting Rules

a = np.array([1, 2, 3])
b = 2

print(np.multiply(a, b))  # Broadcast scalar to array

Broadcasting 1D and 2D Arrays

m = np.array([[1], [2], [3]])
n = np.array([10, 20, 30])

result = np.add(m, n)
print(result)

Reduce, Accumulate, and Outer

Reduce

x = np.arange(1, 5)
print(np.add.reduce(x))  # 1 + 2 + 3 + 4

Accumulate

print(np.add.accumulate(x))  # [1, 3, 6, 10]

Outer

print(np.multiply.outer(x, x))

Creating Custom Ufuncs

Using frompyfunc

def custom_add(x, y):
    return x + y + 1

ufunc = np.frompyfunc(custom_add, 2, 1)
result = ufunc([1, 2, 3], [4, 5, 6])
print(result)

Using vectorize

vec_add = np.vectorize(lambda x, y: x + y + 1)
print(vec_add([1, 2], [3, 4]))

Performance Note

np.frompyfunc and np.vectorize create ufunc-like behavior in Python but are not as fast as built-in ufuncs since they operate in Python space.

Type Casting and Type Signatures

Checking Types

print(np.add.types)

Using Signature in vectorize

def add_str(x, y):
    return str(x) + str(y)

vec = np.vectorize(add_str, otypes=[str])
print(vec([1, 2, 3], [4, 5, 6]))

Advanced Ufunc Methods

reduceat

x = np.arange(10)
print(np.add.reduceat(x, [0, 5, 7]))  # sum from [0:5], [5:7], [7:]

at (in-place operation)

x = np.array([1, 2, 3, 4, 5])
np.add.at(x, [0, 1, 1], [10, 20, 30])
print(x)  # Modifies in-place

outer

x = np.array([1, 2, 3])
y = np.array([4, 5])

print(np.subtract.outer(x, y))

Real-World Examples

Image Thresholding

from PIL import Image

img = Image.open("grayscale.jpg").convert("L")
arr = np.array(img)

thresholded = np.where(arr > 128, 255, 0)
Image.fromarray(thresholded.astype(np.uint8)).save("thresholded.jpg")

Financial Data: Returns

prices = np.array([100, 105, 103, 107])
returns = np.divide(np.diff(prices), prices[:-1])
print(returns)

Standardization

data = np.random.rand(1000)
standardized = (data - np.mean(data)) / np.std(data)
print(standardized[:5])

Tips and Best Practices

• Always prefer ufuncs over Python loops for speed
• Use built-in ufuncs whenever possible
• Broadcasting makes operations simpler and cleaner
• Use reduce, accumulate, and outer for custom aggregations
• Use np.vectorize and frompyfunc to create your own ufuncs when needed
• Leverage ufunc methods like reduceat and at for advanced slicing and performance

Universal functions are one of the most powerful features of NumPy. They combine performance, convenience, and flexibility, making them indispensable for numerical computing. With support for broadcasting, advanced method chaining, and the ability to create custom functions, ufuncs provide a robust foundation for data analysis, scientific modeling, and high-performance applications.

By mastering ufuncs, you move beyond simple array manipulations and gain the ability to write concise, readable, and fast numerical Python code.