# Basic data types¶

This chapter briefly discusses the basic data types that are used in R. Here we mainly show how to create data of these types. There is much more on how to manipulate data in the following chapters. The most important basic (or “primitive”) data types are the “numeric” and “character” types. Additional types are the “integer”, which can be used to represent whole numbers; the “logical” and the “factor”. These are all discussed below.

## Numeric and integer values¶

Let’s create a variable a that is a vector of one number.

a <- 7


To do this yourself, type the code in an R console. Or, if you use R-Studio, use ‘File / New File / R script’ and type it in the new script. Then press “Run” or “Ctrl-Enter” (Apple-Enter on a Mac) to run the line (make sure your cursor is on the line that you want to run).

The “arrow” <- was used to assign the value 7 to variable a. You can pronounce the above as “a becomes 7”.

It is also possible to use the = sign.

a = 7


Although you can use =, <- is preferred, because the arrow clearly indicates the assignment action, and because = is also used in another context (to pass arguments to functions).

The name a is entirely arbitrary. We could have used x, varib, fruit or any other name that would help us recognize it. There are a few restrictions: variable names cannot start with a number, and they cannot contain spaces or “special” characters, such as * (which is used for multiplication).

To check the value of a, we can ask R to show or print it.

show(a)
## [1] 7
print(a)
## [1] 7


This is also what happens if you simply type the variable name.

a
## [1] 7


In R, all basic values are stored as a vector, a one-dimensional array of n values of a certain type. Even a single number is a vector (of length 1). That is why R shows that the value of a is [1] 7. Because 7 is the first element in vector a.

We can use the class function to find out what type of object a is (what class it belongs to).

class(a)
## [1] "numeric"


numeric means that a is a real (decimal) number. Its value is equivalent to 7.000, but trailing zeros are not printed by default. In a few cases it can be useful, or even necessary, to use integer (whole number) values. To create a vector with a single integer you can either use the as.integer function, or append an L to the number.

a <- as.integer(7)
class(a)
## [1] "integer"
a <- 7L
class(a)
## [1] "integer"


To create a vector of several numbers, the c (combine) function can be used.

b <- c(1.25, 2.9, 3.0)
b
## [1] 1.25 2.90 3.00


But to create a regular sequence it is easier to use :.

d <- 5:9
d
## [1] 5 6 7 8 9


You can also use the : to create a sequence in descending order.

6:2
## [1] 6 5 4 3 2


The seq function provides more flexibility. For example it allows for step sizes different than one. In this case we go from 3 to 12, taking steps of 3. Try some variations!

e <- seq(from=6, to=12, by=3)
e
## [1]  6  9 12


To go in descending order the by argument needs to be negative.

seq(from=12, to=0, by=-4)
## [1] 12  8  4  0


You can also reverse the order of a sequence, after making the sequence, using the rev function.

s <- seq(from=0, to=12, by=4)
s
## [1]  0  4  8 12
r <- rev(s)
r
## [1] 12  8  4  0


We will discuss functions like seq in more detail later. But, in essence, a function is a named procedure that performs a certain task. In this case the name is seq, and the task is to create a sequence of numbers. The exact specification of the sequence is modified by the arguments that are provided to seq, in this case: from, to, and by. If you are unsure what a function does, or which arguments are available, then read the function’s help page. You can get to the help page for seq by typing ?seq or help(seq), and likewise for all other functions in R.

The rep (for repeat) function provides another way to create a vector of numbers. You can repeat a single number, or a sequence of numbers.

rep(9, times=5)
## [1] 9 9 9 9 9
rep(5:7, times=3)
## [1] 5 6 7 5 6 7 5 6 7
rep(5:7, each=3)
## [1] 5 5 5 6 6 6 7 7 7


## Character values¶

A character variable is used to represent letters, codes, or words. Character values are often referred to as a ‘string’.

