R programming tutorials and exercises for data science and mathematics

Generate hours of white, pink and brown noise in R

Sat, 06 Aug 2022 00:00:00 +0000

Many studies suggest that white, pink and brown noise can improve focus, help with relaxation and sleep and even reduce crying in babies. Due to these potential benefits many options are available to generate color noise, including sound machines, phone apps and online clips.

R also provides tools to generate white, pink and brown noise: you can create your own sound clip of a desired length and save it to a local file. A helpful package in this process is tuneR, which offers many useful functions to process and generate sounds and write WAVE files.

Let’s start by loading the tuneR package and setting our default player for WAVE files (on my computer this is aplay):

library(tuneR)
setWavPlayer("aplay")

We can now easily generate multiple types of sounds via the noise function. The code below constructs a Wave object that holds 4 seconds of stereo brown noise:

brown_noise <- noise(kind = "red", duration = 4, xunit = "time", stereo = TRUE)
# kind = "red": brown noise
# kind = "white": white noise
# kind = "pink": pink noise

We can plot the two channels of this Wave object (both channels are generated independently):

plot(brown_noise)

And finally we can play the sound clip directly from R or save it to a local file:

play(brown_noise)
writeWave(brown_noise, filename = "brown_noise_sample.wav")

Pre-recorded loops of white, pink and brown noise

As a bonus I am including a pre-recorded loop for each noise type that you can listen to below and compare (if you are reading this post via RSS feed then visit my original page to access the audio).

White noise loop:
Pink noise loop:
Brown noise loop:

For a full collection of R programming tutorials and exercises visit my website at codeRtime.org and the codeRtime YouTube channel.

How to write insertion sort in R

Thu, 04 Aug 2022 00:00:00 +0000

Getting started with insertion sort

The insertion sort algorithm works by constructing a sorted vector one element at a time:

First element: a vector with one element is already trivially sorted.
Second element: if the second element is less than the first, swap them. We now have an increasing sorted vector of length two.
Third element: perform any necessary swaps to move the third element into the correct position relative to the first to elements. We now have an increasing sorted vector of length three.

This process continues until the entire input vector is fully sorted.

For example, we want to sort the vector 4, 3, 2, 1 in increasing order using insertion sort. The algorithm will perform the following rearrangements of our input:

Input: 4, 3, 2, 1
Intermediary step: 3, 4, 2, 1 (first two elements sorted in increasing order)
Intermediary step: 2, 3, 4, 1 (first three elements sorted in increasing order)
Final step: 1, 2, 3, 4 (all four elements sorted in increasing order)

The insertion sort implementation in R

Let’s write an insertion sort function in R that arranges a numeric vector of two or more elements in increasing order:

insertion_sort <- function(x) {
  # The first loop goes through the elements of x to build a partially sorted vector
  # The first element is already trivially sorted, so we start the index at 2
  for (i in 2:length(x)) {
    # The second loop performs swaps to place the current element in its correct place
    for (j in i:2) {
      if (x[j - 1] > x[j]) {
        tmp <- x[j]
        x[j] <- x[j - 1]
        x[j - 1] <- tmp
      }
    }
  }
  # The sorted vector is returned
  return(x)
}

Testing our insertion sort R program

We can now test our insertion sort function on a few random input vectors:

for (i in 1:4) {
  x <- sample(1:10)
  cat("Input: ", x, "\n")
  cat("Output: ", insertion_sort(x), "\n")
}

## Input:  10 1 3 4 5 2 6 9 7 8 
## Output:  1 2 3 4 5 6 7 8 9 10 
## Input:  6 10 2 7 8 3 4 9 5 1 
## Output:  1 2 3 4 5 6 7 8 9 10 
## Input:  4 3 10 1 9 7 2 6 5 8 
## Output:  1 2 3 4 5 6 7 8 9 10 
## Input:  10 8 3 9 2 5 6 4 1 7 
## Output:  1 2 3 4 5 6 7 8 9 10

All output vectors are sorted in increasing order as expected.

We can also add two lines to our program that print the current state of the vector after each step:

insertion_sort <- function(x) {
  # The first loop goes through the elements of x to build a partially sorted vector
  # The first element is already trivially sorted, so we start the index at 2
  for (i in 2:length(x)) {
    # The second loop performs swaps to place the current element in its correct place
    for (j in i:2) {
      if (x[j - 1] > x[j]) {
        tmp <- x[j]
        x[j] <- x[j - 1]
        x[j - 1] <- tmp
      }
      cat("Swap performed:", x, "\n")
    }
    cat("First", i, "elements are sorted: ", x, "\n")
  }
  # The sorted vector is returned
  return(x)
}

This allows us to track the progress of insertion sort as it orders the input vector:

insertion_sort(c(4, 3, 2, 1))

## Swap performed: 3 4 2 1 
## First 2 elements are sorted:  3 4 2 1 
## Swap performed: 3 2 4 1 
## Swap performed: 2 3 4 1 
## First 3 elements are sorted:  2 3 4 1 
## Swap performed: 2 3 1 4 
## Swap performed: 2 1 3 4 
## Swap performed: 1 2 3 4 
## First 4 elements are sorted:  1 2 3 4

## [1] 1 2 3 4

For a full collection of R programming tutorials and exercises visit my website at codeRtime.org and the codeRtime YouTube channel.

Spirals and trigonometric functions: R exercise #9

