R courses

Generating Useful Vectors with the Operator: The operator : in R is a simple and efficient method for generating sequences of numbers. It is particularly useful for creating vectors of consecutive integers. This section explores how to use this operator to generate vectors and its various behaviors. Creating Sequences The : operator allows for straightforward sequence creation. The basic syntax is start, where start is the starting number and end is the ending number of the sequence. Examples:  # Generate a sequence from 1 to 5 seq1 <- 1:5 print(seq1)  # Output: 1 2 3 4 5 # Generate a sequence from 10 to 1 (descending order) seq2 <- 10:1 print(seq2)  # Output: 10 9 8 7 6 5 4 3 2 1 Explanation: 1:5 generates an ascending sequence from 1 to 5. 10:1 generates a descending sequence from 10 to 1. Sequences with Non-Unit Steps The : operator generates sequences with a step of 1. To create sequences with steps other than 1, you should use the seq() function which offers more flexibility. Example with a step of 1 (default):  # Generate a sequence from 1 to 10 with a step of 1 seq3 <- 1:10 print(seq3)  # Output: 1 2 3 4 5 6 7 8 9 10 Example with a step of 2 using seq():  # Generate a sequence from 1 to 10 with a step of 2 seq4 <- seq(1, 10, by = 2) print(seq4)  # Output: 1 3 5 7 9 Explanation: 1:10 generates a sequence from 1 to 10 with a step of 1. seq(1, 10, by = 2) generates a sequence from 1 to 10 with a step of 2. Using in Loops The : operator is often used in for loops to iterate over a sequence of numbers. Example:  # Use the `:` operator in a for loop for (i in 1:5) {   print(i) } # Output: 1 2 3 4 5  Explanation: The for loop iterates over each number in the sequence generated by 1:5 and prints each number. Behavior with Negative Values If the start value is greater than the end value, the : operator will generate an empty sequence or a descending sequence if the values are in descending order. Examples:  # Generate a descending sequence seq_descending <- 5:1 print(seq_descending)  # Output: 5 4 3 2 1 # Generate an empty sequence (no values between 5 and 1 with a positive step) seq_empty <- 5:10 print(seq_empty)  # Output: 5 6 7 8 9 10  Explanation: 5:1 generates a descending sequence from 5 to 1. 5:10 generates an empty sequence in this context as indices are increasing but limits are not respected. Using with Zero-Length Vectors When generating a sequence with identical start and end values but invalid steps, the result will be a zero-length vector. Example:  # Generate a sequence with identical start and end values seq_identical <- 5:5 print(seq_identical)  # Output: 5 Explanation: 5:5 generates a vector containing a single element, 5, as the start and end values are identical. Comparison with the seq() Function The seq() function offers more flexibility than the : operator for generating sequences, notably for setting different steps, specific lengths, or non-uniform sequences. Examples with seq():  # Generate a sequence with a step of 0.5 seq_step <- seq(1, 5, by = 0.5) print(seq_step)  # Output: 1 1.5 2 2.5 3 3.5 4 4.5 5 # Generate a sequence with a specific number of elements seq_length <- seq(1, 10, length.out = 5) print(seq_length)  # Output: 1 3.25 5.5 7.75 10 Explanation: seq(1, 5, by = 0.5) generates a sequence from 1 to 5 with a step of 0.5. seq(1, 10, length.out = 5) generates a sequence from 1 to 10 with exactly 5 elements, regardless of the step. Summary The : operator in R is a simple and practical way to generate sequences of consecutive integers, whether ascending or descending. It generates sequences with a step of 1. For sequences with different steps or specific lengths, the seq() function is preferable. The : operator is commonly used in loops and operations requiring simple sequences. Understanding its behavior with negative values and identical start and end values is crucial to avoid unexpected results.  

