numpy.inner() in Python

Introduction to numpy.inner()

The numpy.inner() function in Python computes the inner product of two arrays. For 1-D arrays, it calculates the ordinary inner product, which is the sum of the products of corresponding elements. For higher-dimensional arrays, it performs a sum product over the last axes of the input arrays.

Basic Syntax

The syntax of the numpy.inner() function is:

numpy.inner(a, b)

Where a and b are the input arrays. If a and b are both 1-D arrays, it returns their inner product. If they are higher-dimensional arrays, it computes the sum product over the last axes.

Examples

1. Inner Product of Scalars

import numpy as np
product = np.inner(5, 4)
print("Inner Product of scalar values:", product)

Output:

20

2. Inner Product of 1-D Arrays

import numpy as np
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
product = np.inner(a, b)
print("Inner Product of 1-D arrays:", product)

Output:

32

3. Inner Product of Complex Numbers

import numpy as np
a = np.array([1 + 2j, 3 + 4j])
b = np.array([5 + 6j, 7 + 8j])
product = np.inner(a, b)
print("Inner Product of complex numbers:", product)

Output:

(70+80j)

4. Inner Product of 2-D Arrays

import numpy as np
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])
product = np.inner(a, b)
print("Inner Product of 2-D arrays:\n", product)

Output:

[[17 23]
 [39 53]]

Comparison with numpy.dot()

While both numpy.inner() and numpy.dot() compute inner products, there are differences in their behavior for higher-dimensional arrays. The numpy.inner() function performs a sum product over the last axes, whereas numpy.dot() performs matrix multiplication for 2-D arrays and a sum product over the last and second-to-last dimensions for higher-dimensional arrays. Understanding these differences is crucial when working with multi-dimensional data structures.

Handling Broadcasting

When the input arrays have different shapes, NumPy attempts to broadcast them to a common shape. Broadcasting allows NumPy to perform element-wise operations on arrays of different shapes, making the code more efficient and concise. However, it's important to ensure that the dimensions are compatible for broadcasting to avoid errors.

Performance Considerations

Using numpy.inner() is generally more efficient than using Python's built-in sum() function, especially for large arrays. NumPy's implementation is optimized for performance, making it suitable for numerical computations on large datasets.

Combining with numpy.moveaxis()

In some cases, you may need to rearrange the axes of the input arrays before computing the inner product. The numpy.moveaxis() function allows you to move axes of an array to new positions. This can be useful when the axes are not in the desired order for the inner product computation.

import numpy as np
a = np.zeros((2, 3, 4))
a_moved = np.moveaxis(a, 0, -1)
print(a_moved.shape)  # Output: (3, 4, 2)

Conclusion

The numpy.inner() function is a versatile tool for computing the inner product of two arrays. By understanding its syntax, usage, and differences from similar functions like numpy.dot(), you can effectively perform inner product computations in your numerical and scientific applications.