Data Structure

Introduction: Matrices in R

by

While dealing with matrices in R, all columns in the matrix must have the same mode (numeric, character, etc.), and the same length. A matrix is a two-dimensional rectangular data set. It can be created using a vector input to the function matrix() in R.

The general syntax of creating matrices in R is:

matrix_name <- matrix(vector, nrow = r, ncol = c,
                         byrow = FALSE, dimnames = list(char_vector_rownames,
                                                        char_vector_colnames)
)

byrow = TRUE indicates that the matrix will be filled by rows.

dimnames provides optional labels for the columns and rows.

Creating Matrices in R

Following the general syntax of the function matrix() in R, let us create a matrix from a vector of the first 20 numbers.

Example 1: 

# Generate matrix having 5 rows and 4 columns 
y1 <- matrix (1 : 20, nrow = 5, ncol = 4) ; y1

# Output
[,1] [,2] [,3] [,4]
[1,] 1 6 11 16
[2,] 2 7 12 17
[3,] 3 8 13 18
[4,] 4 9 14 19
[5,] 5 10 15 20
y2 <- matrix (1 : 20, nrow = 5, ncol = 4, byrow = FALSE); y2

# Output
[,1] [,2] [,3] [,4]
[1,] 1 6 11 16
[2,] 2 7 12 17
[3,] 3 8 13 18
[4,] 4 9 14 19
[5,] 5 10 15 20
y3 <- matrix (1 : 20, nrow = 5, ncol = 4, byrow = TRUE) ; y3

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

Example 2:

elements <- c(11, 23, 29, 67)
rownames <- c("R1", "R2")
colnames <- c("C1", "C2")

m1 <- matrix(elements, nrow = 2, ncol = 2, byrow = TRUE, 
      dimnames = list(rownames, colnames)
      )

# Output
   C1 C2
R1 11 23
R2 29 67

Try the above example 2 with the following values set to arguments as below

nrow = 4 and ncol = 1, byrow = FALSE

Note the difference. You may also have some errors related to the number of rows or columns. Therefore, if you change the number of rows or columns then ensure that you have the same number of row names and column names too.

Matrix Operations in R Language

In the R language, there are some operators and functions that can be used to perform computation on one or more matrices. Some basic matrix operations in R are:

Matrix OperationOperator/ Function
Add/ Subtract+, −
Multiply%*%
Transposet( )
Inversesolve ( )
Extract Diagonaldiag( ) It is described at the end too
Determinantdet( )

The following are some examples related to these operators and matrix functions.

m1 <- matrix(c(11, 23, 9, 35), nrow = 2)
m2 <- matrix(c(5, 19, 11, 20), nrow =2)
m3 <- m1 + m2
m4 <- m1 - m2
m5 <- m1 %*% m2
m6 <- m1 / m2
m1t <- t(m1)
m1tminv <- solve(m1t %*% m1)
diag(m1tminv)

# Output
> m1
     [,1] [,2]
[1,]   11    9
[2,]   23   35

> m2
     [,1] [,2]
[1,]    5   11
[2,]   19   20

> m3
     [,1] [,2]
[1,]   16   20
[2,]   42   55

> m4
     [,1] [,2]
[1,]    6   -2
[2,]    4   15

> m5
     [,1] [,2]
[1,]  226  301
[2,]  780  953

> m6
         [,1]      [,2]
[1,] 2.200000 0.8181818
[2,] 1.210526 1.7500000

> m1t
     [,1] [,2]
[1,]   11   23
[2,]    9   35
Introduction: Matrices in R

Some other important functions can be used to perform some required computations on matrices in R. These matrix operations in R are described below for matrix $X$. You can use your matrix.

Consider we have a matrix X with elements.

X <- matrix(1:20, nrow = 4, ncol = 5) 
X
FunctionDescription
rowSums(X)Compute the average value of each column of the Matrix $X$
colSums(X)Compute the average value of each row of the Matrix $X$
rowMeans(X)Compute the average value of each column of the Matrix $X$
colMeans(X)Compute the average value of each column of the Matrix $X$
diag(X)Extract diagonal elements of the Matrix $X$, or
Create a Matrix that has required diagonal elements such as diag(1:5), diag(5),
crossprod(X,X)Compute X‘X. It is a shortcut of t(X)%*%X