Vector Indexing Vector indexing in R allows you to access or modify specific elements within a vector. R uses 1-based indexing, meaning that the index of the first element is 1. This section will cover the various ways to index and subset vectors, including positive and negative indexing, logical indexing, and more. Positive Indexing You can use positive integers to access elements of a vector. The index positions are specified by numbers, starting from 1. Examples:  # Define a numeric vector vec <- c(10, 20, 30, 40, 50) # Access elements by positive indexing first_element <- vec[1] print(first_element)  # Output: 10 # Access multiple elements subset_vec <- vec[c(2, 4)] print(subset_vec)  # Output: 20 40 Explanation: vec[1] accesses the first element of the vector. vec[c(2, 4)] accesses the elements at positions 2 and 4. Negative Indexing Negative indexing allows you to exclude specific elements from the vector. The indices specified are removed from the vector. Examples:  # Define a numeric vector vec <- c(10, 20, 30, 40, 50) # Exclude elements using negative indexing excluded_elements <- vec[-c(2, 4)] print(excluded_elements)  # Output: 10 30 50 Explanation: vec[-c(2, 4)] returns the vector with the 2nd and 4th elements excluded. Logical Indexing Logical indexing allows you to select elements based on conditions. A logical vector of the same length as the original vector is used, with TRUE indicating elements to include and FALSE indicating elements to exclude. Examples:  # Define a numeric vector vec <- c(10, 20, 30, 40, 50) # Create a logical vector logical_index <- c(TRUE, FALSE, TRUE, FALSE, TRUE) # Access elements based on logical indexing filtered_vec <- vec[logical_index] print(filtered_vec)  # Output: 10 30 50 Explanation: logical_index specifies which elements to include based on the TRUE values. Indexing with Names Vectors in R can have names assigned to their elements, and you can index these vectors using these names. Examples:  # Define a named vector named_vec <- c(a = 10, b = 20, c = 30, d = 40) # Access elements by name element_a <- named_vec[“a”] print(element_a)  # Output: 10 # Access multiple elements by name subset_named_vec <- named_vec[c(“b”, “d”)] print(subset_named_vec)  # Output: b 20 d 40 Explanation: named_vec[“a”] retrieves the value associated with the name “a”. named_vec[c(“b”, “d”)] retrieves values associated with the names “b” and “d”. Indexing with Sequences You can use sequences to index and access a range of elements in a vector. This is useful for selecting contiguous blocks of elements. Examples:  # Define a numeric vector vec <- c(10, 20, 30, 40, 50) # Access elements using a sequence sequence_index <- vec[2:4] print(sequence_index)  # Output: 20 30 40 Explanation: 2:4 creates a sequence from 2 to 4, which is used to access the 2nd through 4th elements of the vector. Advanced Indexing with which() The which() function is used to find the indices of elements that satisfy a condition. It returns the positions of the TRUE values in a logical vector. Examples:  # Define a numeric vector vec <- c(10, 20, 30, 40, 50) # Find indices of elements greater than 25 indices <- which(vec > 25) print(indices)  # Output: 3 4 5 # Use these indices to access the elements elements <- vec[indices] print(elements)  # Output: 30 40 50 Explanation: which(vec > 25) returns the indices where the condition vec > 25 is TRUE. Modifying Elements You can modify elements of a vector by assigning new values to specific indices. Examples:  # Define a numeric vector vec <- c(10, 20, 30, 40, 50) # Modify elements vec[3] <- 35 print(vec)  # Output: 10 20 35 40 50 # Modify multiple elements vec[c(1, 5)] <- c(15, 55) print(vec)  # Output: 15 20 35 40 55 Explanation: vec[3] <- 35 changes the value of the 3rd element to 35. vec[c(1, 5)] <- c(15, 55) changes the values of the 1st and 5th elements. Handling Out-of-Bounds Indexes When indexing with numbers outside the range of the vector, R returns an empty result or NA. Examples:  # Define a numeric vector vec <- c(10, 20, 30) # Access out-of-bounds index out_of_bounds <- vec[5] print(out_of_bounds)  # Output: NA # Access with a mix of in-bounds and out-of-bounds indexes mixed_index <- vec[c(1, 3, 5)] print(mixed_index)  # Output: 10 30 NA Explanation: Indexing with 5 returns NA because it is out of the bounds of the vector. A mix of valid and invalid indexes will return NA for the invalid indices. Summary Vector indexing in R is a versatile tool for accessing and manipulating elements in vectors. You can use positive indexing to access specific elements, negative indexing to exclude elements, and logical indexing to filter elements based on conditions. Named indexing allows you to use element names for access, while sequences and the which() function offer advanced indexing capabilities. Modifying elements and handling out-of-bounds indices are also important aspects of vector indexing.

