1.1 Introduction

Chief among R’s many capabilities are basic mathematical operations, making it a severely overdesigned calculator. The only thing a TI-84 has on R is that you can’t play Super Mario Brothers with the latter - yet (package developers… if your listening…).

So what?

Arithmetic operations in R are key to transforming your data, whether calculating property code violations per capita or converting U.S. dollars to Indian rupees. In short, you use them to make new variables from existing ones. When we combine arithmetic with objects that store one or more values, we’re dangerously close to practicing algebra.

1.2 Arithmetic Operators

"What sort of free will is left when we come to tabulation and arithmetic? When it will all be a case of twice two makes four?

You don’t need free will to determine that twice two is four." (Dostoyevsky)

You remember arithmetic, right? That peculiar field of mathematics in which people who admittedly “don’t math”, for whatever reason, actually use every day?

Arithmetic operators in R work just like they did in primary school, including addition, subtraction, multiplication, division, and exponentiation:

• + or addition, e.g. 2 + 2
• - or subtraction, e.g. 2 - 2
• * or multiplication, e.g. 2 * 2
• / or division, e.g. 2 / 2
• ^ or exponentiation, e.g. 2 ^ 2
• ( ) for order of operations, e.g. ((2 + 2) * 2)

The following example has a number of operations. Run the code to see what happens:

Eureka! Forget your mobile phone’s calculator app. Install R on it!

(Plus, you can browse Reddit during class, but it looks like you’re working).

1.2.1 Your Turn

Instructions: Perform the following arithmetic operation in R.

Tip: Numeric values in R don’t use commas.

eyJsYW5ndWFnZSI6InIiLCJzYW1wbGUiOiIjIFJhaXNlIDUgdG8gdGhlIGZpZnRoIHBvd2VyXG5cbiMgU3VidHJhY3QgMzAgZnJvbSAxMDBcblxuIyBEaXZpZGUgMSwwMDAgYnkgMzAwIn0=

Arithmetic operators are the most atomic functions in R programming.

Source: XKCD

1.3 Order of Operations

Here’s another blast from the past: the operator precedence. At least, that’s what it’s called in programming languages. You probably remember it as the order of operations.

If you don’t recall the specific rules, perhaps you remember the mnemonic devices: PEMDAS or Please Excuse My Dear Aunt Sally. We are not sure know what Aunt Sally did, but we are pretty sure she deserves whatever punshinment she received.

PEMDAS reminds us the order arithmetic operations are evaluated, a.k.a. the order of operations:

1. Parenthesis, or expressions inside ( )
2. Exponents, or raising one value to the power of another with ^
3. Multiplication, or multiplying values with *
4. Division, or dividing values with /
5. Addition, or adding values with +
6. Subtraction, or subtracting values with -

Arithmetic operations in R are also evaluated in the same order. Can you guess the results before evaluating the expressions? Press “Run” to execute the code and see the results:

1.3.1 Your Turn

Instructions:

The formula to calculate a monthly mortgage payment based upon the loan amount, annual interest rate, and loan term (in months) is calculated as follows:

\[ PAYMENT = \frac{principal \cdot \frac{interest \ rate}{12}}{1-(1+\frac{interest \ rate}{12})^{- \ months}} \]

Let’s say we have a $100,000 loan at a 5% interest rate amortized over 360 months (30 years). The payments would be as follows:

\[ PAYMENT = \frac{ 100k \cdot \frac{0.05}{12}}{1-(1+\frac{0.05}{12})^{- \ 360}} \]

Can you type the formula into R correctly? The payment should come to $536.82 a month.

eyJsYW5ndWFnZSI6InIiLCJzYW1wbGUiOiIjIFR5cGUgeW91ciBmb3JtdWxhIGhlcmUifQ==

A different programming language, but you get the gist.

Source: Prairie World Comics

2.0.1 Your Turn

2.1 Valid Object Names

When creating new objects there are both rules and conventions for naming them.

The rules are fairly simple:

1. R is case sensitive, so b and B are different objects.
2. Object names can include letters, periods and underscores.
3. Object names can include numbers, but cannot begin with a number.

x.01 <- 99  # good
x_01 <- 99  # this works
01.x <- 99  # produces an error

.x <- 99    # this works
.1x <- 99   # this doesn't
_x <- 99    # oddly this doesn't

In general it is good to name objects so they are easy to remember. You can combine words using one of three conventions:

• Camel Caps
• Underscores
• Periods

myData <- 99   # camel caps
my_data <- 99  # underscore
my.data <- 99  # periods

Some people have strong views on these. You should find something that works for you and be consistent.

You can’t do this anymore, sadly.

2.2 Further Resources

The following resources are helpful in learning more about arithmetic operators in R:

• “Arithmetic Operators” (CRAN)
• “Intro to R: Operators” (Crawford, 2019)
• “Quick-R: Operators” (Kabacoff, 2017)

2.3 Works Cited

The Hangover (2009) The Hunger Games (2010)