Advanced Programming in R Exam

Data Manipulation (20 points)

1. Using the dplyr package, write a function that takes a data frame and performs the following operations:
2. Filters rows based on a given condition
3. Groups the data by a specified column
4. Calculates the mean of a numeric column for each group
5. Arranges the result in descending order of the calculated mean

library(dplyr)

##
## Attaching package: 'dplyr'

## The following objects are masked from 'package:stats':
##
## filter, lag

## The following objects are masked from 'package:base':
##
## intersect, setdiff, setequal, union

# Example data frame
my_data <- data.frame(
condition_column = c("A", "B", "A", "B"),
numeric_column = c(10, 15, 8, 12)
)

manipulate_data <- function(data_frame, condition_column, numeric_column) {
result <- data_frame %>%
group_by(!!sym(condition_column)) %>%
summarise(mean_value = mean(!!sym(numeric_column), na.rm = TRUE)) %>%
arrange(desc(mean_value))

return(result)
}

# Call the function
manipulate_data(my_data, "condition_column", "numeric_column")

## # A tibble: 2 × 2
## condition_column mean_value
## <chr> <dbl>
## 1 B 13.5
## 2 A 9

Advanced Functions (15 points)

1. Create a function that implements the bootstrap method for estimating the standard error of the mean. The function should:
2. Take a vector of numbers and the number of bootstrap samples as input
3. Use R's functional programming capabilities
4. Return the estimated standard error

bootstrap_se_mean <- function(data_vector, num_samples) {
boot_samples <- replicate(num_samples, sample(data_vector, replace = TRUE))
boot_means <- apply(boot_samples, 2, mean)
se_estimate <- sd(boot_means)
return(se_estimate)
}

# Example usage
my_vector <- c(10, 15, 8, 12, 17, 24, 23, 13, 9)
my_se_estimate <- bootstrap_se_mean(my_vector, num_samples = 1000)
print(paste("Estimated SE of mean:", my_se_estimate))

## [1] "Estimated SE of mean: 1.77124607852647"

Package Development (20 points)

1. Provide an example that outlines the steps to create an R package

@param x Numeric value. @return Square of x. @examples square(3) # Output: 9

square <- function(x) {
x^2
}

Sample data: Iris flower measurements

@format A data frame with 150 rows and 5 variables:

"iris"

## [1] "iris"

Calculate the mean of a numeric vector

@param x Numeric vector. @return Mean value. @examples mean_value(c(1, 2, 3)) # Output: 2

mean_value <- function(x) {
mean(x)
}

Parallel Computing (15 points)

1. Write a function that performs parallel computation using the parallel package. The function should take a large dataset and a complex operation as input. Implement the operation using both sequential and parallel approaches. Compare and report the execution times of both approaches.

library(parallel)

parallel_computation <- function(data, complex_operation) {

cl <- makeCluster(detectCores())

on.exit(stopCluster(cl))

# Sequential approach

start_time_seq <- Sys.time()

result_seq <- lapply(data, complex_operation)

end_time_seq <- Sys.time()

# Parallel approach

start_time_par <- Sys.time()

result_par <- parLapply(cl, data, complex_operation)

end_time_par <- Sys.time()

# Compare execution times

time_diff_seq <- end_time_seq - start_time_seq

time_diff_par <- end_time_par - start_time_par

return(list(result_seq = result_seq, result_par = result_par,

time_seq = time_diff_seq, time_par = time_diff_par))

}

# Example usage

my_data <- 1:1000

my_complex_operation <- function(x) sqrt(x) + log(x)

result_times <- parallel_computation(my_data, my_complex_operation)

print(result_times)

Advanced Visualization (20 points)

1. Create a complex visualization using ggplot2 that includes:
2. Multiple layers of geometric objects
3. Faceting
4. Custom themes
5. Interactive elements

library(ggplot2)
library(plotly)

##
## Attaching package: 'plotly'

## The following object is masked from 'package:ggplot2':
##
## last_plot

## The following object is masked from 'package:stats':
##
## filter

## The following object is masked from 'package:graphics':
##
## layout

# Example data
my_data <- data.frame(
x = rnorm(100),
y = rnorm(100),
group = rep(letters[1:4], each = 25)
)

# Create a scatter plot with facets
p <- ggplot(my_data, aes(x, y)) +
geom_point() +
facet_wrap(~group) +
theme_minimal()

# Convert to interactive plotly plot
p_plotly <- ggplotly(p)
print(p_plotly)