Your second question is a bit more involved (if we continue to use ACF to get the autocorrelation function values), because the plot.ACF function hard-codes the y-axis limits to be the range of the autocorrelations. More on that in a moment. First, an easy way around this: In my example above, m1 is the model. We can directly extract the residuals with resid(m1). Then we can use the base acf function to plot their autocorrelation function. The acf function allows us to explicitly set the y-axis range, rather than hard-coding it inside the function.
acf(resid(m1), lag.max=4, ylim=c(-1,1))
If you still want to use the ACF function, we need to modify the function, plot.ACF that plots ACF objects. To see the function that plots ACF objects, run getAnywhere(plot.ACF) and the code for this function will appear in the console (see the explanatory note at the bottom for some background on why we're looking for the plot.ACF function when we actually called the plot function in our code).
Note that the second line of the function body is ylim <- range(object$ACF). A way around this is to modify the function to accept a ylim argument. Note in the code below that I've created a new function called my_plot.ACF. I've commented out the ylim line in the original function and added a new function argument ylim=c(-1.0, 1.0), so it defaults to full range, but can be changed, if desired, when calling the function.
my_plot.ACF = function (x, alpha = 0, xlab = "Lag", ylab = "Autocorrelation",
grid = FALSE, ylim=c(-1.0,1.0), ...) {
object <- x
#ylim <- range(object$ACF)
if (alpha) {
assign("stdv", qnorm(1 - alpha/2)/sqrt(attr(object, "n.used")))
stMax <- max(stdv)
ylim <- c(min(c(-stMax, ylim[1])), max(c(ylim[2], stMax)))
}
assign("alpha", as.logical(alpha))
assign("grid", grid)
xyplot(ACF ~ lag, object, ylim = ylim, panel = function(x,
y, ...) {
x <- as.numeric(x)
y <- as.numeric(y)
if (grid)
panel.grid()
panel.xyplot(x, y, type = "h")
panel.abline(0, 0)
if (alpha) {
llines(x, stdv, lty = 2)
llines(x, -stdv, lty = 2)
}
}, xlab = xlab, ylab = ylab, ...)
}
Now we run the function. We also need to load the lattice package, since plot.ACF (and therefore our new function) use the xyplot function from lattice.
library(lattice)
my_plot.ACF(ACF(m1, maxLag=4))
Explanatory note in case you're not already familiar with generic functions, methods, and method dispatch: plot is a "generic" function. When you run the plot function, what it does depends on the type of object you pass to it. If you type plot(mtcars) you'll get a scatterplot matrix. If you type plot(lm(mpg ~ hp, data=mtcars)) you'll get several diagnostic plots for a linear regression model. If you type plot(ACF(m1)) you'll get a plot of an autocorrelation function. And so on.
plot does different things with each of these objects because each of them has a different class, specifically, "data.frame", "lm", and "ACF", respectively (for example, run class(ACF(m1)). plot itself just "dispatches" the appropriate "plot method" (the actual function that does the plotting) for each of these objects. To see what these methods are, run methods(plot). They'll all be called plot.zzz where zzz is the class of the object.. For example, note that one of the functions is plot.ACF. You can see the code for this function by typing getAnywhere(plot.ACF).
