SymPy 牛顿法 ValueError 深度解析与修正：符号变量与数值求值

import sympy as sp

x = sp.symbols('x') # 全局符号变量

def newton_method(f, x0, tol, max_iter=100):
    x = x0 # 局部变量 x 被重新赋值为数值 x0
    iteration = 0
    while iteration < max_iter:
        # 错误发生在这里：f.subs(x, x) 和 f.diff(x).subs(x, x)
        x_next = x - f.subs(x, x) / f.diff(x).subs(x, x)
        if abs(x - x_next) < tol:
            return x_next
        x = x_next
        iteration += 1
    return None

import sympy as sp

# 定义全局符号变量
x = sp.symbols('x')

# 定义多项式
p = x**5 + 11*x**4 - 21*x**3 - 10*x**2 - 21*x - 5

# 牛顿法函数
def newton_method(f_expr, current_guess, tol, max_iter=100):
    """
    使用牛顿法查找函数 f_expr 的根。
    f_expr: SymPy 表达式，表示要求根的函数。
    current_guess: 初始猜测值（数值）。
    tol: 容差。
    max_iter: 最大迭代次数。
    """
    # 确保 f_expr 是一个 SymPy 表达式，并且包含符号 x
    if not isinstance(f_expr, sp.Expr):
        raise TypeError("f_expr 必须是一个 SymPy 表达式。")
    if x not in f_expr.free_symbols:
        raise ValueError("f_expr 必须包含符号 'x'。")

    # 计算导数，导数本身也是一个 SymPy 表达式
    f_prime_expr = f_expr.diff(x)

    iteration = 0
    while iteration < max_iter:
        # 1. 将当前猜测值代入函数表达式 f_expr
        f_val = f_expr.subs(x, current_guess).evalf()
        # 2. 将当前猜测值代入导数表达式 f_prime_expr
        f_prime_val = f_prime_expr.subs(x, current_guess).evalf()

        # 避免除以零
        if abs(f_prime_val) < 1e-10:
            # print(f"Warning: Derivative is near zero at {current_guess}. Skipping this initial guess.")
            return None

        # 牛顿法迭代公式
        next_guess = current_guess - f_val / f_prime_val

        # 检查收敛性
        if abs(current_guess - next_guess) < tol:
            return next_guess

        current_guess = next_guess
        iteration += 1

    # 未收敛
    return None

# 查找实数根
tolerance = 1e-5  # 容差
real_roots = []

# 尝试不同的初始猜测值
for i in range(-10, 10): # 扩大搜索范围以提高找到根的可能性
    root = newton_method(p, float(i), tolerance)
    if root is not None:
        # 避免重复的根（由于浮点精度，可能需要近似比较）
        is_new_root = True
        for existing_root in real_roots:
            if abs(root - existing_root) < tolerance * 10: # 稍微放宽比较容差
                is_new_root = False
                break
        if is_new_root:
            real_roots.append(root)

print("找到的实数根:", [round(r, 6) for r in real_roots]) # 格式化输出

# 约简多项式以寻找复数根
def reduce_polynomial(poly, root_val):
    """
    将多项式 poly 除以 (x - root_val) 来约简。
    root_val 必须是数值。
    """
    # 将数值根转换为 SymPy 表达式，以便与 SymPy 多项式进行符号除法
    return sp.simplify(poly / (x - sp.Float(root_val)))

complex_roots = []
current_poly = p # 从原始多项式开始

# 依次约简多项式
for root_val in real_roots:
    try:
        current_poly = reduce_polynomial(current_poly, root_val)
        # print(f"约简后多项式 (移除根 {root_val}): {current_poly}")
    except sp.PolynomialDivisionFailed:
        # 如果约简失败，可能是因为根不精确，或者已经处理过
        continue
    except Exception as e:
        # print(f"约简多项式时发生错误: {e}")
        continue

# 求解约简后多项式的根（可能包含复数根）
# 如果约简后的多项式仍有高次项，sp.solve 可以直接求解
if current_poly != 0 and current_poly.is_polynomial(x):
    remaining_roots = sp.solve(current_poly, x)
    # 过滤掉已经找到的实数根，并添加复数根
    for r in remaining_roots:
        is_new_complex_root = True
        # 检查是否是已知的实数根（SymPy 的 solve 可能会返回已知的实数根）
        for known_real_root in real_roots:
            if abs(r - known_real_root) < tolerance * 10:
                is_new_complex_root = False
                break

        if is_new_complex_root:
            # 检查是否是重复的复数根
            is_duplicate_complex = False
            for existing_complex_root in complex_roots:
                if abs(r - existing_complex_root) < tolerance * 10:
                    is_duplicate_complex = True
                    break
            if not is_duplicate_complex:
                complex_roots.append(r)

print("找到的复数根 (可能包含重复或近似值):", [round(c, 6) if c.is_real else c for c in complex_roots])