Obtaining Regression Coefficients using Matrices in R

Consider we have a dataset that has a response variable and few regressors. There are many ways to create data (or variables), such as one can create a vector for each variable, a data frame for all of the variables, matrices, or can read data stored in a file.

Here we try it using vectors, then bind the vectors where required. We will use matrices to obtain the regression coefficients.

y  <- c(5, 6, 7, 9, 8, 4, 3, 2, 1, 6, 0, 7)
x1 <- c(4, 5, 6, 7, 8, 3, 4, 9, 9, 8, 7, 5)
x2 <- c(10, 22, 23, 10, 11, 14, 15, 16, 17, 12, 11, 17)
x  <- cbind(1, x1, x2)

The cbind( ) function is used to create a matrix x. Note that 1 is also bound to get the intercept term (the model with the intercept term). Let us compute $\beta$’s from OLS using matrix functions and operators.

xt <- t(x)
xtx <- xt %*% x
xtxinv <- solve(xtx)
xty <- xt %*% y
b <- xtxinv %*% xty

The output is

#Output
x
        x1 x2
 [1,] 1  4 10
 [2,] 1  5 22
 [3,] 1  6 23
 [4,] 1  7 10
 [5,] 1  8 11
 [6,] 1  3 14
 [7,] 1  4 15
 [8,] 1  9 16
 [9,] 1  9 17
[10,] 1  8 12
[11,] 1  7 11
[12,] 1  5 17

xt
   [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10] [,11] [,12]
      1    1    1    1    1    1    1    1    1     1     1     1
x1    4    5    6    7    8    3    4    9    9     8     7     5
x2   10   22   23   10   11   14   15   16   17    12    11    17

xtx
         x1   x2
    12   75  178
x1  75  515 1103
x2 178 1103 2854

xtxinv
xty
b
Computing regression coefficient, matrices in R

Data Structure Matrix in R

visit https://gmstat.com

Creating Vectors in R, Subsetting, and Vectorization

by

The article is about creating vectors in R language. You will also learn about quick and short methods of subsetting the vectors in R and the vectorization of vectors

Creating Vectors in R Using c() Function

The c() function can be used for creating vectors of objects in R. This function concatenates the values having one dimension (either row or column matrix in a sense). The following are some examples related to creating different types of vectors in R.

# Numeric vector
x <- c(1, 2, 5, 0.5, 10, 20, pi)
# Logical vector
x <- c(TRUE, FALSE, FALSE, T, T, F)
# Character vector
x <- c("a", "z", "good", "bad", "null hypothesis")
# Integer vector 
x <- 9 : 29   # (colon operator is used)
x <- c(1L, 5L, 0L, 15L)
# Complex vector
x <- c(1+0i, 2+4i, 0+0i)

Using vector() Function

Creates a vector of $n$ elements with a default value of zero for numeric vector, an empty string for character vector, FALSE for logical vector, and 0+0i for complex vector.

# Numeric vector of lenght 10 (default is zero)
x <- vector("numeric", length = 10)
# Integer vector of length 10 (default is integer zeros)
x <- vector("integer", length = 10)
# Character vector of length 10 (default is empty string)
x <- vector("character", length = 10)
# Logical vector of length 10 (default is FALSE)
x <- vector("logical", length = 10)
# Complex vector of length 10 (default is 0+0i)
x <- vector("complex", length=10)
Vectors in R

Creating Vectors with Mixed Objects

When different objects are mixed in a vector, coercion occurs, that is, the data type of the vector changes intelligently.

The following are examples

# coerce to character vector 
y <- c(1.2, "good")
y <- c("a", T)
# coerce to a numeric vector
y <- c(T, 2)

From the above examples, the coercion will make each element of the vector of the same class.

Explicitly Coercing Objects to Other Class

Objects can be explicitly coerced from one class to another class using as.character(), as.numeric(), as.integer(), as.complex(), and as.logical() functions. For example;

x <- 0:6
as.numeric(x)
as.logical(x)
as.character(x)
as.complex(x)

Note that non-sensual coercion results in NAs (missing values). For example,