Vector Arithmetic and Logical Operations Vector Arithmetic Operations Vector arithmetic operations allow you to perform mathematical calculations element-wise between vectors or with scalar values. This is essential for data analysis and manipulation. Addition, Subtraction, Multiplication, and Division These operations are performed element-wise. Examples:  # Define two numeric vectors vec1 <- c(2, 4, 6, 8) vec2 <- c(1, 3, 5, 7) # Addition add_vec <- vec1 + vec2 print(add_vec)  # Output: 3 7 11 15 # Subtraction sub_vec <- vec1 – vec2 print(sub_vec)  # Output: 1 1 1 1 # Multiplication mul_vec <- vec1 * vec2 print(mul_vec)  # Output: 2 12 30 56 # Division div_vec <- vec1 / vec2 print(div_vec)  # Output: 2 1.333333 1.2 1.142857 Explanation: Each element in vec1 is combined with the corresponding element in vec2 using the specified arithmetic operation. Scalar Arithmetic Operations When you perform arithmetic operations with a scalar and a vector, the scalar is applied to each element of the vector. Examples:  # Define a numeric vector vec <- c(5, 10, 15) # Addition with a scalar add_scalar <- vec + 2 print(add_scalar)  # Output: 7 12 17 # Multiplication with a scalar mul_scalar <- vec * 3 print(mul_scalar)  # Output: 15 30 45 Explanation: The scalar 2 or 3 is added or multiplied with each element of vec. Logical Operations on Vectors Logical operations are used to perform comparisons and generate boolean vectors (TRUE or FALSE). Basic Comparisons Examples:  # Define two numeric vectors vec1 <- c(1, 2, 3, 4, 5) vec2 <- c(3, 2, 1, 4, 6) # Equality comparison eq_logical <- vec1 == vec2 print(eq_logical)  # Output: FALSE TRUE FALSE TRUE FALSE # Greater than comparison gt_logical <- vec1 > vec2 print(gt_logical)  # Output: FALSE FALSE TRUE FALSE FALSE # Less than comparison lt_logical <- vec1 < vec2 print(lt_logical)  # Output: TRUE FALSE FALSE FALSE TRUE Explanation: == checks if elements are equal. > and < check for greater than or less than conditions, respectively. Logical Operators Logical operators like & (and), | (or), and ! (not) can be used to combine or invert logical vectors. Examples:  # Define two logical vectors log_vec1 <- c(TRUE, FALSE, TRUE, FALSE) log_vec2 <- c(FALSE, FALSE, TRUE, TRUE) # Logical AND and_logical <- log_vec1 & log_vec2 print(and_logical)  # Output: FALSE FALSE TRUE FALSE # Logical OR or_logical <- log_vec1 | log_vec2 print(or_logical)  # Output: TRUE FALSE TRUE TRUE # Logical NOT not_logical <- !log_vec1 print(not_logical)  # Output: FALSE TRUE FALSE TRUE Explanation: & performs element-wise logical AND. | performs element-wise logical OR. ! inverts the boolean values. Combining Logical Conditions You can use logical operators to combine multiple conditions. Examples:  # Define a numeric vector vec <- c(1, 4, 5, 6, 7, 9) # Logical conditions condition1 <- vec > 3 condition2 <- vec %% 2 == 0 # Combine conditions combined_condition <- condition1 & condition2 print(combined_condition)  # Output: FALSE TRUE FALSE TRUE FALSE FALSE Explanation: condition1 checks if elements are greater than 3. condition2 checks if elements are even. combined_condition combines both conditions using &. Using Logical Vectors for Subsetting Logical vectors can be used to subset other vectors or data frames. Examples:  # Define a numeric vector vec <- c(10, 20, 30, 40, 50) # Define a logical vector logical_subset <- c(TRUE, FALSE, TRUE, FALSE, TRUE) # Subset the numeric vector subset_vec <- vec[logical_subset] print(subset_vec)  # Output: 10 30 50 Explanation: logical_subset is used to filter vec. Only elements corresponding to TRUE are included. Handling NA and NULL Values in Arithmetic and Logical Operations NA (Not Available): Represents missing or undefined values in R. Operations involving NA generally result in NA. NULL: Represents the absence of a value or an empty object. NULL values can disrupt operations and are typically used for different purposes. Examples:  # Define vectors with NA values vec1 <- c(1, 2, NA, 4) vec2 <- c(5, NA, 3, 2) # Arithmetic operation with NA na_sum <- vec1 + vec2 print(na_sum)  # Output: 6 NA NA 6 # Logical operation with NA na_comparison <- vec1 == vec2 print(na_comparison)  # Output: FALSE NA NA FALSE # Handling NULL values null_vec <- NULL print(null_vec + vec1)  # Output: NULL Explanation: Arithmetic and logical operations involving NA typically result in NA. NULL does not interact well with arithmetic operations and generally propagates through operations. Summary Vector arithmetic operations in R allow for element-wise computations between vectors or with scalars, including addition, subtraction, multiplication, and division. Logical operations enable comparisons and the creation of boolean vectors, with operators like ==, >, <, &, |, and ! facilitating various logical tests. Logical vectors are useful for subsetting and filtering. Handling NA and NULL values requires special attention, as they affect the results of arithmetic and logical operations.

