R Arrays

Content

Creating Arrays in R
Array Subscripting
Arrays as Contingency Tables
Outer Product and Infix Flexibility

Arrays in R are among the most important data structures for managing large, data objects. Arrays generalize matrices by extending the .Dim slot to more than two dimensions. The script below convert’s Anderson’s Iris data from a rectangular data frame to a 3-dimensional array and prints the first 2 of 50 rows:

# Initialize names and array
3D.names <- c("setosa", "versicolor", "virginica")
2D.names <- c("Sepal.L", "Sepal.W", "Petal.L", "Petal.W")
my.iris <- array(0, dim=c(50, 4, 3), dimnames=list(1:50, 2D.names, 3D.names))

# Define matrices by species
my.setosa <- as.matrix(iris[which(iris[, "Species"] == "setosa"), ][, 1:4])
my.versicolor <- as.matrix(iris[which(iris[, "Species"] == "versicolor"), ][, 1:4])
my.virginica <- as.matrix(iris[which(iris[, "Species"] == "virginica"), ][, 1:4])

# Populate Array
my.iris[,,"setosa"] <- my.setosa
my.iris[,,"versicolor"] <- my.versicolor
my.iris[,, "virginica"] <- my.virginica

# Print data
my.iris[1:2, , ]

, , setosa
    Sepal.L Sepal.W Petal.L Petal.W
1   5.1     3.5     1.4     0.2
2   4.9     3.0     1.4     0.2

, , versicolor
    Sepal.L Sepal.W Petal.L Petal.W
1   7.0     3.2    4.7     1.4
2   6.4     3.2     4.5     1.5

, , virginica
    Sepal.L Sepal.W Petal.L Petal.W
1   6.3     3.3     6.0     2.5
2   5.8     2.7     5.1     1.9

# Initialize names and array

3D.names <- c("setosa", "versicolor", "virginica")

2D.names <- c("Sepal.L", "Sepal.W", "Petal.L", "Petal.W")

my.iris <- array(0, dim=c(50, 4, 3), dimnames=list(1:50, 2D.names, 3D.names))

# Define matrices by species

my.setosa <- as.matrix(iris[which(iris[, "Species"] == "setosa"), ][, 1:4])

my.versicolor <- as.matrix(iris[which(iris[, "Species"] == "versicolor"), ][, 1:4])

my.virginica <- as.matrix(iris[which(iris[, "Species"] == "virginica"), ][, 1:4])

# Populate Array

my.iris[,,"setosa"] <- my.setosa

my.iris[,,"versicolor"] <- my.versicolor

my.iris[,, "virginica"] <- my.virginica

# Print data

my.iris[1:2, , ]

, , setosa

Sepal.L Sepal.W Petal.L Petal.W

1 5.1 3.5 1.4 0.2

2 4.9 3.0 1.4 0.2

, , versicolor

Sepal.L Sepal.W Petal.L Petal.W

1 7.0 3.2 4.7 1.4

2 6.4 3.2 4.5 1.5

, , virginica

Sepal.L Sepal.W Petal.L Petal.W

1 6.3 3.3 6.0 2.5

2 5.8 2.7 5.1 1.9

Creating Arrays in R

To create an array in R, use the array() function, which takes data and the dim argument as inputs. If no data is supplied, the array is filled with NAs. When passing values to array(), use vectors or matrices as only:

> array(c(1:8,11:18,111:118),dim=c(2,4,3))

, , 1
    [,1][,2][,3][,4]
[1,] 1   3   5   7
[2,] 2   4   6   8

, , 2
     [,1][,2][,3][,4]
[1,]  11  13  15  17
[2,]  12  14  16  18

, , 3
     [,1][,2][,3][,4]
[1,]  111 113 115 117
[2,]  112 114 116 118

> array(c(1:8,11:18,111:118),dim=c(2,4,3))

, , 1

[,1][,2][,3][,4]

[1,] 1 3 5 7

[2,] 2 4 6 8

, , 2

[,1][,2][,3][,4]

[1,] 11 13 15 17

[2,] 12 14 16 18

, , 3

[,1][,2][,3][,4]

[1,] 111 113 115 117

[2,] 112 114 116 118

