9.3.1 What is a function?

In R, a function is the basic mechanism by which operation are done. We have been using a lot of them (e.g. sum, mean, summary, plot etc.), but we haven’t talked much about what they are. In R, functions are stored as variables, just like everything else. They just also have some special features, a few of which we will explore here.

9.3.2 Writing your own function

In computer programming, the “Hello World” program is classically the first program demonstrated in any language. Here, we will see how to write it for R.

When we create a function, we save it as a variable using the same assignment notation we’ve been using, the <- operator. We create the function using the function function (as we might expect); for now, we won’t put any arguments inside the call to function. Finally, we tell R what to do when our function is called by putting it inside curly brackets ( { and } ) just like when we used apply (that was actually a small function that you have already written). Let’s see it in action.

# Write your first function
hello <- function(){
  "Hello World!"
}

Now, when you run those lines, R won’t print any output, which is what we expect. To see the output, we now need to run the function, just like we run the built in functions:

# Run my function
hello()

## [1] "Hello World!"

It worked! You just wrote, or at least copied, a computer program. This also gives us a chance to look at some features of functions. Let’s try running it without the parentheses:

# Run without parentheses
hello

## function(){
##   "Hello World!"
## }

Now, it just tells us what the function is. This is a great way to see what any function in R is actually doing, if you are ever curious. It also means that you can copy that code and change the function if you want (I have done this often for functions that don’t quite do what I want). Let’s start by doing that for your program.

9.3.3 Adding arguments

A program that always says “Hello World” isn’t useful for much more than learning to program. However, we can extend it to see some of the features of R. Let’s start by adding arguments. These work just like they do in the other functions we use. Let’s try a simple one:

# Add an argument
hello <- function(yourName){
  paste("Hello",yourName)
}

Here, we use the function paste to combine an input with the word “Hello”. Paste just outputs a string with all it’s arguments smooshed together (by default with a space between them). Let’s see what it does:

# Run the new function
hello(yourName = "Dr. Peterson")

## [1] "Hello Dr. Peterson"

Now, we got the computer to talk directly to us! Here, we can even show that we don’t need to specify the name of the argument, as long as it is in the right order (we’ve been doing this all along, but here it is explicit).

# Run function without arg name
hello("Professor")

## [1] "Hello Professor"

But, what happens if we don’t put a name in?

# Run with out an argument
hello()

## Error in paste("Hello", yourName): argument "yourName" is missing, with no default

It tells us we don’t have a default, so let’s add one. (Of note, comment out that line, or the error will prevent compiling later.) We set a default by specifying a value to use when the user doesn’t give one to the function. It works just like if we were calling a function ourselves.

# Add a default
hello <- function(yourName = "World!"){
  paste("Hello",yourName)
}

# Run to see the result
hello()

## [1] "Hello World!"

These defaults are what help us from having to set every option every time we run a function. For example, when we use scale it defaults to using center = TRUE, scale = TRUE to give us the z-scores, if we don’t give it a value. You can see these defaults at the top of the help files (and usually listed in the argument description).

9.3.4 Add a second argument

As our last step with this function, let’s add a second argument. I kind of like getting the “!” at the end of the greeting, but we lost it when we set the name argument. Let’s add it back with an argument for punctuation.

# Add punctuation
hello <- function(yourName = "World", punctuation = "!"){
  paste("Hello",yourName,punctuation)
}

# Run it
hello()

## [1] "Hello World !"

So, now we got it to work, but there is an obnoxious space at the end before the puncuation. Let’s remove that by setting the sep = argument in the paste function (note, we then need to manually add a space after “Hello”).

# Add punctuation
hello <- function(yourName = "World", punctuation = "!"){
  paste("Hello ", yourName, punctuation, sep = "")
}

# Run it
hello()

## [1] "Hello World!"

Now, run the function to get it to say hello to you with a question mark.

Here is also a good place to point out that we can put the arguments into a function in any order, as long as we name them all. To demonstrate:

# Name args to put out of order
hello(punctuation = "!!!!!!",
      yourName = "Dr. Peterson")

## [1] "Hello Dr. Peterson!!!!!!"

This is one of the flexibilities offered in R. Take a moment to play with this function a bit. Maybe try adding something, or changing it.

9.3.5 A function that does arithmetic

Recall that we can do anything we want to inside of a function. I even use a function that I wrote to insert those little pop up notes[*] See, I wouldn’t be here without a custom function because typing a bunch of html and javascript code all the time would be way more obnoxius That (hopefully obviously) includes arithmetic. Let’s make a toy example here: a function that multiplies by three.

# Write a simple function to multiply by three
timesThree <- function(x){
  x*3
}

# Run it
timesThree(3)

## [1] 9

Notice that x can be anything we want it to be. So, let’s pass in a vector. Here, I will use the : which means “give me a sequence of number between these two”

# Test my vector
1:4

## [1] 1 2 3 4

# Use my function
timesThree(1:4)

## [1]  3  6  9 12

9.3.6 Try it out

Try combining the ideas that we’ve developed. Write a function that multiplies a value by 3, and returns a statment about what it did. It might look something like this:

timesThreeStatement(4)

## [1] "4 times 3 is 12."

9.5.1 A note on regular expressions

grep() works by searching something called “regular expressions.” These are special ways of searching that allow you to match general patterns in addition to the normal strings we have been using. There are a lot of these special options, but most are beyond what we need to do introductory statistics. If you want to learn more, google for regular expressions, or check out this quick guide.

For our purposes, we only need to consider two of these special characters. The carat (^), which means “the start” and the dollar sign ($), which means “the end.”

