> fr <- function(x) { ## Rosenbrock Banana function
x1 <- x[1]
x2 <- x[2]
100 * (x2 - x1 * x1)^2 + (1 - x1)^2
}
> optim(c(-1.2,1), fr)[c("par","value")]
$par
[1] 1.000260 1.000506
$value
[1] 8.825241e-08
Great. But sometimes you only want to optimise over some of your parameters, keeping the others fixed. Let's consider optimising the banana function for x2=0.3
> fr <- function(x) { ## Rosenbrock Banana function
x1 <- x[1]
x2 <- 0.3
100 * (x2 - x1 * x1)^2 + (1 - x1)^2
}
> optim(-1.2, fr,method="BFGS")[c("par","value")]
$par
[1] -0.5344572
$value
[1] 2.375167
(R gripes about doing 1-d optimisation with Nelder-Mead, so I switch to BFGS)
Okay, but we had to write a new objective function with 0.3 coded into it. Now repeat for a number of values. That's a pain.
The conventional solution would be to make x2 an extra parameter of fr:
> fr <- function(x,x2) {
x1 <- x[1]
100 * (x2 - x1 * x1)^2 + (1 - x1)^2
}
and call optim with this passed in the dot-dot-dots:
> optim(-1.2,fr,method="BFGS",x2=0.3)[c("par","value")]
$par
[1] -0.5344572
$value
[1] 2.375167
Okay great. But suppose now we want to fix x1 and optimise over x2. You're going to need another objective function. Suppose your function has twelve parameters... This is becoming a pain.
You need optifix. Go back to the original 2 parameter banana function, and do:
> optifix(c(-1.2,0.3),c(FALSE,TRUE), fr,method="BFGS")
$par
[1] -0.5344572
$value
[1] 2.375167
$counts
function gradient
27 9
$convergence
[1] 0
$message
NULL
$fullpars
[1] -0.5344572 0.3000000
$fixed
[1] FALSE TRUE
Here the function call is almost the same as the 2-parameter optimisation, except with a second argument that tells which parameters to fix - and they are fixed at the values given in the first argument. The values in that argument for non-fixed parameters are starting values for the optimiser as usual.
The output is the output from the reduced optimiser. In this case it is one parameter value, but there's also a couple of other components, $fullpars and $fixed, to tell you what the overall parameter values were and which ones were fixed.
Optifix takes your objective function and your specification of what's fixed to create a wrapper round your function that only takes the variable parameters. The wrapper inserts the fixed values in the right place and calls your original function. It then calls optim with a reduced vector of starting parameters and the wrapped objective function. Hence the wrapped function is only every called with the variable parameters, and the original function is called with the variables and the fixed values.
Optifix should work on optim calls that use a supplied gradient function - it wraps that as well to produce a reduced-dimensional gradient function for optim to work on.
Code? Oh you want the code? Okay. I've put a file in a folder on a server for you to download. Its very beta, needs testing and probably should find a package for its home. All things to do.
