Introducing the nascent R package {blimey} (repository). At this stage it contains only the following data:

• railways— latitude and longitude segments along railway lines (wide format);
• railways_pivot— latitude and longitude segments along railway lines (long format); and
• railway_stations— codes, names and locations of railway stations.

Load a couple of core packages.

library(dplyr)library(ggmap)

Load the {blimey} package.

library(blimey)

Let’s take a look at the railways data.

head(railways)# A tibble: 6 × 7    fid elr    trid lat_start lat_end lon_end lon_start  <dbl> <chr> <dbl>     <dbl>   <dbl>   <dbl>     <dbl>1     0 MLN3   1100      50.3    50.3   -5.06     -4.832     1 SDS    3100      50.3    50.3   -4.83     -4.833     2 MLN3   1600      50.3    50.3   -5.07     -5.074     3 MLN4   3700      50.2    50.2   -5.45     -5.455     4 MLN4   3601      50.1    50.1   -5.53     -5.536     5 MLN4   1100      50.2    50.1   -5.50     -5.45

We’re going to plot those data out on a map. Define the bounding box for the map.

bb <- c(left = -8, bottom = 49.80, right = 3, top = 59.50)

Use {ggmap} to load Stamen Map tiles for the toner lite map.

map_toner <- get_stamenmap(bb, zoom = 8, maptype = "toner-lite")

Define some colours for plotting the lines and stations.

COLOUR_MUTED_BLUE <- "#1f77b4"COLOUR_SAFETY_ORANGE <- "#ff7f0e"

Create a function which will tweak the map appearance.

theme_map <- function(plot) {  plot +   coord_map() +  scale_x_continuous(expand = expansion(0, 0)) +  scale_y_continuous(expand = expansion(0, 0)) +  theme(    legend.position = "none",    axis.title = element_blank(),    axis.text = element_blank(),    axis.ticks = element_blank(),    text = element_text(size = 12)  )}

Show the railway line segments over the toner lite map.

map <- ggmap(map_toner, extent = "normal") +  geom_segment(    data = railways,    aes(      x = lon_start,      y = lat_start,      xend = lon_end,      yend = lat_end,    ),    size = 1, alpha = 0.5, col = COLOUR_MUTED_BLUE  )(map <- theme_map(map))

Now add in the railway stations.

(ggmap(map_toner, extent = "normal") +  geom_segment(    data = railways,    aes(      x = lon_start,      y = lat_start,      xend = lon_end,      yend = lat_end    ),    size = 2, alpha = 0.5, col = COLOUR_MUTED_BLUE  ) +  geom_point(    data = railway_stations,    aes(      x = lon,      y = lat    ),    size = 2, alpha = 0.5, col = COLOUR_SAFETY_ORANGE  )) %>%  theme_map()

The maps are fairly large. Open them in a separate tab so that you can zoom in on the details.

After a long run in the Forest of Bowland when visiting Lancaster for a few days, I decided to try out the {rStrava} package to make some maps of where I’d been. This tutorial blog will walk through the process of getting the data from Strava, making the map, and animating it with {gganimate}.

Last week's route mapped out in #rstats using {rStrava} and {gganimate}https://t.co/O510G8E6hrpic.twitter.com/WgUAFV6eFA

— Nicola Rennie (@nrennie35) July 15, 2022

What is {rStrava}?

Strava is a an app for tracking physical activities, mostly used for running and cycling. The {rStrava} package lets you access data through the Strava API.

Since {rStrava} is available on CRAN, you can install it in the usual way using:

install.packages("rStrava")library(rStrava)

There are two levels of data you can get using {rStrava} depending on whether or not you have an authentication token. If you don’t have a token, you can access some basic summary information on athletes with public profiles and their recent activities. You don’t even need a Strava account to access this data. You can see which functions don’t require a token by running:

help.search('notoken', package = 'rStrava')

However, if you want detailed data on your activities or if your profile is private (like mine) you need an authentication token to get the data into R. To get an authentication token you do need a Strava account of your own. The instructions on the {rStrava} README are pretty easy to follow to set up your authentication token.

Setting up an authentication token

On the Strava website, in the settings, you can make an API application. There are three pieces of information you need to fill out:

• Application Name: the name of your app (this can be almost anything). I used the blog title.
• Website: Must be a valid URL, but can otherwise be pretty much anything.
• Authorization Callback Domain: change to localhost or any domain. If deploying an app that uses the Strava API, you’ll need to update this.

After you click “Create”, you’ll be prompted to upload an icon (can be any image), and this will generate a token for you.

Now, you need to add this token into R. You can do this using the config() function from {httr}, and the strava_oauth() function from {rStrava}. The strava_oauth() function needs four pieces of information, all provided as character strings.

strava_token <- httr::config(token = strava_oauth(app_name,                                                  app_client_id,                                                  app_secret,                                                  app_scope = "activity:read_all"))

The app_name is the name you gave to the app when making your token on the Strava website. The app_client_id and app_secret were generated after you clicked “Create” on the Strava website, and you can simply pass these in. You will also perhaps want to change the app_scope argument. By default, this is set to "public", but you may want to get information on your activities which are not public. You can save the token as a variable, to pass into the {rStrava} functions. I’ve called it strava_token.

Reading in the data

With the authentication token set you can now begin to get data into R, directly from the Strava API. First of all, I grabbed the data on my activities using the get_activity_list() function, for which I need to pass in my Strava token. I then use the get_activity_streams() function to get detailed information on a specific activity. Here the id is the activity id i.e., the number that comes at the end of the URL string for the activity: https://www.strava.com/activities/{id}.

my_acts <- get_activity_list(strava_token) id = {id}strava_data <- get_activity_streams(my_acts,                                    strava_token,                                    id = id)

This is what the output of strava_data looks like:

  altitude cadence distance grade_smooth heartrate      lat       lng moving time velocity_smooth         id1     24.8      84   0.0027          2.0       105 54.04575 -2.798552  FALSE    0          0.0000 74192251872     24.9      85   0.0066          1.3       112 54.04572 -2.798607   TRUE    3          4.6548 74192251873     24.9      85   0.0078          1.0       117 54.04572 -2.798626   TRUE    4          4.5180 74192251874     24.9      86   0.0078          0.8       117 54.04570 -2.798638  FALSE    5          3.6144 74192251875     24.9      86   0.0102          0.9       118 54.04567 -2.798653   TRUE    6          4.4892 74192251876     24.9      85   0.0130          1.1       119 54.04565 -2.798678   TRUE    7          5.2812 7419225187

There are some nice built-in mapping functions in {rStrava} that I recommend checking out, but since I’m going to build my own here, I don’t need to use {rStrava} again. I saved the data as a CSV file so that I could go back and work on it again without having to re-download it using {rStrava}.

write.csv(strava_data, "strava_data.csv", row.names = F)

Data wrangling

The data the comes out of the get_activity_streams() function is already very clean, so the data wrangling for this example is very minimal. In fact, I only used two functions, neither of which was really necessary. I converted the data frame to a tibble using as_tibble() because I prefer working with tibbles. Since all the data is for a single activity in this case, the id column is a bit redundant so I also used select() from {dplyr} to remove the id column.

library(tidyverse)strava_data %>%   as_tibble() %>%   select(-id)

Background maps

Now it’s finally time to start building a map! Here, I loaded the rest of the R packages I’ll be using for mapping and animating.

library(sf)library(ggmap)library(osmdata)library(rcartocolor)library(gganimate)

Here, {sf} isn’t technically necessary but useful if you want to make a geometry object in R (more on that later). {ggmap} and {osmdata} are used for creating a background map. {ggplot2} has already been loaded eariler with the rest of the tidyverse, and along with {rcartocolor} for a nice colour scheme, this will plot the main map. Then, {gganimate} is used for animating the map.

Before I actually mapped my run, I wanted to get a background map. I used the getbb() (bounding box) function from {osmdata} to get the approximate coordinates around where I started my run using the place name as input.

getbb("Lancaster, UK")        min       maxx -2.983647 -2.458735y 53.918066 54.239557