The first dimension (rows) is incremented first, placing the values column by column. The second dimension (columns) is incremented second. The third dimension is incremented next, and so on until dimensions are defined.

The dim() function works for arrays in the same way it works for matrices when folding vectors into arrays. The dim() function lets you set the .dim slot. For example, if the input data above was stored in the vector vec, the above array is created by defining the .dim slot with the vector c(2, 4, 3):

> vec
[1]    1   2   3   4   5   6   7   8  11  12  13
[12]  14  15  16  17  18 111 112 113 114 115 116
[23] 117 118

> dim(vec) <- c(2, 4, 3)

> vec

[1] 1 2 3 4 5 6 7 8 11 12 13

[12] 14 15 16 17 18 111 112 113 114 115 116

[23] 117 118

> dim(vec) <- c(2, 4, 3)

To name each level of each dimension, use the dimnames argument to array(). This passes a list of names in the same way as is done for matrices:

# Define array input data
> a <- 1:24
> dim(a) <- c(3,4,2)
> dimnames(a) <- list(1:3, letters[1:4], c("Level 1","Level 2"))
> a

, , Level 1
  a b c  d
1 1 4 7 10
2 2 5 8 11
3 3 6 9 12

, , Level 2
   a  b  c  d
1 13 16 19 22
2 14 17 20 23
3 15 18 21 24

# Define array input data

> a <- 1:24

> dim(a) <- c(3,4,2)

> dimnames(a) <- list(1:3, letters[1:4], c("Level 1","Level 2"))

> a

, , Level 1

a b c d

1 1 4 7 10

2 2 5 8 11

3 3 6 9 12

, , Level 2

a b c d

1 13 16 19 22

2 14 17 20 23

3 15 18 21 24

Array Subscripting

Data extraction and replacement of array elements via subscripting is similar to matrices and relies on the [] infix operator. Using the example, above, the first row of the level 1 data is extracted as follows:

> a[1, , 1]
[1] 1 4 7 10

1 2	> a[1, , 1] [1] 1 4 7 10

More complex subscripting is also possible. The following example uses a matrix to extract and then replace multiple elements from several locations of a two dimensional array:

# Define and print the array
> x <- array(1:20, dim=c(4,5))
> x
     [,1] [,2] [,3] [,4] [,5]
[1,]    1    5    9   13   17
[2,]    2    6   10   14   18
[3,]    3    7   11   15   19
[4,]    4    8   12   16   20

# Generate and print the index matrix
> y <- array(c(1:3,3:1), dim=c(3,2))
> y

     [,1] [,2]
[1,]    1    3
[2,]    2    2
[3,]    3    1

# Extract array elements using the index matrix
> x[y]
[1] 9 6 3

# Replace array elements using the index matrix
> x[y] <- 0 > x

     [,1] [,2] [,3] [,4] [,5]
[1,]    1    5    0   13   17
[2,]    2    0   10   14   18
[3,]    0    7   11   15   19
[4,]    4    8   12   16   20

# Define and print the array

> x <- array(1:20, dim=c(4,5))

> x

[,1] [,2] [,3] [,4] [,5]

[1,] 1 5 9 13 17

[2,] 2 6 10 14 18

[3,] 3 7 11 15 19

[4,] 4 8 12 16 20

# Generate and print the index matrix

> y <- array(c(1:3,3:1), dim=c(3,2))

> y

[,1] [,2]

[1,] 1 3

[2,] 2 2

[3,] 3 1

# Extract array elements using the index matrix

> x[y]

[1] 9 6 3

# Replace array elements using the index matrix

> x[y] <- 0 > x

[,1] [,2] [,3] [,4] [,5]

[1,] 1 5 0 13 17

[2,] 2 0 10 14 18

[3,] 0 7 11 15 19

[4,] 4 8 12 16 20

Arrays as Contingency Tables

Contingency tables are unique arrays defined by the number of arguments given, and the tables present summary information based on the number of combinations defined by the observed data. The table() function will create a contingency table, voiding significant coding:

# Define observed data
> pet <- c("cat", "dog", "cat", "dog", "cat", "?")
> food <- c("dry", "dry", "dry", "wet", "wet", "wet")
> eat.time <- c("morn", "morn", "noon", "noon", "night", "night")