Wed, 03 Aug 2022 00:00:00 +0000

Define a one-line R function FUN that provides the following output:

FUN(seq(from = 0, to = 20, by = 0.1))

FUN(seq(from = 0, to = 100, by = 0.1))

FUN(seq(from = 0, to = 200, by = 0.1))

Answer: click to reveal

We can write the function as follows:

  FUN <- function(x) plot(cbind(x * sin(x), x * cos(x)), type = "l", panel.first = grid(), ann = FALSE, col = "red")

This definition uses the functions cos and sin to plot a spiral with the origin at 0 and also adds grid lines consistent with the axis ticks:

  FUN(seq(from = 0, to = 20, by = 0.1))

For a full collection of R programming tutorials and exercises visit my website at codeRtime.org and the codeRtime YouTube channel.

Access and map the latest monkeypox case data in R

Sun, 31 Jul 2022 00:00:00 +0000

The ongoing monkeypox outbreak in many countries outside of the endemic regions in Africa has drawn significant attention over the past months. Government agencies as well as academic and industry teams have released open-access databases to track case numbers over time across different countries and visualizations have been made available to help identify and interpret trends. This sharing of real-time data can help support response efforts by offering insight into the dynamics of this outbreak.

I will talk about some of the currently available monkeypox case databases, with a focus on high-quality resources that are frequently updated and easily imported and processed in R. I will show a few examples of how this information can be mapped and visualized. Overall this article aims to help you get started with your own exploration of the available raw data.

We will use a few R packages to construct choropleth maps:

library(ggplot2)
library(dplyr)
library(maps)
library(viridis)

At the time of writing this article, one of the most comprehensive monkeypox case databases is accessible via the Global.health Monkeypox repository. This resource is updated in near real-time by a team of curators that aggregate data from verified sources including governments, public health organisations and health official statements. You can find more details on their methodology here.

We can load the latest worldwide case data into R directly from the Global.health GitHub repository:

# Read worldwide case data
case_series <- read.csv("https://raw.githubusercontent.com/globaldothealth/monkeypox/main/timeseries-country-confirmed.csv")
head(case_series)

##         Date Cases Cumulative_cases   Country
## 1 2022-07-25     1                1   Andorra
## 2 2022-07-26     2                3   Andorra
## 3 2022-07-27     0                3   Andorra
## 4 2022-07-28     0                3   Andorra
## 5 2022-07-29     0                3   Andorra
## 6 2022-05-27     2                2 Argentina

Each row records the number of cases and cumulative cases for a country at a given date. We also extract data from the maps package for plotting with ggplot2:

world_map <- map_data("world")
head(world_map)

##        long      lat group order region subregion
## 1 -69.89912 12.45200     1     1  Aruba      <NA>
## 2 -69.89571 12.42300     1     2  Aruba      <NA>
## 3 -69.94219 12.43853     1     3  Aruba      <NA>
## 4 -70.00415 12.50049     1     4  Aruba      <NA>
## 5 -70.06612 12.54697     1     5  Aruba      <NA>
## 6 -70.05088 12.59707     1     6  Aruba      <NA>

This table includes latitude and longitude values for the countries that will be represented in our plots. All the information needed to draw geographic maps of case numbers is now ready. Let’s define a function with the following characteristics:

Inputs: date, latitude range, longitude range
Output: map of cumulative case counts on the date provided, bounded by the requested latitude and longitude values

plot_case_map <- function(date, xlim, ylim) {
  # Pre-process case and map data
  case_map <- case_series[which(case_series$Date == date), c(4, 3)]
  colnames(case_map)[1] <- "region"
  case_map$region[which(case_map$region == "United States")] <- "USA"
  case_map$region[which(case_map$region == "United Kingdom")] <- "UK"
  case_map$region[which(case_map$region == "Democratic Republic Of The Congo")] <- "Democratic Republic of the Congo"
  case_map$region[which(case_map$region == "Bosnia And Herzegovina")] <- "Bosnia and Herzegovina"
  if ("Gibraltar" %in% case_map$region) {
    case_map <- case_map[-which(case_map$region == "Gibraltar"), ]
  }
  if (length(setdiff(world_map$region, case_map$region)) > 0) {
    case_map_other <- as.data.frame(cbind(setdiff(world_map$region, case_map$region), NA))
    colnames(case_map_other) <- c("region", "Cumulative_cases")
    case_map <- rbind(case_map, case_map_other)
  }
  case_map$Cumulative_cases <- as.numeric(case_map$Cumulative_cases)
  case_map <- left_join(case_map, world_map, by = "region")

  # Plot case map
  ggplot(case_map, aes(long, lat, group = group)) +
    geom_polygon(aes(fill = Cumulative_cases), color = "white", size = 0.2) +
    scale_fill_viridis_c() +
    theme_linedraw() +
    theme(legend.position = "right") +
    labs(fill = "Cumulative cases") +
    theme(legend.direction = "vertical") +
    coord_map(xlim = xlim, ylim = ylim)
}

We can now plot choropleth maps representing cumulative monkeypox case numbers for given dates and geographic regions:

# Plot world case map as of July 29th 2022:
plot_case_map("2022-07-29", c(-180, 180), c(-55, 90))

Figure 1: World case map on July 29th 2022

# Plot world case map as of May 29th 2022:
plot_case_map("2022-05-29", c(-180, 180), c(-55, 90))

