Homework 1

Introduction

Overview

This homework is designed to evaluate your understanding of R programming, focusing on your ability to write functions, manipulate data, and apply various programming concepts. The exercises are structured to present different levels of difficulty, beginning with basic tasks and progressing to more complex challenges. This progression will allow you to apply foundational skills while also pushing you to tackle more advanced problems.

Expectations

Clarity and Correctness

• Each function should be clearly named and precisely perform the task described in the exercise.
• Ensure that your code is correct by producing the expected output for a variety of test cases, including edge cases.

Code Efficiency

• While correctness is crucial, you should also consider the efficiency of your code.
• Avoid unnecessary computations or memory usage where possible.

Documentation and Readability

• Include comments in your code to explain what each part of your function does, especially for more complex functions.
• Use meaningful variable names that make it clear what each variable represents, enhancing the readability of your code.

Handling Edge Cases

• For exercises involving numeric inputs, consider how your function should behave with different types of numbers (e.g., zero, negative numbers, non-integers).
• For data-related exercises, ensure that your function can handle scenarios like empty data frames or missing values gracefully.

Testing

• Test your functions with a variety of inputs to ensure they work as expected. Include some of these tests in your submission to demonstrate that your code has been thoroughly checked.
• Where applicable, provide an explanation of how you tested the function and why you believe it is correct.

Use of Built-in Functions

• You are encouraged to use R’s built-in functions and packages where appropriate, but ensure you understand how they work and can explain their usage if needed.

Submission Guidelines

• Submit your code in a single R script file (.R).
• Ensure that your code runs without errors. If there are any known issues, document them in comments within your script.
• If you collaborated with others or consulted external resources, please acknowledge them in comments.
• Include a brief write-up (as comments at the top of your script) summarizing how you approached the homework and any challenges you encountered.

---

Exercises

Exercise 1: Simple Functions

1. Greeting Function:
   • Create a function called greet that takes a character string name as input and returns a greeting message in the format "Hello, <name>!". For example, greet("Alice") should return "Hello, Alice!".
2. Basic Arithmetic Operations:
   • Write a function basic_ops(a, b) that takes two numbers a and b as input and returns their sum, difference, product, and quotient in a named list.
3. Summing Even Numbers:
   • Create a function even_sum(n) that takes a positive integer n and returns the sum of all even numbers from 1 to n.
4. Prime Number Checker:
   • Write a function is_prime(n) that takes an integer n as input and returns TRUE if n is a prime number, and FALSE otherwise.

Exercise 2: Conditional Statements

• Age Classification:
  • Write a function classify_age that takes an integer age as input and returns a character string indicating whether the person is "young" (under 18), "adult" (18-64), or "senior" (65 or older).

Exercise 3: String Manipulation

• Extracting Initials:
  • Write a function extract_initials that takes a character string full_name as input and returns the initials of the name (e.g., "John Smith" -> "JS").

Exercise 4: Simple Variable Manipulation

1. Assigning Values:
   • Create three variables: a, b, and c. Assign them the values 5, 10, and 15, respectively.
2. Swapping Values:
   • Write code to swap the values of a and c.
3. Printing Variables:
   • Print the new values of a, b, and c.

Exercise 5: Vector Operations

1. Creating Vectors:
   • Create a vector v1 containing the numbers 1 through 10.
2. Concatenating Vectors:
   • Create a vector v2 containing the numbers 11 through 20. Write code to concatenate v1 and v2 into a new vector v3.
3. Statistical Analysis:
   • Calculate the sum, mean, and standard deviation of v3.

Exercise 6: Matrix Operations

1. Creating Matrices:
   • Create a 3x3 matrix m1 with random integer values between 1 and 50.
2. Matrix Addition:
   • Create a 3x3 matrix m2 with random integer values between 1 and 50. Write code to add m1 and m2 and store the result in m3.
3. Determinant Calculation:
   • Calculate the determinant of m3.

Exercise 7: Data Frame Manipulation

1. Loading Data:
   • Download the "mtcars" dataset and store it in a variable called df.
2. Filtering Data:
   • Write code to select all rows where the car has more than 100 horsepower.
3. Creating Subsets:
   • Create a new data frame df_subset that contains only the mpg, cyl, and hp columns.
4. Sorting Data:
   • Sort df_subset in descending order by hp.

Exercise 8: Data Visualization

1. Creating a Scatterplot:
   • Use the ggplot2 library to create a scatterplot of the mtcars dataset, plotting mpg on the y-axis and hp on the x-axis.
2. Adding a Trend Line:
   • Add a trend line to the scatterplot using a linear regression model.
3. Customizing the Plot:
   • Customize the plot by adding a title, axis labels, and applying a theme.

Exercise 9: Estimating π with the Monte Carlo Method

Objective

In this exercise, you will write a function that estimates the value of π using a Monte Carlo simulation. The Monte Carlo method relies on random sampling to obtain numerical results, making it a powerful tool for estimating values that are difficult to calculate directly.

Problem Statement

• Function Name: monte_carlo_pi
• Input: A single integer iterations, representing the number of random points to generate.
• Output: A numeric value representing the estimated value of π.

Methodology

The Monte Carlo method can be used to estimate π by simulating random points within a unit square and determining the proportion that fall within a quarter circle inscribed within the square.

1. Generate Random Points:
   • The unit square is defined with both x and y coordinates ranging from 0 to 1.
   • For each iteration, generate a random point (x, y) where both x and y are uniformly distributed between 0 and 1.
2. Determine if the Point is Inside the Quarter Circle:
   • A point (x, y) lies inside the quarter circle if it satisfies the equation \(x^2 + y^2 \leq 1\).
   • Count how many points fall inside the quarter circle.
3. Estimate π:
   • The ratio of points inside the quarter circle to the total number of points, multiplied by 4, gives an estimate of π: \[ \text{Estimated } \pi = \frac{\text{Number of points inside the circle}}{\text{Total number of points}} \times 4 \]

Implementation

monte_carlo_pi <- function(iterations) {
    ...
    return(estimated_pi)
}

Testing Your Function

To verify that your function works correctly, test it with a range of values for iterations:

set.seed(123)
print(monte_carlo_pi(100))      # Small number of iterations
print(monte_carlo_pi(10000))    # Larger number of iterations
print(monte_carlo_pi(1000000))  # Even larger number of iterations

Expected Outcomes

• Understanding Random Sampling: This exercise will help you grasp how random sampling can be used to estimate complex values.
• Algorithm Design: You’ll practice designing an algorithm that repeatedly tests a condition and accumulates results.
• Numerical Estimation: You’ll gain insight into how large-scale simulations can approximate mathematical constants.