stars                package:graphics                R Documentation

_S_t_a_r (_S_p_i_d_e_r/_R_a_d_a_r) _P_l_o_t_s _a_n_d _S_e_g_m_e_n_t _D_i_a_g_r_a_m_s

_D_e_s_c_r_i_p_t_i_o_n:

     Draw star plots or segment diagrams of a multivariate data set.
     With one single location, also draws "spider" (or "radar") plots.

_U_s_a_g_e:

     stars(x, full = TRUE, scale = TRUE, radius = TRUE,
           labels = dimnames(x)[[1]], locations = NULL,
           nrow = NULL, ncol = NULL, len = 1,
           key.loc = NULL, key.labels = dimnames(x)[[2]], key.xpd = TRUE,
           xlim = NULL, ylim = NULL, flip.labels = NULL,
           draw.segments = FALSE, col.segments = 1:n.seg, col.stars = NA,
           axes = FALSE, frame.plot = axes,
           main = NULL, sub = NULL, xlab = "", ylab = "",
           cex = 0.8, lwd = 0.25, lty = par("lty"), xpd = FALSE,
           mar = pmin(par("mar"),
                      1.1+ c(2*axes+ (xlab != ""), 2*axes+ (ylab != ""), 1,0)),
           add=FALSE, plot=TRUE, ...)

_A_r_g_u_m_e_n_t_s:

       x: matrix or data frame of data. One star or segment plot will
          be produced for each row of 'x'. Missing values ('NA') are
          allowed, but they are treated as if they were 0 (after
          scaling, if relevant).

    full: logical flag: if 'TRUE', the segment plots will occupy a full
          circle.  Otherwise, they occupy the (upper) semicircle only.

   scale: logical flag: if 'TRUE', the columns of the data matrix are
          scaled independently so that the maximum value in each column
          is 1 and the minimum is 0.  If 'FALSE', the presumption is
          that the data have been scaled by some other algorithm to the
          range [0,1].

  radius: logical flag: in 'TRUE', the radii corresponding to each
          variable in the data will be drawn.

  labels: vector of character strings for labeling the plots. Unlike
          the S function 'stars', no attempt is made to construct
          labels if 'labels = NULL'.

locations: Either two column matrix with the x and y coordinates used
          to place each of the segment plots; or numeric of length 2
          when all plots should be superimposed (for a "spider plot").
          By default, 'locations = NULL', the segment plots will be
          placed in a rectangular grid.

nrow, ncol: integers giving the number of rows and columns to use when
          'locations' is 'NULL'.  By default, 'nrow == ncol', a square
          layout will be used.

     len: scale factor for the length of radii or segments.

 key.loc: vector with x and y coordinates of the unit key.

key.labels: vector of character strings for labeling the segments of
          the unit key.  If omitted, the second component of
          'dimnames(x)' is used, if available.

 key.xpd: clipping switch for the unit key (drawing and labeling), see
          'par("xpd")'.

    xlim: vector with the range of x coordinates to plot. 

    ylim: vector with the range of y coordinates to plot.

flip.labels: logical indicating if the label locations should flip up
          and down from diagram to diagram. Defaults to a somewhat
          smart heuristic.

draw.segments: logical. If 'TRUE' draw a segment diagram.

col.segments: color vector (integer or character, see 'par'), each
          specifying a color for one of the segments (variables). 
          Ignored if 'draw.segments = FALSE'.

col.stars: color vector (integer or character, see 'par'), each
          specifying a color for one of the stars (cases).  Ignored if
          'draw.segments = TRUE'.

    axes: logical flag: if 'TRUE' axes are added to the plot.