Common Vector Operations in R Vector operations are fundamental for data manipulation and analysis in R. These operations allow you to perform calculations and transformations on vectors efficiently. Here’s a comprehensive overview of common vector operations in R. Basic Arithmetic Operations You can perform basic arithmetic operations element-wise on vectors. Examples:  # Define two numeric vectors vec1 <- c(1, 2, 3, 4, 5) vec2 <- c(10, 20, 30, 40, 50) # Addition sum_vec <- vec1 + vec2 print(sum_vec)  # Output: 11 22 33 44 55 # Subtraction diff_vec <- vec1 – vec2 print(diff_vec)  # Output: -9 -18 -27 -36 -45 # Multiplication prod_vec <- vec1 * vec2 print(prod_vec)  # Output: 10 40 90 160 250 # Division div_vec <- vec1 / vec2 print(div_vec)  # Output: 0.1 0.1 0.1 0.1 0.1 Explanation: Arithmetic operations are performed element-wise. Logical Operations Logical vectors enable comparisons and create boolean vectors. Examples:  # Define two numeric vectors vec1 <- c(1, 2, 3, 4, 5) vec2 <- c(3, 4, 2, 5, 1) # Equality comparison eq_vec <- vec1 == vec2 print(eq_vec)  # Output: FALSE FALSE TRUE FALSE FALSE # Greater than comparison gt_vec <- vec1 > vec2 print(gt_vec)  # Output: FALSE FALSE TRUE FALSE TRUE # Greater than or equal to comparison ge_vec <- vec1 >= vec2 print(ge_vec)  # Output: FALSE FALSE TRUE TRUE TRUE Explanation: Logical comparisons return boolean vectors (TRUE or FALSE). Summary Statistics Summary operations compute simple statistics on vectors. Examples:  # Define a numeric vector vec <- c(5, 10, 15, 20, 25) # Sum of elements sum_vec <- sum(vec) print(sum_vec)  # Output: 75 # Mean of elements mean_vec <- mean(vec) print(mean_vec)  # Output: 15 # Variance of elements var_vec <- var(vec) print(var_vec)  # Output: 62.5 # Standard deviation of elements sd_vec <- sd(vec) print(sd_vec)  # Output: 7.905694 Explanation: sum() calculates the sum of elements. mean() computes the mean. var() calculates variance. sd() computes the standard deviation. Sorting Operations  Sorting vectors is crucial for data analysis. Examples: # Define a numeric vector vec <- c(3, 1, 4, 1, 5, 9, 2) # Sort elements in ascending order sorted_vec <- sort(vec) print(sorted_vec)  # Output: 1 1 2 3 4 5 9 # Sort elements in descending order sorted_vec_desc <- sort(vec, decreasing = TRUE) print(sorted_vec_desc)  # Output: 9 5 4 3 2 1 1  Explanation: sort() sorts vector elements. decreasing = TRUE sorts in descending order. Indexing Elements Access elements of a vector using indices. Examples:  # Define a numeric vector vec <- c(10, 20, 30, 40, 50) # Access the first element first_elem <- vec[1] print(first_elem)  # Output: 10 # Access elements from index 2 to 4 sub_vec <- vec[2:4] print(sub_vec)  # Output: 20 30 40 # Access specific elements specific_elems <- vec[c(1, 3, 5)] print(specific_elems)  # Output: 10 30 50 Explanation: Indices are used to extract specific elements from the vector. Modifying Elements Modify elements of a vector using indices. Examples:  # Define a numeric vector vec <- c(1, 2, 3, 4, 5) # Modify the third element vec[3] <- 99 print(vec)  # Output: 1 2 99 4 5 # Modify multiple elements vec[c(1, 4)] <- c(10, 20) print(vec)  # Output: 10 2 99 20 5 Explanation: Indices are used to update specific elements in the vector. Element Names Manipulation Element names in a vector can be assigned and manipulated. Examples:  # Define a named vector vec <- c(a = 1, b = 2, c = 3) # Access an element by name element_b <- vec[“b”] print(element_b)  # Output: 2 # Modify an element using its name vec[“c”] <- 99 print(vec)  # Output: a 1 b 2 c 99 Explanation: Names of elements allow for more readable access and modification. Combining and Stacking Vectors Vectors can be combined or stacked to create new vectors or matrices. Examples:  # Define two vectors vec1 <- c(1, 2, 3) vec2 <- c(4, 5, 6) # Combine vectors combined_vec <- c(vec1, vec2) print(combined_vec)  # Output: 1 2 3 4 5 6 # Stack vectors into a matrix matrix_vec <- rbind(vec1, vec2) print(matrix_vec) # Output: #      [,1] [,2] [,3] # vec1    1    2    3 # vec2    4    5    6 Explanation: c() combines multiple vectors. rbind() stacks vectors into rows of a matrix. Vector Calculations Perform cumulative calculations like cumulative sums or products. Examples:  # Define a numeric vector vec <- c(1, 2, 3, 4, 5) # Cumulative sum cumsum_vec <- cumsum(vec) print(cumsum_vec)  # Output: 1 3 6 10 15 # Cumulative product cumprod_vec <- cumprod(vec) print(cumprod_vec)  # Output: 1 2 6 24 120 Explanation: cumsum() calculates the cumulative sum. cumprod() calculates the cumulative product. Summary Common vector operations in R include arithmetic, logical operations, summary statistics, sorting, indexing, modification, name manipulation, combining and stacking vectors, and cumulative calculations. Mastering these operations allows for efficient and effective data manipulation and analysis.

