dyn {dyn} | R Documentation |
dyn is constructs objects of class "dyn"
,
dyn(x)
x |
an object, typically a "formula" object or
an object produced by "lm" , "glm" or other
regression function. |
"dyn"
enables regression functions that were not written to handle
time series to so handle them. The time series need not have the same
indexes (the are automatically intersected) and may have missing
values including internal missing values.
"dyn"
creates a dynamic regression object by
returning x
with the "dyn"
class name
prepended to the class of the argument.
If the argument to "dyn"
is a formula its variables may be time series objects of one
of the following classes: "ts"
, "irts"
,
code{"its"}, "zoo"
or "zooreg"
.
"dyn"
methods are available for "model.frame"
, "fitted"
,
"residuals"
, "predict"
, "update"
, "anova"
and "$"
.
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 objects are
intersected so that they all have the time indexes
to ensure that a meaningful input is provided to "anova"
.
The $
method is always used with a left argument of "dyn"
like this "dyn$lm(x, ...)"
. This expression is equivalent to
"dyn(lm(dyn(x), ...))"
but is more convenient to write.
"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 pkg{"MASS"}), "randomForest"
(from "randomForest"), "rq"
(from "quantreg") and
likely others.
"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.
"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"
its 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 questions 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.
See Also
model.frame
,
predict
,
fitted
,
residuals
,
anova
,
update
,
lm
,
glm
,
loess
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)) 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) )