ray
    Estimated location where function is zero.
r : `RootResults`, optional
    Present if ``full_output=True`` and `x0` is scalar.
    Object containing information about the convergence. In particular,
    ``r.converged`` is True if the routine converged.
converged : ndarray of bool, optional
    Present if ``full_output=True`` and `x0` is non-scalar.
    For vector functions, indicates which elements converged successfully.
zero_der : ndarray of bool, optional
    Present if ``full_output=True`` and `x0` is non-scalar.
    For vector functions, indicates which elements had a zero derivative.

See Also
--------
root_scalar : interface to root solvers for scalar functions
root : interface to root solvers for multi-input, multi-output functions

Notes
-----
The convergence rate of the Newton-Raphson method is quadratic,
the Halley method is cubic, and the secant method is
sub-quadratic. This means that if the function is well-behaved
the actual error in the estimated root after the nth iteration
is approximately the square (cube for Halley) of the error
after the (n-1)th step. However, the stopping criterion used
here is the step size and there is no guarantee that a root
has been found. Consequently, the result should be verified.
Safer algorithms are brentq, brenth, ridder, and bisect,
but they all require that the root first be bracketed in an
interval where the function changes sign. The brentq algorithm
is recommended for general use in one dimensional problems
when such an interval has been found.

When `newton` is used with arrays, it is best suited for the following
types of problems:

* The initial guesses, `x0`, are all relatively the same distance from
  the roots.
* Some or all of the extra arguments, `args`, are also arrays so that a
  class of similar problems can be solved together.
* The size of the initial guesses, `x0`, is larger than O(100) elements.
  Otherwise, a naive loop may perform as well or better than a vector.

Examples
--------
>>> 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`` is not provided, use the secant method:

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

Only ``fprime`` is provided, use the Newton-Raphson method:

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

Both ``fprime2`` and ``fprime`` are provided, use Halley's method:

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

When we want to find roots for a set of related starting values and/or
function parameters, we can provide both of those as an array of inputs:

>>> 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)

The above is the equivalent of solving for each value in ``(x, a)``
separately in a for-loop, just faster:

>>> 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

Plot the results found for all values of ``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()

r