selfStart {stats} | R Documentation |

Construct self-starting nonlinear models to be used in
`nls`

, etc. Via function `initial`

to compute
approximate parameter values from data, such models are
“self-starting”, i.e., do not need a `start`

argument in,
e.g., `nls()`

.

```
selfStart(model, initial, parameters, template)
```

`model` |
a function object defining a nonlinear model or
a nonlinear |

`initial` |
a function object, taking arguments |

`parameters` |
a character vector specifying the terms on the right
hand side of |

`template` |
an optional prototype for the calling sequence of the
returned object, passed as the |

`nls()`

calls `getInitial`

and the
`initial`

function for these self-starting models.

This function is generic; methods functions can be written to handle specific classes of objects.

a `function`

object of class `"selfStart"`

, for the
`formula`

method obtained by applying `deriv`

to the right hand side of the `model`

formula. An
`initial`

attribute (defined by the `initial`

argument) is
added to the function to calculate starting estimates for the
parameters in the model automatically.

JosÃ© Pinheiro and Douglas Bates

Each of the following are `"selfStart"`

models (with examples)
`SSasymp`

, `SSasympOff`

, `SSasympOrig`

,
`SSbiexp`

, `SSfol`

, `SSfpl`

,
`SSgompertz`

, `SSlogis`

, `SSmicmen`

,
`SSweibull`

.

Further, package nlme's `nlsList`

.

```
## self-starting logistic model
## The "initializer" (finds initial values for parameters from data):
initLogis <- function(mCall, data, LHS, ...) {
xy <- sortedXyData(mCall[["x"]], LHS, data)
if(nrow(xy) < 4)
stop("too few distinct input values to fit a logistic model")
z <- xy[["y"]]
## transform to proportion, i.e. in (0,1) :
rng <- range(z); dz <- diff(rng)
z <- (z - rng[1L] + 0.05 * dz)/(1.1 * dz)
xy[["z"]] <- log(z/(1 - z)) # logit transformation
aux <- coef(lm(x ~ z, xy))
pars <- coef(nls(y ~ 1/(1 + exp((xmid - x)/scal)),
data = xy,
start = list(xmid = aux[[1L]], scal = aux[[2L]]),
algorithm = "plinear", ...))
setNames(pars [c(".lin", "xmid", "scal")],
mCall[c("Asym", "xmid", "scal")])
}
mySSlogis <- selfStart(~ Asym/(1 + exp((xmid - x)/scal)),
initial = initLogis,
parameters = c("Asym", "xmid", "scal"))
getInitial(weight ~ mySSlogis(Time, Asym, xmid, scal),
data = subset(ChickWeight, Chick == 1))
# 'first.order.log.model' is a function object defining a first order
# compartment model
# 'first.order.log.initial' is a function object which calculates initial
# values for the parameters in 'first.order.log.model'
#
# self-starting first order compartment model
## Not run:
SSfol <- selfStart(first.order.log.model, first.order.log.initial)
## End(Not run)
## Explore the self-starting models already available in R's "stats":
pos.st <- which("package:stats" == search())
mSS <- apropos("^SS..", where = TRUE, ignore.case = FALSE)
(mSS <- unname(mSS[names(mSS) == pos.st]))
fSS <- sapply(mSS, get, pos = pos.st, mode = "function")
all(sapply(fSS, inherits, "selfStart")) # -> TRUE
## Show the argument list of each self-starting function:
str(fSS, give.attr = FALSE)
```

[Package *stats* version 4.3.2 Index]