Confidential - Oracle Restricted
Vectors
Vectors are a fundamental data structure in R used to store sequences of elements that are
all of the same type. They are essential for data manipulation and statistical analysis.
Types of Vectors in R
1. Numeric Vector: Contains numbers (integers or floating-point).
2. Character Vector: Contains strings or text data.
3. Logical Vector: Contains TRUE or FALSE values.
4. Integer Vector: A special type of numeric vector where all elements are integers.
5. Complex Vector: Contains complex numbers with real and imaginary parts.
Creating and Using Vectors
Vectors can be created using the c() function, which combines or concatenates elements
into a vector.
Examples of Each Type:
1. Numeric Vector
num_vec <- c(1.5, 2.3, 4.7)
print(num_vec) # Outputs: [1] 1.5 2.3 4.7
c means concatenate
2. Character Vector
char_vec <- c("apple", "banana", "cherry")
print(char_vec) # Outputs: [1] "apple" "banana" "cherry"
3. Logical Vector
log_vec <- c(TRUE, FALSE, TRUE)
print(log_vec) # Outputs: [1] TRUE FALSE TRUE
Confidential - Oracle Restricted
Confidential - Oracle Restricted
4. Integer Vector
o You can create integer vectors by appending L to numbers or using
as.integer().
int_vec <- c(1L, 2L, 3L)
print(int_vec) # Outputs: [1] 1 2 3
class(int_vec) # Outputs: "integer"
5. Complex Vector
complex_vec <- c(1+2i, 3-4i, 5+0i)
print(complex_vec) # Outputs: [1] 1+2i 3-4i 5+0i
Simple Program Demonstrating Different Vector Types
# Create vectors of different types
num_vec <- c(10.5, 20.3, 30.8) # Numeric vector
char_vec <- c("R", "is", "fun") # Character vector
log_vec <- c(TRUE, FALSE, TRUE) # Logical vector
int_vec <- c(5L, 10L, 15L) # Integer vector
complex_vec <- c(2+3i, 4-2i) # Complex vector
# Print each vector
print("Numeric Vector:")
print(num_vec) # Outputs: [1] 10.5 20.3 30.8
print("Character Vector:")
print(char_vec) # Outputs: [1] "R" "is" "fun"
Confidential - Oracle Restricted
Confidential - Oracle Restricted
print("Logical Vector:")
print(log_vec) # Outputs: [1] TRUE FALSE TRUE
print("Integer Vector:")
print(int_vec) # Outputs: [1] 5 10 15
print("Complex Vector:")
print(complex_vec) # Outputs: [1] 2+3i 4-2i
Vector Operations
You can perform operations on vectors, and they apply element-wise:
vec1 <- c(1, 2, 3)
vec2 <- c(4, 5, 6)
sum_vec <- vec1 + vec2 # Outputs: [1] 5 7 9
Summary
• Vectors are the simplest data structures in R and can only hold elements of the
same type.
• Types include numeric, character, logical, integer, and complex.
• Creation is done using the c() function, and operations on vectors apply to each
element.
Vector operations in R are powerful because they are performed element-wise,
meaning that operations are automatically applied to each element of the vectors.
Below are the main types of vector operations, along with examples to illustrate
their use:
1. Arithmetic Operations
These operations can be performed directly on numeric vectors:
• Addition (+)
Confidential - Oracle Restricted
Confidential - Oracle Restricted
• Subtraction (-)
• Multiplication (*)
• Division (/)
• Exponentiation (^)
Example:
Copy code
vec1 <- c(2, 4, 6)
vec2 <- c(1, 3, 5)
# Element-wise addition
result_add <- vec1 + vec2 # Outputs: [1] 3 7 11
# Element-wise subtraction
result_sub <- vec1 - vec2 # Outputs: [1] 1 1 1
# Element-wise multiplication
result_mul <- vec1 * vec2 # Outputs: [1] 2 12 30
# Element-wise division
result_div <- vec1 / vec2 # Outputs: [1] 2.000000 1.333333 1.200000
# Element-wise exponentiation
result_exp <- vec1 ^ vec2 # Outputs: [1] 2^1 4^3 6^5 -> [1] 2 64 7776
2. Relational Operations
These operations return logical vectors indicating the comparison results:
Confidential - Oracle Restricted
Confidential - Oracle Restricted
• Greater than (>)
• Less than (<)
• Equal to (==)
• Not equal to (!=)
• Greater than or equal to (>=)
• Less than or equal to (<=)
Example:
Copy code
vec1 <- c(5, 10, 15)
vec2 <- c(3, 10, 20)
# Greater than comparison
result_gt <- vec1 > vec2 # Outputs: [1] TRUE FALSE FALSE
# Equal to comparison
result_eq <- vec1 == vec2 # Outputs: [1] FALSE TRUE FALSE
3. Logical Operations
These operations work with logical vectors and return logical results:
• AND (&)
• OR (|)
• NOT (!)
Example:
Copy code
vec1 <- c(TRUE, FALSE, TRUE)
Confidential - Oracle Restricted
Confidential - Oracle Restricted
vec2 <- c(FALSE, FALSE, TRUE)
# Logical AND
result_and <- vec1 & vec2 # Outputs: [1] FALSE FALSE TRUE
# Logical OR
result_or <- vec1 | vec2 # Outputs: [1] TRUE FALSE TRUE
# Logical NOT
result_not <- !vec1 # Outputs: [1] FALSE TRUE FALSE
4. Vector Recycling
If two vectors of different lengths are used in an operation, R recycles the shorter
vector to match the length of the longer one.
Example:
Copy code
vec1 <- c(1, 2, 3, 4)
vec2 <- c(5, 10)
# Recycling occurs; `vec2` becomes c(5, 10, 5, 10)
result_recycle <- vec1 + vec2 # Outputs: [1] 6 12 8 14
5. Element Access and Manipulation
You can access or modify vector elements using indexing.
• Single element access: vec[2]
• Range access: vec[1:3]
• Conditional access: vec[vec > 5]
Confidential - Oracle Restricted
Confidential - Oracle Restricted
Example:
Copy code
vec <- c(10, 20, 30, 40, 50)
# Access the third element
element <- vec[3] # Outputs: 30
# Access a range of elements
range_elements <- vec[2:4] # Outputs: [1] 20 30 40
# Conditional access
greater_than_25 <- vec[vec > 25] # Outputs: [1] 30 40 50
6. Common Vector Functions
• sum(): Sum of all elements.
• mean(): Average of elements.
• max() and min(): Maximum and minimum elements.
• length(): Number of elements in the vector.
Example:
Copy code
vec <- c(5, 10, 15, 20)
# Sum of elements
total_sum <- sum(vec) # Outputs: 50
Confidential - Oracle Restricted
Confidential - Oracle Restricted
# Mean of elements
average <- mean(vec) # Outputs: 12.5
# Maximum element
max_value <- max(vec) # Outputs: 20
# Length of the vector
vec_length <- length(vec) # Outputs: 4
Summary
• Vector operations in R are applied element-wise and support arithmetic, relational,
and logical operations.
• Recycling allows for operations on vectors of different lengths but may need
attention to avoid unexpected results.
• Element access and functions like sum(), mean(), max(), and min() are useful for
vector manipulation and analysis.
4o
Sequences, Repetition, Sorting, and Lengths
Confidential - Oracle Restricted
Confidential - Oracle Restricted
Sequences, repetition, sorting, and lengths are common operations and
functions in R that are useful for data manipulation and analysis. Here’s an
explanation of each concept with examples:
1. Sequences
Sequences are ordered sets of numbers. You can create sequences in R using
functions like seq() or the colon operator :.
Examples:
• Using the Colon Operator:
seq1 <- 1:10 # Creates a sequence from 1 to 10
print(seq1) # Outputs: [1] 1 2 3 4 5 6 7 8 9 10
• Using seq() Function:
seq2 <- seq(from = 5, to = 20, by = 3) # Creates a sequence from 5 to 20 with a
step of 3
print(seq2) # Outputs: [1] 5 8 11 14 17 20
seq3 <- seq(from = 1, to = 10, length.out = 5) # Generates 5 equally spaced
numbers between 1 and 10
print(seq3) # Outputs: [1] 1.00 3.25 5.50 7.75 10.00
2. Repetition
Repetition is useful when you need to create vectors with repeated values.
The rep() function is used for this.
Examples:
• Repeating a Single Value:
rep1 <- rep(5, times = 4) # Repeats the number 5 four times
print(rep1) # Outputs: [1] 5 5 5 5
Confidential - Oracle Restricted
Confidential - Oracle Restricted
• Repeating a Vector:
rep2 <- rep(c(1, 2, 3), times = 2) # Repeats the vector (1, 2, 3) two times
print(rep2) # Outputs: [1] 1 2 3 1 2 3
• Repeating Each Element:
rep3 <- rep(c(1, 2, 3), each = 3) # Repeats each element of the vector three
times
print(rep3) # Outputs: [1] 1 1 1 2 2 2 3 3 3
3. Sorting
Sorting is used to arrange the elements of a vector in ascending or descending
order. The sort() function is commonly used for this purpose.
Examples:
• Ascending Order:
vec <- c(10, 3, 8, 1, 5)
sorted_vec <- sort(vec) # Sorts in ascending order by default
print(sorted_vec) # Outputs: [1] 1 3 5 8 10
• Descending Order:
sorted_vec_desc <- sort(vec, decreasing = TRUE) # Sorts in descending order
print(sorted_vec_desc) # Outputs: [1] 10 8 5 3 1
4. Lengths
The length() function is used to determine the number of elements in a vector
or list.
Examples:
Confidential - Oracle Restricted
Confidential - Oracle Restricted
• Finding the Length of a Vector:
vec <- c(4, 7, 1, 9, 3)
len <- length(vec) # Returns the number of elements in the vector
print(len) # Outputs: 5
• Finding Length of an Empty Vector:
empty_vec <- c()
print(length(empty_vec)) # Outputs: 0
Summary
• Sequences can be created with : or seq() for ordered sets.
• Repetition of elements or vectors can be done using rep().
• Sorting organizes data in ascending or descending order with sort().
• Lengths of vectors or lists are determined using length().
These operations are fundamental for data manipulation and help in preparing
and exploring datasets in R.
Subsetting and element extraction
Subsetting and element extraction are essential techniques in R for accessing
specific parts of vectors, matrices, lists, and data frames. They allow you to
retrieve, modify, or manipulate data efficiently. Here’s how these operations
are performed:
1. Subsetting Vectors
Subsetting a vector means accessing one or more elements from it. There are
different ways to subset vectors:
• Using Positive Indexing: Extracts elements at specific positions.
• Using Negative Indexing: Excludes elements at specific positions.
Confidential - Oracle Restricted
Confidential - Oracle Restricted
• Using Logical Vectors: Selects elements that meet certain conditions.
• Using Names: Extracts elements by their names if they are named.
Examples:
• Positive Indexing:
vec <- c(10, 20, 30, 40, 50)
subset_vec <- vec[2] # Extracts the second element
print(subset_vec) # Outputs: 20
• Negative Indexing:
subset_vec_neg <- vec[-3] # Excludes the third element
print(subset_vec_neg) # Outputs: [1] 10 20 40 50
• Logical Indexing:
subset_vec_logical <- vec[vec > 25] # Extracts elements greater than 25
print(subset_vec_logical) # Outputs: [1] 30 40 50
• Named Indexing:
names(vec) <- c("a", "b", "c", "d", "e")
subset_named <- vec["c"] # Extracts the element named "c"
print(subset_named) # Outputs: 30
Matrices
Confidential - Oracle Restricted
Confidential - Oracle Restricted
Matrices in R are two-dimensional data structures that store elements of the
same type (typically numeric or character data). They are arranged in rows and
columns and are useful for mathematical computations and data analysis.
Here's an overview of matrices, including how to create, access, and
manipulate them.
1. Creating Matrices
Matrices can be created using the matrix() function or by combining vectors.
Examples:
• Using the matrix() Function:
mat <- matrix(1:9, nrow = 3, ncol = 3)
print(mat)
# Outputs:
# [,1] [,2] [,3]
# [1,] 1 4 7
# [2,] 2 5 8
# [3,] 3 6 9
• Specifying byrow = TRUE: By default, matrices are filled column-wise.
You can fill them row-wise by setting byrow = TRUE.
mat_by_row <- matrix(1:9, nrow = 3, ncol = 3, byrow = TRUE)
print(mat_by_row)
# Outputs:
# [,1] [,2] [,3]
# [1,] 1 2 3
# [2,] 4 5 6
# [3,] 7 8 9
Confidential - Oracle Restricted
Confidential - Oracle Restricted
• Creating a Matrix by Combining Vectors:
vec1 <- c(1, 2, 3)
vec2 <- c(4, 5, 6)
combined_mat <- rbind(vec1, vec2) # Creates a matrix by binding rows
print(combined_mat)
# Outputs:
# [,1] [,2] [,3]
# vec1 1 2 3
# vec2 4 5 6
2. Accessing Matrix Elements
You can access specific elements, rows, or columns using indices.
Examples:
• Accessing a Specific Element:
mat <- matrix(1:9, nrow = 3)
elem <- mat[2, 3] # Extracts the element in the 2nd row, 3rd column
print(elem) # Outputs: 8
• Accessing Entire Rows or Columns:
row_extract <- mat[1, ] # Extracts the first row
print(row_extract) # Outputs: [1] 1 4 7
col_extract <- mat[, 2] # Extracts the second column
print(col_extract) # Outputs: [1] 4 5 6
3. Matrix Operations
Confidential - Oracle Restricted
Confidential - Oracle Restricted
Matrices support various mathematical operations, including addition,
subtraction, multiplication, and transposition.
Examples:
• Matrix Addition and Subtraction:
mat1 <- matrix(1:4, nrow = 2)
mat2 <- matrix(5:8, nrow = 2)
sum_mat <- mat1 + mat2
print(sum_mat)
# Outputs:
# [,1] [,2]
# [1,] 6 10
# [2,] 8 12
• Matrix Multiplication: Use %*% for matrix multiplication.
mat_mult <- mat1 %*% mat2
print(mat_mult)
# Outputs (result depends on matrix dimensions):
# [,1] [,2]
# [1,] 19 22
# [2,] 43 50
• Element-wise Multiplication: Use * for element-wise multiplication.
elementwise_mult <- mat1 * mat2
print(elementwise_mult)
# Outputs:
Confidential - Oracle Restricted
Confidential - Oracle Restricted
# [,1] [,2]
# [1,] 5 21
# [2,] 12 32
• Transposing a Matrix:
transposed_mat <- t(mat1)
print(transposed_mat)
# Outputs:
# [,1] [,2]
# [1,] 1 3
# [2,] 2 4
4. Functions for Matrices
• dim(): Returns the dimensions (rows and columns) of the matrix.
• nrow() and ncol(): Return the number of rows and columns,
respectively.
• diag(): Creates or extracts the diagonal of a matrix.
• solve(): Computes the inverse of a matrix (if invertible).
Examples:
• Dimensions and Diagonal:
print(dim(mat)) # Outputs: [1] 3 3 (3 rows, 3 columns)
print(diag(mat)) # Outputs: [1] 1 5 9
5. Combining Matrices
Confidential - Oracle Restricted
Confidential - Oracle Restricted
You can combine matrices by rows or columns using rbind() and cbind().
Example:
mat1 <- matrix(1:4, nrow = 2)
mat2 <- matrix(5:8, nrow = 2)
combined_row <- rbind(mat1, mat2)
print(combined_row)
# Outputs:
# [,1] [,2]
# [1,] 1 3
# [2,] 2 4
# [3,] 5 7
# [4,] 6 8
combined_col <- cbind(mat1, mat2)
print(combined_col)
# Outputs:
# [,1] [,2] [,3] [,4]
# [1,] 1 3 5 7
# [2,] 2 4 6 8
Summary
Confidential - Oracle Restricted
Confidential - Oracle Restricted
• Matrices are two-dimensional data structures with rows and columns.
• Creation can be done using matrix() or by combining vectors.
• Accessing elements uses [row, column] notation.
• Operations include addition, multiplication, and transposition.
• Functions like dim(), diag(), and solve() are useful for matrix analysis.
ARRAY
Arrays in R are multi-dimensional data structures that can hold data of the
same type (usually numeric or character). Unlike matrices, which are limited
to two dimensions, arrays can have more than two dimensions, making them
suitable for more complex data structures.
1. Creating Arrays
You can create arrays in R using the array() function, specifying the data and
dimensions.
Syntax:
array(c(rows,columns,layers).
array(data, dim = c(dim1, dim2, dim3, ...))
• data: The elements to populate the array.
• dim: A vector specifying the number of elements in each dimension.
Example:
arr <- array(1:12, dim = c(3, 4))
print(arr)
# Outputs a 3x4 matrix:
Confidential - Oracle Restricted
Confidential - Oracle Restricted
# [,1] [,2] [,3] [,4]
# [1,] 1 4 7 10
# [2,] 2 5 8 11
# [3,] 3 6 9 12
Example of a 3D Array:
arr_3d <- array(1:24, dim = c(3, 4, 2))
print(arr_3d)
# Outputs a 3-dimensional array with two 3x4 matrices:
#,,1
# [,1] [,2] [,3] [,4]
# [1,] 1 4 7 10
# [2,] 2 5 8 11
# [3,] 3 6 9 12
#,,2
# [,1] [,2] [,3] [,4]
# [1,] 13 16 19 22
# [2,] 14 17 20 23
# [3,] 15 18 21 24
2. Accessing Elements in Arrays
Confidential - Oracle Restricted
Confidential - Oracle Restricted
You can access elements of an array using indices for each dimension.
Example:
• Accessing a Single Element:
elem <- arr_3d[2, 3, 1] # Accesses the element at the 2nd row, 3rd column,
1st matrix
print(elem) # Outputs: 8
• Accessing an Entire Row or Column:
row_extract <- arr_3d[1, , 2] # Extracts the 1st row from the 2nd matrix
print(row_extract) # Outputs: [1] 13 16 19 22
col_extract <- arr_3d[, 4, 1] # Extracts the 4th column from the 1st matrix
print(col_extract) # Outputs: [1] 10 11 12
• Accessing an Entire Matrix:
matrix_extract <- arr_3d[, , 1] # Extracts the 1st matrix
print(matrix_extract)
# Outputs:
# [,1] [,2] [,3] [,4]
# [1,] 1 4 7 10
# [2,] 2 5 8 11
# [3,] 3 6 9 12
3. Modifying Elements
You can modify elements in an array by assigning new values to specific
positions.
Example:
Confidential - Oracle Restricted
Confidential - Oracle Restricted
arr_3d[2, 2, 1] <- 99 # Modifies the element at the 2nd row, 2nd column, 1st
matrix
print(arr_3d[2, , 1]) # Outputs the modified 2nd row of the 1st matrix: [1] 2 99 8
11
4. Array Operations
Arrays support arithmetic operations, which are performed element-wise.
Examples:
• Addition:
arr1 <- array(1:6, dim = c(2, 3))
arr2 <- array(7:12, dim = c(2, 3))
arr_sum <- arr1 + arr2
print(arr_sum)
# Outputs:
# [,1] [,2] [,3]
# [1,] 8 12 16
# [2,] 10 14 18
• Multiplication:
arr_mult <- arr1 * arr2
print(arr_mult)
# Outputs:
# [,1] [,2] [,3]
# [1,] 7 27 55
# [2,] 16 40 72
5. Checking Array Properties
Confidential - Oracle Restricted
Confidential - Oracle Restricted
Arrays have certain properties that you can check using various functions:
• dim(): Returns the dimensions of the array.
• length(): Returns the total number of elements in the array.
• dimnames(): Assigns or retrieves names for the dimensions.
Examples:
print(dim(arr_3d)) # Outputs: [1] 3 4 2 (3 rows, 4 columns, 2 matrices)
print(length(arr_3d)) # Outputs: 24 (total number of elements)
# Assigning names to dimensions:
dimnames(arr_3d) <- list(c("Row1", "Row2", "Row3"), c("Col1", "Col2", "Col3",
"Col4"), c("Matrix1", "Matrix2"))
print(dimnames(arr_3d))
6. Combining Arrays
Arrays can be combined along existing or new dimensions using functions like
abind() (requires the abind package) or manually combining using cbind() and
rbind() if dimensions allow.
Example:
# Combining arrays along the third dimension
library(abind)
combined_arr <- abind(arr1, arr2, along = 3)
print(dim(combined_arr)) # Outputs: [1] 2 3 2 (2 rows, 3 columns, 2 matrices)
Summary
Confidential - Oracle Restricted
Confidential - Oracle Restricted
• Arrays in R can be multi-dimensional, supporting data storage beyond
2D matrices.
• Creation is done with array() by specifying data and dimensions.
• Element Access uses indexing for each dimension.
• Arithmetic Operations are element-wise and can involve more than
one array.
• Properties can be checked using dim(), length(), and dimnames().
when working with multi-dimensional datasets.
Confidential - Oracle Restricted
