Exercise 6.4.2.

These are some notes about axis labels in R plots, particularly how you can use superscript, bold and so on.

• Introduction
• The expression() commande
  • Basics: superscript and subscript
  • Font face: bold & italic
  • Maths expressions
• Ways to incorporate expression() in plots
  • Add text to the plot area
  • Math symbols
  • Add axis titles
  • Add marginal text

The labelling of your graph axes is an important element in presenting your data and results. You often want to incorporate text formatting to your labelling. Superscript and subscript are particularly important for scientific graphs. You may also need to use bold or italics (the latter especially for species names).

The expression() command allows you to build strings that incorporate these features. You can use the results of expression() in several ways:

• As axis labels directly from plotting commands.
• As axis labels added to plots via the title()
• As marginal text via the mtext()
• As text in the plot area via the text()

You can use the expression() command directly or save the “result” to a named object that can be used later.

The expression() command takes regular characters and uses them in a special way, allowing you to build more complicated strings. You don’t need quotes (most of the time) as the usual letters and numbers are not “interpreted”. R usually takes strings that are un-quoted and tries to interpret them as objects or commands.

What the expression() command does do though, is to look for certain characters or phrases, which are treated as “switches” that do something, like turn on superscript or bold font.

• ~ Acts as a space character (actual spaces are ignored in R commands).
• * Acts as a connector, this allows you to join several elements.
• “” Quotes are used to enclose items that would otherwise be treated as a special character (like ~ or *).

So, type a ~ when you want a space and “~” when you want a ~. The * is a connector, which can be used to join sections of the expression. This allows you to “turn off” superscript for example, or switch font face.

There are various “reserved” characters e.g. + – / * ? ^ (mostly they are not letters or numbers), and these should be inside quotes. Items in quotes should be bracketed by ~ and/or * characters.

When you type an expression() any spaces you type are ignored. You can type spaces to help yourself see clearly what you have typed but they are all stripped out. If you display an expression() result R will place a single space (for clarity) between various elements of your expression().

The following expression():

expression(The~"~"~character~forms~spaces)

Would appear like “The ~ character forms spaces” when used in titles or text.

The most common thing you’ll want to do in axis labels is to make superscripts and subscripts.

• ^ Anything following the caret is displayed as superscript.
• [] Anything inside the square brackets is displayed as subscript.

The [] are simple enough to use, anything that you want to be subscripted goes inside the brackets.