I then played around to get the exact rectangle I wanted, and specified it manually. Now, bb specifies the minimum and maximum latitude and longitude of where my background map should cover.

bb <- matrix(c(-2.9, -2.53, 53.95, 54.10),              ncol = 2,              nrow = 2,             byrow = TRUE,             dimnames = list(c("x", "y"), c("min", "max")))

This bounding box can be passed into get_map() from {ggmap} to get the background map. By default, {ggmap} uses Google Maps, for which an API key is required. Setting the source = "stamen" means that you don’t have to register a Google API key. You can also choose a maptype, and here I chose "toner-hybrid". I’d recommend playing around with the different types to see which one you like - use ?get_map() for a list of options. You can also choose whether or not you want a colour or black and white background. I opted for a black and white ("bw") background map, as I later found it difficult to get enough contrast between my data points and the background map otherwise.

bg_map <- get_map(bb,                  source = "stamen",                  maptype = "toner-hybrid",                   color = "bw")

The background map can be visualised using ggmap().

ggmap(bg_map)

Overlaying the activity data

I’m simply going to use {ggplot2} to overlay the data in strava_data on top of my background map. Using {ggplot2}, there are (at least) two different ways we could add the data: either using geom_point() or geom_sf(). We’ll start with geom_point().

g <- ggmap(bg_map) +     geom_point(data = strava_data,                inherit.aes = FALSE,                aes(x = lng,                     y = lat,                     colour = altitude),                  size = 1)

Here, we specify strava_data as the data argument in geom_point(). Note that there is no ggplot() call here, as it’s hidden inside the ggmap() function. Therefore, we also want to specify inherit.aes = FALSE to make sure that the hidden aesthetics carried through by ggmap() don’t interfere with our point data. I specify the x and y coordinates as the longitude and latitude, respectively, and colour the points based on the altitude. I also played around with the size of the points until it looked the way I wanted it to. Note that, alternatively you could use geom_line() in exactly the same way.

Since, longitude and latitude are geographic data, it may make sense to instead convert them to a geometry object using the {sf} package. This may be necessary if your background map and coordinate data use different coordinate systems. In this case, it doesn’t actually matter. But I’ll show you anyway, just in case you need it. First, we convert our strava_data tibble into an sf object using st_as_sf(). We also specify which columns from strava_data are the longitude and latitude, with the longitude column coming first. We set the coordinate reference system (crs) as 4326 to match the coordinate system used. Setting remove = FALSE also keeps the original latitude and longitude columns in the tibble, even after converting to an sf object.

strava_sf <- st_as_sf(strava_data,                      coords = c("lng", "lat"),                      crs = 4326,                      remove = FALSE)

The strava_sf object is now an sf object so it can be used with geom_sf() instead of geom_point(). Here, we don’t need to specify the x and y aesthetics as they are automatically detected from the sf object. You may get a Coordinate system already present. Adding new coordinate system, which will replace the existing one. warning. This is because geom_sf() and ggmap() are both trying to set the (same) coordinate system.

g <- ggmap(bg_map) +     geom_sf(data = strava_sf,             inherit.aes = FALSE,             aes(colour = altitude),              size = 1) g

The maps returned using geom_point() and geom_sf() are essentially the same in this case.

Styling the map

The inital map looks okay, but we can add some styling to make it look better. I’m a big fan of {rcartocolor} for colour palettes. I can get the hex codes of the "SunsetDark" palette, and use the same hex codes for the title font later.

my_colors <- carto_pal(7, "SunsetDark")my_colors

I change the colour of my points using scale_colour_carto_c() from {rcartocolor}, and change the title that appears in the legend at the same time. I also add a caption using the labs() function. Finally, I edit the theme. The theme_void() function is really useful for maps because it removes most of the theme elements which aren’t very useful on maps like this e.g. axis labels, axis ticks, grid lines. I use the theme() function to bring the legend and the plot caption (used as a title here) inside the plot area. This create a little bit of white space at the bottom of the plot, so I remove it using plot.margin. I also edit the colour and size of the caption text.

g <- g +   scale_colour_carto_c(name = "Altitude (m)", palette = "SunsetDark") +  labs(caption = "Lancaster - Forest of Bowland ") +  theme_void() +  theme(legend.position = c(0.85, 0.7),         legend.title = element_text(face = "bold", hjust = 0.5),         plot.caption = element_text(colour = "#dc3977", face = "bold", size = 16,                                     vjust = 10),         plot.margin = unit(c(0, 0, -0.75, 0), unit = "cm"))g

Animating with {gganimate}

I was pretty happy with the final static image, but why not animate it? {gganimate} makes it really easy to animate ggplot objects. For this example, I’d strongly recommend using the geom_point() version of the map.

g <- ggmap(bg_map) +  geom_point(data = strava_data,          inherit.aes = FALSE,          aes(colour = altitude,               x = lng,               y = lat),           size = 1) +   scale_colour_carto_c(name = "Altitude (m)", palette = "SunsetDark") +  labs(caption = "Lancaster - Forest of Bowland ") +  theme_void() +  theme(legend.position = c(0.85, 0.7),         axis.title = element_blank(),         legend.title = element_text(face = "bold", hjust = 0.5),         plot.caption = element_text(colour = "#dc3977", face = "bold", size = 16,                                     vjust = 10),         plot.margin = unit(c(0, 0, -0.75, 0), unit = "cm"))

Although you can animate plots with sf data using {gganimate}, it’s a little bit trickier and it takes longer to render. So why not make our lives a little easier? There are two functions we need to animate our map:

• transition_time() specifies which variable in strava_data we want to animate over.
• shadow_mark() means the animation plots points cumulatively over time rather than just plotting a single point for each time.

g = g +   transition_time(time = time) +  shadow_mark()

The animate() function then actually builds the animation. Usually renderer = gifski_renderer() should be the default, but I kept getting individual images instead of a gif unless I specified it manually - to investigate later. Here, I also specified the width and height (using a little bit of trial and error to avoid white space caused by the fixed ratio from ggmap()). anim_save() then saves the gif to a file (analogously to ggsave() from {ggplot2}).

animate(g, renderer = gifski_renderer(), height = 372, width = 538, units = "px")anim_save("mapping_marathon.gif")

And that’s it! You now have an animated map of your Strava recorded run (or cycle, or walk, or …)! If you want to create a map of your own, you can find the R code used in this blog on my website. Thanks very much to the creators of {rStrava} for such an easy to use package!

Tweet

An xlsx is a file format used for Microsoft Excel spreadsheets. Excel can be used to store tabular data.

R has built-in functionality that makes it easy to read and write an xlsx file.

Sample xlsx File

To demonstrate how we read xlsx files in R, let's suppose we have an excel file named studentinfo.xlsx with the following data:

We will be reading these data with the help of R's built-in functions.

Install and Load xlsx Package

In order to read, write, and format Excel files into R, we first need to install and load the xlsx package as:

# install xlsx package 
install.package("xlsx")

# load xlsx file
library("xlsx")

Here, we have successfully installed and loaded the xlsx package.

Now, we are able to read data from an xlsx file.

Read an xlsx File in R

In R, we use the read.xlsx() function to read an xlsx file available in our current directory. For example,

# install xlsx package 
install.package("xlsx")

# load xlsx file
library("xlsx")

# read studentinfo.xlsx file from our current directory
read_data <- read.xlsx("studentinfo.xlsx", sheetIndex = 1)

# display xlsx file
print(read_data)

Output

      Name      Age   Faculty           State
1    Abby       24     Business         Florida
2    Hazzle     23     Engineering      Arizona
3    Cathy      20     Engineering      Colorado
4    Paterson   22     Arts             Texas
5    Sammy      20     Economics        Ohio
6    Pam        21     Arts             Arizona

In the above example, we have read the studentinfo.xlsx file that is available in our current directory. Notice the code,

read_data <- read.xlsx("studentinfo.xlsx", sheetIndex = 1)

Here,