# Generate contingency table and print array summary
> table(pet, food, eat.time)

, , morn
   dry     wet
?    0       0
cat  1       0
dog  1       0

, , night
   dry     wet
?    0       1
cat  0       1
dog  0       0

, , noon
   dry     wet
?    0       0
cat  1       0
dog  0       1

# Define observed data

> pet <- c("cat", "dog", "cat", "dog", "cat", "?")

> food <- c("dry", "dry", "dry", "wet", "wet", "wet")

> eat.time <- c("morn", "morn", "noon", "noon", "night", "night")

# Generate contingency table and print array summary

> table(pet, food, eat.time)

, , morn

dry wet

? 0 0

cat 1 0

dog 1 0

, , night

dry wet

? 0 1

cat 0 1

dog 0 0

, , noon

dry wet

? 0 0

cat 1 0

dog 0 1

Outer Product and Infix Flexibility

An important operation involving arrays in R is the outer product. If a and b are two arrays, their outer product is an array whose dimension vector is is obtained by concatenating their two dimension vectors (order is important), and whose data vector is obtained by forming all possible products of elements of the data vector a with those of b (again order is important). For example:

# Define input matrices
> a <- matrix(1:4,  ncol = 2)
> b <- matrix(rep(10, 4), ncol = 2)

# Generate outer product and print
> ba <- b %o% a
> ba

, , 1, 1
    [,1] [,2]
[1,]  10   10
[2,]  10   10

, , 2, 1
    [,1] [,2]
[1,]  20   20
[2,]  20   20

, , 1, 2
    [,1] [,2]
[1,]  30   30
[2,]  30   30

, , 2, 2
    [,1] [,2]
[1,]  40   40
[2,]  40   40

Interrogate array dimension
> dim(ba)
[1] 2 2 2 2

# Define input matrices

> a <- matrix(1:4, ncol = 2)

> b <- matrix(rep(10, 4), ncol = 2)

# Generate outer product and print

> ba <- b %o% a

> ba

, , 1, 1

[,1] [,2]

[1,] 10 10

[2,] 10 10

, , 2, 1

[,1] [,2]

[1,] 20 20

[2,] 20 20

, , 1, 2

[,1] [,2]

[1,] 30 30

[2,] 30 30

, , 2, 2

[,1] [,2]

[1,] 40 40

[2,] 40 40

Interrogate array dimension

> dim(ba)

[1] 2 2 2 2

An alternative execution is also possible and broadens the use of the outer product infix operator to assume infinite applications. The full argument structure of outer() is displayed below. The third element is the multiplication operator, which is the default function used:

> outer(b, a, "*")

1	> outer(b, a, "*")

The multiplication function can be replaced by any arbitrary function of two variables (or its name as a character string). For example, if we want to evaluate the function:

f(a, b) = sin(a)b²

over a regular grid of values with x- and y-coordinates defined by the vectors a and b, then we could use:

#Define function
> my.fun <- function(b, a) {sin(a) * b^2}

# Redefine outer product function
> outer(b, a, my.fun)

, , 1, 1
    [,1] [,2]
[1,]  84   84
[2,]  84   84

, , 2, 1
    [,1] [,2]
[1,]  91   91
[2,]  91   91

, , 1, 2
    [,1] [,2]
[1,]  14   14
[2,]  14   14

, , 2, 2
    [,1] [,2]
[1,] -76  -76
[2,] -76  -76

#Define function

> my.fun <- function(b, a) {sin(a) * b^2}

# Redefine outer product function

> outer(b, a, my.fun)

, , 1, 1

[,1] [,2]

[1,] 84 84

[2,] 84 84

, , 2, 1

[,1] [,2]

[1,] 91 91

[2,] 91 91

, , 1, 2

[,1] [,2]

[1,] 14 14

[2,] 14 14

, , 2, 2

[,1] [,2]

[1,] -76 -76

[2,] -76 -76

Back | Next

Creating Arrays in R

Array Subscripting

Arrays as Contingency Tables

Outer Product and Infix Flexibility

Login

Today in Energy

Tags

Archives