Figure 2: World case map on May 29th 2022

# Plot Europe case map as of July 29th 2022:
plot_case_map("2022-07-29", c(-22, 38), c(35, 64))

Figure 3: Europe case map on July 29th 2022

# Plot Europe case map as of May 29th 2022:
plot_case_map("2022-05-29", c(-22, 38), c(35, 64))

Figure 4: Europe case map on May 29th 2022

A similar map of the latest cumulative monkeypox case numbers in the US can be plotted based on information published and updated regularly by the CDC. The data can be accessed via the “Download Data (CSV)” button at the bottom of the page.

# Download US case data
us_case_map <- read.table("~/Downloads/Monkeypox and Orthopoxvirus Cases in the U.S..csv", header = T, sep = ",")
head(us_case_map)

##        State Cases  Range
## 1    Alabama    16 1 to 2
## 2     Alaska     1 1 to 2
## 3    Arizona    50 1 to 2
## 4   Arkansas     4 1 to 2
## 5 California   799 1 to 2
## 6   Colorado    53 1 to 2

This file contains the latest case numbers for each US state. We can now generate a choropleth map based on this CDC data:

# Pre-process US case and map data
us_map <- map_data("state")
us_case_map <- us_case_map[-which(us_case_map$State %in% c("Alaska", "Hawaii", "Puerto Rico", "Non-US Resident")), -3]
colnames(us_case_map)[1] <- "region"
us_case_map$region <- tolower(us_case_map$region)
if (length(setdiff(us_map$region, us_case_map$region)) > 0) {
  us_case_map_other <- as.data.frame(cbind(setdiff(us_map$region, us_case_map$region), NA))
  colnames(us_case_map_other) <- c("region", "Cases")
  us_case_map <- rbind(us_case_map, us_case_map_other)
}
us_case_map$Cases <- as.numeric(us_case_map$Cases)
us_case_map <- left_join(us_case_map, us_map, by = "region")

# Plot US case map
ggplot(us_case_map, aes(long, lat, group = group)) +
  geom_polygon(aes(fill = Cases), color = "white", size = 0.2) +
  scale_fill_viridis_c() +
  theme_linedraw() +
  theme(legend.position = "right") +
  labs(fill = "Total cases") +
  theme(legend.direction = "vertical")

Figure 5: US case map on July 29th 2022

We can also graph case trends over time for individual countries based on the published Global.health Monkeypox repository data. Let’s define a function that takes a country name as input and plots:

dates on the x-axis
cumulative case counts on the left y-axis in red
daily case counts on the right y-axis in blue

plot_case_series <- function(country) {
  # Plot cumulative case counts in red
  country_series <- case_series[which(case_series$Country == country), ]
  par(oma = c(1, 1, 1, 3))
  plot(country_series$Cumulative_cases, type = "l", xaxt = "n", xlab = NA, main = paste(country, "reported case time series"), ylab = "Cumulative cases", col.lab = "red", col = "red")
  axis(1, at = 1:nrow(country_series), labels = country_series$Date, las = 2, gap.axis = 1, cex.axis = 0.8)

  # Plot daily case counts in blue
  par(new = TRUE)
  plot(country_series$Cases, type = "l", axes = FALSE, xlab = NA, ylab = NA, col = "blue")
  axis(4, at = pretty(range(country_series$Cases)))
  mtext("Cases", side = 4, line = 3, col = "blue")
  grid()
}

We can now use this function to explore case trends for multiple countries:

plot_case_series("Canada")

plot_case_series("United States")

plot_case_series("United Kingdom")

This was a short overview of a few high-quality public databases that aggregate and curate monkeypox case numbers, and we explored some of the options offered by R for custom analyses and visualizations of this raw data.

For a full collection of R programming tutorials and exercises visit my website at codeRtime.org and the codeRtime YouTube channel.

Programming a simple minimax chess engine in R

Sat, 23 Jul 2022 00:00:00 +0000

Why write a chess engine in R?

Chess has always fascinated me. This is a game with simple rules that takes a lot of practice to master. No information is hidden from the players: the game state is clearly visible on the board, but strategies can be complex and subtle. This combination of simple rules and complex strategy becomes very relevant when attempting to write a chess engine. As we will see, a single line of R code is sufficient to implement a program that returns random legal moves. Creating a chess engine that actually plays well is another story.

Powerful chess engines have been developed that can currently defeat most human players. These are highly optimized pieces of software that:

search through the space of available moves very quickly to query positions many moves ahead
often use expert knowledge of the game or pre-computed results to evaluate positions accurately (examples include opening books, endgame databases and evaluation heuristics)
rely on vast amounts of computer resources for training and leverage advanced machine learning models such as neural networks for position evaluation

My goal is not to recreate any of these advanced efforts. This would be unrealistic and, as a casual chess player and avid R programmer, I am more interested to discover the opportunities that R offers around chess. For example, multiple packages are available to plot game positions or to generate lists of legal moves. I am also curious to explore some of the standard algorithms used in chess engines (starting with minimax) and see how simple R implementations of these approaches translate into enjoyable chess games.

In essence, my simple R chess engine should be fun and informative to write and also entertaining to play against as a casual player. It serves as an opportunity to explore an uncommon but fun application of R.

With this introduction let’s dive into the world of R chess!

Getting started: basic chess functions in R and first ‘chess engine’