• read.xlsx() - reads the xlsx file studentinfo.xlsx and creates a dataframe that is stored in the read_data variable.
• sheetIndex = 1 - reads specified worksheet i.e. 1

xlsx rowIndex and colIndex Argument in R

In R, we can also read a specific range of data from excel files. We can pass the rowIndex and colIndex argument inside read.xlsx() to read specific range.

• rowIndex - reads a specific range of rows
• colIndex - read a specific range of columns

Example: Read Range of Rows

# install xlsx package 
install.package("xlsx")

# load xlsx file
library("xlsx")

# read first five rows of xlsx file
read_data <- read.xlsx("studentinfo.xlsx", 
  sheetIndex = 1,
  rowIndex = 1:5
)

# display xlsx file
print(read_data)

Output

      Name      Age   Faculty           State
1    Abby       24     Business         Florida
2    Hazzle     23     Engineering      Arizona
3    Cathy      20     Engineering      Colorado
4    Paterson   22     Arts             Texas

In the above example, we have passed rowIndex = 1:5 inside read.xlsx() so the function reads only the first five rows from the studentinfo.xlsx file.

Example: Read Range of Columns

# install xlsx package 
install.package("xlsx")

# load xlsx file
library("xlsx")

# read first three columns of xlsx file
read_data <- read.xlsx("studentinfo.xlsx", 
  sheetIndex = 1,
  colIndex = 1:3
)

# display xlsx file
print(read_data)

Output

      Name      Age   Faculty           
1    Abby       24     Business         
2    Hazzle     23     Engineering   
3    Cathy      20     Engineering    
4    Paterson   22     Arts                
5    Sammy      20     Economics      
6    Pam        21     Arts                

Here, colIndex = 1:3 inside read.xlsx() reads only the first three columns from the studentinfo.xlsx file.

xlsx startRow Argument in R

Sometimes the excel file may contain headers at the beginning that we may not want to include. For example,

Here, the 1st Row of the excel file contains a header, and the 2nd row is empty. So we don't want to include these two rows.

To start reading data from a specific row in the excel worksheet, we pass the startRow argument inside read.xlsx().

Let's take a look at an example,

# install xlsx package 
install.package("xlsx")

# load xlsx file
library("xlsx")

# start reading from 3rd row
read_data <- read.xlsx("studentinfo.xlsx", 
  sheetIndex = 1,
  startRow = 3
)

# display xlsx file
print(read_data)

Output

      Name      Age   Faculty           State
1    Abby       24     Business         Florida
2    Hazzle     23     Engineering      Arizona
3    Cathy      20     Engineering      Colorado
4    Paterson   22     Arts             Texas
5    Sammy      20     Economics        Ohio
6    Pam        21     Arts             Arizona

In the above example, we have used the startRow argument inside the read.xlsx() function to start reading from the specified row.

startRow = 3 means the first two rows are ignored and read.xlsx() starts reading data from the 3rd row.

Write Into xlsx File in R

In R, we use the write.xlsx() function to write into an xlsx file. We pass the data in the form of dataframe. For example,

# install xlsx package 
install.package("xlsx")

# load xlsx file
library("xlsx")

# create a data frame
dataframe1 <- data.frame (
  Name = c("Juan", "Alcaraz", "Simantha"),
  Age = c(22, 15, 19),
  Vote = c(TRUE, FALSE, TRUE))

# write dataframe1 into file1 xlsx file
write.xlsx(dataframe1, "file1.xlsx")

In the above example, we have used the write.xlsx() function to export a data frame named dataframe1 to a xlsx file. Notice the arguments passed inside write.xlsx(),

write.xlsx(dataframe1, "file1.xlsx")

Here,

• dataframe1 - name of the data frame we want to export
• file1.xlsx - name of the xlsx file

Finally, the file1.xlsx file would look like this in our directory:

Rename Current Worksheet

We can rename the current worksheet by using the sheetName argument inside the write.xlsx() function. For example,

# install xlsx package 
install.package("xlsx")

# load xlsx file
library("xlsx")

# create a data frame
dataframe1 <- data.frame (
  Name = c("Juan", "Alcaraz", "Simantha"),
  Age = c(22, 15, 19),
  Vote = c(TRUE, FALSE, TRUE))

# name current worksheet
write.xlsx(dataframe1, "file1.xlsx",
  sheetName = "Voting Eligibility"
)

Here, we have passed sheetname = "Voting Eligibility" inside write.xlsx(), so the name of the sheet is changed to "Voting Eligibility".

So the file1.xlsx looks like this:

A matrix is a two-dimensional data structure where data are arranged into rows and columns. For example,

{IMAGE: 2 * 3 matrix with integer data}

Here, the above matrix is 2 * 3 (pronounced “two by three”) matrix because it has 2 rows and 3 columns.

Create a Matrix in R

In R, we use the matrix() function to create a matrix.

The syntax of the matrix() function is

matrix(vector, nrow, ncol)

Here,

• vector – the data items of same type
• nrow– number of rows
• ncol– number of columns
• byrow (optional) – if TRUE, the matrix is filled row-wise. By default, the matrix is filled column-wise.

Let's see an example,

# create a 2 by 3 matrix
matrix1 <- matrix(c(1, 2, 3, 4, 5, 6), nrow = 2, ncol = 3, byrow = TRUE)

print(matrix1)

Output

    [,1] [,2] [,3]
[1,]    1    2    3
[2,]    4    5    6

In the above example, we have used the matrix() function to create a matrix named matrix1.

matrix(c(1, 2, 3, 4, 5, 6), nrow = 2, ncol = 3, byrow = TRUE)

Here, we have passed data items of integer type and used c() to combine data items together. And nrow = 2 and ncol = 3 means the matrix has 2 rows and 3 columns.

Since we have passed byrow = TRUE, the data items in the matrix are filled row-wise. If we didn't pass byrow argument as

matrix(c(1, 2, 3, 4, 5, 6), nrow = 2, ncol = 3)

The output would be

    [,1]  [,2] [,3]
[1,]    1    3    5
[2,]    2    4    6

Access Matrix Elements in R

We use the vector index operator [ ] to access specific elements of a matrix in R.

The syntax to access a matrix element is

matrix[n1, n2]

Here,

• n1 - specifies the row position
• n2 - specifies the column position

Let's see an example,

matrix1 <- matrix(c("Sabby", "Cathy", "Larry", "Harry"), nrow = 2, ncol = 2)

print(matrix1)

# access element at 1st row, 2nd column
cat("\nDesired Element:", matrix1[1, 2])

Output

      [,1]          [,2]   
[1,] "Sabby" "Larry"
[2,] "Cathy" "Harry"

Desired Element: Larry

In the above example, we have created a 2 by 2 matrix named matrix1 with 4 string type datas. Notice the use of index operator [],

matrix1[1, 2]

Here, [1, 2] specifies we are trying to access element present at 1st row, 2nd column i.e. "Larry".

Access Entire Row or Column

In R, we can also access the entire row or column based on the value passed inside [].

• [n, ] - returns the entire element of the nth row.
• [ ,n] - returns the entire element of the nth column.

For example,

matrix1 <- matrix(c("Sabby", "Cathy", "Larry", "Harry"), nrow = 2, ncol = 2)

print(matrix1)

# access entire element at 1st row
cat("\n1st Row:", matrix1[1, ])

# access entire element at 2nd column
cat("\n2nd Column:", matrix1[, 2])

Output

       [,1]         [,2]   
[1,] "Sabby" "Larry"
[2,] "Cathy" "Harry"

1st Row: Sabby Larry
2nd Column: Larry Harry

Here,

• matrix1[1, ] - access entire elements at 1st row i.e. Sabby and Larry
• matrix1[ ,2] - access entire elements at 2nd row i.e. Larry and Harry

Access More Than One Row or Column

We can access more than one row or column in R using the c() function.

• [c(n1,n2), ] - returns the entire element of n1 and n2 row.
• [ ,c(n1,n2)] - returns the entire element of n1 and n2 column.

For example,

