numpy中元素为Fraction类型的矩阵求逆报错问题咨询

Great question! This isn't a bug in NumPy—it's a deliberate design choice tied to how NumPy's linear algebra operations are implemented. Let's break this down:

Why Multiplication Works (@ Operator / np.dot) #

When you use @ or np.dot on a NumPy array filled with Fraction objects, NumPy treats the array as having an object dtype (since Fraction is a Python class, not a native NumPy numeric type). For object dtype arrays, NumPy falls back to executing operations at the Python level: it iterates over each element, calls the Fraction class's __mul__ and __add__ methods, and assembles the result. This is slower than native numeric operations, but it works because Fraction supports the necessary arithmetic operations.

Why np.linalg.inv() Fails #

The np.linalg module (including inv()) relies heavily on optimized low-level libraries like BLAS and LAPACK for performance. These libraries are written in Fortran/C and only work with native numeric types (floats, doubles, complex numbers). They can't handle Python objects like Fraction because they don't understand how to perform linear algebra operations on arbitrary Python classes.

When you call np.linalg.inv() on an object dtype array, NumPy tries to find a compatible implementation in its ufuncs (universal functions), but there's no loop that can handle Fraction objects—hence the TypeError: No loop matching the specified signature and casting was found for ufunc inv.

Solutions for Inverting a Fraction Matrix #

If you need an exact inverse using rational numbers, here are two reliable approaches:

1. Use SymPy for Exact Symbolic Computation #

SymPy is designed for precise symbolic and rational arithmetic, and it handles matrices with rational elements seamlessly:

import numpy as np
from fractions import Fraction as F
import sympy as sp

# Create your original NumPy array
c = np.array([[F(2),F(-1), F(-1)],[F(3),F(4), F(-2)],[F(3),F(-2), F(4)]])

# Convert to a SymPy Matrix
sym_matrix = sp.Matrix(c.tolist())

# Compute the inverse (exact rational values)
sym_inv = sym_matrix.inv()

# Convert back to a NumPy array of Fractions
np_inv = np.array(sym_inv.tolist(), dtype=object)

print(np_inv)

2. Manual Calculation (For Small Matrices) #

For small matrices, you can compute the inverse manually using the adjugate matrix method:

• Calculate the determinant of the matrix (you can use SymPy to compute this with Fraction support, or implement a recursive determinant function for object dtype arrays).
• Compute the adjugate matrix (transpose of the cofactor matrix).
• Divide each element of the adjugate matrix by the determinant to get the inverse.

This is more work, but it's feasible for small matrices like your 3x3 example.

Key Takeaway #

NumPy is optimized for fast numerical computations with native types. For exact rational arithmetic and linear algebra operations, tools like SymPy are a better fit. The fact that multiplication works for object dtype arrays is a convenience, but it's not indicative of full linear algebra support for Python objects in np.linalg.

内容的提问来源于stack exchange，提问作者peter.petrov