RStudio Guide

To get started, click on the 'workspace' folder in the bottom right pane of RStudio. Click on the file entitled "Step 1...". You may want to drag the console pane to be smaller so that you have more room to work. You'll complete each task for Step 1 in that R Markdown file. Remember, you must run the cells with the play button at the top right of each cell for a task before moving onto the next task in the R Markdown file. Continue until you have completed all tasks in this step. Then when you are ready to move onto the next step, you'll come back and click on the file for the next step until you have completed all tasks in all steps of the lab.

Exploring Numerical Methods with R

To review the concepts covered in this step, please refer to the Understanding Numerical Methods module of the Solving Problems with Numerical Methods course.

Understanding numerical methods is important because it lays the foundation for solving complex mathematical problems using computational techniques. Write basic code in R to demonstrate the basics of numerical methods, including a simple example using the Jacobi method for solving a system of linear equations.

Dive into the world of numerical methods by exploring how they differ from analytical techniques and why this distinction is crucial for solving complex problems. Using R, you will practice solving a simple problem numerically and analytically to understand the practical differences and applications. Goal: Understand the fundamental concepts of numerical methods and their applications. Tools: R programming language.

Task 1.1: Loading Required Libraries

Before diving into numerical methods, let's ensure that all necessary libraries are loaded. You do not need to install these libraries, as they come pre-installed in the environment. For this lab, we'll need RcppArmadillo, Rlinsolve, ggplot2, and pracma for numerical computations and visualizations.

library('RcppArmadillo')
library('Rlinsolve')
library('ggplot2')
library('pracma')

Task 1.2: Constructing a 2x2 Linear System

To delve deeper into numerical methods, let's construct a simpler system of linear equations. Create a 2x2 matrix A representing the coefficients of the equations, and a 2x1 vector b representing the constants on the right side of the equations. The matrix should have the values c(4, 1, 2, 3) and the vector should have the values c(5, 6).

A <- matrix(c(4, 1, 2, 3), nrow = 2, ncol = 2, byrow = T)
b <- matrix(c(5, 6), nrow = 2, ncol = 1, byrow = T)

Task 1.3: Solving the System Using the Jacobi Method

Now that we have our system of equations defined, let's solve it using the Jacobi method. Use the lsolve.jacobi() function from the Rlinsolve library to find the solution. Print the solution and the number of iterations used. Then, use ggplot2 to plot the error at each iteration step.

# Solve
out <- lsolve.jacobi(A, b, weight = 1, verbose = F)

# Print the solution
print(out$x)

# Print the numer of iterations
print(out$iter)

# Plot the error over iterations
error <- out$errors
iteration <- out$iter
iter_seq <- seq.int(0, iteration, 1)
error_per_iter <- data.frame(iter_seq, error)
ggplot(error_per_iter, aes(x = iter_seq, y = error)) + geom_line(col = 'red', size = 2)

Task 1.4: Analytical Solution of the System

To understand the difference between numerical and analytical solutions, let's solve the same system of equations analytically using the rref() function from the pracma library. This will give us the Reduced Row Echelon Form (RREF) of the augmented matrix [A|b], which represents the system of equations.

rref_solution <- rref(cbind(A, b))
print(rref_solution)

Implementing Interpolation Techniques in R

To review the concepts covered in this step, please refer to the Applying Numerical Methods to Solve Problems module of the Solving Problems with Numerical Methods course.

Interpolation and Extrapolation are important because they allow us to estimate unknown values within a set of known data points or beyond them. This step will cover different interpolation techniques, including linear, polynomial, and spline interpolation.

Practice implementing various interpolation techniques in R to estimate unknown values within toy datasets created for you in the example code. You will use the approx, approxfun, and spline functions in R to perform linear, polynomial, and spline interpolation, respectively. Goal: Gain hands-on experience with interpolation techniques in R. Tools: R programming language, approx, approxfun, spline functions.

Task 2.1: Exploring Linear Interpolation with approx

Load the stats library. Given the predefined data points, use linear interpolation with the approx function. Visualize the result with plot().

# Load the stats library
library(stats)

# Predefined data points
x <- c(1, 3, 5, 7, 9)
y <- c(2, 8, 24, 45, 73)

# Perform linear interpolation using the approx function
linear_interp <- approx(x = x, y = y)

# Visualize the interpolated values
plot(linear_interp)

Task 2.2: Polynomial Interpolation with poly.calc

Load the polynom package. Now perform polynomial interpolation on the data from the previous step. Estimate values against the provided x_seq data and plot the results.

# Load the polynom library
library(polynom)

# Calculate the polynomial interpolation coefficients
poly_coefs <- poly.calc(x, y)

# Provided sequence of x values for plotting the polynomial curve
x_seq <- seq(min(x), max(x), length.out = 100)

# Calculate interpolated y values using the polynomial coefficients
y_poly <- predict(poly_coefs, x_seq)

# Visualize the interpolated values
plot(x_seq, y_poly)

Task 2.3: Exploring Spline Interpolation

Perform spline interpolation on x and y using the spline function. Plot the results.