# create 2 by 3 matrix
matrix1 <- matrix(c(10, 20, 30, 40, 50, 60), nrow = 2, ncol = 3)

print(matrix1)

# access entire element of 1st and 3rd row
cat("\n1st and 2nd Row:", matrix1[c(1,3), ])

# access entire element of 2nd and 3rd column
cat("\n2nd and 3rd Column:", matrix1[  ,c(2,3)])

Output

       [,1] [,2]  [,3]
[1,]   10   30   50
[2,]   20   40   60

1st and 3rd Row: 10 20 30 40 50 60
2nd and 3rd Column: 30 40 50 60

Here,

• [c(1,3), ] - returns the entire element of 1st and 3rd row.
• [ ,c(2,3)] - returns the entire element of 2nd and 3rd column.

Modify Matrix Element in R

We use the vector index operator [] to modify the specified element. For example,

matrix1[1,2] = 140

Here, the element present at 1st row, 2nd column is changed to 140.

Let's see an example,

# create 2 by 2 matrix
matrix1 <- matrix(c(1, 2, 3, 4), nrow = 2, ncol = 2)

# print original matrix
print(matrix1)

# change value at 1st row, 2nd column to 5 
matrix1[1,2] = 5

# print updated matrix
print(matrix1)

Output

    [,1] [,2]
[1,]    1    3
[2,]    2    4

     [,1] [,2]
[1,]    1    5
[2,]    2    4

Combine Two Matrices in R

In R, we use the cbind() and the rbind() function to combine two matrices together.

• cbind() - combines two matrices by columns
• rbind() - combines two matrices by rows

The number of rows and columns of two matrices we want to combine must be equal. For example,

# create two 2 by 2 matrices 
even_numbers <- matrix(c(2, 4, 6, 8), nrow = 2, ncol = 2)
odd_numbers <- matrix(c(1, 3, 5, 7), nrow = 2, ncol = 2)

# combine two matrices by column
total1 <- cbind(even_numbers, odd_numbers)
print(total1)

# combine two matrices by row
total2 <- rbind(even_numbers, odd_numbers)
print(total2)

Output

    [,1] [,2] [,3] [,4]
[1,]    2    6    1    5
[2,]    4    8    3    7
     [,1] [,2]
[1,]    2    6
[2,]    4    8
[3,]    1    5
[4,]    3    7

Here, first we have used the cbind() function to combine the two matrices: even_numbers and odd_numbers by column. And rbind() to combine two matrices by row.

Check if Element Exists in R Matrix

In R, we use the %in% operator to check if the specified element is present in the matrix or not and returns a boolean value.

• TRUE - if specified element is present in the matrix
• FALSE - if specified element is not present in the matrix

For example,

matrix1 <- matrix(c("Sabby", "Cathy", "Larry", "Harry"), nrow = 2, ncol = 2)

"Larry" %in% matrix1 # TRUE

"Kinsley" %in% matrix1 # FALSE

Output

TRUE
FALSE

Here,

• "Larry" is present in matrix1, so the method returns TRUE
• "Kinsley" is not present in matrix1, so the method returns FALSE

This is part 2 of a 3 part series highlighting a selection of 35 new entries into Big Book of R.

Read part 1.

The site now has well over 300 free R programming titles.

Onto the second batch of new books! Sign up to the newsletter for the next update happening in a few days.

Handling Strings With R

by Gaston Sanchez

Handling character strings in R? Wait a second… you exclaim, R is not a scripting language like Perl, Python, or Ruby. Why would you want to use R for handling and processing text? Well, because sooner or later (I would say sooner than later) you will have to deal with some kind of string manipulation for your data analysis. So it’s better to be prepared for such tasks and know how to perform them inside the R environment.

https://www.bigbookofr.com/getting-cleaning-and-wrangling-data.html#handling-strings-with-r

Data Science: Theories, Models, Algorithms, and Analytics

by Sanjiv Ranjan Das

I developed these class notes for my Machine Learning with R course. It traces my evolution as a data scientist into redundancy, I expect I will be replaced by a machine soon! 

https://www.bigbookofr.com/machine-learning.html#data-science-theories-models-algorithms-and-analytics

Pack YouR Code

by Gaston Sanchez

The ultimate goal of this book is to teach you how to create a relatively simple R package based on the so-called S3 classes.

https://www.bigbookofr.com/r-package-development.html#pack-your-code

rlist Tutorial

by Kun Ren

rlist is a set of tools for working with list objects. Its goal is to make it easier to work with lists by providing a wide range of functions on non-tabular data stored in them. This package supports filtering, mapping, grouping, sorting, updating, searching and many other functions. It is pipe-friendly and strongly recommends functional programming style in list operations. This tutorial serves as complete guide to using rlist functionality to work with non-tabular data.

https://www.bigbookofr.com/packages.html#rlist-tutorial

Doing Bayesian Data Analysis in brms and the tidyverse

by A Solomon Kurz

Kruschke began his text with “This book explains how to actually do Bayesian data analysis, by real people (like you), for realistic data (like yours).” In the same way, this project is designed to help those real people do Bayesian data analysis.

https://www.bigbookofr.com/statistics.html#doing-bayesian-data-analysis-in-brms-and-the-tidyverse

CSSS 508 Introduction to R for Social Scientists

by Charles Lanfear, Rebecca Ferrell

Course material with Youtube Video

https://www.bigbookofr.com/social-science.html#csss-508-introduction-to-r-for-social-scientists

Principles of Econometrics with R

by Constantin Colonescu

R supplementary resource for the “Principles of Econometrics” textbook by Carter Hill, William Griffiths and Guay Lim, 4-th edition

https://www.bigbookofr.com/finance.html#principles-of-econometrics-with-r

Using R for Introductory Econometrics

by Florian Heiss

An R book supplement to the Wooldridge’s “Introductory Econometrics” textbook

https://www.bigbookofr.com/finance.html#using-r-for-introductory-econometrics

Introduction to R for Econometrics

by Kieran Marray

This is a short introduction to R to go with the first year econometrics courses at the Tinbergen Institute. It is aimed at people who are relatively new to R, or programming in general.

The goal is to give you enough of knowledge of the fundamentals of R to write and adapt code to fit econometric models to data, and to simulate your own data, working alone or with others. You will be able to: read data from csv files, plot it, manipulate it into the form you want, use sets of functions others have built (packages), write your own functions to compute estimators, simulate data to test the performance of estimators, and present the results in a nice format.

Most importantly, when things inevitably go wrong, you will be able to begin to interpret error messages and adapt others’ solutions to fit your needs.

https://www.bigbookofr.com/finance.html#introduction-to-r-for-econometrics

Introduction to Econometrics with R

by Florian Oswald, Vincent Viers, Jean-Marc Robin, Pierre Villedieu, Gustave Kenedi

Welcome to Introductory Econometrics for 2nd year undergraduates at ScPo! On this page we outline the course and present the Syllabus. 2018/2019 was the first time that we taught this course in this format, so we are in year 3 now.

https://www.bigbookofr.com/finance.html#introduction-to-econometrics-with-r-1

#mc_embed_signup{background:#fff; clear:left; font:14px Helvetica,Arial,sans-serif; width:600px;}/* Add your own Mailchimp form style overrides in your site stylesheet or in this style block. We recommend moving this block and the preceding CSS link to the HEAD of your HTML file. */

The post Part 2 of 3: 300+ milestone for Big Book of R appeared first on Oscar Baruffa.

The CSV (Comma Separated Value) file is a plain text file that uses a comma to separate values.

R has a built-in functionality that makes it easy to read and write a CSV file.

Sample CSV File

To demonstrate how we read CSV files in R, let's suppose we have a CSV file named airtravel.csv with following data:

Month,  1958,   1959,   1960
JAN,    340,    360,    417
FEB,    318,    342,    391
MAR,    362,    406,    419
APR,    348,    396,    461
MAY,    363,    420,    472
JUN,    435,    472,    535
JUL,    491,    548,    622
AUG,    505,    559,    606
SEP,    404,    463,    508
OCT,    359,    407,    461
NOV,    310,    362,    390
DEC,    337,    405,    432

