Description Usage Arguments Details Value Note See Also Examples

dyn is used to construct objects of class `"dyn"`

1 | ```
dyn(x)
``` |

`x` |
an object, typically a |

`"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"`

.

`"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"`

.

`"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
`model.frame`

,
`predict`

,
`fitted`

,
`residuals`

,
`anova`

,
`update`

,
`lm`

,
`glm`

,
`loess`

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"])
``` |

Embedding an R snippet on your website

Add the following code to your website.

For more information on customizing the embed code, read Embedding Snippets.