scipy.optimize.

newton#

scipy.optimize.newton(func, x0, fprime=None, args=(), tol=1.48e-08, maxiter=50, fprime2=None, x1=None, rtol=0.0, full_output=False, disp=True)[source]#

使用牛顿-拉夫森（或割线或哈雷）方法找到实数或复数函数的根。

在给定附近标量起始点 x0 的情况下，找到标量值函数 func 的根。如果提供了 func 的导数 fprime，则使用牛顿-拉夫森方法，否则使用割线方法。如果还提供了 func 的二阶导数 fprime2，则使用哈雷方法。

如果 x0 是一个包含多个元素的序列，则 newton 返回一个数组：从 x0 中的每个（标量）起始点开始的函数的根。在这种情况下，func 必须是矢量化的，以返回与第一个参数相同形状的序列或数组。如果提供了 fprime (fprime2)，则其返回也必须具有相同的形状：每个元素是 func 对其唯一变量的第一个（第二个）导数，在第一个参数的每个元素处进行评估。

newton 用于查找单个变量的标量值函数的根。对于涉及多个变量的问题，请参阅 root.

参数：:

func可调用: 需要找到其根的函数。它必须是一个形如 f(x,a,b,c...) 的单个变量的函数，其中 a,b,c... 是可以通过 args 参数传递的额外参数。
x0浮点数、序列或 ndarray: 根的初始估计值，应该位于实际根附近。如果不是标量，则 func 必须是矢量化的，并返回与第一个参数相同形状的序列或数组。
fprime可调用，可选: 函数的导数，当可用且方便时。如果为 None（默认），则使用割线方法。
args元组，可选: 要在函数调用中使用的额外参数。
tol浮点数，可选: 根值的容许误差。如果 func 是复数，建议使用更大的 tol，因为 x 的实部和虚部都对 |x - x0| 有贡献。
maxiter整数，可选: 最大迭代次数。
fprime2可调用，可选: 函数的二阶导数，当可用且方便时。如果为 None（默认），则使用正常的牛顿-拉夫森方法或割线方法。如果它不是 None，则使用哈雷方法。
x1浮点数，可选: 根的另一个估计值，应该位于实际根附近。如果未提供 fprime，则使用。
rtol浮点数，可选: 终止的容差（相对）。
full_output布尔值，可选: 如果 full_output 为 False（默认），则返回根。如果为 True 且 x0 为标量，则返回值为 (x, r)，其中 x 是根，r 是一个 RootResults 对象。如果为 True 且 x0 非标量，则返回值为 (x, converged, zero_der)（有关详细信息，请参见“返回值”部分）。
disp布尔值，可选: 如果为 True，如果算法未收敛，则引发 RuntimeError，错误消息包含迭代次数和当前函数值。否则，收敛状态将记录在 RootResults 返回对象中。如果 x0 不是标量，则忽略。注意：这与显示关系不大，但是，`disp` 关键字不能为了向后兼容而重命名。

返回值：:

root浮点数、序列或 ndarray: 估计函数为零的位置。
rRootResults，可选: 如果 full_output=True 且 x0 为标量，则存在。包含有关收敛的信息的对象。特别是，r.converged 如果例程收敛，则为 True。
converged布尔值 ndarray，可选: 如果 full_output=True 且 x0 非标量，则存在。对于向量函数，指示哪些元素成功收敛。
zero_der布尔值 ndarray，可选: 如果 full_output=True 且 x0 非标量，则存在。对于向量函数，指示哪些元素具有零导数。

另请参阅

root_scalar: 标量函数的求根解算器接口
root: 多输入、多输出函数的求根解算器接口

注释

牛顿-拉夫森方法的收敛速度为二次，哈雷方法为三次，割线方法为二次。这意味着如果函数表现良好，则估计根的实际误差在第 n 次迭代后的误差大约是第 (n-1) 步后的误差的平方（哈雷为三次方）。但是，这里使用的停止准则是步长，并且无法保证已找到根。因此，结果应得到验证。更安全的算法是 brentq、brenth、ridder 和 bisect，但它们都要求根首先在函数改变符号的区间内进行括号。brentq 算法推荐在已找到此类区间的单维问题中使用。

当 newton 与数组一起使用时，最适合以下类型的问题

初始猜测 x0 与根的距离都相对相同。
一些或所有额外的参数 args 也是数组，以便可以一起解决一类类似的问题。
初始猜测 x0 的大小大于 O(100) 个元素。否则，一个简单的循环可能与向量一样好或更好。

示例

>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy import optimize

>>> def f(x):
...     return (x**3 - 1)  # only one real root at x = 1

fprime 未提供，使用割线方法

>>> root = optimize.newton(f, 1.5)
>>> root
1.0000000000000016
>>> root = optimize.newton(f, 1.5, fprime2=lambda x: 6 * x)
>>> root
1.0000000000000016

仅提供 fprime，使用牛顿-拉夫森方法

>>> root = optimize.newton(f, 1.5, fprime=lambda x: 3 * x**2)
>>> root
1.0

同时提供 fprime2 和 fprime，使用哈雷方法

>>> root = optimize.newton(f, 1.5, fprime=lambda x: 3 * x**2,
...                        fprime2=lambda x: 6 * x)
>>> root
1.0

当我们想为一组相关的起始值和/或函数参数找到根时，我们可以将两者都作为输入数组提供

>>> f = lambda x, a: x**3 - a
>>> fder = lambda x, a: 3 * x**2
>>> rng = np.random.default_rng()
>>> x = rng.standard_normal(100)
>>> a = np.arange(-50, 50)
>>> vec_res = optimize.newton(f, x, fprime=fder, args=(a, ), maxiter=200)

以上相当于在 for 循环中分别针对 (x, a) 中的每个值求解，只是速度更快

>>> loop_res = [optimize.newton(f, x0, fprime=fder, args=(a0,),
...                             maxiter=200)
...             for x0, a0 in zip(x, a)]
>>> np.allclose(vec_res, loop_res)
True

绘制针对所有 a 值找到的结果

>>> analytical_result = np.sign(a) * np.abs(a)**(1/3)
>>> fig, ax = plt.subplots()
>>> ax.plot(a, analytical_result, 'o')
>>> ax.plot(a, vec_res, '.')
>>> ax.set_xlabel('$a$')
>>> ax.set_ylabel('$x$ where $f(x, a)=0$')
>>> plt.show()

../../_images/scipy-optimize-newton-1.png