Mathematical Operations with NumPy
NumPy supports element-wise arithmetic, broadcasting, reductions, and linear algebra on arrays. Performance depends on data size, dtype, memory layout, temporary allocations, and hardware; benchmark representative work rather than assuming every array expression is faster.
1. Element-wise Operations
Element-wise operations are the most basic type of mathematical operations in NumPy, where operations are applied to each element of an array individually.
1.1 Basic Arithmetic Operations
You can perform basic arithmetic operations such as addition, subtraction, multiplication, and division directly on NumPy arrays. These operations are automatically applied element-wise.
import numpy as np
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
# Element-wise addition
add_result = arr1 + arr2
print("Addition:", add_result)
# Element-wise multiplication
mul_result = arr1 * arr2
print("Multiplication:", mul_result)
# Element-wise subtraction
sub_result = arr1 - arr2
print("Subtraction:", sub_result)
# Element-wise division
div_result = arr1 / arr2
print("Division:", div_result)
1.2 Unary Operations
NumPy provides functions for performing operations on individual elements of an array, such as computing the square root, exponentiation, or absolute value.
arr = np.array([1, 4, 9])
# Square root of each element
sqrt_result = np.sqrt(arr)
print("Square root:", sqrt_result)
# Exponentiation of each element
exp_result = np.exp(arr)
print("Exponentiation:", exp_result)
# Absolute value of each element
abs_result = np.abs([-1, -2, -3])
print("Absolute value:", abs_result)
1.3 Vectorized Functions (UFuncs)
Universal functions, or ufuncs, are vectorized functions that perform element-wise operations on arrays. They are optimized for performance and can handle broadcasting, typecasting, and other advanced features.
arr = np.array([1, 2, 3])
# Using np.add (a ufunc) for element-wise addition
add_result = np.add(arr, 10)
print("Addition using ufunc:", add_result)
2. Matrix Operations
Matrix operations are a key feature in NumPy, enabling you to perform linear algebra computations efficiently.
2.1 Dot Product
The dot product is a fundamental operation in linear algebra. In NumPy, it can be performed using the np.dot() function or the @ operator.
matrix1 = np.array([[1, 2], [3, 4]])
matrix2 = np.array([[5, 6], [7, 8]])
# Dot product using np.dot
dot_result = np.dot(matrix1, matrix2)
print("Dot product:\n", dot_result)
# Dot product using @ operator
dot_result_alt = matrix1 @ matrix2
print("Dot product (alternative):\n", dot_result_alt)
2.2 Cross Product
The cross product is used to find a vector perpendicular to two given vectors in 3D space. It can be computed using np.cross().
vector1 = np.array([1, 0, 0])
vector2 = np.array([0, 1, 0])
# Cross product
cross_result = np.cross(vector1, vector2)
print("Cross product:", cross_result)
2.3 Matrix Multiplication
Matrix multiplication differs from element-wise multiplication and can be performed using np.matmul() or the @ operator.
matrix1 = np.array([[1, 2], [3, 4]])
matrix2 = np.array([[2, 0], [1, 3]])
# Matrix multiplication using np.matmul
matmul_result = np.matmul(matrix1, matrix2)
print("Matrix multiplication:\n", matmul_result)
# Matrix multiplication using @ operator
matmul_result_alt = matrix1 @ matrix2
print("Matrix multiplication (alternative):\n", matmul_result_alt)
2.4 Transpose and Inverse
NumPy can transpose matrices and compute inverses. For solving A x = b, prefer np.linalg.solve(A, b) to forming inv(A) @ b.
matrix = np.array([[1, 2], [3, 4]])
# Transpose of the matrix
transpose_result = np.transpose(matrix)
print("Transpose:\n", transpose_result)
# Inverse of the matrix
inverse_result = np.linalg.inv(matrix)
print("Inverse:\n", inverse_result)
3. Statistical Functions
NumPy provides a range of statistical functions to compute common descriptive statistics on arrays.
3.1 Mean and Median
The mean and median are available directly in NumPy. NumPy has no general mode reduction; use a frequency-based implementation appropriate to the dtype or a statistics library when a mode is required.
arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
# Mean of the array
mean_result = np.mean(arr)
print("Mean:", mean_result)
# Median of the array
median_result = np.median(arr)
print("Median:", median_result)
3.2 Variance and Standard Deviation
Variance and standard deviation measure spread. np.var() and np.std() use ddof=0 by default, so they compute population-style denominators. Set ddof=1 only when that sample estimate matches the statistical question.
# Variance of the array
variance_result = np.var(arr)
print("Variance:", variance_result)
# Standard deviation of the array
std_dev_result = np.std(arr)
print("Standard deviation:", std_dev_result)
3.3 Summation and Product
Summation and product functions allow you to compute the sum and product of array elements.
arr = np.array([1, 2, 3, 4, 5])
# Sum of all elements
sum_result = np.sum(arr)
print("Sum:", sum_result)
# Product of all elements
product_result = np.prod(arr)
print("Product:", product_result)
3.4 Axis-based Operations
Most statistical functions in NumPy allow you to specify an axis, enabling you to perform the operation along a specific axis of a multi-dimensional array.
matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# Sum along rows (axis 1)
sum_rows = np.sum(matrix, axis=1)
print("Sum along rows:", sum_rows)
# Sum along columns (axis 0)
sum_cols = np.sum(matrix, axis=0)
print("Sum along columns:", sum_cols)
4. Trigonometric Functions
NumPy includes a range of trigonometric functions that operate on arrays, including sin, cos, and tan.
Inputs are in radians. Values such as tan(pi / 2) are not a reliable infinity test because pi / 2 is only approximated in floating-point arithmetic.
arr = np.array([0, np.pi/2, np.pi])
# Sine of each element
sin_result = np.sin(arr)
print("Sine:", sin_result)
# Cosine of each element
cos_result = np.cos(arr)
print("Cosine:", cos_result)
# Tangent of each element
tan_result = np.tan(arr)
print("Tangent:", tan_result)
Conclusion
NumPy's mathematical operations are central to its power and efficiency in handling numerical data. From basic arithmetic and matrix operations to advanced statistical and trigonometric functions, NumPy provides the tools necessary for a wide range of mathematical computations. By mastering these operations, you can leverage NumPy to perform complex data analysis tasks with ease.
import numpy as np
matrix = np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
offset = np.array([10.0, 20.0, 30.0])
np.testing.assert_array_equal(matrix + offset, [[11, 22, 33], [14, 25, 36]])
np.testing.assert_array_equal(matrix.sum(axis=0), [5, 7, 9])
np.testing.assert_array_equal(matrix.mean(axis=1), [2, 5])
assert np.isclose(0.1 + 0.2, 0.3)