The CSV file above is a sample data of monthly air travel, in thousands of passengers, for 1958-1960.

Now, let's try to read data from this CSV File using R's built-in functions.

Read a CSV File in R

In R, we use the read.csv() function to read a CSV file available in our current directory. For example,

# read airtravel.csv file from our current directory
read_data <- read.csv("airtravel.csv")

# display csv file
print(read_data)

Output

      Month,  1958,  1959,    1960
1    JAN       340    360      417
2    FEB       318    342      391
3    MAR       362    406      419
4    APR       348    396      461
5    MAY       363    420      472
6    JUN       435    472      535
7    JUL       491    548      622
8    AUG       505    559      606
9    SEP       404    463      508
10  OCT        359    407      461
11  NOV        310    362      390
12  DEC        337    405      432

In the above example, we have read the airtravel.csv file that is available in our current directory. Notice the code,

read_data <- read.csv("airtravel.csv")

Here, read.csv() reads the csv file airtravel.csv and creates a dataframe which is stored in the read_data variable.

Finally, the csv file is displayed using print().

Note: If the file is in some other location, we have to specify the path along with the file name as: read.csv("D:/folder1/airtravel.csv").

Number of Rows and Columns of CSV File in R

We use the ncol() and nrow() function to get the total number of rows and columns present in the CSV file in R. For example,

# read airtravel.csv file from our directory
read_data <- read.csv("airtravel.csv")

# print total number of columns
cat("Total Columns: ", ncol(read_data))

# print total number of rows
cat("Total Rows:", nrow(read_data))

Output

Total Columns: 4
Total Rows: 12 

In the above example, we have used the ncol() and nrow() function to find the total number of columns and rows in the airtravel.csv file.

Here,

• ncol(read_data) - returns total number of columns i.e. 4
• nrow(read_data) - returns total number of rows i.e. 12

Using min() and max() With CSV Files

In R, we can also find minimum and maximum data in a certain column of a CSV file using the min() and max() function. For example,

# read airtravel.csv file from our directory
read_data <- read.csv("airtravel.csv")

# return minimum value of 1960 column of airtravel.csv
 min_data <- min(read_data$1960)  # 390

# return maximum value of 1958 column of airtravel.csv
 min_data <- max(read_data$1958)  # 505

Output

[1] 390
[1] 505

Here, we have used the min() and max() function to find the minimum and maximum value of the 1960 and 1958 column of the airtravel.csv file respectively.

• min(read_data$1960) - returns the minimum value from the 1960 column i.e. 390
• max(read_data$1958) - returns the maximum value from the 1958 column i.e. 505

Subset of a CSV File in R

In R, we use the subset() function to return all the datas from a CSV file that satisfies the specified condition. For example,

# read airtravel.csv file from our directory
read_data <- read.csv("airtravel.csv")

# return subset of csv where number of air 
# traveler in 1958 should be greater than 400
sub_data <- subset(read_data, 1958 > 400) 

print(sub_data)

Output

      Month,  1958,  1959,  1960
6    JUN       435    472      535
7    JUL       491    548      622
8    AUG       505    559      606
9    SEP       404    463      508

In the above example, we have specified a certain condition inside the subset() function to extract data from a CSV file.

subset(read_data, 1958 > 400)

Here, subset() creates a subset of airtravel.csv with data column 1958 having data greater than 400 and stored it in the sub_data data frame.

Since column 1958 has data greater than 400 in 6th, 7th, 8th, and 9th row, only these rows are displayed.

Write Into CSV File in R

In R, we use the write.csv() function to write into a CSV file. We pass the data in the form of dataframe. For example,

# Create a data frame
dataframe1 <- data.frame (
  Name = c("Juan", "Alcaraz", "Simantha"),
  Age = c(22, 15, 19),
  Vote = c(TRUE, FALSE, TRUE))

# write dataframe1 into file1 csv file
write.csv(dataframe1, "file1.csv")

In the above example, we have used the write.csv() function to export a data frame named dataframe1 to a CSV file. Notice the arguments passed inside write.csv(),

write.csv(dataframe1, "file1.csv")

Here,

• dataframe1 - name of the data frame we want to export
• file1.csv - name of the csv file

Finally, the file1.csv file would look like this in our directory:

If we pass "quote = FALSE" to write.csv() as:

write.csv(dataframe1, "file1.csv",
  quote = FALSE
)

Our file1.csv would look like this:

All the values which were wrapped by double quotes " " are removed.

This offseason, we worked hard to update our FFA Projection and Lineup Optimizer apps. We are excited to provide the apps to our subscribers to test out and provide feedback. You can access the new app at the link below:

https://apps.fantasyfootballanalytics.net/

App Improvements

We rebuilt the app using Golem in R/Shiny to create a much faster and more dynamic app experience during drafts. We worked hard to optimize the app to improve loading and computation times, which should result in an overall smoother experience and make it easier to use and to update lineups quickly.

Features

This new app has a similar feature set as the original FFA apps but should be faster to load and update scoring settings using the “Calculate Projections” button when scoring and lineup settings are changed.

Feedback

We have greatly improved the apps over the years in response to feedback from our users. Give it a test run and let us know your thoughts in the comments (or via our Google form for bug reporting)!

-FFA Team

The post 2022 Projections & FFA App Updates appeared first on Fantasy Football Analytics.

The post How to Use Spread Function in R?-tidyr Part1 appeared first on Data Science Tutorials

How to Use Spread Function in R, To “spread” a key-value pair across multiple columns, use the spread() method from the tidyr package.

The basic syntax used by this function is as follows.

spread(data, key value)

where:

data: Name of the data frame

key: column whose values will serve as the names of variables

value: Column where new variables formed from keys will populate with values

How to Use Spread Function in R?

The practical application of this function is demonstrated in the examples that follow.

dplyr Techniques and Tips – Data Science Tutorials

Example 1: Divide Values Between Two Columns

Let’s say we have the R data frame shown below.

Let’s create a data frame

df <- data.frame(player=rep(c('A', 'B'), each=4),
year=rep(c(1, 1, 2, 2), times=2),
stat=rep(c('points', 'assists'), times=4),
amount=c(14, 6, 18, 7, 22, 9, 38, 4))

Now we can view the data frame

df
   player year    stat amount
1     P1    1  points    125
2     P1    1 assists    142
3     P1    2  points    145
4     P1    2 assists    157
5     P2    1  points    134
6     P2    1 assists    213
7     P2    2  points    125
8     P2    2 assists    214

The stat column’s values can be separated into separate columns using the spread() function.

library(tidyr)

Dividing the stats column into several columns

spread(df, key=stat, value=amount)
player year assists points
1     P1    1     142    125
2     P1    2     157    145
3     P2    1     213    134
4     P2    2     214    125

Example 2: Values Should Be Spread Across More Than Two Columns

Let’s say we have the R data frame shown below:

Imagine we have the following data frame

df2 <- data.frame(player=rep(c('P1'), times=8),
year=rep(c(1, 2), each=4),
stat=rep(c('points', 'assists', 'steals', 'blocks'), times=2),
amount=c(115, 116, 212, 211, 229, 319, 213, 314))

Now we can view the data frame

df2
  player year    stat amount
1     P1    1  points    115
2     P1    1 assists    116
3     P1    1  steals    212
4     P1    1  blocks    211
5     P1    2  points    229
6     P1    2 assists    319
7     P1    2  steals    213
8     P1    2  blocks    314

The spread() function can be used to create four additional columns from the stat column’s four distinct values.

library(tidyr)

Dividing the stats column into several columns

spread(df2, key=stat, value=amount)
   player year assists blocks points steals
1     P1    1     116    211    115    212
2     P1    2     319    314    229    213

How to Group and Summarize Data in R – Data Science Tutorials

Have you liked this article? If you could email it to a friend or share it on Facebook, Twitter, or Linked In, I would be eternally grateful.

Please use the like buttons below to show your support. Please remember to share and comment below. 

