Matrix Operations in R:
1. **Create a Matrix:**
```
matrix(data, nrow, ncol, byrow = FALSE)
```
2. **Access Elements:**
```
mat[row_index, col_index]
```
3. **Change Elements:**
```
mat[row_index, col_index] <- new_value
```
4. **Combine Matrices by Rows (rbind):**
```
rbind(matrix1, matrix2, ...)
```
5. **Combine Matrices by Columns (cbind):**
```
cbind(matrix1, matrix2, ...)
```
6. **Matrix Dimensions:**
```
dim(matrix)
```
7. **Transpose a Matrix:**
```
t(matrix)
```
8. **Matrix Multiplication:**
```
mat1 %*% mat2
```
9. **Element-wise Operations:**
- Element-wise Addition: `mat1 + mat2`
- Element-wise Subtraction: `mat1 - mat2`
- Element-wise Multiplication: `mat1 * mat2`
- Element-wise Division: `mat1 / mat2`
- Element-wise Exponentiation: `mat ^ 2`
10. **Matrix Element Sum, Mean, etc.:**
```
sum(matrix)
mean(matrix)
min(matrix)
max(matrix)
```
11. **Matrix Row or Column Sum, Mean, etc.:**
```
rowSums(matrix)
colSums(matrix)
rowMeans(matrix)
colMeans(matrix)
```
12. **Matrix Subsetting and Indexing:**
13. **Row or Column Extraction:**
```
matrix[, col_index]
matrix[row_index, ]
```
14. **Extract Diagonal Elements:**
```
diag(matrix)
```
15. **Determinant and Inverse:**
```
det(matrix)
solve(matrix)
```
16. **Eigenvalues and Eigenvectors:**
```
eigen(matrix)
```
17. **Row or Column Bind by Name (cbind):**
```
cbind(matrix1, matrix2, ...)
```
18. **Row or Column Bind by Index (cbind):**
```
cbind(matrix1, matrix2, ...)
```
19. **Element-wise Logical Operations:**
```
mat1 > mat2
```
20. **Check for Missing Values:**
```
is.na(matrix)
```
21. **Matrix Reshaping:**
- Convert Matrix to Vector: `as.vector(matrix)`
- Convert Vector to Matrix: `matrix(vector, nrow, ncol)`
22. **Row or Column Names:**
```
rownames(matrix)
colnames(matrix)
```
Vectors
Certainly! Here's the list of various operations you can perform on vectors in R, formatted for easy
copying into Word:
---
**Vector Operations in R:**
1. **Create a Vector:**
```
c(element1, element2, ...)
```
2. **Access Elements:**
```
vector[index]
```
3. **Change Elements:**
```
vector[index] <- new_value
```
4. **Vector Length:**
```
length(vector)
```
5. **Combine Vectors:**
```
c(vector1, vector2, ...)
```
6. **Element-wise Operations:**
- Element-wise Addition: `vector1 + vector2`
- Element-wise Subtraction: `vector1 - vector2`
- Element-wise Multiplication: `vector1 * vector2`
- Element-wise Division: `vector1 / vector2`
- Element-wise Exponentiation: `vector ^ 2`
7. **Vector Sum, Mean, etc.:**
```
sum(vector)
mean(vector)
min(vector)
max(vector)
```
8. **Logical Operations:**
```
vector1 > vector2
```
9. **Check for Missing Values:**
```
is.na(vector)
```
10. **Sort a Vector:**
```
sort(vector)
```
11. **Find Unique Elements:**
```
unique(vector)
```
12. **Vector Subsetting and Indexing:**
13. **Extract Elements by Condition:**
```
vector[condition]
```
14. **Vector Element Recycling:**
```
rep(vector, times)
```
15. **Vector Element Repetition:**
```
rep(vector, each)
```
16. **Find Indices with Condition:**
```
which(condition)
```
17. **Vector Reshaping:**
- Convert Vector to Matrix: `matrix(vector, nrow, ncol)`
- Convert Matrix to Vector: `as.vector(matrix)`
18. **Append Elements to Vector:**
```
append(vector, new_elements)
```
19. **Vector Element Removal:**
```
vector[-index]
```
20. **Vector Names:**
```
names(vector)
```
---
Factors
Certainly! Here's the list of various operations you can perform on factors in R, formatted for easy
copying into Word:
---
**Factor Operations in R:**
1. **Create a Factor:**
```
factor(vector, levels = NULL, labels = levels)
```
2. **Access Levels of a Factor:**
```
levels(factor)
```
3. **Change Levels and Labels:**
```
levels(factor) <- new_levels
```
4. **Factor Length:**
```
length(factor)
```
5. **Factor Count:**
```
table(factor)
```
6. **Factor Summary:**
```
summary(factor)
```
7. **Factor Subset and Indexing:**
8. **Convert Factor to Numeric:**
```
as.numeric(factor)
```
9. **Convert Factor to Character:**
```
as.character(factor)
```
10. **Factor with Ordered Levels:**
```
factor(vector, levels = ordered_levels, ordered = TRUE)
```
11. **Find Unique Levels:**
```
unique(factor)
```
12. **Check for Missing Values:**
```
is.na(factor)
```
13. **Factor Sorting:**
```
sort(factor)
```
14. **Factor Merging:**
```
merge(factor1, factor2)
```
15. **Factor Reordering:**
```
relevel(factor, new_order)
```
16. **Factor to Numeric Encoding:**
```
as.integer(factor)
```
17. **Factor Frequency:**
```
table(factor)
```
18. **Subset Factor by Level:**
```
subset_factor <- factor[factor == "level"]
```
19. **Factor Renaming:**
```
levels(factor) <- new_labels
```
20. **Factor Renaming with Labels:**
```
factor <- factor(factor, labels = new_labels)
```
21. **Factor Conversion to Logical:**
```
as.logical(factor)
```
---
Arrays
---
**Array Operations in R:**
1. **Create an Array:**
```
array(data, dim = c(dim1, dim2, ...))
```
2. **Access Elements:**
```
array[index1, index2, ...]
```
3. **Change Elements:**
```
array[index1, index2, ...] <- new_value
```
4. **Array Dimensions:**
```
dim(array)
```
5. **Access Dimension Names:**
```
dimnames(array)
```
6. **Array Reshaping:**
```
dim(array) <- c(new_dim1, new_dim2, ...)
```
7. **Transpose an Array:**
```
aperm(array, perm = c(dim_order))
```
8. **Array Element-wise Operations:**
- Element-wise Addition: `array1 + array2`
- Element-wise Subtraction: `array1 - array2`
- Element-wise Multiplication: `array1 * array2`
- Element-wise Division: `array1 / array2`
9. **Array Sum, Mean, etc.:**
```
sum(array)
mean(array)
min(array)
max(array)
```
10. **Logical Operations on Arrays:**
```
array1 > array2
```
11. **Check for Missing Values:**
```
is.na(array)
```
12. **Array Subset and Indexing:**
13. **Array Reshaping to Matrix:**
```
matrix(array, nrow, ncol)
```
14. **Array Merging:**
```
abind(array1, array2, along = dimension)
```
15. **Array Apply Functions:**
```
apply(array, margin, FUN)
```
16. **Array Slice Extraction:**
```
array[start:end, start:end, ...]
```
17. **Array Dimension Collapse:**
```
drop(array)
```
18. **Array Replication:**
```
replicate(times, array)
```
19. **Array Binding by Dimension:**
```
abind(array1, array2, along = dimension)
```
20. **Array Names:**
```
dimnames(array) <- list(row_names, col_names, ...)
```
Dataframes
---
**Data Frame Operations in R:**
1. **Create a Data Frame:**
```
data.frame(column1, column2, ...)
```
2. **Access Columns:**
```
data_frame$column_name
```
3. **Access Rows:**
```
data_frame[row_index, ]
```
4. **Change Column Values:**
```
data_frame$column_name <- new_values
```
5. **Data Frame Dimensions:**
```
dim(data_frame)
```
6. **Data Frame Summary:**
```
summary(data_frame)
```
7. **Add New Column:**
```
data_frame$new_column <- values
```
8. **Remove Column:**
```
data_frame$column_name <- NULL
```
9. **Subset Data Frame:**
```
subset(data_frame, condition)
```
10. **Data Frame Filtering:**
```
data_frame[data_frame$column > threshold, ]
```
11. **Data Frame Sorting:**
```
sorted_data_frame <- data_frame[order(data_frame$column), ]
```
12. **Data Frame Merging:**
```
merged_data_frame <- merge(data_frame1, data_frame2, by = "common_column")
```
13. **Data Frame Grouping:**
```
grouped_data <- group_by(data_frame, group_column)
```
14. **Data Frame Aggregation:**
```
summarise(grouped_data, agg_column = aggregation_function(column))
```
15. **Data Frame Joining:**
```
joined_data <- inner_join(data_frame1, data_frame2, by = "common_column")
```
16. **Data Frame Pivot:**
```
pivoted_data <- pivot_wider(data_frame, names_from = column, values_from = value_column)
```
17. **Data Frame Melting:**
```
melted_data <- melt(data_frame, id.vars = c("id_columns"))
```
18. **Check for Missing Values:**
```
is.na(data_frame)
```
19. **Data Frame Reshaping:**
```
reshape(data_frame, direction = "long" or "wide", ...)
```
20. **Data Frame Rename Columns:**
```
names(data_frame) <- c("new_column_names")
```
21. **Data Frame Column Sum, Mean, etc.:**
```
colSums(data_frame)
colMeans(data_frame)
```
22. **Subset Data Frame by Column Values:**
```
subset(data_frame, column_name %in% c("value1", "value2"))
```
Lists
---
**List Operations in R:**
1. **Create a List:**
```
list(item1, item2, ...)
```
2. **Access Elements:**
```
my_list[[index]]
```
3. **Access Named Elements:**
```
my_list$element_name
```
4. **Change List Elements:**
```
my_list[[index]] <- new_value
```
5. **List Length:**
```
length(my_list)
```
6. **Add New Element:**
```
my_list$new_element <- value
```
7. **Remove Element:**
```
my_list[[element_name]] <- NULL
```
8. **List Subsetting:**
```
sub_list <- my_list[c(index1, index2, ...)]
```
9. **Named List Elements:**
```
names(my_list) <- c("name1", "name2", ...)
```
10. **Nested Lists:**
```
nested_list <- list(list1 = sub_list1, list2 = sub_list2)
```
11. **List Unlisting:**
```
unlist(my_list)
```
12. **List to Data Frame Conversion:**
```
data_frame <- as.data.frame(my_list)
```
13. **List Merge:**
```
merged_list <- c(my_list1, my_list2)
```
14. **List Element Check:**
```
exists("element_name", where = my_list)
```
15. **List to Matrix Conversion:**
```
matrix <- do.call(rbind, my_list)
```
16. **List Reverse:**
```
reversed_list <- rev(my_list)
```
17. **List Sorting:**
```
sorted_list <- sort(my_list)
```
18. **List Apply Functions:**
```
lapply(my_list, function)
```
19. **List Slicing:**
```
sliced_list <- my_list[start:end]
```
20. **Check if List is Empty:**
```
length(my_list) == 0
```
---
