scipy.optimize.minimize_scalar¶

scipy.optimize.
minimize_scalar
(fun, bracket=None, bounds=None, args=(), method='brent', tol=None, options=None)[source]¶ Minimization of scalar function of one variable.
Parameters:  fun : callable
Objective function. Scalar function, must return a scalar.
 bracket : sequence, optional
For methods ‘brent’ and ‘golden’,
bracket
defines the bracketing interval and can either have three items(a, b, c)
so thata < b < c
andfun(b) < fun(a), fun(c)
or two itemsa
andc
which are assumed to be a starting interval for a downhill bracket search (seebracket
); it doesn’t always mean that the obtained solution will satisfya <= x <= c
. bounds : sequence, optional
For method ‘bounded’, bounds is mandatory and must have two items corresponding to the optimization bounds.
 args : tuple, optional
Extra arguments passed to the objective function.
 method : str or callable, optional
Type of solver. Should be one of:
 ‘Brent’ (see here)
 ‘Bounded’ (see here)
 ‘Golden’ (see here)
 custom  a callable object (added in version 0.14.0), see below
 tol : float, optional
Tolerance for termination. For detailed control, use solverspecific options.
 options : dict, optional
A dictionary of solver options.
 maxiter : int
Maximum number of iterations to perform.
 disp : bool
Set to True to print convergence messages.
See
show_options
for solverspecific options.
Returns:  res : OptimizeResult
The optimization result represented as a
OptimizeResult
object. Important attributes are:x
the solution array,success
a Boolean flag indicating if the optimizer exited successfully andmessage
which describes the cause of the termination. SeeOptimizeResult
for a description of other attributes.
See also
minimize
 Interface to minimization algorithms for scalar multivariate functions
show_options
 Additional options accepted by the solvers
Notes
This section describes the available solvers that can be selected by the ‘method’ parameter. The default method is Brent.
Method Brent uses Brent’s algorithm to find a local minimum. The algorithm uses inverse parabolic interpolation when possible to speed up convergence of the golden section method.
Method Golden uses the golden section search technique. It uses analog of the bisection method to decrease the bracketed interval. It is usually preferable to use the Brent method.
Method Bounded can perform bounded minimization. It uses the Brent method to find a local minimum in the interval x1 < xopt < x2.
Custom minimizers
It may be useful to pass a custom minimization method, for example when using some library frontend to minimize_scalar. You can simply pass a callable as the
method
parameter.The callable is called as
method(fun, args, **kwargs, **options)
wherekwargs
corresponds to any other parameters passed tominimize
(such asbracket
, tol, etc.), except the options dict, which has its contents also passed as method parameters pair by pair. The method shall return anOptimizeResult
object.The provided method callable must be able to accept (and possibly ignore) arbitrary parameters; the set of parameters accepted by
minimize
may expand in future versions and then these parameters will be passed to the method. You can find an example in the scipy.optimize tutorial.New in version 0.11.0.
Examples
Consider the problem of minimizing the following function.
>>> def f(x): ... return (x  2) * x * (x + 2)**2
Using the Brent method, we find the local minimum as:
>>> from scipy.optimize import minimize_scalar >>> res = minimize_scalar(f) >>> res.x 1.28077640403
Using the Bounded method, we find a local minimum with specified bounds as:
>>> res = minimize_scalar(f, bounds=(3, 1), method='bounded') >>> res.x 2.0000002026