frame.plot: logical flag: if 'TRUE', the plot region is framed.

    main: a main title for the plot.

     sub: a sub title for the plot.

    xlab: a label for the x axis.

    ylab: a label for the y axis.

     cex: character expansion factor for the labels.

     lwd: line width used for drawing.

     lty: line type used for drawing.

     xpd: logical or NA indicating if clipping should be done, see
          'par(xpd = .)'.

     mar: argument to 'par(mar = *)', typically choosing smaller
          margings than by default.

     ...: further arguments, passed to the first call of 'plot()', see
          'plot.default' and to 'box()' if 'frame.plot' is true.

     add: logical, if 'TRUE' _add_ stars to current plot.

    plot: logical, if 'FALSE', nothing is plotted.

_D_e_t_a_i_l_s:

     Missing values are treated as 0.

     Each star plot or segment diagram represents one row of the input
     'x'.  Variables (columns) start on the right and wind
     counterclockwise around the circle.  The size of the (scaled)
     column is shown by the distance from the center to the point on
     the star or the radius of the segment representing the variable.

     Only one page of output is produced.

_N_o_t_e:

     This code started life as spatial star plots by David A. Andrews.
     See <URL:
     http://www.udallas.edu:8080/~andrews/software/software.html>.

     Prior to 1.4.1, scaling only shifted the maximum to 1, although
     documented as here.

_A_u_t_h_o_r(_s):

     Thomas S. Dye

_R_e_f_e_r_e_n_c_e_s:

     Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988) _The New S
     Language_. Wadsworth & Brooks/Cole.

_E_x_a_m_p_l_e_s:

     data(mtcars)
     stars(mtcars[, 1:7], key.loc = c(14, 2),
           main = "Motor Trend Cars : stars(*, full = F)", full = FALSE)
     stars(mtcars[, 1:7], key.loc = c(14, 1.5),
           main = "Motor Trend Cars : full stars()",flip.labels=FALSE)

     ## 'Spider' or 'Radar' plot:
     stars(mtcars[, 1:7], locations = c(0,0), radius = FALSE,
           key.loc=c(0,0), main="Motor Trend Cars", lty = 2)

     ## Segment Diagrams:
     palette(rainbow(12, s = 0.6, v = 0.75))
     stars(mtcars[, 1:7], len = 0.8, key.loc = c(12, 1.5),
           main = "Motor Trend Cars", draw.segments = TRUE)
     stars(mtcars[, 1:7], len = 0.6, key.loc = c(1.5, 0),
           main = "Motor Trend Cars", draw.segments = TRUE,
           frame.plot=TRUE, nrow = 4, cex = .7)

     data(USJudgeRatings)
     ## scale linearly (not affinely) to [0, 1]
     USJudge <- apply(USJudgeRatings, 2, function(x) x/max(x))
     Jnam <- row.names(USJudgeRatings)
     Snam <- abbreviate(substring(Jnam,1,regexpr("[,.]",Jnam) - 1), 7)
     stars(USJudge, labels = Jnam, scale = FALSE,
           key.loc = c(13, 1.5), main = "Judge not ...", len = 0.8)
     stars(USJudge, labels = Snam, scale = FALSE,
           key.loc = c(13, 1.5), radius = FALSE)

     loc <- stars(USJudge, labels = NULL, scale = FALSE,
                  radius = FALSE, frame.plot = TRUE,
                  key.loc = c(13, 1.5), main = "Judge not ...", len = 1.2)
     text(loc, Snam, col = "blue", cex = 0.8, xpd = TRUE)

     ## 'Segments':
     stars(USJudge, draw.segments = TRUE, scale = FALSE, key.loc = c(13,1.5))

     ## 'Spider':
     stars(USJudgeRatings, locations=c(0,0), scale=FALSE,radius = FALSE,
           col.stars=1:10, key.loc = c(0,0), main="US Judges rated")
     ## 'Radar-Segments'
     stars(USJudgeRatings[1:10,], locations = 0:1, scale=FALSE,
           draw.segments = TRUE, col.segments=0, col.stars=1:10,key.loc= 0:1,
            main="US Judges 1-10 ")
     palette("default")
     stars(cbind(1:16,10*(16:1)),draw.segments=TRUE,
           main = "A Joke -- do *not* use symbols on 2D data!")