Recycling in R Overview Recycling in R is a mechanism that allows vectors of different lengths to be used together in operations. When performing element-wise operations on vectors, R will recycle the shorter vector to match the length of the longer vector, if possible. This can simplify code and improve efficiency but requires an understanding of how recycling works to avoid unexpected results. Basic Recycling When you perform operations with vectors of different lengths, R will recycle the shorter vector by repeating its values. Example:  # Define a longer vector long_vec <- c(1, 2, 3, 4, 5) # Define a shorter vector short_vec <- c(10, 20) # Add the vectors together result <- long_vec + short_vec # Output print(result)  # Result: 11 22 13 24 15 Explanation: short_vec is recycled to match the length of long_vec. The operation proceeds as if short_vec were c(10, 20, 10, 20, 10). Recycling with Different Lengths Recycling works when the length of the longer vector is a multiple of the length of the shorter vector. If not, R will issue a warning. Example:  # Define a longer vector long_vec <- c(1, 2, 3, 4, 5) # Define a shorter vector short_vec <- c(10, 20, 30) # Attempt to add the vectors together result <- long_vec + short_vec # Output print(result)  # Warning: longer object length is not a multiple of shorter object length Explanation: short_vec does not evenly divide into the length of long_vec. R gives a warning and recycles short_vec as c(10, 20, 30, 10, 20). Recycling with Logical Vectors Recycling also applies to logical vectors. The logical vector will be recycled to match the length of the other vector. Example:  # Define a numeric vector num_vec <- c(1, 2, 3, 4, 5) # Define a logical vector log_vec <- c(TRUE, FALSE) # Subtract using the logical vector result <- num_vec – log_vec # Output print(result)  # Result: 0 2 2 4 4 Explanation: log_vec is recycled to c(TRUE, FALSE, TRUE, FALSE, TRUE). Logical TRUE is treated as 1 and FALSE as 0. Recycling in Conditional Statements Recycling can also affect the results of conditional operations. When logical vectors are used for indexing or conditions, they will be recycled. Example:  # Define a numeric vector num_vec <- c(10, 20, 30, 40, 50) # Define a logical vector log_vec <- c(TRUE, FALSE) # Filter using the logical vector filtered_vec <- num_vec[log_vec] # Output print(filtered_vec)  # Result: 10 30 50 Explanation: log_vec is recycled to c(TRUE, FALSE, TRUE, FALSE, TRUE). Filtering keeps values where the logical vector is TRUE. Recycling in Data Frames and Lists Recycling also applies to data frames and lists, where columns or elements may be recycled during operations. Example:  # Define a data frame df <- data.frame(A = c(1, 2, 3), B = c(10, 20, 30)) # Define a vector to add to a column vec <- c(100, 200) # Add vector to the data frame column df$A <- df$A + vec # Output print(df)  # Result: A B 1 101 10 2 202 20 3 103 30 Explanation: vec is recycled to c(100, 200, 100). Column A is updated with the recycled vector values. Recycling Rules and Warnings When vectors are recycled, it’s important to understand the rules and warnings: Rule: The length of the longer vector must be a multiple of the length of the shorter vector. Warning: If this rule is not followed, R will issue a warning indicating that the longer object length is not a multiple of the shorter object length. Example:  # Define a vector v_long <- c(1, 2, 3, 4, 5, 6) # Define a shorter vector v_short <- c(1, 2) # Add the vectors result <- v_long + v_short # Output print(result)  # Warning: longer object length is not a multiple of shorter object length Explanation: v_short is recycled as c(1, 2, 1, 2, 1, 2). The warning is issued because the length of v_long is not a multiple of the length of v_short. Summary Recycling in R is a powerful feature that simplifies operations with vectors of different lengths by automatically repeating the shorter vector. Understanding how recycling works helps in writing efficient and error-free code. Keep an eye out for warnings to ensure that recycling is occurring as expected and that no unintended results are produced.

Vector Declarations in R Vectors are fundamental data structures in R that store elements of the same type. Here’s an in-depth look at how to declare and create vectors in R. Creating Numeric Vectors Numeric vectors contain numbers. Example:  # Creating an integer numeric vector num_vec_int <- c(1, 2, 3, 4, 5) # Creating a floating-point numeric vector num_vec_float <- c(1.1, 2.2, 3.3, 4.4, 5.5)  Notes: Numeric vectors can contain either integers (1, 2, 3) or floating-point numbers (1.1, 2.2). R automatically converts integers to floating-point numbers if necessary to maintain type consistency. Creating Character Vectors Character vectors store text strings. Example:  # Creating a character vector char_vec <- c(“apple”, “banana”, “cherry”) # Mixing text strings with numbers char_mixed <- c(“Age: “, 25) Notes: If a vector contains characters and numbers, R converts all elements to characters to maintain type consistency. Creating Logical Vectors Logical vectors store boolean values: TRUE or FALSE. Example:  # Creating a logical vector log_vec <- c(TRUE, FALSE, TRUE, FALSE) Notes: Logical vectors are often used for conditions and filtering. Creating Complex Vectors Complex vectors can store complex numbers (which have a real and imaginary part). Example:  # Creating a complex vector comp_vec <- c(1+2i, 3+4i, 5+6i) Notes: Complex numbers are noted with i for the imaginary part (e.g., 3+4i). Creating Vectors with Element Names Element names can be assigned to make vectors more readable. Example:  # Creating a named vector named_vec <- c(a = 1, b = 2, c = 3) # Accessing an element by name element_b <- named_vec[“b”] Notes: Element names allow you to reference vector values by names rather than numeric indices. Creating Vectors with the vector() Function The vector() function allows you to create vectors of specific types with an initial length. Example:  # Creating a numeric vector of length 5 vec_numeric <- vector(“numeric”, length = 5) # Creating a logical vector of length 3 vec_logical <- vector(“logical”, length = 3) Notes: vector(“numeric”, length = n) creates a numeric vector of length n with initial values set to 0. vector(“logical”, length = n) creates a logical vector of length n with initial values set to FALSE. Using the c() Function to Combine Vectors The c() function can also be used to concatenate multiple vectors into a single vector. Example:  # Creating two vectors vec1 <- c(1, 2, 3) vec2 <- c(4, 5, 6) # Combining the two vectors combined_vec <- c(vec1, vec2) Notes: The c() function concatenates multiple vectors into a single vector. Using the seq() Function to Create Sequential Vectors The seq() function generates sequences of numbers. Example:  # Creating a sequence from 1 to 10 with a step of 1 seq_vec <- seq(1, 10, by = 1) # Creating a sequence with a specific length seq_len_vec <- seq_len(5)  # Equivalent to seq(1, 5)  Notes: seq(from, to, by) allows you to specify the start, end, and step of the sequence. seq_len(n) generates a sequence from 1 to n. Using the rep() Function to Repeat Elements The rep() function allows you to repeat elements of a vector. Example:  # Repeating each element of c(1, 2) twice repeated_vec <- rep(c(1, 2), each = 2) # Repeating the vector c(1, 2) three times repeated_vec_times <- rep(c(1, 2), times = 3) Notes: rep(x, each = n) repeats each element n times. rep(x, times = n) repeats the entire vector n times. Creating Zero-Length Vectors Vectors can also be created with zero length, which can be useful for subsequent operations. Example:  # Creating an empty vector empty_vec <- c() # Checking the length of the vector length(empty_vec)  # Result: 0 Notes: Empty vectors are often used as a base to conditionally add elements later.

