minimize_scalar(fun, bracket=None, bounds=None, args=(), method='brent', tol=None, options=None)
This section describes the available solvers that can be selected by the 'method' parameter. The default method is Brent.
Method Brent <optimize.minimize_scalar-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 <optimize.minimize_scalar-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 <optimize.minimize_scalar-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)
where kwargs
corresponds to any other parameters passed to minimize
(such as bracket
, :None:None:`tol`, etc.), except the :None:None:`options` dict, which has its contents also passed as method
parameters pair by pair. The method shall return an OptimizeResult
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.
Objective function. Scalar function, must return a scalar.
For methods 'brent' and 'golden', bracket
defines the bracketing interval and can either have three items (a, b, c)
so that a < b < c
and fun(b) < fun(a), fun(c)
or two items a
and c
which are assumed to be a starting interval for a downhill bracket search (see bracket
); it doesn't always mean that the obtained solution will satisfy a <= x <= c
.
For method 'bounded', :None:None:`bounds` is mandatory and must have two items corresponding to the optimization bounds.
Extra arguments passed to the objective function.
Type of solver. Should be one of:
Brent <optimize.minimize_scalar-brent>
Bounded <optimize.minimize_scalar-bounded>
Golden <optimize.minimize_scalar-golden>custom - a callable object (added in version 0.14.0), see below
See the 'Notes' section for details of each solver.
Tolerance for termination. For detailed control, use solver-specific options.
A dictionary of solver options.
maxiter
maxiter
disp
disp
See show_options()
for solver-specific options.
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 and message
which describes the cause of the termination. See OptimizeResult
for a description of other attributes.
Minimization of scalar function of one variable.
minimize
Interface to minimization algorithms for scalar multivariate functions
show_options
Additional options accepted by the solvers
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')See :
... res.x -2.0000002026
The following pages refer to to this document either explicitly or contain code examples using this.
scipy.optimize._optimize.show_options
scipy.optimize._minimize.minimize
scipy.optimize
scipy.optimize._optimize.fminbound
scipy.optimize._optimize.golden
scipy.optimize._minimize.minimize_scalar
Hover to see nodes names; edges to Self not shown, Caped at 50 nodes.
Using a canvas is more power efficient and can get hundred of nodes ; but does not allow hyperlinks; , arrows or text (beyond on hover)
SVG is more flexible but power hungry; and does not scale well to 50 + nodes.
All aboves nodes referred to, (or are referred from) current nodes; Edges from Self to other have been omitted (or all nodes would be connected to the central node "self" which is not useful). Nodes are colored by the library they belong to, and scaled with the number of references pointing them