x <- 'Yi'
y <- 'Wong'
class(x)
## [1] "character"
x
## [1] "Yi"


To distinguish a character value from a variable name, it needs to be quoted. 'x' is a character value, but x is a variable! Double-quoted "Yi" is the same as single-quoted 'Yi', but you cannot mix the two in one value: "Yi' is not valid. But you can enclose one type of quote inside a pair of the other type. For example, you can do "Yi's dog" or 'Wong said "hello" and left'.

One of the most common mistakes for beginners is to forget the quotes.

Yi


The error occurs because R tries to print the value of variable Yi, but there is no such variable. So remember that any time you get the error message object 'something' not found, the most likely reason is that you forgot to quote a character value. If not, it probably means that you have misspelled, or not yet created, the variable that you are referring to.

Keep in mind that R is case-sensitive: a is not the same as A. In most computing contexts, a and A are entirely different and, for most intents and purposes, unrelated symbols.

Now let’s create variable countries holding a character vector of five elements.

countries <- c('China', 'China', 'Japan', 'South Korea', 'Japan')
class(countries)
## [1] "character"
countries
## [1] "China"       "China"       "Japan"       "South Korea" "Japan"


The function length tells us how long the vector is (how many elements it has).

length(countries)
## [1] 5


If you want to know the number of characters of each element of the vector, you can use nchar.

nchar(countries)
## [1]  5  5  5 11  5


nchar returns a vector of integers with the same length as x (5). Each number is the number of characters of the corresponding element of countries. This is an example of why we say that most functions in R are vectorized. This means that you normally do not need to tell R to compute things for each individual element in a vector.

It is handy to know that letters (a constant value, like pi) returns the alphabet (LETTERS returns them in uppercase), and toupper and tolower can be used to change case.

z <- letters
z
##  [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q"
## [18] "r" "s" "t" "u" "v" "w" "x" "y" "z"
up <- toupper(z)


Perhaps the most commonly used function for string manipulation is paste. This function is used to concatenate strings. For example:

girl <- "Mary"
boy <- "John"
paste(girl, "likes", boy)
## [1] "Mary likes John"


By default, paste uses a space to separate the elements. You can change that with the sep argument.

paste(girl, "likes", boy, sep = " ~ ")
## [1] "Mary ~ likes ~ John"


Sometimes you do not want any separator. You can then use sep="" or the paste0 function.

By using the “collapse” argument, we can concatenate all values of a vector into a single element.

paste(countries, collapse=' -- ')
## [1] "China -- China -- Japan -- South Korea -- Japan"


We’ll leave more advanced manipulation of strings for later, but here are two more important functions. To get a part of a string use ‘substr’.

substr('Hello World', 1, 5)
## [1] "Hello"
substr('Hello World', 7, 11)
## [1] "World"


To replace characters in a string use gsub or sub.

gsub('l', '!!', 'Hello World')
## [1] "He!!!!o Wor!!d"
gsub('Hello', 'Bye bye', 'Hello World')
## [1] "Bye bye World"


To find elements that fit a particular pattern use grep. It returns the index of the matching elements in a vector.

d <- c('az20', 'az21', 'az22', 'ba30', 'ba31', 'ba32')
i <- grep('b', d)
i
## [1] 4 5 6
d[i]
## [1] "ba30" "ba31" "ba32"


Which elements of d include the character “2”?

grep('2', d)
## [1] 1 2 3 6


Which elements of d end with the character “2”? “$” has a special meaning. grep('2$', d)
## [1] 3 6


Which elements of d start with the character “b”? “^” has a special meaning.

grep('^b', d)
## [1] 4 5 6


## Logical values¶

A logical (or Boolean) value is either TRUE or FALSE. They are used very frequently in R and in computer programming in general.

z <- FALSE
z
## [1] FALSE
class(z)
## [1] "logical"
z <- c(TRUE, TRUE, FALSE)
z
## [1]  TRUE  TRUE FALSE