Matrices and Arrays as Vectors In R, matrices and arrays are more complex data structures that can be thought of as multidimensional vectors. Understanding how matrices and arrays operate as vectors is key for advanced data manipulation and analysis. Matrices Matrices are two-dimensional structures that store data in rows and columns. They can be conceptualized as vectors in a multidimensional context. Creating a Matrix You can create a matrix using the matrix() function. Create a Matrix # Create a 2×3 matrix mat <- matrix(1:6, nrow = 2, ncol = 3) print(mat) # Output: #      [,1] [,2] [,3] # [1,]    1    3    5 # [2,]    2    4    6  The matrix() function takes a vector of elements (here 1:6) and organizes them into a matrix with the specified number of rows (nrow) and columns (ncol). Accessing Matrix Elements Elements in a matrix can be accessed by row and column indices. Access a Single Element  # Access the element in the 1st row and 2nd column element <- mat[1, 2] print(element)  # Output: 3  Access a Whole Row or Column  # Access the 2nd row second_row <- mat[2, ] print(second_row)  # Output: c(2, 4, 6) # Access the 3rd column third_col <- mat[, 3] print(third_col)  # Output: c(5, 6)  Resizing a Matrix Matrices can be resized by reorganizing their elements. Resize a Matrix  # Create an initial matrix mat <- matrix(1:6, nrow = 2, ncol = 3) # Resize to 3×2 new_mat <- matrix(mat, nrow = 3, ncol = 2) print(new_mat) # Output: #      [,1] [,2] # [1,]    1    4 # [2,]    2    5 # [3,]    3    6  Arrays Arrays are multidimensional data structures that can have more than two dimensions. Creating an Array You can create an array using the array() function. Create an Array  # Create a 3x2x2 array array_3d <- array(1:12, dim = c(3, 2, 2)) print(array_3d) # Output: # , , 1 # #      [,1] [,2] # [1,]    1    4 # [2,]    2    5 # [3,]    3    6 # # , , 2 # #      [,1] [,2] # [1,]    7   10 # [2,]    8   11 # [3,]    9   12  The array() function takes a vector of elements (here 1:12) and arranges them into a multidimensional structure according to the specified dimensions (dim). Accessing Array Elements Elements in an array can be accessed by indices for each dimension. Access a Single Element  # Access the element at position [2, 1, 2] element <- array_3d[2, 1, 2] print(element)  # Output: 8  Access a Slice of the Array  # Access the 2nd slice (2nd plane) of the array slice <- array_3d[, , 2] print(slice) # Output: #      [,1] [,2] # [1,]    7   10 # [2,]    8   11 # [3,]    9   12  Resizing an Array Arrays can also be resized by reorganizing their elements. Resize an Array  # Create an initial 3x2x2 array array_3d <- array(1:12, dim = c(3, 2, 2)) # Resize to 2x3x2 new_array <- array(array_3d, dim = c(2, 3, 2)) print(new_array) # Output: # , , 1 # #      [,1] [,2] [,3] # [1,]    1    4    7 # [2,]    2    5    8 # # , , 2 # #      [,1] [,2] [,3] # [1,]    3    6    9 # [2,]    4    7   10 Advanced Manipulation Conversion Between Vectors and Matrices You can convert between vectors and matrices for various manipulations. Convert a Vector to a Matrix  # Create a vector vec <- 1:12 # Convert to a 3×4 matrix mat <- matrix(vec, nrow = 3, ncol = 4) print(mat) # Output: #      [,1] [,2] [,3] [,4] # [1,]    1    4    7   10 # [2,]    2    5    8   11 # [3,]    3    6    9   12 Manipulating Multidimensional Arrays You can manipulate multidimensional arrays by accessing and modifying specific slices and dimensions. Manipulate a Slice of an Array  # Create a 2x3x2 array array_3d <- array(1:12, dim = c(2, 3, 2)) # Modify elements in the first slice array_3d[1, , 1] <- c(10, 20, 30) print(array_3d) # Output: # , , 1 # #      [,1] [,2] [,3] # [1,]   10   20   30 # [2,]    2    5    8 # # , , 2 # #      [,1] [,2] [,3] # [1,]    7   10   13 # [2,]    8   11   14 In summary, matrices and arrays in R can be thought of as extensions of vectors into higher dimensions. Matrices are two-dimensional structures, while arrays are multidimensional. They use vectors to store their elements and allow for a wide range of manipulations through their multidimensional indexing. Understanding these concepts is crucial for handling complex data structures and performing advanced data analysis in R.

