Two dimensional R objects include data.frame, matrix and table objects. You can transpose the rows and columns using the t() command. Here is a simple data.frame:

> dat <- as.data.frame(matrix(1:12, ncol = 4))
> colnames(dat) <- LETTERS[1:4]
> dat
  A B C  D
1 1 4 7 10
2 2 5 8 11
3 3 6 9 12

You can rotate the data.frame so that the rows become the columns and the columns become the rows. That is, you transpose the rows and columns. You simply use the t() command.

> t(dat)
  [,1] [,2] [,3]
A    1    2    3
B    4    5    6
C    7    8    9
D   10   11   12

The result of the t() command is always a matrix object.

> dat.t <- t(dat)
> class(dat.t)
[1] "matrix"

You can also rotate a matrix object or a table, as long as the table only has 2 dimensions. These items will have rownames() and colnames() elements (even if empty). You can use the dim() command to look at the dimensions of an object.

> dim(HairEyeColor)
[1] 4 4 2

The HairEyeColor table has more than 2 dimensions and so will not rotate:

> t(HairEyeColor)
Error in t.default(HairEyeColor) : argument is not a matrix

However, you can get part of the table (as 2-dimensions):

> HEC <- as.table(HairEyeColor[,,1])
> HEC
       Eye
Hair    Brown Blue Hazel Green
  Black    32   11    10     3
  Brown    53   50    25    15
  Red      10   10     7     7
  Blond     3   30     5     8

> class(HEC)
[1] "table"

Now it can be rotated:

> t(HEC)
       Hair
Eye     Black Brown Red Blond
  Brown    32    53  10     3
  Blue     11    50  10    30
  Hazel    10    25   7     5
  Green     3    15   7     8

The colnames() and rownames() elements are preserved (but transposed of course), any names() attributes are lost (since the result is a matrix):

> HEC.t <- t(HEC)
> dimnames(HEC.t)
$Eye
[1] "Brown" "Blue"  "Hazel" "Green"

$Hair
[1] "Black" "Brown" "Red"   "Blond"

• Use t() to rotate (transpose) frame, matrix or table objects with 2-dimensions.
• Check the dimensions using dim().
• The result is always a matrix.
• The colnames() and rownames() attributes are preserved (but transposed).
• Any names() attributes are lost.

Many R objects are composed of multiple elements. There are various ways to extract one (or more) elements from an object, depending on the object itself.

A simple vector for example is a 1-D object; you can get elements from a vector using the square brackets:

# Make a numeric vector
> data1 <- c(3, 5, 7, 5, 3, 2, 6, 8, 5, 6, 9)
> data1
[1] 3 5 7 5 3 2 6 8 5 6 9

> data1[1] # The first item
[1] 3

> data1[3] # The third item
[1] 7

> data1[1:4] # The first 4 items
[1] 3 5 7 5

> data1[-1] # All except the first
[1] 5 7 5 3 2 6 8 5 6 9

> data1[c(1, 3, 4, 8)] # The 1st, 3rd, 4th, 8th
[1] 3 7 5 8

> data1[data1 > 3] # All items > 3
[1] 5 7 5 6 8 5 6 9

> data1[data1 < 5 | data1 > 7] # Items < 5 OR > 7
[1] 3 3 2 8 9

If your object has 2 dimensions, such as a data.frame or a matrix you can use the same idea but now specify [rows, columns]. Extra dimensions can be supplied if needed (e.g. for a table).

> mymat <- matrix(1:30, ncol = 5, dimnames = list(letters[1:6], LETTERS[1:5]))
> mymat
  A  B  C  D  E
a 1  7 13 19 25
b 2  8 14 20 26
c 3  9 15 21 27
d 4 10 16 22 28
e 5 11 17 23 29
f 6 12 18 24 30

> mymat[2, 3] # Item from 2nd row and 3rd column
[1] 14

> mymat[, 2]  # All rows but only 2nd column
a  b  c  d  e  f
7  8  9 10 11 12

> mymat[3, ] # All columns but only 3rd row
A  B  C  D  E
3  9 15 21 27

> mymat[-1, ]  # All columns and all rows except the first
  A  B  C  D  E
b 2  8 14 20 26
c 3  9 15 21 27
d 4 10 16 22 28
e 5 11 17 23 29
f 6 12 18 24 30

> mymat[, "B"] # All rows and the column named "B"
a  b  c  d  e  f
7  8  9 10 11 12

You can also use conditional statements just like for a vector.

With some objects you can use the $, particularly data.frame and list objects:

> mydf <- data.frame(num = 1:12, mnths = month.abb[1:12], fac = gl(3, 4, labels = c("high", "mid", "low")), let = LETTERS[12:1])

> mydf
   num mnths  fac let
