histogram              package:lattice              R Documentation

_H_i_s_t_o_g_r_a_m_s _a_n_d _K_e_r_n_e_l _D_e_n_s_i_t_y _P_l_o_t_s

_D_e_s_c_r_i_p_t_i_o_n:

     Draw Histograms and Kernel Density Plots, possibly conditioned on
     other variables.

_U_s_a_g_e:

     histogram(x, ...)
     densityplot(x, ...)
     ## S3 method for class 'formula':
     histogram(x,
                  data = parent.frame(),
                  allow.multiple, outer = TRUE,
                  auto.key = FALSE,
                  aspect = "fill",
                  panel = "panel.histogram",
                  prepanel, scales, strip, groups,
                  xlab, xlim, ylab, ylim,
                  type = c("percent", "count", "density"),
                  nint = if (is.factor(x)) length(levels(x))
                  else round(log2(length(x)) + 1),
                  endpoints = extend.limits(range(x, finite = TRUE), prop = 0.04),
                  breaks = if (is.factor(x)) seq(0.5, length = length(levels(x))+1)
                  else do.breaks(endpoints, nint),
                  equal.widths = TRUE,
                  drop.unused.levels = lattice.getOption("drop.unused.levels"),
                  ...,
                  default.scales = list(),
                  subscripts,
                  subset)

     ## S3 method for class 'numeric':
     histogram(x, data, xlab, ...)
     ## S3 method for class 'factor':
     histogram(x, data, xlab, ...)

     ## S3 method for class 'formula':
     densityplot(x,
                 data = parent.frame(),
                 allow.multiple = is.null(groups) || outer,
                 outer = !is.null(groups),
                 auto.key = FALSE,
                 aspect = "fill",
                 panel = if (is.null(groups)) "panel.densityplot" else "panel.superpose",
                 prepanel, scales, strip, groups,
                 xlab, xlim, ylab, ylim,
                 bw, adjust, kernel, window, width, give.Rkern,
                 n = 50, from, to, cut, na.rm,
                 drop.unused.levels = lattice.getOption("drop.unused.levels"),
                 ...,
                 default.scales = list(),
                 panel.groups = "panel.densityplot",
                 subscripts,
                 subset)
     ## S3 method for class 'numeric':
     densityplot(x, data, xlab, ...)

     do.breaks(endpoints, nint)

_A_r_g_u_m_e_n_t_s:

       x: The object on which method dispatch is carried out.

          For the 'formula' method, a formula of the form '~ x | g1 *
          g2 * ...' indicates that histograms or Kernel Density
          estimates of 'x' should be produced conditioned on the levels
          of the (optional) variables 'g1, g2, ...'.  'x' can be
          numeric (or factor for 'histogram'), and each of 'g1, g2,
          ...' must be either factors or shingles.

          As a special case, the right hand side of the formula can
          contain more than one variable separated by a '+' sign. What
          happens in this case is described in details in the
          documentation for 'xyplot'.  Note that in either form, all
          the variables involved in the formula have to have same
          length.

          For the 'numeric' and 'factor' methods, 'x' replaces the 'x'
          vector described above.  Conditioning is not allowed in these
          cases.

    data: For the 'formula' method, an optional data frame in which
          variables are to be evaluated.  Ignored with a warning in
          other cases. 

    type: Character string indicating type of histogram to be drawn.
          '"percent"' and '"count"' give relative frequency and
          frequency histograms, and can be misleading when breakpoints
          are not equally spaced. '"density"' produces a density scale
          histogram.

          'type' defaults to '"percent"', except when the breakpoints
          are unequally spaced or 'breaks = NULL', when it defaults to
          '"density"'.

    nint: Number of bins.  Applies only when 'breaks' is unspecified in
          the call. 

endpoints: vector of length 2 indicating the range of x-values that is
          to be covered by the histogram.  Again, applies only when
          'breaks' is unspecified.  In 'do.breaks', this specifies the
          interval that is to be divided up. 

  breaks: numeric vector of length = (number of bins + 1) defining the
          breakpoints of the bins. Note that when breakpoints are not
          equally spaced, the only value of 'type' that makes sense is
          density.

          Usually all panels use the same breakpoints. This can be
          changed by specifying 'breaks = NULL'. This has the effect of
          letting each panel choose its own breakpoints. The choice of
          these breakpoints are made as follows: The number of bins is
          calculated by the formula for 'nint' above, and then
          breakpoints are chosen according to the value of
          'equal.widths'. 

equal.widths: logical, relevant only when 'breaks=NULL'. If 'TRUE',
          equally spaced bins will be selected, otherwise, 
          approximately equal area bins will be selected (this would
          mean that the breakpoints will *not* be equally spaced). 

       n: number of points at which density is to be evaluated 

   panel: The function that uses the packet (subset of display
          variables) corresponding to a panel to create a display. 
          Default panel functions are documented separately, and often
          have arguments that can be used to customize its display in
          various ways.  Such arguments can usually be directly
          supplied to the high level function.  

panel.groups: function used as the 'panel.groups' argument when
          'panel.superpose' is used as the panel function, which
          happens by default when 'groups' is non-null.  

allow.multiple, outer, auto.key, aspect, prepanel, scales,
strip, groups, xlab, xlim, ylab, ylim, drop.unused.levels,
default.scales, subscripts, subset: See
          'xyplot' 

bw, adjust, kernel, window, width, give.Rkern, from, to, cut,
na.rm: ar
          guments to 'density', passed on as appropriate 

     ...: Further arguments.  See corresponding entry in 'xyplot' for
          non-trivial details.  

_D_e_t_a_i_l_s:

     'histogram' draws Conditional Histograms, while 'densityplot'
     draws Conditional Kernel Density Plots.  The density estimate in
     'densityplot' is actually calculated using the function 'density',
     and all arguments accepted by it can be passed (as '...') in the
     call to 'densityplot' to control the output.  See documentation of
     'density' for details. (Note: The default value of the argument
     'n' of 'density' is changed to 50.)

     These and all other high level Trellis functions have several
     arguments in common. These are extensively documented only in the
     help page for 'xyplot', which should be consulted to learn more
     detailed usage.

     'do.breaks' is an utility function that calculates breakpoints
     given an interval and the number of pieces to break it into.

_V_a_l_u_e:

     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.

_N_o_t_e:

     The form of the arguments accepted by the default panel function
     'panel.histogram' is different from that in S-PLUS. Whereas S-PLUS
     calculates the heights inside 'histogram' and passes only the
     breakpoints and the heights to the panel function, here the
     original variable 'x' is passed along with the breakpoints. This
     allows plots as in the second example below.

_A_u_t_h_o_r(_s):

     Deepayan Sarkar Deepayan.Sarkar@R-project.org

_S_e_e _A_l_s_o:

     'xyplot', 'panel.histogram', 'density', 'panel.densityplot',
     'panel.mathdensity', 'Lattice'

_E_x_a_m_p_l_e_s:

     require(stats)
     histogram( ~ height | voice.part, data = singer, nint = 17,
               endpoints = c(59.5, 76.5), layout = c(2,4), aspect = 1,
               xlab = "Height (inches)")

     histogram( ~ height | voice.part, data = singer,
               xlab = "Height (inches)", type = "density",
               panel = function(x, ...) {
                   panel.histogram(x, ...)
                   panel.mathdensity(dmath = dnorm, col = "black",
                                     args = list(mean=mean(x),sd=sd(x)))
               } )

     densityplot( ~ height | voice.part, data = singer, layout = c(2, 4),  
                 xlab = "Height (inches)", bw = 5)

