Inspecting gene_expression.txt: The first file that reads into R, gene_expression.txt, contains exemplary gene expression data obtained from two different conditions: control and treatment. The individual values in this data file resemble fold-differences of gene expression relative to a housekeeping gene that was used as a reference to normalize the data.

The data was saved as a .txt file and consists of 105 lines. The first two lines from the top are comments about the data and begin with a slash (/) as the first character. Followed by two blank lines, a header labels the two data columns of the expression data under the two conditions.

Notice that the data columns are separated by tab spaces as shown in the following screenshot of the gene_expression.txt data set:

Reading data from gene_expression.txt: Let's take a look at the arguments we need to provide in the read.table() function in order to read this data file as a data table into R:

gene_data <- read.table("gene_expression.txt",
  comment.char = "/", 
  blank.lines.skip = TRUE,
  header = TRUE,  
  sep = "\t", 
  nrows = 20)

When we use the read.table() function, R ignores every line in the data file that starts with a hash mark (#), which is the default comment character. However, the first character of the comment lines in our data file is a forward slash (/). Therefore, we have to pass it to the function as an additional argument for the comment.char parameter so R can interpret the first two lines in gene_expression.txt as comments and skip them. The second argument, blank.lines.skip = TRUE, ensures that R also skips the two blank lines after the comment section.

From here on, R will read every line that follows and will interpret it as data—skipping the comment and blank lines at the beginning.

There are two data columns in this text file, which are labeled as Control and Treatment. By setting the header parameter to TRUE, R will store these labels as a header for our data table. The header is followed by 100 rows of tab-delimited data (Gene1 to Gene100). We need to use the argument sep = "/t" to set the field separator character to a tab space, since the default data field separator is the white space, sep = "".

The data file is quite large with its 100 entries, and for this example, we just use the first 20 genes to create our heat map. We can tell R to stop reading data after the 20th entry by providing the argument nrows = 20 in the function call.

Converting the data table into a numerical matrix: As we remember from the Creating your first heat map in R recipe, we need to convert our data into a numeric matrix format before we can use it to create a heat map. Instead of using the relative expression measures deployed in the data file, we are interested in showing the fold-changes of the gene expression levels. To calculate those fold-changes of the Treatment column in relation to the Control column, we are using the outer() function. This function allows us to create a 20 x 20 matrix by dividing each gene from the Treatment column (third column in the data file) by each gene from the Control column (second column in the data file):

gene_data <- data.matrix(gene_data)
gene_ratio <- outer(gene_data[,"Treatment"],
  gene_data[,"Control"], 
  FUN = "/")

Reading data from runners.csv: The runners.csv file contains the fastest personal times of seven popular 100 meters sprinters for the years between 2003 and 2012.

If we want to read a data file with comma-separated values, it is most convenient to use the read.csv() function:

runner_data <- read.csv("runners.csv")

runner_data <- read.table("runners.csv",
header = TRUE,
sep = ",",…)

Dealing with missing values in runners.csv: The default constant for missing values in R is NA, which stands for Not Available. Therefore, if we read data from a file that contains empty fields, missing values will be replaced by NA when R creates the data table.

When we read in runner_data.csv, we see that our data table contains many 0.00 values, which means that no time was recorded for the runner in those years. However, it would make more sense to have those values denoted as missing data (NA) in our heat map.

So, if we want R to interpret values other than NA or empty fields as missing values, we do this by providing an argument for the na.strings parameter in our read.table() or read.csv() function:

runner_data <- read.csv("runners.csv", na.strings = 0.00)

runner_data[runner_data == 0.00] <- NA

By default, cells with NA values will be left blank and appear as white cells in our heat map. This can be very misleading, since the color palette that we are using converges into a very bright yellow. It would be very hard to distinguish those empty cells from values that are seeded very high in our color key.

To avoid this confusion, we can simply assign a different color to those cells that contain missing values. Here, we are coloring them in gray:

heatmap.2(runner_data, 
    dendrogram = "none", 
  Colv = NA,
  Rowv = NA,
  trace = "none", 
  na.color = "gray",
  main = "runners.csv",
  margin = c(8,10))

runner_data <- na.omit(runner_data)

Reading Apple's stock data from an Excel spreadsheet file: Now, let us take a look at Apple's daily stock market data from 1984 to 2013.

The following screenshot shows the apple_stock.xlsx data set opened in Microsoft Excel 2011:

R has no in-built function to read data from this proprietary format. But, we are lucky that someone developed the xlsx package especially for this case that is freely available on CRAN. Therefore, we can use the read.xlsx() function to conveniently get this data from apple_stock.xlsx into R.

stocks_table <- read.xlsx("apple_stocks.xlsx", 
  sheetIndex = 1, 
  rowIndex = c(1:28), 
  colIndex = c(1:5,7))

With sheetIndex, we have selected which sheet we want to read from the Excel spreadsheet file—apple_stock.xlsx only has data on sheet 1. The spreadsheet consists of 7168 rows of data, but we are interested only in the recent data stock data of 2013. So, to only read in those first 28 lines, we included the rowIndex = c(1:28) argument in the read.xlsx() function call above. Furthermore, we are not interested in the Volume column (column 6), so let's skip it via the argument colIndex = c(1:5,7).

In most cases, we will use the read.table() function to read our data into R. The following table summarizes the most important options: