Examples of numeric values.

# assign number 150 to variable a.
a <- 150
a

## [1] 150

# assign a number in scientific format to variable b.
b <- 3e-2
b

## [1] 0.03

Examples of character values.

# assign a string "BRCA1" to variable gene
gene <- "BRCA1"
gene

## [1] "BRCA1"

# assign a string "Hello World" to variable hello
hello <- "Hello World"
hello

## [1] "Hello World"

Examples of logical values.

# assign logical value "TRUE" to variable brca1_expressed
brca1_expressed <- TRUE
brca1_expressed

## [1] TRUE

# assign logical value "FALSE" to variable her2_expressed
her2_expressed <- FALSE
her2_expressed

## [1] FALSE

# assign logical value to a variable by logical operation
her2_expression_level <- 0
her2_expressed <- her2_expression_level > 0
her2_expressed

## [1] FALSE

To find out the type of variable.

class(her2_expressed)

## [1] "logical"

# To check whether the variable is a specific type
is.numeric(gene)

## [1] FALSE

is.numeric(a)

## [1] TRUE

is.character(gene)

## [1] TRUE

In the case that one compares two different classes of data, the coersion rule in R is logical -> integer -> numeric -> complex -> character . The following is an example of converting a numeric variable to character.

b

## [1] 0.03

as.character(b)

## [1] "0.03"

What happens when one converts a logical variable to numeric?

# recall her2_expressed
her2_expressed

## [1] FALSE

# conversion
as.numeric(her2_expressed)

## [1] 0

her2_expressed + 1

## [1] 1

A logical TRUE is converted to integer 1 and a logical FALSE is converted to integer 0.

One can give names to the elements of an atomic vector.

# assign names to a vector by specifying them
names(gene_expression) <- c("ESR1", "p53", "PI3K", "BRCA1", "EGFR")
gene_expression

##  ESR1   p53  PI3K BRCA1  EGFR 
##     0   100    50   200    80

# assign names to a vector using another vector
names(gene_expression) <- gene_names
gene_expression

##  ESR1   p53  PI3K BRCA1  EGFR 
##     0   100    50   200    80

Or One may create a vector with named elements from scratch.

gene_expression <- c(ESR1=0, p53=100, PI3K=50, BRCA1=200, EGFR=80)
gene_expression

##  ESR1   p53  PI3K BRCA1  EGFR 
##     0   100    50   200    80

To find out the length of a vector:

length(gene_expression)

## [1] 5

NOTE: a vector can only hold elements of the same type. If there are a mixture of data types, they will be coerced according to the coersion rule mentioned earlier in this documentation.

In R, categories of the data are stored as factor levels. The function levels() can be used to access the factor levels.

levels(disease_stage)

## [1] "Stage1" "Stage2" "Stage3" "Stage4"

A function to compactly display the internal structure of an R object is str(). Please use str() to display the internal structure of the object we just created disease_stage. It shows that disease_stage is a factor with four levels: “Stage1”, “Stage2”, “Stage3”, etc… The integer numbers after the colon shows that these levels are encoded under the hood by integer values: the first level is 1, the second level is 2, and so on. Basically, when factor function is called, R first scan through the vector to determine how many different categories there are, then it converts the character vector to a vector of integer values, with each integer value labeled with a category.

str(disease_stage)

##  Factor w/ 4 levels "Stage1","Stage2",..: 1 2 2 3 1 4

By default, R infers the factor levels by ordering the unique elements in a factor alphanumerically. One may specifically define the factor levels at the creation of the factor.

disease_stage <- factor(c("Stage1", "Stage2", "Stage2", "Stage3", "Stage1", "Stage4"), levels=c("Stage2", "Stage1", "Stage3", "Stage4"))
# The encoding for levels are different from above.
str(disease_stage)

##  Factor w/ 4 levels "Stage2","Stage1",..: 2 1 1 3 2 4

If you want to know the number of individuals at each levels, there are two functions: summary and table.

summary(disease_stage)

## Stage2 Stage1 Stage3 Stage4 
##      2      2      1      1

table(disease_stage)

## disease_stage
## Stage2 Stage1 Stage3 Stage4 
##      2      2      1      1

One other way to create a matrix is to use matrix() function.

nums <- c(col1, col2, col3)
nums

##  [1]   1   3   8   9   2  18  27  10   8  37 267  19

matrix(nums, ncol=2)

##      [,1] [,2]
## [1,]    1   27
## [2,]    3   10
## [3,]    8    8
## [4,]    9   37
## [5,]    2  267
## [6,]   18   19

rownames(my_matrix) <- c("row1", "row2", "row3", "row4")
my_matrix

##      col1 col2 col3
## row1    1    2    8
## row2    3   18   37
## row3    8   27  267
## row4    9   10   19

t(my_matrix)

##      row1 row2 row3 row4
## col1    1    3    8    9
## col2    2   18   27   10
## col3    8   37  267   19

To find out the dimension of a matrix:

ncol(my_matrix)

## [1] 3

nrow(my_matrix)

## [1] 4

dim(my_matrix)

## [1] 4 3

Calculations with numeric matrices.

my_matrix * 3

##      col1 col2 col3
## row1    3    6   24
## row2    9   54  111
## row3   24   81  801
## row4   27   30   57

log10(my_matrix)

##           col1     col2     col3
## row1 0.0000000 0.301030 0.903090
## row2 0.4771213 1.255273 1.568202
## row3 0.9030900 1.431364 2.426511
## row4 0.9542425 1.000000 1.278754

Total of each row.

rowSums(my_matrix)

## row1 row2 row3 row4 
##   11   58  302   38

Total of each column.

colSums(my_matrix)

## col1 col2 col3 
##   21   57  331

There is a data structure Array in R, that holds multi-dimensional (d > 2) data and is a generalized version of a matrix. Matrix is used much more commonly than Array, therefore we are not going to talk about Array here.

A data frame can be created using the function data.frame().

# creating a data frame using pre-defined vectors
patients_name=c("Patient1", "Patient2", "Patient3", "Patient4", "Patient5", "Patient6")
Family_history=c("Y", "N", "Y", "N", "Y", "Y")
patients_age=c(31, 40, 39, 50, 45, 65)
meta.data <- data.frame(patients_name=patients_name, disease_stage=disease_stage, Family_history=Family_history, patients_age=patients_age)
meta.data

##   patients_name disease_stage Family_history patients_age
## 1      Patient1        Stage1              Y           31
## 2      Patient2        Stage2              N           40
## 3      Patient3        Stage2              Y           39
## 4      Patient4        Stage3              N           50
## 5      Patient5        Stage1              Y           45
## 6      Patient6        Stage4              Y           65

is.data.frame(meta.data)

## [1] TRUE

is.data.frame(my_matrix)

## [1] FALSE

class(my_matrix)

## [1] "matrix" "array"

my_data <- as.data.frame(my_matrix)
class(my_data)

## [1] "data.frame"

A data frame can be transposed in the similar way as a matrix. However, the result of transposing a data frame might not be a data frame anymore.

my_data

##      col1 col2 col3
## row1    1    2    8
## row2    3   18   37
## row3    8   27  267
## row4    9   10   19

t(my_data)

##      row1 row2 row3 row4
## col1    1    3    8    9
## col2    2   18   27   10
## col3    8   37  267   19

A data frame can be extended.

# add a column that has the information on harmful mutations in BRCA1/BRCA2 genes for each patient.
meta.data

##   patients_name disease_stage Family_history patients_age
## 1      Patient1        Stage1              Y           31
## 2      Patient2        Stage2              N           40
## 3      Patient3        Stage2              Y           39
## 4      Patient4        Stage3              N           50
## 5      Patient5        Stage1              Y           45
## 6      Patient6        Stage4              Y           65

meta.data$BRCA <- c("YES", "NO", "YES", "YES", "YES", "NO")
meta.data

##   patients_name disease_stage Family_history patients_age BRCA
## 1      Patient1        Stage1              Y           31  YES
## 2      Patient2        Stage2              N           40   NO
## 3      Patient3        Stage2              Y           39  YES
## 4      Patient4        Stage3              N           50  YES
## 5      Patient5        Stage1              Y           45  YES
## 6      Patient6        Stage4              Y           65   NO

A data frame can also be extended using the functions cbind() and rbind(), for adding columns and rows respectively. When using cbind(), the number of values in the new column must match the number of rows in the data frame. When using rbind(), the two data frames must have the same variables/columns.

# add a column that has the information on the racial information for each patient.
cbind(meta.data, Race=c("AJ", "AS", "AA", "NE", "NE", "AS"))

##   patients_name disease_stage Family_history patients_age BRCA Race
## 1      Patient1        Stage1              Y           31  YES   AJ
## 2      Patient2        Stage2              N           40   NO   AS
## 3      Patient3        Stage2              Y           39  YES   AA
## 4      Patient4        Stage3              N           50  YES   NE
## 5      Patient5        Stage1              Y           45  YES   NE
## 6      Patient6        Stage4              Y           65   NO   AS

# rbind can be used to add more rows to a data frame.
rbind(meta.data, data.frame(patients_name="Patient7", disease_stage="S4", Family_history="Y", patients_age=48, BRCA="YES"))

##   patients_name disease_stage Family_history patients_age BRCA
## 1      Patient1        Stage1              Y           31  YES
## 2      Patient2        Stage2              N           40   NO
## 3      Patient3        Stage2              Y           39  YES
## 4      Patient4        Stage3              N           50  YES
## 5      Patient5        Stage1              Y           45  YES
## 6      Patient6        Stage4              Y           65   NO
## 7      Patient7            S4              Y           48  YES

One may use the function merge to merge two data frames horizontally, based on one or more common key variables.

expression.data <- data.frame(patients_name=c("Patient3", "Patient4", "Patient5", "Patient1", "Patient2", "Patient6"), EGFR=c(10, 472, 103784, 1782, 187, 18289), TP53=c(16493, 72, 8193, 1849, 173894, 1482))
expression.data

##   patients_name   EGFR   TP53
## 1      Patient3     10  16493
## 2      Patient4    472     72
## 3      Patient5 103784   8193
## 4      Patient1   1782   1849
## 5      Patient2    187 173894
## 6      Patient6  18289   1482

merge(meta.data, expression.data, by="patients_name")

##   patients_name disease_stage Family_history patients_age BRCA   EGFR   TP53
## 1      Patient1        Stage1              Y           31  YES   1782   1849
## 2      Patient2        Stage2              N           40   NO    187 173894
## 3      Patient3        Stage2              Y           39  YES     10  16493
## 4      Patient4        Stage3              N           50  YES    472     72
## 5      Patient5        Stage1              Y           45  YES 103784   8193
## 6      Patient6        Stage4              Y           65   NO  18289   1482

Challenge:

• In the previous example, we created expression.data with the same number of patients as meta.data. What if expression.data has less number of patients? As an exercise to understand how merge works, you can reduce the dimention of expression.data and check the merge results.

A list is constructed using the function list().

my_list <- list(1:5, "a", c(TRUE, FALSE, FALSE), c(3.2, 103.0, 82.3))
my_list

## [[1]]
## [1] 1 2 3 4 5
## 
## [[2]]
## [1] "a"
## 
## [[3]]
## [1]  TRUE FALSE FALSE
## 
## [[4]]
## [1]   3.2 103.0  82.3

str(my_list)

## List of 4
##  $ : int [1:5] 1 2 3 4 5
##  $ : chr "a"
##  $ : logi [1:3] TRUE FALSE FALSE
##  $ : num [1:3] 3.2 103 82.3

One could construct a list by giving names to elements.

my_list <- list(Ranking=1:5, ID="a", Test=c(TRUE, FALSE, FALSE), Score=c(3.2, 103.0, 82.3))

# display the names of elements in the list using the function *names*, or *str*. Compare the output of *str* with the above results to see the difference.
names(my_list)

## [1] "Ranking" "ID"      "Test"    "Score"

str(my_list)