The post How to Use Spread Function in R?-tidyr Part1 appeared first on Data Science Tutorials

Introducing Free Week 

Free Access for Individuals 

• DataCamp Workspace
• DataCamp Projects
• Data Scientist and Data Analyst Certifications
• DataCamp Jobs
• DataCamp Competitions
• R-programming challenges

• Data visualization
• Data manipulation
• A/B Testing
• R for Finance
• Machine learning
• Regression
• Web scraping

Free Access for Teams

• Build learning programs with their team to create custom learning paths just for your team (eg. if your team specializes in R, their team will help create R-specialized learning pathways)
• Report on your ROI using DataCamp’s visualization and spreadsheet tools to thoroughly understand your team’s progress
• Upskill your company by investing in professional development for all roles and skill levels
• Get started and scale using DataCamp’s integrations

The post How to handle missing data in r appeared first on finnstats.

How to handle missing data in r, If you’ve ever conducted any research involving measurements taken in the actual world, you are aware that the data is frequently messy.

The quality of the data can be controlled in a lab, but this is not always the case in the actual world. There are occasions when events outside of your control can result in data gaps.

How to handle missing data in r

In R, there are numerous methods for handling missing data. The is.na() function can be used to simply detect it.

Another function in R called na.omit() removes any rows in the data frame that have missing data. NA is used to indicate missing data so that it may be quickly identified.

Removing Missing values in R-Quick Guide »

It is effortlessly accepted by data.frame(). The cbind() function does issue a warning even though it will accept data that contains NA.

By using the na.rm logical boundary, dataframe functions can address missing data in one method.

Delete NA values from r.

The NA number cannot be incorporated into calculations because it is only a placeholder and not a real numeric value.

Therefore, it must be eliminated from the calculations in some way to produce a useful result. An NA value will be produced if the NA value is factored into a calculation.

While this might be OK in some circumstances, in others you require a number. The na.omit() function, which deletes the entire row, and the na.rm logical perimeter, which instructs the function to skip that value, are the two methods used in R to eliminate NA values.

What does the R-word na.rm mean?

When utilizing a dataframe function, the logical argument na.rm in the R language specifies whether or not NA values should be eliminated from the calculation. Literally, it means remove NA.

It is not an operation or a function. It is merely a parameter that many dataframe functions use. ColSums(), RowSums(), ColMeans(), and RowMeans are some of them ().

The function skips over any NA values if na.rm is TRUE. However, if na.rm returns FALSE, the calculation on the entire row or column yields NA.

Na.rm examples in R

We need to set up a dataframe before we can begin our examples.

x<-data.frame(a=c(22,45,51,78),b=c(21,16,18,NA),c=c(110,234,126,511))
x
  a  b   c
1 22 21 110
2 45 16 234
3 51 18 126
4 78 NA 511

For these examples, the missing data set will be the NA in row 4 column b.

Imputing missing values in R »

colMeans(x, na.rm = TRUE, dims = 1)
   a         b         c
 49.00000  18.33333 245.25000
rowSums(x, na.rm = FALSE, dims = 1)
[1] 153 295 195  NA

rowSums(x, na.rm = TRUE, dims = 1)

[1] 153 295 195 589

With the exception of the fact that in the first example, na.rm = FALSE, the second and third examples are identical. That radically alters everything.

Correct data science requires dealing with missing data from a data set. R is used so frequently in statistical research because it makes handling this missing data so simple.

Have you found this article to be interesting? We’d be glad if you could forward it to a friend or share it on Twitter or Linked In to help it spread.

If you are interested to learn more about data science, you can find more articles here finnstats.

The post How to handle missing data in r appeared first on finnstats.

Introduction to R Functions

A function is just a block of code that you can call and run from any part of your program. They are used to break our code in simple parts and avoid repeatable codes.

You can pass data into functions with the help of parameters and return some other data as a result. You can use the function() reserve keyword to create a function in R. The syntax is:

func_name <- function (parameters) {
statement
}

Here, func_name is the name of the function. For example,

# define a function to compute power
power <- function(a, b) {
    print(paste("a raised to the power b is: ", a^b))
}

Here, we have defined a function called power which takes two parameters - a and b. Inside the function, we have included a code to print the value of a raised to the power b.

Call the Function

After you have defined the function, you can call the function using the function name and arguments. For example,

# define a function to compute power
power <- function(a, b) {
    print(paste("a raised to the power b is: ", a^b))
}

# call the power function with arguments
power(2, 3)

Output

[1] "a raised to the power b is:  8"

Here, we have called the function with two arguments - 2 and 3. This will print the value of 2 raised to the power 3 which is 8.

The arguments used in the actual function are called formal arguments. They are also called parameters. The values passed to the function while calling the function are called actual arguments.

Named Arguments

In the above function call of the power() function, the arguments passed during the function call must be of the same order as the parameters passed during function declaration.

This means that when we call power(2, 3), the value 2 is assigned to a and 3 is assigned to b. If you want to change the order of arguments to be passed, you can use named arguments. For example,

# define a function to compute power
power <- function(a, b) {
    print(paste("a raised to the power b is: ", a^b))
}

# call the power function with arguments
power(b=3, a=2)

Output

[1] "a raised to the power b is:  8"

Here, the result is the same irrespective of the order of arguments that you pass during the function call.

You can also use a mix of named and unnamed arguments. For example,

# define a function to compute power
power <- function(a, b) {
    print(paste("a raised to the power b is: ", a^b))
}

# call the power function with arguments
power(b=3, 2)

Output

[1] "a raised to the power b is:  8"

Default Parameters Values

You can assign default parameter values to functions. To do so, you can specify an appropriate value to the function parameters during function definition.

When you call a function without an argument, the default value is used. For example,

# define a function to compute power
power <- function(a = 2, b) {
    print(paste("a raised to the power b is: ", a^b))
}

# call the power function with arguments
power(2, 3)

# call function with default arguments
power(b=3)

Output

[1] "a raised to the power b is:  8"
[1] "a raised to the power b is:  8"

Here, in the second call to power() function, we have only specified the b argument as a named argument. In such a case, it uses the default value for a provided in the function definition.

Return Values

You can use the return() keyword to return values from a function. For example,

# define a function to compute power
power <- function(a, b) {
    return (a^b)
}

# call the power function with arguments
print(paste("a raised to the power b is: ", power(2, 3)))

Output

[1] "a raised to the power b is:  8"

Here, instead of printing the result inside the function, we have returned a^b. When we call the power() function with arguments, the result is returned which can be printed during the call.

Nested Function

In R, you can create a nested function in 2 different ways.

• By calling a function inside another function call.
• By writing a function inside another function.

Example 1: Call a Function Inside Another Function Call

Consider the example below to create a function to add two numbers.

# define a function to compute addition
add <- function(a, b) {
    return (a + b)
}

# nested call of the add function 
print(add(add(1, 2), add(3, 4)))

Output

[1] 10

Here, we have created a function called add() to add two numbers. But during the function call, the arguments are calls to the add() function.

First, add(1, 2) and add(3, 4) are computed and the results are passed as arguments to the outer add() function. Hence, the result is the sum of all four numbers.

Example 2: Write a Function Inside Another Function

Let's create a nested function by writing a function inside another function.

# define a function to compute power
power <- function(a) {
    exponent <- function(b) {
        return (a^b)
    }
    return (exponent)
}

# call nested function 
result <- power(2)
print(result(3))

Output

[1] 8

Here, we cannot directly call the power() function because the exponent() function is defined inside the power() function.

Hence, we need to first call the outer function with the argument a and set it to a variable. This variable now acts as a function to which we pass the next argument b.

A histogram is a graphical display of data using bars of different heights.

Histogram is used to summarize discrete or continuous data that are measured on an interval scale.

Create Histogram in R

In R, we use the hist() function to create Histograms. For example,

temperatures <- c(67 ,72 ,74 ,62 ,76 ,66 ,65 ,59 ,61 ,69 )

# histogram of temperatures vector
result <- hist(temperatures)

print(result)

