Sympy牛顿法中的ValueError解析与修正：符号变量与数值的正确使用

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

def newton_method(f, x0, tol, max_iter=100):
    # 确保使用全局定义的符号变量x进行求导和替换
    # x0 始终作为当前的数值近似值
    global x # 明确引用全局符号变量x

    iteration = 0
    while iteration < max_iter:
        # 1. f.subs(x, x0): 将符号表达式f中的符号x替换为当前数值x0
        # 2. f.diff(x): 对符号表达式f关于符号x求导
        # 3. .subs(x, x0): 将导数表达式中的符号x替换为当前数值x0
        # 4. .evalf(): 将结果从Sympy表达式转换为浮点数

        f_val = f.subs(x, x0).evalf()
        f_prime_val = f.diff(x).subs(x, x0).evalf()

        if f_prime_val == 0: # 避免除以零
            return None

        x_next = x0 - f_val / f_prime_val

        if abs(x0 - x_next) < tol:
            return x_next
        x0 = 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 - 21x - 5

# 牛顿法函数
def newton_method(f_expr, initial_guess, tol, max_iter=100):
    """
    使用牛顿法查找函数 f_expr 的根。
    f_expr: Sympy符号表达式
    initial_guess: 初始猜测值 (数值)
    tol: 容差
    max_iter: 最大迭代次数
    """
    # 确保使用全局定义的符号变量x进行求导和替换
    # initial_guess 始终作为当前的数值近似值
    global x 

    current_x = float(initial_guess) # 确保初始猜测是浮点数

    for _ in range(max_iter):
        f_val = f_expr.subs(x, current_x).evalf()
        f_prime_val = f_expr.diff(x).subs(x, current_x).evalf()

        if abs(f_prime_val) < 1e-10: # 避免除以零或接近零
            # print(f"Warning: Derivative is zero at x = {current_x}. Newton's method failed to converge.")
            return None

        next_x = current_x - f_val / f_prime_val

        if abs(current_x - next_x) < tol:
            return next_x

        current_x = next_x

    # print(f"Warning: Newton's method did not converge within {max_iter} iterations.")
    return None

# 查找实根
tolerance = 1e-5
real_roots = []
# 尝试不同的初始猜测，以找到不同的实根
# 注意：牛顿法对初始猜测敏感，可能需要更复杂的策略来找到所有根
for i in range(-10, 10): # 扩大初始猜测范围
    root = newton_method(p, i, tolerance)
    if root is not None:
        # 检查是否已找到此根（避免重复）
        is_new_root = True
        for existing_root in real_roots:
            if abs(root - existing_root) < tolerance:
                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)
    """
    global x
    # 将数值根转换为Sympy表达式，以便进行符号除法
    root_symbolic = sp.Rational(str(root_val)) # 转换为有理数，避免浮点精度问题
    divisor = x - root_symbolic

    # 使用sp.div进行多项式除法，返回商和余数
    quotient, remainder = sp.div(poly, divisor, x)

    # 如果余数很小（接近0），则认为可以整除
    if abs(remainder.subs(x, 0).evalf()) < 1e-9: # 检查余数是否为零多项式
        return quotient
    else:
        # 如果不能整除，可能是因为浮点精度问题，或者根不精确
        # 此时，简化表达式可能无法得到精确的多项式
        # 对于数值根，更稳健的方法是直接用sp.solve处理剩余多项式
        return poly / divisor # 仍返回简化后的表达式，但可能不是一个整数多项式

current_poly = p
found_roots_for_reduction = [] # 存储用于降阶的根，避免原始根列表被修改

# 逐步降低多项式
for r_root in real_roots:
    # 检查根是否已用于降阶，或者是否太接近现有根
    is_used = False
    for used_r in found_roots_for_reduction:
        if abs(r_root - used_r) < tolerance:
            is_used = True
            break
    if not is_used:
        current_poly = reduce_polynomial(current_poly, r_root)
        found_roots_for_reduction.append(r_root)

# 寻找剩余多项式的根（可能包含复根）
# 如果多项式被完全分解，current_poly可能变成一个常数或1
if not current_poly.is_constant():
    remaining_roots = sp.solve(current_poly, x)
    # 过滤掉已经找到的实根
    final_complex_roots = []
    for r in remaining_roots:
        if r.is_real:
            is_new_real_root = True
            for existing_root in real_roots:
                if abs(r - existing_root) < tolerance:
                    is_new_real_root = False
                    break
            if is_new_real_root:
                final_complex_roots.append(r)
        else:
            final_complex_roots.append(r)
else:
    final_complex_roots = []

print("剩余多项式的根 (可能包含复根):", [r.evalf(chop=True) for r in final_complex_roots])

# 结合所有根
all_roots = real_roots + [r.evalf(chop=True) for r in final_complex_roots if not r.is_real]
print("所有根 (实根和复根):", [round(r, 6) if r.is_real else r for r in all_roots])