dyn: dynamic regression class

Description Usage Arguments Details Value Note See Also Examples

View source: R/dyn.R

Description

dyn is used to construct objects of class "dyn"

Usage

1
dyn(x)

Arguments

x

an object, typically a "formula" object or an object produced by "lm", "glm" or other regression function.

Details

"dyn" enables regression functions that were not written to handle time series to handle them. Both the dependent and independent variables may be time series and they may have different time indexes (in which case they are automatically aligned). The time series may also have missing values including internal missing values.

"dyn" currently works with any regression function that makes use of "model.frame" and is written in the style of "lm". This includes "lm", "glm", "loess", "rlm" (from "MASS"), "lqs" (from "MASS"), "MCMCregress" (from "MCMCpack"), "randomForest" (from "randomForest"), "rq" (from "quantreg") and others. The time series objects can be one of the following classes: "ts", "irts", "its", "zoo" or "zooreg".

Typically "dyn" is used like this "dyn$lm(y ~ lag(y, -1))". That is, one prepends the usual "lm" or other regression function with "dyn$" and then uses time series including "lag" and "diff" operators in the formula. The returned object has a class vector beginning with "dyn" and includes all classes that it would have had without "dyn". "dyn" methods include "model.frame", "fitted", "residuals", "predict", "update", "anova" and "$" methods. These methods preprocess their arguments, call the real method which does the actual work and then post process the returned object. In the case of "fitted", "residuals" and "predict" they ensure that the result is a time series. In the case of anova the times of the objects are intersected so that they all have the same time indexes to ensure that a comparable input is provided to "anova".

Value

"dyn" returns its argument with the class name "dyn" prepended to its class vector. The "fitted", "residuals" and "predict" "dyn" methods return time series of the appropriate class. "model.frame" creates a model frame with an attribute of "series" that contains a data frame of the time series and factor variables as columns. "model.matrix" returns a model matrix of class "matrix".

Note

"dyn" relies on the underlying time series classes and regression routines for all substantive functionality. In particular note these limitations: "irts" has no "lag" or "diff" methods. The lag function of "its" is called "lagIts". "ts" and "zooreg" series can be lagged outside of the data range (both forward and backward) but other time series classes cannot represent such data and therefore will drop them. If the regression function in question does not have an associated "fitted", "residuals", etc. method then such method will not be available with "dyn" either.

Internally the system uses "zoo". Additional time series classes not already defined to work with "dyn" can be added by simply defining "as" methods between the new class and "zoo" and then creating new methods (for "model.frame", "predict", "fitted", etc.) In most cases these method names can be set equal to the corresponding "zoo" method name (e.g. "model.frame.newclass <- model.frame.zoo" so that no new function bodies need be written).

The main requirements for new regression routines to work with "dyn" are that they use "model.frame", that their "fitted", "residuals" and "predict" methods return named vectors whose names are the corresponding indexes in the original data and that they follow the same style of processing as "lm". There is no "dyn" code specific to any particular regression routine.

"dyn$lm(formula, ...)" is equivalent to "dyn(lm(dyn(formula), ...))" (where "formula" is assumed to be the first argument) but is easier to write. When "dyn" is used with an argument, as just shown, then its effect is simply to return its argument with the "dyn" class prepended to the class vector so that further processing of the result is intercepted by other "dyn" methods.

See Also

See Also model.frame, predict, fitted, residuals, anova, update, lm, glm, loess

Examples

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
y <- ts(1:12, start = c(2000,2), freq = 4)^3
x <- ts(1:9, start = c(2000,3), freq = 4)^2

# can be used with numerous different regression functions
y.lm <- dyn$lm( window(y, start = c(2000,4)) ~ diff(x) )
y.lm <- dyn$lm( y ~ diff(x) )
y.glm <- dyn$glm( y ~ diff(x) )
y.loess <- dyn$loess( y ~ diff(x) )

y.lm <- dyn(lm(dyn(y ~ diff(x))))  # same
y.lm
summary(y.lm)
residuals(y.lm)
fitted(y.lm)
y2.lm <- update(y.lm, . ~ . + lag(x,-1))
y2.lm
anova(y.lm, y2.lm)

# examples of using data
dyn$lm(y ~ diff(x), list(y = y, x = x))
dyn$lm(y ~ diffx, list(y = y, diffx = diff(x)))

# invoke model.frame on formula as a dyn object
dyn$model.frame( y ~ diff(x) )

# superimpose a loess fit on Nile time series data
plot(Nile)
lines(fitted(dyn$loess(Nile ~ time(Nile))), col = "red")

# lag.zoo can take vector lags
set.seed(1)
yz <- zoo(rnorm(100)); xz <- zoo(rnorm(100))
yz.lm <- dyn$lm(yz ~ lag(xz, 0:-3))


###
# simulate series and then NA out 7:10 and predict them
###

library(dyn)
set.seed(123)
tz <- zoo(cbind(Y = 0, x = rnorm(10), z = rnorm(10)))

# simulate values
for(i in 2:10) {
 tz$Y[i] <- with(as.data.frame(tz), 
	2*Y[i-1] + 3*z[i] +4* x[i] + 5*x[i-1] + rnorm(1))
}

# keep copy of tz to compare later to simulated Y's
tz.orig <- tz

# NA out Y's that are to be predicted
tz[7:10, "Y"] <- NA

L <- function(x, k = 1) lag(x, -k)

# predict 1 ahead each iteration
for(i in 7:10) {
   # fit based on first i-1 values
   fit <- dyn$lm(Y ~ L(Y) + z + L(x, 0:1), tz, subset = seq_len(i-1))
   # get prediction for ith value
   tz[i, "Y"] <- tail(predict(fit, tz[1:i,]), 1)
}
cbind(pred = tz[7:10, "Y"], act = tz.orig[7:10, "Y"])

dyn documentation built on May 30, 2017, 1:09 a.m.