Package 'zoo' reference manual

Title:	S3 Infrastructure for Regular and Irregular Time Series (Z's Ordered Observations)
Description:	An S3 class with methods for totally ordered indexed observations. It is particularly aimed at irregular time series of numeric vectors/matrices and factors. zoo's key design goals are independence of a particular index/date/time class and consistency with ts and base R by providing methods to extend standard generics.
Authors:	Achim Zeileis [aut, cre] , Gabor Grothendieck [aut], Jeffrey A. Ryan [aut], Joshua M. Ulrich [ctb], Felix Andrews [ctb]
Maintainer:	Achim Zeileis <[email protected]>
License:	GPL-2 \| GPL-3
Version:	1.8-13
Built:	2024-05-09 07:00:34 UTC
Source:	https://github.com/r-forge/zoo

Reading and Writing zoo Series

Description

read.zoo and write.zoo are convenience functions for reading and writing "zoo" series from/to text files. They are convenience interfaces to read.table and write.table, respectively. To employ read.csv, read.csv2, read.delim, read.delim2 instead of read.table additional functions read.csv.zoo etc. are provided.

Usage

read.zoo(file, format = "", tz = "", FUN = NULL,
  regular = FALSE, index.column = 1, drop = TRUE, FUN2 = NULL,
  split = NULL, aggregate = FALSE, ..., text, read = read.table)
  
write.zoo(x, file = "", index.name = "Index", row.names = FALSE, col.names = NULL,
  FUN = format, ...)

read.csv.zoo(..., read = read.csv)
read.csv2.zoo(..., read = read.csv2)
read.delim.zoo(..., read = read.delim)
read.delim2.zoo(..., read = read.delim2)

Arguments

`file`	character string or strings giving the name of the file(s) which the data are to be read from/written to. See `read.table` and `write.table` for more information. Alternatively, in `read.zoo`, `file` can be a `connection` or a `data.frame` (e.g., resulting from a previous `read.table` call) that is subsequently processed to a `"zoo"` series.
`format`	date format argument passed to `FUN`.
`tz`	time zone argument passed to `as.POSIXct`.
`FUN`	a function for processing the time index. In `read.zoo` this is the function that computes the index from the `index.column`, see the details. In `write.zoo` it is a function that formats the index prior to writing it to `file`.
`regular`	logical. Should the series be coerced to class `"zooreg"` (if the series is regular)?
`index.column`	numeric vector or list. The column names or numbers of the data frame in which the index/time is stored. If the `read.table` argument `colClasses` is used and `"NULL"` is among its components then `index.column` refers to the column numbers after the columns corresponding to `"NULL"` in `colClasses` have been removed. If specified as a list then one argument will be passed to argument `FUN` per component so that, for example, `index.column = list(1, 2)` will cause `FUN(x[,1], x[,2], ...)` to be called whereas `index.column = list(1:2)` will cause `FUN(x[,1:2], ...)` to be called where `x` is a data frame of characters data. Here `...` refers to `format` and/or `tz`, if they specified as arguments. `index.column = 0` can be used to specify that the row names be used as the index. In the case that no row names were input sequential numbering is used. If `index.column` is specified as an ordinary vector then if it has the same length as the number of arguments of `FUN` (or `FUN2` in the event that `FUN2` is specified and `FUN` is not) then `index.column` is converted to a list. Also it is always converted to a list if it has length 1.
`drop`	logical. If the data frame contains just a single data column, should the second dimension be dropped?
`x`	a `"zoo"` object.
`index.name`	character with name of the index column in the written data file.
`row.names`	logical. Should row names be written? Default is `FALSE` because the row names are just character representations of the index.
`col.names`	logical. Should column names be written? Default is to write column names only if `x` has column names.
`FUN2`	function. It is applied to the time index after `FUN` and before `aggregate`. If `FUN` is not specified but `FUN2` is specified then only `FUN2` is applied.
`split`	NULL or column number or name or vector of numbers or names. If not NULL then the data is assumed to be in long format and is split according to the indicated columns. See the R `reshape` command for description of long data. If `split = Inf` then the first of each run among the times are made into a separate series, the second of each run and so on. If `split= -Inf` then the last of each run is made into a separate series, the second last and so on.
`aggregate`	logical or function. If set to `TRUE`, then `aggregate.zoo` is applied to the zoo object created to compute the `mean` of all values with the same time index. Alternatively, `aggregate` can be set to any other function that should be used for aggregation. If `FALSE` (the default), no aggregation is performed and a warning is given if there are any duplicated time indexes. Note that most `zoo` functions do not accept objects with duplicate time indexes. See `aggregate.zoo`.
`...`	further arguments passed to other functions. In the `read.*.zoo` the arguments are passed to the function specified in `read` (unless `file` is a `data.frame` already). In `write.zoo` the arguments are passed to `write.table`.
`text`	character. If `file` is not supplied and this is, then data are read from the value of `text` via a text connection. See below for an example.
`read`	function. The function for reading `file` (unless it is a `data.frame` already).

Details

read.zoo is a convenience function which should make it easier to read data from a text file and turn it into a "zoo" series immediately. read.zoo reads the data file via read.table(file, ...). The column index.column (by default the first) of the resulting data is interpreted to be the index/time, the remaining columns the corresponding data. (If the file only has only column then that is assumed to be the data column and 1, 2, ... are used for the index.) To assign the appropriate class to the index, FUN can be specified and is applied to the first column.

To process the index, read.zoo calls FUN with the index as the first argument. If FUN is not specified, the following default is employed:

(a) If file is a data frame with a single index column that appears to be a time index already, then FUN = identity is used. The conditions for a readily produced time index are: It is not character or factor (and the arguments tz and format must not be specified).

(b) If the conditions from (a) do not hold then the following strategy is used. If there are multiple index columns they are pasted together with a space between each. Using the (pasted) index column: (1) If tz is specified then the index column is converted to POSIXct. (2) If format is specified then the index column is converted to Date. (3) Otherwise, a heuristic attempts to decide between "numeric", "POSIXct", and "Date" by trying them in that order (which may not always succeed though). By default, only the standard date/time format is used. Hence, supplying format and/or tz is necessary if some date/time format is used that is not the default. And even if the default format is appropriate for the index, explicitly supplying FUN or at least format and/or tz typically leads to more reliable results than the heuristic.

If regular is set to TRUE and the resulting series has an underlying regularity, it is coerced to a "zooreg" series.

To employ other functions than read.table to read the initial data, further convenience interfaces read.csv.zoo etc. are provided.

write.zoo is a convenience function for writing "zoo" series to text files. It first coerces its argument to a "data.frame", adds a column with the index and then calls write.table.

See also vignette("zoo-read", package = "zoo") for detailed examples.

Value

read.zoo returns an object of class "zoo" (or "zooreg").

Note

read.zoo works by first reading the data in using read.table and then processing it. This implies that if the index field is entirely numeric the default is to pass it to FUN or the built-in date conversion routine a number, rather than a character string. Thus, a date field such as 09122007 intended to represent September 12, 2007 would be seen as 9122007 and interpreted as the 91st day thereby generating an error.

This comment also applies to trailing decimals so that if 2000.10 were intended to represent the 10th month of 2000 in fact it would receive 2000.1 and regard it as the first month of 2000 unless similar precautions were taken.

In the above cases the index field should be specified to be "character" so that leading or trailing zeros are not dropped. This can be done by specifying a "character" index column in the "colClasses" argument, which is passed to read.table, as shown in the examples below.

Examples

## this manual page provides a few typical examples, many more cases
## are covered in vignette("zoo-read", package = "zoo")

## read text lines with a single date column
Lines <- "2013-12-24  2
2013-12-25 3
2013-12-26 8"
read.zoo(text = Lines, FUN = as.Date)       # explicit coercion
read.zoo(text = Lines, format = "%Y-%m-%d") # same
read.zoo(text = Lines)                      # same, via heuristic

## read text lines with date/time in separate columns
Lines <- "2013-11-24 12:41:21 2
2013-12-25 12:41:22.25 3
2013-12-26 12:41:22.75 8"
read.zoo(text = Lines, index = 1:2,
  FUN = paste, FUN2 = as.POSIXct)            # explicit coercion
read.zoo(text = Lines, index = 1:2, tz = "") # same
read.zoo(text = Lines, index = 1:2)          # same, via heuristic

## read text lines with month/year in separate columns
Lines <- "Jan 1998 4.36
Feb 1998 4.34"
read.zoo(text = Lines, index = 1:2, FUN = paste, FUN2 = as.yearmon)

## read directly from a data.frame (artificial and built-in BOD)
dat <- data.frame(date = paste("2000-01-", 10:15, sep = ""),
  a = sin(1:6), b = cos(1:6))
read.zoo(dat)
data("BOD", package = "datasets")
read.zoo(BOD)

## Not run: 
## descriptions of typical examples

## turn *numeric* first column into yearmon index
## where number is year + fraction of year represented by month
z <- read.zoo("foo.csv", sep = ",", FUN = as.yearmon)

## first column is of form yyyy.mm
## (Here we use format in place of as.character so that final zero 
## is not dropped in dates like 2001.10 which as.character would do.)
f <- function(x) as.yearmon(format(x, nsmall = 2), "%Y.%m")
z <- read.zoo("foo.csv", header = TRUE, FUN = f)

## turn *character* first column into "Date" index
## Assume lines look like: 12/22/2007 1 2
z <- read.zoo("foo.tab", format = "%m/%d/%Y")

# Suppose lines look like: 09112007 1 2 and there is no header
z <- read.zoo("foo.txt", format = "%d%m%Y")

## csv file with first column of form YYYY-mm-dd HH:MM:SS
## Read in times as "chron" class. Requires chron 2.3-22 or later.
z <- read.zoo("foo.csv", header = TRUE, sep = ",", FUN = as.chron)

## same but with custom format.  Note as.chron uses POSIXt-style 
## Read in times as "chron" class. Requires chron 2.3-24 or later.
z <- read.zoo("foo.csv", header = TRUE, sep = ",", FUN = as.chron, 
	format = "

## same file format but read it in times as "POSIXct" class.
z <- read.zoo("foo.csv", header = TRUE, sep = ",", tz = "")

## csv file with first column mm-dd-yyyy. Read times as "Date" class.
z <- read.zoo("foo.csv", header = TRUE, sep = ",", format = "%m-%d-%Y")

## whitespace separated file with first column of form YYYY-mm-ddTHH:MM:SS
## and no headers.  T appears literally.  Requires chron 2.3-22 or later.
z <- read.zoo("foo.csv", FUN = as.chron)

# read in all csv files in the current directory and merge them
read.zoo(Sys.glob("*.csv"), header = TRUE, sep = ",")

# We use "NULL" in colClasses for those columns we don't need but in 
# col.names we still have to include dummy names for them.  Of what 
# is left the index is the first three columns (1:3) which we convert 
# to chron class times in FUN and then truncate to 5 seconds in FUN2.  
# Finally we use aggregate = mean to average over the 5 second intervals.
library("chron")

Lines <- "CVX 20070201 9 30 51 73.25 81400 0
CVX 20070201 9 30 51 73.25 100 0
CVX 20070201 9 30 51 73.25 100 0
CVX 20070201 9 30 51 73.25 300 0
CVX 20070201 9 30 51 73.25 81400 0
CVX 20070201 9 40 51 73.25 100 0
CVX 20070201 9 40 52 73.25 100 0
CVX 20070201 9 40 53 73.25 300 0"

z <- read.zoo(text = Lines, 
  colClasses = c("NULL", "NULL", "numeric", "numeric", "numeric",
    "numeric", "numeric", "NULL"),
  col.names = c("Symbol", "Date", "Hour", "Minute", "Second", "Price", "Volume", "junk"),
  index = 1:3,  # do not count columns that are "NULL" in colClasses
  FUN = function(h, m, s) times(paste(h, m, s, sep = ":")),
  FUN2 = function(tt) trunc(tt, "00:00:05"),
  aggregate = mean)

## End(Not run)

Z's Ordered Observations

Description

zoo is the creator for an S3 class of indexed totally ordered observations which includes irregular time series.

Usage

zoo(x = NULL, order.by = index(x), frequency = NULL,
  calendar = getOption("zoo.calendar", TRUE))
## S3 method for class 'zoo'
print(x, style = , quote = FALSE, ...)

Arguments

`x`	a numeric vector, matrix or a factor.
`order.by`	an index vector with unique entries by which the observations in `x` are ordered. See the details for support of non-unique indexes.
`frequency`	numeric indicating frequency of `order.by`. If specified, it is checked whether `order.by` and `frequency` comply. If so, a regular `"zoo"` series is returned, i.e., an object of class `c("zooreg", "zoo")`. See below and `zooreg` for more details.
`calendar`	logical. If `frequency` is specified and is 4 or 12: Should `yearqtr` or `yearmon` be used for a numeric index `order.by`?
`style`	a string specifying the printing style which can be `"horizontal"` (the default for vectors), `"vertical"` (the default for matrices) or `"plain"` (which first prints the data and then the index).
`quote`	logical. Should characters be quoted?
`...`	further arguments passed to the print methods of the data and the index.

Details

zoo provides infrastructure for ordered observations which are stored internally in a vector or matrix with an index attribute (of arbitrary class, see below). The index must have the same length as NROW(x) except in the case of a zero length numeric vector in which case the index length can be any length. Emphasis has been given to make all methods independent of the index/time class (given in order.by). In principle, the data x could also be arbitrary, but currently there is only support for vectors and matrices and partial support for factors.

zoo is particularly aimed at irregular time series of numeric vectors/matrices, but it also supports regular time series (i.e., series with a certain frequency). zoo's key design goals are independence of a particular index/date/time class and consistency with ts and base R by providing methods to standard generics. Therefore, standard functions can be used to work with "zoo" objects and memorization of new commands is reduced.

When creating a "zoo" object with the function zoo, the vector of indexes order.by can be of (a single) arbitrary class (if x is shorter or longer than order.by it is expanded accordingly), but it is essential that ORDER(order.by) works. For other functions it is assumed that c(), length(), MATCH() and subsetting [, work. If this is not the case for a particular index/date/time class, then methods for these generic functions should be created by the user. Note, that to achieve this, new generic functions ORDER and MATCH are created in the zoo package with default methods corresponding to the non-generic base functions order and match. Note that the order and hence the default ORDER typically work if there is a xtfrm method. Furthermore, for certain (but not for all) operations the index class should have an as.numeric method (in particular for regular series) and an as.character method might improve printed output (see also below).

The index observations order.by should typically be unique, such that the observations can be totally ordered. Nevertheless, zoo() is able to create "zoo" objects with duplicated indexes (with a warning) and simple methods such as plot() or summary() will typically work for such objects. However, this is not formally supported as the bulk of functionality provided in zoo requires unique index observations/time stamps. See below for an example how to remove duplicated indexes.

If a frequency is specified when creating a series via zoo, the object returned is actually of class "zooreg" which inherits from "zoo". This is a subclass of "zoo" which relies on having a "zoo" series with an additional "frequency" attribute (which has to comply with the index of that series). Regular "zooreg" series can also be created by zooreg, the zoo analogue of ts. See the respective help page and is.regular for further details.

Methods to standard generics for "zoo" objects currently include: print (see above), summary, str, head, tail, [ (subsetting), rbind, cbind, merge (see merge.zoo), aggregate (see aggregate.zoo), rev, split (see aggregate.zoo), barplot, plot and lines (see plot.zoo). For multivariate "zoo" series with column names the $ extractor is available, behaving similar as for "data.frame" objects. Methods are also available for median and quantile.

ifelse.zoo is not a method (because ifelse is not a generic) but must be written out including the .zoo suffix.

To “prettify” printed output of "zoo" series the generic function index2char is used for turning index values into character values. It defaults to using as.character but can be customized if a different printed display should be used (although this should not be necessary, usually).

The subsetting method [ work essentially like the corresponding functions for vectors or matrices respectively, i.e., takes indexes of type "numeric", "integer" or "logical". But additionally, it can be used to index with observations from the index class of the series. If the index class of the series is one of the three classes above, the corresponding index has to be encapsulated in I() to enforce usage of the index class (see examples). Subscripting by a zoo object whose data contains logical values is undefined.

Additionally, zoo provides several generic functions and methods to work (a) on the data contained in a "zoo" object, (b) the index (or time) attribute associated to it, and (c) on both data and index:

(a) The data contained in "zoo" objects can be extracted by coredata (strips off all "zoo"-specific attributes) and modified using coredata<-. Both are new generic functions with methods for "zoo" objects, see coredata.

(b) The index associated with a "zoo" object can be extracted by index and modified by index<-. As the interpretation of the index as “time” in time series applications is more natural, there are also synonymous methods time and time<-. The start and the end of the index/time vector can be queried by start and end. See index.

(c) To work on both data and index/time, zoo provides methods lag, diff (see lag.zoo) and window, window<- (see window.zoo).

In addition to standard group generic function (see Ops), the following mathematical operations are available as methods for "zoo" objects: transpose t which coerces to a matrix first, and cumsum, cumprod, cummin, cummax which are applied column wise.

Coercion to and from "zoo" objects is available for objects of various classes, in particular "ts", "irts" and "its" objects can be coerced to "zoo", the reverse is available for "its" and for "irts" (the latter in package tseries). Furthermore, "zoo" objects can be coerced to vectors, matrices and lists and data frames (dropping the index/time attribute). See as.zoo.

Several methods are available for NA handling in the data of "zoo" objects: na.aggregate which uses group means to fill in NA values, na.approx which uses linear interpolation to fill in NA values. na.contiguous which extracts the longest consecutive stretch of non-missing values in a "zoo" object, na.fill which uses fixed specified values to replace NA values, na.locf which replaces NAs by the last previous non-NA, na.omit which returns a "zoo" object with incomplete observations removed, na.spline which uses spline interpolation to fill in NA values and na.StructTS which uses a seasonal Kalman filter to fill in NA values, na.trim which trims runs of NAs off the beginning and end but not in the interior. Yet another NA routine can be found in the stinepack package where na.stinterp performs Stineman interpolation.

A typical task to be performed on ordered observations is to evaluate some function, e.g., computing the mean, in a window of observations that is moved over the full sample period. The generic function rollapply provides this functionality for arbitrary functions and more efficient versions rollmean, rollmax, rollmedian are available for the mean, maximum and median respectively.

The zoo package has an as.Date numeric method which is similar to the one in the core of R except that the origin argument defaults to January 1, 1970 (whereas the one in the core of R has no default).

Note that since zoo uses date/time classes from base R and other packages, it may inherit bugs or problems with those date/time classes. Currently, there is one such known problem with the c method for the POSIXct class in base R: If x and y are POSIXct objects with tzone attributes, the attribute will always be dropped in c(x, y), even if it is the same across both x and y. Although this is documented at c.POSIXct, one may want to employ a workaround as shown at https://stat.ethz.ch/pipermail/r-devel/2010-August/058112.html.

Value

A vector or matrix with an "index" attribute of the same dimension (NROW(x)) by which x is ordered.

References

Achim Zeileis and Gabor Grothendieck (2005). zoo: S3 Infrastructure for Regular and Irregular Time Series. Journal of Statistical Software, 14(6), 1-27. URL http://www.jstatsoft.org/v14/i06/ and available as vignette("zoo").

Ajay Shah, Achim Zeileis and Gabor Grothendieck (2005). zoo Quick Reference. Package vignette available as vignette("zoo-quickref").

Examples

suppressWarnings(RNGversion("3.5.0"))
set.seed(1)

## simple creation and plotting
x.Date <- as.Date("2003-02-01") + c(1, 3, 7, 9, 14) - 1
x <- zoo(rnorm(5), x.Date)
plot(x)
time(x)

## subsetting with numeric indexes
x[c(2, 4)]
## subsetting with index class
x[as.Date("2003-02-01") + c(2, 8)]

## different classes of indexes/times can be used, e.g. numeric vector
x <- zoo(rnorm(5), c(1, 3, 7, 9, 14))
## subsetting with numeric indexes then uses observation numbers
x[c(2, 4)]
## subsetting with index class can be enforced by I()
x[I(c(3, 9))]

## visualization
plot(x)
## or POSIXct
y.POSIXct <- ISOdatetime(2003, 02, c(1, 3, 7, 9, 14), 0, 0, 0)
y <- zoo(rnorm(5), y.POSIXct)
plot(y)

## create a constant series
z <- zoo(1, seq(4)[-2])

## create a 0-dimensional zoo series
z0 <- zoo(, 1:4)

## create a 2-dimensional zoo series
z2 <- zoo(matrix(1:12, 4, 3), as.Date("2003-01-01") + 0:3)

## create a factor zoo object
fz <- zoo(gl(2,5), as.Date("2004-01-01") + 0:9)

## create a zoo series with 0 columns
z20 <- zoo(matrix(nrow = 4, ncol = 0), 1:4)

## arithmetic on zoo objects intersects them first
x1 <- zoo(1:5, 1:5)
x2 <- zoo(2:6, 2:6)
10 * x1 + x2

## $ extractor for multivariate zoo series with column names
z <- zoo(cbind(foo = rnorm(5), bar = rnorm(5)))
z$foo
z$xyz <- zoo(rnorm(3), 2:4)
z

## add comments to a zoo object
comment(x1) <- c("This is a very simple example of a zoo object.",
  "It can be recreated using this R code: example(zoo)")
## comments are not output by default but are still there
x1
comment(x1)

# ifelse does not work with zoo but this works
# to create a zoo object which equals x1 at
# time i if x1[i] > x1[i-1] and 0 otherwise
(diff(x1) > 0) * x1

## zoo series with duplicated indexes
z3 <- zoo(1:8, c(1, 2, 2, 2, 3, 4, 5, 5))
plot(z3)
## remove duplicated indexes by averaging
lines(aggregate(z3, index(z3), mean), col = 2)
## or by using the last observation
lines(aggregate(z3, index(z3), tail, 1), col = 4)

## x1[x1 > 3] is not officially supported since
## x1 > 3 is of class "zoo", not "logical".
## Use one of these instead:
x1[which(x1 > 3)]
x1[coredata(x1 > 3)]
x1[as.logical(x1 > 3)]
subset(x1, x1 > 3)

## any class supporting the methods discussed can be used
## as an index class. Here are examples using complex numbers
## and letters as the time class.

z4 <- zoo(11:15, complex(real = c(1, 3, 4, 5, 6), imag = c(0, 1, 0, 0, 1)))
merge(z4, lag(z4))

z5 <- zoo(11:15, letters[1:5])
merge(z5, lag(z5))

# index values relative to 2001Q1
zz <- zooreg(cbind(a = 1:10, b = 11:20), start = as.yearqtr(2000), freq = 4)
zz[] <- mapply("/", as.data.frame(zz), coredata(zz[as.yearqtr("2001Q1")]))


## even though time index must be unique zoo (and read.zoo)
## will both allow creation of such illegal objects with
## a warning (rather than ana error) to give the user a 
## chance to fix them up.  Extracting and replacing times
## and aggregate.zoo will still work.
## Not run: 
# this gives a warning
# and then creates an illegal zoo object
z6 <- zoo(11:15, c(1, 1, 2, 2, 5))
z6

# fix it up by averaging duplicates
aggregate(z6, identity, mean)

# or, fix it up by taking last in each set of duplicates
aggregate(z6, identity, tail, 1)

# fix it up via interpolation of duplicate times
time(z6) <- na.approx(ifelse(duplicated(time(z6)), NA, time(z6)), na.rm = FALSE)
# if there is a run of equal times at end they
# wind up as NAs and we cannot have NA times
z6 <- z6[!is.na(time(z6))]
z6

x1. <- x1 <- zoo (matrix (1:12, nrow = 3), as.Date("2008-08-01") + 0:2)
colnames (x1) <- c ("A", "B", "C", "D")
x2 <- zoo (matrix (1:12, nrow = 3), as.Date("2008-08-01") + 1:3)
colnames (x2) <- c ("B", "C", "D", "E")

both.dates = as.Date (intersect (index (t1), index (t2)))
both.cols = intersect (colnames (t1), colnames (t2))

x1[both.dates, both.cols]
## there is "[.zoo" but no "[<-.zoo" however four of the following
## five examples work

## wrong
## x1[both.dates, both.cols] <- x2[both.dates, both.cols]

# 4 correct alternatives
# #1
window(x1, both.dates)[, both.cols] <- x2[both.dates, both.cols]

# #2. restore x1 and show a different way
x1 <- x1.
window(x1, both.dates)[, both.cols] <- window(x2, both.dates)[, both.cols]

# #3. restore x1 and show a different way
x1 <- x1.
x1[time(x1) 

# #4. restore x1 and show a different way
x1 <- x1.
x1[time(x1) 


## End(Not run)

`x`	an object of class `"zoo"`.
`by`	index vector of the same length as `index(x)` which defines aggregation groups and the new index to be associated with each group. If `by` is a function, then it is applied to `index(x)` to obtain the aggregation groups.
`FUN`	a function to compute the summary statistics which can be applied to all subsets. Always needs to return a result of fixed length (typically scalar).
`...`	further arguments passed to `FUN`.
`regular`	logical. Should the aggregated series be coerced to class `"zooreg"` (if the series is regular)? The default is `FALSE` for `"zoo"` series and `TRUE` for `"zooreg"` series.
`frequency`	numeric indicating the frequency of the aggregated series (if a `"zooreg"` series should be returned. The default is to determine the frequency from the data if `regular` is `TRUE`. If `frequency` is specified, it sets `regular` to `TRUE`. See examples for illustration.
`coredata`	logical. Should only the `coredata(x)` be passed to every `by` group? If set to `FALSE` the full zoo series is used.

`x`	an object.
`...`	further arguments passed to methods.
`value`	a suitable value object for use with `x`.

`x`	an object.
`value`	a frequency.

`object`	an object of class `"zoo"`.
`geom`	character (e.g., `"line"`) or function (e.g., `geom_line`) specifying which `geom` to use.
`facets`	specification of `facets` for `facet_grid`. The default in the `autoplot` method is to use `facets = NULL` for univariate series and `facets = Series ~ .` for multivariate series.
`...`	further arguments passed to `aes` for `autoplot` (e.g., `linetype = Series` and/or `shape = Series`). For `fortify` the arguments are not used. For the `scale__` functions the arguments are passed on to `scale_*_continuous`.
`model`	an object of class `"zoo"` to be converted to a `"data.frame"`.
`data`	not used (required by generic `fortify` method).
`names`	(list of) character vector(s). New names given to index/time column, series indicator (if melted), and value column (if melted). If only a subset of characters should be changed, either NAs can be used or a named vector.
`sep`	If specified then the Series column is split into multiple columns using sep as the split character.
`melt`	Should the resulting data frame be in long format (`melt = TRUE`) or wide format (`melt = FALSE`).
`margins`	As in `facet_grid`.
`scales`	As in `facet_grid` except it defaults to `"free_y"`.
`format`	A format acceptable to format.yearmon or format.yearqtr.
`n`	Approximate number of axis ticks.

`x`	an object.
`...`	further arguments passed to methods.
`value`	an ordered vector of the same length as the `"index"` attribute of `x`.

`x`	an object,
`...`	further arguments passed to `zoo` when the return object is created.

`x`	an object (representing a series of ordered observations).
`strict`	logical. Should strict regularity be checked? See details.

`x`	a `"zoo"` object.
`k`, `lag`	For `lag` the number of lags (in units of observations). Note the sign of `k` behaves as in `lag`. For `diff` it is the number of backward lags used (or if negative the number of forward lags.
`differences`	an integer indicating the order of the difference.
`arithmetic`	logical. Should arithmetic (or geometric) differences be computed?
`na.pad`	logical. If `TRUE` it adds any times that would not otherwise have been in the result with a value of `NA`. If `FALSE` those times are dropped.
`log`	logical. Should the differences of the log series be computed?
`...`	currently not used.

`nams`	character vector with names of variables.
`x`	list or vector of parameter specifications, see details.
`n`	numeric, number of rows.
`m`	numeric, number of columns. (Only determines whether `m` is 1 or greater than 1.
`def`	default parameter value.
`recycle`	logical. If `TRUE` recycle columns to provide unspecified ones. If `FALSE` use `def` to provide unspecified ones. This only applies to entire columns. Within columns recycling is always done regardless of how `recycle` is set. Defaults to `TRUE` if there is at least one unnamed variable and defaults to `FALSE` if there are only named variables in `x`.

`x`	an object.
`table`	the values to be matched against.
`nomatch`	the value to be returned in the case when no match is found. Note that it is coerced to `integer`.
`units`	See `trunc.times`.
`eps`	See `trunc.times`.
`...`	further arguments to be passed to methods.

`...`	two or more objects, usually of class `"zoo"`.
`all`	logical vector having the same length as the number of `"zoo"` objects to be merged (otherwise expanded).
`fill`	an element for filling gaps in merged `"zoo"` objects (if any).
`suffixes`	character vector of the same length as the number of `"zoo"` objects specifying the suffixes to be used for making the merged column names unique.
`check.names`	See `read.table`.
`retclass`	character that specifies the class of the returned result. It can be `"zoo"` (the default), `"list"` or `NULL`. For details see below.
`drop`	logical. If a `"zoo"` object without observations is merged with a one-dimensional `"zoo"` object (vector or 1-column matrix), should the result be a vector (`drop = TRUE`) or a 1-column matrix (`drop = FALSE`)? The former is the default in the `Merge` method, the latter in the `cbind` method.
`sep`	character. Separator character that should be used when pasting `suffixes` to column names for making them unique.

`object`	object in which `NA`s are to be replaced
`x`, `xout`	Variables to be used for interpolation as in `approx`.
`na.rm`	logical. If the result of the (spline) interpolation still results in leading and/or trailing `NA`s, should these be removed (using `na.trim`)?
`maxgap`	maximum number of consecutive `NA`s to fill. Any longer gaps will be left unchanged. Note that all methods listed above can accept `maxgap` as it is ultimately passed to the `default` method. In `na.spline` the `maxgap` argument cannot be combined with `xout`, though.
`along`	deprecated.
`...`	further arguments passed to methods. The `n` argument of `approx` is currently not supported.

`object`	an object.
`sides`	character specifying whether `NA`s are to be removed from both sides, just from the left side or just from the right side.
`is.na`	If "any" then a row will be regarded as `NA` if it has any `NA`s. If "all" then a row will be regarded as `NA` only if all elements in the row are `NA`. For one dimensional zoo objects this argument has no effect.
`maxgap`	maximum number of consecutive `NA`s to trim. Any longer gaps will be left unchanged.
`...`	further arguments passed to methods.

`x`	an object of class `"zoo"`.
`y`	an object of class `"zoo"`. If `y` is `NULL` (the default) a time series plot of `x` is produced, otherwise if both `x` and `y` are univariate `"zoo"` series, a scatter plot of `y` versus `x` is produced.
`screens`	factor (or coerced to factor) whose levels specify which graph each series is to be plotted in. `screens=c(1,2,1)` would plot series 1, 2 and 3 in graphs 1, 2 and 1. If not specified then 1 is used if `plot.type="single"` and `seq_len(ncol(x))` otherwise.
`plot.type`	for multivariate zoo objects, "multiple" plots the series on multiple plots and "single" superimposes them on a single plot. Default is "single" if `screens` has only one level and `"multiple"` otherwise. If neither `screens` nor `plot.type` is specified then `"single"` is used if there is one series and `"mulitple"` otherwise. This option is provided for back compatibility. Usually `screens` is used instead.
`panel`	a `function(x, y, col, lty, ...)` which gives the action to be carried out in each panel of the display for `plot.type = "multiple"`.
`ylim`	if `plot.type = "multiple"` then it can be a list of y axis limits. If not a list each graph has the same limits. If any list element is not a pair then its range is used instead. If `plot.type = "single"` then it is as in `plot`.
`xy.labels`	logical, indicating if `text` labels should be used in the scatter plot, or character, supplying a vector of labels to be used.
`xy.lines`	logical, indicating if `lines` should be drawn in the scatter plot. Defaults to the value of `xy.labels` if that is logical, otherwise to `FALSE`.
`yax.flip`	logical, indicating if the y-axis (ticks and numbering) should flip from side 2 (left) to 4 (right) from series to series when `type = "multiple"`.
`xlab`, `ylab`, `main`, `xlim`, `oma`, `mar`	graphical arguments, see `par`.
`col`, `lty`, `lwd`, `pch`, `type`	graphical arguments that can be vectors or (named) lists. See the details for more information.
`log`	specification of log scales as `"x"`, `"y"` or `"xy"`.
`nc`	the number of columns to use when `plot.type = "multiple"`. Defaults to `1` for up to `4` series, otherwise to `2`.
`widths`, `heights`	widths and heights for individual graphs, see `layout`.
`...`	additional graphical arguments.

`data`	the data to be used (representing a series of observations).
`width`	numeric vector or list. In the simplest case this is an integer specifying the window width (in numbers of observations) which is aligned to the original sample according to the `align` argument. Alternatively, `width` can be a list regarded as offsets compared to the current time, see below for details.
`FUN`	the function to be applied.
`...`	optional arguments to `FUN`.
`by`	calculate FUN at every `by`-th time point rather than every point. `by` is only used if `width` is length 1 and either a plain scalar or a list.
`by.column`	logical. If `TRUE`, `FUN` is applied to each column separately.
`fill`	a three-component vector or list (recycled otherwise) providing filling values at the left/within/to the right of the data range. See the `fill` argument of `na.fill` for details.
`na.pad`	deprecated. Use `fill = NA` instead of `na.pad = TRUE`.
`partial`	logical or numeric. If `FALSE` (default) then `FUN` is only applied when all indexes of the rolling window are within the observed time range. If `TRUE`, then the subset of indexes that are in range are passed to `FUN`. A numeric argument to `partial` can be used to determin the minimal window size for partial computations. See below for more details.
`align`	specifyies whether the index of the result should be left- or right-aligned or centered (default) compared to the rolling window of observations. This argument is only used if `width` represents widths.
`coredata`	logical. Should only the `coredata(data)` be passed to every `width` window? If set to `FALSE` the full zoo series is used.

`x`	an object (representing a series of observations).
`k`	integer width of the rolling window. Must be odd for `rollmedian`.
`fill`	a three-component vector or list (recycled otherwise) providing filling values at the left/within/to the right of the data range. See the `fill` argument of `na.fill` for details.
`na.pad`	deprecated. Use `fill = NA` instead of `na.pad = TRUE`.
`align`	character specifying whether the index of the result should be left- or right-aligned or centered (default) compared to the rolling window of observations.
`...`	Further arguments passed to methods.

`x`	an object.
`index.`	the index/time window which should be extracted.
`start`	an index/time value. Only the indexes in `index` which are greater or equal to `start` are used. If the index class supports comparisons to character variables, as does `"Date"` class, `"yearmon"` class, `"yearqtr"` class and the `chron` package classes `"dates"` and `"times"` then `start` may alternately be a character variable.
`end`	an index/time value. Only the indexes in `index` which are lower or equal to `end` are used. Similar comments about character variables mentioned under `start` apply here too.
`value`	a suitable value object for use with `window(x)`.
`...`	currently not used.

`x`, `y`	In the default method, `x` gives the ordinates along the x axis and must be in increasing order. `y` gives the color values to plot as contiguous blocks. If `y` is numeric, data coverage is plotted, by converting it into a logical (`!is.na(y)`). Finally, if `y` is a function, it is applied to `x` (`time(x)` in the time series methods). If `y` has character (or factor) values, these are interpreted as colors – and should therefore be color names or hex codes. Missing values in `y` are not plotted. The default color is taken from `palette()[1]`. If `col` is given, this over-rides the block colors given as `y`. The `ts` and `zoo` methods plot the `coredata(y)` values against the time index `index(x)`.
`...`	In the default method, further arguments are graphical parameters passed on to `gpar`.
`col`	if `col` is specified, it determines the colors of the blocks defined by `y`. If multiple colors are specified they will be repeated to cover the total number of blocks.
`border`	border color.
`ybottom`, `ytop`, `height`	y axis position of the blocks. The default it to fill the whole plot region, but by setting these values one can draw blocks along the top of bottom of the plot. Note that `height` is not used directly, it only sets the default value of `ytop`.
`last.step`	width (in native units) of the final block. Defaults to the median of the last 5 time steps (assuming steps are regular).

`x`, `x0`, `x1`	time series object of class `"zoo"`, `"its"` or `"tis"`. For `panel.plot.default` it should be a numeric vector.
`y`	numeric vector or matrix.
`data`	not used.
`...`	arguments are passed to `xyplot.ts`, and may be passed through to `xyplot` and `panel.xyplot`. Some of the commonly used arguments are: `screens` factor (or coerced to factor) whose levels specify which graph each series is to be plotted in. `screens = c(1, 2, 1)` would plot series 1, 2 and 3 in graphs 1, 2 and 1. This also defines the strip text in multi-panel plots. `scales` the default is set so that all series have the `"same"` X axis but `"free"` Y axis. See `xyplot` in the lattice package for more information on `scales`. `layout` numeric vector of length 2 specifying number of columns and rows in the plot, see `xyplot` for more details. The default is to fill columns with up to 6 rows. `xlab` character string used as the X axis label. `ylab` character string used as the Y axis label. If there are multiple panels it may be a character vector the same length as the number of panels, but NOTE in this case the vector should be reversed OR the argument `as.table` set to `FALSE`. `lty, lwd, pch, type, col` graphical arguments passed to `panel.xyplot`. These arguments can also be vectors or (named) lists, see details for more information.

`x`	for `yearqtr` a numeric (interpreted as being “in years”). For `as.yearqtr` another date class object. For the `"yearqtr"` method of `format` an object of class `"yearqtr"` or if called as `format.yearqtr` then an object with an `as.yearqtr` method that can be coerced to `"yearqtr"`.
`format`	character string specifying format. For coercing to `"yearqtr"` from character: `"%Y"` and `"%q"` have to be specified. For formatting an existing `"yearqtr"`: `"%C"`, `"%Y"`, `"%y"` and `"%q"`, if present, are replaced with the century, year, last two digits of the year, and quarter (i.e. a number between 1 and 4), respectively.
`...`	arguments passed ot other methods.

Package 'zoo'

Help Index

Compute Summary Statistics of zoo Objects

Description

Usage

Arguments

Value

Note

See Also

Examples

Coercion from and to zoo

Description

Usage

Arguments

Details

Value

See Also

Examples

Extracting/Replacing the Core Data of Objects

Description

Usage

Arguments

Value

See Also

Examples

Replacing the Index of Objects

Description

Usage

Arguments

Details

See Also

Examples

Convenience Functions for Plotting zoo Objects with ggplot2

Description

Usage

Arguments

Details

Value

Author(s)

See Also

Examples

Extracting/Replacing the Index of Objects

Description

Usage

Arguments

Details

See Also

Examples

Check Regularity of a Series

Description

Usage

Arguments

Details

Value

See Also

Examples

Lags and Differences of zoo Objects

Description

Usage

Arguments

Details

Value

Note

See Also

Examples

Make a List from a Parameter Specification

Description

Usage

Arguments

Details

Value

Examples

Value Matching

Description

Usage

Arguments

Details

See Also

Examples

Merge Two or More zoo Objects