The basic data structures in R can be divided in to two types
Types of data structures
- Homogeneous
- All the elements in the data structure are of same type (string, number, boolean etc)
- Heterogeneous
- The elements in the data structure can be of mixed type.
Basic Data structures in R
Here are the basic data structures. We will go through each of them in detail in subsequent tutorials.
| Data structure | Type | Dimensions |
|---|---|---|
| Vector | Homogeneous | 1 |
| List | Heterogeneous | 1 |
| Matrix | Homogeneous | 2 |
| Array | Homogeneous | any |
| Data frame | Heterogeneous | 2 |
Note that there are no scalars in R. scalars can be thought of as vectors of length 1.
Lets look at data structures and understand how they differ
Vector (atomic)
> vector("logical",2)
[1] FALSE FALSE
> vector("integer",2)
[1] 0 0
> vector("numeric",2)
[1] 0 0
> vector("double",2)
[1] 0 0
> vector("character",2)
[1] "" ""
> vector("complex",2)
[1] 0+0i 0+0i
> vector("raw",2)
[1] 00 00
>
An easy way to create a vector is to use the ‘c’ (combine) function. When different types of elements are used in a combine function, it coerces all elements to a single type based on this hierarchy NULL < raw < logical < integer < double < complex < character
> a=c(1,2)
> is.atomic(a)
[1] TRUE
> typeof(a)
[1] "double"
> a=c("1",2)
> typeof(a)
[1] "character"
> a
[1] "1" "2"
use the ‘L’ suffix to create integers instead of double
> typeof(c(1L,2L)) [1] "integer" > typeof(c(1,2)) [1] "double"
To test whether the vector contains elements of a particular type use the isxxxx function. The major functions are
is.character(), is.logical(), is.character(),is.numeric(),is.integer(),
is.complex(),is.raw(),is.double() and the generic is.atomic()
> is.character(vector("character",2))
[1] TRUE
> is.atomic(vector("character",2))
[1] TRUE
The
typeof()
method that we saw earlier determines the internal storage type of an object. You can explicitly convert elements of a vector from one type to another using the asXXX() function.
> a=c(1,2) > typeof(a) [1] "double" > b=as.character(a) > typeof(b) [1] "character" > b [1] "1" "2"
Lets look at ways to subset or retrieve elements from an atomic vector
‘[‘ vs ‘[[‘
[ ] can be used to retrieve a subset of the vector. It returns another list. Even if you want to retrieve a single element, it retrieves a list. ‘[[]]’ can be used to retrieve a single element. It cannot return more than one element.
> a=c(1,2,3) > a[1] [1] 1 > a[[1]] [1] 1 > a[1-3] [1] 1 3 > a[[1-3]] Error in a[[1 - 3]] : attempt to select more than one element
Subset using integer
In the previous example we saw how to subset using an integer. lets look at some more examples. We create a vector a of characters. We can retrieve any element using an integer index
> a=c('a','b','c','d','e')
> a[3]
[1] "c"
We can retrieve a subset by specifying multiple indexes
> a[c(1,4)]
[1] "a" "d"
>
We can subset using a range
> a[seq(1:3)]
[1] "a" "b" "c"
We can give it a negative index to 'exclude' that element.
> a[-3]
[1] "a" "b" "d" "e"
this excludes the third element.
you can't include both negative and positive numbers
> a[c(-2,1)]
Error in a[c(-2, 1)] : only 0's may be mixed with negative subscripts
You could also give it a mathematical expression
> a[4/2]
[1] "b"
> a[4/3]
[1] "a"
A missing value in index is converted to a missing value in the output
> a[c(1,NA)]
[1] "a" NA
Subset using boolean
We could use boolean values to subset. Lets look at some examples
> a[c(TRUE,FALSE,TRUE,TRUE,FALSE)] [1] "a" "c" "d" This returns elements at TRUE positions. You can also use the shortcut T and F > a[c(TRUE,FALSE,TRUE,T,F)] [1] "a" "c" "d" Logical lists are recycled > a[c(T,F)] [1] "a" "c" "e" T,F is recycled to T,F,T,F,T
List
> a=list(1,TRUE,T,'a',2.3) > str(a) List of 5 $ : num 1 $ : logi TRUE $ : logi TRUE $ : chr "a" $ : num 2.3
some things to note
- we have created a list containing elements of different types.
- logical elements can be represented as TRUE as well as T
- the
str()function can be used to compactly display the internals of an R object.
A list can contain other lists.
> b=list(a,5,6) > str(b) List of 3 $ :List of 5 ..$ : num 1 ..$ : logi TRUE ..$ : logi TRUE ..$ : chr "a" ..$ : num 2.3 $ : num 5 $ : num 6
something very interesting happens when we convert the list to an atomic vector. It ‘unfolds’ all inner lists recursively and returns as a single atomic vector. Use the function
unlist()
to convert a list to an atomic vector
> unlist(b) [1] "1" "TRUE" "TRUE" "a" "2.3" "5" "6"
Note that as.vector() does not convert list to an atomic vector, since a list is already a vector (With mode ‘list’). You can convert any other data structure to a list using the as.list() function.
List (as well as atomic vectors) allows names for all elements. Lets look at an example
> a=list(apple=1,orange=2) > str(a) List of 2 $ apple : num 1 $ orange: num 2 >
apple and orange are names. All the names can be retrieved using the function attributes(). Note that the names are not actually attributes of a list but are just reported as one.
> attributes(a) $names [1] "apple" "orange"
This is how you remove the names from a list
> attributes(a) <- NULL > str(a) List of 2 $ : num 1 $ : num 2
you can use is.list() to check if the object is a list.R also has a concept of Pairlist. These are internally represented as a linked list instead of a vector.
Attributes
lists can have attributes. Attributes are additional information that can be stored with the object. Lets look at an example
> a=list(apple=1,orange=2) > attr(a,"type") <- 'fruit' > a $apple [1] 1 $orange [1] 2 attr(,"type") [1] "fruit"
Here we have added an attribute called type to the list. We say that this list contains elements of type fruit. the
attr
function can be used to get or set an attribute
Look at subsetting in atomic vectors for common subsetting operations. Here we describe operations specific to a list
we Use the following list of the examples
> a=c('a','b','c','d','e')
> b=list('alphabets'=a,'fruits'=c('apple'=1,'orange'=2))
> b
$alphabets
[1] "a" "b" "c" "d" "e"
$fruits
apple orange
1 2
Subset using $
You can use the $ to subset a list using its name
> b$alphabets [1] "a" "b" "c" "d" "e"