| xyplot {lattice} | R Documentation |
These are the most commonly used high level Trellis functions to plot
pairs of variables. By far the most common is xyplot, designed
mainly for two continuous variates (though factors can be supplied as
well, in which case they will simply be coerced to numeric), which
produces Conditional Scatter plots. The others are useful when one of
the variates is a factor or a shingle. Most of these arguments are
also applicable to other high level functions in the lattice package,
but are only documented here.
xyplot(x, data, ...)
dotplot(x, data, ...)
barchart(x, data, ...)
stripplot(x, data, ...)
bwplot(x, data, ...)
## S3 method for class 'formula':
xyplot(x,
data,
allow.multiple = is.null(groups) || outer,
outer = !is.null(groups),
auto.key = FALSE,
aspect = "fill",
panel = "panel.xyplot",
prepanel = NULL,
scales = list(),
strip = TRUE,
groups = NULL,
xlab,
xlim,
ylab,
ylim,
drop.unused.levels = lattice.getOption("drop.unused.levels"),
...,
default.scales,
subscripts = !is.null(groups),
subset = TRUE)
## S3 method for class 'formula':
dotplot(x,
data,
panel = "panel.dotplot",
...)
## S3 method for class 'formula':
barchart(x,
data,
panel = "panel.barchart",
box.ratio = 2,
...)
## S3 method for class 'formula':
stripplot(x,
data,
panel = "panel.stripplot",
...)
## S3 method for class 'formula':
bwplot(x,
data,
allow.multiple = is.null(groups) || outer,
outer = FALSE,
auto.key = FALSE,
aspect = "fill",
panel = "panel.bwplot",
prepanel = NULL,
scales = list(),
strip = TRUE,
groups = NULL,
xlab,
xlim,
ylab,
ylim,
box.ratio = 1,
horizontal = NULL,
drop.unused.levels = lattice.getOption("drop.unused.levels"),
...,
default.scales,
subscripts = !is.null(groups),
subset = TRUE)
x |
The object on which method dispatch is carried out.
For the "formula" methods, a formula describing the form of
conditioning plot. The formula is generally of the form y ~ x
| g1 * g2 * ..., indicating that plots of y (on the y
axis) versus x (on the x axis) should be produced conditional
on the variables g1, g2, .... However, the conditioning
variables g1,g2,... may be omitted. The formula can also be
supplied as y ~ x | g1 + g2 + ....
For all of these functions, with the exception of xyplot, a
formula of the form ~ x | g1 * g2 * ... is also
allowed. In that case, y defaults to names(x) if
x is named, and a factor with a single level otherwise.
Other usage of the form dotplot(x) is handled by method
dispatch as appropriate. The numeric method is equivalent to
a call with no left hand side and no conditioning variables in the
formula. For barchart and dotplot, non-trivial
methods exist for tables and arrays, documented under
barchart.table.
The conditioning variables g1, g2, ... must be either
factors or shingles. Shingles are a way of processing numeric
variables for use in conditioning. See documentation of
shingle for details. Like factors, they have a
"levels" attribute, which is used in producing the
conditional plots.
Numeric conditioning variables are converted to shingles by the function shingle (however, using equal.count
might be more appropriate in many cases) and character vectors are
coerced to factors.
The formula can involve expressions, e.g. sqrt(),
log().
A special case is when the left and/or right sides of the formula (before the conditioning variables) contain a ‘+’ sign, e.g., y1+y2 ~ x | a*b. This formula would be taken to mean that the
user wants to plot both y1~x | a*b and y2~x | a*b, but
with the y1~x and y2~x superposed in each panel (this
is slightly more complicated in barchart). The two parts
would be distinguished by different graphical parameters. This is
essentially what the groups argument would produce, if
y1 and y2 were concatenated to produce a longer
vector, with the groups argument being an indicator of which
rows come from which variable. In fact, this is exactly what is
done internally using the reshape function. This
feature cannot be used in conjunction with the groups
argument.
To interpret y1 + y2 as a sum, one can either set
allow.multiple=FALSE or use I(y1+y2).
A variation on this feature is when the outer argument is set
to TRUE as well as allow.multiple. In that case, the
plots are not superposed in each panel, but instead separated into
different panels (as if a new conditioning variable had been added).
The x and y variables should both be numeric in
xyplot, and an attempt is made to coerce them if
not. However, if either is a factor, the levels of that factor are
used as axis labels. In the other four functions documented here,
exactly one of x and y should be numeric, and the
other a factor or shingle. Which of these will happen is determined
by the horizontal argument — if horizontal=TRUE,
then y will be coerced to be a factor or shingle, otherwise
x. The default value of horizontal is FALSE if
x is a factor or shingle, TRUE otherwise. (The
functionality provided by horizontal=FALSE is not
S-compatible.)
Note that this argument used to be called formula in earlier
versions (when the high level functions were not generic and the
formula method was essentially the only method). This is no longer
allowed. It is recommended that this argument not be named in any
case, but rather be the first (unnamed) argument.
|
data |
For the formula method, a data frame containing values for
any variables in the formula, as well as groups and
subset if applicable. If not found in data, or if
data is unspecified, the variables are looked for in the
environment of the formula. For other methods (where x is
not a formula), data is usually ignored, often with a
warning.
|
allow.multiple, outer |
logical flags to control what happens with formulas like y1 +
y2 ~ x. See the entry for x for details.
allow.multiple defaults to TRUE whenever it makes
sense, and outer defaults to FALSE except when
groups is explicitly specified or grouping doesn't make sense
for the default panel function
|
box.ratio |
applicable to bwplot, barchart and
stripplot, specifies the ratio of the width of the rectangles
to the inter rectangle space.
|
horizontal |
logical, applicable to bwplot, dotplot,
barchart and stripplot. Determines which of x and
y is to be a factor or shingle (y if TRUE, x
otherwise). Defaults to FALSE if x is a factor or
shingle, TRUE otherwise. This argument is used to process the
arguments to these high level functions, but more importantly, it is
passed as an argument to the panel function, which is supposed to
use it as appropriate.
A potentially useful component of scales in this case might
be abbreviate = TRUE, in which case long labels which would
usually overlap will be abbreviated. scales could also
contain a minlength argument in this case, which would be
passed to the abbreviate function.
|
panel |
Once the subset of rows defined by each unique combination of the
levels of the grouping variables are obtained (see details), the
corresponding x and y variables (or other variables,
as appropriate, in the case of other high level functions) are
passed on to be plotted in each panel. The actual plotting is done
by the function specified by the panel argument. Each high
level function has its own default panel function, which could
depend on whether the groups argument was supplied.
The panel function can be a function object or a character string giving the name of a predefined function. Much of the power of Trellis Graphics comes from the ability to define customized panel functions. A panel function appropriate for the functions described here would usually expect arguments named x and y, which would be provided by the
conditioning process. It can also have other arguments. It might be
useful to know in this context that all arguments passed to a high
level Trellis function (such as xyplot) that are not
recognized by it are passed through to the panel function. It is
thus generally good practice when defining panel functions to allow
a ... argument. Such extra arguments typically control
graphical parameters, but other uses are also common. See
documentation for individual panel functions for specifics.
Note that unlike in S-PLUS, it is not guaranteed that panel functions will be supplied only numeric vectors for the x and
y arguments; they can be factors as well (but not
shingles). Panel functions need to handle this case, which in most
cases can be done by simply coercing them to numeric.
Technically speaking, panel functions must be written using Grid graphics functions. However, knowledge of Grid is usually not necessary to construct new custom panel functions, there are several predefined panel functions which can help; for example, panel.grid, panel.loess, etc. There are also some
grid-compatible replacements of commonly used base R graphics
functions useful for this purpose. For example, lines can be
replaced by llines (or equivalently, panel.lines).
Note that base R graphics functions like lines will not work
in a lattice panel function.
One case where a bit more is required of the panel function is when the groups argument is not null. In that case, the panel
function should also accept arguments named groups and
subscripts (see below for details). A useful panel function
predefined for use in such cases is panel.superpose, which
can be combined with different panel.groups functions
determining what is plotted for each group. See the examples
section for an interaction plot constructed in this way. Several
other panel functions can also handle the groups argument,
including the default ones for barchart, dotplot and
stripplot.
Even when groups is not present, the panel function can have
subscripts as a formal argument. In either case, the
subscripts argument passed to the panel function are the
indices of the x and y data for that panel in the
original data, BEFORE taking into account the effect of
the subset argument. Note that groups remains
unaffected by any subsetting operations, so
groups[subscripts] gives the values of groups that
correspond to the data in that panel. The value of
subscripts becomes slightly more complicated when
allow.multiple is in effect. Details can be found in the
source code of the function latticeParseFormula.
A panel function can have two other optional arguments for convenience, namely panel.number and packet.number,
representing panel order and packet order respectively. Both
provide a simple integer index indicating which panel is currently
being drawn, but differ in how the count is calculated.
panel.number is a simple incremental counter that starts with
1 and is incremented each time a panel is drawn.
packet.number on the other hand indexes the combination of
levels of the conditioning variables that is represented by that
panel. The two indices coincide unless the order of conditioning
variables is permuted and/or the plotting order of levels within one
or more conditioning variables is altered (using perm.cond
and index.cond respectively), in which case
packet.number gives the index corresponding to the
‘natural’ ordering of that combination of levels of the
conditioning variables.
panel.xyplot has an argument called type which is
worth mentioning here because it is quite frequently used (and as
mentioned above, can be passed to xyplot directly). panel
functions for bwplot and friends should have an argument
called horizontal to account for the cases when x is
the factor or shingle.
|
aspect |
controls physical aspect ratio of the panels (same for
all the panels). It can be specified as a ratio (vertical
size/horizontal size) or as a character string. Legitimate
values are "fill" (the default) which tries to make the
panels as big as possible to fill the available space; "xy",
which tries to compute the aspect based on the 45 degree
banking rule (see Visualizing Data by William S. Cleveland
for details); and "iso" for isometric scales, where the
relation between physical distance on the device and distance in the
data scale are forced to be the same for both axes.
If a prepanel function is specified and it returns components
dx and dy, these are used for banking calculations.
Otherwise, values from the default prepanel function are used.
Currently, only the default prepanel function for xyplot can
be expected to produce sensible banking calculations. See
banking for details on the implementation of banking .
|
groups |
a variable or expression to be evaluated in the data
frame specified by data, expected to act as a grouping
variable within each panel, typically used to distinguish different
groups by varying graphical parameters like color and line type.
Formally, if groups is specified, then groups along
with subscripts is passed to the panel function, which is
expected to handle these arguments. Not all pre-defined panel
functions know how to, but for high level functions where grouping
is appropriate, the default panel functions are chosen so that they
do.
It is very common to use a key (legend) when a grouping variable is specified. See entries for key, auto.key
and simpleKey for how to draw a key.
|
auto.key |
A logical (indicating whether a key is to be drawn automatically when
a grouping variable is present in the plot), or a list of parameters
that would be valid arguments to simpleKey. If
auto.key is not FALSE, groups is non-null and
there is no key or legend argument specified in the
call, a key is created with simpleKey with
levels(groups) as the first argument. (Note: this may not
work in all high level functions, but it does work for the ones
where grouping makes sense with the default panel function)
simpleKey uses the trellis settings to determine the
graphical parameters in the key, so this will be meaningful only if
the settings are used in the plot as well.
One disadvantage to using key (or even simpleKey)
directly is that the graphical parameters used in the key are
absolutely determined at the time when the "trellis" object is
created. Consequently, if a plot once created is re-printed
with different settings, the parameter settings for the original
device will be used. However, with auto.key, the key is
actually created at printing time, so the key settings will match
the device settings.
|
prepanel |
function that takes the same arguments as the panel function
and returns a list, possibly containing components named
xlim, ylim, dx and dy (and less
frequently, xat and yat).
The xlim and ylim components are similar to the high
level xlim and ylim arguments (i.e., they are usually
a numeric vector of length 2 defining a range of values, or a
character vector representing levels of a factor). If the
xlim and ylim arguments are not explicitly specified
(possibly as components in scales), then the actual limits of
the panels are guaranteed to include the limits returned by the
prepanel function. This happens globally if the relation
component of scales is "same", and on a panel by panel
basis otherwise. See xlim to see what forms of the components
xlim and ylim are allowed.
The dx and dy components are used for banking
computations in case aspect is specified as "xy". See
documentation for the function banking for details regarding
how this is done.
The return value of the prepanel function need not have all the components named above; in case some are missing, they are replaced by the usual component-wise defaults. If xlim or ylim is a character vector (which is
appropriate when the corresponding variable is a factor), this
implicitly indicates that the scale should include the first
n integers, where n is the length of xlim or
ylim, as the case may be. The elements of the character
vector are used as the default labels for these n integers.
Thus, to make this information consistent between panels, the
xlim or ylim values should represent all the levels of
the corresponding factor, even if some are not used within that
particular panel.
In such cases, an additional component xat or yat may
be returned by the prepanel function, which should be a
subset of 1:n, indicating which of the n values
(levels) are actually represented in the panel. This is useful when
calculating the limits with relation="free" or
relation="sliced" in scales.
The prepanel function is responsible for providing a meaningful return value when the x, y (etc.) variables are
zero-length vectors. When nothing is appropriate, values of NA
should be returned for the xlim and ylim components.
|
strip |
logical flag or function. If FALSE, strips are not drawn.
Otherwise, strips are drawn using the strip function, which
defaults to strip.default. See documentation of
strip.default to see the arguments that are available to the
strip function. This description also applies to the
strip.left argument (see ... below), which can be
used to draw strips on the left of each panel, which can be useful
for wide short panels, e.g. in time series plots.
|
xlab |
character string or expression (or a "grob") giving
label for the x-axis. Defaults to the expression for x in
formula. Can be specified as NULL to omit the label
altogether. Finer control is possible, as described in the entry
for main, with the additional feature that if the
label component is omitted from the list, it is replaced by
the default xlab.
|
ylab |
character string or expression (or "grob") giving
label for the y-axis. Defaults to the expression for y in
formula. Fine control is possible, see entries for
main and xlab.
|
scales |
list determining how the x- and y-axes (tick marks and
labels) are drawn. The list contains parameters in
name=value form, and may also contain two other lists called
x and y of the same form (described below).
Components of x and y affect the respective axes only,
while those in scales affect both. When parameters are
specified in both lists, the values in x or y are
used. Note that certain high-level functions have defaults that are
specific to a particular axis (e.g., bwplot has
alternating=FALSE for the y-axis only); these can be
overridden only by an entry in the corresponding component of
scales.
The possible components are :
Note that much of the function of scales is accomplished by
pscales in splom.
|
subscripts |
logical specifying whether or not a vector named subscripts
should be passed to the panel function. Defaults to FALSE,
unless groups is specified, or if the panel function accepts
an argument named subscripts. (One should be careful when
defining the panel function on-the-fly.)
|
subset |
logical or integer indexing vector (can be specified in terms of
variables in data). Only these rows of data will be
used for the plot. If subscripts is TRUE, the
subscripts will provide indices to the rows of data before the
subsetting is done. Whether levels of factors in the data frame
that are unused after the subsetting will be dropped depends on the
drop.unused.levels argument.
|
xlim |
Normally a numeric vector of length 2 (possibly a
DateTime object) giving minimum and maximum for the x-axis, or, a
character vector, expected to denote the levels of x. The
latter form is interpreted as a range containing c(1, length(xlim)),
with the character vector determining labels at tick positions
1:length(xlim)
xlim could also be a list, with as many components as the
number of panels (recycled if necessary), with each component as
described above. This is meaningful only when
scales$x$relation is "free" or "sliced", in
which case these are treated as if they were the corresponding limit
components returned by prepanel calculations.
|
ylim |
similar to xlim, applied to the y-axis. |
drop.unused.levels |
logical indicating whether the unused levels of factors will be
dropped. Unused levels are usually dropped, but it is sometimes
appropriate to suppress dropping to preserve a useful layout. For
finer control, this argument could also be list containing
components cond and data, both logical, indicating
desired behavior for conditioning variables and data variables
respectively. The default is given by
lattice.getOption("drop.unused.levels") , which is initially
set to TRUE for both components.
|
default.scales |
list giving the default values of scales for a particular
high level function. This should not be of any interest to the
normal user, but may be helpful when defining other functions that
act as a wrapper to one of the high level lattice functions.
|
... |
further arguments, usually not directly processed by the
high level functions documented here, but rather passed on to other
functions. Such arguments can be broadly categorized into two types:
those that affect all high level Trellis functions in a similar
manner, and those that are meant for the specific panel function
used, which may differ across high level functions.
The first group of arguments are processed by a common, unexported function called trellis.skeleton. These arguments affect all
high level functions, but are only documented here, except to
override the behaviour described here. All other arguments
specified in a high level call, specifically those neither described
here nor in the help page of the relevant high level function, are
passed unchanged to the panel function used. By convention, the
default panel function used for any high level function is named as
"panel." followed by the name of the high level function;
for example, the default panel function for bwplot is
panel.bwplot. In practical terms, this means that in
addition to the help page of the high level function being used, the
user should also consult the help page of the corresponding panel
function for arguments that may be specified in the high level call.
The effect of the first group of common arguments are as follows:
|
All the functions documented here are generic, with the formula
method usually doing the actual work. The structure of the plot that
is produced is mostly controlled by the formula. For each unique
combination of the levels of the conditioning variables g1, g2,
..., a separate panel is produced using the points (x,y)
for the subset of the data (also called packet) defined by that
combination. The display can be though of as a 3-dimensional array of
panels, consisting of one 2-dimensional matrix per page. The
dimensions of this array are determined by the layout argument.
If there are no conditioning variables, the plot produced consists of
a single panel.
The coordinate system used by lattice by default is like a graph,
with the origin at the bottom left, with axes increasing to left and
up. In particular, panels are by default drawn starting from the
bottom left corner, going right and then up; unless as.table =
TRUE, in which case panels are drawn from the top left corner,
going right and then down. One might wish to set a global preference
for a table-like arrangement by changing the default to
as.table=TRUE; this can be done by setting
lattice.options(default.args = list(as.table = TRUE)). In
fact, default values can be set in this manner for the following
arguments: as.table, aspect, between,
page, main, sub, par.strip.text,
layout, skip and strip. Note that these global
defaults are sometimes overridden by individual functions.
The order of the panels depends on the order in which the conditioning
variables are specified, with g1 varying fastest. Within a
conditioning variable, the order depends on the order of the levels
(which for factors is usually in alphabetical order). Both of these
orders can be modified using the index.cond and
perm.cond arguments, possibly using the
update (and other related)
method(s).
An object of class "trellis". The
update method can be used to
update components of the object and the
print method (usually called by
default) will plot it on an appropriate plotting device.
Most of the arguments documented here are also applicable for the other high level functions in the lattice package. These are not described in any detail elsewhere unless relevant, and this should be considered the canonical documentation for such arguments.
Any arguments passed to these functions and not recognized by them will be passed to the panel function. Most predefined panel functions have arguments that customize its output. These arguments are described only in the help pages for these panel functions, but can usually be supplied as arguments to the high level plot.
Deepayan Sarkar Deepayan.Sarkar@R-project.org
Lattice for an overview of the package, as well as
barchart.table,
Lattice,
print.trellis,
shingle,
banking,
reshape,
panel.xyplot,
panel.bwplot,
panel.barchart,
panel.dotplot,
panel.stripplot,
panel.superpose,
panel.loess,
panel.linejoin,
strip.default,
simpleKey
trellis.par.set
## Not run:
## wait for user input before each new page (like 'par(ask = TRUE)')
old.prompt <- grid::grid.prompt(TRUE)
## End(Not run)
require(stats)
## Tonga Trench Earthquakes
Depth <- equal.count(quakes$depth, number=8, overlap=.1)
xyplot(lat ~ long | Depth, data = quakes)
update(trellis.last.object(),
strip = strip.custom(strip.names = TRUE, strip.levels = TRUE),
par.strip.text = list(cex = 0.75),
aspect = "iso")
## Examples with data from `Visualizing Data' (Cleveland)
## (obtained from Bill Cleveland's Homepage :
## http://cm.bell-labs.com/cm/ms/departments/sia/wsc/, also
## available at statlib)
EE <- equal.count(ethanol$E, number=9, overlap=1/4)
## Constructing panel functions on the fly; prepanel
xyplot(NOx ~ C | EE, data = ethanol,
prepanel = function(x, y) prepanel.loess(x, y, span = 1),
xlab = "Compression Ratio", ylab = "NOx (micrograms/J)",
panel = function(x, y) {
panel.grid(h=-1, v= 2)
panel.xyplot(x, y)
panel.loess(x,y, span=1)
},
aspect = "xy")
## with and without banking
plot <- xyplot(sunspot.year ~ 1700:1988, xlab = "", type = "l",
scales = list(x = list(alternating = 2)),
main = "Yearly Sunspots")
print(plot, position = c(0, .3, 1, .9), more = TRUE)
print(update(plot, aspect = "xy", main = "", xlab = "Year"),
position = c(0, 0, 1, .3))
## Multiple variables in formula for grouped displays
xyplot(Sepal.Length + Sepal.Width ~ Petal.Length + Petal.Width | Species,
data = iris, scales = "free", layout = c(2, 2),
auto.key = list(x = .6, y = .7, corner = c(0, 0)))
## user defined panel functions
states <- data.frame(state.x77,
state.name = dimnames(state.x77)[[1]],
state.region = state.region)
xyplot(Murder ~ Population | state.region, data = states,
groups = state.name,
panel = function(x, y, subscripts, groups)
ltext(x = x, y = y, label = groups[subscripts], cex=1,
fontfamily = "HersheySans"))
barchart(yield ~ variety | site, data = barley,
groups = year, layout = c(1,6),
ylab = "Barley Yield (bushels/acre)",
scales = list(x = list(abbreviate = TRUE,
minlength = 5)))
barchart(yield ~ variety | site, data = barley,
groups = year, layout = c(1,6), stack = TRUE,
auto.key = list(points = FALSE, rectangles = TRUE, space = "right"),
ylab = "Barley Yield (bushels/acre)",
scales = list(x = list(rot = 45)))
bwplot(voice.part ~ height, data=singer, xlab="Height (inches)")
dotplot(variety ~ yield | year * site, data=barley)
dotplot(variety ~ yield | site, data = barley, groups = year,
key = simpleKey(levels(barley$year), space = "right"),
xlab = "Barley Yield (bushels/acre) ",
aspect=0.5, layout = c(1,6), ylab=NULL)
stripplot(voice.part ~ jitter(height), data = singer, aspect = 1,
jitter = TRUE, xlab = "Height (inches)")
## Interaction Plot
xyplot(decrease ~ treatment, OrchardSprays, groups = rowpos,
type = "a",
auto.key =
list(space = "right", points = FALSE, lines = TRUE))
## longer version with no x-ticks
## Not run:
bwplot(decrease ~ treatment, OrchardSprays, groups = rowpos,
panel = "panel.superpose",
panel.groups = "panel.linejoin",
xlab = "treatment",
key = list(lines = Rows(trellis.par.get("superpose.line"),
c(1:7, 1)),
text = list(lab = as.character(unique(OrchardSprays$rowpos))),
columns = 4, title = "Row position"))
## End(Not run)
## Not run:
grid::grid.prompt(old.prompt)
## End(Not run)