So, if we just want the “basic” blue colors, we can tell R that we only want the “blue”s that occur at the start of the line like this:

# Get only the start of lines
grep("^blue", colors(), value = TRUE)

## [1] "blue"       "blue1"      "blue2"      "blue3"      "blue4"     
## [6] "blueviolet"

showpanel( grep("^blue", colors(), value = TRUE))

Which can be interpretted as: “give me things that match: (start of line)blue”. We can similarly pull out all of the non-numbered blues by only matching things that end in “blue”:

grep("blue$", colors(), value = TRUE)

##  [1] "aliceblue"       "blue"            "cadetblue"      
##  [4] "cornflowerblue"  "darkblue"        "darkslateblue"  
##  [7] "deepskyblue"     "dodgerblue"      "lightblue"      
## [10] "lightskyblue"    "lightslateblue"  "lightsteelblue" 
## [13] "mediumblue"      "mediumslateblue" "midnightblue"   
## [16] "navyblue"        "powderblue"      "royalblue"      
## [19] "skyblue"         "slateblue"       "steelblue"

showpanel( grep("blue$", colors(), value = TRUE))

Which can be interpretted as: “give me things that match: blue(start of line)”.

9.5.2 Try it out

Now, give it a shot. Use these tools to look look at a color that interests you in R.

9.7.1 Scatterplot

To start, we can use the code from the linear regresion chapter to see the colors in action. Here, instead of having to type out the colors, we’ve just used the myColors variable to set the colors. This is especially nice if we want to be able to change the colors easily and/or use them in multiple plots.

# Make column for colors
hotdogs$colorType <- factor(hotdogs$Type,
                            labels = myColors)

# Plot the data, setting col = to be the colors we created
# note that we have to use as.character, because otherwise
# the order of the types is returned
plot(Calories ~ Sodium, data = hotdogs,
     col = as.character(colorType),
     pch = 19)

# Add a legend, here by using levels() to make sure our orders match
legend("topleft",
       inset  = 0.01,
       legend = levels(hotdogs$Type),
       col    = levels(hotdogs$colorType),
       pch    = 19)

9.7.2 Simple barplot

Speaking of using colors again, let’s use these colors to make a barplot. Whenever you are presenting data, you want colors to mean the same thing throughout. So, we want to use myColors again to set the colors.

First, let’s make a plain barplot, like we have before:

# Make a table of hotdog types
typeCounts <- table(hotdogs$Type)

# Make a barchart
barplot(typeCounts,
        xlab = "Hotdog type",
        ylab = "Number of Hotdogs",
        main = "What's in your hotdog?")

But, we’d like to use some color here. barplot() also has a col = argument, which will be used for the bars in order. We can either make the bars all the same color, like this:

# One color bar
barplot(typeCounts,
        xlab = "Hotdog type",
        ylab = "Number of Hotdogs",
        main = "What's in your hotdog?",
        col = "darkblue")

Or, we can make each bar its own color:

# Color by type
barplot(typeCounts,
        xlab = "Hotdog type",
        ylab = "Number of Hotdogs",
        main = "What's in your hotdog?",
        col = myColors)

Because the bar plot is always made in the order of the levels, these colors match the ones we used on the scatter plot

9.7.3 Two way barplots

When we have two different categorical variables, sometimes we just want to use color to highlight the differences between them. For this, we turn again to the titanicData. Make a base bar plot like we have before:

# Save a two-way table of survival
survivalClass <-  table(titanicData$survival,
                        titanicData$class)
barplot(survivalClass,
        beside = TRUE,
        ylab = "Number of passengers",
        xlab = "Class",
        legend.text = TRUE)

This clearly separates the survivors by color, but perhaps not the color we want. Here, we don’t need to create a new factor, we just need to tell R which colors we are using.

Here, I am going to pick out two different colors, but you should feel free to pick out any you would like. Note, however, that RColorBrewer only wants to return 3 or more colors. To get just two, I always set my values to 3, then select the first two with square brackets, though you could also select the second 2, or use a larger set and select any two you wanted (or just pick two colors a different way).

# Pick new colors
twoBarColors <- brewer.pal(3, "Dark2")[1:2]

# Change the colors
barplot(survivalClass,
        beside = TRUE,
        ylab = "Number of passengers",
        xlab = "Class",
        legend.text = TRUE,
        col = twoBarColors )

9.7.4 More complex two bars

Sometimes, we may want to get even fancier and color every single bar a different color. This isn’t neccesarily a good idea, as to many colors can be distracting. However, if you are using distinct colors throughout a report, it may make sense to continue that in the barplot.

For this, let’s plot the relative survival in each class.

# Change the colors
barplot(prop.table(survivalClass,2),
        beside = TRUE,
        ylab = "Proportion of passengers",
        xlab = "Class",
        legend.text = TRUE)

Here, we probably want paired colors. So, I am going to select a set of paired colors.

# Pick some paired colors
pairedColors <- brewer.pal(8, "Paired")

# Show what I picked
showpanel(pairedColors)

Now, if I use those in barplot:

# Change the colors
barplot(prop.table(survivalClass,2),
        beside = TRUE,
        ylab = "Proportion of passengers",
        xlab = "Class",
        col = pairedColors)

Now, each light bar is the passengers that lived, and the dark bar is those that died. Choosing paired colors is extra tricky, but see if you can manage to select a different set (hint: using square brackets may help).

Finally, we probably want a legend. For this, I am going to choose to use gray and black, and then explain (elsewhere) that all of light are living and dark are dead.

legend("top",
       legend = levels(titanicData$survival),
       fill = c("gray","black"))