1    1   Jan high   L
2    2   Feb high   K
3    3   Mar high   J
4    4   Apr high   I
5    5   May  mid   H
6    6   Jun  mid   G
7    7   Jul  mid   F
8    8   Aug  mid   E
9    9   Sep  low   D
10  10   Oct  low   C
11  11   Nov  low   B
12  12   Dec  low   A

> mylist <- list(num = 1:6, let = letters[9:1], mnth = month.abb[1:7])
> mylist
$num
[1] 1 2 3 4 5 6

$let
[1] "i" "h" "g" "f" "e" "d" "c" "b" "a"

$mnth
[1] "Jan" "Feb" "Mar" "Apr" "May" "Jun" "Jul"

The $ is used with the element name like so:

> mydf$let
[1] L K J I H G F E D C B A
Levels: A B C D E F G H I J K L

> mydf$num
[1]  1  2  3  4  5  6  7  8  9 10 11 12

> mylist$mnth
[1] "Jan" "Feb" "Mar" "Apr" "May" "Jun" "Jul"

You can also use square brackets. For the data.frame the [row, column] syntax works as it did for the matrix. Giving a single value selects a column.

> mylist[1]
$num
[1] 1 2 3 4 5 6

> mydf[2]
   mnths
1    Jan
2    Feb
3    Mar
4    Apr
5    May
6    Jun
7    Jul
8    Aug
9    Sep
10   Oct
11   Nov
12   Dec

> mydf[2,]
  num mnths  fac let
2   2   Feb high   K

Note that the $ does not work with a matrix object.

You can use double brackets to select elements in more or less the same way as single brackets. The difference between single and double is that with double brackets any element names are not displayed:

> mydf[[2]]
[1] Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec
Levels: Apr Aug Dec Feb Jan Jul Jun Mar May Nov Oct Sep

> mydf[2]
   mnths
1    Jan
2    Feb
3    Mar
4    Apr
5    May
6    Jun
7    Jul
8    Aug
9    Sep
10   Oct
11   Nov
12   Dec

mylist[3]
$mnth
[1] "Jan" "Feb" "Mar" "Apr" "May" "Jun" "Jul"

> mylist[[3]]
[1] "Jan" "Feb" "Mar" "Apr" "May" "Jun" "Jul"

You don’t have to use an index value, the element name gives a similar result:

> mylist[["let"]]
[1] "i" "h" "g" "f" "e" "d" "c" "b" "a"

> mylist["let"]
$let
[1] "i" "h" "g" "f" "e" "d" "c" "b" "a"

So, the $ can be used with vector and data.frame objects and the [] with more or less any object. Use [[]] to suppress the element name.

All R objects have a class attribute, which can be important as R “decides” how to deal with objects based upon their class.

You can think of the simple classes as being in different categories:

• Basic: numeric, character or factor
• Logical: TRUE or FALSE
• Complex: A number with real and imaginary parts

You can make a complex number simply by appending an “imaginary” part to an actual number:

> newvec <- c(1+1i, 2+3i)
> newvec
[1] 1+1i 2+3i

So, R recognises 2+3i for example as a complex number with real part = 2, imaginary part = 3

The class() command shows that the result is complex:

> class(newvec)
[1] "complex"

There are several commands associated with complex numbers:

# The real part of the number
> Re(newvec)
[1] 1 2

# The imaginary part
> Im(newvec)
[1] 1 3

# The modulus
> Mod(newvec)
[1] 1.414214 3.605551

# The argument
> Arg(newvec)
[1] 0.7853982 0.9827937

# The complex conjugate
> Conj(newvec)
[1] 1-1i 2-3i

The commands help in dealing with complex numbers. In addition, the elementary trigonometric, logarithmic, exponential, square root and hyperbolic functions are implemented for complex values.

R “recognises” various sorts of object. Every object holds a class attribute, which controls how the object is dealt with by various commands.

At the most basic level you can think of R objects as being in one of three main forms:

• numeric
• character
• factor

The numeric type is obvious – numbers:

> num <- c(2.3, 4.1, 5, 12.2)
> num
[1] 2.3 4.1 5.0 12.2

> class(num)
[1] "numeric"

The character type is also obvious – text:

> chr <- c("a", "b", "c")
> chr
[1] "a" "b" "c"

> class(chr)
[1] "character"

The last basic type is a factor. The factor can appear like a number or a character, depending upon its contents:

> fact <- gl(3, 2)
> fact
[1] 1 1 2 2 3 3
Levels: 1 2 3

> class(fact)
[1] "factor"

The previous object (fact) looks like numbers. The following looks superficially like characters:

> fac <- gl(3, 2, labels = c("p", "q", "r"))
> fac
[1] p p q q r r
Levels: p q r

> class(fac)
[1] "factor"

In fact, you can see that it is not a character object because the text items do not have quotes around them. Another “clue” is the Levels: part of the display – but beware because this is not always displayed.

Factor objects are important and are used in many statistical analyses. When you import data using read.csv() for example, the columns of text are converted to factor objects unless you explicitly tell R otherwise.