x <- c("a", "b", "c")
as.numeric(x)
as.logical(x)
as.complex(x)
as.integer(x)

Vectorization in R

Many operations in the R Language are vectorized. The operations ( +, -, *, and / ) are performed element by element. For example,

r vectors
x <- 1 : 4
y <- 6 : 9

# Arithmetics
x + y
x - y
x * y
x / y
# Logical Operation
x >= 2
x < 3
y == 8

Without vectorization (as in other languages) one has to use a for loop for performing element-by-element operations on say vectors.

Subsetting Vectors in R Language

Subsetting in the R Language can be done easily. Subsetting vectors means extracting the elements of a vector. For this purpose square brackets ([ ]) are used. For example;

x <- c(1, 6, 10, -15, 0, 13, 5, 2, 10, 9)

# Subsetting  Examples
x[1]   # extract first element of x vecotr
x[1:5] # extract first five values of x
x[-1]  # extract all values except first
x[x > 2] # extracts all elements that are greater than 2

head(x)  # extracts first 6 elements of x
tail(x)  # extracts last 6 elements of x

x[x > 5 & x < 10]  # extracts elements that are greater than 5 but less than 10

One can use the subset() function to extract the desired element using logical operators, For example,

subset(x, x > 5)
subset(x, x > 5 & x < 10)
subset(x, !x < 0 )

Learn more about Vectors

https://itfeature.com

https://gmstat.com

Lists in R Language: Create, Name, and Append

by

Before understanding and working on lists in R Language, let’s review the other data types in R Language.

Each of the data types (vectors, matrices, and data frames) has some level of constraints. For example, vectors are single-column data types and can only store one type of data. Matrices are of two-dimensional, but they can store only one type of data. On the other hand, data frames are two-dimensional and can store different types of data, but in data frames, the length of columns should be the same.

Lists in R Language

Lists in R are a fundamental data structure used to store collections of elements. Lists offer a flexible way to organize data of different types, unlike vectors that can hold elements of the same data type. Lists in R language have no such constraints as vectors, matrices, and data frames. The element of a list can contain any type of data can contain any type of data having varying lengths for each element.

Lists are the most flexible data type in R, as the list can hold all kinds of different operations when programming. Let us consider some examples of how to create lists in R, and how elements of the list can be named, retrieved, and appended. The list data type is created using the list() keyword. For examples,

mylist <- list('alpha', 'beta', 'gamma', 1:5, TRUE)

Note that lists are printed differently and they have their form of indexing for retrieving each element of the list.

Retrieving List Elements

A certain element of a list can be accessed using the subsetting technique (based on the list indexing mechanism. For example, to access the first three elements of the list created above, one can write in R console as,

A certain element of a list can be accessed using a subsetting technique (based on the list indexing mechanism. For example, to access the first three elements of the list created above, one can write in R console as,

mylist[1:3]

To examine one element of the list, double square brackets can be used with the required index number. For example, to access the fourth element of the list, one can use,

mylist[[4]]

Note when one uses normal subsetting, a list will be obtained as a result. When double square brackets are used the contents of the elements are obtained. Note the difference and command and output of each command used below:

mylist[4]
mylist[[4]]

Naming Elements of a List

The elements of a list can be named, and elements of lists can be retrieved using the $ operator instead of square brackets. The first command will name the elements of the mylist object. and then other commands will result in the same output.

names(mylist) <- c("a", "b", "c", "d", "e")

mylist$d
myslit[[4]]
Lists in R Language: Create, Name, and Append

Appending an Element to List

Like data frames, an element of a list can be created by assigning something to an index that does not exist yet. For example, a sixth element is added to the list

mylist$f <- c("Pass", "Fail")

Now the 6th element of the list contains a vector of strings “Pass”, and “Fail”. To check this, 

mylist$f
mylist[[6]]

To access the elements of specific list vector subsetting and two square brackets can be used. For example to access the fourth element of the list one can use,

mylist[[4]][3] # 3rd element of 4th list element
mylist[[4]][1:3]# first three elements of 4th list element
mylist$d[3]
  • Remember to name elements for readability when dealing with complex data structures.
  • Lists are versatile for storing various data types, making them a powerful tool for data organization in R.

For further reading about lists see the link Lists in R.

MCQs General Knowledge