Before we start implementing any game logic it is important to ensure that some basic chess functionality is available. This includes:

plotting the game board
listing all legal moves for a given position
recognizing when a game is won or drawn

The rchess package provides excellent functions that address these points.

Let’s start a new chess game and plot the board:

# Load the rchess package:
library(rchess)
# Create a new game:
chess_game <- Chess$new()
# Plot the current position:
plot(chess_game)

What moves are available for white? We can get a list of all legal moves via the moves function:

chess_game$moves()

##  [1] "a3"  "a4"  "b3"  "b4"  "c3"  "c4"  "d3"  "d4" 
##  [9] "e3"  "e4"  "f3"  "f4"  "g3"  "g4"  "h3"  "h4" 
## [17] "Na3" "Nc3" "Nf3" "Nh3"

We can pick a move and update the game accordingly:

chess_game$move("e4")
plot(chess_game)

The next player to move is black:

chess_game$turn()

## [1] "b"

and the available moves are:

chess_game$moves()

##  [1] "Nc6" "Na6" "Nh6" "Nf6" "a6"  "a5"  "b6"  "b5" 
##  [9] "c6"  "c5"  "d6"  "d5"  "e6"  "e5"  "f6"  "f5" 
## [17] "g6"  "g5"  "h6"  "h5"

Using the moves function we can already write a first chess engine that returns a random legal move:

# Random move generator for a given position:
get_random_move <- function(chess_game) {
  return(sample(chess_game$moves(), size = 1))
}

We can use this simple function to generate full chess games with both sides played by the computer:

# Set up a new game
chess_game <- Chess$new()

# Perform random legal moves until the game ends in mate or draw
while (!chess_game$game_over()) {
  chess_game$move(get_random_move(chess_game))
}

# Plot the final position
plot(chess_game)

This game ended in a win for white and took only a few seconds to run. We can also get a summary of the board in FEN notation by using the fen function:

chess_game$fen()

## [1] "7N/r1nb4/4kQ2/1p1pP1p1/p1p3p1/1P5P/P1P3P1/R2K1B1R b - - 0 43"

This FEN representation of the game state allows us to easily determine which pieces are still available for each player.

We can also confirm that the game is over, that checkmate occurred and that black is in check:

chess_game$game_over()

## [1] TRUE

chess_game$in_checkmate()

## [1] TRUE

chess_game$in_check()

## [1] TRUE

Improving our chess logic: heuristic position evaluation function

While playing a full random game is surprisingly simple with the help of the rchess package, we would like to start improving our engine in two ways:

Evaluation function: implement a simple heuristic to evaluate individual positions based on the pieces on the board and the safety of the king
Search function: implement an algorithm that allows our engine to search through positions multiple moves ahead

Let’s first work on the position evaluation function, which is usually performed from the perspective of white. More precisely, scores greater than zero indicate an advantage for white and scores less than zero point to an advantage for black. Our scores are based on three aspects of the position being evaluated:

Is this position a win for one of the players or a draw? If white won the score is 1000. If black won the score is -1000. In case of a draw the score in 0.
What is the material advantage for white? Each piece receives a value (9 points for queens, 5 points for rooks, 3 points for bishops and knights and 1 point for pawns) and the total piece value for black is subtracted from the total piece value for white.
If the white king is in check subtract one point from the position score. If the black king is in check add one point to the position score.

This is a fairly standard (although highly simplified) way to define an evaluation function: white will choose moves with high scores and black will prefer moves with low scores. Both players can thus use the same position evaluation function, which simplifies our program.

Let’s implement these simple heuristics in R:

# Position evaluation function
evaluate_position <- function(position) {
  # Test if black won
  if (position$in_checkmate() & (position$turn() == "w")) {
    return(-1000)
  }
  # Test if white won
  if (position$in_checkmate() & (position$turn() == "b")) {
    return(1000)
  }
  # Test if game ended in a draw
  if (position$game_over()) {
    return(0)
  }

  # Compute material advantage
  position_fen <- strsplit(strsplit(position$fen(), split = " ")[[1]][1], split = "")[[1]]
  white_score <- length(which(position_fen == "Q")) * 9 + length(which(position_fen == "R")) * 5 + length(which(position_fen == "B")) * 3 + length(which(position_fen == "N")) * 3 + length(which(position_fen == "P"))
  black_score <- length(which(position_fen == "q")) * 9 + length(which(position_fen == "r")) * 5 + length(which(position_fen == "b")) * 3 + length(which(position_fen == "n")) * 3 + length(which(position_fen == "p"))

  # Evaluate king safety
  check_score <- 0
  if (position$in_check() & (position$turn() == "w")) check_score <- -1
  if (position$in_check() & (position$turn() == "b")) check_score <- 1

  # Return final position score
  return(white_score - black_score + check_score)
}

Applying this function to our previous game we see that it correctly recognizes a win by white by returning a score of 1000:

evaluate_position(chess_game)

## [1] 1000

Improving our chess logic: minimax search

So far we have implemented a function that quantifies whether a given position is advantageous for white or black. The second part of our engine builds on this result and focuses on searching through potential next moves to identify the best choice. We will use an algorithm called minimax to perform this search.

The figure below shows how minimax works on a toy example:

Figure 1: Example of minimax search for the best next move (white to move in the current position)