Obtaining the Length of a Vector Using the length() Function The primary function to determine the length of a vector in R is length(). This function returns the number of elements present in the vector. Basic Usage Find Length of a Vector  # Create a vector vec <- c(10, 20, 30, 40, 50) # Get the length of the vector length_of_vec <- length(vec) print(length_of_vec)  # Result: 5 In this example, the vector vec contains 5 elements, so length(vec) returns 5. Length of Different Types of Vectors Numeric Vector  numeric_vec <- c(1, 2, 3, 4, 5, 6) length(numeric_vec)  # Result: 6  Character Vector  char_vec <- c(“apple”, “banana”, “cherry”) length(char_vec)  # Result: 3  Logical Vector  log_vec <- c(TRUE, FALSE, TRUE, TRUE) length(log_vec)  # Result: 4  Empty Vector  empty_vec <- c() length(empty_vec)  # Result: 0  Using Length in Data Manipulation The length of a vector is often used in various data manipulation tasks: Conditional Operations Loop through Vector Elements  # Create a vector vec <- c(1, 2, 3, 4, 5) # Loop through vector using its length for (i in 1:length(vec)) {   print(vec[i]) } Resizing or Repeating Elements Resize a Vector  # Create a vector vec <- c(1, 2, 3) # Resize vector by repeating elements resized_vec <- rep(vec, length.out = 5) print(resized_vec)  # Result: c(1, 2, 3, 1, 2)  Add Elements to Match a Desired Length  # Create a vector vec <- c(1, 2) # Desired length desired_length <- 5 # Add elements to match the desired length vec <- c(vec, rep(NA, desired_length – length(vec))) print(vec)  # Result: c(1, 2, NA, NA, NA)  Practical Examples Here are some practical scenarios where obtaining the length of a vector is useful: Generating Random Data When generating random data, you often specify the length of the vector.  # Generate a vector of 10 random numbers random_vec <- rnorm(10) print(length(random_vec))  # Result: 10  Subsetting Data Determine the length of a vector to subset it accordingly.  # Create a vector vec <- c(10, 20, 30, 40, 50) # Get length len <- length(vec) # Subset the first half first_half <- vec[1:(len / 2)] print(first_half)  # Result: c(10, 20) Working with Lists Find the length of elements within lists.  # Create a list with vectors of different lengths my_list <- list(vec1 = c(1, 2, 3), vec2 = c(4, 5, 6, 7)) # Get lengths of list elements lengths <- sapply(my_list, length) print(lengths)  # Result: c(3, 4)  Handling Length in Complex Data Structures Vectors in Data Frames When working with data frames, you may need to get the length of columns or rows.  # Create a data frame df <- data.frame(Name = c(“Alice”, “Bob”, “Charlie”),                  Age = c(25, 30, 35)) # Length of columns column_lengths <- sapply(df, length) print(column_lengths)  # Result: 3 3 (number of rows in each column) # Number of rows in the data frame num_rows <- nrow(df) print(num_rows)  # Result: 3  In summary, obtaining the length of a vector is a fundamental operation in R that is widely used in data manipulation and analysis. The length() function provides a straightforward way to get this information, and it plays a crucial role in many programming tasks, including iteration, resizing, and subsetting.

Adding and Removing Elements from a Vector Managing vectors often involves adding or removing elements. Here’s a detailed look at how to perform these operations in R. Adding Elements to a Vector You can add elements to a vector using several methods: Using the c() Function The c() function (for “concatenate”) combines vectors. You can use it to append elements to an existing vector. Add a Single Element  # Create an initial vector vec <- c(1, 2, 3) # Add an element vec <- c(vec, 4) # Result: c(1, 2, 3, 4) Add Multiple Elements  # Create an initial vector vec <- c(1, 2, 3) # Add multiple elements vec <- c(vec, 4, 5, 6) # Result: c(1, 2, 3, 4, 5, 6) Combine Two Vectors  vec1 <- c(1, 2, 3) vec2 <- c(4, 5, 6) # Combine vec2 with vec1 vec1 <- c(vec1, vec2) # Result: c(1, 2, 3, 4, 5, 6)  Using the append() Function The append() function allows you to insert elements at a specific position in a vector. Add an Element at a Specific Position  # Create an initial vector vec <- c(1, 2, 3) # Insert the element 4 at the 2nd position vec <- append(vec, 4, after = 1) # Result: c(1, 4, 2, 3)  Add Multiple Elements  # Create an initial vector vec <- c(1, 2, 3) # Insert elements 4 and 5 at the 2nd position vec <- append(vec, c(4, 5), after = 1) # Result: c(1, 4, 5, 2, 3 Removing Elements from a Vector Removing elements can be done in different ways: Using Negative Indices Negative indices are used to exclude specific elements from a vector. Remove a Single Element # Create an initial vector vec <- c(1, 2, 3, 4, 5) # Remove the 3rd element vec <- vec[-3] # Result: c(1, 2, 4, 5) Remove Multiple Elements # Create an initial vector vec <- c(1, 2, 3, 4, 5) # Remove elements at positions 2 and 4 vec <- vec[-c(2, 4)] # Result: c(1, 3, 5) Using Logical Conditions You can use logical conditions to filter out elements based on certain criteria. Remove Elements Based on a Condition # Create an initial vector vec <- c(1, 2, 3, 4, 5) # Remove elements greater than 3 vec <- vec[vec <= 3] # Result: c(1, 2, 3) Remove Elements Equal to a Specific Value # Create an initial vector vec <- c(1, 2, 3, 2, 4, 2) # Remove all occurrences of 2 vec <- vec[vec != 2] # Result: c(1, 3, 4) Practical Examples Here are some practical examples to illustrate these operations: Adding Elements to a List of Scores # Initial list of scores scores <- c(85, 90, 78) # Add a new score scores <- c(scores, 92) # Result: c(85, 90, 78, 92) # Add multiple new scores scores <- c(scores, 88, 91) # Result: c(85, 90, 78, 92, 88, 91) Removing Scores Below a Threshold # List of scores scores <- c(85, 90, 78, 92, 88, 91) # Remove scores below 85 scores <- scores[scores >= 85] # Result: c(85, 90, 92, 88, 91) Adding and Removing Elements in a List of IDs # Initial list of IDs ids <- c(101, 102, 103, 104) # Add a new ID ids <- c(ids, 105) # Result: c(101, 102, 103, 104, 105) # Remove ID 102 ids <- ids[ids != 102] # Result: c(101, 103, 104, 105) In summary, adding and removing elements from a vector in R is a fundamental aspect of data manipulation. Using functions like c(), append(), and indexing techniques, you can effectively manage vector content. These skills are essential for data analysis and processing in R.