Output

In the above example, we have used the hist() function to create a histogram of the temperatures vector.

The histogram we have created above is plain and simple, we can add so many things to the Histogram.

Add Title and Label to a Histogram in R

To add a title and a label to our Histogram in R, we pass the main and the xlab parameter respectively inside the hist() function. For example,

temperatures <- c(67 ,72 ,74 ,62 ,76 ,66 ,65 ,59 ,61 ,69 )

# histogram of temperatures vector
result <- hist(temperatures,
  main = "Histogram of Temperature",
  xlab = "Temperature in degrees Fahrenheit"

print(result)

Output

In the above figure, we can see that we have added a title and a label to the Histogram of the temperatures vector.

hist(temperatures, 
  main = "Maximum Temperatures in a Week",
  xlab = "Temperature in degrees Fahrenheit")

Here,

• main - adds the title "Maximum Temperatures in a Week"
• xlab - adds the label "Temperature in degrees Fahrenheit"

Change Bar Color of Histogram in R

In R, we pass the col parameter inside hist() to change the color of bars. For example,

temperatures <- c(67 ,72 ,74 ,62 ,76 ,66 ,65 ,59 ,61 ,69 )

# histogram of temperatures vector
result <- hist(temperatures,
  main = "Histogram of Temperature",
  xlab = "Temperature in degrees Fahrenheit",
  col = "red")

print(result)

Output

In the above example, we have used the col parameter inside barplot() to change the color of bars.

result <- hist(temperatures, 
  ...
  col = "red"
)

Here, col = "red" changes the color of bars to red.

Range of Axes in R

To provide a range of the axes in R, we pass the xlab and the ylab parameter inside hist(). For example,

temperatures <- c(67 ,72 ,74 ,62 ,76 ,66 ,65 ,59 ,61 ,69 )

# histogram of temperatures vector
result <- hist(temperatures,
  main = "Histogram of Temperature",
  xlab = "Temperature in degrees Fahrenheit",
  col = "red",
  xlim = c(50,100),
  ylim = c(0, 5))

print(result)

Output

In the above example, we have used the xlim and the ylim parameter inside hist() to provide a range of x-axis and y-axis respectively.

result <- hist(temperatures, 
  ...
  xlim = c(50,100),
  ylim = c(0, 5))
)

Here,

• x-axis ranges from 50 to 100
• y-axis ranges from 0 to 5

A pie chart is a circular statistical graphic, which is divided into slices to illustrate numerical proportion.

Pie charts represents data visually as a fractional part of a whole, which can be an effective communication tool.

Create Pie Plot in R

In R, we use the pie() function to create a pie chart. For example,

expenditure <- c(600, 300, 150, 100, 200)

# pie chart of of expenditure vector
result <- pie(expenditure)

print(result)

Output

In the above example, we have used the pie() function to create a pie chart of the expenditure vector.

The pie chart we have created above is plain and simple, we can add so many things to the pie chart.

Add Title to a Pie Chart in R

To add a title to our pie chart in R, we pass the main parameter inside the pie() function. For example,

expenditure <- c(600, 300, 150, 100, 200)

result <- pie(expenditure,
  main = "Monthly Expenditure Breakdown"  
)

print(result)

Output

In the above figure, we can see that we have added a title to the pie chart of the expenditure vector.

result <- pie(expenditure
  main = "Monthly Expenditure Breakdown"  
)

Here, the main parameter adds the title "Monthly Expenditure Breakdown" to our pie chart.

Add Labels to Each Pie Chart Slice in R

We pass the labels parameter inside pie() to provide labels to each slice of a pie chart in R.

For example,

expenditure <- c(600, 300, 150, 100, 200)

result <- pie(expenditure,
  main = "Monthly Expenditure Breakdown",
  labels = c("Housing", "Food", "Cloths", "Entertainment", "Other")
)

print(result)

Output

In the above example, we have used the labels parameter to provide names to each slice of pie chart. Notice the code,

pie(expenditure,
  labels = c("Housing", "Food", "Cloths", "Entertainment", "Other")
)

Here, we have assigned "Housing" to the first vector item 600, "Food" to the second vector item 300 and so on.

Change Color of Pie Slices in R

In R, we pass the col parameter inside pie() to change the color of each pie slices. For example,

expenditure <- c(600, 300, 150, 100, 200)

result <- pie(expenditure,
  main = "Monthly Expenditure Breakdown",
  labels = c("Housing", "Food", "Cloths", "Entertainment", "Other"),
  col = c("red", "orange", "yellow", "blue", "green")
)

print(result)

Output

In the above example, we have used the col parameter inside pie() to change the color of each slice of a pie chart.

pie(expenditure,
  ...
  labels = c("Housing", "Food", "Cloths", "Entertainment", "Other"),
  col = c("red", "orange", "yellow", "blue", "green")
)

Here, we have provided a vector of colors which corresponds to each label of a pie chart.

Create a 3D Pie Chart in R

In order to create a 3D pie chart, first we need to import the plotrix package. Then, we use the pie3D() function to create a 3D pie chart. For example,

# import plotrix to use pie3D()
library(plotrix)

expenditure <- c(600, 300, 150, 100, 200)

result <- pie3D(expenditure,
  main = "Monthly Expenditure Breakdown",
  labels = c("Housing", "Food", "Cloths", "Entertainment", "Other"),
  col = c("red", "orange", "yellow", "blue", "green")
)

print(result)

Output

Here, we have used the pie3D() function to create a 3D pie chart.

A boxplot is a graph that gives us a good indication of how the values in the data are spread out.

Box plots provide some indication of the data's symmetry and skew-ness.

Dataset to Create Boxplot

In R, first we need to load the dataset of which we want to create the boxplot of.

In this tutorial, we will be using the built-in dataset named mtcars to create a boxplot.

Let's see the first six rows of the dataset we will be using,

# use head() to load first six rows of mtcars dataset
head(mtcars)

Output

We will be creating a stripchart of this dataset.

Create boxplot in R

In R, we use the boxplot() method to create a boxplot. For example,

# boxplot for ozone reading of airquality dataset
boxplot(mtcars$mpg)

Output

In the above example, we have used the boxplot() function and the $ operator to create a boxplot of the mpg reading of the mtcars dataset.

We can pass additional parameters to control the way our plot looks.

Add Title, Label, New Color to a Boxplot in R

We can add titles, provide labels for the axes, and change the color of the boxplot in R. For example,

# add title, label, new color to boxplot
boxplot(mtcars$mpg,
  main="Mileage Data Boxplot",
  ylab="Miles Per Gallon(mpg)",
  xlab="No. of Cylinders",
  col="orange")

Output

In the above figure, we can see that we have added a title, a label to the x-axis and y-axis, and changed the color of the boxplot.

Here,

• main– adds the title "Mileage Data Boxplot"
• xlab– adds the label "No. of Cylinders" for x-axis
• ylab– add the label "Miles Per Gallon(mpg)" for y-axis
• col = "Orange"– changes the color of boxplot to orange

Boxplot Formula in R

In R, the function boxplot() can also take in formulas of the form y~x where y is a numeric vector which is grouped according to the value of x.

For example, in our dataset mtcars, the mileage per gallon mpg is grouped according to the number of cylinders cyl present in cars.

Let's take a look at example,

boxplot(mpg ~ cyl, data = mtcars,
  main = "Mileage Data Boxplot",
  ylab = "Miles Per Gallon(mpg)",
  xlab = "No. of Cylinders",
  col = "orange")

Output

In the above example, we have created a boxplot for the relation between mpg and cyl. Notice the code

boxplot(mpg ~ cyl, data = mtcars,
  ...
)

Here,

• mpg ~ cyl– mileage per gallon mpg is grouped according to the number of cylinders cyl in cars
• data = mtcars– data is taken from mtcars dataset

It is clear from the above figure that less number of cylinders means more mileage per gallon.

Add Notch to Boxplot in R

In R, we add a notch to boxplot to find out how the medians of different data groups match with each other. For example,