Note that you cannot start an expression() with a [ so you have to “fool” the system and use a pair of empty quotes:

expression(""[x]*X)

Note also that if you do that you have to use a connector (*) afterwards (or a space character ~)! The preceding example would produce text like so:

_xX

Superscript is “started” by the caret ^ character. Anything after ^ is superscript. The superscript continues until you use a * or ~ character. If you want more text as superscript, then enclose it in quotes. The only exception is + or – when preceded by a number.

In the following example only the word “script” would appear superscript:

expression(Super^script~text)

Super^script text

The following uses quotes to get the two words superscripted.

expression(Super^"script text")

Super^{script text}

You can alter the basic font face by enclosing the items you require in a command-like element:

• plain() Anything in the parentheses is regular plain font face.
• italic()italic.
• bold()Bold
• bolditalic()Italic and bold.
• underline()Underlined.

The font face element must be preceded by a ~ or a * so that R can recognize it as a font face element.

The title() command allows you to specify a general font face as part of the command. Similarly the par() command allows you to specify font face for various plot elements:

• font – the main text font face.
• lab – axis labels.
• main – main title.
• sub – sub-title.

You specify the font face as an integer:

• 1 = Plain.
• 2 = Bold.
• 3 = Italic.
• 4 = Bold & Italic.

You can set the font face(s) from par() or as part of the plotting command. This is useful for the entire label/title but does not allow for mixed font faces. To mix font faces use the expression() elements italic(), bold() and so on.

The expression() command can also produce a range of mathematical symbols and… expressions! You can create fractions, degree signs, arrows and all manner of items. These are generally less useful in axis labels but here are a few of the expressions to whet your appetite:

There are plenty of others, type help(plotmath) into your R console to get the help entry page.

There are four main ways you can incorporate expression() objects into your plots:

• In the plot area via text()
• As a title via title()
• Directly via the plotting command; essentially the same as title()
• In the margin via mtext()

As far as the expression() part goes there is no difference between these methods; the main difference is the placement.

The text() command allows you to add text, and expression() objects to an existing plot window.

text(x, y, ...)

You need to type in the co-ordinates and then the text, quoted or as an expression(). There are other graphical parameters you can add such as:

col
cex

There are a whole lot more besides, but this article is primarily about axis labels so I’ll gloss over text() for the moment, except to demonstrate some mathematical symbols.

You can use the title() command to add titles to the main marginal areas of an existing plot. In general, you’ll use xlab and ylab elements to add labels to the x and y axes. However, you can also add a main or sub title too.

Most graphical plotting commands allow you to add titles directly, the title() command is therefore perhaps redundant. However, it is often easier to set your titles “” (i.e. blank) and then use title() afterwards, especially if they are complicated.

If you are using expression() to make a label/title then save the expression() result as a named object, which is easier to use in the subsequent command(s) that use them.

The title() command has an additional “trick” up its sleeve, the line parameter. This allows you to select a position for the title(s) in lines from the edge of the plot.

• Set line = 0 to place the title beside the axis (where the tick-marks usually are).
• Set line = 1 to place the title one line in (where the axis values usually are).

The maximum value you can set depends on the margin sizes. In practice you can get the margin value minus one. To see the currently set margin sizes:

par(mar)

You’ll get a vector of four values (bottom, left, top, right).

You can also set the title to appear inside the plot using negative values, line = -1 will be adjacent to the axis and just inside.

The mtext() command allows you to place text and expression() objects into any of the margins of a plot. The mtext() command allows you a bit more control over the placement of the text, compared to the title() command.

The general form of the command is:

mtext(text, side = 3, line = 0, outer = FALSE, at = NA,
      adj = NA, padj = NA, cex = NA, col = NA, font = NA, ...)

Exercise 6.3.

On this page you’ll find some additional notes regarding the use of colour in graphs and charts. These items did not quite make the final edit to the book itself but make a useful (I hope) addition to the topic in Chapter 6.

• Introduction
• Using colour in Excel charts
  • Quick settings
  • Overall settings
  • Setting chart colours explicitly
• Using colour in R plots
  • Specifying colours
  • Setting a colour palette
  • Built-in colour palettes
  • Shading lines
• Summary

Colour is very important in presenting data and results. Both Excel and R have a wide range of colours you can use when creating your graphs and charts (certainly more than 50 shades of gray!).

Controlling and managing the colours you display is an important element in presenting your work. With an increasing volume of work being presented via the Internet, colour is something not to take for granted. Using default colours is “easy” but for maximum impact you should think carefully about how to present the best colours for the job.

Traditional journals generally use monochrome, which you can think of as just another set of colours, but even if you are “stuck” with shades of grey you need to think carefully. Pattern filling can be an especially useful option when using monochrome.

You can set colours in Excel in several ways:

• General color can be set from the Page Layout menu, which sets overall color themes.
• When you make a chart the Chart Tools > Design > Change Colors button allows you to “override” the general colors and set your own.
• You can format elements in charts directly from the Chart Tools > Format
• Right-click or double-click a chart element directly.

When you set a colour explicitly you can also incorporate fill effects, with Pattern Fill being the most useful.

R has over 650 named colors to choose from. You can see the colors using the colors() command.

colors() 
 [1] "white"          "aliceblue"      "antiquewhite"
 [4] "antiquewhite1"  "antiquewhite2"  "antiquewhite3"
 [7] "antiquewhite4"  "aquamarine"     "aquamarine1"
[10] "aquamarine2"    "aquamarine3"    "aquamarine4"
[13] "azure"          "azure1"         "azure2"
[16] "azure3"         "azure4"         "beige"
[19] "bisque"         "bisque1"        "bisque2"
[22] "bisque3"        "bisque4"        "black"
[25] "blanchedalmond" "blue"           "blue1"
[28] "blue2"          "blue3"          "blue4"

The colors used for most graphical commands are taken from a default palette, which can be different for different commands. For example the barplot() command uses shades of gray whilst the pie() command uses a palette of pastel shades.

In most graphical commands you can set the colors for the plot using the col parameter. Colors can be named explicitly or given numbers, in which case the numbers are taken to be the colors of the existing color palette().

You can set the colors of an R plot in several ways:

• Give color names (in quotes) as in the colors()
• Give numbers – the numbers will refer to the colors in the currently set palette().
• Give the name of a built-in color palette (and the number of shades).

You can set the colors directly in a plotting command using the col parameter and a vector of names (in quotes), for example:

> barplot(VADeaths, beside = TRUE,
col = c("aliceblue", "bisque", "coral", "seagreen", "tomato"))

If you plan to use the colors more than once you might want to save your vector of colors as a named object.

> mycol = c("aliceblue", "bisque", "coral", "seagreen", "tomato")
> pie(VADeaths[1,], col = mycol)

If you don’t provide enough colors then they are recycled. If there are too many colors the un-required ones are ignored.

If you give the colors as numbers the plotting command will take the colors from their position in the vector of colors that are in the color palette(), not the position of the color from the colors() command.

You can also use one of the built-in palettes by specifying the palette name and the number of shades needed.

The palette() command allows you to set a default color palette. The default palette() can be viewed using an empty command:

> palette()
[1] "black"   "red"     "green3"  "blue"    "cyan"
[6] "magenta" "yellow"  "gray"

Now, whenever a color is referred to by an integer value the color is taken as the position in the current palette(). Some plotting commands have their own default colors, which are used if you do not specify the colors explicitly.

• The barplot() command uses a palette() of gray.
• The pie() command uses a palette() of pastel shades.

You can set the palette() by giving a vector of colors:

> palette(mycol)
> palette()
[1] "aliceblue" "bisque"    "coral"     "seagreen"  "tomato"

To restore the default palette():

> palette("default")

You can make your own color palette() by specifying color names explicitly. However, R has several built-in palettes that you can use to create a series of “co-ordinated” colors.

There are six built-in palettes.

• rainbow()
• colors()
• colors()
• colors()
• colors()
• colors()

In general you specify how many colors you require in the palette and the command produces a series of colors graded across the range, however, with rainbow() and gray.colors() you can specify starting and ending points.

Type help(palette) to get more information from within R.

In some chart types it may be helpful to have shading lines, especially when using monochromatic color palettes. The barplot() and pie() commands allow you to specify shading lines from within the command. There are two parameters:

• density – gives the density of the shading lines in lines per inch. If not specified or negative the color is solid, even if angle is given.
• angle – gives the angle to draw the shading lines measured anti-clockwise, 0 is horizontal and the default is 45 degrees.

Shading is not available in the boxplot() command. If is rather less useful there anyhow, as the bars are all labelled. It is possible to find a solution using the polygon() command but this is not for the faint hearted.

Don’t just rely on the default colors for your graphs and charts. If you are presenting a graphic that uses color then think carefully about how easy it will be for readers to differentiate the colors. Think about the colors themselves, perhaps a particular color theme would be especially suitable for your presentation.

You can use color to highlight a particularly important finding, making some data stand out from the rest. You can also make some data “disappear” into obscurity!

For monochrome charts try a wide range so that individual series are identifiable. This is where pattern fills are especially useful.

Don’t forget that the purpose of your chart is to help a reader understand the data/results easily.

Exercise 6.2.2.

Recently I saw a message in a forum asking about the difference between dot plots and histograms. This got me thinking and so I decided to work out how to make R produce a dot plot from scratch. These notes also supplement Chapter 6 (Graphics).

• Introduction
• Stem-leaf plot
• Frequency tables
• Bar charts
• Histograms
• Developing a dot-histogram
• The R script

A histogram is a way of showing the frequency of your numeric data in a visual manner. The histogram looks more or less like a bar chart except that the bars are touching – the x-axis is a continuous scale rather than being discrete categories. Look at the following data:

> mydata = c(6, 7, 8, 7, 6, 3, 8, 9, 10, 7, 6, 9)

You can visualise the distribution using a stem-leaf plot:

> stem(mydata)
The decimal point is at the |
 2 | 0
 4 |
 6 | 000000
 8 | 0000
10 | 0

The stem() command does not give much flexibility when it comes to the bins separating the data categories but you can use the scale = n instruction. The default is 1 so making the value larger will increase the number of bin categories:

> stem(mydata, scale = 2)
The decimal point is at the |
 3 | 0
 4 |
 5 |
 6 | 000
 7 | 000
 8 | 00
 9 | 00
10 | 0

Making the scale smaller gives a different impression:

> stem(mydata, scale = 0.5)
The decimal point is 1 digit(s) to the right of the |
0 | 3
0 | 6667778899
1 | 0

The stem() command can be useful but it does not really match the histogram.

Another method of looking at the data is to make a frequency table:

> table(mydata)
mydata
3  6  7  8  9 10
1  3  3  2  2  1

Not very visual but it does a job. It splits the data into chunks and shows the frequency for each. The table() command really only works sensibly on integer values (otherwise you end up with loads of “bins”).

The barplot is useful but can be misleading. The bars are discrete categories (bins or size classes) and are discontinuous. In the preceding barplot you can see that there is a jump from the 3-bin to the 6-bin. The barplot() command is very flexible and you can customize your plot in many ways but you cannot get around this problem.

The histogram can be jazzed up and customized in various ways, which I won’t delve into at this point. However, one important aspect is the control of the x-axis. The x-axis is a continuous scale and you can see the difference between this and the earlier barplot by looking at the position of the axis labels. In the barplot they are in the middle of each bar but in the histogram they are placed at the edges of the bars.

You can control the breakpoints using the breaks instruction. The default is breaks = “sturges”, which uses an algorithm to determine the breakpoints. You can also specify the number of breakpoints you want or even specify the “exact” position of the breakpoints by giving the values explicitly.

What I wanted was to make a chart that replaced the bars with dots, the number of dots in each column being equal to the frequency. One feature of the hist() command is that you can make a histogram without actually making the final plot. In other words you can calculate all the required statistics. I started by making a result object of the histogram data like so:

> hg = hist(mydata, plot = FALSE)

The result contains several elements in a list; useful elements are the mid-points of the columns and the counts (frequency):

> hg$mids
[1] 3.5 4.5 5.5 6.5 7.5 8.5 9.5

> hg$counts
[1] 1 0 3 3 2 2 1

I reasoned that I could use the $mids as the x-values in a regular plot. The y-values would come from the $counts data. A frequency of 3 would get plotted three times, at y = 1, y = 2 and y = 3. This meant I had to replicate the count data to make a sequence, which would have to be matched up to the x-data.

A loop of some sort seemed unavoidable and the number of times the loop would need to run would be equal to the number of bins, that is the number of bars. Put another way, it is the number of breaks-1. It is simplest to count the number of items in the $counts:

> bins = length(hg$counts)

To make the y-values I needed to make each frequency into a series, so a value of 3 would become 1, 2, 3. I also needed to take care of 0 values so I decided to make each frequency a series 0:frequency. Actually it was logical to do this the other way around freqency:0 so the loop becomes:

> yvals = numeric(0)
>  for(i in 1:bins) {
     yvals = c(yvals, hg$counts[i]:0)
  }

The first line simply creates a blank numeric vector. The loop creates the appropriate values and appends them to the vector. For the data under consideration this produces:

> yvals
[1] 1 0 0 3 2 1 0 3 2 1 0 2 1 0 2 1 0 1 0

Each count value is a sequence ending in zero, the count that was a zero remains so.

The x-values are derived from the $mids result, since I added an extra 0 to each y-value each item needed to be repeated a number of times equivalent to the count +1. This has the bonus of dealing with the 0 count, as a repeat of 0 would be “difficult”. A loop is needed again and it will run for as many times as there are bin categories.

> xvals = numeric(0)
>  for(i in 1:bins) {
     xvals = c(xvals, rep(hg$mids[i], hg$counts[i]+1))
  }
> xvals
[1] 3.5 3.5 4.5 5.5 5.5 5.5 5.5 6.5 6.5 6.5 6.5 7.5 7.5 7.5 8.5 8.5 8.5 9.5 9.5

The xvals and yvals cannot be used directly because there are zero items and we don’t want points plotted at 0. The simplest way to deal with this is to join up the values in a data.frame and then remove rows where y = 0.

> dat = data.frame(xvals, yvals)
> dat = dat[yvals > 0, ]

Now the data are ready to make into a plot. A regular scatter plot will do the job via the plot() command:

> plot(yvals ~ xvals, data = dat)

However, the points are too small and the plot does not look “tidy”.

The command uses the default breaks = “sturges” to work out the breakpoints, you can specify other breakpoints in exactly the same way as for the hist() command. The plotting symbols are set to pch = 19 (a solid circle) and enlarged somewhat with cex = 3. You can specify other values. The offset = 0.4 parameter plots each point slightly “upwards”. You can alter this offset and with the cex and pch parameters can get the appearance you want.

The biggest alteration you can make is with the graphics window. It seemed a lot of hassle to attempt to match the plot window size to the other parameters. It is easiest to simply use the mouse to resize the plot window to give the appearance you like. You can easily save the plot to a file once it is completed.

When made up into a function the command lines look like the following:

## Dotplot histogram
## Mark Gardener 2013
## www.dataanalytics.org.uk
hg_dot <- function(x, breaks = "sturges",
                      offset = 0.4,
                      cex = 3,
                      pch = 19, ...) {

#   x = data vector
# ... = other instructions for plot

hg <- hist(x, breaks = breaks, plot = FALSE) # Make histogram data but do not plot
bins <- length(hg$count                      # How many bins are needed?
yvals <- numeric(0)                 # A blank variable to fill in

for(i in 1:bins) {                  # Start a loop
yvals <- c(yvals, hg$counts[i]:0)  # Work out the y-values
}                                  # End the loop

xvals <- numeric(0)                                 # A blank variable

for(i in 1:bins) {                                  # Start a loop
xvals <- c(xvals, rep(hg$mids[i], hg$counts[i]+1))  # Work out x-values
}                                                   # End the loop

dat <- data.frame(xvals, yvals)  # Make data frame of x, y variables
dat <- dat[yvals > 0, ]          # Knock out any zero y-values
 minx <- min(hg$breaks)  # Min value for x-axis
 maxx <- max(hg$breaks)  # Max value x-axis
  miny <- min(dat$yvals)  # Min value for y-axis
  maxy <- max(dat$yvals)  # Max value for y-axis

# Make the plot, without axes, allow points to overspill plot region
plot(yvals + offset ~ xvals, data = dat,
        xlim = c(minx, maxx), ylim = c(miny, maxy),
        axes = FALSE, ylab = "", xpd = NA,
        cex = cex, pch = pch, ...)
axis(1)   # Add in the x-axis

# Make results of original data, histogram and plot data
result <- list(hist = hg, original = x, plot.data = dat)
invisible(result)  # Save all the results invisibly
  } # end
## END

Once you run the command your chart will be created in whatever size your default graphics window is set to. Simply drag the window to a new size as appropriate.

The command produces a list result that contains the following:

• the original data $original
• the histogram statistics $hist
• the values plotted $plot.data

If you assign a named object to the command you can access these results afterwards.

> hg = hg_dot(mydata)

> names(hg)
[1] "hist"      "original"  "plot.data"

You can get the R script here: Dot Histogram Script.