Scalars and Vectors in R Scalars and Vectors Scalars In R, a “scalar” is essentially a single value. Although R does not have a distinct scalar type (as in some other programming languages), a scalar in R is effectively a vector of length 1. Examples of Scalars: Numeric: 42, 3.14 Character: “Hello”, “R” Logical: TRUE, FALSE Creating Scalars:  # Numeric num_scalar <- 42 # Character char_scalar <- “Hello” # Logical log_scalar <- TRUE  Properties of Scalars: Length: The length() function returns 1 for a scalar. Class: The class() function indicates the data type of the scalar.  length(num_scalar)  # returns 1 class(num_scalar)   # returns “numeric” length(char_scalar) # returns 1 class(char_scalar)  # returns “character” length(log_scalar)  # returns 1 class(log_scalar)   # returns “logical”  Vectors Vectors in R are collections of elements of the same type. They are one-dimensional and can contain multiple scalars. Here are the most common types of vectors: Numeric Vectors: Contain numbers (integers or real numbers). Logical Vectors: Contain boolean values (TRUE or FALSE). Character Vectors: Contain strings. Complex Vectors: Contain complex numbers (with real and imaginary parts). Creating Vectors: Numeric Vector: Use the c() function to combine several numbers.  num_vector <- c(1, 2, 3, 4, 5) Logical Vector: Combine several boolean values.  log_vector <- c(TRUE, FALSE, TRUE) Character Vector: Combine several strings.  char_vector <- c(“a”, “b”, “c”) Complex Vector: Create a vector of complex numbers.  complex_vector <- c(1+2i, 3+4i) Properties of Vectors: Length: The length() function returns the number of elements in a vector.  length(num_vector)  # returns 5 Class: The class() function indicates the type of vector.  class(num_vector)   # returns “numeric” class(char_vector)  # returns “character” Indexing: You can access elements of a vector by their index. Indexing starts at 1 in R. # Access the 3rd element num_vector[3]  # returns 3 # Access elements 1 and 3 num_vector[c(1, 3)]  # returns c(1, 3) Manipulating Vectors: Adding Elements: Combine the existing vector with new elements using c(). num_vector <- c(num_vector, 6, 7)  # vector becomes c(1, 2, 3, 4, 5, 6, 7) Removing Elements: Use negative indices to exclude certain elements. num_vector <- num_vector[-3]  # removes the 3rd element, becomes c(1, 2, 4, 5, 6, 7) Modifying Elements: Assign a new value to one or more elements. num_vector[2] <- 20  # vector becomes c(1, 20, 4, 5, 6, 7) Operations on Vectors: Arithmetic Operations: Arithmetic operations are performed element-wise. num_vector + 10  # returns c(11, 30, 14, 15, 16, 17) Statistical Functions: Use functions like mean(), sum(), median(), etc. mean(num_vector)  # returns the mean of the elements in the vector sum(num_vector)   # returns the sum of the elements in the vector Logical Comparisons: Perform comparisons that return logical vectors.  num_vector > 4   # returns c(FALSE, FALSE, TRUE, TRUE, TRUE, TRUE) Practical Examples Create and Manipulate a Vector of Scores:  # Create the vector scores <- c(12, 15, 14, 18, 16) # Add a new score scores <- c(scores, 17) # Remove the lowest score scores <- scores[scores != min(scores)] # Calculate the average mean(scores)  # returns the mean of the remaining scores Use a Logical Vector to Filter Data:  # Create a vector of numbers numbers <- c(5, 8, 12, 15, 20) # Create a logical vector to filter numbers greater than 10 filter_logical <- numbers > 10 # Use the logical vector to filter numbers filtered_numbers <- numbers[filter_logical]  # returns c(12, 15, 20) In summary, scalars and vectors are fundamental concepts in R. Scalars are vectors of length 1, while vectors can contain multiple elements of the same type. Understanding how to create, manipulate, and analyze these structures is essential for data analysis in R.