First, use the following commands to convert all the characters in the data to lowercase:

top_2_reviews <- review_corpus[1:2]
top_2_reviews <- tm_map(top_2_reviews,content_transformer(tolower))
lapply(top_2_reviews[1], as.character)

The output is as follows:

## [1] "I have bought several of the vitality canned dog food products and have found them all to be of good quality. the product looks more like a stew than a processed meat and it smells better. my labrador is finicky, and she appreciates this product better than  most."

Next, remove the stopwords from the data, such as, a, the, an, and many more:

top_2_reviews <- tm_map(top_2_reviews,removeWords, stopwords("english"))
lapply(top_2_reviews[1], as.character)

The output is as follows:

## [1] "  bought several   vitality canned dog food products   found      good quality.  product looks  like  stew   processed meat   smells better.  labrador  finicky   appreciates  product better   ."

Remove extra whitespaces between words using the following command:

top_2_reviews <- tm_map(top_2_reviews,stripWhitespace)
lapply(top_2_reviews[1], as.character)

The output is as follows:

## [1] " bought several vitality canned dog food products found good quality. product looks like stew processed meat smells better. labrador finicky appreciates product better ."

Perform the stemming process, which will only keep the root of the word. For example, looking and looked will become look:

top_2_reviews <- tm_map(top_2_reviews,stemDocument)
lapply(top_2_reviews[1], as.character)

The output is as follows:

## [1] " bought sever vital can dog food product found good quality. product look like stew process meat smell better. labrador finicki appreci product better ."

Now that we have the text processed and cleaned up, we can create a document matrix that stores merely the frequency of the occurrence of distinct words in the two reviews. We will demonstrate how to count each word contained in the review. Each row of the matrix represents one review, and the columns are distinct words. Most of the values are zero because not all the words will be present in each review. In this example, we have a sparsity of 49%, which means only 51% of the matrix contains non-zero values.

Create Document Term Matrix (DTM), in which each row will represent one tweet (also referred to as Doc) and each column a unique word from the corpus:

dtm <- DocumentTermMatrix(top_2_reviews)
inspect(dtm)

The output is as follows:

## <<DocumentTermMatrix (documents: 2, terms: 37)>>
## Non-/sparse entries: 38/36
## Sparsity           : 49%
## Maximal term length: 10
## Weighting          : term frequency (tf)
## 
##     Terms
## Docs "jumbo". actual appreci arriv better better. bought can dog error
##    1        0      0       1     0      1       1      1   1   1     0
##    2        1      1       0     1      0       0      0   0   0     1
##     Terms
## Docs finicki food found good intend jumbo label labrador like look meat
##    1       1    1     1    1      0     0     0        1    1    1    1
##    2       0    0     0    0      1     1     1        0    0    0    0
0

We can use this document term matrix in a plenty of ways. For the sake of the brevity of this introduction to the matrix, we will skip the details of the Document Term Matric here.

The DTM shown in the previous code is in the list format. In order to convert it to the matrix, we can use the as.matrix() method again. The matrix contains two documents (reviews) and 37 unique words. The count of a particular word in a document is retrieved by specifying the row and column index or name in the matrix.

Now, store the results in a matrix using the following command:

dtm_matrix <- as.matrix(dtm)

To find the dimension of the matrix, that is, 2 documents and 37 words, use the following command:

dim(dtm_matrix)

The output is as follows:

## [1]  2 37

Now, print a subset of the matrix:

dtm_matrix[1:2,1:7]

The output is as follows:

##     Terms
## Docs "jumbo". actual appreci arriv better better. bought
##    1        0      0       1     0      1       1      1
##    2        1      1       0     1      0       0      0

Finally, count the word product in document 1 using the following command:

dtm_matrix[1,"product"]

The output is as follows:

## [1] 3

First, generate 16 random numbers drawn from a binomial distribution with parameter size equals 100 and the probability of success equals 0.4:

r_numbers <- rbinom(n = 16, size = 100, prob = 0.4)

Now, select 16 alphabets from English LETTERS without repetition:

#sample() will generate 16 random letters from the English alphabet without repetition
r_characters <- sample(LETTERS, size = 16, replace = FALSE)

Put r_numbers and r_characters into a single list. The list() function will create the data structure list with r_numbers and r_characters:

list(r_numbers, r_characters)

The output is as follows:

## [[1]]
##  [1] 48 53 38 31 44 43 36 47 43 38 43 41 45 40 44 50
## 
## [[2]]
##  [1] "V" "C" "N" "Z" "E" "L" "A" "Y" "U" "F" "H" "D" "O" "K" "T" "X"

In the following step, we will see a list with the integer and character vectors stored together.

Now, let's store and retrieve integer and character vectors from a list:

r_list <- list(r_numbers, r_characters)

Next, retrieve values in the character vector using the following command:

r_list[[2]]

The output is as follows:

##  [1] "V" "C" "N" "Z" "E" "L" "A" "Y" "U" "F" "H" "D" "O" "K" "T" "X"

Finally, retrieve the first value in the character vector:

(r_list[[2]])[1]

The output is as follows:

## [1] "V" 

Though this solves the requirement of storing heterogeneous data types together, its still doesn't put any integrity checks on the relationship between the values in the two vectors. If we would like to assign every letter to one integer. In the previous output, V represents 48, C represents 53, and so on.

A list is not robust to handle such one-to-one mapping. Consider the following code, instead of 16 characters, if we generate 18 random characters, and it still allows for storing it in a list. The last two characters have no associated mapping with the integer now.

Now, generate 16 random numbers drawn from a binomial distribution with parameter size equal to 100 and probability of success equal to 0.4:

r_numbers <- rbinom(n = 16, size = 100, prob = 0.4)

Select any 18 alphabets from English LETTERS without repetition:

r_characters <- sample(LETTERS, 18, FALSE)

Place r_numbers and r_characters into a single list:

list(r_numbers, r_characters)

The output is as follows:

## [[1]]
##  [1] 48 53 38 31 44 43 36 47 43 38 43 41 45 40 44 50
## 
## [[2]]
##  [1] "V" "C" "N" "Z" "E" "L" "A" "Y" "U" "F" "H" "D" "O" "K" "T" "X" "P"  "Q"

Create two matrices of size 10 x 4 and 4 x 5 by randomly generated numbers from a binomial distribution (use rbinom method). Call the matrix mat_A and mat_B, respectively.

Now, store the two matrices in a list.

Using the list, access the row 4 and column 2 of mat_A and store it in variable A, and access row 2 and column 1 of mat_B and store it in variable B.

Multiply the A and B matrices and subtract from row 2 and column 1 of mat_A.