root_scalar#
- scipy.optimize.root_scalar(f, args=(), method=None, bracket=None, fprime=None, fprime2=None, x0=None, x1=None, xtol=None, rtol=None, maxiter=None, options=None)[source]#
- Find a root of a scalar function. - Parameters:
- fcallable
- A function to find a root of. - Suppose the callable has signature - f0(x, *my_args, **my_kwargs), where- my_argsand- my_kwargsare required positional and keyword arguments. Rather than passing- f0as the callable, wrap it to accept only- x; e.g., pass- fun=lambda x: f0(x, *my_args, **my_kwargs)as the callable, where- my_args(tuple) and- my_kwargs(dict) have been gathered before invoking this function.
- argstuple, optional
- Extra arguments passed to the objective function and its derivative(s). 
- methodstr, optional
- Type of solver. Should be one of - ‘bisect’ (see here) 
- ‘brentq’ (see here) 
- ‘brenth’ (see here) 
- ‘ridder’ (see here) 
- ‘toms748’ (see here) 
- ‘newton’ (see here) 
- ‘secant’ (see here) 
- ‘halley’ (see here) 
 
- bracket: A sequence of 2 floats, optional
- An interval bracketing a root. - f(x, *args)must have different signs at the two endpoints.
- x0float, optional
- Initial guess. 
- x1float, optional
- A second guess. 
- fprimebool or callable, optional
- If fprime is a boolean and is True, f is assumed to return the value of the objective function and of the derivative. fprime can also be a callable returning the derivative of f. In this case, it must accept the same arguments as f. 
- fprime2bool or callable, optional
- If fprime2 is a boolean and is True, f is assumed to return the value of the objective function and of the first and second derivatives. fprime2 can also be a callable returning the second derivative of f. In this case, it must accept the same arguments as f. 
- xtolfloat, optional
- Tolerance (absolute) for termination. 
- rtolfloat, optional
- Tolerance (relative) for termination. 
- maxiterint, optional
- Maximum number of iterations. 
- optionsdict, optional
- A dictionary of solver options. E.g., - k, see- show_options()for details.
 
- Returns:
- solRootResults
- The solution represented as a - RootResultsobject. Important attributes are:- rootthe solution ,- convergeda boolean flag indicating if the algorithm exited successfully and- flagwhich describes the cause of the termination. See- RootResultsfor a description of other attributes.
 
 - See also - show_options
- Additional options accepted by the solvers 
- root
- Find a root of a vector function. 
 - Notes - This section describes the available solvers that can be selected by the ‘method’ parameter. - The default is to use the best method available for the situation presented. If a bracket is provided, it may use one of the bracketing methods. If a derivative and an initial value are specified, it may select one of the derivative-based methods. If no method is judged applicable, it will raise an Exception. - Arguments for each method are as follows (x=required, o=optional). - method - f - args - bracket - x0 - x1 - fprime - fprime2 - xtol - rtol - maxiter - options - x - o - x - o - o - o - o - x - o - x - o - o - o - o - x - o - x - o - o - o - o - x - o - x - o - o - o - o - x - o - x - o - o - o - o - x - o - x - o - o - o - o - o - x - o - x - o - o - o - o - o - x - o - x - x - x - o - o - o - o - Examples - Find the root of a simple cubic - >>> from scipy import optimize >>> def f(x): ... return (x**3 - 1) # only one real root at x = 1 - >>> def fprime(x): ... return 3*x**2 - The - brentqmethod takes as input a bracket- >>> sol = optimize.root_scalar(f, bracket=[0, 3], method='brentq') >>> sol.root, sol.iterations, sol.function_calls (1.0, 10, 11) - The - newtonmethod takes as input a single point and uses the derivative(s).- >>> sol = optimize.root_scalar(f, x0=0.2, fprime=fprime, method='newton') >>> sol.root, sol.iterations, sol.function_calls (1.0, 11, 22) - The function can provide the value and derivative(s) in a single call. - >>> def f_p_pp(x): ... return (x**3 - 1), 3*x**2, 6*x - >>> sol = optimize.root_scalar( ... f_p_pp, x0=0.2, fprime=True, method='newton' ... ) >>> sol.root, sol.iterations, sol.function_calls (1.0, 11, 11) - >>> sol = optimize.root_scalar( ... f_p_pp, x0=0.2, fprime=True, fprime2=True, method='halley' ... ) >>> sol.root, sol.iterations, sol.function_calls (1.0, 7, 8)