White starts at the root position and has two move options. For each option, black has two replies available. Figure 1 summarizes this tree of move possibilities and shows the heuristic score for each of the leaf nodes based on the position evaluation function we just defined.

Black will always pick the move that minimizes the heuristic score. In the right branch black will play the move that results in a score of -3, so white can predict that picking the right branch move will lead to a position with score -3. Picking the left branch move however will result in a score of 0, since black cannot capture any material. Based on this reasoning, white will chose the left branch since it leads to a more advantageous outcome even after black plays its best reply.

This minimax strategy is powerful in chess since it looks multiple moves ahead and evaluates positions assuming that each player makes optimal choices. We can also increase the height of this tree: the position evaluation will be more precise since more moves are tested but the runtime will also increase.

Let’s implement this algorithm in R:

# Score position via minimax strategy
minimax_scoring <- function(chess_game, depth) {
  # If the game is already over or the depth limit is reached
  # then return the heuristic evaluation of the position
  if (depth == 0 | chess_game$game_over()) {
    return(evaluate_position(chess_game))
  }

  # Run the minimax scoring recursively on every legal next move, making sure the search depth is not exceeded
  next_moves <- chess_game$moves()
  next_move_scores <- vector(length = length(next_moves))
  for (i in 1:length(next_moves)) {
    chess_game$move(next_moves[i])
    next_move_scores[i] <- minimax_scoring(chess_game, depth - 1)
    chess_game$undo()
  }

  # White will select the move that maximizes the position score
  # Black will select the move that minimizes the position score
  if (chess_game$turn() == "w") {
    return(max(next_move_scores))
  } else {
    return(min(next_move_scores))
  }
}

This completes the minimax_scoring function that returns a score given an input position. Now we just need a wrapper function to evaluate all legal next moves via minimax_scoring and return the optimal choice:

# Select the next move based on the minimax scoring
get_minimax_move <- function(chess_game) {
  # Score all next moves via minimax
  next_moves <- chess_game$moves()
  next_move_scores <- vector(length = length(next_moves))
  for (i in 1:length(next_moves)) {
    chess_game$move(next_moves[i])
    # To ensure fast execution of the minimax function we select a depth of 1
    # This depth can be increased to enable stronger play at the expense of longer runtime
    next_move_scores[i] <- minimax_scoring(chess_game, 1)
    chess_game$undo()
  }

  # For white return the move with maximum score
  # For black return the move with minimum score
  # If the optimal score is achieved by multiple moves, select one at random
  # This random selection from the optimal moves adds some variability to the play
  if (chess_game$turn() == "w") {
    return(sample(next_moves[which(next_move_scores == max(next_move_scores))], size = 1))
  } else {
    return(sample(next_moves[which(next_move_scores == min(next_move_scores))], size = 1))
  }
}

The function get_minimax_move defines the complete logic for our computer chess player. We are now ready to test the performance of our algorithm.

Testing our R minimax chess engine

Let’s first test the performance of our minimax-based chess engine by letting it play 10 games as white and 10 games as black against the random move generator we defined at the beginning of this article. If everything works as expected then our engine should win every time:

# Function that takes a side as input ("w" or "b") and plays 10 games
# The selected side will choose moves based on the minimax algorithm
# The opponent will use the random move generator
play_10_games <- function(minimax_player) {
  game_results <- vector(length = 10)
  for (i in 1:10) {
    chess_game <- Chess$new()
    while (!chess_game$game_over()) {
      if (chess_game$turn() == minimax_player) {
        # Selected player uses the minimax strategy
        chess_game$move(get_minimax_move(chess_game))
      } else {
        # Opponent uses the random move generator
        chess_game$move(get_random_move(chess_game))
      }
    }
    # Record the result of the current finished game
    # If mate: the losing player is recorded
    # If draw: record a 0
    if (chess_game$in_checkmate()) {
      game_results[i] <- chess_game$turn()
    } else {
      game_results[i] <- "0"
    }
  }

  # Print the outcome of the 10 games
  print(table(game_results))
}

White wins every game by playing the minimax strategy against the random move generator:

play_10_games("w")

## game_results
##  b 
## 10

Black also wins every game as the minimax player against random white moves:

play_10_games("b")

## game_results
##  w 
## 10

This simple experiment shows that our minimax chess engine is indeed more powerful than a random move generator, but this is a fairly low bar. I have also tested this program against multiple chess apps and it was able to win games against opponents playing at a casual difficulty level. Increasing the minimax depth leads to stronger play, but evaluating more than four moves in advance was not feasible on my computer due to long runtimes.

Conclusion and next steps

Overall this simple R chess engine is fun to play against for a beginner or casual player, and writing it was a great way to practice the minimax algorithm. Numerous improvements can still be made.

Some updates that I plan to discuss in future posts are:

Implement alpha-beta pruning to decrease the number of positions evaluated by minimax.
Use negamax to further simplify the code.
Leverage neural networks to define a better position evaluation function. The tensorflow and keras R packages make it possible to build very flexible neural networks within R.

Programming a simple chess engine is an exciting journey through the many machine learning capabilities offered by R. Looking forward to the next steps!

For a full collection of R programming tutorials and exercises visit my website at codeRtime.org and the codeRtime YouTube channel.

How to write bubble sort in R

Sat, 25 Jun 2022 00:00:00 +0000

Topics covered: number operations, vector operations, sorting algorithms

Getting started

