Nothing
#' Time-series models in Zelig
#'
#' @import methods
#' @export Zelig-timeseries
#' @exportClass Zelig-timeseries
#'
#' @include model-zelig.R
ztimeseries <- setRefClass("Zelig-timeseries",
contains = "Zelig",
fields = list(link = "character",
linkinv = "function"))
ztimeseries$methods(
initialize = function() {
callSuper()
.self$packageauthors <- "R Core Team"
.self$modelauthors <- "James Honaker"
.self$acceptweights <- FALSE # Need to deal with block bootstrap
.self$category <- "timeseries"
.self$setx.labels <- list(ev = "Expected Values: E(Y|X)",
ev1 = "Expected Values: E(Y|X1)",
pv = "Predicted Values: Y|X",
pv1 = "Predicted Values: Y|X1",
fd = "First Differences: E(Y|X1) - E(Y|X)",
acf = "Autocorrelation Function",
ev.shortrun = "Expected Values Immediately Resulting from Shock",
ev.longrun = "Long Run Expected Values after Innovation",
pv.shortrun = "Predicted Values Immediately Resulting from Shock",
pv.longrun = "Long Run Predicted Values after Innovation",
evseries.shock = "Expected Values Over Time from Shock",
evseries.innovation ="Expected Values Over Time from Innovation",
pvseries.shock = "Predicted Values Over Time from Shock",
pvseries.innovation ="Predicted Values Over Time from Innovation")
warning("++++ All Zelig time series models are deprecated ++++",
call. = FALSE)
}
)
ztimeseries$methods(
zelig = function(formula, data, order = c(1, 0, 0), ts = NULL, cs = NULL, ...,
weights = NULL, by = NULL, bootstrap = FALSE){
localBy <- by # avoids CRAN warning about deep assignment from by existing separately as argument and field
if (identical(class(data), "function"))
stop("data not found.", call. = FALSE)
else
localData <- data # avoids CRAN warning about deep assignment from data existing separately as argument and field
if(!identical(bootstrap, FALSE)){
stop("Error: The bootstrap is not implemented for time-series models",
call. = FALSE)
}
if (!is.null(cs) && is.null(ts))
stop("ts must be specified if cs is specified.", call. = FALSE)
if (!is.null(cs) && !is.null(by)) {
stop("cs and by are equivalent for this model. Only one needs to be specified.",
call. = FALSE)
}
.self$zelig.call <- match.call(expand.dots = TRUE)
if(identical(.self$name,"ar")){
order <- c(1,0,0)
.self$zelig.call$order <- order
} else if(identical(.self$name,"ma")){
order <- c(0,0,1)
.self$zelig.call$order <- order
} else {
dots <- list(...)
if (!is.null(dots$order)) {
order <- dots$order
}
.self$zelig.call$order <- order
}
.self$model.call <- .self$zelig.call
## Sort dataset by time and cross-section
## Should add checks that ts, cs, are valid, and consider how to interact with by.
## This follows handling from Amelia::prep.r, which also has code to deal with lags, should we add those.
if(!is.null(ts)){
.self$model.call$ts <- NULL
if (!is.null(cs)) {
.self$model.call$cs <- NULL
tsarg<-list(localData[,cs],localData[,ts])
localBy <- cs # Use by architecture to deal with cross-sections in time-series models that do not support such. Currently overrides.
} else {
tsarg<-list(localData[,ts])
}
tssort <- do.call("order",tsarg)
localData <- localData[tssort,]
}
## ts and cs are used to reorganize dataset, and do not get further passed on to Super
callSuper(formula = formula, data = localData, order=order, ...,
weights = weights, by = localBy, bootstrap = FALSE)
}
)
# replace packagename method as stats::arima() has a second layer of wrapping in zeligArimaWrapper().
ztimeseries$methods(
packagename = function() {
"Automatically retrieve wrapped package name"
return("stats")
}
)
# replace simx method to add ACF as QI.
ztimeseries$methods(
simx = function() {
base_vals <- .self$set() # generate mm of all averages
d <- zelig_mutate(.self$zelig.out, simparam = .self$simparam$simparam)
d <- zelig_mutate(d, mm = base_vals$mm)
d <- zelig_mutate(d, mm1 = .self$setx.out$x$mm)
.self$sim.out$x <- d %>%
do(qi = .self$qi(.$simparam, .$mm, .$mm1)) %>%
do(acf = .$qi$acf,
ev = .$qi$ev,
pv = .$qi$pv,
ev.shortrun = .$qi$ev.shortrun,
pv.shortrun = .$qi$pv.shortrun,
ev.longrun = .$qi$ev.longrun,
pv.longrun = .$qi$pv.longrun,
pvseries.shock = .$qi$pvseries.shock,
evseries.shock = .$qi$evseries.shock,
pvseries.innovation = .$qi$pvseries.innovation,
evseries.innovation = .$qi$evseries.innovation)
d <- zelig_mutate(.self$sim.out$x, ev0 = .self$sim.out$x$ev) # Eventually, when ev moves, then this path for ev0 changes. (Or make movement happen after fd calculation.)
d <- d %>%
do(fd = .$ev.longrun - .$ev0)
.self$sim.out$x <- zelig_mutate(.self$sim.out$x, fd = d$fd) #JH
}
)
ztimeseries$methods(
simx1 = function() {
d <- zelig_mutate(.self$zelig.out, simparam = .self$simparam$simparam)
d <- zelig_mutate(d, mm = .self$setx.out$x$mm)
d <- zelig_mutate(d, mm1 = .self$setx.out$x1$mm)
# return(list(acf = acf, ev = ev, pv = pv, pv.shortrun=pv.shortrun, pv.longrun=pv.longrun, ev.shortrun=ev.shortrun, ev.longrun=ev.longrun,
# pvseries.shock=yseries$y.shock, pvseries.innovation=yseries$y.innovation,
# evseries.shock=yseries$ev.shock, evseries.innovation=yseries$ev.innovation))
.self$sim.out$x1 <- d %>%
do(qi = .self$qi(.$simparam, .$mm, .$mm1)) %>%
do(acf = .$qi$acf,
ev = .$qi$ev,
pv = .$qi$pv,
ev.shortrun = .$qi$ev.shortrun,
pv.shortrun = .$qi$pv.shortrun,
ev.longrun = .$qi$ev.longrun,
pv.longrun = .$qi$pv.longrun,
pvseries.shock = .$qi$pvseries.shock,
evseries.shock = .$qi$evseries.shock,
pvseries.innovation = .$qi$pvseries.innovation,
evseries.innovation = .$qi$evseries.innovation)
# Will eventually have to then move acf, ev, and pv from .self$setx.out$x1 to .self$setx.out$x
# This will also effect next line:
d <- zelig_mutate(.self$sim.out$x1, ev0 = .self$sim.out$x1$ev) # Eventually, when ev moves, then this path for ev0 changes. (Or make movement happen after fd calculation.)
d <- d %>%
do(fd = .$ev.longrun - .$ev0)
.self$sim.out$x1 <- zelig_mutate(.self$sim.out$x1, fd = d$fd) #JH
}
)
# replace sim method to skip {simx, simx1, simrange, simrange1} methods as they are not separable
# instead go directly to qi method
ztimeseries$methods(
sim = function(num = 1000) {
"Timeseries Method for Computing and Organizing Simulated Quantities of Interest"
if (length(.self$num) == 0)
.self$num <- num
.self$simparam <- .self$zelig.out %>%
do(simparam = .self$param(.$z.out))
# NOTE difference here from standard Zelig approach.
# Normally these are done in sequence, but now we do one or the other.
if (.self$bsetx1) {
.self$simx1()
} else {
.self$simx()
}
}
)
# There is no fitting summary function for objects of class Arima.
# So this passes the object through to print, and z$summary() is essentially print(summary(x)).
#' Summary of an object of class Arima
#' @method summary Arima
#' @param object An object of class Arima
#' @param ... Additional parameters
#' @return The original object
#' @export
summary.Arima = function(object, ...) object
Any scripts or data that you put into this service are public.
Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.