<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def newton(func, x0, fprime, args=(), tol=1.48e-8, maxiter=50, disp=True):
 """ Find a zero from the Newton-Raphson method using the jitted version of Scipy's newton for scalars. Note that this does not provide an alternative method such as secant. Thus, it is important that `fprime` can be provided. Note that `func` and `fprime` must be jitted via Numba. They are recommended to be `njit` for performance. Parameters func : callable and jitted The function whose zero is wanted. It must be a function of a arguments that can be passed in the `args` parameter. x0 : float An initial estimate of the zero that should be somewhere near the actual zero. fprime : callable and jitted The derivative of the function (when available and convenient). args : tuple, optional(default=()) Extra arguments to be used in the function call. tol : float, optional(default=1.48e-8) The allowable error of the zero value. maxiter : int, optional(default=50) Maximum number of iterations. disp : bool, optional(default=True) If True, raise a RuntimeError if the algorithm didn't converge Returns ------- results : namedtuple A namedtuple containing the following items: :: root - Estimated location where function is zero. function_calls - Number of times the function was called. iterations - Number of iterations needed to find the root. converged - True if the routine converged """


    if tol <= 0:
        raise ValueError("tol is too small <= 0")
    if maxiter < 1:
        raise ValueError("maxiter must be greater than 0")

    # Convert to float (don't use float(x0); this works also for complex x0)
    p0 = 1.0 * x0
    funcalls = 0
    status = _ECONVERR

    # Newton-Raphson method
    for itr in range(maxiter):
        # first evaluate fval
        fval = func(p0, *args)
        funcalls += 1
        # If fval is 0, a root has been found, then terminate
        if fval == 0:
            status = _ECONVERGED
            p = p0
            itr -= 1
            break
        fder = fprime(p0, *args)
        funcalls += 1
        # derivative is zero, not converged
        if fder == 0:
            p = p0
            break
        newton_step = fval / fder
        # Newton step
        p = p0 - newton_step
        if abs(p - p0) < tol:
            status = _ECONVERGED
            break
        p0 = p

    if disp and status == _ECONVERR:
        msg = "Failed to converge"
        raise RuntimeError(msg)

    return _results((p, funcalls, itr + 1, status))