The bubble sort algorithm works by swapping neighboring entries of an input vector if they are not in the desired order. This process is repeated until no more swaps are necessary: the vector is already sorted.

For example, we want to sort the vector 4, 3, 2, 1 in increasing order using bubble sort. The algorithm will perform the following rearrangements of our input:

Input: 4, 3, 2, 1
Intermediary step (first pass through the vector): 3, 4, 2, 1
Intermediary step (first pass through the vector): 3, 2, 4, 1
Intermediary step (first pass through the vector): 3, 2, 1, 4
Intermediary step (second pass through the vector): 2, 3, 1, 4
Intermediary step (second pass through the vector): 2, 1, 3, 4
Final step (third pass through the vector): 1, 2, 3, 4

The bubble sort implementation

Let’s write a bubble sort function in R that arranges a numeric vector of two or more elements in increasing order:

# Input: numeric vector of two or more elements
bubble_sort <- function(x) {
  swap_performed <- TRUE
  # Repeat the algorithm until no more swaps are performed
  while (swap_performed) {
    swap_performed <- FALSE
    # Check if any swaps are necessary
    for (i in 1:(length(x) - 1)) {
      if (x[i] > x[i + 1]) {
        # Swap elements that are not in increasing order
        tmp <- x[i]
        x[i] <- x[i + 1]
        x[i + 1] <- tmp
        # Now record that a swap was performed
        # This requests another pass through the while loop
        swap_performed <- TRUE
      }
    }
  }
  # Output: the vector sorted in increasing order
  return(x)
}

Testing our implementation

We can now test our bubble sort function on a few random input vectors:

for (i in 1:4) {
  x <- sample(1:10)
  cat("Input: ", x, "\n")
  cat("Output: ", bubble_sort(x), "\n")
}

## Input:  5 10 8 9 2 6 4 1 7 3 
## Output:  1 2 3 4 5 6 7 8 9 10 
## Input:  6 4 9 2 5 7 10 8 1 3 
## Output:  1 2 3 4 5 6 7 8 9 10 
## Input:  9 3 6 10 8 7 2 4 5 1 
## Output:  1 2 3 4 5 6 7 8 9 10 
## Input:  10 3 2 4 9 1 7 5 6 8 
## Output:  1 2 3 4 5 6 7 8 9 10

All output vectors are sorted in increasing order as expected.

We can also add a line to our program that prints the current state of the vector after each swap:

# Input: numeric vector of two or more elements
bubble_sort <- function(x) {
  swap_performed <- TRUE
  # Repeat the algorithm until no more swaps are performed
  while (swap_performed) {
    swap_performed <- FALSE
    # Check if any swaps are necessary
    for (i in 1:(length(x) - 1)) {
      if (x[i] > x[i + 1]) {
        # Swap elements that are not in increasing order
        tmp <- x[i]
        x[i] <- x[i + 1]
        x[i + 1] <- tmp
        # Now record that a swap was performed
        # This requests another pass through the while loop
        swap_performed <- TRUE
        # Print the current state of our vector
        cat("Current state: ", x, "\n")
      }
    }
  }
  # Output: the vector sorted in increasing order
  return(x)
}

This allows us to track the progress of bubble sort as it orders the input vector:

bubble_sort(c(1, 3, 5, 2, 4, 6))

## Current state:  1 3 2 5 4 6 
## Current state:  1 3 2 4 5 6 
## Current state:  1 2 3 4 5 6

## [1] 1 2 3 4 5 6

For a full collection of R programming tutorials and exercises visit my website at codeRtime.org and the codeRtime YouTube channel.

Exercise 8: recursive functions in R

Mon, 20 Jun 2022 00:00:00 +0000

The recursive R function FUN is defined as:

FUN <- function(x) {
  if (x == 0 | x == 1) {
    return(x)
  } else {
    return(FUN(x - 1) + FUN(x - 2))
  }
}

What is the value of x that leads to the following output:

FUN(x)

## [1] 6765

Answer: click to reveal

To help answer this question we first notice that the recursive function FUN defines the Fibonacci sequence. So we are searching for an integer x >= 0 that corresponds to the Fibonacci number 6765. To solve the puzzle we can either look up the first few terms of the Fibonacci sequence or use our function definition to run through some inputs.

To avoid calling FUN manually for different values we can define a vectorized version of the function and run it on the integer inputs between 0 and 20:

  vector_FUN <- Vectorize(FUN)
  vector_FUN(0:20)

  ##  [1]    0    1    1    2    3    5    8   13   21   34
  ## [11]   55   89  144  233  377  610  987 1597 2584 4181
  ## [21] 6765

The answer we get is x = 20:

  x <- 20
  FUN(x)

  ## [1] 6765

For a full collection of R programming tutorials and exercises visit my website at codeRtime.org and the codeRtime YouTube channel.

Exercise 7: R string processing

Sun, 05 Jun 2022 00:00:00 +0000

Find a function FUN that leads to the following output:

FUN("mile")

## [1] "e" "i" "l" "m"

FUN("lime")

## [1] "e" "i" "l" "m"

FUN("camel")

## [1] "a" "c" "e" "l" "m"

FUN(paste(sample(letters), collapse = ""))

##  [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m"
## [14] "n" "o" "p" "q" "r" "s" "t" "u" "v" "w" "x" "y" "z"

Hint: aim to keep the answer simple. The main logic of the function can often be summarized in a single line of R code.

