Difference between data frame and matrix indexing - r

Question

I have a text file of integers which I've been reading into R and storing as a data frame for the time being. However, coercing it to a matrix it (say y, using as.matrix()) doesn't seem to be the same as the matrix I created (x). Namely, if I look at a single entry I get different output
> y[1,1]
V1
0
as opposed to
> x[1,1]
[1] 0
Can anyone explain the difference?

Answer 1

I am interpreting your question as asking what is the difference between a matrix and a data frame and not just why does the output of y[1,1] look different if y is a data frame vs. matrix. If all you want to know is why they look different then the answer is that data frames and matrices are different classes and have different internal representations and although many operations have been designed and implemented to paper over the differences in the end matrix indexing and data frame indexing are separately implemented and do not necessarily have to be the same although hopefully they are implemented reasonably consistently. At this point it would likely be unwise to modify R to reduce any inconsistencies given how much code it might break.
matrix A matrix is a vector with dimensions.
m1 <- 1:12
dim(m1) <- c(4, 3)
m2 <- matrix(1:12, 4, 3)
identical(m1, m2)
## [1] TRUE
length(m1) # 12 elements in the underlying vector
## [1] 12
data frame
A data.frame is a named list (the names are the column names) of columns with row names -- the default row names of 1, 2, ... are internally represented as c(NA, -4L) for a 4 row data frame in order to avoid having to store a possibly large vector of row names.
DF1 <- as.data.frame(m1)
DF2 <- list(V1 = 1:4, V2 = 5:8, V3 = 9:12)
attr(DF2, "row.names") <- c(NA, -4L)
class(DF2) <- "data.frame"
identical(DF1, DF2)
## [1] TRUE
length(DF1) # 3 columns
## [1] 3
names
Matrices do not have to have row or column names whereas data frames always do. If a matrix has row and column names then they are represented as a list of two vectors called dimnames (as opposed to a named list with a row.names attribute which is how data frames represent their row names).
m3 <- m1
rownames(m3) <- c("a", "b", "c", "d")
colnames(m3) <- c("A", "B", "C")
str(m3)
## int [1:4, 1:3] 1 2 3 4 5 6 7 8 9 10 ...
## - attr(*, "dimnames")=List of 2
## ..$ : chr [1:4] "a" "b" "c" "d"
## ..$ : chr [1:3] "A" "B" "C"
m4 <- m1
dimnames(m4) <- list(c("a", "b", "c", "d"), c("A", "B", "C"))
identical(m3, m4)
## [1] TRUE
lapply
Suppose we lapply over matrix m1. Since it is really a vector with dimensions we are lapplying over each of the 12 elements:
> str(lapply(m1, length))
List of 12
$ : int 1
$ : int 1
$ : int 1
$ : int 1
$ : int 1
$ : int 1
$ : int 1
$ : int 1
$ : int 1
$ : int 1
$ : int 1
$ : int 1
whereas if we do this over DF1 we are lapplying over 3 elements each of which has length 4
> str(lapply(DF1, length))
List of 3
$ V1: int 4
$ V2: int 4
$ V3: int 4
double indexing
Indexing is such that DF1[1,1] and m1[1,1] give the same result if the matrix does not have names.
DF1[1,1]
## [1] 1
m1[1,1]
## [1] 1
If it does then there is the observed difference:
as.matrix(DF1)[1,1] # as.matrix(DF1) has col names V1, V2, V3 from DF1
V1
1
DF1[1,1]
[1] 1
One has to be careful when convering a matrix to a data frame because if there are character and numeric columns in the data frame then the conversion will force them all to the same type, i.e. all to character.
single indexing
however, if we index like this then since a data frame is a list of columns we get a data frame made of the first column
> DF1[1]
V1
1 1
2 2
3 3
4 4
but for a matrix since it is a vector with dimensions we get the first element of that vector
> m1[1]
[1] 1
other
In the usual case all elements of a matrix are numeric, or all are character but for a data frame each column might be different. One column might be numeric whereas another might be character or logical.
Typically operations on matrices are faster than operations on data frames.

Answer 2

The attributes assigned to data structures also depend on the methods used to import or read data, and whether they are explicitly defined or coerced using others functions.
Here is a data frame called integers created by importing data from a .txt file.
> integers
V1 V2 V3
1 1 5 9
2 2 6 10
3 3 7 11
4 4 8 12
Here is data a matrix called m.integers created by passing integers to as.matrix()
as.matrix(integers)
> m.integers
V1 V2 V3
[1,] 1 5 9
[2,] 2 6 10
[3,] 3 7 11
[4,] 4 8 12
Here is a matrix called m2 created as indicated above by using matrix()
> m2
[,1] [,2] [,3]
[1,] 1 5 9
[2,] 2 6 10
[3,] 3 7 11
[4,] 4 8 12
Now selecting the first element of each structure gives the following.
Also looking at the attributes of each reveals the default values (or assigned values if you assigned any) for each attribute.
# The element is given a row name.
> integers[1,1]
[1] 1
# Notice attributes$row.names
> attributes(integers)
$names
[1] "V1" "V2" "V3"
$class
[1] "data.frame"
$row.names
[1] 1 2 3 4
#################################################
# The element is given a column name.
> m.integers[1,1]
V1
1
# Notice there is no row name attribute
> attributes(m.integers)
$dim
[1] 4 3
$dimnames
$dimnames[[1]]
NULL
$dimnames[[2]]
[1] "V1" "V2" "V3"
###############################################
# The element is given a row name.
> m2[1,1]
[1] 1
# Notice no row name attribute.
> attributes(m2)
$dim
[1] 4 3
According the the documentation for data.frame() the default for row.names = NULL and the row names are set to the integer sequence starting at [1]. And the row names are not preserved by as.matrix(). When passing a data frame to as.matrix() the column names are preserved. Rownames are also automatically assigned as a sequence of integers if unassigned when using matrix().
If necessary, the row names can be changed.
> attributes(integers)$row.names <- c("one", "two", "three", "four")
> integers
V1 V2 V3
one 1 5 9
two 2 6 10
three 3 7 11
four 4 8 12
> attributes(integers)$row.names <- c("one", "two", "three", "four")
> integers
V1 V2 V3
one 1 5 9
two 2 6 10
three 3 7 11
four 4 8 12
> attributes(m.integers)$dimnames[[2]] <- NULL
> m.integers
[,1] [,2] [,3]
[1,] 1 5 9
[2,] 2 6 10
[3,] 3 7 11
[4,] 4 8 12
> attributes(m.integers)$dimnames[[1]] <- c("one", "two", "three", "four")
> m.integers
[,1] [,2] [,3]
one 1 5 9
two 2 6 10
three 3 7 11
four 4 8 12