optimize {stats} | R Documentation |

The function `optimize`

searches the interval from
`lower`

to `upper`

for a minimum or maximum of
the function `f`

with respect to its first argument.

`optimise`

is an alias for `optimize`

.

optimize(f = , interval = , lower = min(interval), upper = max(interval), maximum = FALSE, tol = .Machine$double.eps^0.25, ...) optimise(f = , interval = , lower = min(interval), upper = max(interval), maximum = FALSE, tol = .Machine$double.eps^0.25, ...)

`f` |
the function to be optimized. The function is
either minimized or maximized over its first argument
depending on the value of `maximum` . |

`interval` |
a vector containing the end-points of the interval to be searched for the minimum. |

`lower` |
the lower end point of the interval to be searched. |

`upper` |
the upper end point of the interval to be searched. |

`maximum` |
logical. Should we maximize or minimize (the default)? |

`tol` |
the desired accuracy. |

`...` |
additional arguments to `f` . |

The method used is a combination of golden section search and
successive parabolic interpolation. Convergence is never much slower
than that for a Fibonacci search. If `f`

has a continuous second
derivative which is positive at the minimum (which is not at `lower`

or
`upper`

), then convergence is superlinear, and usually of the
order of about 1.324.

The function `f`

is never evaluated at two points closer together
than *eps *** |x_0| + (tol/3)*, where
*eps* is approximately `sqrt(.Machine$double.eps)`

and *x_0* is the final abscissa `optimize()$minimum`

.

If `f`

is a unimodal function and the computed values of `f`

are always unimodal when separated by at least *eps **
* |x| + (tol/3)*, then *x_0* approximates the abscissa of the
global minimum of `f`

on the interval `lower,upper`

with an
error less than *eps *** |x_0|+ tol*.

If `f`

is not unimodal, then `optimize()`

may approximate a
local, but perhaps non-global, minimum to the same accuracy.

The first evaluation of `f`

is always at
*x_1 = a + (1-phi)(b-a)* where `(a,b) = (lower, upper)`

and
*phi = (sqrt 5 - 1)/2 = 0.61803..* is the golden section ratio.
Almost always, the second evaluation is at *x_2 = a + phi(b-a)*.
Note that a local minimum inside *[x_1,x_2]* will be found as
solution, even when `f`

is constant in there, see the last
example.

It uses a C translation of Fortran code (from Netlib) based on the
Algol 60 procedure `localmin`

given in the reference.

A list with components `minimum`

(or `maximum`

)
and `objective`

which give the location of the minimum (or maximum)
and the value of the function at that point.

Brent, R. (1973)
*Algorithms for Minimization without Derivatives.*
Englewood Cliffs N.J.: Prentice-Hall.

f <- function (x,a) (x-a)^2 xmin <- optimize(f, c(0, 1), tol = 0.0001, a = 1/3) xmin ## See where the function is evaluated: optimize(function(x) x^2*(print(x)-1), l=0, u=10) ## "wrong" solution with unlucky interval and piecewise constant f(): f <- function(x) ifelse(x > -1, ifelse(x < 4, exp(-1/abs(x - 1)), 10), 10) fp <- function(x) { print(x); f(x) } plot(f, -2,5, ylim = 0:1, col = 2) optimize(fp, c(-4, 20))# doesn't see the minimum optimize(fp, c(-7, 20))# ok

[Package *stats* version 2.2.1 Index]