Answer: click to reveal

We can write the function as follows:

  FUN <- function(x) {
    return(sort(strsplit(x, split = "")[[1]]))
  }

This function splits the input string into single characters and then performs an alphabetical sort. For example:

  x <- "camel"
  strsplit(x, split = "")

  ## [[1]]
  ## [1] "c" "a" "m" "e" "l"

  sort(strsplit(x, split = "")[[1]])

  ## [1] "a" "c" "e" "l" "m"

For a full collection of R programming tutorials and exercises visit my website at codeRtime.org and the codeRtime YouTube channel.

Beginner R lesson: arithmetic operations (part 1)

Fri, 03 Jun 2022 00:00:00 +0000

Topics covered: number operations, defining and using variables

Getting started

We start our programming journey by exploring how R lets us perform numerical calculations. We will first review some practical aspects relating to syntax and then dive into multiple example programs that provide a deeper insight into the language and R’s powerful number-crunching abilities.

Working with numbers is an essential part of many programs that we will create and showcases some basic syntax and functionality built into the R language. This lesson does not require any prior knowledge of R and is designed as a first contact with the language, so let’s dive in!

At a fundamental level R can serve as a powerful interactive calculator and the syntax we use for most arithmetic operations is fairly intuitive:

Addition and subtraction:

99 + 1

## [1] 100

101 - 1

## [1] 100

Multiplication and division:

100 * 2

## [1] 200

100 / 3

## [1] 33.33333

Powers:

10^2

## [1] 100

Parentheses to define the order of operations:

(99 + 1) / 2

## [1] 50

We can also define variables that store numerical or other types of data via an assignment operator:

a <- 100
a

## [1] 100

b <- 100 / 2
b

## [1] 50

Arithmetic operations can now be run using the variables we defined:

a + b

## [1] 150

a^b

## [1] 1e+100

We can also test whether two numbers are equal, which will be helpful in future lessons:

## [1] 100

## [1] 50

a == b

## [1] FALSE

a == b * 2

## [1] TRUE

Throughout this lesson we will also include comments in our code to clarify intended functionality and make the programs more easily readable. Everything in a line after the # symbol will be treated by R as a comment and will not be executed:

# This is a comment
10^2 + 10^1 + 10^0 # The code before this comment will execute

## [1] 111

The concepts presented so far will serve as basic building blocks for more complex programs. Let’s see these topics in action by working through some examples.

Practice: computing sums of consecutive integers

Many mathematical formulas have been constructed around sums of integer numbers. One such formula computes the sum of all integers between 1 and any integer n greater than or equal to 1:

1 + … + n = n(n+1)/2 for any integer n >= 1.

Let’s use R to implement and test this formula for a few values of n:

n <- 10
# Compute sum via formula:
n * (n + 1) / 2

## [1] 55

# Compute sum by explicit addition:
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10

## [1] 55

As expected, computing this sum by explicitly adding each number together gives us the same answer as using the formula. We can also formally test if the outputs are equal without even looking at the actual results:

n * (n + 1) / 2 == 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10

## [1] TRUE

Now that we have implemented this formula in R we can easily compute sums for new values of n:

n <- 100
n * (n + 1) / 2

## [1] 5050

n <- 1000
n * (n + 1) / 2

## [1] 500500

Re-using the formula for different values of n is much easier and less error-prone than writing out the whole sum term by term, especially if n becomes large, but formulas are not always available to simplify repetitive computations. We will see in future lessons that R offers powerful ways to enable such tasks through loops and vector operations.

For a full collection of R programming tutorials and exercises visit my website at codeRtime.org and the codeRtime YouTube channel.

Exercise 6: R numeric calculations

Thu, 02 Jun 2022 00:00:00 +0000

Find a function FUN that leads to the following output:

curve(FUN, from = -2, to = 2, n = 1000)
grid()

Hint: aim to keep the answer simple. The main logic of the function can often be summarized in a single line of R code.

Answer: click to reveal

We can write the function as follows:

  FUN <- function(x) {
    return(abs(x) %% 1)
  }

This function returns the fractional part of the absolute value of its input. For example:

  FUN(12.345)

  ## [1] 0.345

  FUN(-0.1234)

  ## [1] 0.1234

FUN can be defined equivalently as:

  FUN <- function(x) {
    return(abs(x) - floor(abs(x)))
  }

To check that this function is indeed a solution to the puzzle we can redraw the plot:

  curve(FUN, from = -2, to = 2, n = 1000)
  grid()

For a full collection of R programming tutorials and exercises visit my website at codeRtime.org and the codeRtime YouTube channel.

Exercise 5: R matrix operations

Wed, 01 Jun 2022 00:00:00 +0000

Find a function FUN that leads to the following output:

a <- matrix(1:36, nrow = 6)
b <- matrix(1:25, nrow = 5)
a

##      [,1] [,2] [,3] [,4] [,5] [,6]
## [1,]    1    7   13   19   25   31
## [2,]    2    8   14   20   26   32
## [3,]    3    9   15   21   27   33
## [4,]    4   10   16   22   28   34
## [5,]    5   11   17   23   29   35
## [6,]    6   12   18   24   30   36

FUN(a)

## [1] 16 17 18 19 20 21

##      [,1] [,2] [,3] [,4] [,5]
## [1,]    1    6   11   16   21
## [2,]    2    7   12   17   22
## [3,]    3    8   13   18   23
## [4,]    4    9   14   19   24
## [5,]    5   10   15   20   25