# Perform spline interpolation on the predefined data points
spline_interp <- spline(x = x, y = y)

# Visualize the spline interpolation
plot(spline_interp)

Solving Linear Equations with Iterative and Direct Methods

To review the concepts covered in this step, please refer to the Applying Numerical Methods to Solve Problems module of the Solving Problems with Numerical Methods course.

Solving systems of linear equations is important because it's a fundamental problem in numerical analysis with applications across various fields. This step will focus on using both direct (Gaussian elimination) and iterative (Jacobi method) techniques to solve linear equations.

Apply direct and iterative numerical techniques to solve a system of linear equations in R. You will use Gaussian elimination and the Jacobi method to understand the differences and applications of each approach. Goal: Master solving systems of linear equations using direct and iterative methods. Tools: R programming language.

Task 3.1: Loading Required Libraries

Before we start solving linear equations, let's ensure that all necessary libraries are loaded. For this lab, we will need the Matrix library for creating matrices and the pracma and Rlinsolve libraries for numerical methods.

library('Matrix')
library('Rlinsolve')
library('pracma')

Task 3.2: Creating a System of Linear Equations

Use the predefined data to create a system of linear equations that we will solve using both direct and iterative methods. Define a matrix A representing the coefficients of the system and a vector b representing the constants on the right side of the equations. Print the matrix and vector.

A <- matrix(c(4, -1, 0, -1, 3, -1, 0, -1, 3), nrow = 3, ncol = 3)
b <- c(3, 3, -1)
print(A)
print(b)

Task 3.3: Solving with Gauss Jordan Elimination

Now that we have our system of linear equations, let's solve it by reducing it to row echelon form. Use the rref function from the pracma library to achieve this.

# Reduce the matrix to row echelon form
reduced_matrix <- rref(cbind(A, b))

# Display the reduced matrix
print(reduced_matrix)

Task 3.4: Exploring Direct and Iterative Methods for Solving Linear Equations

In this task, you will compare the effectiveness of direct and iterative methods for solving a system of linear equations. You will use the solve function for the direct method and the lsolve.jacobi function from the Rlinsolve package for the iterative method. Compare the solutions obtained from both methods to understand their differences and applications.

# Direct solution
direct_solution <- solve(A, b)
print(direct_solution)

# Iterative solution
x0 <- rep(0, 3) # Initial guess
tol <- 1e-5 # Tolerance
max_iter <- 100 # Maximum iterations

iterative_solution <- lsolve.jacobi(A, b, x0, tol, max_iter)
print(iterative_solution$x)

Graph Theory Applications with R

To review the concepts covered in this step, please refer to the Working with Graphs Using Numerical Techniques module of the Solving Problems with Numerical Methods course.

Graph theory is important because it provides tools for modeling relationships between entities, which is essential in various fields such as computer science, biology, and social sciences. This step will explore creating and manipulating graphs using the igraph library in R.

Utilize the igraph library in R to create and analyze graphs. You will practice creating different types of graphs (including, directed, undirected, connected, and disconnected) and apply shortest path algorithms to solve real-world problems. Goal: Understand and apply graph theory concepts using R. Tools: R programming language, igraph library.

Task 4.1: Loading the igraph Library

Before we can start working with graphs in R, we need to ensure that the igraph library is loaded. This will give us access to all the functions necessary for creating and manipulating graphs.

library('igraph')

Task 4.2: Creating an Undirected Graph

Create an undirected graph with 5 nodes and the following edges: (1,2), (2,3), (3,4), (4,5), (5,1). Visualize the graph using the plot() function.

# Create an undirected graph
g <- graph(edge = c(1,2, 2,3, 3,4, 4,5, 5,1), n = 5, directed = FALSE)
# Visualize the graph
plot(g)

Task 4.3: Creating a Directed Graph

Now, create a directed graph using the same nodes and edges as the previous task. Visualize the graph to see the difference.

# Create a directed graph
g_directed <- graph(edge = c(1,2, 2,3, 3,4, 4,5, 5,1), n = 5, directed = TRUE)
# Visualize the graph
plot(g_directed)

Task 4.4: Finding Shortest Path

Find the shortest path between node 1 and node 5 in the directed graph you created earlier. Print the path.

path <- shortest_paths(g_directed, from = 1, to = 5)
print(path)

Task 4.5: Analyzing Graph Connectivity

Check if the directed graph is strongly connected. A graph is strongly connected if there is a path between all pairs of vertices.

# Check if the graph is strongly connected
is_strongly_connected <- is_connected(g_directed, mode = 'strong')
print(is_strongly_connected)

Optimizing the N-Queens Problem with Local Search

To review the concepts covered in this step, please refer to the Implementing Local Search and Optimizations module of the Solving Problems with Numerical Methods course.

Local search algorithms are important because they offer a way to find optimal or near-optimal solutions to complex optimization problems that may not be solvable through traditional methods. This step will focus on applying local search techniques, including simulated annealing and threshold accepting, to solve the N-queens problem.

