panel.xyplot             package:lattice             R Documentation

_D_e_f_a_u_l_t _P_a_n_e_l _F_u_n_c_t_i_o_n _f_o_r _x_y_p_l_o_t

_D_e_s_c_r_i_p_t_i_o_n:

     This is the default panel function for 'xyplot'. Also see
     'panel.superpose'.  The default panel functions for 'splom' and
     'qq' are essentially the same function.

_U_s_a_g_e:

     panel.xyplot(x, y, type = "p",
                  groups = NULL,
                  pch, col, col.line, col.symbol,
                  font, fontfamily, fontface,
                  lty, cex, fill, lwd,
                  horizontal = FALSE, ...,
                  jitter.x = FALSE, jitter.y = FALSE,
                  factor = 0.5, amount = NULL)
     panel.splom(...)
     panel.qq(...)

_A_r_g_u_m_e_n_t_s:

     x,y: variables to be plotted in the scatterplot

    type: character vector consisting of one or more of the following:
          '"p"', '"l"', '"h"', '"b"', '"o"', '"s"', '"S"', '"r"',
          '"a"', '"g"', '"smooth"'.  If type has more than one element,
          an attempt is made to combine the effect of each of the
          components.

          The behaviour if any of the first six are included in 'type'
          is similar to the effect of 'type' in 'plot' (type '"b"' is
          actually the same as '"o"').  '"r"' adds a regression line
          (same as 'panel.lmline', except for default graphical
          parameters), and '"smooth"' adds a lowess fit (same as
          'panel.loess').  '"g"' adds a reference grid using
          'panel.grid' in the background.  '"a"' has the effect of
          calling 'panel.linejoin', which can be useful for creating
          interaction plots.  The effect of several of these
          specifications depend on the value of 'horizontal'.

          Type '"s"' (and '"S"') sorts the values along one of the axes
          (depending on 'horizontal'); this is unlike the behavior in
          'plot'.  For the latter behavior, use 'type = "s"' with
          'panel = panel.points'.

          See 'example(xyplot)' and 'demo(lattice)' for examples. 

  groups: an optional grouping variable.  If present, 'panel.superpose'
          will be used instead to display each subgroup 

col, col.line, col.symbol: default colours are obtained from
          'plot.symbol' and 'plot.line' using 'trellis.par.get'. 

font, fontface, fontfamily: font used when 'pch' is a character 

pch, lty, cex, lwd, fill: other graphical parameters.  'fill' serves
          the purpose of 'bg' in 'points' for certain values of 'pch' 

     ...: extra arguments, if any, for 'panel.xyplot'. In most cases
          'panel.xyplot' ignores these. For types "r" and "smooth",
          these are passed on to 'panel.lmline' and 'panel.loess'
          respectively. 

horizontal: logical. Controls orientation for certain 'type''s, e.g. 
          one of '"h"', '"s"' or '"S"'

jitter.x, jitter.y: logical, whether the data should be jittered before
          being plotted. 

factor, amount: controls amount of jittering. 

_D_e_t_a_i_l_s:

     Creates scatterplot of 'x' and 'y', with various modifications
     possible via the type argument. 'panel.qq' draws a 45 degree line
     before calling 'panel.xyplot'.

     Note that most of the arguments controlling the display can be
     supplied directly to the high-level (e.g. 'xyplot') call.

_A_u_t_h_o_r(_s):

     Deepayan Sarkar Deepayan.Sarkar@R-project.org

_S_e_e _A_l_s_o:

     'panel.superpose', 'xyplot', 'splom'

_E_x_a_m_p_l_e_s:

     types.plain <- c("p", "l", "o", "r", "g", "s", "S", "h", "a", "smooth")
     types.horiz <- c("s", "S", "h", "a", "smooth")
     horiz <- rep(c(FALSE, TRUE), c(length(types.plain), length(types.horiz)))

     types <- c(types.plain, types.horiz)

     x <- sample(seq(-10, 10, length = 15), 30, TRUE)
     y <- x + 0.25 * (x + 1)^2 + rnorm(length(x), sd = 5)

     xyplot(y ~ x | gl(1, length(types)),
            xlab = "type", 
            ylab = list(c("horizontal=TRUE", "horizontal=FALSE"), y = c(1/6, 4/6)),
            as.table = TRUE, layout = c(5, 3),
            between = list(y = c(0, 1)),
            strip = function(...) {
                panel.fill(trellis.par.get("strip.background")$col[1])
                type <- types[panel.number()]
                grid::grid.text(lab = sprintf('"%s"', type), 
                                x = 0.5, y = 0.5)
                grid::grid.rect()
            },
            scales = list(alternating = c(0, 2), tck = c(0, 0.7), draw = FALSE),
            par.settings = 
            list(layout.widths = list(strip.left = c(1, 0, 0, 0, 0))),
            panel = function(...) {
                type <- types[panel.number()]
                horizontal <- horiz[panel.number()]
                panel.xyplot(..., 
                             type = type,
                             horizontal = horizontal)
            })[rep(1, length(types))]