TRUE and FALSE can be abbreviated to T and F, but that is very bad practice. This is because it is possible to change the value of T and F to something else which would be extraordinarily confusing. In contrast, TRUE and FALSE are constants that cannot be changed.

Logical values are often the result of a computation. For example, here we ask if the values of x are larger than 3, which is TRUE for values 4 and 5

x <- 5
x > 3
## [1] TRUE


Likewise we can test for equality using two equal signs == (not = which would be an assignment!). <= means “smaller or equal”.

x == 3
## [1] FALSE
x <= 2
## [1] FALSE


Logical values can be treated as numerical values. TRUE is equivalent to 1 and FALSE to 0.

y <- TRUE
y + 1
## [1] 2


However, if you go the other way, only zero is equivalent to FALSE while any number that is not zero, is TRUE

as.logical(0)
## [1] FALSE
as.logical(1)
## [1] TRUE
as.logical(2.5)
## [1] TRUE


## Factors¶

A factor is a nominal (categorical) variable with a set of known possible values called levels. They can be created using the as.factor function. In R you typically need to convert (cast) a character variable to a factor to identify groups for use in statistical tests and models.

f1 <- as.factor(countries)
f1
## [1] China       China       Japan       South Korea Japan
## Levels: China Japan South Korea


But numbers can also be used. For example, they may simply indicate group membership.

f2 <- c(5:7, 5:7, 5:7)
f2
## [1] 5 6 7 5 6 7 5 6 7
f2 <- as.factor(f2)
f2
## [1] 5 6 7 5 6 7 5 6 7
## Levels: 5 6 7


Dealing with factors can be tricky. For example f2 created above is not what it may seem. We see numbers 5, 6 and 7, but these are now just labels to identify groups. They cannot be used in algebraic expressions.

We can convert factors to something else. Here we use as.integer. If you want a number with decimal places, you can use as.numeric instead.

f2
## [1] 5 6 7 5 6 7 5 6 7
## Levels: 5 6 7
as.integer(f2)
## [1] 1 2 3 1 2 3 1 2 3


The result of as.integer(f2) may have been surprising. But it should not be, as there is no direct link between a category with label “5” and the number 5. In this case, “5” is simply the label of the first category and hence it gets converted to the integer 1. Nevertheless, we can get the numbers back as there is an established link between the character symbol ‘5’ and the number 5. So we first create characters from the factor values, and then numbers from the characters.

fc2 <- as.character(f2)
fc2
## [1] "5" "6" "7" "5" "6" "7" "5" "6" "7"
as.integer(fc2)
## [1] 5 6 7 5 6 7 5 6 7


This is different from as.integer(f2), which returned the indices of the factor values. It has no way of knowing if you want factor level 6 to represent the number 6.

At this point it is OK if you are confused about factors and why you might do such things as conversion from and to them.

## Missing values¶

All basic data types can have “missing values”. These are represented by the symbol NA for “not available”. For example, we can have vector ‘m’

m <- c(2, NA, 5, 2, NA, 2)
m
## [1]  2 NA  5  2 NA  2


Note that NA is not quoted.

Properly treating missing values is very important. The first question to ask when they appear is whether they should be missing (or did you make a mistake in the data manipulation?). If they should be missing, the second question becomes how to treat them. Can they be ignored? Should the records with NAs be removed?

## Time¶

Representing time is a somewhat complex problem. There are different calendars, hours, days, months, and leap years to consider. As a basic introduction, here is simple way to create date values.

d1 <- as.Date('2015-4-11')
d2 <- as.Date('2015-3-11')
class(d1)
## [1] "Date"
d1 - d2
## Time difference of 31 days


And there are more advanced classes as well that capture date and time.

as.POSIXlt(d1)
## [1] "2015-04-11 UTC"
as.POSIXct(d1)
## [1] "2015-04-10 17:00:00 PDT"