Implement local search algorithms to find a solution to the N-queens problem in R. You will use stochastic local search, simulated annealing, and threshold accepting algorithms to position N-queens on an NxN chessboard without any attacking each other. Goal: Apply local search algorithms to solve optimization problems. Tools: R programming language.

Task 5.1: Loading the NMOF Package

Before we start implementing local search algorithms, we need to ensure that the necessary R package is loaded. For this lab, we'll be using the NMOF package, which provides functions for numerical optimization, including local search algorithms.

library('NMOF')

Task 5.2: Initializing the Chessboard

To solve the N-queens problem, we first need to initialize a data frame to represent the position of each queen. Create a function named initializeChessboard that takes an integer N as input. The function should return a dataframe with a column called row that ranges from 1:N. The dataframe should also have a column called queen_position that represents the position of each queen on that row. That column can be initialized with NA values. Call the function to initialize an 10x10 chessboard named chessboard.

initializeChessboard <- function(N) {
  data_frame <- data.frame(row = 1:N, queen_position = rep(NA, N))
  return(data_frame)
}
chessboard <- initializeChessboard(8)

Task 5.3: Randomly Placing the Queens

Now that we have a function to initialize the chessboard, the next step is to place the queens on the board. Create a function named placeQueensRandomly that takes the chessboard data frame and the number of queens N as input, and returns the chessboard with N queen placed at a random position in each row. Place 10 queens on chessboard.

placeQueensRandomly <- function(chessboard, N) {
  chessboard$queen_position <- sample.int(N, N, replace = FALSE)
  return(chessboard)
}
chessboard <- placeQueensRandomly(chessboard, 10)

Task 5.4: Visualizing the Chessboard

To better understand the placement of queens on the chessboard, it's helpful to visualize it. Create a function named visualizeChessboard that takes the chessboard data frame as input and prints a visual representation of the chessboard with queens placed on it. Use '_' to represent an empty space and 'Q' to represent a queen.

visualizeChessboard <- function(chessboard) {
  N <- nrow(chessboard)
  for (i in 1:N) {
    row <- rep('_', N)
    row[chessboard$queen_position[i]] <- 'Q'
    cat(paste(row, collapse = '  '))
    cat('\n')
  }
}
visualizeChessboard(chessboard)

Task 5.5: Applying Stochastic Local Search

The provided functions help count the number of attacks and move the queens. Apply local search algorithms to find a solution where no queens attack each other. Use the stochastic local search algorithm. Use the LSopt function from the NMOF package to optimize the placement of queens. Visualize the solved chessboard.

# Provided functions
num_attacks <- function(rand_position) {
  sum(duplicated(rand_position)) + 
    sum(duplicated(rand_position - seq_along(rand_position))) + 
    sum(duplicated(rand_position + seq_along(rand_position)))
}
move_one_queen <- function(rand_position, N=10){
  step <- 4
  i <- sample.int(N, 1)
  
  rand_position[i] <- rand_position[i] + sample(c(1:step, -(1:step)), 1)
  
  if (rand_position[i] > N)
    rand_position[i] <- 1
  else if (rand_position[i] < 1)
    rand_position[i] <- N
  
  rand_position
}

# Solve the N-queens problem
stochastic_local_search <- LSopt(num_attacks, list(x0 = chessboard$queen_position, neighbour = move_one_queen, printBar = TRUE, nS = 10000))

# Use visualizeChessboard to see the result
solved_chessboard <- chessboard
solved_chessboard$queen_position <- stochastic_local_search$xbest
visualizeChessboard(solved_chessboard)

Implementing Integration and Differentiation in R

To review the concepts covered in this step, please refer to the Implementing Integration and Differentiation module of the Solving Problems with Numerical Methods course.

Understanding integration and differentiation is important because these are fundamental concepts in calculus with applications in various fields such as physics, engineering, and economics. This step will cover implementing these concepts in R to solve real-world problems.

Practice calculating derivatives and performing integration in R. You will use R functions to calculate the derivative of a function and integrate functions to find areas under curves or solve differential equations. Goal: Master the concepts of differentiation and integration using R. Tools: R programming language.

Task 6.1: Loading Necessary Libraries

Before we start implementing integration and differentiation in R, let's ensure that the necessary libraries are loaded. For this lab, we will need the mosaic and Deriv libraries. The mosaic library provides functions for mathematical operations, while Deriv allows us to perform symbolic differentiation.

library('mosaic')
library('Deriv')

Task 6.2: Calculating the Derivative

Now that we have the necessary libraries loaded, let's calculate the derivative of a simple function, f(x) = 3x^2 + 2x + 1.

# Define the function
f1 <- function(x) {3 * x^2 + 2 * x + 1}

# Calculate the derivative
f_prime <- Deriv(f1)
print(f_prime)

Task 6.3: Performing Integration

After calculating derivatives, let's move on to integration. Calculate the definite integral of the function f(x) = x^3 - x from x=0 to x=2.

# Define the function
f2 <- function(x) {x^3 - x}

# Perform the integration from x=0 to x=2
result <- integrate(f2, lower = 0, upper = 2)
print(result$value)