## List of 4
##  $ Ranking: int [1:5] 1 2 3 4 5
##  $ ID     : chr "a"
##  $ Test   : logi [1:3] TRUE FALSE FALSE
##  $ Score  : num [1:3] 3.2 103 82.3

# number of elements in the list
length(my_list)

## [1] 4

First, we are going to talk about subsetting data using [, which is the most commonly used operator. We will start by looking at vectors and talk about four ways to subset a vector.

• Positive integers return elements at the specified positions

# first to recall what are stored in gene_names
gene_names

## [1] "ESR1"  "p53"   "PI3K"  "BRCA1" "EGFR"

# obtain the first and the third elements
gene_names[c(1,3)]

## [1] "ESR1" "PI3K"

R uses 1 based indexing, meaning the first element is at the position 1, not at position 0.

• Negative integers omit elements at the specified positions

gene_names[-c(1,3)]

## [1] "p53"   "BRCA1" "EGFR"

One may not mixed positive and negative integers in one single subset operation.

# The following command will produce an error.
gene_names[c(-1, 2)]

## Error in gene_names[c(-1, 2)]: only 0's may be mixed with negative subscripts

• Logical vectors select elements where the corresponding logical value is TRUE, This is very useful because one may write the expression that creates the logical vector.

gene_names[c(TRUE, FALSE, TRUE, FALSE, FALSE)]

## [1] "ESR1" "PI3K"

Recall that we have created one vector called gene_expression. Let’s assume that gene_expression stores the expression values correspond to the genes in gene_names. Then we may subset the genes based on expression values.

gene_expression

##  ESR1   p53  PI3K BRCA1  EGFR 
##     0   100    50   200    80

gene_names[gene_expression > 50]

## [1] "p53"   "BRCA1" "EGFR"

If the logical vector is shorter in length than the data vector that we want to subset, then it will be recycled to be the same length as the data vector.

gene_names[c(TRUE, FALSE)]

## [1] "ESR1" "PI3K" "EGFR"

If the logical vector has “NA” in it, the corresponding value will be “NA” in the output. “NA” in R is a sysmbol for missing value.

gene_names[c(TRUE, NA, FALSE, TRUE, NA)]

## [1] "ESR1"  NA      "BRCA1" NA

• Character vectors return elements with matching names, when the vector is named.

gene_expression

##  ESR1   p53  PI3K BRCA1  EGFR 
##     0   100    50   200    80

gene_expression[c("ESR1", "p53")]

## ESR1  p53 
##    0  100

• Nothing returns the original vector, This is more useful for matrices, data frames than for vectors.

gene_names[]

## [1] "ESR1"  "p53"   "PI3K"  "BRCA1" "EGFR"

Subsetting a list works in the same way as subsetting an atomic vector. Using [ will always return a list.

my_list[1]

## $Ranking
## [1] 1 2 3 4 5

Subsetting a matrix can be done by simply generalizing the one dimension subsetting: one may supply a one dimension index for each dimension of the matrix. Blank/Nothing subsetting is now useful in keeping all rows or all columns.

my_matrix[c(TRUE, FALSE), ]

##      col1 col2 col3
## row1    1    2    8
## row3    8   27  267

Subsetting a data frame can be done similarly as subsetting a matrix. In addition, one may supply only one 1-dimensional index to subset a data frame. In this case, R will treat the data frame as a list with each column is an element in the list.

# recall a data frame created from above: *meta.data*
meta.data

##   patients_name disease_stage Family_history patients_age BRCA
## 1      Patient1        Stage1              Y           31  YES
## 2      Patient2        Stage2              N           40   NO
## 3      Patient3        Stage2              Y           39  YES
## 4      Patient4        Stage3              N           50  YES
## 5      Patient5        Stage1              Y           45  YES
## 6      Patient6        Stage4              Y           65   NO

# subset the data frame similarly to a matrix
meta.data[c(TRUE, FALSE, FALSE, TRUE),]

##   patients_name disease_stage Family_history patients_age BRCA
## 1      Patient1        Stage1              Y           31  YES
## 4      Patient4        Stage3              N           50  YES
## 5      Patient5        Stage1              Y           45  YES

# subset the data frame using one vector
meta.data[c("patients_age", "disease_stage")]

##   patients_age disease_stage
## 1           31        Stage1
## 2           40        Stage2
## 3           39        Stage2
## 4           50        Stage3
## 5           45        Stage1
## 6           65        Stage4

[[ is similar to [, except that it returns the content of the element.

# recall my_list
my_list

## $Ranking
## [1] 1 2 3 4 5
## 
## $ID
## [1] "a"
## 
## $Test
## [1]  TRUE FALSE FALSE
## 
## $Score
## [1]   3.2 103.0  82.3

# comparing [[ with [ in subsetting a list
my_list[[1]]

## [1] 1 2 3 4 5

my_list[1]

## $Ranking
## [1] 1 2 3 4 5

[[ is very useful when working with a list. Because when [ is applied to a list, it always returns a list. While [[ returns the contents of the list. [[ can only extrac/return one element, so it only accept one integer/string as input.

Because data frames are implemented as lists of columns, one may use [[ to extract a column from data frames.

meta.data[["disease_stage"]]

## [1] Stage1 Stage2 Stage2 Stage3 Stage1 Stage4
## Levels: Stage2 Stage1 Stage3 Stage4

$ is a shorthand for [[ combined with character subsetting.

# subsetting a list using $ 
my_list$Score

## [1]   3.2 103.0  82.3

# subsetting a data frame using
meta.data$disease_stage

## [1] Stage1 Stage2 Stage2 Stage3 Stage1 Stage4
## Levels: Stage2 Stage1 Stage3 Stage4

Simplifying vs. preserving subsetting

We have seen some examples of simplying vs. preserving subsetting, for example:

# simplifying subsetting
my_list[[1]]

## [1] 1 2 3 4 5

# preserving subsetting
my_list[1]

## $Ranking
## [1] 1 2 3 4 5

Basically, simplying subsetting returns the simplest possible data structure that can represent the output. While preserving subsetting keeps the structure of the output as the same as the input. In the above example, [[ simplifies the output to a vector, while [ keeps the output as a list.

Because the syntax of carrying out simplifying and preserving subsetting differs depending on the data structure, the table below provides the information for the most basic data structure.

Please play around with the data structures that we have created to understand the behaviours of simplifying and preserving subsetting

One useful function to find out information on an R object: str(). It compactly display the internal structure of an R object.

str(data2)

## 'data.frame':    33602 obs. of  24 variables:
##  $ C61 : int  322 149 15 687 1 1447 2667 297 0 74 ...
##  $ C62 : int  346 87 32 469 1 1032 2472 226 0 79 ...
##  $ C63 : int  256 162 35 568 5 1083 2881 325 0 138 ...
##  $ C64 : int  396 144 22 651 4 1204 2632 341 0 85 ...
##  $ C91 : int  372 189 24 885 5 1413 5120 199 0 68 ...
##  $ C92 : int  506 169 33 978 3 1484 6176 180 0 41 ...
##  $ C93 : int  361 147 21 794 0 1138 7088 195 0 110 ...
##  $ C94 : int  342 108 35 862 2 938 6810 107 0 81 ...
##  $ I561: int  638 163 18 799 4 1247 2258 377 0 72 ...
##  $ I562: int  488 141 8 769 3 1516 1808 534 0 76 ...
##  $ I563: int  440 119 54 725 1 984 2279 300 0 184 ...
##  $ I564: int  479 147 35 715 0 1044 2299 223 0 156 ...
##  $ I591: int  770 182 23 811 2 1374 4755 298 0 96 ...
##  $ I592: int  430 156 8 567 8 1355 3128 318 0 70 ...
##  $ I593: int  656 153 16 831 8 1437 4419 397 0 77 ...
##  $ I594: int  467 177 24 694 1 1577 3726 373 0 77 ...
##  $ I861: int  143 43 42 345 0 412 1452 86 0 174 ...
##  $ I862: int  453 144 17 575 4 1338 1516 266 0 113 ...
##  $ I863: int  429 114 22 605 0 1051 1455 281 0 69 ...
##  $ I864: int  206 50 39 404 3 621 1429 164 0 176 ...
##  $ I891: int  567 161 26 735 5 1434 3867 230 0 69 ...
##  $ I892: int  458 195 28 651 7 1552 4718 270 0 80 ...
##  $ I893: int  520 157 39 725 0 1248 4580 220 0 81 ...
##  $ I894: int  474 144 30 591 5 1186 3575 229 0 62 ...

Challenge:

Please rewrite the calculation of the column sum using while loop.

apply() takes array or matrix as input and output in vector, array or list.

# recall my_matrix
my_matrix

##      col1 col2 col3
## row1    1    2    8
## row2    3   18   37
## row3    8   27  267
## row4    9   10   19

# check the usage of apply() function
?apply()
# calculate sums for each row
apply(my_matrix, MARGIN=1, sum)

## row1 row2 row3 row4 
##   11   58  302   38

lapply() takes a list, vector or data frame as input and outputs in list.

?lapply()

# generate some random data matrix
data <- as.data.frame(matrix(rnorm(49), ncol=7), stringsAsFactors=F)
dim(data)

## [1] 7 7

# calculate the sum for each row
lapply(1:dim(data)[1], function(x){sum(data[x,])})

## [[1]]
## [1] 0.7489872
## 
## [[2]]
## [1] -1.107934
## 
## [[3]]
## [1] -3.226682
## 
## [[4]]
## [1] -2.384708
## 
## [[5]]
## [1] 3.45378
## 
## [[6]]
## [1] -3.428476
## 
## [[7]]
## [1] 2.634509

# comparing the results to apply() results
apply(data, MARGIN=1, sum)

## [1]  0.7489872 -1.1079337 -3.2266819 -2.3847076  3.4537804 -3.4284755  2.6345085

# calculate log10 of the sum of each row
lapply(1:dim(data)[1], function(x){log10(sum(data[x,]))})

## Warning in FUN(X[[i]], ...): NaNs produced

## Warning in FUN(X[[i]], ...): NaNs produced

## Warning in FUN(X[[i]], ...): NaNs produced

## Warning in FUN(X[[i]], ...): NaNs produced

## [[1]]
## [1] -0.1255256
## 
## [[2]]
## [1] NaN
## 
## [[3]]
## [1] NaN
## 
## [[4]]
## [1] NaN
## 
## [[5]]
## [1] 0.5382947
## 
## [[6]]
## [1] NaN
## 
## [[7]]
## [1] 0.4206996

The function sapply() works like function lapply(), but tries to simplify the output to the most elementary data structure that is possible. As a matter of fact, sapply() is a “wrapper” function for lapply(). By default, it returns a vector.

# To check the syntax of using sapply():
?sapply()

sapply(1:dim(data)[1], function(x){log10(sum(data[x,]))})

## Warning in FUN(X[[i]], ...): NaNs produced

## Warning in FUN(X[[i]], ...): NaNs produced

## Warning in FUN(X[[i]], ...): NaNs produced

## Warning in FUN(X[[i]], ...): NaNs produced

## [1] -0.1255256        NaN        NaN        NaN  0.5382947        NaN  0.4206996

If the “simplify” parameter is turned off, sapply() will produced exactly the same results as lapply(), in the form of a list. By default, “simplify” is turned on.

sapply(1:dim(data)[1], function(x){log10(sum(data[x,]))}, simplify=FALSE)

## Warning in FUN(X[[i]], ...): NaNs produced

## Warning in FUN(X[[i]], ...): NaNs produced

## Warning in FUN(X[[i]], ...): NaNs produced

## Warning in FUN(X[[i]], ...): NaNs produced

## [[1]]
## [1] -0.1255256
## 
## [[2]]
## [1] NaN
## 
## [[3]]
## [1] NaN
## 
## [[4]]
## [1] NaN
## 
## [[5]]
## [1] 0.5382947
## 
## [[6]]
## [1] NaN
## 
## [[7]]
## [1] 0.4206996