boxplot(mpg ~ cyl, data = mtcars,
  main ="Mileage Data Boxplot",
  ylab ="Miles Per Gallon(mpg)",
  xlab ="No. of Cylinders",
  col ="orange",
  notch = TRUE)

Output

In the above example, we have added notch to boxplot to find out how the medians of different data groups match with each other.

Note: If the notches overlap, we can say that the medians are equal to each other.

A strip chart is a type of chart that displays numerical data along a single strip.

A strip chart can be used to visualize dozens of time series at once.

Dataset to Create Strip Chart

In R, first we need to load the dataset of which we want to create the strip chart of.

In this tutorial, we will be using the built-in dataset named airquality to create a strip chart.

Let’s see the first six rows of the dataset we will be using,

# use head() to load first six rows of airquality dataset
head(airquality)

Output

We will be creating a stripchart of this dataset.

Create Strip Chart in R

In R, we use the stripchart() function to create a strip chart. For example,

# strip chart for ozone reading of airquality dataset
stripchart(airquality$Ozone)

Output

In the above example, we have used the stripchart() function and the $ operator to create a strip chart of the Ozone reading of the airquality dataset.

We can pass additional parameters to control the way our plot looks.

Add Title, Label, New Color to a Strip Chart in R

We can add titles, provide labels for the axes, and change the color of the strip chart in R. For example,

# add title, label, new color to strip chart
stripchart(airquality$Ozone,
  main="Mean ozone in parts per billion at Roosevelt Island",
  xlab="Parts Per Billion",
  ylab="Ozone",
  col="orange")

Output

In the above figure, we can see that we have added a title, a label to the x-axis and y-axis, and changed the color of the strip.

Here,

• main– adds the title "Mean ozone in parts per billion at Roosevelt Island"
• xlab– adds the label "Parts Per Billion" for x-axis
• ylab– add the label "Ozone" for y-axis
• col = "Orange"– changes the color of strip to orange

Jitter Plot in R

Jitter plot is a variant of the strip plot with a better view of overlapping data points. It is useful when there are large clusters of data points.

We pass method = "Jitter" inside the stripchart() method to create a strip chart without overlapping of points. For example,

stripchart(airquality$Ozone,
  main="Mean ozone in parts per billion at Roosevelt Island",
  xlab="Parts Per Billion",
  ylab="Ozone",
  col="orange",
  method = "jitter")

Output

In the above example, we have used the method parameter inside stripchart() to create a jitter plot.

stripchart(airquality$Ozone,
  ...
  method = "jitter")

Here, method = "jitter" specifies the coincident points are plotted like stacked or jitter and no points are overlapped.

Multiple Strip Charts in R

We can draw multiple strip charts in a single plot, by passing in a list of numeric vectors. For example,

# create list of ozone and solar radiation reading of airquality dataset
list1 <- list("Ozone" = airquality$Ozone,  "Solar Radiations" = airquality$Solar.R)

stripchart(list1,
  main="Mean ozone in parts per billion at Roosevelt Island",
  xlab="Parts Per Billion",
  col= c("orange","brown"),
  method = "jitter")

Output

In the above example, we have passed a list named list1 with two vectors: Ozone and Solar Radiation of airquality dataset inside stripchart() to create multiple strips.

We have also provided two colors to represent two different strip charts

• "orange" - to represent Ozone readings
• "brown" - to represent Solar.R readings

We use the R break and next statements to alter the flow of a program. These are also known as jump statements in programming:

• break– terminate a looping statement
• next– skips an iteration of the loop

R break Statement

You can use a break statement inside a loop (for, while, repeat) to terminate the execution of the loop. This will stop any further iterations.

The syntax of the break statement is:

if (test_expression) {
  break
}

The break statement is often used inside a conditional (if...else) statement in a loop. If the condition inside the test_expression returns True, then the break statement is executed. For example,

# vector to be iterated over
x = c(1, 2, 3, 4, 5, 6, 7)

# for loop with break statement
for(i in x) {
    
    # if condition with break
    if(i == 4) {
        break
    }
    
    print(i)
}

Output

[1] 1
[1] 2
[1] 3

Here, we have defined a vector of numbers from 1 to 7. Inside the for loop, we check if the current number is 4 using an if statement.

If yes, then the break statement is executed and no further iterations are carried out. Hence, only numbers from 1 to 3 are printed.

break Statement in Nested Loop

If you have a nested loop and the break statement is inside the inner loop, then the execution of only the inner loop will be terminated.

Let's check out a program to use break statements in a nested loop.

# vector to be iterated over
x = c(1, 2, 3)
y = c(1, 2, 3)

# nested for loop with break statement
for(i in x) {
    for (j in y) {
        if (i == 2 & j == 2) {
            break
        }
        print(paste(i, j))
    }
}

Output

[1] "1 1"
[1] "1 2"
[1] "1 3"
[1] "2 1"
[1] "3 1"
[1] "3 2"
[1] "3 3"

Here, we have a break statement inside the inner loop.

We have used it inside a conditional statement such that if both the numbers are equal to 2, the inner loop gets terminated.

The flow then moves to the outer loop. Hence, the combination (2, 2) is never printed.

R next Statement

In R, the next statement skips the current iteration of the loop and starts the loop from the next iteration.

The syntax of the next statement is:

if (test_condition) {
  next
}

If the program encounters the next statement, any further execution of code from the current iteration is skipped, and the next iteration begins.

Let's check out a program to print only even numbers from a vector of numbers.

# vector to be iterated over
x = c(1, 2, 3, 4, 5, 6, 7, 8)

# for loop with next statement
for(i in x) {
    
    # if condition with next
    if(i %% 2 != 0) {
        next
    }
    
    print(i)
}

Output

[1] 2
[1] 4
[1] 6
[1] 8

Here, we have used an if statement to check whether the current number in the loop is odd or not.

If yes, the next statement inside the if block is executed, and the current iteration is skipped.

We use the R repeat loop to execute a code block multiple times. However, the repeat loop doesn't have any condition to terminate the lYou can use the repeat loop in R to execute a block of code multiple times. However, the repeat loop does not have any condition to terminate the loop. You need to put an exit condition implicitly with a break statement inside the loop.

The syntax of repeat loop is:

repeat {
      # statements
      if(stop_condition) {
          break
      }
  }

Here, we have used the repeat keyword to create a repeat loop. It is different from the for and while loop because it does not use a predefined condition to exit from the loop.

Example 1: R repeat Loop

Let's see an example that will print numbers using a repeat loop and will execute until the break statement is executed.

x = 1

# Repeat loop
repeat {

    print(x)
    
    # Break statement to terminate if x > 4
    if (x > 4) {
        break
    } 
    
    # Increment x by 1
    x = x + 1
    
}

Output

[1] 1
[1] 2
[1] 3
[1] 4
[1] 5

Here, we have used a repeat loop to print numbers from 1 to 5. We have used an if statement to provide a breaking condition which breaks the loop if the value of x is greater than 4.

Example 2: Infinite repeat Loop

If you fail to put a break statement inside a repeat loop, it will lead to an infinite loop. For example,

x = 1
sum = 0

# Repeat loop
repeat {

    # Calculate sum
    sum = sum + x
    
    # Print sum
    print(sum)
    
    # Increment x by 1
    x = x + 1
    
}

Output

[1] 1
[1] 3
[1] 6
[1] 10
.
.
.

In the above program, since we have not included any break statement with an exit condition, the program prints the sum of numbers infinitely.

Example 3: repeat Loop with next Statement

You can also use a next statement inside a repeat loop to skip an iteration. For example,

x = 1

repeat {
    
    # Break if x = 4
    if ( x == 4) {
        break
    } 
    
    # Skip if x == 2
    if ( x == 2 ) {
        # Increment x by 1 and skip
        x = x + 1
        next
    }
    
    # Print x and increment x by 1
    print(x)
    x = x + 1
    
}

Output

[1] 1
[1] 3

Here, we have a repeat loop where we break the loop if x is equal to 4. We skip the iteration where x becomes equal to 2.