Description
read.zoo
and write.zoo
are convenience functions for readingand writing "zoo"
series from/to text files. They are convenienceinterfaces to read.table
and write.table
, respectively.To employ read.csv
, read.csv2
, read.delim
,read.delim2
instead of read.table
additional functionsread.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, ...)read.csv.zoo(..., read = read.csv)read.csv2.zoo(..., read = read.csv2)read.delim.zoo(..., read = read.delim)read.delim2.zoo(..., read = read.delim2)
Value
read.zoo
returns an object of class "zoo"
(or "zooreg"
).
Arguments
character string or strings giving the name of the file(s) which the data are to be read from/written to. See date format argument passed to time zone argument passed to read.table
and write.table
for more information. Alternatively, in read.zoo
, file
can be a connection
or adata.frame
(e.g., resulting from a previous read.table
call) that is subsequently processed to a "zoo"
series.FUN
.as.POSIXct
.
a function for computing the index from the first column of the data. See details.
logical. Should the series be coerced to class "zooreg"
(if the series is regular)?
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.
logical. If the data frame contains just a single data column, should the second dimension be dropped?
a "zoo"
object.
character with name of the index column in the written data file.
logical. Should row names be written? Default is FALSE
because the row names are just character representations of the index.
logical. Should column names be written? Default is to write column names only if x
has column names.
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.
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.
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
.
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.
function. The function for reading file
(unless it is a data.frame
already).
Details
read.zoo
is a convenience function which should make it easierto 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 isinterpreted 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 and1, 2, ...
are used for the index.) To assign the appropriate classto 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 thefirst argument. If FUN
is not specified, the following default is employed:
(a) If file
is a data frame with a singleindex 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 theindex column is converted to POSIXct
. (2) If format
is specifiedthen the index column is converted to Date
. (3) Otherwise, a heuristicattempts to decide between "numeric"
, "POSIXct"
, and "Date"
bytrying 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 evenif the default format is appropriate for the index, explicitly supplyingFUN
or at least format
and/or tz
typically leads to morereliable 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"
seriesto text files. It first coerces its argument to a "data.frame"
, addsa column with the index and then calls write.table
.
See also vignette("zoo-read", package = "zoo")
for detailed examples.
See Also
zoo