FUN(b)

## [1] 11 12 13 14 15

Hint: aim to keep the answer simple. The main logic of the function can often be summarized in a single line of R code.

Answer: click to reveal

We can write the function as follows:

  FUN <- function(x) {
    return(apply(x, MARGIN = 1, FUN = median))
  }

This function computes the median for each row of the input matrix.

For a full collection of R programming tutorials and exercises visit my website at codeRtime.org and the codeRtime YouTube channel.

Exercise 4: R trigonometric functions

Tue, 31 May 2022 00:00:00 +0000

Find a function FUN that leads to the following output:

curve(FUN, from = -10, to = 10, col = "red", ylim = c(-2, 2))
curve(sin, add = TRUE)
grid()

Hint: aim to keep the answer simple. The main logic of the function can often be summarized in a single line of R code.

Answer 1: click to reveal

We can write the function as follows:

  FUN <- function(x) {
    return(sin(x + pi / 2))
  }

We then get:

  curve(FUN, from = -10, to = 10, col = "red", ylim = c(-2, 2))
  curve(sin, add = TRUE)
  grid()

Answer 2: click to reveal

We can use various trigonometric identities to derive more solutions to this puzzle. For example:

sin(x + pi/2) = cos(x)

FUN can then be defined as:

  FUN <- function(x) {
    return(cos(x))
  }

We can confirm that this function solves the puzzle:

  curve(FUN, from = -10, to = 10, col = "red", ylim = c(-2, 2))
  curve(sin, add = TRUE)
  grid()

For a full collection of R programming tutorials and exercises visit my website at codeRtime.org and the codeRtime YouTube channel.

Exercise 3: R numeric calculations

Mon, 30 May 2022 00:00:00 +0000

Find a function FUN that leads to the following output:

FUN(pi) - FUN(exp(1))

## [1] 1

Hint: aim to keep the answer simple. The main logic of the function can often be summarized in a single line of R code.

Answer: click to reveal

We can write the function as follows:

  FUN <- function(x) {
    return(floor(x))
  }

The R function floor returns the largest integer not greater than the input argument:

pi

  ## [1] 3.141593

  FUN(pi)

  ## [1] 3

  exp(1)

  ## [1] 2.718282

  FUN(exp(1))

  ## [1] 2

For a full collection of R programming tutorials and exercises visit my website at codeRtime.org and the codeRtime YouTube channel.

Exercise 2: R vector operations

Sun, 29 May 2022 00:00:00 +0000

Find a function FUN that leads to the following output:

x <- sample(1:10)
FUN(x) - FUN(-x)

##  [1] 11 11 11 11 11 11 11 11 11 11

Hint: aim to keep the answer simple. The main logic of the function can often be summarized in a single line of R code.

Answer 1: click to reveal

We can write the function as follows:

  FUN <- function(x) {
    return(sort(x))
  }

Based on this definition of FUN we get:

  FUN(x)

  ##  [1]  1  2  3  4  5  6  7  8  9 10

  FUN(-x)

  ##  [1] -10  -9  -8  -7  -6  -5  -4  -3  -2  -1

which fulfills the puzzle condition:

  FUN(x) - FUN(-x)

  ##  [1] 11 11 11 11 11 11 11 11 11 11

Answer 2: click to reveal

Another possible definition of FUN that builds on Puzzle 1 is:

  FUN <- function(x) {
    return(rep(max(x), times = length(x)))
  }

Based on this definition of FUN we get:

  FUN(x)

  ##  [1] 10 10 10 10 10 10 10 10 10 10

  FUN(-x)

  ##  [1] -1 -1 -1 -1 -1 -1 -1 -1 -1 -1

which fulfills the puzzle condition:

  FUN(x) - FUN(-x)

  ##  [1] 11 11 11 11 11 11 11 11 11 11

As we have seen in exercise 1 the max can also be replaced with min and the result still holds:

  FUN <- function(x) {
    return(rep(min(x), times = length(x)))
  }
  FUN(x) - FUN(-x)

  ##  [1] 11 11 11 11 11 11 11 11 11 11

For a full collection of R programming tutorials and exercises visit my website at codeRtime.org and the codeRtime YouTube channel.

Exercise 1: R vector operations

Sat, 28 May 2022 00:00:00 +0000

Find a function FUN that leads to the following output:

x <- 1:10
FUN(x) - FUN(-x)

## [1] 11

Hint: aim to keep the answer simple. The main logic of the function can often be summarized in a single line of R code.

Answer 1: click to reveal

We can write the function as follows:

  FUN <- function(x) {
    return(max(x))
  }

Based on this definition of FUN we get:

  FUN(x)

  ## [1] 10

  FUN(-x)

  ## [1] -1

We finally confirm that this function solves the puzzle:

  FUN(x) - FUN(-x)

  ## [1] 11

Answer 2: click to reveal

Another solution to this puzzle is:

  FUN <- function(x) {
    return(min(x))
  }

Based on this definition of FUN we get:

  FUN(x)

  ## [1] 1

  FUN(-x)

  ## [1] -10

We confirm that this function solves the puzzle:

  FUN(x) - FUN(-x)

  ## [1] 11

For a full collection of R programming tutorials and exercises visit my website at codeRtime.org and the codeRtime YouTube channel.