R courses

Loops in R  Loops are used to repeat a block of code multiple times based on conditions or iterations. In R, there are three main types of loops: for, while, and repeat. Each serves different purposes and is used in different scenarios. for Loop The for loop iterates over a sequence of values, executing the block of code for each value. Syntax: for (variable in sequence) {   # Code to execute for each value in the sequence } Example:  # Print numbers from 1 to 5 for (i in 1:5) {   print(i) } Example with Vectors:  # Sum elements of a vector numbers <- c(1, 2, 3, 4, 5) sum <- 0 for (num in numbers) {   sum <- sum + num } print(sum)  # Prints 15 Example with Lists:  # Print each element of a list my_list <- list(a = 1, b = 2, c = 3) for (item in my_list) {   print(item) } while Loop The while loop continues to execute a block of code as long as a specified condition remains true. Syntax:  while (condition) {   # Code to execute while condition is true } Example:  # Print numbers from 1 to 5 count <- 1 while (count <= 5) {   print(count)   count <- count + 1 } Example with Accumulation:  # Calculate the sum of numbers from 1 to 5 sum <- 0 num <- 1 while (num <= 5) {   sum <- sum + num   num <- num + 1 } print(sum)  # Prints 15 repeat Loop The repeat loop is similar to the while loop but does not have a built-in condition for stopping. It requires an explicit break statement to exit the loop. Syntax:  repeat {   # Code to execute   if (condition) {     break   } } Example:  # Print numbers from 1 to 5 count <- 1 repeat {   print(count)   count <- count + 1   if (count > 5) break } Example with Condition Check:  # Find the first number greater than 10 num <- 1 repeat {   if (num > 10) break   num <- num + 1 } print(num)  # Prints 11 Using break and next in Loops break: Immediately exits the current loop. next: Skips the current iteration and proceeds to the next iteration of the loop. Example of break:  # Find the first even number greater than 10 for (num in 11:20) {   if (num %% 2 == 0) {     print(num)     break   } } Example of next:  # Print only odd numbers from 1 to 10 for (num in 1:10) {   if (num %% 2 == 0) next   print(num) } Nested Loops Loops can be nested within each other to perform more complex operations. Example:  # Print a multiplication table from 1 to 3 for (i in 1:3) {   for (j in 1:3) {     print(paste(i, “*”, j, “=”, i * j))   } } Vectorized Operations In R, many operations can be vectorized, meaning they can be performed on entire vectors without explicit loops, which can be more efficient. Example:  # Adding two vectors without a loop vec1 <- c(1, 2, 3, 4, 5) vec2 <- c(10, 20, 30, 40, 50) result <- vec1 + vec2 print(result)  # Prints 11 22 33 44 55 Applying Functions to Vectors and Data Frames Functions like lapply, sapply, apply, and mapply can be used to apply operations over vectors, lists, or data frames in a loop-like manner. Example with lapply:  # Applying a function to each element of a list my_list <- list(a = 1, b = 2, c = 3) squared_list <- lapply(my_list, function(x) x^2) print(squared_list) Example with apply:  # Applying a function to each row of a matrix mat <- matrix(1:6, nrow = 2) row_sums <- apply(mat, 1, sum)  # Sum of each row print(row_sums) Performance Considerations While loops are essential for certain tasks, vectorized operations and apply functions are often more efficient in R. They avoid the overhead of explicit loops and take advantage of optimized C code.

Functions as Objects Concept In R, functions are first-class objects, meaning they can be treated like any other data type. You can assign them to variables, pass them as arguments, and return them from other functions. Assigning Functions to Variables You can assign a function to a variable, which allows you to call the function using that variable name.  # Define a function add <- function(a, b) {   return(a + b) } # Assign function to a variable my_func <- add # Call the function using the variable result <- my_func(3, 4)  # 7 print(result) Explanation: The add function is assigned to my_func. my_func(3, 4) calls the function via the variable, returning 7. Passing Functions as Arguments Functions can be passed as arguments to other functions, allowing for flexible and dynamic code.  # Define a function that takes another function as an argument apply_function <- function(func, x, y) {   return(func(x, y)) } # Define a function to pass multiply <- function(a, b) {   return(a * b) } # Use apply_function with multiply result <- apply_function(multiply, 6, 7)  # 42 print(result) Explanation: apply_function takes a function func and applies it to x and y. multiply is passed to apply_function, resulting in 42. Returning Functions from Functions Functions can return other functions, which allows for function factories and closures.  # Define a function that returns another function make_power_function <- function(exponent) {   return(function(base) {     return(base ^ exponent)   }) } # Create a power function for squaring square <- make_power_function(2) # Use the returned function result <- square(4)  # 16 print(result) Explanation: make_power_function returns a function that raises a number to a given exponent. square is a function returned by make_power_function that squares its input. Functions as List Elements Functions can be elements of lists, allowing for dynamic and flexible function handling.  # Define some functions sum_func <- function(a, b) {   return(a + b) } diff_func <- function(a, b) {   return(a – b) } # Create a list of functions func_list <- list(add = sum_func, subtract = diff_func) # Use functions from the list result1 <- func_list$add(5, 3)      # 8 result2 <- func_list$subtract(5, 3) # 2 print(result1) print(result2) Explanation: func_list contains two functions. Functions are accessed and called using $ notation. Manipulating Functions You can also manipulate functions by modifying their environment or behavior.  # Define a function with an environment f <- function(x) {   env <- environment()   env$y <- 10   return(x + y) } # Change the environment’s value environment(f)$y <- 20 # Call the function result <- f(5)  # 25 print(result) Explanation: The function f uses an environment variable y. Changing y in the environment affects the function’s behavior. Best Practices Clarity: When assigning functions to variables or passing them around, ensure your code remains clear and understandable. Documentation: Document functions that are used as arguments or returned from other functions to make their usage clear. Testing: Test functions thoroughly when they are passed around or returned to ensure they behave as expected in different contexts.

Return Values Concept In R, return values are crucial as they determine what a function outputs after execution. You can specify what a function should return using the return() function, or, if omitted, R returns the last evaluated expression by default. Syntax  function_name <- function(arguments) {   # Function body   return(value)  # Specifies what to return } Basic Example  # Define the function add_numbers <- function(a, b) {   sum <- a + b   return(sum) } # Function call result <- add_numbers(5, 3)  # 8 print(result) Explanation: The add_numbers function calculates the sum of a and b and returns it using return(sum). The function call add_numbers(5, 3) returns 8. Default Return Value If return() is not used, R returns the last value evaluated in the function.  # Define the function without return() subtract_numbers <- function(a, b) {   difference <- a – b   difference  # The last evaluated value is returned } # Function call result <- subtract_numbers(10, 4)  # 6 print(result) Explanation: Here, subtract_numbers returns the value of difference even though return() is not explicitly used. Multiple Return Values R functions can return multiple values by encapsulating them in a list.  # Define the function statistics <- function(x) {   mean_val <- mean(x)   sd_val <- sd(x)   return(list(mean = mean_val, sd = sd_val)) } # Function call result <- statistics(c(1, 2, 3, 4, 5)) print(result) Explanation: The statistics function returns a list containing the mean and standard deviation of the input values. list(mean = mean_val, sd = sd_val) creates a list with two named elements: mean and sd. Return Value with Conditions You can use conditional statements to determine what the function returns.  # Define the function categorize_number <- function(x) {   if (x > 0) {     return(“Positive”)   } else if (x < 0) {    return(“Negative”)   } else {     return(“Zero”)   } } # Function calls print(categorize_number(10))   # “Positive” print(categorize_number(-5))   # “Negative” print(categorize_number(0))    # “Zero” Explanation: The categorize_number function returns a different string based on whether x is positive, negative, or zero. Implicit Return Value If no explicit return() is used, the last evaluated expression is returned. This can simplify functions.  # Define the function multiply_numbers <- function(a, b) {   a * b  # The last evaluated expression is returned } # Function call result <- multiply_numbers(4, 5)  # 20 print(result) Explanation: Here, a * b is the last expression evaluated, so it is automatically returned. Best Practices Clarity: Use return() to make it clear what your function returns, especially if multiple values are computed. Consistency: Be consistent in whether you use return(). Choose to use or omit it based on code readability and clarity.

Default Values for Arguments Concept Default values for arguments in R functions allow you to specify a value that will be used if the caller does not provide a value for that argument. This makes your functions more flexible and easier to use. Syntax When defining a function, you can set default values for arguments. The syntax is as follows:  function_name(arg1 = default_value1, arg2 = default_value2, …) {   # Function body } Examples Example 1: Basic Function with Default Values  # Define the function greet <- function(name = “John Doe”, message = “Hello”) {   print(paste(message, name)) } # Function calls greet()                          # Uses default values greet(“Alice”)                   # Uses “Alice” for ‘name’ and default “Hello” for ‘message’ greet(“Alice”, “Hi”)             # Uses “Alice” for ‘name’ and “Hi” for ‘message’ Explanation: In the first call, the default values “John Doe” and “Hello” are used. In the second call, “Alice” replaces the default for name, and the default “Hello” is used for message. In the third call, “Alice” replaces the default for name, and “Hi” replaces the default for message. Example 2: Function with Default Values and Calculation  # Define the function calculate_area <- function(length = 10, width = 5) {   area <- length * width   return(area) } # Function calls calculate_area()          # Uses default values, returns 50 calculate_area(7)         # Uses 7 for ‘length’ and default 5 for ‘width’, returns 35 calculate_area(7, 3)     # Uses 7 for ‘length’ and 3 for ‘width’, returns 21 Explanation: In the first call, default values are used to calculate the area (10 x 5 = 50). In the second call, length is set to 7, and the default value for width is 5, resulting in an area of 35. In the third call, both arguments are specified, resulting in an area of 21. Specifying Default Values Default values should be provided when defining the function and usually appear at the end of the argument list. Example: Default Values with Optional Argument  # Define the function describe <- function(name, age = NA, occupation = “Unknown”) {   description <- paste(“Name:”, name, “- Age:”, age, “- Occupation:”, occupation)   return(description) } # Function calls describe(“Alice”)                   # Uses default values for ‘age’ and ‘occupation’ describe(“Bob”, 30)                # Uses 30 for ‘age’ and default “Unknown” for ‘occupation’ describe(“Carol”, 28, “Engineer”) # Uses 28 for ‘age’ and “Engineer” for ‘occupation’ Explanation: In the first call, age and occupation use their default values (NA and “Unknown”). In the second call, age is specified as 30, and occupation uses the default “Unknown”. In the third call, all three arguments are specified. Best Practices Clarity: Ensure that default values make sense and are appropriate for the function. Consistency: Place arguments with default values at the end of the argument list to avoid confusion when calling the function. Documentation: Document the default values in the function’s documentation so users understand their role. By using default values for arguments, you can make your functions more versatile and easier to use, providing sensible defaults when users do not supply all necessary arguments.

Arithmetic Operators  Arithmetic operators are used to perform mathematical operations on numeric values. Addition (+) Syntax :  a + b Example :  a <- 5 b <- 3 result <- a + b  # 8 print(result) Explanation: Adds the values of a and b, resulting in 8. Subtraction (–) Syntax:  a – b  Example :  a <- 5 b <- 3 result <- a – b  # 2 print(result) Explanation: Subtracts b from a, resulting in 2. Multiplication (*) Syntax :  a * b  Example :  a <- 5 b <- 3 result <- a * b  # 15 print(result) Explanation: Multiplies a by b, resulting in 15. Division (/) Syntax :  a / b Example :  a <- 5 b <- 3 result <- a / b  # 1.6667 print(result) Explanation: Divides a by b, resulting in approximately 1.6667. Exponentiation (^ or **) Syntax :  a ^ b a ** b  Example :  a <- 2 b <- 3 result <- a ^ b  # 8 print(result) Explanation: Raises a to the power of b, resulting in 8. Modulo (%%) Syntax:  a %% b Example :  a <- 10 b <- 3 result <- a %% b  # 1 print(result) Explanation: Computes the remainder of a divided by b, resulting in 1. Integer Division (%/%) Syntax :  a %/% b Example :  a <- 10 b <- 3 result <- a %/% b  # 3 print(result)  Explanation: Computes the integer quotient of a divided by b, resulting in 3. Boolean Operators Les opérateurs booléens sont utilisés pour effectuer des opérations logiques sur des valeurs booléennes (TRUE ou FALSE). Equality (==) Syntax :  a == b Example :  a <- 5 b <- 3 result <- a == b  # FALSE print(result) Explanation: Checks if a is equal to b. The result is FALSE because 5 is not equal to 3. Inequality (!=) Syntax :  a != b  Example :  a <- 5 b <- 3 result <- a != b  # TRUE print(result) Explanation: Checks if a is not equal to b. The result is TRUE because 5 is not equal to 3. Less Than (<) Syntax :  a < b Example :  a <- 5 b <- 10 result <- a < b  # TRUE print(result) Explanation: Checks if a is less than b. The result is TRUE because 5 is less than 10. Greater Than (>) Syntax :  a > b Example :  a <- 5 b <- 10 result <- a > b  # FALSE print(result) Explanation: Checks if a is greater than b. The result is FALSE because 5 is not greater than 10. Less Than or Equal To (<=) Syntax:  a <= b  Example :  a <- 5 b <- 5 result <- a <= b  # TRUE print(result) Explanation: Checks if a is less than or equal to b. The result is TRUE because 5 is equal to 5. Greater Than or Equal To (>=) Syntax :  a >= b Example :  a <- 5 b <- 3 result <- a >= b  # TRUE print(result) Explanation: Checks if a is greater than or equal to b. The result is TRUE because 5 is greater than 3. Logical AND (& and &&) Syntax : & : Element-wise logical AND. && : Short-circuit logical AND. Example :  a <- TRUE b <- FALSE result1 <- a & b  # FALSE result2 <- a && b  # FALSE print(result1) print(result2) Explanation: Both & and && check if both conditions are true. && evaluates only the first element, while & evaluates element-wise. Logical OR (| and ||) Syntax : | : Element-wise logical OR. || : Short-circuit logical OR. Example :  a <- TRUE b <- FALSE result1 <- a | b  # TRUE result2 <- a || b  # TRUE print(result1) print(result2) Explanation: Both | and || check if at least one condition is true. || evaluates only the first element, while | evaluates element-wise. Logical NOT (!) Syntax :  !a Example :  a <- TRUE result <- !a  # FALSE print(result) Explanation: Negates the boolean value of a. If a is TRUE, !a is FALSE. These operators are fundamental in performing mathematical and logical operations in R. They allow for a wide range of data manipulation and decision-making processes in your code.

Control Statements in R Control statements in R direct the flow of execution in a program. Here’s a comprehensive look at the key control statements available in R: The if Statement The if statement executes a block of code only if a specific condition is true. Syntax:  if (condition) {  # Code to execute if condition is true }  Example:  x <- 10 if (x > 5) {  print(“x is greater than 5”) } The if-else Statement The if-else statement executes one block of code if the condition is true and another block if it is false. Syntax:  if (condition) {  # Code to execute if condition is true } else {  # Code to execute if condition is false } Example:  x <- 3 if (x > 5) {  print(“x is greater than 5”) } else {  print(“x is less than or equal to 5”) } The if-else if-else Statement The if-else if-else statement allows testing multiple conditions in sequence. Syntax:  if (condition1) {  # Code to execute if condition1 is true } else if (condition2) {  # Code to execute if condition2 is true } else {  # Code to execute if none of the above conditions are true }  Example:  x <- 7 if (x < 5) {  print(“x is less than 5”) } else if (x == 7) {  print(“x is equal to 7”) } else {  print(“x is greater than 5 but not equal to 7”) } The ifelse Function The ifelse function is a vectorized version of if-else, allowing you to handle vectors of values. Syntax:  ifelse(condition, value_if_true, value_if_false) Example:  x <- c(1, 2, 3, 4, 5) result <- ifelse(x %% 2 == 0, “Even”, “Odd”) print(result) The switch Statement The switch statement allows choosing from several options based on an index or value. Syntax:  switch(expression,       “value1” = result1,       “value2” = result2,       …) Example:  day <- 3 day_name <- switch(day, “1” = “Monday”, “2” = “Tuesday”,”3″ = “Wednesday”, “4” = “Thursday”, “5” = “Friday”, “6” = “Saturday”, “7” = “Sunday”) print(day_name)  # Prints “Wednesday”  while Loops while loops execute a block of code as long as a condition is true. Syntax:  while (condition) {  # Code to execute while condition is true} Example:  count <- 1 while (count <= 5) {  print(paste(“Count:”, count))  count <- count + 1 } repeat Loops repeat loops execute a block of code indefinitely until a break condition is met. Syntax:  repeat {  # Code to execute  if (condition) {    break  } } Example:  count <- 1 repeat {   print(paste(“Count:”, count))   count <- count + 1  if (count > 5) break }  break and next Statements break: Immediately exits the loop. next: Skips to the next iteration of the loop. Example of break:  for (i in 1:10) {   if (i == 5) break  print(i) } Example of next:  for (i in 1:10) {      if (i %% 2 == 0)            next     print(i) }  Combined Control Statements Control statements can be combined to handle more complex scenarios. Example:  x <- 8 y <- 12 if (x > 5) {  if (y < 10) {    print(“x is greater than 5 and y is less than 10”)  } else {    print(“x is greater than 5 but y is greater than or equal to 10”)   } } else {  print(“x is less than or equal to 5”) }